# Ajouter une route
ip route add (IP address de destination)/(mask) via (IP local capable d'aller vers le réseau de destination)

# Ajouter une route par défaut
ip route add default via <address-passerelle>

# Rendre une route permanente (Debian/Ubuntu)
echo "192.168.10.0/24 via 192.168.60.5 dev eth0" | sudo tee -a /etc/network/interfaces

# Vérifier la table de routage
ip route show

# Ajouter une adresse IP permanente
ip address add 192.168.1.2/24 dev eth0 sur l'interface concerné dans /etc/network/interfaces
up ip address add 192.168.1.2/24 dev eth0 sur l'interface concerné

# Lister les interfaces
ip link show, ip a

# Activer une interface
ip link set <interface> up

# Configurer une adresse IP
ip address add <IP>/<masque> dev <interface>

# Vérifier l'adresse IP
ip address show <interface>

# Désactiver NAT temporairement
iptables -t nat -F POSTROUTING

# Activer NAT
iptables -t nat -A POSTROUTING -s <Network+Mask> -o <Interface> -j MASQUERADE

# Activer le forwarding IP
sysctl -w net.ipv4.ip_forward=1
# Permanent: Edit /etc/sysctl.conf and set net.ipv4.ip_forward=1.

# Vérifier le NAT
sudo iptables -t nat -L POSTROUTING -v -n --line-numbers
iptables -t nat -L -n -v

# Vérifier le port forwarding
cat /proc/sys/net/ipv4/ip_forward

# Afficher les paquets NAT en temps réel
watch -n 1 'sudo iptables -t nat -L POSTROUTING -v -n'

# Autoriser les paquets RIP (destination)
iptables -t nat -A POSTROUTING -p udp --dport 520 -j ACCEPT

# Autoriser les paquets RIP (source)
iptables -t nat -A POSTROUTING -p udp --sport 520 -j ACCEPT

# Autoriser tous les paquets
iptables -A FORWARD -i pnet0 -j ACCEPT
iptables -A FORWARD -o pnet0 -j ACCEPT

# Envoyer seulement 3 paquets par saut
traceroute 8.8.8.8 probe 3

# Trouver le PID du traceroute
show processes | include traceroute

# Terminer le processus
kill <PID>

# Ajouter un commentaire à la première ligne
sed -i '1i # Commentaire' /etc/hosts

# Ajouter un texte à la première ligne
sed -i '1iTexteà insérer' /etc/hosts

# Créer un fichier avec 2 lignes
echo -e "Ligne 1\nLigne 3" > fichier.txt

# Ajouter une ligne en position 2
sed -i '2iLigne 2 (ajoutée)' fichier.txt

# Supprimer la deuxième ligne
sed -i '2d' fichier.txt

# Supprimer un texte spécifique
sed -i '/texte à supprimer/d' fichier.txt

# Supprimer un bloc de lignes
sed -i '2,4d' fichier.txt

# Édition interactive avec ed
ed -s fichier.txt < tmp
echo "Nouvelle ligne 2" >> tmp
tail -n +2 fichier.txt >> tmp
mv tmp fichier.txt

# Moderniser les dépôts apt
apt modernize-sources

# Reconfigurer GRUB
sudo update-grub

# Nettoyer le système
sudo apt autoremove --purge

# Régénérer initramfs
sudo update-initramfs -u -k all

# Corriger les dépendances
sudo apt install -f

# Vérifier l'espace disque
df -h /boot

# Joindre un domaine AD
sudo apt install realmd sssd adcli samba-common krb5-user packagekit
sudo realm join --user=Administrateur MONDOMAINE.LOCAL

# Supprimer une machine du domaine AD
sudo realm leave --remove=/home/[username] [domain.name]

# Utiliser un scanneur virtuel
scanimage -d "net:<IP_Scanner>:test:0" --format=png > fake-scan.png

# Vérifier les périphériques disponibles
scanimage -L

# Vérification des interfaces réseau
ip a
ip -br addr show

# Vérification de la table de routage
ip route show
ip route get 8.8.8.8

# Test de connectivité de base
ping 192.168.10.1
ping 8.8.8.8
ping google.com

# Test DNS
nslookup google.com
nslookup 0.debian.pool.ntp.org

# Traceroute
traceroute -n 8.8.8.8

# Statistiques des interfaces
ip -s link show

# Connexions réseau actives
ss -tulpn

# Tables ARP
ip neigh show

# Informations matérielles réseau
lshw -class network 2>/dev/null | head -20

# Pilotes réseau
ethtool -i enp0s10 2>/dev/null

# Bandwidth par interface
cat /proc/net/dev

# Qualité du signal Wi-Fi (si applicable)
iwconfig 2>/dev/null | grep -i quality

# Latence réseau
ping -c 3 8.8.8.8

# Script de diagnostic rapide
#!/bin/bash
echo "=== DIAGNOSTIC RÉSEAU RAPIDE ==="
ip -br addr show
ip route show
ping -c 2 8.8.8.8

# Vérifier les règles iptables
sudo iptables -L -n -v
sudo iptables -S

# Vérifier nftables
sudo nft list ruleset

# Désactivation temporaire du firewall
sudo iptables -F
sudo iptables -X
sudo iptables -t nat -F
sudo iptables -P INPUT ACCEPT
sudo iptables -P FORWARD ACCEPT
sudo iptables -P OUTPUT ACCEPT
sudo nft flush ruleset

# Test après désactivation firewall
ping -c 3 8.8.8.8

# Règles firewall
sudo iptables -L 2>/dev/null | head -20

# Ports ouverts
sudo netstat -tulpn 2>/dev/null | head -20

# Services réseau écoutants
sudo ss -tulpn | grep LISTEN

# État des connexions NetworkManager
nmcli connection show
nmcli device status

# Vérification détaillée d'une connexion
nmcli connection show "Connexion Ethernet 1"
nmcli connection show enp0s10

# Modification configuration DNS
sudo nmcli connection modify "Connexion Ethernet 1" ipv4.dns "8.8.8.8,1.1.1.1"
sudo nmcli connection modify "Connexion Ethernet 1" ipv4.ignore-auto-dns yes
sudo nmcli connection modify "Connexion Ethernet 1" ipv4.dns-search ""

# Redémarrage connexion
sudo nmcli connection down "Connexion Ethernet 1"
sudo nmcli connection up "Connexion Ethernet 1"

# Suppression et recréation de profil
sudo nmcli connection delete "Connexion Ethernet 1"
sudo nmcli connection add type ethernet ifname enp0s10 con-name enp0s10 \
ipv4.method auto \
ipv4.dns "8.8.8.8,1.1.1.1" \
ipv4.ignore-auto-dns yes \
ipv4.dns-search "" \
connection.autoconnect yes

# Activer la nouvelle connexion
sudo nmcli connection up enp0s10

# Forcer la reconnaissance de l'interface
sudo nmcli device connect enp0s10

# Redémarrer NetworkManager (si nécessaire)
sudo systemctl restart NetworkManager

# Arrêt NetworkManager
sudo systemctl stop NetworkManager
sudo systemctl disable NetworkManager

# Installation ifupdown
sudo apt update
sudo apt install ifupdown

# Configuration /etc/network/interfaces
sudo nano /etc/network/interfaces

# Contenu fichier interfaces :
source /etc/network/interfaces.d/*

# Interface loopback
auto lo
iface lo inet loopback

# Interface ethernet en DHCP
auto enp0s10
iface enp0s10 inet dhcp

# OU configuration statique
# auto enp0s10
# iface enp0s10 inet static
#     address 192.168.10.4/24
#     gateway 192.168.10.1
#     dns-nameservers 8.8.8.8 1.1.1.1

# Configuration DNS manuelle
sudo nano /etc/resolv.conf

# Contenu resolv.conf :
nameserver 8.8.8.8
nameserver 1.1.1.1
options timeout:2 attempts:1

# Rendre resolv.conf immuable
sudo chattr +i /etc/resolv.conf

# Activation service networking
sudo systemctl enable networking
sudo systemctl restart networking

# Gestion manuelle interface
sudo ifdown enp0s10
sudo ifup enp0s10

# Suppression route APIPA problématique
sudo ip route del 169.254.0.0/16 dev enp0s10

# Nettoyage interface en cas de conflit
sudo ip link set enp0s10 down
sudo ip addr flush dev enp0s10
sudo ip route flush dev enp0s10

# Renouvellement DHCP
sudo dhclient -r enp0s10
sudo dhclient enp0s10

# Configuration IP manuelle temporaire
sudo ip addr add 192.168.10.20/24 dev enp0s10
sudo ip route add default via 192.168.10.1

# Supprimer une IP secondaire
sudo ip addr del 192.168.30.8/24 dev enp0s10

# Appliquer Netplan
sudo netplan generate && sudo netplan apply

# Configurer IP fixe avec NetworkManager
sudo nmcli connection modify 'enp0s10' ipv4.method manual ipv4.addresses 192.168.30.6/24 ipv4.gateway 192.168.30.1 ipv4.dns '8.8.8.8,8.8.4.4'

# Configurer IP fixe avec Netplan
sudo cat > /etc/netplan/01-network.yaml << 'EOF'
network:
  version: 2
  renderer: networkd
  ethernets:
    enp0s10:
      dhcp4: false
      addresses: [192.168.30.6/24]
      gateway4: 192.168.30.1
      nameservers:
        addresses: [8.8.8.8, 8.8.4.4]
EOF

# Script de correction IP double
#!/bin/bash
INTERFACE=${1:-enp0s10}
MAIN_IP=${2:-192.168.30.6}
sudo ip addr flush dev $INTERFACE
sudo ip addr add $MAIN_IP/24 dev $INTERFACE
sudo systemctl restart systemd-networkd

# Arrêt complet services réseau
sudo systemctl stop NetworkManager
sudo systemctl stop networking
sudo systemctl stop systemd-networkd

# Nettoyer les configurations existantes
sudo rm -rf /var/lib/NetworkManager/*

# Nettoyer l'interface manuellement
sudo ip link set enp0s10 down
sudo ip addr flush dev enp0s10
sudo ip route flush dev enp0s10

# Redémarrer les services
sudo systemctl start NetworkManager
sudo systemctl enable NetworkManager

# Laisser NetworkManager détecter automatiquement
sudo nmcli device connect enp0s10

# Configuration DNS manuelle
echo "nameserver 8.8.8.8" | sudo tee /etc/resolv.conf
echo "nameserver 1.1.1.1" | sudo tee -a /etc/resolv.conf

# Rendre le DNS permanent
sudo chattr +i /etc/resolv.conf
# Pour débloquer plus tard : sudo chattr -i /etc/resolv.conf

# Capture paquets sortants
sudo tcpdump -i enp0s10 host 192.168.10.4

# Vérification processus réseau
ps aux | grep -E "(dhclient|NetworkManager)"

# Logs système
sudo journalctl -u NetworkManager -f
sudo journalctl -u networking -f

# Vérification fichiers configuration
ls -la /etc/network/interfaces.d/
cat /etc/resolv.conf

# Traceroute pour voir où ça bloque
traceroute -n 8.8.8.8

# Vérifier les processus réseau
ss -tuln

# Vérifier les logs système
sudo journalctl -u NetworkManager -f

# Vérifier les logs du noyau
dmesg | grep -i network

# Test HTTP/HTTPS
curl -I http://google.com
curl -I https://google.com

# Test connectivité intermédiaire
ping 192.168.10.1  # Switch L3
ping 192.168.1.1   # pfSense

# Vérification tables ARP
arp -n

# Test ports spécifiques
nc -vz 192.168.10.1 22
nc -vz 192.168.1.1 443

# Baux DHCP
cat /var/lib/dhcp/dhclient.*.leases 2>/dev/null | grep "fixed-address" | head -5

# Vérifier la configuration Netplan
cat /etc/netplan/*.yaml 2>/dev/null

# Serveurs DNS utilisés
systemd-resolve --status 2>/dev/null

# Interfaces virtuelles
ip link show type bridge 2>/dev/null

# VLANs
ip link show | grep "@"

# Sauvegarder configuration réseau
sudo cp /etc/netplan/*.yaml ~/backup_network/ 2>/dev/null || true
sudo cp /etc/network/interfaces ~/backup_network/ 2>/dev/null || true
sudo nmcli connection show > ~/backup_network/nmcli_connections.txt 2>/dev/null || true

# Réseaux Docker
docker network ls 2>/dev/null | head -10

# Vérifier un port distant
nc -vz IP_DU_SERVEUR 631

# Connecter des conteneurs Docker à un bridge
docker network connect bridge guacamole
docker network connect bridge guacamole_db
docker network connect bridge guacd

# Installer les paquets NFS
sudo apt install nfs-common

# Vérifier les partages disponibles sur le serveur
showmount -e <IP Serveur NFS>

# Créer un point de montage sur la machine locale
mkdir -p /mnt/truenas_backup

# Monter le partage
mount -t nfs 192.168.100.10:/mnt/tank/vmbackups /mnt/truenas_backup

# Vérifier le montage
df -h
mount | grep nfs

# Tester l'accès
ls /mnt/truenas_backup

# Monter automatiquement au démarrage
nano /etc/fstab
# Ajouter: 192.168.100.10:/mnt/tank/vmbackups  /mnt/truenas_backup  nfs  rw,soft,nolock  0  0

# Démonter le partage local
umount /mnt/truenas_backup

# Alternative avec autofs
sudo apt install autofs
# Éditer /etc/auto.master: /mnt/truenas  /etc/auto.truenas  --timeout=60
# Créer /etc/auto.truenas: backup  -fstype=nfs,rw,soft,nolock  192.168.100.10:/mnt/tank/vmbackups
sudo systemctl restart autofs
ls /mnt/truenas/backup

# Connecter au serveur SMB et afficher les partages
smbclient -L <IP Serveur SMB> -U <Utilisateur d'accès SMB Partage>

# Monter un partage SMB
sudo mount -t cifs -o username=<Nom Utilisateur>,password=<Mot de passe utilisateur>,vers=3.0,uid=$(id -u),gid=$(id -g),nosharesock //IP_Serveur_SMB/Nom_Partage /mnt/truenas_storage

# Supprimer une clé du known_hosts
ssh-keygen -f '/root/.ssh/known_hosts' -R 'IP_Host'

# Générer une nouvelle clé SSH
ssh-keygen -t rsa -b 4096

# Installation du serveur SFTP sur Debian
sudo apt update 
sudo apt install vsftpd
sudo systemctl enable vsftpd
sudo systemctl start vsftpd

# Configuration de base
sudo nano /etc/vsftpd.conf
# Ajouter:
listen=YES
anonymous_enable=NO
local_enable=YES
write_enable=YES
chroot_local_user=YES
user_sub_token=$USER
local_root=/home/$USER/ftp
pasv_min_port=40000
pasv_max_port=50000

# Créer un utilisateur et les répertoires
sudo adduser ftpuser
mkdir -p /home/ftpuser/ftp/files
chmod 550 /home/ftpuser/ftp
sudo systemctl restart vsftpd

# Tester la connexion FTP
ftp adresse_ip_serveur

# Ajouter une route permanente
route add -p (IP addres de destination) MASK (ex:255.255.255.0) (IP local capable d'aller vers le réseau de destination)

# Afficher la table de routage
route print

# Supprimer une route
route delete (IP destination)

# Activer le routage IP
Set-NetIPInterface -InterfaceAlias "Ethernet" -Forwarding Enabled

# Configurer le NAT pour un réseau
New-NetNat -Name "SwitchAccess" -InternalIPInterfaceAddressPrefix "192.168.10.0/24"

# Vérifier le NAT
Get-NetNat
get-NetNatStaticMappingetFirewallRule -DisplayName "Allow_Linux_Subnet" -RemoteAddress 192.168.60.4 -Action Allow
Get-NetNatTransitionConfiguration

# Proxy SSH via Windows
ssh -J user@<IP_Windows> user@<IP_Machine_Adminstrée>

# Tester l'accès SSH
Test-NetConnection 10.10.2.2 -Port 22

# Réparer la pile OSI - problème de connexion internet
netsh int ip reset              # Réinitialiser les interfaces réseau
netsh winsock reset             # Réinitialiser Windows Sockets
ipconfig /release               # Libérer l'adresse IP 
ipconfig /renew                 # Redemander l'adresse IP

# Trouver l'identifiant du client
ipconfig /all                   # Regarder "ID physique" ou "Adresse physique"

# Activer le client NFS sous Windows
# Sur Windows 10/11 Pro/Enterprise :
# - Ouvrez "Paramètres" → "Applications" → "Fonctionnalités facultatives"
# - Cherchez "Services pour NFS" et installez "Client pour NFS"

# Monter le partage NFS via l'invite de commandes (admin)
mount -o anon 192.168.100.10:/mnt/tank/vmbackups Z:

# Options avancées avec authentification
mount -o user=mon_user,password=mon_mdp 192.168.100.10:/mnt/tank/vmbackups Z:

# Démonter
umount Z:

# Afficher les routes RIP
show ip route rip

# Afficher les voisins RIP
show ip rip neighbors

# Désactiver RIP sur toutes les interfaces sauf celles nécessaires
passive-interface default

# Activer RIP sur une interface spécifique
int <Interface>
no passive-interface

# Debug RIP
debug ip rip

# Afficher la configuration RIP
show run | section router rip

# Effacer la table de routage
clear ip route *

# Afficher la base de données RIP
show ip rip database

# Modifier la métrique RIP
int <Interface>
ip rip metric 1

# Désactiver RIP sur une interface
int <Interface>
no ip rip send

# Forcer les broadcasts RIP v2
int <Interface>
ip rip v2-broadcast

# Désactiver le debug
undebug all

# Activer le multicast
configure terminal => ip multicast-routing

# Activer PIM
int <Interface>
ip pim sparse-mode

# Utiliser IGMPv2
ip igmp version 2

# Afficher la table multicast
show ip mroute

# Lister les groupes joints
show ip igmp groups

# Debug IGMP
debug ip igmp

# Lister les interfaces PIM-actives
show ip pim interface

# Vérifier la RPF
show ip rpf 224.0.0.9

# Partager les réseaux locaux connectés
redistribute connected

# Limiter l'accès SSH à une IP spécifique
access-list 10 permit 192.168.1.100
line vty 0 4
 access-class 10 in
exit

# Configurer SFTP
ip ssh server algorithm sftp
ip scp server enable

# Lister les répertoires disponibles
dir flash:
dir usbflash0:
dir nvram:

# Commandes SFTP
sftp admin@<IP>
sftp> ls
sftp> cd flash:
sftp> get running-config
sftp> put mon_fichier.txt

# Exclure les adresses qui ne doivent pas être distribuées
ip dhcp excluded-address <IP Début> <IP FIN>

# Réserver une adresse IP pour un hôte précis
ip dhcp pool HOST-PC1
host 192.168.10.50 255.255.255.0
client-identifier 0100.1A2B.3C4D.5E  # 01 + MAC address
client-name PC-SERVEUR
default-router 192.168.10.1
dns-server 8.8.8.8 10.10.1.2
domain-name home.lab

# Alternative avec MAC address directement
ip dhcp pool HOST-PC2
hardware-address aaaa.bbbb.cccc
client-name PC-SERVEUR
default-router 192.168.1.1
dns-server 8.8.8.8 8.8.4.4

# Gestion des pools DHCP
clear ip dhcp binding 192.168.x.x        # Supprimer une adresse attribuée
show ip dhcp pool                        # Afficher les adresses attribuées
show ip source binding                   # Afficher les bindings statiques

# Activation SNMP sur Cisco IOS
enable
configure terminal
snmp-server community public RO
snmp-server community private RW
snmp-server host [IP-du-manager] traps version 2c public
snmp-server enable traps
exit
write memory

# Tables ARP
show ip arp                              # Afficher la table ARP complète
show ip arp interface vlan 10           # Filtrer par interface
show ip arp <IP>                        # Rechercher une IP spécifique

# Tables MAC
show mac address-table                   # Afficher toutes les MAC addresses apprises
show mac address-table dynamic           # Afficher les MAC addresses en temps réel
show mac address-table interface gigabitethernet 1/0/5   # Filtrer par interface
show mac address-table vlan 10           # Filtrer par VLAN
show mac address-table address aaaa.bbbb.cccc   # Rechercher une MAC spécifique

# Gestion des entrées
clear mac address-table dynamic interface gigabitethernet 1/0/5   # Vider une entrée MAC

# Monitoring
show interfaces counters                 # Voir les compteurs par interface
show mac address-table dynamic | include Gi1/0/5   # Monitoring en temps réel

# Afficher les interfaces VLAN
show ip int bri | include vlan

# Afficher les détails des VLANs
show vlan brief

# Afficher la table ARP
show arp

# Afficher les listes d'accès
show access-lists

# Vérifier la connectivité physique
show cdp neighbors

# Filtrer la table ARP
show arp | inculde <IP>

# Afficher le switch root
show spanning-tree root

# Afficher une route spécifique
show ip route 224.0.0.0/24

# Configurer un tunnel
int Tunnel0
tunnel source <Interface>
tunnel destination <IP de l'autre équipement ou Tunnel sur l'autre> 
keepalive
ip address <IP> <MASK>
no ip split-horizon
ip rip advertise <Network>
no shut

# Vérifier la version de Windows
Get-ComputerInfo | Select-Object WindowsProductName, WindowsVersion, OsHardwareAbstractionLayer

# Activer le rôle de serveur (ex: AD DS)
Install-WindowsFeature AD-Domain-Services -IncludeManagementTools

# Configurer un nouveau contrôleur de domaine
Install-ADDSForest -DomainName "corp.example.com" -DomainNetbiosName "CORP" -InstallDns

# Redémarrer après installation
Restart-Computer -Force

# Créer un nouvel utilisateur
New-ADUser -Name "Jean Dupont" -GivenName "Jean" -Surname "Dupont" `
            -SamAccountName "jdupont" -UserPrincipalName "jdupont@corp.example.com" `
            -Path "OU=Utilisateurs,DC=corp,DC=example,DC=com" -AccountPassword (ConvertTo-SecureString "P@ssw0rd" -AsPlainText -Force) `
            -Enabled $true

# Modifier un utilisateur
Set-ADUser -Identity jdupont -Office "Paris" -Department "IT" -Title "Administrateur Système"

# Créer un groupe et ajouter des membres
New-ADGroup -Name "Admins IT" -GroupScope Global -Path "OU=Groupes,DC=corp,DC=example,DC=com"
Add-ADGroupMember -Identity "Admins IT" -Members jdupont

# Lister tous les utilisateurs d'une OU
Get-ADUser -Filter * -SearchBase "OU=Utilisateurs,DC=corp,DC=example,DC=com" | Select Name,SamAccountName

# Créer une nouvelle GPO
New-GPO -Name "Verrouillage Station" -Comment "Stratégie de sécurité de base"

# Lier une GPO à une OU
New-GPLink -Name "Verrouillage Station" -Target "OU=Utilisateurs,DC=corp,DC=example,DC=com"

# Modifier une GPO
Set-GPRegistryValue -Name "Verrouillage Station" -Key "HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System" `
                    -ValueName "DisableTaskMgr" -Type DWord -Value 1

# Forcer la mise à jour des GPO sur un client
Invoke-GPUpdate -Computer "CLIENT01" -Force

# Lister les disques disponibles
Get-Disk

# Initialiser un nouveau disque
Initialize-Disk -Number 1 -PartitionStyle GPT

# Créer une partition
New-Partition -DiskNumber 1 -UseMaximumSize -DriveLetter D

# Formater le volume
Format-Volume -DriveLetter D -FileSystem NTFS -NewFileSystemLabel "Données" -Confirm:$false

# Configurer un quota de disque
New-FsrmQuota -Path "D:\Partage" -Size 5GB -Description "Limite 5GB par utilisateur"

# Vérifier l'espace disque
Get-Volume | Select DriveLetter,FileSystemLabel,SizeRemaining,Size

# Analyser les événements système
Get-EventLog -LogName System -Newest 50 | Where-Object {$_.EntryType -eq "Error"}

# Planifier une tâche
$action = New-ScheduledTaskAction -Execute "powershell.exe" -Argument "-File D:\scripts\cleanup.ps1"
$trigger = New-ScheduledTaskTrigger -Daily -At 2am
Register-ScheduledTask -TaskName "Nettoyage nocturne" -Action $action -Trigger $trigger -User "SYSTEM"

# Vérifier les services critiques
Get-Service | Where-Object {$_.Status -ne "Running" -and $_.StartType -eq "Automatic"}

# Installer les rôles DHCP et DNS
Install-WindowsFeature DHCP,DNS -IncludeManagementTools

# Configurer le serveur DHCP après installation
Add-DhcpServerInDC -DnsName "dc1.corp.example.com" -IPAddress 192.168.1.1

# Redémarrer si nécessaire
Restart-Computer -Force

# Créer une étendue DHCP
Add-DhcpServerv4Scope -Name "Réseau Principal" `
                      -StartRange 192.168.1.100 -EndRange 192.168.1.200 `
                      -SubnetMask 255.255.255.0 -State Active

# Configurer les options de l'étendue
Set-DhcpServerv4OptionValue -ScopeId 192.168.1.0 `
                           -DnsServer 192.168.1.1, 192.168.1.2 `
                           -Router 192.168.1.1 `
                           -DnsDomain "corp.example.com"

# Activer les adresses MAC réservées
Add-DhcpServerv4Reservation -ScopeId 192.168.1.0 `
                           -IPAddress 192.168.1.50 `
                           -ClientId "01-23-45-67-89-AB" `
                           -Description "Serveur d'impression"

# Configurer les plages d'exclusion
Add-DhcpServerv4ExclusionRange -ScopeId 192.168.1.0 `
                              -StartRange 192.168.1.1 `
                              -EndRange 192.168.1.15

# Afficher toutes les étendues DHCP
Get-DhcpServerv4Scope

# Afficher les baux actifs
Get-DhcpServerv4Lease -ScopeId 192.168.1.0

# Supprimer un bail spécifique
Remove-DhcpServerv4Lease -IPAddress 192.168.1.105

# Sauvegarder la configuration DHCP
Backup-DhcpServer -Path "C:\DHCP_Backup\" -Force

# Restaurer la configuration DHCP
Restore-DhcpServer -Path "C:\DHCP_Backup\" -Force

# Migrer un serveur DHCP
Export-DhcpServer -File "C:\DHCP_Export.xml" -Leases
Import-DhcpServer -File "C:\DHCP_Export.xml" -Leases

# Créer une zone DNS principale
Add-DnsServerPrimaryZone -Name "corp.example.com" `
                        -ZoneFile "corp.example.com.dns" `
                        -DynamicUpdate Secure

# Créer une zone DNS inverse
Add-DnsServerPrimaryZone -NetworkId "192.168.1.0/24" `
                        -ZoneFile "1.168.192.in-addr.arpa.dns"

# Ajouter un enregistrement A
Add-DnsServerResourceRecordA -Name "serveur1" `
                           -ZoneName "corp.example.com" `
                           -IPv4Address "192.168.1.10" `
                           -CreatePtr

# Ajouter un enregistrement CNAME
Add-DnsServerResourceRecordCName -Name "www" `
                               -HostNameAlias "serveur1.corp.example.com" `
                               -ZoneName "corp.example.com"

# Ajouter un enregistrement MX
Add-DnsServerResourceRecordMX -Preference 10 `
                             -Name "@" `
                             -MailExchange "mail.corp.example.com" `
                             -ZoneName "corp.example.com"

# Activer le nettoyage automatique
Set-DnsServerScavenging -ScavengingState $true `
                       -RefreshInterval 7.00:00:00 `
                       -NoRefreshInterval 7.00:00:00 `
                       -ApplyOnAllZones

# Forcer le nettoyage immédiat
Start-DnsServerScavenging -Force

# Configurer le transfert de zone
Set-DnsServerForwarder -IPAddress "8.8.8.8","8.8.4.4" -PassThru

# Configurer la réplication DNS entre contrôleurs de domaine
Set-DnsServerDirectoryPartition -Name "DomainDnsZones.corp.example.com" `
                               -ReplicationScope "Domain"

# Exporter la configuration DNS
Export-DnsServerZone -Name "corp.example.com" -FileName "C:\DNS_Backup\corp.example.com.dns"

# Importer une zone DNS
Import-DnsServerZone -Name "corp.example.com" -FileName "C:\DNS_Backup\corp.example.com.dns"

# Vérifier l'état du service DHCP
Get-Service -Name DHCPServer | Select-Object Name,Status,StartType

# Analyser les événements DHCP
Get-EventLog -LogName "System" -Source "DHCPServer" -Newest 50

# Tester la résolution DNS
Resolve-DnsName -Name "serveur1.corp.example.com" -Type A

# Effectuer une requête DNS détaillée
nslookup
> server 192.168.1.1
> set type=MX
> corp.example.com
> exit

# Vérifier la réplication DNS
Repadmin /showrepl
Repadmin /syncall /AdeP

# Capturer le trafic DHCP/DNS
netsh trace start scenario=NetConnection capture=yes tracefile=C:\traces\network.etl
netsh trace stop

# Configurer les options de sécurité DHCP
Set-DhcpServerv4DnsSetting -DynamicUpdates "Always" `
                          -DeleteDnsRRonLeaseExpiry $true `
                          -UpdateDnsRRForOlderClients $true

# Activer DNSSEC pour une zone
Set-DnsServerZoneSigning -Name "corp.example.com" -Sign

# Configurer le filtrage DNS
Add-DnsServerQueryResolutionPolicy -Name "BlockMaliciousDomains" `
                                 -Action DENY `
                                 -FQDN "EQ,*.malicious.com" `
                                 -PassThru

# Restreindre les mises à jour DNS dynamiques
Set-DnsServerPrimaryZone -Name "corp.example.com" `
                        -DynamicUpdate Secure

# Script pour vérifier les baux DHCP expirés
$ExpiredLeases = Get-DhcpServerv4Lease -ScopeId 192.168.1.0 | Where-Object {$_.LeaseExpiryTime -lt (Get-Date)}
$ExpiredLeases | Export-Csv -Path "C:\Reports\ExpiredLeases.csv" -NoTypeInformation

# Script pour auditer les enregistrements DNS
$DNSRecords = Get-DnsServerResourceRecord -ZoneName "corp.example.com" -RRType "A"
$DNSRecords | Select-Object HostName,RecordType,Timestamp | Out-GridView

# Script pour migrer des plages DHCP
$OldScope = Get-DhcpServerv4Scope -ScopeId 192.168.0.0
Add-DhcpServerv4Scope -Name $OldScope.Name `
                     -StartRange 192.168.1.100 `
                     -EndRange 192.168.1.200 `
                     -SubnetMask $OldScope.SubnetMask
Get-DhcpServerv4OptionValue -ScopeId $OldScope.ScopeId | ForEach-Object {
    Set-DhcpServerv4OptionValue -ScopeId 192.168.1.0 -OptionId $_.OptionId -Value $_.Value
}

# Créer un nouvel utilisateur
sudo useradd -m -s /bin/bash jdupont
sudo passwd jdupont

# Modifier un utilisateur
sudo usermod -aG sudo jdupont  # Ajouter aux sudoers
sudo usermod -d /new/home/jdupont jdupont  # Changer le répertoire home

# Créer un groupe
sudo groupadd admins_it

# Ajouter un utilisateur à un groupe
sudo usermod -aG admins_it jdupont

# Lister tous les utilisateurs
cut -d: -f1 /etc/passwd

# Vérifier les sudoers
sudo grep -Po '^sudo.+:\K.*$' /etc/group

# Trouver l'identifiant du client (MAC address)
ip link show                    # Regarder "link/ether"
cat /sys/class/net/eth0/address

# Changer le propriétaire d'un fichier
sudo chown jdupont:admins_it /chemin/du/fichier

# Changer les permissions (chmod en octal)
sudo chmod 750 /chemin/du/fichier  # rwx pour owner, r-x pour group, --- pour others

# Changer les permissions (chmod symbolique)
sudo chmod u=rwx,g=rx,o= /chemin/du/fichier

# Définir le bit SUID
sudo chmod u+s /chemin/du/fichier

# Définir le sticky bit sur un répertoire
sudo chmod +t /chemin/du/repertoire

# Debian/Ubuntu
sudo apt update && sudo apt upgrade  # Mettre à jour tous les paquets
sudo apt install apache2            # Installer un paquet
sudo apt remove apache2             # Désinstaller un paquet
sudo apt autoremove                 # Nettoyer les paquets inutiles

# RHEL/CentOS
sudo yum update                     # Mettre à jour tous les paquets
sudo yum install httpd              # Installer un paquet
sudo yum remove httpd               # Désinstaller un paquet
sudo yum clean all                  # Nettoyer le cache

# Systemd (récent)
sudo systemctl start apache2        # Démarrer un service
sudo systemctl stop apache2         # Arrêter un service
sudo systemctl restart apache2      # Redémarrer un service
sudo systemctl enable apache2       # Activer au démarrage
sudo systemctl status apache2       # Vérifier l'état

# SysVinit (ancien)
sudo service apache2 start          # Démarrer un service
sudo service apache2 stop           # Arrêter un service
sudo service apache2 restart        # Redémarrer un service
sudo update-rc.d apache2 defaults   # Activer au démarrage

# Espace disque
df -h                              # Afficher l'espace disque
du -sh /chemin                     # Taille d'un répertoire

# Mémoire
free -m                            # Utilisation mémoire
top                                # Moniteur d'activité
htop                               # Version améliorée de top

# Processus
ps aux                             # Lister tous les processus
pstree                             # Arbre des processus
kill -9 PID                        # Tuer un processus

# Journaux système
sudo journalctl -xe                # Afficher les logs systemd
sudo tail -f /var/log/syslog       # Suivre les logs en temps réel
sudo grep "error" /var/log/syslog  # Filtrer les erreurs

# Pare-feu (UFW - Ubuntu)
sudo ufw enable                    # Activer le pare-feu
sudo ufw allow 22/tcp              # Autoriser le port SSH
sudo ufw deny 23/tcp               # Bloquer le port Telnet
sudo ufw status verbose            # Vérifier les règles

# Pare-feu (firewalld - RHEL/CentOS)
sudo firewall-cmd --permanent --add-port=80/tcp
sudo firewall-cmd --reload

# SSH
sudo ssh-keygen -t rsa -b 4096     # Générer une paire de clés
sudo nano /etc/ssh/sshd_config     # Configurer le serveur SSH
sudo systemctl restart sshd        # Redémarrer SSH après modification

# Analyse de sécurité
sudo lynis audit system            # Audit de sécurité
sudo chkrootkit                   # Vérifier les rootkits
sudo rkhunter --checkall          # Analyse complète du système

# Sauvegarde avec tar
sudo tar -czvf backup-$(date +%F).tar.gz /dossier/a/sauvegarder

# Sauvegarde incrémentielle avec rsync
sudo rsync -av --delete --link-dest=/previous/backup /source /destination/backup-$(date +%F)

# Sauvegarde MySQL
sudo mysqldump -u root -p --all-databases > full_backup.sql

# Sauvegarde PostgreSQL
sudo pg_dumpall -U postgres > full_backup.sql

# Planifier des sauvegardes avec cron
(crontab -l 2>/dev/null; echo "0 2 * * * /chemin/vers/script_backup.sh") | crontab -

#!/bin/bash
# Exemple de script de surveillance

# Variables
THRESHOLD=90
EMAIL="admin@example.com"

# Vérification espace disque
DISK_USAGE=$(df / | awk '{print $5}' | tail -1 | cut -d'%' -f1)

if [ $DISK_USAGE -gt $THRESHOLD ]; then
    echo "Alerte : Espace disque critique sur $(hostname)" | mail -s "Alerte disque" $EMAIL
fi

# Vérification mémoire
MEM_FREE=$(free -m | awk '/Mem:/ {print $4}')
if [ $MEM_FREE -lt 100 ]; then
    echo "Alerte : Mémoire faible sur $(hostname)" | mail -s "Alerte mémoire" $EMAIL
fi

# Vérification configuration base de données GLPI
cat /var/www/html/glpi/config/config_db.php

# Ou avec un format plus lisible
grep -E "(dbhost|dbuser|dbpassword|dbdefault)" /var/www/html/glpi/config/config_db.php

# Version détaillée
php -r '
    include "/var/www/html/glpi/config/config_db.php";
    echo "Hôte: " . $DB->dbhost . "\n";
    echo "Base: " . $DB->dbdefault . "\n";
    echo "Utilisateur: " . $DB->dbuser . "\n";
    echo "Mot de passe: " . $DB->dbpassword . "\n";
'

# Connexion MySQL et exploration
mysql -u root -p -e "SHOW DATABASES;"
mysql -u root -p -e "USE glpi_db; SHOW TABLES;"

# Voir les utilisateurs MySQL
mysql -u root -p -e "SELECT user, host FROM mysql.user;"

# Voir les privilèges de l'utilisateur GLPI
mysql -u root -p -e "SHOW GRANTS FOR 'glpi_admin'@'localhost';"

# Console GLPI
cd /var/www/html/glpi
php bin/console glpi:system:status
php bin/console glpi:database:check

# Donner droits super-admin
mysql -u glpi_admin -p'34PenetrationTest' -h localhost glpi_db -e "
UPDATE glpi_profiles_users 
SET profiles_id = 4 
WHERE users_id = (SELECT id FROM glpi_users WHERE name = 'glpi_admin');"

# Si l'utilisateur n'a aucun profil, l'ajouter :
mysql -u glpi_admin -p'34PenetrationTest' -h localhost glpi_db -e "
INSERT INTO glpi_profiles_users (users_id, profiles_id, entities_id, is_recursive, is_dynamic) 
VALUES (
  (SELECT id FROM glpi_users WHERE name = 'glpi_admin'), 
  4, 0, 1, 0
);"

# Vérification :
mysql -u glpi_admin -p'34PenetrationTest' -h localhost glpi_db -e "
SELECT u.name, p.name as profile 
FROM glpi_users u 
JOIN glpi_profiles_users pu ON u.id = pu.users_id 
JOIN glpi_profiles p ON pu.profiles_id = p.id 
WHERE u.name = 'glpi_admin';"

# Chercher les fichiers de configuration
sudo find / -name "config_db.php" 2>/dev/null

# Commandes MySQL GLPI
mysql -u root -p glpi_db << 'EOF'
-- Désactiver vérification versions
UPDATE glpi_configs SET value = '0' WHERE name = 'founded_new_version';
UPDATE glpi_configs SET value = '0' WHERE name = 'checkversion';

-- Réactiver vérification versions
UPDATE glpi_configs SET value = '1' WHERE name = 'checkversion';
UPDATE glpi_configs SET value = '' WHERE name = 'founded_new_version';

-- Vérification configuration
SELECT name, value FROM glpi_configs WHERE name IN ('founded_new_version', 'checkversion');

-- Créer configuration manquante
INSERT INTO glpi_configs (name, value, context) 
VALUES ('checkversion', '1', 'core')
ON DUPLICATE KEY UPDATE value = '1';
EOF

# Fuseaux horaires GLPI
# Activation fuseaux horaires
cd /var/www/html/glpi
php bin/console database:enable_timezones

# Vérification
php bin/console database:check_timezones

# Configuration MySQL pour fuseaux horaires
mysql -u root -p << 'EOF'
GRANT SELECT ON mysql.time_zone_name TO 'glpi_admin'@'localhost';
GRANT SELECT ON mysql.time_zone TO 'glpi_admin'@'localhost';
GRANT SELECT ON mysql.time_zone_leap_second TO 'glpi_admin'@'localhost';
GRANT SELECT ON mysql.time_zone_transition TO 'glpi_admin'@'localhost';
GRANT SELECT ON mysql.time_zone_transition_type TO 'glpi_admin'@'localhost';
FLUSH PRIVILEGES;
EOF

# Chargement données fuseaux horaires
mysql_tzinfo_to_sql /usr/share/zoneinfo | mysql -u root -p mysql

# Agent GLPI Windows
# Arrêt service GLPI Agent (Windows)
echo "# Sur Windows (CMD admin) :"
echo "net stop 'GLPI Agent'"
echo "timeout /t 30"
echo "net start 'GLPI Agent'"

# Configuration agent GLPI (fichier agent.cfg)
cat > "C:\Program Files\GLPI-Agent\agent.cfg" << 'EOF'
# Désactiver scans réseau
modules = inventory,deploy,collect
no-task = netdiscovery,netinventory

[netdiscovery]
enabled = 0

[netinventory]
enabled = 0

[network]
delay = 0
no-task = 1
EOF

# Réinitialisation GLPI
# Réinitialisation via console
cd /var/www/html/glpi
php bin/console glpi:system:clear_cache
php bin/console glpi:database:configure \
    --db-host=localhost \
    --db-name=glpi_db \
    --db-user=glpi_admin \
    --db-password=34PenetrationTest \
    --reconfigure

# Réinstallation sans perte données
php bin/console glpi:database:install \
    --db-host=localhost \
    --db-name=glpi_db \
    --db-user=glpi_admin \
    --db-password=34PenetrationTest \
    --force

# Sauvegardes GLPI
# Sauvegarde base données
BACKUP_DIR="/root/glpi_backup_$(date +%Y%m%d_%H%M%S)"
mkdir -p $BACKUP_DIR
mysqldump -u root -p glpi_db > "$BACKUP_DIR/glpi_db_complete.sql"
mysqldump -u root -p --no-create-info glpi_db > "$BACKUP_DIR/glpi_db_data_only.sql"
mysqldump -u root -p --no-data glpi_db > "$BACKUP_DIR/glpi_db_structure_only.sql"

# Sauvegarde fichiers configuration
cp /var/www/html/glpi/config/config_db.php "$BACKUP_DIR/"
cp /var/www/html/glpi/config/local_define.php "$BACKUP_DIR/" 2>/dev/null || true

# Sauvegarde fichiers GLPI
tar -czf "$BACKUP_DIR/glpi_files.tar.gz" -C /var/www/html/glpi/files . 2>/dev/null || true

# Vérifications GLPI
# Statut services
systemctl status snmpd
systemctl status apache2
systemctl status mysql

# Test GLPI
curl -I http://localhost/glpi
php bin/console glpi:system:status

# Logs
tail -f /var/log/syslog | grep snmp
tail -f /var/log/apache2/error.log

# Lister toutes les interfaces réseau
Get-NetAdapter | Select Name, InterfaceDescription, Status

# Activer/Désactiver une interface
Enable-NetAdapter -Name "Ethernet" -Confirm:$false
Disable-NetAdapter -Name "Wi-Fi" -Confirm:$false

# Configurer une adresse IP statique
New-NetIPAddress -InterfaceAlias "Ethernet" -IPAddress 192.168.1.100 `
                -PrefixLength 24 -DefaultGateway 192.168.1.1

# Configurer les serveurs DNS
Set-DnsClientServerAddress -InterfaceAlias "Ethernet" `
                        -ServerAddresses ("8.8.8.8", "8.8.4.4")

# Test de connectivité
Test-NetConnection -ComputerName google.com -Port 80

# Traceroute amélioré
Test-NetConnection -ComputerName google.com -TraceRoute

# Analyse des ports ouverts
Get-NetTCPConnection -State Listen | Sort-Object LocalPort | Format-Table

# Vérifier la configuration IP détaillée
Get-NetIPConfiguration -Detailed

# Capturer des paquets (nécessite Npcap)
# Installer d'abord : choco install npcap
New-NetEventSession -Name "CaptureSession" -CaptureMode SaveToFile -LocalFilePath "C:\capture.etl"
Add-NetEventPacketCaptureProvider -SessionName "CaptureSession"
Start-NetEventSession -Name "CaptureSession"
Stop-NetEventSession -Name "CaptureSession"

# Lister toutes les règles
Get-NetFirewallRule | Where-Object {$_.Enabled -eq "True"} | Format-Table Name,DisplayName

# Créer une nouvelle règle
New-NetFirewallRule -Name "AllowWeb" -DisplayName "HTTP/HTTPS Access" `
                   -Direction Inbound -Protocol TCP -LocalPort 80,443 `
                   -Action Allow

# Bloquer une plage IP
New-NetFirewallRule -Name "BlockMalicious" -DisplayName "Block Malicious IPs" `
                   -Direction Inbound -RemoteAddress 192.168.100.0/24 `
                   -Action Block

# Afficher la table de routage
Get-NetRoute -AddressFamily IPv4 | Format-Table

# Ajouter une route statique
New-NetRoute -DestinationPrefix "10.0.0.0/24" -InterfaceAlias "Ethernet" `
             -NextHop 192.168.1.1 -RouteMetric 100

# Configurer le NAT (exige le rôle RRAS)
Install-WindowsFeature RemoteAccess -IncludeManagementTools
Install-RemoteAccess -VpnType RoutingOnly
Add-NetNatStaticMapping -NatName "CorpNAT" -Protocol TCP -ExternalIPAddress 203.0.113.25 `
                       -InternalIPAddress 192.168.1.50 -InternalPort 3389 -ExternalPort 3389

# Configurer un VPN (PowerShell 5.1+)
Add-VpnConnection -Name "CorporateVPN" -ServerAddress "vpn.corp.example.com" `
                 -TunnelType L2tp -L2tpPsk "SharedSecret123" -Force -RememberCredential

# Se connecter à un VPN
rasdial "CorporateVPN" username password

# Vérifier les connexions VPN
Get-VpnConnection

# Lister les interfaces
ip link show
nmcli device status

# Activer/Désactiver une interface
sudo ip link set eth0 up
sudo ip link set eth0 down

# Configurer une adresse IP temporaire
sudo ip addr add 192.168.1.100/24 dev eth0

# Configurer une adresse IP permanente (Ubuntu/Debian)
sudo nano /etc/netplan/01-netcfg.yaml
# Exemple de configuration:
network:
  version: 2
  ethernets:
    eth0:
      addresses: [192.168.1.100/24]
      gateway4: 192.168.1.1
      nameservers:
        addresses: [8.8.8.8, 8.8.4.4]
sudo netplan apply

# Vérification des interfaces
ip a
ip -br addr show
ip link show

# Tables de routage
ip route show
ip route get 8.8.8.8

# Test de connectivité
ping -c 4 google.com
ping6 -c 4 ipv6.google.com

# Traceroute (installer avec: sudo apt install traceroute)
traceroute -n google.com

# Vérifier les ports ouverts
ss -tulnp
netstat -tulnp  # Alternative

# Analyse des paquets
sudo tcpdump -i eth0 -n 'port 80'
sudo tshark -i eth0 -f "tcp port 22"  # Version avancée (Wireshark CLI)

# Test de débit (installer speedtest-cli)
speedtest-cli --bytes

# Connexions réseau actives
ss -tulpn
netstat -tulpn

# Installation SNMP sur Linux
sudo apt-get update
sudo apt-get install snmpd snmp

# Configuration SNMPD
sudo cat > /etc/snmp/snmpd.conf << 'EOF'
agentAddress udp:161
rocommunity public 0.0.0.0/0
rwcommunity private 0.0.0.0/0
sysLocation "EVE-NG Lab"
sysContact "admin@eve-ng.net"
EOF

# Redémarrage service SNMP
sudo systemctl restart snmpd
sudo systemctl enable snmpd

# Test SNMP
snmpwalk -v2c -c public localhost system
snmpwalk -v2c -c public [IP-EVE-NG] system

# Configuration SNMP détaillée pour GLPI
sudo cat > /etc/snmp/snmpd.conf << 'EOF'
# EVE-NG SNMP Minimal Config
agentAddress udp:161

# Communities avec restrictions réseau
rocommunity public 127.0.0.1
rocommunity public 192.168.0.0/16
rocommunity public 10.0.0.0/8

# Informations système
sysLocation "EVE-NG Lab"
sysContact "admin@eve-ng.net"
sysName "eve-ng"

# Options de sécurité
com2sec notConfigUser  default       public
group   notConfigGroup v1           notConfigUser
group   notConfigGroup v2c           notConfigUser
view    systemview    included   .1.3.6.1.2.1.1
view    systemview    included   .1.3.6.1.2.1.25.1.1
access  notConfigGroup ""      any       noauth    exact  systemview none none
EOF

# Purge SNMP
# Arrêt service
sudo systemctl stop snmpd

# Réinitialisation configuration
sudo rm -f /etc/snmp/snmpd.conf

# Nouvelle configuration propre
sudo cat > /etc/snmp/snmpd.conf << 'EOF'
# SNMPd minimal configuration for EVE-NG
rocommunity public 127.0.0.1
rocommunity public 192.168.0.0/16
sysLocation "EVE-NG Laboratory"
sysContact "admin@eve-ng.net"
EOF

# Redémarrage
sudo systemctl start snmpd

# Diagnostic réseau SNMP
# Test connectivité
ping -c 3 192.168.30.6
telnet 192.168.30.6 161

# Vérification ports ouverts
netstat -tulpn | grep 161
ss -tulpn | grep 161

# Test firewall
sudo ufw status
sudo ufw allow from 192.168.30.0/24 to any port 161

# État des connexions NetworkManager
nmcli connection show
nmcli device status

# Vérification détaillée d'une connexion
nmcli connection show "Connexion Ethernet 1"
nmcli connection show enp0s10

# Modification configuration DNS
sudo nmcli connection modify "Connexion Ethernet 1" ipv4.dns "8.8.8.8,1.1.1.1"
sudo nmcli connection modify "Connexion Ethernet 1" ipv4.ignore-auto-dns yes

# Redémarrage connexion
sudo nmcli connection down "Connexion Ethernet 1"
sudo nmcli connection up "Connexion Ethernet 1"

# Suppression et recréation de profil
sudo nmcli connection delete "Connexion Ethernet 1"
sudo nmcli connection add type ethernet ifname enp0s10 con-name enp0s10 \
    ipv4.method auto \
    ipv4.ignore-auto-dns yes \
    ipv4.dns "8.8.8.8,1.1.1.1"

# Lister les règles iptables
sudo iptables -L -v -n --line-numbers
sudo iptables -S

# Autoriser le trafic HTTP/HTTPS
sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 443 -j ACCEPT

# Bloquer une IP
sudo iptables -A INPUT -s 192.168.100.23 -j DROP

# Sauvegarder les règles (Debian/Ubuntu)
sudo iptables-save > /etc/iptables.rules

# Désactivation temporaire du firewall
sudo iptables -F
sudo iptables -X
sudo iptables -t nat -F
sudo iptables -P INPUT ACCEPT
sudo iptables -P FORWARD ACCEPT
sudo iptables -P OUTPUT ACCEPT
sudo nft flush ruleset

# nftables (nouvelle génération)
sudo nft add table inet filter
sudo nft add chain inet filter input { type filter hook input priority 0 \; }
sudo nft add rule inet filter input tcp dport 22 accept

# Vérification nftables
sudo nft list ruleset

# Afficher la table de routage
ip route show
route -n  # Alternative

# Ajouter une route statique
sudo ip route add 10.0.0.0/24 via 192.168.1.1 dev eth0

# Configurer le NAT
sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
sudo sysctl -w net.ipv4.ip_forward=1

# Configurer le NAT permanent
echo "net.ipv4.ip_forward=1" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

# OpenVPN (client)
sudo openvpn --config client.ovpn

# WireGuard (client)
sudo wg-quick up wg0

# Créer un tunnel SSH
ssh -N -L 8080:localhost:80 user@remote-server
ssh -N -R 2222:localhost:22 user@remote-server  # Reverse tunnel

# Tunnel GRE (entre deux serveurs)
sudo ip tunnel add gre1 mode gre remote 203.0.113.2 local 198.51.100.1 ttl 255
sudo ip link set gre1 up
sudo ip addr add 10.0.0.1/30 dev gre1

# Analyse de bande passante (nload)
sudo nload eth0

# Monitorer les connexions (iftop)
sudo iftop -i eth0

# Scanner réseau (nmap)
sudo nmap -sS -p 1-1024 192.168.1.0/24

# Benchmark HTTP (httperf)
httperf --server example.com --port 80 --uri / --num-conn 100

# Test de résilience (mtr)
mtr -n --report google.com

# Installation
sudo apt install tshark                       # Sur Debian/Ubuntu

# Capture en direct
tshark -D                                     # Lister les interfaces disponibles
tshark -i eth0                                # Capturer sur une interface spécifique
tshark -i eth0 -w capture.pcap                # Capturer et enregistrer dans un fichier
tshark -i eth0 -Y "http"                      # Filtrer le trafic (HTTP seulement)
tshark -i eth0 -c 100                         # Capturer seulement 100 paquets
tshark -i eth0 -f "port 80" -Y "http.request" # Afficher en temps réel avec filtrage

# Analyse de fichiers de capture
tshark -r capture.pcap                        # Lire un fichier .pcap
tshark -r capture.pcap -Y "dns"               # Filtrer les paquets (DNS seulement)
tshark -r capture.pcap -qz io,phs             # Afficher les statistiques

#!/bin/bash
# Script de surveillance réseau
INTERFACE="eth0"
MAX_UTIL=90

# Vérifier l'utilisation de la bande passante
CURRENT_RX=$(ifconfig $INTERFACE | grep "RX packets" | awk '{print $5}')
CURRENT_TX=$(ifconfig $INTERFACE | grep "TX packets" | awk '{print $5}')
sleep 1
NEW_RX=$(ifconfig $INTERFACE | grep "RX packets" | awk '{print $5}')
NEW_TX=$(ifconfig $INTERFACE | grep "TX packets" | awk '{print $5}')

RX_UTIL=$(( ($NEW_RX - $CURRENT_RX) / 1024 ))
TX_UTIL=$(( ($NEW_TX - $CURRENT_TX) / 1024 ))

if [ $RX_UTIL -gt $MAX_UTIL ] || [ $TX_UTIL -gt $MAX_UTIL ]; then
    echo "Alerte: Utilisation élevée du réseau - RX: ${RX_UTIL}KB/s TX: ${TX_UTIL}KB/s" | mail -s "Alerte réseau" admin@example.com
fi

# Gestion du firewall
pftcl -d && pfctl -e

# Vérifier les règles firewall pour le port RIP
pfctl -sr | grep 520

# Redémarrer le service RIP
/etc/rc.d/ripd restart

# Gestion de l'historique
history
fc -l
history | grep rip
cat ~/.history

# Configurer l'historique persistant
echo 'export HISTFILE=~/.persistent_history' >> ~/.shrc
echo 'export HISTSIZE=10000' >> ~/.shrc
touch ~/.persistent_history

# Raccourcis historiques
!!  # Répète la dernière commande
!ssh  # Rappelle la dernière commande commençant par ssh

# Gestion des règles pfSense
nano /etc/pf.conf
# Ajouter avant les règles de blocage:
pass in quick proto udp from any to any port = 520  # Autoriser RIP

# Recharger les règles
pfctl -f /etc/pf.conf

# Installer Apache
sudo apt update && sudo apt upgrade -y
sudo apt install apache2 -y
sudo systemctl enable --now apache2

# Vérifier le statut
sudo systemctl status apache2

# Créer un nouveau site
sudo mkdir -p /var/www/monsite/html
sudo chown -R www-data:www-data /var/www/monsite
sudo chmod -R 755 /var/www/monsite

# Exemple de configuration
<VirtualHost *:80>
    ServerName monsite.local
    ServerAlias www.monsite.local
    DocumentRoot /var/www/monsite/html
    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined
    
    <Directory /var/www/monsite/html>
        Options -Indexes +FollowSymLinks
        AllowOverride All
        Require all granted
    </Directory>
</VirtualHost>

# Activer le site
sudo a2ensite monsite.conf
sudo systemctl reload apache2

# Installer PHP
sudo apt install php libapache2-mod-php php-mysql -y
sudo systemctl restart apache2

# Tester PHP
echo "" | sudo tee /var/www/monsite/html/info.php

# Activer le module security
sudo a2enmod security2
sudo systemctl restart apache2

# Configurer SSL avec Let's Encrypt
sudo apt install certbot python3-certbot-apache -y
sudo certbot --apache -d monsite.local -d www.monsite.local
sudo certbot renew --dry-run

# Lister toutes les imprimantes
Get-Printer | Format-Table Name, DriverName, PortName, Shared, Published

# Ajouter une imprimante locale
Add-Printer -Name "HP_LaserJet" -DriverName "HP LaserJet P3015 Series PCL6" -PortName "USB001"

# Ajouter une imprimante réseau
Add-Printer -ConnectionName "\\print-server\HP_Color_LaserJet"

# Configurer une imprimante partagée
Set-Printer -Name "HP_LaserJet" -Shared $true -ShareName "HP_LaserJet_Shared" -Published $true

# Supprimer une imprimante
Remove-Printer -Name "Old_Printer"

# Gérer les travaux d'impression
Get-PrintJob -PrinterName "HP_LaserJet" | Where-Object {$_.JobStatus -eq "Error"} | Remove-PrintJob
Restart-PrintJob -PrinterName "HP_LaserJet" -ID 5

# Installer un pilote d'imprimante
pnputil.exe -i -a "C:\Drivers\HP\*.inf"

# Lister tous les périphériques connectés
Get-PnpDevice | Where-Object {$_.Present} | Format-Table FriendlyName, Status, InstanceId

# Désactiver un périphérique USB
Disable-PnpDevice -InstanceId "USB\VID_0781&PID_5583\AA0123456789" -Confirm:$false

# Activer un périphérique
Enable-PnpDevice -InstanceId "USB\VID_0781&PID_5583\AA0123456789" -Confirm:$false

# Gérer les moniteurs
# (Nécessite l'installation de DisplaySwitch.exe via Windows SDK)
DisplaySwitch.exe /internal  # Utiliser uniquement l'écran intégré
DisplaySwitch.exe /external  # Utiliser uniquement l'écran externe
DisplaySwitch.exe /extend    # Étendre l'affichage
DisplaySwitch.exe /clone     # Dupliquer l'affichage

# Gérer les périphériques audio
Get-AudioDevice -List | Where-Object {$_.Type -eq "Playback"} | Format-Table Name, ID
Set-AudioDevice -ID "{0.0.0.00000000}.{a12b3c4d-5e67-8f90-1234-567890abcdef}"

# Lister les scanners disponibles (nécessite WIA)
$deviceManager = New-Object -ComObject WIA.DeviceManager
$deviceManager.DeviceInfos | Where-Object {$_.Type -eq 1} | Select-Object Properties

# Scanner un document (script avancé)
$device = $deviceManager.DeviceInfos.Item(1).Connect()
$scanner = $device.Items.Item(1)
$image = $scanner.Transfer()
$image.SaveFile("C:\Scans\document_$(Get-Date -Format 'yyyyMMddHHmmss').jpg")

# Lister les imprimantes
lpstat -p -d

# Installer une imprimante CUPS (Common Unix Printing System)
sudo lpadmin -p HP_LaserJet -E -v socket://192.168.1.10 -m drv:///HP/hp-laserjet.ppd.gz

# Définir l'imprimante par défaut
sudo lpoptions -d HP_LaserJet

# Soumettre un travail d'impression
lpr -P HP_LaserJet document.pdf

# Annuler un travail d'impression
lprm -P HP_LaserJet 15

# Gérer les files d'attente
lpq -P HP_LaserJet

# Configurer une imprimante réseau Samba
sudo lpadmin -p "Office_Printer" -E -v "smb://user:password@print-server/HP_Color" -m everywhere

# Lister tous les périphériques USB
lsusb
lsusb -v  # Version détaillée

# Identifier un périphérique spécifique
udevadm info -a -n /dev/sdb | grep -i "idVendor\|idProduct"

# Monter un périphérique USB
sudo mkdir /mnt/usbdrive
sudo mount /dev/sdb1 /mnt/usbdrive -o uid=1000,gid=1000

# Démontrer un périphérique USB
sudo umount /mnt/usbdrive

# Gérer les moniteurs avec xrandr
xrandr  # Lister les affichages disponibles
xrandr --output HDMI-1 --auto --right-of eDP-1  # Configurer multi-écrans
xrandr --output HDMI-1 --off  # Désactiver un écran

# Configurer les périphériques audio
pactl list short sinks  # Lister les périphériques de sortie
pactl set-default-sink alsa_output.pci-0000_00_1b.0.analog-stereo  # Définir la sortie par défaut

# Installer SANE (Scanner Access Now Easy)
sudo apt install sane sane-utils xsane

# Lister les scanners disponibles
scanimage -L

# Scanner un document (format PNG)
scanimage --format=png --output-file scan.png --resolution 300dpi --mode Color

# Scanner en PDF (nécessite imagemagick)
scanimage --format=tiff --resolution 300dpi | convert - scan.pdf

# Configurer un scanner réseau
sudo nano /etc/sane.d/net.conf
# Ajouter l'adresse IP du serveur de scanner: 192.168.1.20

#!/bin/bash
# Script Linux de surveillance USB
while true; do
    USB_DEVICES=$(lsusb | wc -l)
    if [ $USB_DEVICES -gt 2 ]; then
        echo "Alerte : Nouveau périphérique USB détecté $(date)" >> /var/log/usb_monitor.log
        lsusb >> /var/log/usb_monitor.log
    fi
    sleep 5
done

<#
# Script PowerShell pour déployer des imprimantes
$Printers = Import-Csv "C:\deploy\printers.csv"
foreach ($printer in $Printers) {
    if ($printer.Type -eq "Network") {
        Add-Printer -ConnectionName $printer.Path
    } else {
        Add-Printer -Name $printer.Name -DriverName $printer.Driver -PortName $printer.Port
    }
    if ($printer.Shared -eq $true) {
        Set-Printer -Name $printer.Name -Shared $true -ShareName $printer.ShareName
    }
}
#>

# Windows - Vérifier les erreurs de périphérique
Get-WinEvent -LogName System | Where-Object {$_.ProviderName -match "USB|Print"} | 
    Select-Object TimeCreated, Message | Format-Table -AutoSize

# Linux - Journal des périphériques
sudo journalctl -b | grep -i "usb\|print\|scanner"
sudo dmesg | grep -i "new device"

# Réinitialiser le sous-système USB (Linux)
echo 0 | sudo tee /sys/bus/usb/devices/usb1/authorized
echo 1 | sudo tee /sys/bus/usb/devices/usb1/authorized

# Réinstaller un pilote (Windows)
pnputil.exe /delete-driver oem0.inf /uninstall
pnputil.exe /add-driver "C:\Drivers\new_driver.inf" /install

# Capturer les paquets UDP RIP
tcpdump -i any or <Interface> port 250(ou autres selon la situation) -vv -n

# Capturer les paquets avec une adresse IP spécifique
tcpdump -i eth0 -nn 'host 224.0.0.9'

# Vérifier le trafic NAT
sudo tcpdump -i <interface_host_local> host NAT <IP_WINDOWS>

# Ping depuis une IP source spécifique
ping -S <IP source> -c 3 <IP Destination>

# Afficher la table de routage (Linux et Windows)
netstat -rn

# Afficher les logs RIP
grep RIP /var/log/system.log

# Afficher les logs RIP en temps réel
tail -f /var/log/system.log | grep ripd

# Vérifier le service RIP
ps aux | grep ripd

# Installer KVM sur Ubuntu
sudo apt install qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils virt-manager

# Vérifier que la virtualisation est activée
kvm-ok

# Connexion et informations de base
ssh root@adresse_ip_esxi                       # Se connecter à ESXi via SSH
vmware -v                                      # Afficher la version d'ESXi
esxcli system hostname get                     # Afficher les informations sur l'hôte
esxcli system version get 

# Gestion des VMs
vim-cmd vmsvc/getallvms                       # Lister toutes les VMs
vim-cmd vmsvc/power.on XX                     # Démarrer une VM (remplacez `XX` par l'ID de la VM)
vim-cmd vmsvc/power.off XX                    # Arrêter une VM
vim-cmd vmsvc/power.reset XX                  # Redémarrer une VM
vim-cmd vmsvc/power.getstate XX               # Voir l'état d'une VM

# Gestion du stockage
esxcli storage filesystem list                # Lister les datastores
df -h                                         # Voir l'espace disque disponible
ls -lh /vmfs/volumes/                         # Lister les volumes

# Transfert de fichiers
scp <Repertoire_source_fichier> root@<IP-Machine-ESXI>:/Volumes-Reprtoire_Destionation_Machine-ESXI
# Exemple: scp debian.iso root@192.168.100.10:/vmfs/volumes/ISO/

# Gestion réseau
esxcli network nic list                       # Lister les interfaces réseau
esxcli network vswitch standard list          # Voir les vSwitches
vmkping google.com                            # Tester la connectivité réseau

# Administration système
reboot                                        # Redémarrer l'hôte
poweroff                                      # Éteindre l'hôte

# MySQL dump complet
mysqldump -u root -p --all-databases > backup_complet_$(date +%Y%m%d).sql

# Sauvegarde d'une base spécifique
mysqldump -u root -p ma_base_de_donnees > backup_ma_base_$(date +%Y%m%d).sql

# Sauvegarde PostgreSQL complète
sudo pg_dumpall -U postgres > postgres_backup_$(date +%Y%m%d).sql

# Sauvegarde d'une base PostgreSQL spécifique
pg_dump -U postgres ma_base > postgres_ma_base_$(date +%Y%m%d).sql

# Compression immédiate
mysqldump -u root -p --all-databases | gzip > backup_$(date +%Y%m%d).sql.gz

# Sauvegarde avec timestamp
mysqldump -u root -p --all-databases > backup_$(date +"%Y%m%d_%H%M%S").sql

# Sauvegarde avec tar
sudo tar -czvf backup-$(date +%F).tar.gz /dossier/a/sauvegarder

# Sauvegarde avec exclusion de fichiers
tar -czvf backup-$(date +%F).tar.gz --exclude='*.tmp' --exclude='cache/*' /dossier

# Sauvegarde incrémentielle basée sur la date
tar -czvf backup-$(date +%Y%m%d).tar.gz /dossier/important

# Liste le contenu d'une archive
tar -tzf backup-2023-12-01.tar.gz

# Extraction d'archive
tar -xzvf backup-2023-12-01.tar.gz -C /dossier/restauration

# Sauvegarde incrémentielle avec liens durs
sudo rsync -av --delete --link-dest=/previous/backup /source /destination/backup-$(date +%F)

# Sauvegarde simple
rsync -av /source/ /destination/backup-$(date +%Y%m%d)/

# Sauvegarde avec exclusion
rsync -av --exclude='*.tmp' --exclude='cache/' /source/ /destination/

# Sauvegarde via SSH
rsync -av -e ssh /dossier/local/ utilisateur@serveur:/dossier/backup/

# Synchronisation bidirectionnelle
rsync -av /source/ /destination/ --update

# Planifier des sauvegardes avec cron
(crontab -l 2>/dev/null; echo "0 2 * * * /chemin/vers/script_backup.sh") | crontab -

# Exemple de crontab
# Tous les jours à 2h du matin
0 2 * * * /root/scripts/backup_daily.sh

# Tous les dimanches à 3h
0 3 * * 0 /root/scripts/backup_weekly.sh

# Tous les 1er du mois à 4h
0 4 1 * * /root/scripts/backup_monthly.sh

# Script de sauvegarde automatique exemple
#!/bin/bash
BACKUP_DIR="/backup/$(date +%Y%m%d)"
mkdir -p $BACKUP_DIR
mysqldump -u root -p --all-databases > $BACKUP_DIR/mysql_backup.sql
tar -czf $BACKUP_DIR/config_backup.tar.gz /etc/

# Règle 3-2-1
# 3 copies des données
# 2 supports différents
# 1 copie hors-site

# Script de rotation des sauvegardes
#!/bin/bash
BACKUP_DIR="/backup"
# Supprimer les sauvegardes de plus de 30 jours
find $BACKUP_DIR -name "backup_*" -mtime +30 -delete

# Vérification intégrité des sauvegardes
md5sum backup_file.tar.gz > backup_file.tar.gz.md5
md5sum -c backup_file.tar.gz.md5

# Sauvegarde différentielle exemple
tar -czf backup_full_$(date +%Y%m%d).tar.gz /data
tar -czf backup_diff_$(date +%Y%m%d).tar.gz -N "2023-12-01" /data

# Vérification de l'état du système (Linux)
top
htop
glances  # Version améliorée avec plus de métriques

# Surveillance des disques
iotop -o  # Affiche les E/S disque en temps réel
iftop     # Surveillance du trafic réseau

# Installer NetData (monitoring complet)
bash <(curl -Ss https://my-netdata.io/kickstart.sh)

# Prometheus (collecte de métriques)
# Installation:
wget https://github.com/prometheus/prometheus/releases/download/v2.30.3/prometheus-2.30.3.linux-amd64.tar.gz
tar xvfz prometheus-*.tar.gz
cd prometheus-*
./prometheus --config.file=prometheus.yml

# Grafana (visualisation)
sudo apt-get install -y grafana
sudo systemctl start grafana-server
sudo systemctl enable grafana-server

# Configurer Alertmanager avec Prometheus
global:
  resolve_timeout: 5m
route:
  group_by: ['alertname']
  receiver: 'email-notifications'
receivers:
- name: 'email-notifications'
  email_configs:
  - to: 'admin@example.com'
    from: 'alertmanager@example.com'
    smarthost: 'smtp.example.com:587'
    auth_username: 'user'
    auth_password: 'password'

# Scan de vulnérabilités avec OpenVAS
sudo apt install openvas
sudo gvm-setup
sudo gvm-start

# Analyse avec Lynis (audit de sécurité)
sudo lynis audit system

# Vérification des ports ouverts
nmap -sS -p- -T4 192.168.1.1  # Scan TCP SYN
nmap -sU -p- -T4 192.168.1.1  # Scan UDP

# CIS Benchmark (Windows)
Install-Module -Name CISBenchmark -Force
Get-CISBenchmark -Level 1 | Invoke-CISBenchmark

# Hardening Linux avec Bastille
sudo apt install bastille
sudo bastille -c

# Désactivation des services inutiles (Linux)
sudo systemctl list-unit-files --state=enabled
sudo systemctl disable [service_name]

# Analyse des processus suspects
ps aux | grep -E '(crypt|miner|attack)'

# Recherche de fichiers modifiés récemment
find / -type f -mtime -1 -print

# Capture de trafic suspect
tcpdump -i eth0 -w capture.pcap 'port not 22 and port not 80 and port not 443'

# Gestion des containers
docker ps -a                          # Lister tous les containers
docker stats                          # Statistiques en temps réel
docker inspect [container_id]         # Détails d'un container

# Gestion des images
docker images                         # Lister les images
docker image prune                    # Nettoyer les images inutilisées

# Réseau Docker
docker network ls                     # Lister les réseaux
docker network inspect bridge         # Inspecter un réseau

# Installation de Neko Navigateur avec Docker
docker run -d \
  --name neko \                               # Nom du projet dans docker
  -e NEKO_PASSWORD=34PenetrationTest \        # Mot de passe utilisateur Neko
  -e NEKO_PASSWORD_ADMIN=34PenetrationTest \  # Mot de passe Admin
  -p 8090:8080 \                           # Port d'accès à neko
  -p 52000-52100:52000-52100/udp \
  --shm-size=2gb \
  --cap-add=SYS_ADMIN \
  --device /dev/snd \
  --security-opt seccomp=unconfined \
  --rm \
  m1k1o/neko:firefox                       # Démarrer neko avec le navigateur firefox

# Déployer une stack
docker-compose -f stack.yml up -d

# Surveiller les logs
docker-compose logs -f --tail=100

# Scale de services
docker-compose up -d --scale web=3 --scale worker=5

# Commandes kubectl de base
kubectl get pods -A                   # Lister tous les pods
kubectl describe node [node_name]     # Détails d'un noeud
kubectl logs [pod_name]               # Voir les logs d'un pod

# Surveillance
kubectl top nodes                     # Utilisation ressources des noeuds
kubectl top pods                      # Utilisation ressources des pods

# Déploiement
kubectl apply -f deployment.yml       # Déployer une configuration
kubectl rollout status deployment/[deployment_name]

# Configuration AWS CLI
aws configure
aws configure set region eu-west-1

# Gestion EC2
aws ec2 describe-instances
aws ec2 start-instances --instance-ids i-1234567890abcdef0
aws ec2 create-image --instance-id i-1234567890abcdef0 --name "Backup-$(date +%Y%m%d)"

# Gestion S3
aws s3 ls
aws s3 cp fichier.txt s3://mon-bucket/
aws s3 sync ./local-folder s3://mon-bucket/backup/

# Gestion IAM
aws iam list-users
aws iam create-user --user-name new-user
aws iam attach-user-policy --user-name new-user --policy-arn arn:aws:iam::aws:policy/AdministratorAccess

# CloudFormation
aws cloudformation create-stack --stack-name my-stack --template-body file://template.yaml
aws cloudformation describe-stacks --stack-name my-stack

# Connexion Azure
az login
az account list --output table

# Gestion VM
az vm list --output table
az vm start --name MyVM --resource-group MyResourceGroup
az vm create --resource-group MyRG --name MyVM --image UbuntuLTS --admin-username azureuser

# Gestion Stockage
az storage account list --resource-group MyRG
az storage blob upload --account-name mystorage --container-name mycontainer --name blob.txt --file ./blob.txt

# Azure Resource Manager
az group create --name MyRG --location "West Europe"
az deployment group create --resource-group MyRG --template-file template.json

# Initialisation
terraform init
terraform init -upgrade

# Planification
terraform plan -out plan.tfplan
terraform plan -var "instance_type=t3.medium"

# Application
terraform apply
terraform apply -auto-approve
terraform apply plan.tfplan

# État et inspection
terraform state list
terraform state show aws_instance.web
terraform output

# Destruction contrôlée
terraform plan -destroy
terraform destroy -target=aws_instance.web

# Workspaces
terraform workspace new dev
terraform workspace select prod
terraform workspace list

# Test de connexion
ansible all -m ping -i inventory.ini

# Playbook simple
ansible-playbook -i inventory.ini playbook.yml
ansible-playbook playbook.yml --limit webservers
ansible-playbook playbook.yml --tags "nginx,ssl"

# Ad-hoc commands
ansible webservers -m apt -a "name=nginx state=latest" -b
ansible dbservers -m systemd -a "name=mysql state=started" -b
ansible all -m copy -a "src=config.txt dest=/etc/backup/"

# Vault pour secrets
ansible-vault create secret.yml
ansible-vault edit secret.yml
ansible-playbook playbook.yml --ask-vault-pass

# Galaxy roles
ansible-galaxy role install geerlingguy.nginx
ansible-galaxy collection install community.general

# Pipeline Jenkins déclaratif
pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'mvn clean compile'
            }
        }
        stage('Test') {
            steps {
                sh 'mvn test'
            }
        }
        stage('Deploy') {
            steps {
                sh 'ansible-playbook deploy.yml'
            }
        }
    }
}

# Scripts Groovy pour administration
println(Jenkins.instance.pluginManager.plugins)
Jenkins.instance.nodes.each { node ->
    println("${node.displayName}: ${node.computer.online}")
}

# Curl pour tests API
curl -X GET "https://api.example.com/v1/servers" -H "Authorization: Bearer $TOKEN"
curl -X POST "https://api.example.com/v1/deploy" -H "Content-Type: application/json" -d '{"version":"1.2.3"}'

# Webhook avec Python Flask
from flask import Flask, request
import subprocess

app = Flask(__name__)

@app.route('/webhook/deploy', methods=['POST'])
def deploy_webhook():
    if request.headers.get('X-GitHub-Event') == 'push':
        subprocess.run(['/opt/scripts/deploy.sh'])
        return 'Deployment triggered', 200
    return 'Ignored', 202

# Maintenance et performances
VACUUM (VERBOSE, ANALYZE) table_name;
REINDEX DATABASE database_name;
ANALYZE table_name;

# Surveillance avancée
SELECT * FROM pg_stat_activity WHERE state = 'active';
SELECT schemaname, tablename, n_dead_tup FROM pg_stat_all_tables ORDER BY n_dead_tup DESC;

# Backup avancé
pg_basebackup -D /backup/primary -h primary-host -U replicator -P -v
pg_dump -Fc database_name > backup.dump  # Format custom compressé

# Réplication
SELECT * FROM pg_replication_slots;
SELECT client_addr, state, sync_state FROM pg_stat_replication;

# Partitioning
CREATE TABLE measurement (
    city_id int not null,
    logdate date not null,
    peaktemp int
) PARTITION BY RANGE (logdate);

# Optimisation et tuning
SHOW ENGINE INNODB STATUS;
SHOW PROCESSLIST;
EXPLAIN ANALYZE SELECT * FROM large_table WHERE condition;

# Backup et réplication
mysqldump --single-transaction --routines --triggers database_name > backup.sql
mysqlpump --users --routines --events > full_backup.sql

# Réplication MySQL
SHOW MASTER STATUS;
SHOW SLAVE STATUS\G
CHANGE MASTER TO MASTER_HOST='master', MASTER_USER='repl', MASTER_PASSWORD='password';

# Performance Schema
SELECT * FROM performance_schema.events_statements_summary_by_digest ORDER BY sum_timer_wait DESC LIMIT 10;

# Opérations basiques
use mydb
db.collection.find({status: "active"}).sort({created_at: -1}).limit(10)
db.collection.createIndex({username: 1}, {unique: true})

# Agrégations
db.orders.aggregate([
    {$match: {status: "completed"}},
    {$group: {_id: "$customer_id", total: {$sum: "$amount"}}},
    {$sort: {total: -1}}
])

# Backup et restauration
mongodump --uri="mongodb://localhost:27017/mydb" --out=/backup/
mongorestore --uri="mongodb://localhost:27017/mydb" /backup/mydb/

# Performance
db.collection.explain().find({query: "condition"})
db.currentOp({"secs_running": {"$gte": 60}})

# Installation EVE-NG
wget -O - http://www.eve-ng.net/keys/eve-ng.gpg.key | sudo apt-key add -
echo "deb http://www.eve-ng.net/repo xenial main" | sudo tee /etc/apt/sources.list.d/eve-ng.list
sudo apt update && sudo apt install eve-ng

# Gestion des images
/opt/unetlab/addons/qemu/
chown -R root:root /opt/unetlab/addons/qemu/
/opt/unetlab/wrappers/unl_wrapper -a fixpermissions

# Accès web
https://[IP-EVE-NG]
# Identifiants par défaut : admin / eve

# Redémarrage des services
/opt/unetlab/wrappers/unl_wrapper -a restart

# Installation GNS3
sudo add-apt-repository ppa:gns3/ppa
sudo apt update
sudo apt install gns3-gui gns3-server

# Version All-in-One (Windows)
# Télécharger depuis : https://www.gns3.com/software/download

# Configuration serveur
gns3server
# Accès : http://localhost:3080

# Intégration VMware/VirtualBox
# Dans GNS3: Edit → Preferences → VirtualBox/VMware

# Installation via ISO
# Télécharger l'ISO depuis : https://customerconnect.vmware.com/

# Commandes ESXI utiles
esxcli system version get
esxcli network ip interface list
vim-cmd vmsvc/getallvms
vim-cmd vmsvc/power.on 1

# Configuration réseau
esxcli network ip interface ipv4 set -i vmk0 -t static -g 192.168.1.1 -I 192.168.1.10 -N 255.255.255.0

# Gestion stockage
esxcli storage filesystem list
esxcli storage nfs list

# Installation via ISO
# Télécharger : https://www.proxmox.com/en/downloads

# Commandes Proxmox
pvesh get /nodes
qm list
qm start 100
vzdump 100 --storage backup-storage --mode snapshot

# Création VM via CLI
qm create 200 --name "ubuntu-server" --memory 2048 --cores 2 --net0 virtio,bridge=vmbr0

# Gestion cluster
pvecm create CLUSTER_NAME
pvecm add NODE_IP

# Docker Compose Guacamole
version: '3'
services:
  guacamole:
    image: guacamole/guacamole
    ports: ["8080:8080"]
    environment:
      - GUACD_HOSTNAME=guacd
      - MYSQL_HOSTNAME=mysql
  guacd:
    image: guacamole/guacd
  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: guacamole_db
      MYSQL_USER: guacamole_user
      MYSQL_PASSWORD: guacamole_password

# Initialisation base
docker run --rm guacamole/guacamole /opt/guacamole/bin/initdb.sh --mysql > initdb.sql
docker exec -i mysql mysql -u root -prootpassword guacamole_db < initdb.sql

# Installation Neko avec Docker
docker run -d \
  --name=neko \
  --restart=unless-stopped \
  -e NEKO_PASSWORD=monMotDePasse \
  -e NEKO_PASSWORD_ADMIN=monMotDePasseAdmin \
  -p 8080:8080 \
  -p 52000-52100:52000-52100/udp \
  --shm-size=2gb \
  m1k1o/neko:firefox

# Accès : http://localhost:8080
# Identifiants : neko / monMotDePasse
# Admin : admin / monMotDePasseAdmin

# Version Chrome
docker run -d \
  --name=neko-chrome \
  -e NEKO_PASSWORD=password \
  -p 8081:8080 \
  m1k1o/neko:chromium

# Installation Docker
docker run -d -p 3000:3000 --name grafana grafana/grafana

# Installation native Ubuntu
sudo apt-get install -y adduser libfontconfig1
wget https://dl.grafana.com/oss/release/grafana_10.0.0_amd64.deb
sudo dpkg -i grafana_10.0.0_amd64.deb
sudo systemctl enable grafana-server
sudo systemctl start grafana-server

# Configuration datasource
apiVersion: 1
datasources:
  - name: Prometheus
    type: prometheus
    url: http://prometheus:9090
    access: proxy

# Accès : http://localhost:3000
# Identifiants par défaut : admin / admin

# Installation Prometheus
wget https://github.com/prometheus/prometheus/releases/download/v2.45.0/prometheus-2.45.0.linux-amd64.tar.gz
tar xvfz prometheus-*.tar.gz
cd prometheus-*
./prometheus --config.file=prometheus.yml

# Configuration de base
global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']
  - job_name: 'node_exporter'
    static_configs:
      - targets: ['localhost:9100']

# Node Exporter (métriques système)
docker run -d -p 9100:9100 --name node-exporter prom/node-exporter

# Installation avec Docker
version: '3.5'
services:
  zabbix-server:
    image: zabbix/zabbix-server-mysql:latest
    ports: ["10051:10051"]
    environment:
      DB_SERVER_HOST: zabbix-mysql
      MYSQL_USER: zabbix
      MYSQL_PASSWORD: zabbix-password

  zabbix-web:
    image: zabbix/zabbix-web-nginx-mysql:latest
    ports: ["80:8080", "443:8443"]
    environment:
      DB_SERVER_HOST: zabbix-mysql
      MYSQL_USER: zabbix
      MYSQL_PASSWORD: zabbix-password

  zabbix-mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_USER: zabbix
      MYSQL_PASSWORD: zabbix-password

# Installation 3CX
wget http://downloads.3cx.com/downloads/misc/debian10/3cxpbx.deb
dpkg -i 3cxpbx.deb

# Configuration réseau
# Accès web : https://ip-serveur:5001

# Diagnostic SIP
tcpdump -i any -n port 5060
tail -f /var/lib/3cxpbx/Data/Logs/*.log

# Commandes système
systemctl status nginx
systemctl status 3CXPhoneSystemMC01
systemctl status 3CXHttpServer

# Installation et démarrage
apt install suricata
suricata-update
suricata -c /etc/suricata/suricata.yaml -i eth0

# Configuration de base
# /etc/suricata/suricata.yaml
vars:
  address-groups:
    HOME_NET: "[192.168.0.0/16,10.0.0.0/8]"
    EXTERNAL_NET: "any"

# Surveillance alertes
tail -f /var/log/suricata/fast.log
jq '.' /var/log/suricata/eve.json | head -20

# Mise à jour règles
suricata-update
systemctl restart suricata

# Installation All-in-One
curl -sO https://packages.wazuh.com/4.5/wazuh-install.sh
sudo bash wazuh-install.sh --all-in-one

# Installation manuelle
# Serveur :
curl -s https://packages.wazuh.com/key/GPG-KEY-WAZUH | apt-key add -
echo "deb https://packages.wazuh.com/4.x/apt/ stable main" | tee /etc/apt/sources.list.d/wazuh.list
apt update
apt install wazuh-manager

# Agent Linux :
curl -s https://packages.wazuh.com/key/GPG-KEY-WAZUH | apt-key add -
echo "deb https://packages.wazuh.com/4.x/apt/ stable main" | tee /etc/apt/sources.list.d/wazuh.list
apt update
apt install wazuh-agent

# Installation GLPI
apt install glpi
mysql -u root -p -e "CREATE DATABASE glpi;"
mysql -u root -p -e "GRANT ALL ON glpi.* TO 'glpi'@'localhost';"

# Installation manuelle
wget https://github.com/glpi-project/glpi/releases/download/10.0.0/glpi-10.0.0.tgz
tar -xzf glpi-10.0.0.tgz
mv glpi /var/www/html/
chown -R www-data:www-data /var/www/html/glpi

# Agent FusionInventory
apt install fusioninventory-agent
fusioninventory-agent --server http://glpi-server/glpi/plugins/fusioninventory/

#!/bin/bash
# Script de déploiement automatique des outils du labo

LAB_TOOLS=("docker" "grafana" "prometheus" "zabbix")

deploy_tool() {
    case $1 in
        "docker")
            curl -fsSL https://get.docker.com -o get-docker.sh
            sh get-docker.sh
            usermod -aG docker $USER
            ;;
        "grafana")
            docker run -d -p 3000:3000 --name grafana grafana/grafana
            ;;
        "prometheus")
            docker run -d -p 9090:9090 --name prometheus prom/prometheus
            ;;
        "zabbix")
            docker-compose -f zabbix-docker-compose.yml up -d
            ;;
    esac
}

for tool in "${LAB_TOOLS[@]}"; do
    echo "Déploiement de $tool..."
    deploy_tool $tool
done

echo "Déploiement terminé !"

# Question simple à un modèle
aichat -m openai:deepseek "Explique brièvement la différence entre TCP et UDP."

# Sans streaming pour un affichage instantané
aichat -m openai:deepseek -S "Explique brièvement la différence entre TCP et UDP."

# Utiliser un fichier comme contexte
aichat -f mon_document.pdf -m openai:deepseek "Résume ce document."

# Démarrer le serveur local
aichat --serve 0.0.0.0:8080

# Question simple à un modèle
aichat -m openai:deepseek "Explique brièvement la différence entre TCP et UDP."

# Même chose, sans streaming pour un affichage instantané
aichat -m openai:deepseek -S "Explique brièvement la différence entre TCP et UDP."

# Lister les modèles disponibles
aichat --list-models

# Synchroniser les modèles depuis le dépôt officiel
aichat --sync-models

# Utiliser un fichier comme contexte
aichat -f mon_document.pdf -m openai:deepseek "Résume ce document."

# Démarrer le serveur local
aichat --serve 0.0.0.0:8080

# Gestion des modèles
aichat --list-models                    # Lister les modèles disponibles
aichat --sync-models                    # Synchroniser les modèles

# Gestion des sessions
aichat --list-sessions                  # Lister toutes les sessions
aichat -s, --session [SESSION]          # Démarrer ou rejoindre une session

# Rôles et agents
aichat --list-roles                     # Lister tous les rôles
aichat --list-agents                    # Lister tous les agents

# Fonctionnalités avancées
aichat -e, --execute                    # Exécuter des commandes naturelles
aichat -c, --code                       # Afficher uniquement le code généré
aichat --rag                       # Démarrer un RAG

# Options principales complètes
| Option                    | Description                                                          |
| ------------------------- | -------------------------------------------------------------------- |
| `-m, --model `     | Sélectionner un modèle. Exemple : `openai:deepseek`                  |
| `--prompt `       | Utiliser un **prompt système** spécifique                            |
| `-r, --role `       | Sélectionner un rôle préconfiguré                                    |
| `-s, --session [SESSION]` | Démarrer ou rejoindre une session                                    |
| `--empty-session`         | Forcer une session vide                                              |
| `--save-session`          | Sauvegarder la conversation dans la session                          |
| `-a, --agent `     | Démarrer un agent                                                    |
| `--rag `             | Démarrer un RAG (Retrieval-Augmented Generation)                     |
| `-e, --execute`           | Exécuter des commandes naturelles                                    |
| `-c, --code`              | Afficher uniquement le code généré                                   |
| `-f, --file `       | Inclure fichiers, dossiers ou URLs                                   |
| `-S, --no-stream`         | **Désactiver l'affichage progressif** (plus rapide dans le terminal) |
| `--dry-run`               | Afficher la requête sans l'envoyer                                   |
| `--info`                  | Afficher les informations du modèle ou session                       |
| `--sync-models`           | Synchroniser les modèles avec le dépôt officiel                      |
| `--list-models`           | Lister tous les modèles disponibles                                  |
| `--list-roles`            | Lister tous les rôles                                                |
| `--list-sessions`         | Lister toutes les sessions                                           |
| `--list-agents`           | Lister tous les agents                                               |
| `--list-rags`             | Lister tous les RAGs                                                 |
| `--list-macros`           | Lister tous les macros                                               |
| `--serve [
]`     | Démarrer le serveur API/WebApp                                       |
| `-h, --help`              | Afficher l'aide                                                      |
| `-V, --version`           | Afficher la version                                                  |

# Sites de référence pour commandes et cheat sheets
- https://linuxize.com/# : Linux Sysadmin and DevOps blog about articles,tutorials, server operations and security.
- https://cheat.sh/ : Cheat sheets pour toutes les commandes (curl cht.sh/commande)
- https://tldr.sh/ : Simplified man pages avec des exemples concrets
- https://ss64.com/ : Référence complète des commandes Windows/Linux
- https://explainshell.com/ : Explication détaillée des options de commandes shell
- https://phoenixnap.com/kb : Base de connaissances avec tutoriels et commandes
- https://devhints.io/ : Cheat sheets pour développeurs et administrateurs
- https://github.com/chubin/cheat.sh : Repository officiel avec toutes les cheat sheets
- https://www.commandlinefu.com/ : Commandes shell partagées par la communauté

# Sites de référence Linux
- https://linux.die.net/ : Linux Man Pages Online - Documentation complète des commandes Linux
- https://tldp.org/ : The Linux Documentation Project - Guides et HOWTOs Linux
- https://www.cyberciti.biz/ : nixCraft - Tutoriels et astuces Linux/Unix
- https://www.debian.org/doc/ : Debian Documentation - Documentation officielle Debian
- https://wiki.archlinux.org/ : ArchWiki - Documentation Arch Linux très complète
- https://help.ubuntu.com/ : Documentation officielle Ubuntu
- https://access.redhat.com/documentation/ : Documentation Red Hat Enterprise Linux
- https://docs.fedoraproject.org/ : Documentation Fedora

# Sites de référence Windows
- https://docs.microsoft.com/en-us/powershell/ : PowerShell Documentation - Documentation officielle PowerShell
- https://learn.microsoft.com/en-us/windows-server/ : Windows Server Docs - Documentation Windows Server
- https://docs.microsoft.com/en-us/sysinternals/ : Sysinternals - Outils et documentation système
- https://techcommunity.microsoft.com/ : Microsoft Tech Community
- https://docs.microsoft.com/en-us/windows/ : Documentation Windows client
- https://social.technet.microsoft.com/ : TechNet Forums
- https://gallery.technet.microsoft.com/ : Script Center

# Sites de référence Réseau
- https://www.cisco.com/c/en/us/support/index.html : Cisco Documentation - Documentation officielle Cisco
- https://www.routeralley.com/guides.html : RouterAlley - Guides réseaux et certifications
- https://www.packettracernetwork.com/ : PacketLife Cheat Sheets - Cheat sheets réseaux
- https://networklessons.com/ : Network Lessons - Cours réseaux en ligne
- https://www.firewall.cx/ : Firewall.cx - Réseau et sécurité
- https://www.juniper.net/documentation/ : Documentation Juniper
- https://www.arubanetworks.com/techdocs/ : Documentation Aruba Networks

# Sites de référence Bases de Données
- https://dev.mysql.com/doc/ : MySQL Documentation - Documentation officielle MySQL
- https://www.postgresql.org/docs/ : PostgreSQL Docs - Documentation PostgreSQL
- https://docs.mongodb.com/ : MongoDB Documentation
- https://docs.oracle.com/en/database/ : Documentation Oracle Database
- https://mariadb.com/kb/ : MariaDB Knowledge Base
- https://redis.io/documentation : Documentation Redis
- https://www.sqlite.org/docs.html : Documentation SQLite

# Sites de référence Containers
- https://docs.docker.com/reference/ : Docker Documentation - Référence Docker
- https://kubernetes.io/docs/home/ : Kubernetes Documentation - Docs officielles K8s
- https://docs.vmware.com/en/VMware-vSphere/index.html : vSphere Documentation - Documentation VMware
- https://pve.proxmox.com/wiki/ : Proxmox VE Wiki
- https://docs.ansible.com/ : Documentation Ansible
- https://www.vagrantup.com/docs : Documentation Vagrant
- https://www.packer.io/docs : Documentation Packer

# Sites de référence Sécurité
- https://owasp.org/www-project-cheat-sheets/ : OWASP Cheat Sheets - Sécurité applicative
- https://cheatsheetseries.owasp.org/ : OWASP Cheat Sheet Series - Sécurité web
- https://www.sans.org/blog/the-ultimate-list-of-sans-cheat-sheets/ : SANS Cheat Sheets - Sécurité informatique
- https://www.ncsc.gov.uk/guidance : NCSC Guidance - Centre national de cybersécurité UK
- https://csrc.nist.gov/publications : NIST Publications
- https://www.cisecurity.org/cis-benchmarks/ : CIS Benchmarks
- https://www.securityfocus.com/ : SecurityFocus

# Outils en ligne utiles
- https://www.regex101.com/ : Regex101 - Testeur d'expressions régulières
- https://jsonformatter.org/ : JSON Formatter - Validation et formatage JSON
- https://www.base64decode.org/ : Base64 Decode - Encodeur/décodeur Base64
- https://crontab.guru/ : Crontab Guru - Éditeur visuel de crontab
- https://www.url-encode-decode.com/ : URL Encode/Decode
- https://www.sqlformat.org/ : SQL Formatter - Formatage SQL
- https://www.diffchecker.com/ : Diff Checker - Comparaison de texte
- https://www.online-convert.com/ : Online Convert - Conversion de fichiers

# Forums et communautés techniques
- https://stackoverflow.com/ : Stack Overflow - Questions/réponses programmation
- https://serverfault.com/ : Server Fault - Administration système
- https://superuser.com/ : Super User - Questions utilisateur avancé
- https://www.reddit.com/r/sysadmin/ : Reddit Sysadmin
- https://www.reddit.com/r/networking/ : Reddit Networking
- https://community.spiceworks.com/ : Spiceworks Community
- https://discourse.ubuntu.com/ : Ubuntu Discourse
- https://forums.centos.org/ : CentOS Forums

# Sites de tutoriels et formations
- https://www.digitalocean.com/community/tutorials : DigitalOcean Tutorials
- https://linuxconfig.org/ : LinuxConfig - Tutoriels Linux
- https://www.howtoforge.com/ : HowtoForge - Guides Linux
- https://www.tecmint.com/ : Tecmint - Linux Howtos
- https://www.2daygeek.com/ : 2DayGeek - Articles techniques
- https://www.cyberciti.biz/ : nixCraft (déjà listé mais important)
- https://www.guru99.com/ : Guru99 - Tutoriels IT
- https://www.tutorialspoint.com/index.htm : TutorialsPoint