Sécurité des systèmes — mise en œuvre

Objectif et principes

Pourquoi durcir ? Pour réduire la surface d’attaque, ralentir l’adversaire et limiter l’impact en cas d’incident. Un poste correctement configuré transforme une compromission probable en tentative détectée et contenue.

Comment s’y prendre ? Appliquer la défense en profondeur, le moindre privilège, la standardisation par baselines et l’automatisation (GPO, MDM, IaC). Chaque règle doit être justifiée (risque visé) et vérifiable (contrôle, métrique).

Sommaire rapide

• Méthode en 6 étapes
• Windows — durcir sans casser
• Linux — principe de moindre privilège partout
• macOS — sécurité intégrée, politique claire
• Contrôler et prouver la conformité
• Hygiène système — règles essentielles
• Ressources

Méthode en 6 étapes

1. Cartographier les usages et expositions (utilisateur, serveur, développeur; internet, interne, admin).
2. Choisir une baseline de départ (CIS/ANSSI). Définir ce qui est obligatoire, recommandé, dérogatoire.
3. Réduire la surface: désinstallation, services inutiles, ports fermés, macros et exécutables non approuvés.
4. Renforcer identités et accès: MFA, coffres à secrets, séparation des rôles, sessions privilégiées jetables.
5. Visibilité: journalisation riche, détection locale (Sysmon/auditd/Unified Logging), centralisation.
6. Maintenir: mises à jour, correctifs de configuration, audits périodiques, remédiation automatisée.

Windows — durcir sans casser

Pourquoi

Windows équipe une large part des postes et serveurs; il concentre identités, bureautique et accès distants. Les attaques visent l’escalade locale, le vol de secrets et le mouvement latéral.

Comment

• Baselines : appliquer les Microsoft Security Baselines + CIS via GPO/Intune.
• Comptes & secrets : LAPS (Local Admin Password Solution), interdire comptes locaux partagés; MFA; sessions d’admin dédiées.
• Contrôles d’exécution : AppLocker/WDAC; SmartScreen; blocage des macros non signées; PowerShell en Constrained Language Mode pour les non‑admins.
• Durcissement réseau : pare‑feu actif, SMBv1 et services hérités désactivés, NLA obligatoire pour RDP, restriction NTLM.
• Protection des identifiants : Credential Guard/LSA Protection; désactiver la mise en cache des hachés si possible.
• Chiffrement : BitLocker avec TPM + PIN sur portables; chiffrement des supports amovibles.
• Détection : Sysmon avec configuration réduite au bruit utile; transfert vers SIEM (WEF).
• Mise à jour : Windows Update for Business; canaux différenciés pilote/serveur; inventaire de versions.

# Pare-feu activé
netsh advfirewall set allprofiles state on

# Désactiver SMBv1 (poste)
Dism /online /Disable-Feature /FeatureName:SMB1Protocol

# Forcer NLA pour RDP
reg add "HKLM\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp" /v UserAuthentication /t REG_DWORD /d 1 /f

# LSA Protection
reg add "HKLM\SYSTEM\CurrentControlSet\Control\Lsa" /v RunAsPPL /t REG_DWORD /d 1 /f

# AppLocker - par défaut refuser, autoriser éditeurs approuvés (exemple conceptuel)
# Utiliser les stratégies via GPO/Intune pour la mise en production

Linux — principe de moindre privilège partout

Pourquoi

Linux propulse serveurs et conteneurs. Les compromis viennent d’expositions réseau, de services superflus et de permissions trop larges.

Comment

