Expressions régulières : -match, Select-String, grep et sed

Une expression régulière (regex) est un motif qui décrit une famille de chaînes de caractères : « PC- suivi de quatre chiffres », « une adresse IPv4 », « une ligne qui contient Failed password ». Elle sert à vérifier une saisie, à chercher des lignes dans un journal et à extraire ou remplacer une partie d'un texte. PowerShell (avec -match, -replace, Select-String) et Bash (avec grep, sed et [[ =~ ]]) utilisent la même syntaxe de base, avec quelques différences que ce chapitre signale.

La syntaxe de base

Ancre ton motif dès que tu valides une saisie : \d{4} trouve quatre chiffres dans PC-004212, alors que ^PC-\d{4}$ exige que la chaîne entière soit PC- suivi d'exactement quatre chiffres.

Les quantificateurs sont gourmands : ".*" sur le texte "a" et "b" prend "a" et "b" en entier, du premier au dernier guillemet. Ajoute ? pour la version paresseuse, qui s'arrête au plus tôt : ".*?" prend "a". La version paresseuse existe en PowerShell et avec grep -P, pas dans les expressions étendues de grep -E et sed -E.

Vérifier avec -match en PowerShell

-match renvoie $true ou $false et, quand la gauche est une seule chaîne, remplit la variable automatique $Matches avec ce qui a été trouvé.

'PC-0042' -match '^PC-\d{4}$'        # True
'pc-0042' -match '^PC-\d{4}$'        # True : -match ignore la casse
'pc-0042' -cmatch '^PC-\d{4}$'       # False : -cmatch la respecte
'PC-00421' -match '^PC-\d{4}$'       # False : cinq chiffres

'srv-fichiers.ad.sorbier.example' -match '^(?<hote>[^.]+)\.(?<domaine>.+)$'
$Matches.hote                         # srv-fichiers
$Matches.domaine                      # ad.sorbier.example
$Matches[0]                           # srv-fichiers.ad.sorbier.example : toute la correspondance

(?<nom>…) est un groupe nommé : son contenu se lit dans $Matches.nom. Sans nom, les groupes sont numérotés $Matches[1], $Matches[2] dans l'ordre de leurs parenthèses ouvrantes.

Quand la gauche est un tableau, -match filtre : 'srv-ad', 'srv-web', 'srv-ad2' -match '^srv-ad' renvoie srv-ad et srv-ad2, et ne remplit pas $Matches.

Remplacer et découper

-replace remplace tout ce qui correspond. Dans le texte de remplacement, $1, $2 ou ${nom} reprennent les groupes. Écris ce texte entre apostrophes, sinon PowerShell remplace lui-même $1 par une variable vide avant que la regex ne s'en serve.

'Lefèvre Julie' -replace '^(\w+) (\w+)$', '$2 $1'           # Julie Lefèvre
'192.168.10.177' -replace '\.\d+$', '.0'                    # 192.168.10.0
'Facture   du  3/11' -replace '\s+', ' '                    # Facture du 3/11
'srv-ad, srv-ad2 ;srv-web' -split '\s*[,;]\s*'              # srv-ad, srv-ad2, srv-web

\w reconnaît les lettres accentuées en .NET : Lefèvre est bien un mot. Ce n'est pas le cas partout : en Bash, l'équivalent dépend des réglages de langue du système.

Chercher dans des fichiers avec Select-String

Select-String est le grep de PowerShell : il lit des fichiers (ou des chaînes reçues du pipeline) et renvoie les lignes qui correspondent, avec le nom du fichier, le numéro de ligne et les correspondances.

Voici un extrait d'un journal SSH exporté de srv-web, auth.log :

2026-11-03T02:14:07+01:00 srv-web sshd[4121]: Failed password for invalid user admin from 203.0.113.50 port 51234 ssh2
2026-11-03T02:14:11+01:00 srv-web sshd[4121]: Failed password for invalid user admin from 203.0.113.50 port 51240 ssh2
2026-11-03T02:15:02+01:00 srv-web sshd[4130]: Failed password for root from 198.51.100.23 port 40022 ssh2
2026-11-03T02:15:09+01:00 srv-web sshd[4130]: Failed password for invalid user test from 203.0.113.50 port 51302 ssh2
2026-11-03T07:58:40+01:00 srv-web sshd[5012]: Accepted publickey for mdiallo from 192.168.10.209 port 52114 ssh2: ED25519 SHA256:k3J9
2026-11-03T08:03:15+01:00 srv-web sshd[5077]: Failed password for mdiallo from 192.168.10.209 port 52190 ssh2
2026-11-03T09:41:52+01:00 srv-web sshd[5230]: Failed password for invalid user oracle from 198.51.100.23 port 40188 ssh2

