Archives mensuelles : novembre 2014

WMI événements permanents

Windows Management Instrumentation (WMI) est une technologie Microsoft permettant de manager des serveurs et postes de travail distants à travers des scripts ou de la programmation.

Une des fonctionnalités de WMI qui est assez méconnue est la possibilité de créer de événements permanents.

Ces événements sont démarrés lorsque les conditions d’une query WQL sont remplies.

Dans cet article nous allons voir comment on peut mettre en place un événement permanent qui démarre lorsque une clé USB est insérée dans l’ordinateur.

Les événements permanents sont constitués de trois éléments:

  • Un filtre qui définit la query à exécuter.
  • Un consommateur (ou consumer), qui va consommer l’événement en exécutant un programme ou un script lorsque le filtre attrape l’événement.
  • Une liaison (ou bind) qui lie le filtre au consommateur.

Créons un filtre:

Définissons le langage pour la query:

Définissons la query:

Dans notre cas, la query sélectionne tous les événements dans la liste des événements de créations mais filtre pour récupérer que ceux qui concernent la création de disques logiques (win32_logicaldisk) et ceci toutes les 5 secondes.

Donnons un nom à notre filtre et définissons son espace de nommage:

Finissons la création du filtre, mais récupérons également son chemin d’accès, car il s’agit d’un filtre permanent, c-a-d définitif. Il restera même si on redémarre la machine. Nous avons besoin du chemin d’accès pour le supprimer.

Notre filtre créé, regardons maintenant le consommateur.

Définissons la commande à exécuter

Dans notre cas, nous allons invoquer un script Powershell qui regardera la lettre du lecteur USB. Si cette lettre n’est pas « O: » le script changera la lettre utilisée.

Définissons le path et l’exécutable pour le programme à démarrer:

Sauvegardons notre consommateur et récupérons le path;

Voilà notre consommateur et notre filtre sont prêts. Créons le lien entre les deux:

Indiquons le filtre et le consommateur:

Sauvegardons le lien et récupérons le path:

Regardons maintenant le script reassignDriveLetter.ps1.

En gros ce script va regarder la liste des drives sur l’ordinateur, et trouver celui est un drive USB. Si la lettre du drive n’est pas « O: » il la changera:

Si l’on veut supprimer ces événements on peut utiliser leur path:

 

Voici le script complet:

 

Partager ce contenu

Detecting REGIN with Powershell V3

Regin is a spyware that is making quite a bit of buzz, and Jeffrey Snover nicely gave a solution to detect it with Powershell:

Knowing that sig.txt was previously created from the MD5s from http://www.symantec.com/content/en/us/enterprise/media/security_response/whitepapers/regin-analysis.pdf

Issue is, this solution requires PS V4 due to

and we don’t all have it.

Here is a solution, not the best, but works with the provided MD5s and Powershell V3:

This solution is not a one liner, but hey, if you need it, means you don’t have Powershell V4 either.

PS. this solution is limited to files less than 2 gigabytes in size, and won’t be able to verify opened files.

Disclaimer: This code does not replace professional virus and spyware detection software and should be used as instructional only.

Partager ce contenu

La gestion des jobs Powershell

Une fonction fondamentale de Powershell est la possibilité d’exécuter des commandes en parallèle à travers les jobs.

Lorsqu’on écrit des scripts, les commandes s’exécutent au fur et à mesure, de façon séquentielle. Mais il est parfois souhaitable d’exécuter les commandes en parallèle afin d’optimiser l’exécution dans son ensemble.

Par exemple si je devais auditer les ACL de tous les shares sur un serveur de fichier, je pourrais considérer  de créer un job pour chaque share et ainsi exécuter les audits en parallèle.

Ou si je devais convertir des fichiers d’un format vers un autre, la parallélisation devient intéressante, car je pourrais ainsi utiliser l’hyperthreading de mon CPU .

Par contre qui dit jobs en parallèle dit gestion des jobs, car si j’ai 10.000 shares à parser, je ne veux pas créer 10.000 jobs en parallèle, mais contrôler le nombre de jobs qui s’exécutent.

Imaginons une fonction appelée Convert-File qui prend en paramètres des variables propres à la conversion de fichiers.

Je peux l’appeler de façon séquentielle

Dans ce cas je dois attendre que file1 soit converti pour commencer la conversion de file2.

Je vais alors modifier ma fonction pour qu’elle crée des jobs Powershell.