• Paquets & services : supprimer ce qui est inutile; systemctl disable --now pour les daemons non requis; listes d’allow‑list.
• SSH : clés uniquement, PermitRootLogin no, PasswordAuthentication no, ciphers modernes, port knocking si pertinent.
• Firewall : nftables ou ufw par défaut deny; n’ouvrir que le nécessaire; journaliser les drops.
• MAC : SELinux (Enforcing) ou AppArmor (Complaining → Enforcing) selon distro.
• Journalisation : auditd règles clés (auth, sudo, accès /etc/passwd, /etc/shadow, changements de capabilities).
• Montages : options nodev,nosuid,noexec sur partitions applicatives et /tmp séparé; umask stricte.
• Sudo : pas d’admin permanents; groupes dédiés; enregistrements; 2FA PAM pour accès privilégiés.
• Kernel : durcissements sysctl (IP spoofing, redirects, SYN cookies, ASLR).
• Mises à jour : dépôts officiels, correctifs de sécu priorisés, redémarrages planifiés (kpatch/UKI si dispo).

# SSH
sudo sed -i 's/^#\?PasswordAuthentication .*/PasswordAuthentication no/' /etc/ssh/sshd_config
sudo sed -i 's/^#\?PermitRootLogin .*/PermitRootLogin no/' /etc/ssh/sshd_config
sudo systemctl reload ssh

# UFW
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22/tcp
sudo ufw enable

# sysctl (réseau + ASLR)
cat <<'EOF' | sudo tee /etc/sysctl.d/99-hardening.conf
net.ipv4.conf.all.rp_filter = 2
net.ipv4.conf.all.accept_source_route = 0
net.ipv4.conf.all.accept_redirects = 0
net.ipv4.tcp_syncookies = 1
kernel.randomize_va_space = 2
EOF
sudo sysctl --system

# auditd de base
sudo apt-get install -y auditd audispd-plugins
sudo systemctl enable --now auditd

macOS — sécurité intégrée, politique claire

Pourquoi

macOS dispose d’une sécurité native forte (SIP, Gatekeeper, TCC). Le risque vient des dérogations, des profils hétérogènes et des extensions non gérées.

Comment

• Chiffrement : FileVault obligatoire (clé escrowing MDM).
• Exécution : Gatekeeper strict; notarisation requise; restreindre les extensions noyau (kext) et autorisations TCC via profils.
• Services distants : désactiver partage d’écran, SSH/Remote Login si non utilisé; forcer mot de passe à la sortie de veille.
• Firewall & filtrage : pare‑feu applicatif activé; filtrage de contenu (Network Extension) si EDR présent.
• Visibilité : Unified Logging; collectes centralisées; règles de détection adaptées à l’ecosystème Apple.
• Mise à jour : politiques d’auto‑update macOS et XProtect/MRT via MDM; fenêtres de maintenance gérées.

# État FileVault
fdesetup status
# Mot de passe exigé après veille (immédiat)
defaults write com.apple.screensaver askForPassword -int 1
defaults write com.apple.screensaver askForPasswordDelay -int 0
# Désactiver accès distant si inutile
sudo systemsetup -setremotelogin off
sudo launchctl unload -w /System/Library/LaunchDaemons/ssh.plist 2>/dev/null || true
# Activer pare-feu
sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setglobalstate on

Contrôler et prouver la conformité

• Mesures techniques : présence de règles (GPO/MDM), état des services, versions, options de montage, paramètres sysctl.
• Mesures d’usage : comptes actifs, journaux d’authentification, incidents bloqués, temps moyen de correction.
• Rapports : exporter écarts vs baseline, plan d’action par risque, validation par échantillonnage.

Annexes — Check‑lists express par OS

Aide‑mémoire opérationnel pour valider l’essentiel en quelques minutes par poste/serveur.

Contrôles de conformité automatisables

Commandes rapides pour vérifier l’application des points clés.

# Protection temps réel / anti‑altération
PowerShell -NoProfile -Command "Get-MpComputerStatus | Select-Object RealTimeProtectionEnabled,TamperProtectionEnabled"

# BitLocker et protecteurs
PowerShell -NoProfile -Command "Get-BitLockerVolume | Select-Object MountPoint,ProtectionStatus,VolumeStatus,KeyProtector"