Les adresses 203.0.113.x et 198.51.100.x sont réservées à la documentation : elles jouent ici le rôle d'adresses Internet. Compter les échecs par adresse source :

$motif = 'Failed password for (invalid user )?(?<compte>\S+) from (?<ip>[\d.]+)'
Select-String -Path .\auth.log -Pattern $motif |
    ForEach-Object { $_.Matches[0].Groups['ip'].Value } |
    Group-Object | Sort-Object Count -Descending | Select-Object Count, Name

Count Name
----- ----
    3 203.0.113.50
    2 198.51.100.23
    1 192.168.10.209

Chaque résultat de Select-String a une propriété Matches, dont les Groups donnent les groupes nommés. -SimpleMatch cherche un texte exact sans regex, -NotMatch inverse la recherche, -CaseSensitive respecte la casse, -Context 2 affiche deux lignes avant et après chaque correspondance.

Sur un serveur Windows, les échecs de connexion ne sont pas dans un fichier texte mais dans le journal de sécurité (événement 4625), que l'on lit avec Get-WinEvent : la regex sert alors à extraire des valeurs du champ Message. L'analyse des journaux de sécurité à grande échelle est le travail d'un SIEM comme Wazuh.

grep, sed et [[ =~ ]] en Bash

grep affiche les lignes qui correspondent à un motif. Ses options les plus utiles :

Le même comptage par adresse qu'en PowerShell :

grep "Failed password" auth.log | grep -oE 'from ([0-9]{1,3}\.){3}[0-9]{1,3}' | cut -d' ' -f2 | sort | uniq -c | sort -rn

      3 203.0.113.50
      2 198.51.100.23
      1 192.168.10.209

Les comptes inexistants que les attaquants ont essayés, sans doublons :

grep -oE 'invalid user [^ ]+' auth.log | cut -d' ' -f3 | sort -u

admin
oracle
test

Sur Debian 13, le journal d'authentification n'est plus un fichier /var/log/auth.log par défaut : il est dans le journal du système, que l'on lit avec journalctl -u ssh et que l'on filtre avec les mêmes grep. C'est la pratique du chapitre 13.

sed modifie un flux de texte ; sa commande s/motif/remplacement/ remplace, et \1, \2 reprennent les groupes. Avec -E, les parenthèses forment des groupes sans \.

sed -E 's/^([0-9-]+)T([0-9:]+)\+01:00 ([^ ]+) .*from ([0-9.]+).*/\1 \2 \3 \4/' auth.log | head -2

2026-11-03 02:14:07 srv-web 203.0.113.50
2026-11-03 02:14:11 srv-web 203.0.113.50

sed -i modifie un fichier sur place : sed -i 's/^PermitRootLogin yes/PermitRootLogin no/' /etc/ssh/sshd_config. Garde une copie avant (sed -i.bak … crée sshd_config.bak), et vérifie le résultat : une regex trop large modifie des lignes que tu ne voulais pas toucher.

Dans un script, [[ chaîne =~ regex ]] teste une regex étendue et range les groupes dans le tableau BASH_REMATCH :

ligne='Failed password for root from 198.51.100.23 port 40022 ssh2'
motif='for (invalid user )?([^ ]+) from ([0-9.]+)'
if [[ $ligne =~ $motif ]]; then
    echo "compte=${BASH_REMATCH[2]} ip=${BASH_REMATCH[3]}"
fi

compte=root ip=198.51.100.23

Range toujours le motif dans une variable et écris $motif sans guillemets à droite de =~ : entre guillemets, Bash chercherait le texte littéral et non la regex.

Des motifs prêts à l'emploi

Exercices

'PC-0042' -match '\d{4}'
'PC-004212' -match '^PC-\d{4}$'
'srv-web' -replace 'web', 'bdd'
'Diallo Moussa' -replace '^(\w+) (\w+)$', '$2.$1'
'a1b22c333' -replace '\d+', '#'
('srv-ad;srv-ad2;;srv-web' -split ';').Count

True
False
srv-bdd
Moussa.Diallo
a#b#c#
4

grep -c "Failed password" auth.log
grep "Accepted" auth.log
grep "Failed password" auth.log | sed -E 's/.*Failed password for (invalid user )?([^ ]+) from.*/\2/' | sort -u

admin
mdiallo
oracle
root
test

motif='^PC-[0-9]{4}$'
for n in PC-0042 PC-42 pc-0042 PC-00421; do
    if [[ $n =~ $motif ]]; then echo "$n : valide"; else echo "$n : invalide"; fi
done

PC-0042 : valide
PC-42 : invalide
pc-0042 : invalide
PC-00421 : invalide