J’utilise Start-Job en créant un scriptblock, ou bloc de code, à qui je passe les arguments en paramètre à travers -ArgumentList. Ceci est nécessaire car les variable $density, $quality, $source et $target sont des variables locales et elles appartiennent à la console Powershell actuelle, en créant un job, je crée une nouvelle console, et donc un nouveau contexte et donc mes variables locales ne seront pas visibles. Pour les référencer dans le script block on peut utiliser les éléments de $args, qui est l’array passée à travers  -ArgumentList. L’ordre sera le même que celui créé, donc attention à ça.

A chaque fois que j’appelle Convert-File un job est créé. Et ceci peut poser problème car aucune gestion des jobs en cours n’est faite. Du coup si j’appelle ma fonction énormément de fois, mon système risque d’avoir des problèmes. Nous avons besoin d’un peu de gestion.

Pour récupérer la liste des jobs démarrés, nous pouvons utiliser la cmdlet Get-Job. Nous pouvons envoyer le résultat de Get-Job vers Where-Object à travers un pipe pour vérifier la variable membre State, qui nous dit si le job est Running, ou Completed. Ceci nous donnera la liste des jobs en cours d’exécution.

$running est un array qui possède un compteur que nous pouvons vérifier pour savoir combien de jobs sont en cours d’exécution.

Avec cette information nous pouvons limiter le nombre de jobs. Car nous pouvons attendre qu’un de ces jobs soit fini pour démarrer le suivant.

On fera ceci avec Wait-Job en utilisant le paramètre -Any, ce qui veut dire que dés que un des jobs actuellement en cours est terminé, Wait-Job redonne la main.

Donc si on crée une boucle, on vérifie que le nombre de jobs en cours n’est pas supérieur à une variable qui définit le nombre de jobs maxi et attend qu’un de ces jobs soit terminé avant de démarrer le suivant.

Voici une vue globale de la fonction qui gère les jobs:

Quand j’utilise des jobs, je termine toujours le script par

Ceci permet de s’assurer que tous les jobs sont bien finis avant de continuer ainsi que de récupérer les outputs de toutes les consoles et ainsi savoir si tout s’est bien passé.

Partager ce contenu

Isilon REST API

Dans cet article nous regardons l’utilisation des API REST (REpresentational State Transfer) pour accéder à un cluster EMC Isilon.

Cette approche est particulièrement intéressante car elle permet de s’affranchir de SSH pour accéder à Isilon à partir de Powershell. Ce qui rend la chose très « light ».

Le script ci-dessous définit une cmdlet appelée Get-IsilonInfo qui prend comme paramètres :

  • le serveur Isilon
  • Credentials, le compte doit avoir le privilege ISI_PRIV_LOGIN_PAPI.
  • La ressource demandée qui doit être une valeur parmi les suivantes:
    • « Quotas »
    • « Shares »
    • « Schedules »
    • « Jobs »
    • « Open Files »
    • « Sessions »
    • « SMB Settings »
    • « Job Types »
    • « Job Reports »
    • « Job Statistics »
    • « Sync »
    • « Quota Summary »
    • « Quota Reports »
    • « Snapshot Schedules »
    • « Snapshot Pending »
    • « Access Zones »

La cmdlet Get-IsilonInfo se base sur Invoke-RestMethod pour effectuer l’opération et récupérer le résultat. Ce résultat sera un objet prêt à l’emploi.

 

Voici quelques exemples d’utilisation

Partager ce contenu

Ajouter une page dans un document Word existant

Voici comment ajouter une page à un document Word à un emplacement voulu.

Imaginons un document Microsoft Word, avec n pages. Nous voulons insérer une page après la première et y placer notre curseur.

Avec Word il n’est pas simple de trouver la fin d’une page. Et ça se complique si le document ne contient qu’une page, ou plusieurs. Tous ces cas doivent être gérés.

Créons notre application Word et rendons la visible ainsi on verra ce qui se passe.

Ouvrons maintenant un document.

Nous repositionnons le curseur à la première page, car le document peut être sauvegardé dans une page successive:

Maintenant la partie pas classique du tout.

Nous allons nous appuyer sur un bookmark caché de Word appelé « \page » et le selectionner.

Nous allons nous replier à la fin de cette selection, Ce qui nous amène à la fin de la page.

Maintenant nous allons créer ou plutôt insérer une nouvelle page.

Et finalement nous nous repositionnons au début de la 2ème page.

 

Voici le code complet:

Partager ce contenu