# Pare-feu (3 profils)
PowerShell -NoProfile -Command "Get-NetFirewallProfile | Select-Object Name,Enabled,DefaultInboundAction,DefaultOutboundAction"

# Exécution RDP (NLA)
PowerShell -NoProfile -Command "Get-ItemProperty -Path 'HKLM:\\SYSTEM\\CurrentControlSet\\Control\\Terminal Server\\WinStations\\RDP-Tcp' -Name UserAuthentication"

# SMBv1
PowerShell -NoProfile -Command "Get-WindowsOptionalFeature -Online -FeatureName SMB1Protocol | Select-Object State"

# SSH durci
sshd -T | egrep '^(passwordauthentication|permitrootlogin)'

# Pare-feu
sudo ufw status verbose || sudo nft list ruleset | head -n 50

# Options de montage critiques
findmnt -no OPTIONS / /tmp /var /home 2>/dev/null

# Durcissements noyau / MAC
sysctl -n kernel.randomize_va_space net.ipv4.conf.all.rp_filter net.ipv4.conf.all.accept_redirects
(getenforce 2>/dev/null || true); (aa-status 2>/dev/null || true)

# Audit
systemctl is-enabled auditd 2>/dev/null; sudo auditctl -l | head -n 10

# FileVault / Pare-feu / Gatekeeper
fdesetup status
/usr/libexec/ApplicationFirewall/socketfilterfw --getglobalstate
spctl --status

# Accès distant / verrouillage d'écran
sudo systemsetup -getremotelogin
defaults read com.apple.screensaver askForPassword 2>/dev/null || echo "askForPassword not set"

Hygiène système — règles essentielles (adaptées des 42 règles ANSSI)

Focalisé sur les systèmes (postes et serveurs). Chaque règle présente le pourquoi et le comment, avec déclinaisons Windows, Linux, macOS.

1. Règle 01 — Inventorier et normaliser

   Pourquoi : sans inventaire fiable, impossible de patcher, durcir et contrôler. Comment : tenez une CMDB légère (ou inventaire MDM/Intune), affectez chaque machine à un profil (utilisateur, admin, serveur, dev) et à une baseline donnée.

   • Windows : inventaire Intune/Defender, étiquettes Azure AD; Rationaliser les éditions/versions.
   • Linux : inventaire via Ansible/osquery; tags (prod/dev).
   • macOS : inventaire Jamf/Intune, Smart Groups, profils de configuration.

2. Règle 02 — Baselines de configuration sécurisées

   Pourquoi : un socle commun limite les écarts et les régressions. Comment : appliquez des baselines (CIS/ANSSI/Microsoft/Apple) adaptées par profil et maintenues comme du code (Git).

   • Windows : Windows Security Baselines via GPO/Intune; WDAC/AppLocker.
   • Linux : CIS benchmark par distro; Ansible pour sysctl, services, permissions.
   • macOS : Apple Platform Security + profils MDM (TCC, Gatekeeper, FileVault, updates).

3. Règle 03 — Minimiser services et logiciels

   Pourquoi : moins il y a d’éléments, moins il y a d’attaques possibles. Comment : images « golden » minimales; désinstaller les applications inutiles; désactiver les services non requis; fermer les ports.

   • Windows : désactiver SMBv1, Telnet, services hérités; rôles/Features stricts.
   • Linux : systemctl disable --now daemons inutiles; supprimer paquets orphelins.
   • macOS : désactiver partages, Remote Login, AirDrop si non nécessaire; limiter kext/extensions.

4. Règle 04 — Gérer les comptes locaux et mots de passe

   Pourquoi : les comptes locaux partagés facilitent l’escalade. Comment : un identifiant par personne; rotation automatique des mots de passe d’admin local; coffre à secrets.

   • Windows : LAPS / Windows LAPS; interdire comptes locaux administrateurs partagés.
   • Linux : pas de login direct root; comptes nominaux + sudo journalisé; 2FA PAM pour admin.
   • macOS : admin local unique, géré par MDM; rotation du secret; suppression des comptes inactifs.

