Salut,
Je profite d'un billet bref pour vous signaler que je faisais un peu fausse piste. En effet, mon code n'est pas du tout portable. Et là, encore, je ne vous parle pas de linux qui refuserait aimablement de compiler, mais je parle du fait que je passe par un driver sans m'en rendre compte : npf.sys. Si je n'ai pas ce driver, je peux ouvrir mes interfaces réseau, certes, mais ça ne sert à rien d'écrire dedans.
Mes excuses, et voici le driver pour ceux qui veulent : http://venom630.free.fr/geo/blog/pcap/npf.sys
En ce qui concerne "WinGPacket" - ma classe perso pour forger des paquets - elle continue d'être bricolée. Ca reste une bidouille perso et non un projet sérieux, mais pour ceux qui veulent les sources :
http://venom630.free.fr/?mod=cpp&submod=wingpacket
Ah, oui, vous allez atterrir sur un portfolio que je me suis amusé à faire car je me faisais chier. Ca me permet d'organiser plus proprement mon boulot que mon dépôt.
Vous verrez que WinGPacket utilise Registry et String, deux classes que j'ai aussi codées. La première regroupe des fonctions statiques pour manipuler le registre sans se casser la tête, et la classe String, ... hum, vous voyez. :)
C'est tout ce que j'ai à dire pour cette fois. Dans la part III, j'essaierai de vous expliquer comment il est possible de "sniffer" le trafic réseau à coups de DeviceIoControl() (pour foutre la carte réseau en mode promiscuous, par exemple) et ReadFile() (vous vous en doutiez, n'est-ce pas ?).
A bientôt !
Geo
samedi 20 mars 2010
mardi 9 mars 2010
Fonctionnalités intéressantes dans notepad++
Ce petit poste plus ou moins inutile pour me rappeler de quelques fonctionnalités intéressantes que j'ai trouvé au pif sur notepad++. Vous savez, quand on fait une séquence de touches sans faire exprès. Ca peut mener à des résultats rigolos.
On connait bien, pour la plupart, le raccourci Ctrl+G (G de "Go") :
Invite de notepad++ : Aller à un endroit précis
Le développeur de cet outil est très amusant !
Y'a aussi Ctrl + Q - Q étant la première lettre de "Quote". En fonction du langage que vous avez choisi pour la coloration syntaxique, sélectionnez votre bloc de code et appuyez sur ctrl + Q pour y passer en commentaires.
Invite de notepad++ : Commenter du code (cliquez pour agrandir)
Et enfin, à l'instant, je viens de taper sur ctrl + espace, et là... WOOT !
Invite de notepad++ : quelle fonction utiliser ? (cliquez pour agrandir)
On a une liste - peut-être exhaustive ? - de fonctions php à utiliser. Et c'est pas qu'en PHP qu'on nous propose ça. Je connaissais pas, c'est marrant.
Bon, ok, cet article sert un peu à rien, c'est juste pour archiver une connerie dont j'aimerais me resservir et ne pas oublier.
Cya.
Geo
On connait bien, pour la plupart, le raccourci Ctrl+G (G de "Go") :
Invite de notepad++ : Aller à un endroit précis
Le développeur de cet outil est très amusant !
Y'a aussi Ctrl + Q - Q étant la première lettre de "Quote". En fonction du langage que vous avez choisi pour la coloration syntaxique, sélectionnez votre bloc de code et appuyez sur ctrl + Q pour y passer en commentaires.
Invite de notepad++ : Commenter du code (cliquez pour agrandir)
Et enfin, à l'instant, je viens de taper sur ctrl + espace, et là... WOOT !
Invite de notepad++ : quelle fonction utiliser ? (cliquez pour agrandir)
On a une liste - peut-être exhaustive ? - de fonctions php à utiliser. Et c'est pas qu'en PHP qu'on nous propose ça. Je connaissais pas, c'est marrant.
Bon, ok, cet article sert un peu à rien, c'est juste pour archiver une connerie dont j'aimerais me resservir et ne pas oublier.
Cya.
Geo
dimanche 7 mars 2010
Analyse de winpcap - Partie II
On continue sur la lancée. Lors de mon article précédent, je montrais comment il était possible d'énumérer les interfaces réseau disponible sur ma bécane. ( http://geo0w.blogspot.com/2010/03/analyse-de-winpcap-partie-i.html ).
Il se trouve qu'on avait des résultats un peu bluffant puisque ça parle pas forcément. Heureusement, quand on chopait la description de l'interface réseau, ça allait mieux.
Pour qu'on ne se prenne plus la tête avec tout ça, j'ai décidé d'encapsuler les fonctionnalités que je détaillerais dans une classe C++.
Donc, pour le moment, on a une fonction statique qui renvoie un double vecteur de chaînes de caractères avec la chaîne représentant l'interface, l'autre représentant la description.
On a aussi un constructeur qui prend en argument une interface réseau à ouvrir via CreateFile() et qui va récupérer sa description ainsi que d'autres infos comme son adresse IP, le masque de sous-réseau et la passerelle par défaut. Par contre, j'ai testé sur le Windows Vista de ma copine, ça marche pas. Putain de bordel de merde, quoi.
Bref, on va passer en revue ma classe que j'ai nommée "WinGPacket". Le nom est pourri mais je savais pas comment la baptiser. Win pour Windows, G pour la première lettre de mon pseudo, et "Packet" car ça manipule les paquets réseau. Bref, on s'en fout...
wingpacket.hpp :
En quelques mots : on met des défines pour éviter de se faire couillonner si y'a des inclusions multiples. On a aussi les accesseurs aux principaux membres qui sont des objets non pas de type "string" mais de type "String", ce qui change tout. C'est une classe que j'ai refaite dans le cadre de mes études et je me suis dit que je pourrais la garder.
Mais ce qui reste le plus intéressant, c'est la fonction au prototype suivant :
Elle prend en argument un pointeur sur notre tableau de caractères qui correspond à notre packet en dur, ainsi que sa taille. Effectivement, on n'ira pas mesurer la taille du paquet avec strlen() puisqu'il y a des octets nuls dedans.
Et le plus impressionnant : son code. Vous êtes prêts ? :)
Eh oui, un simple WriteFile() suffit à balancer notre paquet sur le réseau. Quand on sniffe avec WireShark, on les voit tranquillement défiler. Notre handle correspond à une poignée sur notre interface réseau qui est ouverte dans le constructeur de la manière suivante :
Je fais face à un problème : je préfixe la chaîne passée en paramètre formel à ma méthode qui correspond à l'interface réseau, de la forme { ... }. Visiblement, je préfixe cette chaîne de "\\\\.\\Global\\NPF_" et :
Eh oui, à cause de mon manque de patience et de compétences, j'ai pas tout trouvé ce que je cherchais dans les sources de winpcap. Donc il reste des points à éclaircir.
Ce qu'il faut véritablement retenir, c'est qu'il suffise que d'un WriteFile() pour balancer un paquet forgé entièrement à la main à travers le réseau. Allez, un petit exemple de code qui fonctionne chez moi mais, malheureusement, pas chez tout le monde et peut-être pas chez vous...
A l'exécution :
Un invite de saisie où je rentre le numéro d'une interface qui me parle, c'est-à-dire qui possède une description. Ici, ça sera "4" car je bosse avec ma clé USB Wifi.
Super, il m'affiche la configuration de ma clé wifi, malheureusement chopée dans le registre et non à l'aide d' "IoControlCode". Bon, je suis sûr de rien, mais je suis persuadé qu'il soit possible de récupérer ce telles informations via un DeviceIoControl()...
Mais avant, je prends bien soin d'ouvrir WireShark et de capturer les paquets en mode "non promiscuous" (exceptionnellement pour cette interface car sinon ça ne fonctionne pas) et je mate ce qui se passe. Et là...
Cliquez sur l'image pour agrandir
On voit nos paquets passer, l'air de rien. Bon, heureusement, j'ai mis de la merde quant aux adresses MAC. Mais si on fout vraiment n'importe quoi, on peut bloquer entièrement le réseau ; dire à tout le monde que la passerelle par défaut se situe à une adresse MAC foireuse, ça fait mal et ça empêche tout le monde de passer. Effet garanti.
Envoyer nos propres paquets sur le réseau s'avère, avec le recul, vraiment simple. Ce qui est plus dur et ce sur quoi je ne me suis pas (encore ?) attardé : gérer des connexions TCP/IP avec ces paquets, par exemple. Et plus encore si affinité. Heureusement, il y a les rfc.
A retenir : WriteFile() permet l'envoi de paquets sur une interface réseau ouverte avec CreateFile().
Et comme promis, une archive contentant le programme de test, les sources et le fichier projet Code::Blocks : http://venom630.free.fr/geo/blog/pcap/WinGPacket.zip
Et, enfin, si par hasard vous avez des réponses à mes interrogations, je suis entièrement preneur car je compte vraiment faire quelque chose de concret avec tout ça. A vrai dire, faire un fork() de pcap m'intéresserait car j'aurais juste des .h et .cpp à me trimballer ; des fichiers sources dont je connais et maîtrise le contenu plutôt que des dll et plein d'autres dépendances...
Geo
PS : Ivan, je me suis mis aux chocapics.
Il se trouve qu'on avait des résultats un peu bluffant puisque ça parle pas forcément. Heureusement, quand on chopait la description de l'interface réseau, ça allait mieux.
Pour qu'on ne se prenne plus la tête avec tout ça, j'ai décidé d'encapsuler les fonctionnalités que je détaillerais dans une classe C++.
Donc, pour le moment, on a une fonction statique qui renvoie un double vecteur de chaînes de caractères avec la chaîne représentant l'interface, l'autre représentant la description.
On a aussi un constructeur qui prend en argument une interface réseau à ouvrir via CreateFile() et qui va récupérer sa description ainsi que d'autres infos comme son adresse IP, le masque de sous-réseau et la passerelle par défaut. Par contre, j'ai testé sur le Windows Vista de ma copine, ça marche pas. Putain de bordel de merde, quoi.
Bref, on va passer en revue ma classe que j'ai nommée "WinGPacket". Le nom est pourri mais je savais pas comment la baptiser. Win pour Windows, G pour la première lettre de mon pseudo, et "Packet" car ça manipule les paquets réseau. Bref, on s'en fout...
wingpacket.hpp :
#ifndef _WINGPACKET_HPP
#define _WINGPACKET_HPP
#include <iostream>
#include <cstdlib>
#include <vector>
#include <windows.h>
#include "string.hpp"
class Wingpacket {
public:
Wingpacket(char* = NULL);
~Wingpacket();
static std::vector< std::vector<String> > getAllInterfaces();
char* getDescription() const;
char* getIPAddress() const;
char* getSubnetMask() const;
char* getDefaultGateWay() const;
int sendPacket(char* packet, int size) const;
private:
String m_description;
String m_ipAddr, m_subnetMask, m_defaultGateWay;
HANDLE m_hDevice;
};
#endif
En quelques mots : on met des défines pour éviter de se faire couillonner si y'a des inclusions multiples. On a aussi les accesseurs aux principaux membres qui sont des objets non pas de type "string" mais de type "String", ce qui change tout. C'est une classe que j'ai refaite dans le cadre de mes études et je me suis dit que je pourrais la garder.
Mais ce qui reste le plus intéressant, c'est la fonction au prototype suivant :
int sendPacket(char* packet, int size) const;
Elle prend en argument un pointeur sur notre tableau de caractères qui correspond à notre packet en dur, ainsi que sa taille. Effectivement, on n'ira pas mesurer la taille du paquet avec strlen() puisqu'il y a des octets nuls dedans.
Et le plus impressionnant : son code. Vous êtes prêts ? :)
int Wingpacket::sendPacket(char* packet, int size) const {
DWORD dwBytesWritten;
return WriteFile(this->m_hDevice, packet, size, &dwBytesWritten, NULL );
}Eh oui, un simple WriteFile() suffit à balancer notre paquet sur le réseau. Quand on sniffe avec WireShark, on les voit tranquillement défiler. Notre handle correspond à une poignée sur notre interface réseau qui est ouverte dans le constructeur de la manière suivante :
String strDeviceName(deviceName);
if(strDeviceName.substr(0, 8) == "\\Device\\") {
String newName = "\\\\.\\Global\\NPF_";
newName += strDeviceName.substr(8);
String tmpPathKey;
// On essaie d'ouvrir le driver
this->m_hDevice = ::CreateFile(
newName.getStr(),
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
0,
0
);
// ...
Je fais face à un problème : je préfixe la chaîne passée en paramètre formel à ma méthode qui correspond à l'interface réseau, de la forme { ... }. Visiblement, je préfixe cette chaîne de "\\\\.\\Global\\NPF_" et :
- J'aurais du mal à vous dire ce à quoi correspond "NPF_". Je peux juste vous dire qu'il existe un driver sous ce nom ;
- Parfois, il arrive qu'il faille que j'enlève ce préfixe, sans quoi l'envoi de paquets ne marche pas.
Eh oui, à cause de mon manque de patience et de compétences, j'ai pas tout trouvé ce que je cherchais dans les sources de winpcap. Donc il reste des points à éclaircir.
Ce qu'il faut véritablement retenir, c'est qu'il suffise que d'un WriteFile() pour balancer un paquet forgé entièrement à la main à travers le réseau. Allez, un petit exemple de code qui fonctionne chez moi mais, malheureusement, pas chez tout le monde et peut-être pas chez vous...
#include <iostream>
#include "string.hpp"
#include "wingpacket.hpp"
using namespace std;
int main()
{
vector< vector> Devices = Wingpacket::getAllInterfaces();
for(unsigned int i = 0, l = Devices.size(); i < l; i++) {
cout << i+1 << " : " << Devices[i][0] << " " << Devices[i][1] << std::endl;
}
unsigned int choice;
cout << "Select the interface to open : ";
cin >> choice;
while(choice < 1 || choice > Devices.size()) {
cout << "Try again: ";
cin >> choice;
}
Wingpacket myDevice(Devices[choice-1][0]);
cout << "Description is " << myDevice.getDescription() << "\n";
cout << "IP address is " << myDevice.getIPAddress() << "\n";
cout << "Subnet Mask is " << myDevice.getSubnetMask() << "\n";
cout << "DefaultGateWay is " << myDevice.getDefaultGateWay() << "\n";
for(int i = 0; i < 10; i++) {
myDevice.sendPacket(
"\x01\x23\x45\x67\x89\x2a" // Adresse MAC Destination (n'importe quoi)
"\xfe\xdc\xba\x98\x76\x54" // Adresse MAC Source (n'importe quoi)
// Couche réseau
"\x08\x06" // "Protocole ARP"
"\x00\x01" // Hardware type = Ethernet
"\x08\x00" // Protocol type = IP
"\x06" // Hardware size = 6 (une adresse MAC fait 6 octets)
"\x04" // Protocol size = 4 (une adresse ipv4 fait 4 octets)
"\x00\x02" // On envoie une réponse
"\x01\x23\x45\x67\x89\x2a" // Adesse MAC de l'envoyeur (n'importe quoi)
"\xc0\xa8\x01\x01" // Adresse IP de l'envoyeur (on fout n'importe quoi, ici, 192.168.1.1)
"\xfe\xdc\xba\x98\x76\x54" // Adresse MAC Destination (n'importe quoi)
"\xc0\xa8\x01\x05" // Adresse IP Destination (ici, moi : 192.168.1.5
, 42);
Sleep(1000);
}
return 0;
}
A l'exécution :
C:\[...]\WinGPacket\bin\Release>WinGPacket.exe
1 : \Device\{C8B3A563-AC0B-4871-9A3B-9EF6DB42EC87}
2 : \Device\{F9A79020-32A7-4134-BD12-C92351E25EC4}
3 : \Device\NdisWanIp
4 : \Device\{8EEB3BBC-655E-4E05-A2DD-92A5325081A6} Belkin Wireless G Plus MIMO USB Network Adapter
5 : \Device\{79ACFCBD-A8D5-40EE-B565-3AA5D78D34B5}
6 : \Device\{70467207-74FE-4F20-87EB-5F79C03C2D2A}
7 : \Device\NdisWanBh
8 : \Device\{F9415153-9262-4C55-B0A4-D9D3B9911CB7} Realtek PCIe FE Family Controller
Select the interface to open :
1 : \Device\{C8B3A563-AC0B-4871-9A3B-9EF6DB42EC87}
2 : \Device\{F9A79020-32A7-4134-BD12-C92351E25EC4}
3 : \Device\NdisWanIp
4 : \Device\{8EEB3BBC-655E-4E05-A2DD-92A5325081A6} Belkin Wireless G Plus MIMO USB Network Adapter
5 : \Device\{79ACFCBD-A8D5-40EE-B565-3AA5D78D34B5}
6 : \Device\{70467207-74FE-4F20-87EB-5F79C03C2D2A}
7 : \Device\NdisWanBh
8 : \Device\{F9415153-9262-4C55-B0A4-D9D3B9911CB7} Realtek PCIe FE Family Controller
Select the interface to open :
Un invite de saisie où je rentre le numéro d'une interface qui me parle, c'est-à-dire qui possède une description. Ici, ça sera "4" car je bosse avec ma clé USB Wifi.
Select the interface to open : 4
Description is Belkin Wireless G Plus MIMO USB Network Adapter
IP address is 192.168.1.3
Subnet Mask is 255.255.255.0
DefaultGateWay is 192.168.1.1
Description is Belkin Wireless G Plus MIMO USB Network Adapter
IP address is 192.168.1.3
Subnet Mask is 255.255.255.0
DefaultGateWay is 192.168.1.1
Super, il m'affiche la configuration de ma clé wifi, malheureusement chopée dans le registre et non à l'aide d' "IoControlCode". Bon, je suis sûr de rien, mais je suis persuadé qu'il soit possible de récupérer ce telles informations via un DeviceIoControl()...
Mais avant, je prends bien soin d'ouvrir WireShark et de capturer les paquets en mode "non promiscuous" (exceptionnellement pour cette interface car sinon ça ne fonctionne pas) et je mate ce qui se passe. Et là...
Cliquez sur l'image pour agrandir
On voit nos paquets passer, l'air de rien. Bon, heureusement, j'ai mis de la merde quant aux adresses MAC. Mais si on fout vraiment n'importe quoi, on peut bloquer entièrement le réseau ; dire à tout le monde que la passerelle par défaut se situe à une adresse MAC foireuse, ça fait mal et ça empêche tout le monde de passer. Effet garanti.
Conclusion
Envoyer nos propres paquets sur le réseau s'avère, avec le recul, vraiment simple. Ce qui est plus dur et ce sur quoi je ne me suis pas (encore ?) attardé : gérer des connexions TCP/IP avec ces paquets, par exemple. Et plus encore si affinité. Heureusement, il y a les rfc.
A retenir : WriteFile() permet l'envoi de paquets sur une interface réseau ouverte avec CreateFile().
Et comme promis, une archive contentant le programme de test, les sources et le fichier projet Code::Blocks : http://venom630.free.fr/geo/blog/pcap/WinGPacket.zip
Et, enfin, si par hasard vous avez des réponses à mes interrogations, je suis entièrement preneur car je compte vraiment faire quelque chose de concret avec tout ça. A vrai dire, faire un fork() de pcap m'intéresserait car j'aurais juste des .h et .cpp à me trimballer ; des fichiers sources dont je connais et maîtrise le contenu plutôt que des dll et plein d'autres dépendances...
Geo
PS : Ivan, je me suis mis aux chocapics.
mercredi 3 mars 2010
Analyse de winpcap - Partie I
Hello les gens,
Lors de mon dernier poste traitant de la lib winpcap et de ses fonctionnalités, j'avais parlé, en conclusion, d'analyser son fonctionnement. Effectivement, j'étais resté perplexe et me posais une question.
En effet, il faut savoir que Microsoft restreint l'usage des "Raw Socket", où nous sommes en mesure de forger nos propres paquets. On m'a conseillé d'abandonner, et je me suis rendu compte que j'avais bien fait de désobéir ! >:)
Pour ceux qui veulent des infos sur les Raw Socket avec WinSock : http://msdn.microsoft.com/en-us/library/ms740548%28VS.85%29.aspx. Vous comprendrez plus ou moins que si vous voulez balancer un paquet ARP, vous pouvez allez vous faire foutre. Au moins, ça a le mérite d'être clair.
Mais, quand il s'agit de winpcap, on peut faire ce qu'on veut. Etrange, non ? Alors je me suis mis en tête d'analyser ça. La question : "Comment ça fonctionne ?". Question brève pour une réponse qui va se scinder en probablement plusieurs postes.
Dans ce premier poste, j'irai tout en douceur. On n'apprendra pas à balancer / sniffer des paquets, mais juste à récupérer la liste des interfaces réseau (c'est déjà bien pour commencer, non ?)
/!\ Les tests sont menés, ici, sous un windows XP SP3. Il se peut que ça marche sur la série XP, mais je ne garantie rien quant à Vista / Seven et encore moins sous les versions antérieures !
Sous Windows, on peut avoir une ou plusieurs interfaces réseau. Votre carte ethernet en est une, aussi bien que votre carte Wifi. J'ai même une clé USB Wifi reconnue en tant qu'interface réseau. Il se peut aussi que les machines virtuelles engendrent la création d'interfaces réseau exploitables ; je ne me suis pas penché sur ce genre de chose, mais certains reversers doivent avoir la réponse. ;)
Pour récupérer cette liste d'interfaces réseau, il faut aller chercher dans la base de registre à ce chemin : HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Class\{4D36E972-E325-11CE-BFC1-08002BE10318}. Dans cette clé figurent des sous-clés ayant pour non 0000, puis 0001, puis 0002, ... A croire qu'on prévoit 10000 noms d'interfaces réseau.
Dans ces sous-clé se trouvent une clé nommée "Linkage", et, enfin, dans cette clé "Linkage" se trouve une valeur de type REG_MULTI_SZ - constante signifiant "plusieurs chaînes terminées par un octet nul", d'où le "SZ" - String Zero - qui correspond au chemin de notre interface réseau.
L'objectif du moment sera d'afficher chacune de ces interfaces. Grâce à l'API Win32 et à sa panoplie de fonctions RegMachiChouette(), ça doit pas être bien dur ! :)
Quelques fonctions utiles :
RegOpenKeyEx() : Permet d'ouvrir une clé existante : http://msdn.microsoft.com/en-us/library/ms724897(VS.85).aspx ;
RegQueryValueEx() : Permet de récupérer la valeur d'une clé. http://msdn.microsoft.com/en-us/library/ms724911(VS.85).aspx ;
CreateFile() : Permet de déterminer si une interface réseau est accessible (un bon indice pour la suite ! :]) : http://msdn.microsoft.com/en-us/library/aa363858%28VS.85%29.aspx.
Ok, on aura nos interfaces, mais il faudrait aussi la description de chacune d'elles.
Et bien j'ai tout de même trouvé, dans la clé SOFTWARE\Microsoft\Windows NT\CurrentVersion\NetworkCards, des sous-clé ayant pour un un numéro sans les 0 devant, cette fois. Mais ce sont les mêmes numéros que nos interfaces réseau de HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Class\{4D36E972-E325-11CE-BFC1-08002BE10318}, donc il nous sera facile de faire le lien !
Maintenant, on se tait et on code.
Pour la source clean, c'est par ici : http://venom630.free.fr/geo/blog/reverse_pcap/part1/getInterfacesReseau.html. Le gros cadeau, c'est qu'il faille simplement compiler un seul fichier ! Pas de lib à linker ni rien.
Le résultat que j'obtiens :
Pour récupérer les adresses IPs, j'ai pas cherché plus loin. Mais ça ne nous gênera pas pour la suite.
Et j'ai pas testé sur d'autres postes, donc je ne vous garantie rien. Mais alors rien du tout.
Certes, l'article a été très court, mais c'était pour vous montrer un aperçu. Là, on saura quelles interfaces emmerder pour pouvoir balancer nos paquets. Et n'importe quel paquet, de surcroit.
Geo
Lors de mon dernier poste traitant de la lib winpcap et de ses fonctionnalités, j'avais parlé, en conclusion, d'analyser son fonctionnement. Effectivement, j'étais resté perplexe et me posais une question.
En effet, il faut savoir que Microsoft restreint l'usage des "Raw Socket", où nous sommes en mesure de forger nos propres paquets. On m'a conseillé d'abandonner, et je me suis rendu compte que j'avais bien fait de désobéir ! >:)
Pour ceux qui veulent des infos sur les Raw Socket avec WinSock : http://msdn.microsoft.com/en-us/library/ms740548%28VS.85%29.aspx. Vous comprendrez plus ou moins que si vous voulez balancer un paquet ARP, vous pouvez allez vous faire foutre. Au moins, ça a le mérite d'être clair.
Mais, quand il s'agit de winpcap, on peut faire ce qu'on veut. Etrange, non ? Alors je me suis mis en tête d'analyser ça. La question : "Comment ça fonctionne ?". Question brève pour une réponse qui va se scinder en probablement plusieurs postes.
Dans ce premier poste, j'irai tout en douceur. On n'apprendra pas à balancer / sniffer des paquets, mais juste à récupérer la liste des interfaces réseau (c'est déjà bien pour commencer, non ?)
/!\ Les tests sont menés, ici, sous un windows XP SP3. Il se peut que ça marche sur la série XP, mais je ne garantie rien quant à Vista / Seven et encore moins sous les versions antérieures !
Les interfaces réseau
Sous Windows, on peut avoir une ou plusieurs interfaces réseau. Votre carte ethernet en est une, aussi bien que votre carte Wifi. J'ai même une clé USB Wifi reconnue en tant qu'interface réseau. Il se peut aussi que les machines virtuelles engendrent la création d'interfaces réseau exploitables ; je ne me suis pas penché sur ce genre de chose, mais certains reversers doivent avoir la réponse. ;)
Pour récupérer cette liste d'interfaces réseau, il faut aller chercher dans la base de registre à ce chemin : HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Class\{4D36E972-E325-11CE-BFC1-08002BE10318}. Dans cette clé figurent des sous-clés ayant pour non 0000, puis 0001, puis 0002, ... A croire qu'on prévoit 10000 noms d'interfaces réseau.
Dans ces sous-clé se trouvent une clé nommée "Linkage", et, enfin, dans cette clé "Linkage" se trouve une valeur de type REG_MULTI_SZ - constante signifiant "plusieurs chaînes terminées par un octet nul", d'où le "SZ" - String Zero - qui correspond au chemin de notre interface réseau.
L'objectif du moment sera d'afficher chacune de ces interfaces. Grâce à l'API Win32 et à sa panoplie de fonctions RegMachiChouette(), ça doit pas être bien dur ! :)
Quelques fonctions utiles :
RegOpenKeyEx() : Permet d'ouvrir une clé existante : http://msdn.microsoft.com/en-us/library/ms724897(VS.85).aspx ;
RegQueryValueEx() : Permet de récupérer la valeur d'une clé. http://msdn.microsoft.com/en-us/library/ms724911(VS.85).aspx ;
CreateFile() : Permet de déterminer si une interface réseau est accessible (un bon indice pour la suite ! :]) : http://msdn.microsoft.com/en-us/library/aa363858%28VS.85%29.aspx.
Ok, on aura nos interfaces, mais il faudrait aussi la description de chacune d'elles.
Et bien j'ai tout de même trouvé, dans la clé SOFTWARE\Microsoft\Windows NT\CurrentVersion\NetworkCards, des sous-clé ayant pour un un numéro sans les 0 devant, cette fois. Mais ce sont les mêmes numéros que nos interfaces réseau de HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Class\{4D36E972-E325-11CE-BFC1-08002BE10318}, donc il nous sera facile de faire le lien !
Maintenant, on se tait et on code.
#include <stdio.h>
#include <windows.h>
#include <stdlib.h>
#define KEY_IF_RESEAUX "SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002BE10318}"
#define KEY_DESC_RESEAUX "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\NetworkCards"
int main(int argc, char **argv) {
// Des handle de clefs
HKEY hKey, hCurrentKey, hDescKey;
// Variables
char* currentPathKey, *currentDescKey;
// Numéro de l'interface sous chaîne de caractères
char currentNumber[5];
// compteur de l'interface
int cpt = 0;
// Handle sur l'interface qui va nous permettre de savoir si on peut l'ouvrir ou pas
HANDLE hDevice;
// Variable dont on se sert pour connaître les octets retournés par une fonction
LONG dwBytesReturned;
// Tampons
char buffer[1024];
char devName[1024];
char desc[1024];
// Première étape : ouverture de la clé en question
LONG Status = RegOpenKeyEx( HKEY_LOCAL_MACHINE, KEY_IF_RESEAUX, 0, KEY_ALL_ACCESS, &hKey );
if(Status == ERROR_SUCCESS) {
// On la ferme puisqu'on n'en a plus besoin
RegCloseKey(hKey);
// Les sous-clé s'appellent toutes 0000, 0001, ... Donc il va falloir les parcourir.
// strlen("\\0000\\Linkage") + '\0' = 14
sprintf(currentNumber,"%04d", cpt);
// On prépare le chemin de la clé dans le registre
currentPathKey = (char*)malloc(strlen(KEY_IF_RESEAUX) + 14);
strcpy(currentPathKey, KEY_IF_RESEAUX);
strcat(currentPathKey, "\\");
strcat(currentPathKey, currentNumber);
strcat(currentPathKey, "\\Linkage");
// On ouvre cette clé
Status = RegOpenKeyEx(HKEY_LOCAL_MACHINE, currentPathKey, 0, KEY_ALL_ACCESS, &hCurrentKey);
// Tant qu'on arrive à ouvrir la clé...
while(Status == ERROR_SUCCESS) {
// La valeur "Export" nous intéresse.
Status = RegQueryValueEx(hCurrentKey, "Export", NULL, NULL, (BYTE*)buffer, (DWORD*)&dwBytesReturned);
// Si on a réussit à lire la valeur, on l'affiche
if(Status == ERROR_SUCCESS) {
// On teste si l'interface est accessible
sprintf(devName, "\\\\.\\Global\\%s", &buffer[8]);
hDevice = CreateFile(devName, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
if(hDevice != INVALID_HANDLE_VALUE) {
// On essaie de récupérer la description de cette carte
sprintf(currentNumber, "%d", atoi(currentNumber)+1);
//printf("%s %s\n", buffer, currentNumber);
// strlen("\\xxxx") + '\0' = 6
currentDescKey = (char*)malloc(strlen(KEY_DESC_RESEAUX) + 6);
strcpy(currentDescKey, KEY_DESC_RESEAUX);
strcat(currentDescKey, "\\");
strcat(currentDescKey, currentNumber);
// On ouvre la clef de la description
Status = RegOpenKeyEx(HKEY_LOCAL_MACHINE, currentDescKey, 0, KEY_ALL_ACCESS, &hDescKey);
if(Status == ERROR_SUCCESS) {
// "Description" nous intéresse
Status = RegQueryValueEx(hDescKey, "Description", NULL, NULL, (BYTE*)desc, (DWORD*)&dwBytesReturned);
if(Status == ERROR_SUCCESS) {
printf("%s %s\n", buffer, desc);
RegCloseKey(hDescKey);
}
}
free(currentDescKey);
CloseHandle(hDevice);
}
}
ZeroMemory(currentPathKey, strlen(KEY_IF_RESEAUX) + 14);
// On prépare le chemin de la clé suivante
sprintf(currentNumber,"%04d", ++cpt);
strcpy(currentPathKey, KEY_IF_RESEAUX);
strcat(currentPathKey, "\\");
strcat(currentPathKey, currentNumber);
strcat(currentPathKey, "\\Linkage");
// On la relit.
Status = RegOpenKeyEx(HKEY_LOCAL_MACHINE, currentPathKey, 0, KEY_ALL_ACCESS, &hCurrentKey);
}
// On libère tout le tralala & on se casse
free(currentPathKey);
RegCloseKey(hCurrentKey);
}
return EXIT_SUCCESS;
}
Pour la source clean, c'est par ici : http://venom630.free.fr/geo/blog/reverse_pcap/part1/getInterfacesReseau.html. Le gros cadeau, c'est qu'il faille simplement compiler un seul fichier ! Pas de lib à linker ni rien.
Le résultat que j'obtiens :
C:\Documents and Settings\Geoffrey\Mes documents\c>getInterfacesReseau.exe
\Device\{8EEB3BBC-655E-4E05-A2DD-92A5325081A6} Belkin Wireless G Plus MIMO USB Network Adapter
\Device\{F9415153-9262-4C55-B0A4-D9D3B9911CB7} Realtek PCIe FE Family Controller
\Device\{8EEB3BBC-655E-4E05-A2DD-92A5325081A6} Belkin Wireless G Plus MIMO USB Network Adapter
\Device\{F9415153-9262-4C55-B0A4-D9D3B9911CB7} Realtek PCIe FE Family Controller
Pour récupérer les adresses IPs, j'ai pas cherché plus loin. Mais ça ne nous gênera pas pour la suite.
Et j'ai pas testé sur d'autres postes, donc je ne vous garantie rien. Mais alors rien du tout.
Conclusion
Certes, l'article a été très court, mais c'était pour vous montrer un aperçu. Là, on saura quelles interfaces emmerder pour pouvoir balancer nos paquets. Et n'importe quel paquet, de surcroit.
Geo
Inscription à :
Articles (Atom)