WMI – Contrôler Windows en Python
Il y a quelques années,
Microsoft l'un des membres du groupe DMTF (Distributed Management
Task Force) a créé le WMI, un langage permettant de
gérer des systèmes en réseaux via une interface
normalisée. Il permet aussi bien d'accéder aux
ressources d'un ordinateur sous Windows que de le gérer et
même de le contrôler. Le but de cet article n'est pas de
faire un cours long et technique sur la technologie WMI en elle-même
et sur toutes les notions associées, non le but est de vous
proposer un guide simple à lire d'introduction à la
pratique du WMI au travers de petits scripts détaillés
programmés en Python mais aussi de vous familiariser avec des
outils de programmation permettant de raccourcir le temps de
développement (que ce soit en C#, VB.NET ou Visual Basic
Script).
Cet article explique :
La création de scripts WMI
Les langages et les outils
facilitant la création de tels scripts.
Une petite introduction au
langage Python ainsi qu'un comparatif par rapport au C#, VB.NET...
Ce qu'il faut savoir :
Le but de cet article n'est pas de faire un cours long et technique sur la technologie WMI en elle-meme et sur toutes les notions associées, non le but est de vous proposer un guide simple a lire d'introduction a la pratique du WMI au travers de petits scripts détaillés programmés en Python mais aussi de vous familiariser avec des outils de programmation permettant de raccourcir
le temps de développement (que ce soit en C#, VB.NET ou Visual Basic Script).
WMI (Windows Management Instrument) est
un système permettant et même facilitant
l'administration de systèmes et réseaux sous Windows.
Avant d'aller plus loin sur WMI, il vous faut savoir que le WMI est
en quelque sorte l'implémentation made in Microsoft Labs du
WBEM (Web-Based Enterprise Management). Pour plus d'information sur
les protocoles normalisés de management de systèmes,
nous vous conseillons de lire les articles en rapport avec leWBEM, un
ensemble de standards mis en place par le DMTF consortium permettant
aux personnes en charge de systèmes informatiques d'accéder
à des informations de gestion/management des dits systèmes
grâce à des infrastructures et technologies normalisées
et ce depuis n'importe quel point d'un réseau/sous-réseau.
Pour rester simple et clair, les
protocoles WBEM vont permettre l'échange de données
(informations mais aussi des objets informatiques) en local ou à
travers un réseau tout en prônant l'intéropérabilité.
CIM-XML ou encore WSDM sont des exemples de protocoles permettant
d'effectuer ce genre de transfert d'information.
Comme nous venons de le dire en
d'autres termes, WMI est une technologie de gestion, de management de
systèmes Windows. Elle exploite de nombreuses APIs
(Application Programming Interface ou Interfaces de programmation
d'application) pour accéder à divers objets des
systèmes : des objets qui nous permettrons par la suite de
contrôler le(s) système(s) mais aussi d'y recueillir des
informations.
Depuis des années, les outils et
les langages de programmation facilitant le travail des
administrateurs réseaux et systèmes se sont
perfectionnés tout en étant devenus de plus en plus
simple à maîtriser (aussi bien l'apprentissage que la
mise en oeuvre ). Pour administrer des machines en local, Windows
fournit déjà de nombreux outils forts sympathiques et
simples d'utilisation et il est aussi possible d'obtenir de nombreux
logiciels d'administration systèmes développés
par des sociétés tierces. Il en est aussi de même
pour l'administration à distance de systèmes Windows.
Le but de cet article n'est pas de
faire un listing de tous les outils permettant d'administrer des
machines mais de s'intéresser particulièrement sur un
de ces outils : WMI. Grâce au WMI, plus besoin de passer du
temps à lire les manuels d'utilisation des logiciels récemment
achetés, plus besoin de passer du temps à comprendre
les options de la ligne de commande de SSH ou encore RPCCLIENT
(SAMBA). Nous allons voir comment développer en un temps
record des scripts qui vont faire exactement ce que l'on souhaite.
Des scripts qui serviront aussi bien à des administrateurs
qu'à des développeurs informatique voulant accéder
rapidement à des données des ordinateurs sur lesquels
leur création sera installée. Si malgré cet
article, vous n'êtes pas intéressés par l Python,
cet article vous permettra quand même de vous familiariser avec
le WMI car nous ne parlerons pas de Python tout le temps.
WMI n'est pas une technologie inconnue
ou nouvelle, elle est présente depuis très longtemps
dans Windows : elle est préinstallée sur Windows 2000,
Windows XP, Windows Me et Windows 2003 Server. Généralement,
elle est utilisée avec du Visual Basic Script ou encore avec
du C#. Nous verrons comment réaliser des scripts WMI en
langage Python.
Mais qu'est-ce que Python?
Python® est un langage de
programmation orienté objet qui est utilisé pour
réaliser divers types d'applications. Ce langage est utilisé
par de nombreux programmeurs et entreprises pour ces divers
avantages. C'est un langage portable (il peut tourner sous les
systèmes Windows, Linux/Unix, Mac, Amiga, Palm, des portables
Nokia et...).Il permet des développements rapides et des gains
en lignes de codes et rapidité d'exécution non
négligeables comparé à des langages comme le C++
ou encore Java. En moyenne, un programme en Python comporte 4 à
5 fois moins de lignes de codes que la version développée
en C/C++.
Il est très simple à
apprendre aussi bien par des novices de la programmation que par des
hackers.
Il est facilement extensible (le
développement de librairies de fonctions comme le
développement d'extension Python se font assez simplement et
rapidement).Il peut être utilisé pour ajouter des
fonctionnalités à des programmes en tout genre
(Blender, Gimp... pour ne citer qu'eux).
Etant plus vieux que Java et ayant une
communauté très active, il est devenu un langage très
mature utilisé aussi bien par la NASA, dans l'aviation, dans
des entreprises militaires, par Google, dans des banques, des
scientifiques de tous bords, des développeurs de jeux videos,
des développeurs de réseaux P2P (BitTorrent), des
développeurs de systèmes embarqués (NOKIA)...
mais aussi par des administrateurs et des développeurs
d'outils de monitoring réseaux et systèmes. Pour
comprendre le pourquoi de la réussite de ce langage, il faut
s'intéresser au langage lui-même. L'apprentissage est
simple et rapide (normalement, moins d'une demi-journée de
travail suffissent pour maîtriser le Python). Il permet le
développement de scripts comme de programmes de tout taille
(Google s'en sert entre autre pour gérer une grande partie de
leur infrastructure) que ce soit avec une interface graphique ou non.
La syntaxe est aussi simple que le Perl ou encore le Ruby mais la
logique de programmation OO est proche du Java. Il est libre de
droits et présent sur tout type de systèmes. Il est
fourni avec près de 300 modules officiels et on peut
actuellement compter près de 1300 bibliothèques de
fonctions que tout le monde peut utiliser dans ses propres
applications Python et autant de bouts de codes que l'on piocher ici
et là sur Internet. Bon, nous allons arrêter notre
mission d'évangélisateurs Python pour vous présenter
une de ces bibliothèques Python qui sera certainement d'une
très grande utilité à des administrateurs
systèmes et réseaux mais aussi à des
développeurs de tout bord : wmi.py qui facilite la création
de scripts WMI sans avoir à se débattre avec du
VBScript. Mais après tout cela, une question doit quand même
être dans la tête de certaines personnes : pourquoi
utiliser Python dans notre cas? La première des réponses
que l'on peut apporter au début de cet article est la
suivante. Le but de WMI et des autres protocoles WBEM est de
permettre une administration grâce au WEB. Pour réaliser
cela, l'ASP et les mini-scripts coté clients sont très
souvent utilisés. Avec Python, il sera possible avec un seul
langage reconnu et étant à la base de divers frameworks
et autres serveurs d'applications (comme Zope) de permettre le
développement d'une véritable plate-forme
d'administration réseau et système basé sur le
WEB sans avoir à multiplier les langages de scripts et
logiciels utilisés pour réaliser une simple action. Ca
peut donner des idées à tout type d'entrepreneur...
Pour plus d'information sur le Python et si vous avez une
demi-journée à lui consacrer (c'est un investissement
en temps que vous ne serez pas prêt de regretter), vous pourrez
trouver des cours et des articles sur Python plus tard dans
l'article.
Windows Management Instrument
Comme il a été dit plus
haut, WMI est une technologie de gestion sous les systèmes
Windows. Il permet d'obtenir des informations sur des systèmes
locaux mais aussi distants. Il est par exemple possible d'obtenir la
liste de processus actifs, de contrôler l'arrêt des
systèmes et des processus, de voir et contrôler tous les
services d'un système, de contrôler l'espace disque d'un
système, d'accéder, voire de contrôler le spool
d'impressions, d'accéder à des informations réseau,
de voir et contrôler la base de registre d'un système
(le point névralgique de tous les systèmes Windows), de
réaliser une sorte de service cron (un process scheduler) sous
Windows et de réaliser tout type d'actions d'administration
comme accéder à la configuration matérielle et
logiciel d'un parc de systèmes Windows, comme la création
et la suppression de fichiers, partitionner les disques, changer les
attributs de sécurité des fichiers, formatter les
disques durs...Un autre avantage de WMI est que les développeurs
n'auront plus à manipuler les APIs Windows permettant aussi de
réaliser toutes ces actions et qui peuvent en dérouter
plus d'un. Une interface de programmation simple d'utilisation (WMI)
leur permet de réaliser tout cela. Comme vous avez sûrement
pu vous en rendre compte, WMI peut être utilisé à
tous les niveaux : surveillance d'un système en local,
monitoring réseau, recueil d'informations en local ou en
réseau et même contrôler des systèmes. En
quelque sorte, WMI est le couteau suisse parfois méconnu de
l'administration système et réseau. Maintenant avant de
vous donner les adresses des meilleurs cours de Python sur le web
pour ne pas être rapidement perdu et pouvoir ensuite enchaîner
sur des exemples pratiques, nous allons rapidement traiter de
l'architecture et du fonctionnement interne de WMI.
Fonctionnement de cette technologie de gestion
Nous allons rapidement aborder le
fonctionnement de WMI car aborder cet aspect de WMI n'est pas le but
de cet article et n'apporte rien aux développeurs. Lors de
l'utilisation de WMI pour obtenir des informations sur tel ou tel
composant/objet du réseau de l'entreprise, WMI (par le biais
du CIMOM pour Common Information Model Object Manager) va stocker la
réponse qu'il obtient du fournisseur WMI (WMI Provider) en
utilisant le CIM (Common Information Model), un autre standard défini
par le DMTF. Le Common Information Model est un modèle de
représentation des données extensible et orienté
objet qui va contenir après utilisation d'un script WMI des
informations sur divers objets et composants d'un réseau ou
d'une machine bien précise (si on travail au niveau local). En
fait, un développeur va créer des classes CIM par le
biais de WMI et c'est en manipulant les classes CIM que l'on va
pouvoir contrôler les divers composants du réseau et
obtenir tout type d'informations. Techniquement, CIM est un langage
de programmation indépendant de la plate-forme sur lequel il
est invoqué et qui est orienté objet. Comme il hérite
de toutes les qualités et capacités des langages
orientés objets, il est capable de décrire aussi bien
des informations générales que plus précises sur
divers composants du réseau. Heureusement pour nous, nous
n'avons pas à manipuler CIM directement : WMI nous épargne
toutes les complications qu'impose l'utilisation directe du langage
CIM. Nous avons précédemment parlé des
fournisseurs WMI (plus communément appelé WMI
Providers) et nous allons définir cette notion importante de
l'architecture WMI pour être sûrs que tous les termes de
cet articles sont compris par tout le monde. Un provider est un objet
COM (une notion qui sera définie plus tard) qui contrôle
un ou plusieurs objets/composants sur lequel/lesquels peuvent agir
WMI. Les providers sont généralement comparés à
des drivers WMI qui vont permettre aux scripts WMI de communiquer
avec des objets/composants et qui vont s'assurer que le script WMI
reçoit l'information désirée et que l'action
désirée sera belle et bien exécutée. Un
objet/composant est tout simplement tout élément
physique ou logique (comme un processus, un disque dur, un système
Windows...) qu'un script peut contrôler pour obtenir des
informations ou réaliser les actions de son créateur.
COM (pour Component Object Model) est une architecture de
programmation introduite dans le monde de la programmation Windows en
1993 par Microsoft. Cela permet le développement de composants
programmables pouvant interagir, communiquer entre eux, s’échanger
des informations et des messages de manière codifiée et
ordonnée quelque soit le langage de programmation de ce
composant. Pour plus d'informations sur les objets COM, nous vous
recommandons de lire les pages MSDN suivantes
:http://msdn.microsoft.com/library/default.asp?url=/library/enus/dnanchor/html/componentobjectmodelanchor.asp.
Le voyage au sein de l'architecture WMI
est maintenant fini. Dans la section suivante de l'article, nous
allons nous intéresser à Python et poser les bases de
ce langage pour que tout le monde puisse comprendre les exemples qui
suivront.
Premiers pas en Python
Pour les cours sur Python lui-même
(la syntaxe, la logique de programmation et les fonctions de base) en
français, le département biochimie de l'université
Paris 7 propose un bon cours à l'adresse
http://www.ebgm.jussieu.fr/~fuchs/python/index.html. Il y a
aussi les didacticiels de Python Blanc Bleu Belge qui se
trouvent à l'adresse http://www.p3b.org/. Pour finir avec les
bons articles en français, comme tout bon développeur
le ferait, nous vous recommandons les articles du site developez.com.
Au niveau des livres, la version française de Python in a
nutshell suffit amplement car en plus d'expliquer toutes les facettes
du langage, il y a un descriptif des librairies les plus importantes.
Pour les cours sur le Python en
anglais, http://www.python.org/doc/ référence
les bons articles. Au niveau des livres, Python in a nutshell suffit
amplement car en plus d'expliquer toutes les facettes du langage, il
y a un descriptif des librairies les plus importantes.
Python et Windows
Comme nous venons de le dire, Python
est un langage relativement simple à comprendre et à
prendre en main. Mais la question qui se pose est : Python est-il
utilisable sous Windows ? La réponse est oui. Grâce à
des modules comme pywin32, Python supporte déjà
bien les diverses APIs Windows, il supporte aussi divers aspects de
l'architecture COM et permet d'utiliser près de 30 MFC.
Même au niveau de la création
d'interfaces graphiques, Python se débrouille assez bien que
se soit avec wxPython, PyGTK (un binding python de GTK que l'on peut
aussi utiliser sous Windows), PyQT et dernièrement XUL qui est
non officiellement un nouveau moyen de réaliser des interfaces
graphiques en python.
Pour débuter
la programmation graphique sous Windows en Python, il n'y a
malheureusement pas des tas d'articles. Pour en avoir de très
bons, il faut se tourner vers les sites officiels comme PyGTK.org qui
est le site officiel du portage de GTK sous Python : un portage qui
permet de développer des applications graphiques aussi bien
sous Linux que sous Windows. Pour créer des applications
graphiques en Python, il existe bien sûr d'autres librairies
comme PyQT, wxWidgets, Tkinter et XUL qui s'annonce déjà
être le moyen le plus simple et le plus rapide de développer
des applications graphiques pour Python (en tout cas quand sortira la
version 2.0 de firefox et des autres produits Mozilla). Mais
comprendre comment fonctionne l'un facilite grandement
l'apprentissage des autres librairies, nous vous conseillons donc de
parcourir les articles de la page http://www.pygtk.org/articles.html
comme par exemple Writing win32 applications with python and glade
écrit par l'auteur du présent article.
Maintenant que nous avons débroussaillé
le terrain, nous pouvons attaquer sur des exemples concrets
d'utilisation du Python pour réaliser des scripts WMI.
Pratique : utiliser le language Python avec WMI
Dans les pages qui vont suivre, nous
allons analyser une dizaine d'exemples pour se familiariser avec la
création de scripts WMI en Python. Tous les exemples choisis
ont été testés en local mais fonctionnent aussi
en réseau. Nous afficherons parfois le résultat des
exemples pour permettre une meilleure compréhension des codes
développés. Vous pouvez bien sûr (et c'est même
conseillé) les tester chez vous après avoir installé
python et le module wmi.py.
Pour installer Python, vous pouvez
utiliser l'installeur fourni par Python.org (et qui se situe à
l'adresse http://www.python.org/ftp/python/2.4.3/python-2.4.3.msi)
ou celui de ActiveState qui installe par défaut plus de
librairies python (et qui se situe à l'adresse
http://www.activestate.com/Products/ActivePython/).
Pour installer le module WMI, il suffit de télécharger
la dernière version du module sur le site
http://tgolden.sc.sabren.com/python/wmi.html puis de suivre le
readme.
Lister tous les processus actifs
Tout au long de cette section, vous
allez rencontrer ce type de code :
do_something
Pour les personnes n'ayant pas encore
jeté un coup d'oeil sur les articles Python, il vous faut
savoir que Python a plusieurs types de données, entre autre
les listes qui sont tout simplement des tableaux (comme dans les
autres langages). L'instruction for de python ne va pas itérer
un nombre de fois prédéfini comme en langage C, mais va
parcourir élément par élément le contenu
d'un tableau (du premier indice jusqu'au dernier). Si on veut, par
exemple, réaliser 16 boucles, il nous faudra créer avec
une fonction prédéfinie une liste de taille 16 ayant
comme contenu: 1, 2, ..., 16.
Dans ce premier exemple, nous allons
réaliser quelque chose de très simple mais qui peut
être utile parfois.
import wmi
c = wmi.WMI()
for process in c.Win32_Process():
print process.ProcessId,
process.Name
Premièrement, nous avons importé
le module wmi.py (il n'est pas nécessaire de rajouter
l'extension .py mais il faudra mettre le fichier wmi.py dans
le répertoire où se situe le script), puis nous avons
appelé le constructeur de classe : c = wmi.WMI(). Maintenant,
il ne nous reste qu'à invoquer la classe Win32_Process et à
afficher les données qu'elle nous renvoie. Dans notre cas,
nous ne cherchons que l'identifiant du processus et son nom. Mais
essayez d'afficher seulement process et vous obtiendrez des
informations plus qu'utiles comme le nombre de threads utilisés
par le processus, l'heure et la date de lancement du processus, le
nombre de pages mémoires utilisées, le processus
parent, les priorités d'exécution du
processus...(Listing 1).
Listing 1. Les diverses informations
fournies par Win32_Process
|
|
...
instance of Win32_Process
{
Caption = "calc.exe";
CommandLine = ""C:WINDOWSsystem32calc.exe" ";
CreationClassName = "Win32_Process";
CreationDate = "20060911151024.437500+120";
CSCreationClassName = "Win32_ComputerSystem";
CSName = "KHAALEL-38C4FDE";
Description = "calc.exe";
ExecutablePath = "C:WINDOWSsystem32calc.exe";
Handle = "2532";
HandleCount = 51;
KernelModeTime = "5000000";
MaximumWorkingSetSize =
1413120;
MinimumWorkingSetSize =
204800;
Name = "calc.exe";
OSCreationClassName = "Win32_OperatingSystem";
OSName = "Microsoft
Windows XP Professional|C:WINDOWS|DeviceHarddisk0Parti
tion1";
OtherOperationCount = "400";
OtherTransferCount = "97268";
PageFaults = 1188;
PageFileUsage = 1134592;
ParentProcessId = 2680;
PeakPageFileUsage = 1200128;
PeakVirtualSize = "37638144";
PeakWorkingSetSize =
3604480;
Priority = 8;
PrivatePageCount = "1134592";
ProcessId = 2532;
QuotaNonPagedPoolUsage =
2760;
QuotaPagedPoolUsage = 36304;
QuotaPeakNonPagedPoolUsage =
3104;
QuotaPeakPagedPoolUsage =
39512;
ReadOperationCount = "1";
ReadTransferCount = "29170";
SessionId = 0;
ThreadCount = 2;
UserModeTime = "1250000";
VirtualSize = "34615296";
WindowsVersion = "5.1.2600";
WorkingSetSize = "536576";
WriteOperationCount = "0";
WriteTransferCount = "0";
};
...
} |
Comme vous pouvez le voir, en seulement
3 lignes de codes, nous pouvons obtenir une masse d'informations. En
C# ou en VBScript, le nombre de lignes demandé serait beaucoup
plus important.
Localiser et arrêter un processus bien
précis
Maintenant, nous allons apprendre à
localiser un processus ou un ensemble de processus puis réaliser
ce que l'on désire avec : dans notre cas, terminer les
processus.
import wmi
c = wmi.WMI()
for process in
c.Win32_Process(name="calc.exe"):
process.Terminate()
Le modèle ressemble à
l'exemple précédant. Nous pouvons maintenant apercevoir
2 nouveaux éléments. Premièrement, il est
possible de filtrer les processus par le biais de mots clés.
Le mots clés sont tout simplement les diverses variables que
nous avons vu dans l'exemple précédant lorsque nous
avons affiché toutes les informations que nous pouvions
obtenir de la classe Win32_Process. Nous pouvons donc filtrer par
nom, par identifiant de processus mais aussi par la place mémoire
occupée... Ces éléments sont à manipuler
avec précaution pour ne pas avoir à redémarrer
sa machine. Le deuxième nouveau élément est la
méthode Terminate() qui permet d'arrêter un processus.
Lister tous les services du système
Il est possible de lister tous les
services sous un système Windows avec un bout de code comme
celui qui suit.
import wmi
c = wmi.WMI()
services = c.Win32_Service( )
if services:
for s in services:
print s
else:
print "No services"
Cela est réalisé en
instanciant la classe Win32_Service. La variable devient ensuite une
liste comme pour les exemples précédents et il est
aussi possible d'obtenir de nombreuses informations comme nous
pouvons le voir avec l'impression présentée dans le
Listing 2.
Listing 2. Les divserses informations
fournies par Win32_Service
|
|
instance of Win32_Service
{
AcceptPause = FALSE;
AcceptStop = FALSE;
Caption = "Universal
Plug and Play Device Host";
CheckPoint = 0;
CreationClassName =
"Win32_Service";
Description = "Provides
support to host Universal Plug and Play devices.";
DesktopInteract = FALSE;
DisplayName = "Universal
Plug and Play Device Host";
ErrorControl = "Normal";
ExitCode = 1077;
Name = "upnphost";
PathName =
"C:WINDOWSsystem32svchost.exe -k LocalService";
ProcessId = 0;
ServiceSpecificExitCode = 0;
ServiceType = "Share
Process";
Started = FALSE;
StartMode = "Manual";
StartName = "NT
AUTHORITYLocalService";
State = "Stopped";
Status = "OK";
SystemCreationClassName =
"Win32_ComputerSystem";
SystemName =
"KHAALEL-38C4FDE";
TagId = 0;
WaitHint = 0;
};
|
Comme vu dans le deuxième
exemple, il est possible de filtrer les informations retournées
suivant les variables que l'on voit dans ce listing. Par exemple,
pour n'afficher que les services qui se lancent automatiquement et
qui sont encore actifs, il suffit d'utiliser la ligne services =
c.Win32_Service (StartMode=Auto, State=Running) au lieu
de services = c.Win32_Service( ). De quoi pouvoir trouver ce
que l'on veut sur le système au niveau des services. Encore
une fois, le gain en ligne de code n'est pas négligeable.
Afficher l'espace disque libre
Pouvoir contrôler l'espace disque
d'une machine, qu'elle soit en réseau ou non est une chose
primordiale dans l'administration. Heureusement, contrôler cela
peut être réalisé très simplement avec
WMI.
import wmi
c = wmi.WMI ()
for disk in c.Win32_LogicalDisk
(DriveType=3):
sizeof = str( disk.FreeSpace+"
KB /
"+disk.Size+"
KB" )
print disk.Caption, sizeof,
"%0.2f%% free" %
(100.0 * long (disk.FreeSpace) /
long (disk.Size))
En instanciant la classe
Win32_LogicalDisk, nous avons pu accéder à chacun de
disques de l'ordinateur et pu contrôlé combien d'espace
il nous reste.
C:Documents and
SettingskhaalelDesktopDocs
My
DocsHackin9WMICodes>free-space.py
C: 1736204288KB / 31453437952KB
5.52% free
D: 651550720KB / 7667380224KB 8.50%
free
F: 1019871232KB / 20857323520KB
4.89% free
G: 7961657344KB / 20900401152KB
38.09% free
H: 12962070528KB / 159920029696KB
8.11% free
Consulter le spool d'impression
Pouvoir accéder à la
liste des éléments allant être imprimés et
pouvoir la contrôler est quelque chose qui est très
souvent réalisé par des administrateurs réseau
et système. Voici comment en 6 lignes de code, il est possible
d'obtenir une liste des futures impressions des imprimantes
installées.
import wmi
c = wmi.WMI ()
for printer in c.Win32_Printer ():
print printer.Caption
for job in c.Win32_PrintJob
(DriverName=printer.DriverName):
print " ",
job.Document
print
Obtenir des adresses IP
Maintenant, passons à un autre
registre : le réseau. Voici un exemple montrant comment
obtenir avec l'aide d'un script WMI l'adresse IP et MAC du système
sur lequel est lancé le script. On peut bien sûr obtenir
des adresses réseau d'autres machines du réseau.
import wmi
c = wmi.WMI ()
for interface in
c.Win32_NetworkAdapterConfiguration
(IPEnabled=1):
print interface.Description,
interface.MACAddress
for ip_address in
interface.IPAddress:
print ip_address
Pour réaliser cela, il a fallu
instancier la classe Win32_NetworkAdapterConfiguration. Même à
ce niveau, il est toujours possible de filtrer selon nos souhaits les
éléments retournés. Voici ce que l'on obtient
avec ce script sur ma machine en réseau.
C:Documents and
SettingskhaalelDesktopDocs
My
DocsHackin9WMICodes>ip-address.py
Realtek RTL8139/810x Family Fast
Ethernet NIC -
Packet Scheduler Miniport
00:0F:B0:71:D2:E
E
0.0.0.0
Dell TrueMobile 1300 WLAN Mini-PCI
Card -
Packet Scheduler Miniport
00:90:4B:EB:DE:C9
192.168.0.2
Contrôler les programmes lancés dès
le démarrage
Connaître les processus qui se
lancent automatiquement dès le démarrage est une
activité très souvent réalisée par les
professionnels de la sécurité mais aussi par les
personnes voulant savoir s'ils sont infectés par des malwares.
Avec les quelques lignes de codes suivantes, nous pouvons obtenir
cette liste très aisément sans avoir à rentrer
dans la base de registre Windows.
import wmi
c = wmi.WMI ()
for s in c.Win32_StartupCommand ():
print "[%s] %s <%s>"
%
(s.Location, s.Caption, s.Command)
Comme vous pouvez le remarquer, cela
est réalisable en instanciant la classe Win32_StartupCommand.
Dans cet exemple, nous allons obtenir le nom du programme qui se
lance, la clé de registre à laquelle le script a obtenu
l'information (comme ça, nous pouvons empêcher le
prochain lancement en supprimant la clé de registre) et la
position sur le disque dur des programmes. Pleins d'autres options
d'affichage sont possibles.
S'amuser avec la base de registre
Il est possible d'ajouter de nouvelles
clés dans la base de registre, de consulter les valeurs de
diverses clés, de le modifier... en quelque sorte, tout ce que
l'on vouloir faire avec la base de registre Windows. Personnellement,
je n'ai jamais utilisé des scripts WMI pour réaliser de
telles choses car le python nous fournit un autre module mieux adapté
pour les traitements liés à la base de registre
Windows, mais il est bon de savoir que des scripts WMI peuvent quand
même être utilisés.
Accéder aux disques partagés et aux
partitions
Pouvoir connaître les disques
partagés d'un système est le rêve de tout pirate
et sa première tâche si son but est de devenir le root
du système, après une escalade de droits bien sûr!
Listing 3. Script fournissant diverses
informations sur les disques durs
|
import wmi
c = wmi.WMI ()
//First we look after the shared
disks
for share in c.Win32_Share ():
print share.Name, share.Path
print
// Then the partitions
for physical_disk in
c.Win32_DiskDrive ():
for partition in
physical_disk.associators ("Win32_DiskDriveToDiskPartition"):
for logical_disk in
partition.associators ("Win32_LogicalDiskToPartition"):
print physical_disk.Caption,
partition.Caption, logical_disk.Caption
Voici le
résultat de ce script du Listing 3 :
Listing 4. Diverses informations sur
les disques instalés
C:Documents and
SettingskhaalelDesktopDocsMy
DocsHackin9WMICodes>shared-drives.py
IPC$
D$ D:
F$ F:
ADMIN$ C:WINDOWS
C$ C:
IC25N060ATMR04-0 Disk #0, Partition
#0 C:
IC25N060ATMR04-0 Disk #0, Partition
#1 F:
IC25N060ATMR04-0 Disk #0, Partition
#2 D:
Maxtor 6 B200P0 USB Device Disk #1,
Partition #0 G:
Maxtor 6 B200P0 USB Device Disk #1,
Partition #1 H:
|
Faire son cron sous Windows
CRON est un daemon Linux permettant
d'automatiser des tâches diverses et variées à
des heures bien précises définies par les utilisateurs
pouvant accéder au service cron. Sous Windows, il est aussi
possible de créer un scheduler par l'intermédiaire de
la commande AT. Voyons comment ajouter rapidement et simplement des
jobs à ce scheduler made in Windows.
Listing 5. Combiner AT et WMI
|
import os
import wmi
import time
#
// These functions are included in
wmi from 1.0rc4
#
def str_or_stars (i, length):
if i is None:
return "*" * length
else:
return str (i).rjust (length,
"0")
def from_time (
year=None,
month=None,
day=None,
hours=None,
minutes=None,
seconds=None,
microseconds=None,
timezone=None
):
"""Returns a WMI
time string of the form yyyymmddHHMMSS.mmmmmm+UUU
replacing each placeholder by its
respective integer value, or
stars if None is supplied
"""
wmi_time = ""
wmi_time += str_or_stars (year, 4)
wmi_time += str_or_stars (month,
2)
wmi_time += str_or_stars (day, 2)
wmi_time += str_or_stars (hours,
2)
wmi_time += str_or_stars (minutes,
2)
wmi_time += str_or_stars (seconds,
2)
wmi_time += "."
wmi_time += str_or_stars
(microseconds, 6)
wmi_time += str_or_stars
(timezone, 4)
return wmi_time
c = wmi.WMI ()
year, month, day, hours, mins, secs
= time.gmtime ()[:6]
job_id, result =
c.Win32_ScheduledJob.Create (
Command=r"cmd.exe /c dir /b
c: > c:temp.txt",
StartTime=from_time (
hours=hours,
minutes=mins+1,
seconds=secs,
microseconds=0,
timezone="+000"
)
)
print job_id
for line in os.popen ("at"):
print line
|
Minimiser un processus dès son lancement
Nous allons dans cet exemple ne pas
traiter d'exemple habituel : réseau, processus, base de
registre... pour montrer que presque tout peut être réalisé
avec des scripts WMI. Nous avons bien dit presque tout, car WMI n'est
pas la solution ultime à tous les problèmes
d'administration. Voici comment lancer un processus et le minimiser
immédiatement.
import wmi
import win32con
c = wmi.WMI ()
startup = c.Win32_ProcessStartup.new
(ShowWindow=win32con.SW_SHOWMINIMIZED)
pid, result = c.Win32_Process.Create
(
CommandLine="notepad.exe",
ProcessStartupInformation=startup
)
print pid
Vous avez sûrement du voir cela,
des processus qui se lançaient, que l'on aperçoit dans
la barre Windows mais dont on ne voit pas l'interface car ils ont été
minimisés... et bien voici comment cela est possible.
Se connecter à une autre machine pour
exécuter ses scripts
Tout au long de cette section, nous
avons dit que les diverses actions réalisées et toutes
les actions possibles (nous n'en avons abordé qu'une infime
partie) pouvaient aussi être réalisées sur des
machines distantes. Nous allons voir comment cela est possible.
Pas besoin de modifier l'architecture
des codes, même le nombre de ligne ne change pas, il suffit
d'invoquer le constructeur de classe WMI comme suit:
c = wmi.WMI
(computer="other_machine",
user="oneusername",
password="associatedpassword")
Créer un site IIS (non testé mais
ça devrait fonctionner)
Avec un code comme celui qui suit, il
est possible de créer un nouveau serveur Web IIS assez
aisément. N'ayant pas tous les outils nécessaires pour
voir le résultat, ce code n'a pas pu être testé
mais devrait normalement fonctionner.
Listing 6. IIS et WMI
|
import wmi
c = wmi.WMI
(namespace="MicrosoftIISv2")
#
// Could as well be achieved by
doing:
# web_server = c.IISWebService
(Name="W3SVC")[0]
#
for web_server in c.IIsWebService
(Name="W3SVC"):
break
binding = c.new ("ServerBinding")
binding.IP = ""
binding.Port = "8383"
binding.Hostname = ""
result, = web_server.CreateNewSite (
PathOfRootVirtualDir=r"c:inetpubwwwroot",
ServerComment="My Web Site",
ServerBindings=
[binding.ole_object]
)
|
Framework de création de scripts WMI
Pour réaliser des scripts WMI,
d'autres langages peuvent être utilisés comme le
VBScript, le C# ou encore le Visual Basic .NET. Pour aider à
créer des scripts WMI dans ces langages, de nombreux outils
ont été développés par Microsoft dont WMI
Code Creator que nous allons vous présenter.
WMI Code Creator est l'un des meilleurs
et des plus simples à utiliser que l'on ait déjà
rencontré. Il permet à quiconque connaît assez
bien les diverses classes WMI de réaliser en quelques clicks
des scripts en C#, VB.NET ou Visual Basic Script. Comme nous venons
de le dire, réaliser un script sous WMI Code Creator est
l'affaire de quelques clicks de souris, à moins que l'on
désire réaliser des scripts plus complets (et parfois
complexes) qui vont utiliser plusieurs classes en même temps.
Le problème maintenant est de connaître les diverses
classes. Sachant qu'il y en a beaucoup... trop, il est impossible de
toutes les connaître et de toutes les utiliser, donc pour se
faire une idée et découvrir les classes qui peuvent
vous servir, MSDN peut être d'un grand secours ou sinon
parcourir les classes accessibles par ce logiciel peut aider.
Nous n'allons pas nous attarder sur ce
genre d'outils. Nous allons réaliser un script pas à
pas pour vous familiariser avec cet outil. Cela nous permettra de
compléter la réponse à la question, pourquoi
utiliser python pour réaliser des scripts WMI ?
Nous allons reprendre le premier
exemple : afficher une liste des processus actifs.
Premièrement, lancer
WMICodeCreator.exe et se rendre sur le premier onglet du
logiciel.Cette situation est visible sur la Figure 2.
Dans le champ Namespace, il faut
choisir 'rootCIMV2'. Le namespace est un premier filtre qui permet
d'organiser les classes suivant les actions qu'elles effectuent et ce
sur quoi elles les effectuent. Plus techniquement, le namespace (ou
espace de nom pour les francophones) est un mécanisme de
structuration des objets et informations utilisés par et dans
le CIM. Ce sont des sortes de bases de données logiques
contrôlant la portée et la visibilité des classes
qui les composent. Comme vous pouvez le remarquer, nous sommes bien
dans une logique de programmation objet. 'rootCIMV2' permet, entre
autre, d'accéder aux classes de gestion des processus. En
temps réel, le logiciel va vous indiquer le nombre de classes
disponibles. Ensuite, quand le namespace a été
sélectionné, il faut choisir la classe que l'on veut :
dans notre cas, nous cherchons la classe Win32_Process. En
sélectionnant cette classe, nous aurons accès à
toutes les variables que l'on peut utiliser.
Si vous avez remarqué, le nom
des classes en Python et dans les autres langages sont les mêmes.
Cela a été fait ainsi car Python (comme les autres
langages), ne sont là que pour traiter les informations
obtenues, les classes et tout ce qui se rapporte au WMI lui-même
reste inchangé. Les variables qui sont affichées sont
les mêmes que celles que nous avions affichées dans
l'exemple 1 pour montrer tout ce que l'on pouvait obtenir.
Pour obtenir le code (suivant le
langage que vous avez choisi), qui va permettre de lister les
processus, il suffit de sélectionner une variable. Par
exemple, en sélectionnant la variable Caption, on va pouvoir
afficher les processus suivant leur nom. Il est bien sûr
possible de réaliser des filtrages et d'afficher plus
d'informations comme le Process ID. Mais là, il va falloir
retoucher un peu au code fourni par le logiciel.
L'effet de toutes ces manipulations est
visible sur la Figure 3.
Grâce à ce logiciel, il
est aussi possible d'exporter le code sous Notepad et même
d'éxécuter le code immédiatement. Dans le cas où
votre but n'est pas de l'exécuter directement, il vous faudra
utiliser le programme cscript.exe (il est fournit par défaut
avec Windows et est accessible depuis cmd.exe).
Pour finir, il vous faut savoir que
même si nous n'avons pas présenté toutes les
classes WMI dans la section dédiée au Python, une très
grande majorité des classes (avec leurs variables associées)
sont accessibles depuis le Python.
Voici comment réaliser
simplement et rapidement des scripts WMI avec ce framework. Vous
pouvez maintenant compléter la réponse à la
question fatidique: vais-je utiliser le langage Python ou les autres
langages ?
Conclusion
Nous avons présenté dans
cet article les scripts WMI qui sont utilisés pour de
l'administration système et réseau mais aussi par
certains développeurs informatiques pour obtenir des
informations sur un système sans avoir à manipuler les
API win32 qui peuvent être assez complexes à utiliser
parfois. Nous avons commencé par montrer comment créer
de tels scripts en Python puis par l'intermédiaire d'un
framework de création de scripts WMI, avec d'autres langages
comme le VBScript, le C# ou encore le Visual Basic .NET. A vous de
choisir le langage qui vous convient le mieux.
Nzeka Gilbert
Nzeka Gilbert est un jeune étudiant
français de dix-neuf ans qui se passionne pour la
programmation et la sécurité informatique depuis l'age
de quatorze ans. Auteur d'un ouvrage de sécurité
informatique à l'âge de seize ans publié aux
éditions Hermès Sciences, il s'intéresse depuis
deux ans aux « malwares » et à la
cryptographie. White Hat à ces heures perdues, il a travaillé
pour FCI une filiale d'AREVA comme pen-tester et donne des formations
dans son école sur GNU/Linux et la sécurité. Il
est depuis peu entrepreneur et développe des services de
stockages en ligne et de sauvegarde sécurisée de
données.
