Scripts windows



Références utiles :
Ss64.com, un site avec de bonne références
Bon tutoriel powershell

Le livre "Windows PowerShell" de Robin LEMESLE - Arnaud PETITJEAN aux éditions Eni.

Powershell



Bases


Powershell manipule et renvoie des objets, pas du texte : lorsqu'on utilisera un |, on transmettra un objet. Il s'appuie sur la technologie .NET. Un objet a des propriétés (informations sur eux) et des méthodes (actions qu'ils peuvent faire). Get-Member pour voir les méthodes et les propriétés des objets. Pas de différences entre majuscules et minuscules. Comme dans linux, on peut utiliser le symbole | pour faire un pipeline, c'est à dire connecter la sortie d'une commande avec l'entrée d'une autre.

On est pas obligé de préciser le nom des paramètres, powershell va essayer de les renseigner selon l'ordre dans lequel ils apparaissent dans l'aide. Par exemple, Move-Item -path test -destination repertoiretest aura le même effet que Move-Item test repertoiretest.


F7 : Afficher les dernières commandes tapées (entrée pour lancer, flèche droite pour modifier).
F8 : Fait défiler l'historique sur la ligne de commande.
F9 : Pour indiquer le numéro de la commande à répéter.
Page précédente : Remonter à la première commande.
Page suivante : Aller à la dernière commande.
CTRL+C : Stoppe l'instruction courante.
CTRM+pause : Ferme la console.

4 catégories de commandes :

-Cmdlet : Command-Applets, plusieurs centaines (dépend du nombre de rôles installés), fonctionne avec un verbe (Get-Verb pour voir la liste des verbes existants) et un nom, toujours au singulier. ;
-PowerShell Functions ;
-PowerShell Scripts ;
-Commandes Windows natives ;

Get-Help ou man : Recevoir de l'aide. Get-Help * pour recevoir de l'aide sur tout, Get-Help get-command pour recevoir de l'aide sur "get-command". On peut aussi souvent utiliser le paramètre "-?" derrière une commande pour afficher les mêmes informations. Il existe les paramètres "-detailed" et "-full" pour avoir plus d'informations.

get-command : Affiche les cmdlet disponibles. On peut faire get-command -verb write pour n'afficher que les cmdlet prenant en compte tel ou tel verbe, ou encore get-command -noun service. Quand on cherche une commande qui s'applique à des ordinateurs par exemple, on peut faire Get-Command *computer. On peut aussi faire Get-Command get* par exemple, pour avoir la liste des commandes commençants par "get".

Get-ChildItem ou dir : Obtient les éléments d'un emplacement. Ou peut utiliser "-Recurse" pour obtenir les éléments d'un sous dossier. ). "a" indique que le bit d'archive est activé, "r" que l'objet est en lecture seule, “h” qu'il est caché, et "s" que c'est un objet système. Pour voir les fichiers cachés, utiliser le paramètre "-Force". On peut utiliser des jockers, par exemple : Get-ChildItem c:\windows\ *.log. On peut combiner les attributs, par exemple ici on affiche les fichiers cachés ET (+) qui ne sont pas (!) des répertoires : Get-ChildItem c:\windows -attributes hidden+!directory. Affiche les fichiers cachés OU les répertoires (,) : Get-ChildItem c:\windows -attributes hidden,directory. On peut se servir de Get-Childtem pour obtenir une seule propriété d'un objet : (Get-ChildItem test1).CreationTime.

format-list : Formate le résultat d'une commande en liste. Par exemple, GetChildItem | format-list. Son alias est "fl". On peut choisir les prioriétés à afficher. Exemple : Get-ChildItem C:\Windows -Recurse | Format-List -Property FullName,CreationTime,LastWriteTime. Pour afficher tout ce qu'il est possible d'afficher : Get-ChildItem | fl *.

format-table : Similaire à la commande précédente, formate le résultat d'une commande en table. Par exemple, GetChildItem | format-table. Son alias est "ft". On peut choisir les paramètres à afficher. Par défaut toutes les colonnes ont la même tailles, on peut régler ça avec le paramètre "-autosize" (attention, si on active autosize, l'affichage des colonnes ne se fera qu'une fois que tout ce qui doit être affiché est calculé, donc à éviter dans les scripts qui prennent du temps). Il est également possible de grouper selon des propriétés identiques. Exemple : Get-ChildItem | Format-Table -property CreationTime, Name -autosize -groupby creationtimee.

Format-Wide : Formate le résultat d'une commande en affichant une seule propriété, par exemple uniquement le nom d'un fichier. Get-ChildItem | Format-Wide.