5. Règle 05 — Moindre privilège et séparation des rôles

   Pourquoi : limiter l’impact d’un compte compromis. Comment : comptes d’usage sans admin; comptes d’admin séparés; élévation contrôlée et tracée.

   • Windows : UAC renforcé; JEA pour PowerShell; groupes AD spécifiques par tâches.
   • Linux : sudo granulaires; doas ou polkit selon besoin; pas d’admin permanent.
   • macOS : élévation via outils MDM/PPPC; pas d’admin quotidien; approbations TCC minimales.

6. Règle 06 — Authentification forte pour les comptes à privilèges

   Pourquoi : les accès privilégiés sont ciblés. Comment : MFA obligatoire (FIDO2/TOTP), contrôle des sessions et bastion pour accès distants.

   • Windows : MFA Azure AD; AADJ/Hybrid; ADFS ou Conditional Access; bastion RDP.
   • Linux : PAM + TOTP/FIDO2 pour sudo/SSH; accès via jumphost; clés SSH signées.
   • macOS : MFA IdP/MDM; profils SSO; restrictions d’accès admin via Smart Groups.

7. Règle 07 — Postes d’administration dédiés

   Pourquoi : réduire le risque d’attaque sur navigateur/mail. Comment : postes d’admin durcis (PAW), sans messagerie ni navigation ouverte, réseau restreint.

   • Windows : GPO spécifiques; WDAC strict; accès RDP/WinRM sur segments d’admin uniquement.
   • Linux : VM/host dédié; ssh sortant vers cibles d’admin; pas de surf/mail.
   • macOS : session/rôle d’admin séparé; profil réseau MDM dédié.

8. Règle 08 — Contrôle d’exécution et liste blanche d’applications

   Pourquoi : bloquer l’exécution non approuvée. Comment : politiques d’allow‑list par éditeur/haché, et restriction des scripts.

   • Windows : WDAC/AppLocker; SmartScreen; PowerShell Constrained Language pour non‑admins.
   • Linux : SELinux/AppArmor politiques ciblées; noexec sur répertoires temporaires.
   • macOS : Gatekeeper; notarisation; Santa en liste blanche.

9. Règle 09 — Chiffrement des disques et supports

   Pourquoi : limiter l’exploitation d’un vol/perte. Comment : chiffrement intégral + escrow des clés + chiffrement des périphériques amovibles.

   • Windows : BitLocker (TPM+PIN sur portables); chiffrement USB via politiques.
   • Linux : LUKS2; /home et données sensibles chiffrées; gestion des clés en coffre.
   • macOS : FileVault obligatoire; clé de récupération escrow MDM.

10. Règle 10 — Pare-feu hôte et durcissement réseau

    Pourquoi : segmenter au plus près de la ressource. Comment : politique par défaut « deny », ouverture minimale, journalisation des rejets.

    • Windows : pare‑feu Windows activé tous profils; règles ciblées; SMB signing; NTLM restreint.
    • Linux : nftables/ufw; limiter ICMP; saisir logs des drops.
    • macOS : pare‑feu applicatif; Network Extension si EDR/filtrage réseau.

11. Règle 11 — Journalisation et audit

    Pourquoi : détecter, comprendre, prouver. Comment : activer des journaux utiles (auth, élévation, exécution), horodatage synchronisé, centralisation.

    • Windows : Sysmon (bruit maîtrisé), WEF vers SIEM, logs PowerShell/ScriptBlock.
    • Linux : auditd règles clés (auth, sudo, changements sensibles), journald → SIEM.
    • macOS : Unified Logging; événements TCC; osquery pour vues système.