get-service / stop-service / start-service : Affiche/stoppe/démarre les services disponibles sur l'ordinateur. Pour ne voir que les services qui sont démarrés : get-service | where-object {$_.Status -eq 'Running'}. On peut filtrer par nom avec le paramètre "-name" ou "-display name" : Get-Service -name W32time. Là aussi il peut être intéressant de filtrer avec Format-List et Property : Get-Service | Format-List -Property Name, DisplayName, Status. Et pour combiner : Get-Service | Where-Object {$_.Status -eq 'Running'} | fl -property DisplayName, status.

Get-Alias / Set-Alias : affiche/créé des alias. Les alias créé ne sont valides que pour la session powershell en cours. Pour les garder, 2 solutions, soit les exporter et les importer avec Export-Alias et Import-Alias, soit modifier son fichier profile powershell ($profile pour voir le chemin -qui n'existe pas forcément sur le disque, on peut ajouter des commandes à ce profile, qui seront lancées au démarrage de powershell).

New-Item : Créé un nouvel objet, peut créer un fichier ou un autre répertoire si on est dans un répertoire, peut créer une clef dans la base de registre, une variable d'envrionnement si on est en train de les explorer... Par défaut créé dans le répertoire courant et demande le type. On peut aussi faire New-Item -Path c:\nouveaufichier -ItemType file -Force. On peut également remplir le fichier, un peu comme un touch sous linux, : new-item test -ItemType file -value "coucou tout le monde".

test-path : Test l'existence d'un chemin.

get-member : Affiche les propriétés et les méthodes des objets. Par exemple Get-ChildItem | Get-Member montre qu'on peut utiliser la propriété "LastWriteTime", ce qui permet de faire quelque chose comme Get-ChildItem -Path C:\ -Recurse | Where-Object {$_.LastWriteTime -gt (get-date).addDays(-1)}. Il est intéressant de créer une variable texte "var" et d'utiliser get-member.

Get-EventLog : Le contenu de l'observateur d'évènement.

Sort-Object : Classer les objets, par exemple Get-EventLog System | Group-Object eventid | Sort-Object Count -descending.

GetUnique : élimine les doublons d'une liste d'objets.

Convertto-HTML : Convertit la sortie d'une commande en HTML. Get-Process | ConvertTo-html | out-file “Processes.html”

Export-CSV : Exporter la sortie en csv (comma separated values, s'ouvre dans excel). Get-Process | Export-CSV Processes.csv.

get-process : Liste les processus en cour sur la machine.

Invoke-Item : Ouvre un fichier avec le programme par défaut (équivalent de cliquer dessus).

Rename-Item : Renomme un objet.

Remove-Item : Supprime un objet (fichier, clef de registre, variable d'environnement, selon le type de disque qu'on est en train d'explorer). Remove-Item test. On peut l'utiliser avec un jocker *. Penser qu'on peut la combiner avec get-ChildItem par exemple, avec un pipe Get-ChildItem C:\ Temp\* -Include *.txt -Recurse | RemoveItem. Utiliser le paramètre "-Force" pour supprimer un fichier caché, en lecture seule ou protégé.

move-Item element_a_bouger destination : Déplace un fichier ou un dossier dans un autre. Move-Item test2 test1 met le dossier test2 dans test1. On peut utiliser le jocker *. Si le dossier de destination n'existe pas, le dossier de départ sera renommé.

get-content : Lit le contenu d'un fichier, d'une variable d'environnement, d'une clef de registre...

set-location / get-location (ou pwd) : Pour accéder à un disque ou un dossier / afficher l'endroit où on se trouve.

PSDrive : Liste des disques "virtuels". Par exemple, on peut voir qu'on parcourir et utiliser la base de registre comme un disque car elle est listée par PSDrive comme "HKCU". Pour y accéder : Set-Location HKCU:. On peut également voir ici les variables d'environnement (Set-Location env:). Ces "disques" sont fournis par des "providers". Des fournisseurs peuvent être développés par des éditeurs tiers.

psprovider : Affiche la liste des fournisseurs qui offrent des "disques virtuels" pour naviguer dans la base de registre, les variables d'environnement etc comme s'il s'agissait d'un disque. Taper help nom_du_fournisseur pour de l'aide.

more : S'utilise après un pipe pour afficher page par page, par exemple get-command | page.

Where-Object, where : Sélectionne les objets qui lui sont envoyés ayant un certain paramètre spécifié. Par exemple Get-ChildItem c:\windows | Where-Object {$_.length -gt 32kb} ou encore Get-ChildItem c:\windows | Where-Object {$_.lastwritetime -gt '01/09/2014'}. Le terme "$_" indique qu'on traite l'objet courant. On analyse donc les propriétés "lastwritetime" ou "length" de l'objet courant. Il existe une syntaxe simplifiée qui ne fonctionne pas dans tous les cas, donc à éviter: Get-ChildItem c:\windows | Where length -gt 32kb.

Copy-Item objet_a_copier destination : copie un objet. Penser au paramètre "-recurse". Si le dossier de destination n'existe pas, il sera créé.

Write-Host : Envoie des données à la console, rien au pipeline, donc impossible d'écrire dans un fichier par exemple. A réserver à un usage informatif.

Write-Output : Envoie des données vers la sortie standard par défaut, ou vers autre chose. "Write-Output" est implicite lorsqu'on tape une variable.

Read-host : $a=Read-Host "Tapez une lettre"~, enregistre dans une variable le texte saisi l'utilisateur.

Paramètres courants



-whatif – Le Cmdlet n'est pas exécuté, donne simplement des informations sur ce qu'ils se passerait s'il l'était.
-confirm - Demande confirmation avant l'exécution de la commande.
-Verbose - Donne d'avantage de détails en exécutant la commande.
-debug - Donne des information pour le débug.
-ErrorAction - Demande au cmdlet de faire des actions telles que "continue", "stop", "silently continue", ou "inquire" en cas d'erreur.
-ErrorVariable - Stocke l'information sur l'erreur dans une variable spécifique.
-OutVariable - Stocke la valeur renvoyée dans telle variable.
-OutBuffer - Le nombre d'objets à mettre en cache avant d'enchainer sur la prochaine commande.

Redirection des flux


0=entrée standard (clavier) ; 1=sortie standard (écran) ; 2=Sorties d'erreur ; 3=Sortie pour les avertissements ; 4=Sortie verbeuse ; 5=Sortie pour le débug ; *=tous les flux.

Redirige vers un fichier texte en le recréant : echo "test">test.txt
Redirige vers un fichier texte en ajoutant à la suite : echo "test">>test.txt (on peut aussi utiliser Out-File si on a besoin de préciser l'encodage).

Variables


Powershell ne différencie pas les majuscules et les minuscules.

$_ : L'objet courant, permet de faire des commandes ciblant plusieurs objets du type Get-Service | Where-Object {$_Status -eq 'Stopped'}.

$PSversiontable : affiche la version de powershell.

$profile : affiche le chemin de son profil.

$PSHOME : Répertoire de powershell.

$Host : Information sur l'environnement powershell actuellement exécuté.

$PSDefaultParameterValues : modifier les paramètres par défaut de powershell. Vide par défaut.

$pid : Contient l'id du processus powershell entre train d'être exécuté.

$pwd : indique le répertoire actif.
Pour récupérer une variable d'environnement : $env:appdata

Pour afficher le contenu d'une variable, taper simplement son nom.

gettype() est une méthode pour récupérer le type d'une variable.

On peut saisir une plage de valeur en utilisant "..". Par exemple 1..10 affichera une liste de nombres de 1 à 10.

Le type des variable est déterminé automatiquement par powershell mais on peut aussi le forcer en l'indiquant entre crochets : [int]$a, [char]$b, [double]$c... Peut être intéressant dans un script avec prompt pour éviter que des mauvaises valeurs soient entrées.
On peut tester le type avec -is et isnot : $a -is [char].

Les opérateurs sont + - * / et % pour le modulo.

Tableau


Pour créer un tableau $a='a','b','c','d' ou $b=1,2,3,4. Pour afficher la première valeur du tableau $a, faire $a[0]. On peut afficher plusieurs valeurs en même temps en faisant $a[0,2,3] par exemple. Pour afficher toutes les valeurs des tableaux,il suffit de taper son nom ($a). Par défaut les éléments sont séparés par un saut de ligne, on peut les séparer par autre chose avec -join : $tab -join '|'. Pour concaténer 2 tableaux, utiliser '+'. Pour ajouter un élément à un tableau, on peut utiliser $a += "elementaajouter" ou "$a.Add("elementaajouter")". Impossible de supprimer un élément d'un tableau, il faut créer un nouveau tableau sans les valeurs que l'on ne veut pas : par exemple, pour sauter la valeur 4 : $b=$a[0..3+5]. On peut aussi utiliser Where-Object pour filtrer : $a=$a|Where-Object {$_ -ne 'b'} fait un nouveau tableau pour les valeurs n'étant pas égales à 'b'.

Un tableau peut utiliser d'autres types de clefs que les clefs numériques, on parle de tableau associatifs. Pour déclarer et afficher le contenu d'un tableau associatif :

PS U:\> $asso=@{lait=3;pain=1;confiture=5} PS U:\> $asso Name Value ---- ----- confiture 5 pain 1 lait 3 PS U:\> $asso['pain'] 1 PS U:\> $asso.pain 1 PS U:\> $asso.'pain' 1


On peut voir dans les propriétés d'un tableau (en utilisant Get-Member) qu'il existe la valeur "keys" et "values" pour lister facilement les valeurs et les clefs.

Comparaisons Pour effectuer des comparaisons, on utilise -eq (égal à), -ceq (égal au texte, en respectant la casse) -ne (non égal à), -gt (supérieur à), -ge (supérieur ou égal à), -lt (inférieur à), -le (inférieur ou égal). Si ces opérateurs sont appliqués à un tableau, ils retournent les valeurs trouvées (-eq est souvent utilisé pour savoir si un élément est dans un tableau).

On peut également utiliser -like et -notlike pour tester en utiliser un jocker qui signifiera "n'importe quel caractère, en n'importe quelle quantité". 'test' -like 'te*' renvoie true, 'test' -like 'ab*' renvoie false. Le caractère "?" permet de mettre un jocker pour un seul caractère : 'test' -like 'tes?' renvoie true, 'test' -like 'te*' renvoie false. Utiliser -clike et -cnotlike pour respecter la casse.

Pour les expressions régulière on utiliser -match et notmatch.

-in, -notin pour savoir si un objet est dans une collection.

-contains, -notcontains pour savoir si une collection contient un objet.

Opérateurs logiques -and (et), -or (ou), -not(non), !(non), -xor (ou exclusif).

(1 -eq 1) -and (2 -eq 2) renvoie true, (1 -eq 1) -and (2 -eq 1) renvoie false.

Opérateurs binaires -band, -bor, bnot, -bxor.

Boucles


While



#Affiche "lol" sans s'arrêter. $a=1 while ($a=1){ echo lol }


Do While


Très semblable à une boucle while sauf que l'instruction est exécutée au moins une fois.

#affiche "lol" sans s'arrêter. $a=1 do{ echo lola } while($a=1)


For



#Compte de 0 à 99. for($i=0;$i -lt 99;$i++){ echo $i }


Foreach




#Affiche chaque élément précédé de "->" $tableau='automobile','brouette','citroën','dacia' foreach ($element in $tableau){ write-host -> $element }



#Affiche "[nom du processus] a pour status [status] foreach($element in Get-Service){ "$($element.Name) a pour status $($element.status)" }


Une autre solution qui consomme plus de ressources processeur mais moins de mémoire :

#Affiche "[nom du processus] a pour status [status] Get-Service|Foreach{ "$($_.name) a pour $($element.status)" }


Switch


Pour tester plusieurs valeurs facilement :

#Un programme qui gagne tout le temps à pierre/papier/ciseaux $a=Read-Host switch($a){ "pierre"{"Papier ! J'ai gagné !"} "ciseau"{"Pierre ! J'ai gagné !"} "papier"{"Ciseaux ! J'ai gagné !"} default{"Il faut saisir `"pierre`", `"papier`" ou `"ciseaux`"..."} }


Fonctions


Pour appeler une fonction, il suffit de taper son nom.
Pour déclarer une fonction : function nom_de_la_fonction~{}

Pour retourner une fonction, il suffit que ça soit la dernière valeur :

function moitie { param ([float]$a) $a/2 } PS C:\> moitie 7 3,5

Exemple avec une fonction (qui affiche "lol") déclarée et appelée depuis la console :

PS U:\> function echolol{ >> "lol" >> } >> PS U:\> echolol lol


Les arguments éventuels vont dans la variable $arg[0], $arg[1], etc.

Au lieu d'utiliser des arguments, on peut utiliser des paramètres : à ce moment là, dans la fonction, il faudra indiquer une ligne : param([type]var1,[type]var2. Il vaut mieux travailler avec des paramètres que des variables car quand on fait un "Get-Help", on peut voir les paramètres des fonctions qu'on a créé.

Par exemple :


#rajoute "lol" derrière un message function echo_message_et_lol{ param ([string]$message) "$message lol" }



Gérer les erreurs




try { Mettre ici du code que l'on veut essayer d'exécuter. } catch { En cas d'erreur, on peut la gérer ici. } finally{ Mettre ici quelque chose qui doit s’exécuter dans tous le cas, erreur ou non. }


On peut récupérer le contenu de la dernière erreur dans la variable "$_". On peut récupérer le nom exact de l'erreur avec "$_.Exception.GetType().FullName"

Ce qui peut permettre de cibler les erreurs, par exemple :

catch [System.Management.Automation.MethodInvocationException]{ En cas d'erreur System.Management.Automation.MethodInvocationException, on peut la gérer ici. }


Fonctions filtres


Il existe égalements des fonctions filtres qui sont utilisées après un pipe en général pour filtrer les résultats.


filter Get-Oldfiles{ if($($_.CreationTime).year -lt 2010){ $_ } }


On peut utiliser "begin" et "end", utilisés une seule fois au début et à la fin, ainsi que l'instruction process.

filter Get-Oldfiles{ begin { "Liste des fichiers antérieurs à 2010...." $i=0 } Process { if($($_.CreationTime).year -lt 2010){ $_ $i=$i+1 } } End{ "$i fichier(s) trouvé(s)" } }


Texte



Guillemets


Les guillemets sont notamment utilisés dans le cas où un objet ait un espace, par exemple Get-ChildItem "c:\program files" ne fonctionnerait pas correctement sans guillemets.

On peut utiliser des guillemets simples ou double, la différence étant que les guillemets simples ne remplacent pas les variables par leur contenu.

Exemple :

PS C:\> $var="test" PS C:\> "$var" test PS C:\> '$var' $var


Lorsqu'on veut afficher les propriétés d'un objet, il faut englober la variable et sa propriété dans "$(" et ")". Par exemple, $(Get-ChildItem test1).Length donne la taille de test1, pour l'afficher, faire echo "La taille fait $($(Get-ChildItem test1).Length)".

Accent grave (backtick)


Le caractère d'échappement est l'accent grave `.
echo "Peut servir à afficher le caractère `" sans fermer la ligne."

Il peut également produire certains effets combinés à des lettres :
CaractèreEffet
`nSaut de ligne
`fSaut de page (à utiliser avec imprimantes)
`rRetour chariot (`r`n dans les fichers sous windows)
`aBip sur le haut parleur du PC
`bRetour arrière
`tTabulation horizontale
`vTabulation verticale
`0Null

Utilisé à la fin d'une ligne de commande, il indique que la commande continue ligne suivante.

Afficher du texte


Il suffit de mettre un texte entre guillemets pour l'afficher dans la console.
On peut aussi utiliser echo, Write-Ouput ou Write-Host. Ce dernier permet d'utiliser des couleurs, par exemple :
Write-Host "Ce texte est en rouge" -foregroundcolor "red"

Pour les scripts on peut aussi utiliser write-warning, write-debug~ et ~write-verbose.

Il existe l'operateur -replace pour remplacer du texte : PS C:\> "test" -replace "te","ap" renverra "apst". Il peut remplacer en utilisant une expression régulière.

Résultat d'une commande dans une variable


$adresse=[System.Net.Dns]::GetHostAddresses($Data) | out-string
Si on utilisait pas "out-string", le contenu de "$adresse" serait la commande "[System.Net.Dns]::GetHostAddresses($Data)" (et on ne peut pas faire de méthode split par exemple).

On peut également utiliser [string], par exemple : $loginAD=[string]$loginAD.

Pour concaténer du texte dans une variable, utiliser + : $a="bonjour" + " tout le monde". Il existe également l'opérateur -join (et son inverse, -split).


PS U:\> $tab='a','b','c' PS U:\> $tab -join ' ET ' a ET b ET c


Découper une chaine de texte en tableau


Il y a deux façon. La première, utilisant un opérateur :
$tabadresse=$adresses -split("delimiteur")

La deuxième, utilisant une méthode, découpera entre chaque "d", entre chaque "e", entre chaque "l", etc.
$tabadresse=$adresses.split("delimiteur ")


Voir/changer l'encodage



Voir la variable "$OutputEncoding" sous Powershell. On peut faire "$OutputEncoding = [Console]::OutputEncoding" pour donner de la cohérence. Pour changer : [System.Console]::OutputEncoding = [System.Text.Encoding]::UTF8

Here-string


Englober du texte dans @' et '@ permet de saisir du texte brut, avec sauts de lignes et autres intéprétés normalement. Pratique pour y mettre le contenu d'un fichier texte par exemple, sans devoir mettre un `r`n à chaque saut de ligne. Les variables ne sont pas interprétées, sauf si on englobe avec des guillemets double au lieu de simple (@" et "@).


PS C:\> @' >> Ceci est un test. >> Merci. >> '@ >> Ceci est un test. Merci.


Commentaires


Le symbole dièse (#) avant une ligne indique un commentaire.
Pour faire un bloc de commentaire, utiliser "<#" et "#>".

Exemple de script




Créer une variable, la mettre en majuscule :

$maVariable = 'Bonjour !' $maVariable.ToUpper() //affiche "BONJOUR !", c'est une méthode, noter les parenthèses $maVariable.length //affiche "9", c'est une propriété, noter l'absence de parenthèses


Récupérer les fichiers d'aide anglais et les mettre dans le dossier de l'aide en français :

Update-Help -UICulture en-us -Force $CurrentCulture = $Host.CurrentUICulture.Name If ($CurrentCulture -ne 'en-us'){ if ( -not (Test-Path $PSHOME\$CurrentCulture)){ $null = New-Item $PSHOME\$CurrentCulture -ItemType Directory } Copy-Item $PSHOME\en-us\* -Destination $PSHOME\$CurrentCulture }


Compter le nombre de cmdlet :
get-command -CommandType cmdlet | group-object Cmdlet ou get-command -CommandType cmdlet | Measure-Object

CMD


Voir/changer l'encodage


chcp

Les encodages sont :
437 United States ; 850 Multilingual (Latin I) ; 852 ; Slavic (Latin II) 855 ; Cyrillic (Russian) 857 ; Turkish 860 ; Portuguese 861 ; Icelandic 863 ; Canadian-French 865 ; Nordic 866 ; Russian ; 869 Modern Greek ; 1252 West European Latin.





Comparer deux fichiers


fc fichier1 fichier2

Boucle for


Affiche "test 1, test 2, test 3, test 4, test 5" :
FOR /L %i in (1,1,5) do echo test %%i

Robocopy



Copie depuis l'emplacement "c:\a" à "c:\b", /E demande de copier tous les sous-répertoires mêmes les vides, /M ne sauve que les fichiers avec le bit d'archive à 1 (et met le bit d'archive à 0 au passage) :
Robocopy C:\A C:\B /E /M

Liste des tâches



tasklist

Affiche les connexions actives



netstat

LISTEN : Attend une demande de connexion de la part d'un périphérique distant.
ESTABLISHED : Des données peuvent être échangées entre 2 périphériques.
TIME-WAIT : Entre 30 et 120 secondes, attend avant de fermer la connexion.
CLOSE-WAIT : A reçu le message FIN et en attente de se fermer.
SYN-SENT : Attend réponse à la requête de connexion.
SYN_RECEIVED : Attend validation de requête de connexion. Une attaque SYN flood se remarque par beaucoup de SYN_RECEIVED.

n pour éviter de résoudre les noms, a pour tout afficher, o pour savoir quel processus écoute.

netstat -ano

Affiche les interfaces


netsh int show int et netsh int ipv4 show int

Voir l'heure de sa machine



echo %time%

Voir son sid


A chaque utilisateur, groupe ou ordinateur est attribué un SID (sécurity identifier) composé du SID du domaine plus, à la fin, du RID (identifiant relatif). Le SID peut changer, par exemple si l'objet change de domaine. Le SID du compte administrateur se termine toujours par 500.

wmic useraccount get name,sid

Demande d'echo


A une adresse :
ping 1.2.3.4

A un nom de domaine (préférer plutôt nslookup pour tester un nom de domaine. Si on ping un nom de domaine, il y a d'abord une requête dns pour convertir le nom de domaine en ip.) :
ping test.lan

A un nom netbios :
ping MACHINE5

Le TTL que l'on voit apparaitre est celui envoyé par le serveur distant. Un serveur linux renverra en général un paquet avec un TTL de 64, s'il traverse un routeur avant d'arriver jusqu'à nous, on verra Réponse de 1.2.3.4 : octets=32 temps=2 ms TTL=63

Synchroniser l'heure sous windows



net stop w32time w32tm /config /syncfromflags:manual /manualpeerlist:"1.fr.pool.ntp.org" w32tm /config /reliable:yes net start w32time


Ou

w32tm /config /update /manualpeerlist:"0.fr.pool.ntp.org,0x8 1.fr.pool.ntp.org,0x8 2.fr.pool.ntp.org,0x8 3.fr.pool.ntp.org,0x8" /syncfromflags:manual

Pour simplement synchroniser :
w32tm /resync

L'intervalle de synchronisation automatique peut se définir dans "HKEY_LOCAL_MACHINESYSTEMCurrentControlSetServicesW32TimeParametersNtpServer".

Afficher le status de synchronisation de l'heure


w32tm /query /status

Affiche les routes et les numéros des interfaces réseaux


netstat -r ou route print

Ajouter une route sous windows


route ADD reseau_vers_lequel_aller MASK masque_sous_reseau passerelle

Affiche/modifie le compte utilisateur


net user

Affiche les addresses mac connues


Pratique quand un ping est bloqué par un pare-feu, on peut quand même vérifier si on arrive à voir la machine.
arp -a

La liste est vidée au bout de quelques minutes sans activité vers la machine, faire un ping vers une ip pour connaitre sa mac.

Vide le cache des adresses mac connues


arp -d

Outil Netbios


nbtstat

Tester les serveurs DNS


nslookup
Pour voir les enregistrements mx : set type=mx

Envoyer le résultat d'une commande vers un fichier texte


Comme dans linux, on peut utiliser ">" pour que la sortie s'effectue sur un fichier.

Par exemple, DCDIAG > c:log.txt.

Connaitre l'itinéraire vers un point


tracert 1.2.3.4

Utiliser tracert -d 1.2.3.4 pour éviter de résoudre les noms d'hôte et aller plus vite.

Peut aider à déterminer pourquoi un ping échoue en indiquant jusqu'à quel réseau il va.

L'outil tracert utilise le protocole ICMP pour faire plusieurs ping, avec un TTL (nombre de routeur maximum qu'il peut traversé avant d'être détruit) de plus en plus élevé (1, puis 2, puis 3...), car un routeur ne transmet pas un ping avec un TTL de 1, il renvoie l'erreur "Durée de vie TTL expirée lors du transit" (ICMP 11 Time Exceeded ) en indiquant son ip.

Monter un lecteur réseau



net use w: 1.2.3.4\serveurdossier

Avec demande de mot de passe :
net use x: \\ip__ou_adresse_du_serveur votremotdepasse /user:nomuser@domaine

Démonter un lecteur réseau


net use w: delete
Pour démonter tous les lecteurs :
NET USE * /DELETE /YES

Arrêter une session vers un chemin réseau


net session \1.2.3.4 /delete

net use \1.2.3.4 /delete

Il y a également des informations d’identifications présentes dans "panneau de config", "comptes utilisateurs", "gérer vos informations d'identification" (source).

On peut voir ces infos avec l'outil cmdkey. cmdkey /list

Plus d'info

Annuler la fermeture de windows


shutdown -a

Forcer la fermeture de windows


shutdown -s (éteins) -t (pour définir un temps en secondes) -f (force la fermeture) -t (compte à rebours en seconde à ajouter derrière) -m (pour une machine distante)

Détails

Redémarrage


shutdown-r

Redémarrage d'un PC distant


shutdown -i

Afficher le cache DNS


ipconfig /displaydns

Vide le cache DNS


ipconfig /flushdns

Trouver le maitre RID d'un domaine


dsquery server -hasfsmo rid

Lien symbolique


Permet de donner un autre chemin à un fichier.
C'est transparent pour les autres applis, ce qui permet par exemple de partager un film dans le répertoire "partage" tout en l'ayant bien classé dans le répertoire "films".

Imaginons un fichier MonFilm.mkv dans "C:\films\" qu'on voudrait aussi mettre dans le dossier "partage".

Dans le répertoire "partage", taper :
mklink "C:\partage\MonFilm.mkv" "C:\films\MonFilm.mkv"

On pourra ainsi accéder à MonFilm.mkv par "C:\partage\MonFilm.mkv" ou "C:\films\MonFilm.mkv" : ce sera le même fichier, il ne prendra qu'une seule fois de l'espace disque.

Le lien est affiché comme type "symlink" dans l'explorateur windows.

Afficher le hash d'un fichier


Exemple pour le MD5 : CertUtil -hashfile NomDuFichier MD5

Autohotkey



WheelRight::Send {XButton2} WheelLeft::Send {XButton1} XButton1::Send {XButton1} XButton1 & WheelUp::Send {Volume_Up} XButton1 & WheelDown::Send {Volume_Down} XButton1 & MButton::Send {Volume_Mute}



GT


Généralités


-Les "variables" sont en réalité toutes des constantes. Elles commencent par une lettre majuscule.
-Les propriétés (fields) commencent par une minuscule.
-On évite de toucher les classes commençant par cd_quelqueChose car ce sont des tables de références.
-Object requester permet de chercher l'instance d'un objet. Quand on ouvre une classe on a aussi une entrée "find instances" en haut qui permet de trouver
toutes les instances de cette classe.
-Si une fonction prend en argument une variable qui semble venir de nulle part, c'est qu'en réalité elle va la créer après avoir été exécutée.
-Des "workspaces" sont utilisés pour lancer les scripts.

Fenêtre des propriétés


-Lorsqu'on ouvre une entité, un petit marteau dans les cases de l'entité indique que c'est un champ calculé par une méthode.
-"Date effect" en bas : c'est la date à laquelle les modifs des contrats s'appliquent. "Date learn" : date de connaissance de la modification sur les contrats.
La date d'effet est souvent inférieur à la date de connaissance car des modifs sont faites sur les contrats puis on en prend connaissance. Par contre, pour des
actes futurs (par exemple des versements libres programmés), la date de connaissance peut être inférieure à la date d'effet.
-Links navigator repertorie tous les liens de l'objet qui vont pointer sur d'autres. Un dropdown menu en haut permet d'afficher les "reverse links", càd les
liens pointant VERS l'objet en cours.

Fonctions intéressantes


to_date : convertir une date au format Julien (nombre d ejours depuis 1800)
:type.date_to_str : convertir une date du format Julien à un format jj/mm/aaaa. DateFinVal=:type.date_to_str(get:Mandat.date_fin_val)

Trouver l'instance d'un objet


obj.find($package:classe, critères de recherche, variable pour stocker la/les solutions, façon de trier)

Exemple pour chercher une personne ayant le nom TORETTO :


:obj.find ($prsnorg:cp_prsn, [nm_st = "TORETTO"], Prsn,nil)

Exemple pour chercher une personne ayant le nom TORETTO (nil ne ramène que l'Oid, moins impactant pour la BDD)


:obj.find ($prsnorg:cp_prsn (nil), [nm_st = "TORETTO"], Prsn,nil)

Renvoyer toutes les solutions (m) pour les noms de personnes ayant %ETTO% dans le nom.


m:obj.find ($prsnorg:cp_prsn, [nm_st like "%ETTO%"], MesSolutionsDePersonne,nil)

Renvoyer toutes les solutions (m) dans la liste MaListe


m:obj.find ($prsnorg:cp_prsn, [nm_st in MaListe], MesSolutionsDePersonne,nil)

Renvoyer une liste contenant les solutions de personne ayant pour nom TORETTO


MaListeDeSolutionDesPersonnesSeNommantToretto = compute list (MesSolutionsDePersonne)
where
(
m:obj.find ($prsnorg:cp_prsn, [nm_st = "TORETTO"], MesSolutionsDePersonne, nil)
)

Renvoyer une liste contenant les solutions de personne ayant pour nom TORETTO


MaListeDeSolutionDesPersonnesSeNommantToretto = compute list (MesSolutionsDePersonne)
where
(
m:obj.find ($prsnorg:cp_prsn, [nm_st = "TORETTO"], MesSolutionsDePersonne, nil)
) &

MaListeDeSolutionDeContratDansLaListeDesPersonnesSeNommantToretto = compute list (MesSolutionsDeContrat)
where
(
m:obj.find ($header:cp_contract, l_owner_1 in MaListeDeSolutionDesPersonnesSeNommantToretto, MesSolutionsDeContrat, nil)
)


Renvoyer une liste contenant toutes les solutions pour les noms de personnes ayant %ETTO% dans le nom.



MaListeDeSolution = compute list (MesSolutionsDePersonnes) where ( m:obj.find ($prsnorg:cp_prsn, [nm_st like "%ETTO%"], MesSolutionsDePersonnes, nil) ) == Renvoyer une liste contenant toutes les solutions pour les noms de personnes ayant %ETTO% dans le nom (on met le nom dans le résultat) == MaListeDeSolution = compute list ([MesSolutionsDePersonnes,MonBelIdDePersonne]) where ( m:obj.find ($prsnorg:cp_prsn, [nm_st like "%ETTO%"], MesSolutionsDePersonnes, nil)& MonBelIdDePersonne=get:MesSolutionsDePersonnes.display_id )

Retrouver tous les actes ayant un certain n° de demande



:obj.find ($tcwrkmgt:cp_actvty, [extrnl_idntfr = "2018041200098490P"], MaSolutionDActes,nil) & m:obj.find($header:cp_contract,[l_owner_1==MaSolutionDePersonne],MesSolutionsDeContrat,nil)

Retrouver tous les contrats de TORETTO ?



:obj.find ($prsnorg:cp_prsn, [nm_st = "TORETTO"], MaSolutionDePersonne,nil) & m:obj.find($header:cp_contract,[l_owner_1==MaSolutionDePersonne],MesSolutionsDeContrat,nil)

Un peu dégueulasse à parcourir, les contrats et les flux (119 solutions...)



:obj.find ($prsnorg:cp_prsn, [nm_st = "TORETTO"], MaSolutionDePersonne,nil) & m:obj.find($header:cp_contract,[l_owner_1==MaSolutionDePersonne],MesSolutionsDeContrat,nil)& m:obj.find($investmt:cp_allctn_actvty_cntrct_cvrg,[l_cntrct==MesSolutionsDeContrat],MesSolutionsDeFluxDuContrat,nil);


Ici liste claire des contrats de Toretto (8 solutions avec des listes)



:obj.find ($prsnorg:cp_prsn, [nm_st = "TORETTO"], MaSolutionDePersonne,nil) & m:obj.find($header:cp_contract,[l_owner_1==MaSolutionDePersonne],MesSolutionsDeContrat,nil)& MaListeDeFluxParContrat = compute list(MesSolutionsDeFluxDuContrat) %on va constituer une liste des solutions de flux par contrat where ( m:obj.find($investmt:cp_allctn_actvty_cntrct_cvrg,[l_cntrct==MesSolutionsDeContrat],MesSolutionsDeFluxDuContrat,nil) )


Avec les descriptions des contrats, noter les crochets



:obj.find ($prsnorg:cp_prsn, [nm_st = "TORETTO"], MaSolutionDePersonne,nil) & m:obj.find($header:cp_contract,[l_owner_1==MaSolutionDePersonne],MesSolutionsDeContrat,nil)& MaListeDeFluxParContrat = compute list([MesSolutionsDeFluxDuContrat,MonBelIdDeFlux]) %on va constituer une liste des solutions de flux par contrat where ( m:obj.find($investmt:cp_allctn_actvty_cntrct_cvrg,[l_cntrct==MesSolutionsDeContrat],MesSolutionsDeFluxDuContrat,nil)& MonBelIdDeFlux=get:MesSolutionsDeFluxDuContrat.display_id )