12. Règle 12 — Mise à jour OS, logiciels et microcodes

    Pourquoi : réduire la fenêtre d’exploitation. Comment : canaux de mise à jour, correctifs sécurité prioritaires, redémarrages planifiés.

    • Windows : Windows Update for Business; anneaux pilote/large; WSUS si besoin.
    • Linux : dépôts officiels; unattended-upgrades ou équivalent; maintenance régulière.
    • macOS : politiques d’auto‑update macOS et XProtect/MRT via MDM;

13. Règle 13 — Démarrage sécurisé et firmware

    Pourquoi : bloquer les implants bas niveau. Comment : Secure Boot/UEFI/SIP, mots de passe firmware, boot sur disques approuvés uniquement.

    • Windows : Secure Boot; TPM; verrou UEFI; désactiver boot externe.
    • Linux : Secure Boot avec shim/sbctl; verrous BIOS; chargeurs signés.
    • macOS : Startup Security Utility (T2/Apple Silicon) sur « Full Security »; désactiver boot externe.

14. Règle 14 — Maîtriser macros et contenus actifs

    Pourquoi : vecteur d’intrusion courant. Comment : bloquer macros non signées, activer Protected View, isoler les documents non fiables.

    • Windows : stratégies Office (bloquer internet macros), Windows Defender ASR.
    • Linux : suites bureautiques durcies, ouverture par défaut en lecture seule.
    • macOS : Gatekeeper + quarantaine; restrictions PPPC pour accès fichiers.

15. Règle 15 — Navigateur et applications client durcis

    Pourquoi : la navigation expose le SI. Comment : politiques de navigateur, mises à jour auto, extensions contrôlées, sandbox.

    • Windows : politiques Edge/Chrome; isoler sites sensibles (IE Mode/Edge Isolation); SmartScreen.
    • Linux : politiques pour Firefox/Chromium; sandbox flatpak si pertinent.
    • macOS : profils de nav MDM; limiter extensions; Safari sandbox + iCloud Keychain géré.

16. Règle 16 — Périphériques amovibles et radios

    Pourquoi : source d’introduction de code et fuite de données. Comment : contrôle/ban des USB, chiffrement obligatoire, radios désactivées si inutiles.

    • Windows : politiques de contrôle des périphériques; chiffrement USB; désactiver AutoRun.
    • Linux : usbguard; montage noexec par défaut; audit des connexions USB.
    • macOS : restrictions via MDM; chiffrement des supports; AirDrop limité.

17. Règle 17 — Scripts et shells sous contrôle

    Pourquoi : scripts = automatisation, mais aussi exécution silencieuse. Comment : journaliser, signer, restreindre l’interpréteur.

    • Windows : PowerShell CLM pour non‑admins; logs ScriptBlock; exécution signée.
    • Linux : sudo sans NOPASSWD; chemins $PATH propres; umask strictes.
    • macOS : limiter osascript/Automator via TCC; logs Unified; signatures.

18. Règle 18 — Accès distants OS

    Pourquoi : RDP/SSH sont des portes d’entrée. Comment : authent forte, chiffrement, limitation d’exposition, bannissement des mots de passe.

    • Windows : RDP avec NLA; limiter aux groupes; pas d’exposition directe internet; MFA.
    • Linux : SSH clés seules; PermitRootLogin no; ciphers modernes; 2FA.
    • macOS : Remote Login désactivé par défaut; accès par groupes restreints; logins audités.

19. Règle 19 — Partitions, permissions et durcissements noyau

    Pourquoi : contenir l’exécution et l’escalade. Comment : séparer données/systèmes; options de montage; protections mémoire.

    • Windows : Exploit Protection; ASR; Control Flow Guard; SRP si héritage.
    • Linux : nodev,nosuid,noexec sur /tmp et applis; sysctl (ASLR, rp_filter, redirects).
    • macOS : SIP actif; système signé en lecture seule (SSV); sandbox applicatives.

20. Règle 20 — Anti‑malware/EDR

    Pourquoi : détection en temps réel et visibilité post‑incident. Comment : agent EDR/antimalware déployé et géré, exclusions minimales et justifiées.

    • Windows : Defender for Endpoint; tamper protection; onboarding SIEM.
    • Linux : EDR compatible (eBPF/audit); signatures + règles de comportement.
    • macOS : EDR natif compatible TCC/Network Extension; politiques via MDM.

21. Règle 21 — Sauvegardes système et restauration

    Pourquoi : la résilience prime quand la prévention échoue. Comment : 3‑2‑1, sauvegardes hors portée des comptes compromis, tests de restauration réguliers.

    • Windows : sauvegardes d’images système; sauvegarde des clés BitLocker (AD/Azure).
    • Linux : borg/restic chiffrés; snapshots LVM/Btrfs; hors ligne.
    • macOS : Time Machine chiffré; clé FileVault conservée; restauration testée.

22. Règle 22 — Conformité et remédiation automatique

    Pourquoi : éviter la dérive. Comment : évaluer la conformité périodiquement et corriger automatiquement.

    • Windows : Compliance policies Intune; Desired State Configuration (DSC).
    • Linux : Ansible/Augeas; OpenSCAP/CIS‑CAT pour évaluer/corriger.
    • macOS : Smart Groups + scripts de remédiation MDM; osquery packs.

23. Règle 23 — Cloisonnement applicatif et accès aux données

    Pourquoi : réduire l’impact des exploits applicatifs. Comment : sandbox et politiques d’accès aux fichiers/capacités.

    • Windows : Windows Sandbox/WDAG pour navigations à risque; règles TCC équivalentes via WDAC.
    • Linux : AppArmor/SELinux profils dédiés; systemd sandboxing (ProtectSystem, PrivateTmp).
    • macOS : TCC restrictif; sandbox apps; volumes dédiés en noexec si besoin.

24. Règle 24 — Hôtes de conteneurs et VM

    Pourquoi : la sécurité des charges dépend de l’hôte. Comment : isoler, limiter les privilèges, et tenir l’hôte à jour.

    • Windows : isoler Hyper‑V; images signées; pas d’exécutions Docker privilégiées sur postes.
    • Linux : rootless containers; seccomp/AppArmor; user namespaces; mises à jour.
    • macOS : hyperviseur à jour; limiter accès aux fichiers via TCC; pas d’extensions noyau non nécessaires.

25. Règle 25 — Verrouillage automatique des sessions

    Pourquoi : empêcher l’accès opportuniste. Comment : délai court d’inactivité et exigence de mot de passe au réveil.

    • Windows : stratégie Interactive logon: Machine inactivity limit (≤ 10 min) ; demander mot de passe à la sortie de veille ; option Ctrl+Alt+Suppr.
    • Linux : DE policy (GNOME/KDE) : lock ≤ 10 min ; loginctl lock-sessions côté admin ; shells : TMOUT ou ClientAliveInterval SSH.
    • macOS : askForPassword=1, askForPasswordDelay=0 ; profil MDM « Screen Lock » ; Coin actif « verrouiller ».

26. Règle 26 — Politiques de mots de passe et secrets

    Pourquoi : limiter le bruteforce et la réutilisation. Comment : passphrases longues, verrouillage, gestionnaire de mots de passe et MFA.

    • Windows : FGPP/AD : longueur ≥ 12–14, complexité, verrouillage 10 tentatives ; Windows Hello for Business.
    • Linux : pam_pwquality (longueur/entropie) ; pam_faillock (verrouillage) ; clés SSH + coffre secrets.
    • macOS : profils MDM « Password Policy » (longueur, historique, lockout) ; gestion Keychain.

27. Règle 27 — Gestion des clés et certificats

    Pourquoi : éviter les expirations et les usages non autorisés. Comment : cycle de vie, auto‑inscription et inventaire des certificats.

    • Windows : auto‑enrollment AD CS ; magasins de certificats gérés ; TLS moderne.
    • Linux : ACME (certbot) pour services ; stores système à jour ; rotation programmée.
    • macOS : profils d’installation de certificats ; Keychain trust paramétré ; suivi d’expiration via MDM.

28. Règle 28 — Synchronisation horaire fiable

    Pourquoi : journaux et protocoles dépendent d’une heure cohérente. Comment : NTP sécurisé, source interne de référence.

    • Windows : service w32time ou AD DC NTP ; pare‑feu autorisé ; supervision de dérive.
    • Linux : chrony recommandé ; NTP authentifié si possible ; systemd-timesyncd minimaliste.
    • macOS : systemsetup -setusingnetworktime on et serveur NTP géré via MDM.

29. Règle 29 — Résolution DNS et découverte réseau

    Pourquoi : empêcher l’empoisonnement et réduire l’empreinte. Comment : résolveurs d’entreprise, DNSSEC/filtrage, désactiver découvertes héritées.

    • Windows : résolveurs internes ; désactiver LLMNR/NetBIOS over TCP/IP ; WPAD off.
    • Linux : systemd-resolved avec DNSSEC si dispo ; désactiver avahi si inutile.
    • macOS : DNS par profils ; limiter Bonjour/mDNS aux usages nécessaires.

30. Règle 30 — Protection et rétention des journaux

    Pourquoi : empêcher l’effacement et garder l’historique utile. Comment : tailles adaptées, rétention, envoi centralisé.

    • Windows : tailles Security/System augmentées ; Do not overwrite ; transfert WEF ; Tamper Protection.
    • Linux : journald en mode persistant + logrotate ; auditd dédié.
    • macOS : collecte Unified Logging vers SIEM ; conservation exportée.

31. Règle 31 — Intégrité des fichiers (FIM)

    Pourquoi : détecter les modifications non autorisées. Comment : FIM sur répertoires critiques avec alertes.

    • Windows : Defender/FIM tiers ; Sysmon FileCreate/FileCreateStreamHash.
    • Linux : AIDE/Tripwire ; IMA/EVM si disponible ; alertes SIEM.
    • macOS : osquery fim ; surveillance TCC/LaunchAgents.

32. Règle 32 — Réduire la pile réseau héritée

    Pourquoi : limiter l’exploitation de vieux protocoles. Comment : désactiver/contraindre les services obsolètes.

    • Windows : LLMNR/NetBIOS off ; NTLM restreint ; SMB signing ; WDigest off.
    • Linux : arrêter avahi-daemon si non requis ; limiter IPv6 si politique ; SSH modernes.
    • macOS : limiter partages Bonjour ; interdire invité/SMB guest.

33. Règle 33 — Impression et spooler

    Pourquoi : surface d’attaque fréquente. Comment : désactiver si inutile, durcir sinon.

    • Windows : désactiver Print Spooler sur serveurs/clients non concernés ; RPC restrictions d’impression.
    • Linux : désactiver cups ; limiter aux réseaux de confiance.
    • macOS : gestion impression par profils ; désactiver CUPS si non nécessaire.

34. Règle 34 — Interfaces d’administration à distance

    Pourquoi : forts privilèges exposés. Comment : HTTPS/TLS, listes d’autorisations, bastions.

    • Windows : WinRM en HTTPS, JEA, pare‑feu par listes ; WMI restreint.
    • Linux : SSH via jumphost ; VNC/RDP Linux désactivés par défaut ; tunnels chiffrés.
    • macOS : ARD/Remote Management limité à groupes ; audit des sessions.

35. Règle 35 — Protection des identifiants

    Pourquoi : empêcher le vol de secrets/mouvements latéraux. Comment : isoler les secrets et protéger les processus sensibles.

    • Windows : LSA Protection (RunAsPPL), Credential Guard, Remote Credential Guard ; groupe « Protected Users ».
    • Linux : core dumps désactivés ; kernel.kptr_restrict, hidepid=2 sur /proc ; SSH agent control.
    • macOS : TCC restreignant accès trousseau ; profils PPPC ; pas d’outils d’extraction non gérés.

36. Règle 36 — Partages et permissions

    Pourquoi : éviter la propagation/ransom via droits excessifs. Comment : principe du moindre privilège, séparation lecture/écriture.

    • Windows : NTFS/partages en lecture par défaut ; pas de « Everyone:Full Control » ; désactiver partages administratifs externes.
    • Linux : NFS avec root_squash, sec=krb5i/krb5p ; Samba : invités interdits.
    • macOS : SMB avec comptes nominatifs ; invités interdits ; droits minimaux.

37. Règle 37 — Anti‑bruteforce et verrous

    Pourquoi : réduire les essais massifs. Comment : verrous temporaires, délais progressifs et alertes.

    • Windows : Account Lockout Policy (seuil, durée) ; Smart Lockout AAD ; pare‑feu sur tentatives.
    • Linux : fail2ban/sshguard ; pam_faillock ; logs audités.
    • macOS : politique de verrouillage MDM ; échecs répétés signalés.

38. Règle 38 — Mises à jour des applications

    Pourquoi : réduire l’exposition des clients lourds. Comment : flux gérés, canaux maîtrisés et tests pilotes.

    • Windows : Company Portal/Intune ; Winget/WSUS pour apps ; updates auto Edge/Chrome.
    • Linux : dépôts officiels ; unattended‑upgrades sécurité ; versions épinglées si besoin.
    • macOS : App Store/MDM ; notarisations à jour ; Self‑Service géré.

39. Règle 39 — Catalogue logiciel approuvé

    Pourquoi : supprimer le « shadow IT ». Comment : installation via catalogue géré uniquement, avec revue de sécurité.

    • Windows : WDAC/AppLocker en mode catalogue ; Company Portal ; interdiction curl | bash.
    • Linux : packages signés depuis dépôts ; interdiction d’install arbitraire.
    • macOS : Self‑Service Jamf ; apps notarised ; restrictions par bundle ID.

40. Règle 40 — Cycle de vie et effacement sécurisé

    Pourquoi : éviter les fuites en fin de vie. Comment : réinitialisation gérée et effacement cryptographique.

    • Windows : Autopilot Reset ; révoquer accès ; purge des secrets ; effacement BitLocker (suppression clés).
    • Linux : disques chiffrés ⇒ destruction de clés ; blkdiscard sur SSD ; re‑image.
    • macOS : Erase All Content and Settings ; désactiver Activation Lock ; retrait MDM.

41. Règle 41 — Postes nomades et travail à distance

    Pourquoi : exposition accrue hors périmètre. Comment : chiffrement, MFA, VPN toujours‑actif et politiques hors‑ligne.

    • Windows : Always‑On VPN ; conformité conditionnelle ; pare‑feu tous profils.
    • Linux : VPN obligatoire ; politiques ufw/nftables ; chiffrement intégral.
    • macOS : profiles VPN on‑demand ; FileVault ; Lost Mode via MDM.

42. Règle 42 — Vérification périodique

    Pourquoi : maintenir la posture dans le temps. Comment : audits de conformité, scans de vulnérabilités et tests ciblés réguliers.

    • Windows : évaluation baseline (Intune/Defender) ; scans Authentifiés.
    • Linux : OpenSCAP/CIS‑CAT réguliers ; scans vulnérabilités authentifiés.
    • macOS : rapports MDM de conformité ; contrôle d’écarts périodiques.

Ressources

• ANSSI — Configuration sécurisée des postes de travail
• CIS Benchmarks — Windows, Linux, macOS
• Microsoft Windows Security Baselines
• Apple Platform Security Guide