Debian
La distribution de la sagesse et des gens stables.
- [Debian] Nala
- [Debian] Raid mdadm
- [Debian] Serveur DNS
- [Debian] Serveur DHCP
- [Debian] Serveur Samba
- [Debian] Cockpit
- [Debian] Serveur NFS
- [Debian] Installation avec RAID
- [Debian] Serveur NTP
- [Debian] Serveur Apache
- [Debian] Serveur Nginx
- [Debian] ELK
- [Debian] Mauvais écran connexion
- [Debian] Flatpak
- [Debian] Serveur OpenVPN
- [Debian] Serveur Wireguard
- [Debian] SSHS
- [Debian] GlusterFS
- [Debian] Corosync
- [Debian] OpenSSL
- [Debian] LVM
- [Debian] LUKS
[Debian] Nala
Introduction
Nala est une surcouche au gestionnaire de paquet apt de Debian. Il permet d'avoir plus de couleurs et d'avoir un rendu beaucoup plus propre avec une interface ressemblant plus ou moins au gestionnaire de paquet dnf.
Il permet aussi des vitesses de téléchargement des paquets plus rapides grâce à ses tâches lancées en parallèle.
Source : Article d'Adrien Linuxtricks
Installation
Tout d'abord, assurez vous d'être connecté en root puis lancez cette commande :
wget -qO- https://deb.volian.org/volian/scar.key | gpg --dearmor | dd of=/usr/share/keyrings/volian-archive-scar.gpg && echo "deb [signed-by=/usr/share/keyrings/volian-archive-scar.gpg arch=amd64] https://deb.volian.org/volian/ scar main" > /etc/apt/sources.list.d/volian-archive-scar.list && apt update && apt install -y nala
Sélection des miroirs
Maintenant, on peut scanner les meilleurs miroirs et sélectionner les plus rapides grâce à la commande suivante :
nala fetch
Manuel
Voici une liste des options proposées par nala (l'utilisation est assez intuitive) :
Commands:
autopurge Autopurge packages that are no longer needed.
autoremove Autoremove packages that are no longer needed.
clean Clear out the local archive of downloaded package...
fetch Fetch fast mirrors to speed up downloads.
history Show transaction history.
install Install packages.
list List packages based on package names.
purge Purge packages.
remove Remove packages.
search Search package names and descriptions.
show Show package details.
update Update package list.
upgrade Update package list and upgrade the system.
[Debian] Raid mdadm
Introduction
Le raid logiciel est disponible sur les distributions Linux grâce à l'outil mdadm qui supporte les plus grands types de raid (RAID0, RAID1, RAID5, RAID10 etc).
Le tutoriel suivant sera réalisé sur une Debian 12 équipée d'un disque accueillant le système de 15Go ainsi que 2 disques de 1Go utilisées d'abord pour faire du raid0 puis pour faire du raid1 dans la seconde partie du tutoriel.
Sources :
Installation
Raid0
Dans l'exemple ci-dessous nous aurons 2 disques de 1Go en raid0.
Tout d'abord, partitionnez les disques avec fdisk en type fd (Linux raid) :
fdisk /dev/sda
Tapez l'enchaînement de touches suivant :
N / P / ENTER / ENTER / ENTER / T / FD / W
Faire la même opération avec le deuxième disque (/dev/sdb)
Créer le raid0 :
mdadm --create /dev/md0 --level=0 --raid-devices=2 /dev/sda1 /dev/sdb1
Vérifier l'état du raid :
mdadm --detail /dev/md0
Renommer le raid
Pour sauvegarder le nom du raid en md0, lancez cette commande :
mdadm --detail --scan > /etc/mdadm/mdadm.conf
Et pour prendre en compte les changements :
update-initramfs -u && reboot
Formater le système de fichiers du Raid
mkfs.ext4 /dev/md0
Monter le raid
Pour monter le raid manuellement et tester son bon fonctionnement on peut créer son point de montage et utiliser la commande mount :
mkdir /media/myRaid && mount /dev/md0 /media/myRaid
Si vous souhaitez conserver ce point de montage lors du redémarrage de la machine, il faut indiquer le raid dans le /etc/fstab :
/dev/md0 /media/myRaid ext4 defaults 0 0
On peut vérifier la configuration du fstab grâce à la commande suivante qui ne doit rien renvoyer si la configuration est bonne :
mount -a
Raid1
Une fois les partitions configurées, créez le raid1 :
mdadm --create /dev/md0 --level=1 --raid-devices=2 /dev/sda1 /dev/sdb1
Raid5
Dans cette configuration, nous avons un raid5 configuré avec 4 disques.
Une fois les partitions configurées, créez le raid5 :
mdadm --create /dev/md0 --level=5 --raid-devices=4 /dev/sda1 /dev/sdb1 /dev/sdc1 /dev/sdd1
Tester le raid
Afin de vérifier le bon fonctionnement du raid nous allons simuler la panne d'un des deux disques physiques.
Pour cela, nous allons supprimer un des deux disques dans VMware.
Une fois la machine redémarrée, le raid passe en état inactif comme on peut le voir :
On peut éteindre la machine pour ajouter un disque sur la VM afin de reconstruire le raid.
La première étape consiste à éteindre le raid actuel :
mdadm --stop /dev/md0
Une fois la machine redémarrée, nous devons créer la partition de type Linux Raid sur notre nouveau disque (se référer à la partie installation du raid).
Ensuite, il faut recréer le raid en indiquant le nouveau disque et l'ancien sans oublier l'option --assume-clean :
mdadm --create /dev/md0 --level=1 --assume-clean --raid-devices=2 /dev/sda1 /dev/sdb1
Le raid devrait se reconstruire sans perte de données !
Supprimer un raid
Tout d'abord, il faut penser à démonter le raid (s'il est monté) :
umount /dev/md0
Ensuite on peut éteindre le raid :
mdadm --stop /dev/md0
Et on supprime l'entrée (la ligne) du raid dans le /etc/fstab :
nano /etc/fstab
[Debian] Serveur DNS
Introduction
Un serveur DNS permet la résolution de noms de domaine en adresse IP et inversement sur un réseau.
Dans ce tutoriel nous utiliserons la solution Bind9 sur une Debian 11 ayant comme adresse IP 10.100.0.86.
Le domaine configuré sera elie.local.
Installation
- Installez le paquet bind :
apt update && apt install -y bind9
- Au cas où un fichier vous souhaiteriez restaurer les fichiers de configuration par défaut, je vous recommande de faire une sauvegarde de ces différents fichiers :
cp /etc/bind/named.conf /etc/bind/named.conf.bak
cp /etc/bind/named.conf.options /etc/bind/named.conf.options.bak
cp /etc/bind/named.conf.local /etc/bind/named.conf.local.bak
Configuration de forwarding
- Éditez le fichier /etc/bind/named.conf.options de sorte à obtenir cette configuration (à adapter) :
options{
directory "/var/cache/bind";
recursion yes;
allow-query { 10.100.0.0/24; 127.0.0.1; };
forwarders {
1.1.1.1;
8.8.8.8;
};
forward only;
dnssec-validation auto;
auth-nxdomain no;
listen-on-v6 { any; };
};
Vous pouvez choisir les DNS primaires et secondaires vers lesquels la redirection va se produire dans les forwarders, ici j'utilise celui de Cloudflare en primaire et celui de Google en secondaire.
Vérifier les configurations
Vous pouvez vérifier la configuration à l'aide de la commande suivante :
named-checkconf
Redémarrer le service DNS
Une fois que vous avez vérifié que votre configuration DNS est bonne, vous pouvez redémarrer le service named pour prendre en compte les changements :
systemctl restart named
Configuration de zone (classique)
- Éditez le fichier /etc/bind/named.conf.local pour configurer la zone DNS et ajoutez-y ce contenu (à adapter) :
// Configuration DNS
zone "elie.local" IN {
type master;
file "db.elie.local";
allow-update { none; };
};
// Configuration Reverse DNS sur un réseau 10.100.0.X
zone "0.100.10.in-addr.arpa" IN {
type master;
file "rev.elie.local";
allow-update { none; };
};
Ajout des entrées DNS
À chaque fois que vous voudrez ajouter une entrée DNS, il faudra écrire l'entrée le fichier de configuration DNS et dans le fichier de configuration du reverse DNS.
- Pour commencer, déplacez-vous dans le répertoire /var/cache/bind/ et créez votre fichier de configuration des enrtées DNS, ici c'est le fichier db.elie.local et ajoutez le contenu suivant (à adapter) :
$TTL 86400
@ IN SOA debian-dns.elie.local. root.elie.local. (
2022111401
1w
1d
4w
1w )
@ IN NS debian-dns.elie.local.
debian-dns IN A 10.100.0.86
; SET DNS RECORDS
mail IN A 10.100.0.200
debian-client-1 IN A 10.100.0.201
Ici, le serveur DNS ayant pour adresse IP 10.100.0.86 aura le nom debian-dns.elie.local qui est enregistré comme entrée de type A.
On peut voir en dessous qu'un serveur de messagerie et un poste client sont aussi enregistrés dans la base sous leurs noms respectifs (à vous de mettre vos propres entrées).
- Ensuite, toujours dans le répertoire /var/cache/bind/ il faut créer le fichier de configuration du reverse DNS, ici rev.elie.local :
$TTL 86400
@ IN SOA debian-dns.elie.local. root.elie.local. (
2022111401
1w
1d
4w
1w )
@ IN NS debian-dns.elie.local.
86 IN PTR debian-dns.elie.local
; SET DNS RECORDS
200 IN PTR mail.elie.local
201 IN PTR debian-client-1.elie.local
On s'aperçoit que le contenu est similaire à la configuration du DNS avec un différence majeure au niveau des entrées DNS qui sont de type PTR et où on indique la valeur du dernier octet de l'adresse IP pointant vers le nom correspondant.
Par exemple on reconnait l'entrée du serveur de messagerie "200 IN PTR mail.elie.local" où 200 correspond au dernier octet de son adresse c'est à dire 10.100.0.200.
Modification des droits des fichiers
Afin que Bind puisse exploiter vos fichiers de configuration, les bons droits doivent être mis dessus :
chgrp bind /var/cache/bind/*
chmod 664 /var/cache/bind/*
Modification de /etc/resolv.conf
Il faut indiquer au serveur que le serveur DNS correspond désormais à lui-même dans le fichier /etc/resolv.conf :
echo "nameserver 10.100.0.86" > /etc/resolv.conf
Vérifier les configurations
Voici les deux commandes "magiques" qui permettent de vérifier que les configurations sont correctes :
named-checkconf
L'option -z permet d'être beaucoup plus verbeux quant aux erreurs que vous pouvez rencontrer :
named-checkconf -z
Redémarrer le service DNS
Une fois que vous avez vérifié que votre configuration DNS est bonne, vous pouvez redémarrer le service named pour prendre en compte les changements :
systemctl restart named
Configuration de vues (avancé)
Cette approche est particulière puisque contrairement à la configuration en mode zone, nous pourrons définir des entrées et des traitements différents selon l'interface par laquelle la requête DNS va entrer.
Le domaine sera toujours elie.local .
Pour cet exemple nous aurons un lab avec 2 réseaux :
Réseaux | Adresse réseau |
LAN | 192.168.0.0/24 |
DMZ | 10.0.0.0/24 |
Ainsi que 3 machines :
Machine | Adresse interface LAN | Adresse interface DMZ | Rôle |
vm-deb01 | 192.168.0.253 | 10.0.0.253 | Serveur DNS |
vm-deb02 | 192.168.0.1 | / | Client LAN |
vm-deb03 | / | 10.0.0.1 | Serveur web |
- L'ensemble des configurations se fera dans le dossier /etc/bind cette fois :
cd /etc/bind/
- Voici à quoi doit ressembler le fichier named.conf.options :
acl myclients { 127.0.0.0/8; 192.168.0.0/24; 10.0.0.0/24; };
options {
directory "/var/cache/bind";
forwarders { 1.1.1.1; };
dnssec-validation auto;
forward only;
listen-on { 127.0.0.1; 192.168.0.253; 10.0.0.253; };
allow-transfer { none; };
allow-query { myclients; };
};
- Le fichier named.conf.zones :
zone "elie.local" {
type master;
file "/etc/bind/localzones/db.elie.local";
};
zone "elie.local" {
type master;
file "/etc/bind/localzones/db.elie.local.external";
};
- Le fichier common-zones.conf :
zone "elie.local" {
type master;
file "/etc/bind/localzones/db.elie.local";
};
zone "elie.local" {
type master;
file "/etc/bind/localzones/db.elie.local.external";
};
- Le fichier named.conf :
// This is the primary configuration file for the BIND DNS server named.
//
// Please read /usr/share/doc/bind9/README.Debian for information on the
// structure of BIND configuration files in Debian, *BEFORE* you customize
// this configuration file.
//
// If you are just adding zones, please do that in /etc/bind/named.conf.local
include "/etc/bind/named.conf.options";
include "/etc/bind/named.conf.local";
#include "/etc/bind/named.conf.default-zones";
view "local" {
match-clients { 192.168.0.0/24; };
allow-query { any; };
recursion no;
zone "elie.local" {
type master;
file "/etc/bind/localzones/db.elie.local";
};
include "/etc/bind/named.conf.default-zones";
};
view "external" {
match-clients { 10.0.0.0/24; };
allow-query { any; };
recursion no;
zone "elie.local" {
type master;
file "/etc/bind/localzones/db.elie.local.external";
};
include "/etc/bind/named.conf.default-zones";
};
- Le fichier named.conf.internal-zones :
view "internal" {
# match all except targets defined on [match-clients] on internal section
match-clients { 127.0.0.0/8; 192.168.0.0/24 };
# allow all queries
allow-query { any; };
# not allow recursive queries
recursion no;
zone "elie.local" {
type master;
file "/etc/bind/localzones/db.elie.local";
};
include "/etc/bind/named.conf.default-zones";
};
- Le fichier named.conf.external-zones :
view "external" {
# match all except targets defined on [match-clients] on internal section
match-clients { 10.0.0.0/24; };
# allow all queries
allow-query { any; };
# not allow recursive queries
recursion no;
zone "elie.local" {
type master;
file "/etc/bind/localzones/db.elie.local.external";
};
include "/etc/bind/named.conf.default-zones";
};
- Créer un dossier localzones et se déplacer dedans :
mkdir localzone && cd localzone
- Créer le fichier de la zone interne soit db.elie.local :
$TTL 86400
@ IN SOA vm-deb01.elie.local. root.elie.local. (
2022111401
1w
1d
4w
1w
)
@ IN NS vm-deb01.elie.local.
vm-deb01 IN A 192.168.0.253
; SET DNS RECORDS
vm-deb02 IN A 192.168.0.1
- Créer le fichier de la vue externe soit db.elie.local.external :
$TTL 86400
@ IN SOA vm-deb01.elie.local. root.elie.local. (
2022111402
1w
1d
4w
1w
)
@ IN NS vm-deb01.elie.local.
vm-deb01 IN A 10.0.0.253
; SET DNS RECORDS
web-srv IN A 10.0.0.1
- Créer le fichier du reverse DNS de la vue interne rev.elie.local :
$TTL 86400
@ IN SOA vm-deb01.elie.local. root.elie.local. (
2022111401
1w
1d
4w
1w
)
@ IN NS vm-deb01.elie.local.
253 IN PTR vm-deb01.elie.local
; SET DNS RECORDS
1 IN PTR vm-deb02.elie.local
- Créer le fichier du reverse DNS de la vue externe rev.elie.local :
$TTL 86400
@ IN SOA vm-deb01.elie.local. root.elie.local. (
2022111401
1w
1d
4w
1w
)
@ IN NS vm-deb01.elie.local.
253 IN PTR vm-deb01.elie.local
; SET DNS RECORDS
1 IN PTR web-srv.elie.local
[Debian] Serveur DHCP
Introduction
Un serveur DHCP permet d'attribuer automatiquement des adresses IP aux hôtes se connectant sur le réseau.
Dans ce guide, nous allons utiliser une Debian 12 avec l'outil dhcpcd qui va nous permettre de configurer le service DHCP.
Source :
Prérequis
- Définir une adresse IP statique sur votre futur serveur DHCP.
Installation
Tout d'abord, installez le paquet le paquet approprié :
apt update && apt install -y isc-dhcp-server
Indiquer dans le fichier /etc/default/isc-dhcp-server l'interface d'écoute du serveur DHCP et décommenter cette ligne :
DHCPDv4_CONF=/etc/dhcp/dhcpd.conf
Et en ajoutant le nom des interfaces :
INTERFACESv4="ens33"
INTERFACESv6="ens33"
Configuration
La configuration se trouve dans le fichier /etc/dhcp/dhcpd.conf .
Voici un template de configuration :
default-lease-time 86400; # Bail de 24H
max-lease-time 172800; # Bail maxi de 48H
# Déclaration d'un réseau
subnet 192.168.0.0 netmask 255.255.255.0 {
range 192.168.0.100 192.168.0.199; # Plage IP
option domain-name-servers 192.168.0.253; # DNS
option routers 192.168.0.254; # Passerelle
}
On peut aussi ajouter des entrées d'hôtes où l'adresse IP doit être fixe en faisant une réservation d'adresse :
host work-l-arch {
hardware ethernet 10:bf:48:13:f6:cc;
fixed-address 192.168.0.120;
}
On peut aussi si on le souhaite, refuser le service DHCP à un hôte en spécifiant son adresse MAC de la même façon :
host work-l-arch {
hardware ethernet 10:bf:48:13:f6:cc;
deny booting;
}
Démarrage et activation du service
systemctl enable --now isc-dhcp-server
[Debian] Serveur Samba
Introduction
Le service samba est disponible sur les différentes distributions Linux et permet de partager des fichiers comme le ferait un serveur FTP par exemple mais permet la compatibilité native avec Windows ce qui est intéressant.
Source
Installation
Commencez par installer le paquet samba :
sudo apt install -y samba
Puis configurez un partage :
nano /etc/samba/smb.conf
[<SHARE_NAME>]
comment = Partage de données
path = <SHARE_PATH>
valid users = admin @LECTEURS
guest ok = no
read only = no
browseable = yes
create mask = 0664
directory mask = 0775
force group = LECTEURS
Cette configuration autorise un utilisateur admin (qui a les droits d'écriture) ainsi que les utilisateurs du groupe LECTEURS qui ont seulement les droits de lecture sur le partage). Vous pouvez bien sûr modifier cette configuration à souhait.
D'ailleurs, pensez à vérifier que l'utilisateur est bien propriétaire du dossier du partage.
Définissez un mot de passe samba à votre utilisateur :
smbpasswd -a <USER>
Vous pouvez tester votre fichier de configuration grâce à la commande testparm :
testparm
Enfin, activez et démarrez le service samba :
systemctl enable --now smbd
Monter un partage
Ensuite ce qui est intéressant c'est de monter le partage que l'on vient de créer sur le client qui va l'utiliser.
Tout d'abord, installez le paquet cifs-utils :
sudo apt update && sudo apt install -y cifs-utils
Créez le fichier contenant les identifiants du partage et enlevez lui les droits de lecture :
sudo nano /root/.creds
username=myUser
password=myPass
domain=WORKGROUP
sudo chmod 600 /root/.creds
Créez le dossier qui va accueillir le point de montage :
sudo mkdir /media/share
Testez le montage de votre partage :
sudo mount -t cifs -o credentials=/root/.creds //<IP>/<SHARE> /media/share
Afin de rendre persistent votre point de montage, éditez le fichier /etc/fstab :
sudo nano /etc/fstab
Et ajoutez une entrée de la sorte :
//<IP>/<SHARE> </media/share> cifs uid=0,credentials=/root/.creds-nas,iocharset=utf8,vers=3.0 0 0
[Debian] Cockpit
Introduction
Un peu de la même manière que Webmin, Cockpit est une solution de gestion de votre serveur directement par l'interface web.
Cette solution a été développée par RedHat mais est disponible sur la plupart des distributions Linux dont Debian.
Il fonctionne par défaut sur le port 9090.
Source
Installation
sudo apt update && sudo apt install -y cockpit && sudo systemctl enable --now cockpit.socket
Activer le compte root
Par défaut, le compte root est désactivé et nécessite de commenter son entrée dans le fichier /etc/cockpit/disallowed-users :
# List of users which are not allowed to login to Cockpit
#root
[Debian] Serveur NFS
Introduction
Le service NFS pour Network File System est généralement le protocole de partage de fichier à privilégier sur Linux pour sa performance.
Contrairement à la plupart des autres protocoles, il n'est pas basé sur un système d'authentification mais autorise un hôte ou un sous-réseau à se connecter au partage.
Source
Installation du serveur
Tout d'abord, installez le paquet nfs-kernel-server :
sudo apt install nfs-kernel-server
Dans le cas où votre partage sera utilisé via votre nom de domaine, modifiez le fichier idmapd.conf :
Domain = <YOUR_FQDN>
Démarrez et activez le service NFS :
sudo systemctl enable --now nfs-server.service
Configurez vos partages NFS dans le fichier /etc/exports en respectant ce format :
<SHARED_FOLDER_PATH>/ <IP>/<CIDR_MASK>(rw,sync,no_root_squash)
Pour prendre en compte les modifications :
sudo exportfs -a
Montage sur le client
Maintenant que votre partage NFS est configuré côté serveur, il faut monter le partage côté client.
Pour cela, commencez par installer le paquet nfs-common :
sudo apt install nfs-common
Créez le dossier qui va contenir le point de montage pour le partage NFS :
mkdir -p <MOUNT_POINT>
Puis montez le partage :
mount -t nfs <NFS_SERVER_IP>:<NFS_SHARE> <MOUNT_POINT>
Vous pouvez afficher les partages actifs montés sur le client :
showmount -e
On peut ajouter le partage dans le /etc/fstab pour qu'il soit persistent après le démarrage :
<SRV_IP>:<SHARE> <MOUNT_POINT> nfs auto,_netdev,nofail 0 0
[Debian] Installation avec RAID
Introduction
Ce TP est réalisé dans le cadre d'un cours à l'ESGI, et a pour but de mettre en place un serveur Debian fonctionnel avec 2 disques de 20Go où on retrouve la configuration suivante :
- Pas de raid pour la partition de démarrage.
- Raid0 pour le swap de 1G sur chaque disque.
- Raid1 en ext4 pour la partition racine.
L'installation sera réalisée dans mon cas sur une machine virtuelle sous Proxmox mais peut très bien fonctionner dans d'autres configurations.
Installation
Je ne détaillerai pas la création de la VM ni le début de l'installation de Debian car elle est tout à fait traditionnelle.
Arrêtons-nous sur le partitionnement des disques et sélectionnons le disque sda :
Il nous est demandé si on souhaite créer une nouvelle table des partitions, faites Oui :
On réitère pour le disque sdb :
Il faut ensuite créer la partition de démarrage ainsi que les partitions pour accueillir les raids.
On commence par créer une partition primaire de 512MB sur le disque sda qui sera formatée en FAT32, qui aura comme point de montage /boot/efi et qui accueillera l'indicateur d'amorçage :
On peut maintenant créer les partitions qui seront utilisés comme volume physique pour RAID :
Je rappelle qu'on vient créer une partition de 1GB pour le SWAP et une partition de 20GB pour le système sur chaque disque.
On obtient donc la configuration suivante :
On notera qu'il reste un peu d'espace sur le deuxième disque qui représente l'espace qui a été utilisé sur le premier disque par la partition de démarrage.
On peut maintenant Configurer le RAID avec gestion logicielle :
On commence par le RAID0 de la SWAP :
On sélectionnes les deux partitions de 1Go :
On réitère l'opération pour le RAID du système:
Cette fois on configure un RAID1 :
Dans notre configuration, nous n'aurons pas de disque de réserve (spare), laissez 0 :
On sélectionnes les deux partitions de 20Go :
Et on peut Terminer la configuration des périphériques RAID :
Désormais, on sélectionne le Périphérique RAID0 pour configurer la SWAP :
Puis on sélectionne le périphérique RAID1 pour configurer la racine du système :
On peut enfin Terminer le partitionnement et appliquer les changements :
Vous pouvez poursuivre l'installation du système de manière standard sauf pour l'installation de GRUB où vous allez devoir sélectionner le disque /dev/sda :
Vérification de la configuration
Une fois le système redémarré, on peut s'assurer de la configuration des partitions grâce à la commande lsblk :
Puis on peut vérifier l'état du RAID0 grâce à la commande mdadm --detail /dev/md0 :
Et enfin, l'état du RAID1 grâce à la commande mdadm --detail /dev/md1 :
[Debian] Serveur NTP
Introduction
Il peut être utile d'installer un serveur de temps sur un réseau lorsque vous faites des opérations qui nécessitent que les horloges de vos différents systèmes soient synchronisées.
Installation serveur
Commencez par installer le paquet ntp sur le serveur :
apt update && apt install -y ntp
Puis passez à la configuration de votre serveur en éditant le fichier /etc/ntpsec/ntp.conf.
Commencez par commenter (avec le #) les pools de Debian définis par défaut :
#pool 0.debian.pool.ntp.org iburst
#pool 1.debian.pool.ntp.org iburst
#pool 2.debian.pool.ntp.org iburst
#pool 3.debian.pool.ntp.org iburst
Vous pouvez configurer un serveur de temps de strate supérieur (qui servira de référence) en ajoutant cette ligne :
server <NTP_SERVER>
Dans notre cas, nous utiliserons un serveur de temps public qui est 0.fr.pool.ntp.org :
server 0.fr.pool.ntp.org
On peut ensuite configurer les restrictions qui permettent de définir qui aura le droit d'utiliser notre serveur de temps.
Dans notre cas, ce sera l'ensemble du réseau local 192.168.5.0/24 :
restrict 0.fr.pool.ntp.org
restrict 192.168.5.0 netmask 255.255.255.0
restrict default none
Pensez à supprimer les restrictions par défaut.
Puis il faut en dernier lieu utiliser fudge afin de rafraîchir automatiquement l'horloge et définir le niveau de strate :
fudge 127.127.0.1 9
On peut ensuite redémarrer et activer le serveur de temps pour prendre en compte notre configuration :
systemctl enable --now ntp
Configuration client
Debian
Installez les paquets ntp et ntpdate :
apt update && apt install -y ntp ntpdate
Puis configurez le serveur à utiliser en éditant le fichier /etc/ntpsec/ntp.conf :
server <IP|FQDN>
On peut ensuite définir la fréquence de rafraîchissement de la récupération du temps sur le serveur :
minpoll <VALUE>
maxpoll <VALUE>
La valeur doit être égale à la racine carré du nombre de seconde que vous souhaitez (ex: pour un rafraîchissement toutes les 16 secondes la valeur sera égale à 4 car 2^4 = 16).
On peut ensuite redémarrer le service ntp et interroger le serveur avec ntpdate :
systemctl restart ntp
ntpdate <IP|FQDN>
Windows
Rendez vous dans le Panneau de configuration puis dans Horloge et région :
Cliquez sur Ajouter des horloges pour des fuseaux horaires variés :
Accédez à l'onglet Temps Internet et cliquez sur Modifier les paramètres :
Et enfin vous pouvez saisir l'adresse IP ou le FQDN de votre serveur de temps et cliquer sur Mettre à jour puis OK :
[Debian] Serveur Apache
Introduction
Le serveur Apache permet d'héberger des sites web sur votre machine Linux de manière très simple en effectuant un minimum de commandes.
Installation
Apache2
Tout d'abord, installez le paquet apache2 :
sudo apt update && sudo apt install -y apache2
Ensuite, vérifiez que le serveur web est fonctionnel en vous saisissant l'adresse IP de la machine Debian dans l'URL de votre navigateur en utilisant le protocole http :
http://<IP>
PHP
Tout d'abord, installez les paquets nécessaires au fonctionnement de PHP :
sudo apt install -y php libapache2-mod-php
Puis redémarrez le service apache :
sudo systemctl restart apache2
MariaDB
Commencez par installer le paquet mariadb-server :
sudo apt install -y mariadb-server
Vous pouvez ensuite lancer la configuration de votre SGBD avec la commande suivante :
sudo mysql_secure_installation
Puis vous pouvez vous connecter à MariaDB grâce à cette commande :
sudo mysql -u root -p
[Debian] Serveur Nginx
Introduction
Les serveurs Nginx permettent d'héberger des serveurs web tout comme Apache mais tolèrent davantage de configuration et apporte de meilleures performances. Nginx est considéré plus professionnel.
Installation
Nginx
Tout d'abord, installez le paquet nginx :
sudo apt install -y nginx
Les fichiers html et css de votre site web sont stockées dans /var/www/html .
Vous pouvez accéder à votre site web en saisissant l'adresse IP de votre machine Debian dans l'URL de votre navigateur en utilisant le protocole http :
http://<IP>
PHP
Tout d'abord installez le paquet php-fpm :
sudo apt install -y php-fpm
Ensuite éditez le fichier de configuration /etc/nginx/sites-enabled/default pour décommenter la section qui ressemble à ceci :
location ~ \.php$ {
include snippets/fastcgi-php.conf;
fastcgi_pass unix:/run/php/php8.2-fpm.sock; # Le chemin peut varier selon votre version PHP
}
Pensez à vérifier la version de php en utilisant la commande "ls /run/php".
Enfin, n'oubliez pas de redémarrer les services pour appliquer les changements :
sudo systemctl restart php8.2-fpm nginx
[Debian] ELK
Introduction
La suite ELK pour Elastic Logstash et Kibana est un ensemble d'outil de sécurité qui permettent de collecter, indexer, parser et afficher les logs.
Ces outils sont complémentaires et primordiaux pour la blue team.
Sources
- Documentation officielle - Installation Elasticsearch
- Documentation officielle - Installation Logstash
- Documentation officielle - Installation Kibana
Installation
Prérequis
Tout d'abord, il faut importer la clé GPG pour être en mesure d'installer les outils de la suite ELK :
wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | gpg --dearmor -o /usr/share/keyrings/elasticsearch-keyring.gpg && apt-get install apt-transport-https && echo "deb [signed-by=/usr/share/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/7.x/apt stable main" | tee /etc/apt/sources.list.d/elastic-7.x.list && apt-get update
Elasticsearch
Voici la commande pour installer Elasticsearch :
apt install -y elasticsearch
Démarrez et activez le service elasticsearch :
systemctl enable --now elasticsearch
La configuration globale d'elasticsearch se trouve dans le fichier /etc/elasticsearch/elasticsearch.yml .
Ensuite, configurez le mot de passe de l'utilisateur elastic grâce à cette commande :
/usr/share/elasticsearch/bin/elasticsearch-reset-password -u elastic -i
Le service est désormais disponible depuis le navigateur en vous rendant sur https://<IP>:9200 .
Logstash
Voici la commande pour installer Logstash :
apt install -y logstash
Logstash peut être configuré à travers le fichier /etc/logstash/conf.d/beats.conf .
Démarrez et activez le service logstash :
systemctl enable --now logstash
Le service est désormais disponible sur le port 5044 .
Filebeat
Voici la commande pour installer Filebeat :
apt install -y filebeat
Logstash peut être configuré à travers le fichier /etc/filebeat/filebeat.yml .
Démarrez et activez le service filebeat :
systemctl enable --now filebeat
Kibana
Voici la commande pour installer Kibana :
apt install -y kibana
Kibana peut être configuré à travers le fichier /etc/kibana/kibana.yml .
Démarrez et activez le service kibana :
systemctl enable --now kibana
Le service est désormais disponible sur l'url http://<IP>:5601 .
Pour activer Kibana, il vous sera demandé un token d'enrollement qui peut être généré grâce à la commande suivante :
/usr/share/kibana/bin/kibana-verification-code
Ensuite, un code de vérification vous sera demandé, tapez cette commande pour l'obtenir :
/usr/share/elasticsearch/bin/elasticsearch-create-enrollment-token -s kibana
[Debian] Mauvais écran connexion
Introduction
Il se peut qu'après une nouvelle installation vous ayez le mauvais écran pour l'écran de verrouillage.
Dans ce cas vous pouvez essayer la technique ci-dessous.
Résolution
Copier la configuration locale dans le dossier de configuration de GDM :
sudo cp .config/monitors.xml /var/lib/gdm3/.config/
Si /var/lib/gdm3 n'existe pas, essayez avec /var/lib/gdm !
Puis redémarrez GDM pour vérifier que la manipulation a fonctionnée :
sudo systemctl restart gdm
[Debian] Flatpak
Introduction
Les dépôts Flatpak permettent d'étendre votre logithèque et d'installer des logiciels non disponibles normalement.
Installation
Tout d'abord, installez le paquet flatpak :
apt install -y flatpak
Puis ajoutez le dépôts flathub :
flatpak remote-add --if-not-exists flathub https://dl.flathub.org/repo/flathub.flatpakrepo
Manuel
Pour installer un paquet flatpak :
flatpak install <PKG>
[Debian] Serveur OpenVPN
Introduction
Ce tutoriel décrit la procédure d'installation d'un serveur OpenVPN sous Debian.
OpenVPN est une bonne solution lorsque vous travaillez avec du matériel assez ancien, sinon je recommande d'utiliser Wireguard qui est plus performant et qui réduira grandement le ping.
Pour l'installation, un script sera utilisé pour gagner du temps et générer automatiquement les certificats.
Installation du serveur
- Téléchargez et lancez le script d'installation rapide :
wget https://git.io/vpn -O openvpn-install.sh && bash openvpn-install.sh
L'adresse IP du serveur publique (adresse utilisée par les clients pour se connecter) vous est demandé :
Ensuite, vous devez choisir le protocole qu'OpenVPN utilisera :
Puis saisissez le numéro de port que le service OpenVPN devra utiliser :
Vient après la configuration du serveur DNS :
Saisissez le nom d'un premier client :
Le serveur VPN est prêt à être utilisé !
Vous pouvez créer de nouveaux clients en exécutant de nouveau le script.
Installation des clients
Windows
Debian
apt install -y openvpn
openvpn <CONFIG>.ovpn
[Debian] Serveur Wireguard
Introduction
Wireguard est un service VPN récent, sécurisé et performant.
Il peut fonctionner dans plusieurs configurations différentes mais utilise exclusivement le protocole UDP.
Source
Installation du serveur
Réseau privé
Wireguard peut fonctionner en mode réseau simple, c'est à dire qu'il va vous permettre d'établir un réseau avec les hôtes que vous connecterez en mode P2P. Il n'y aura pas de serveur VPN à proprement parler ni une nouvelle passerelle par défaut pour les hôtes.
- Tout d'abord, installez le paquet wireguard :
apt install -y wireguard
Ensuite, éditez la configuration de votre premier noeud à travers le fichier /etc/wireguard/wg0.conf :
[Interface]
PrivateKey = <PRV_KEY>
Address = <SRV_IP>/<CIDR_IP>
ListenPort = 51820
- Dans un deuxième terminal, lancez la génération de :
- La clé privée du serveur :
wg genkey | sudo tee /etc/wireguard/wg-private.key
- La clé publique du serveur :
cat /etc/wireguard/wg-private.key | wg pubkey | sudo tee /etc/wireguard/wg-public.key
Vous pouvez réitérer les deux commandes ci-dessus pour générer une paire clé privée/publique pour chaque hôte du réseau VPN.
Ensuite, pour chaque hôte, ajoutez cela dans la configuration du serveur :
[Peer]
PublicKey = <NODE_PUB_KEY>
AllowedIPs = <NET_ID>/<CIDR_MASK>
Endpoint = <PUBLIC_SERVER_IP>:51820
Une fois que vous avez configurer le serveur et les hôtes, vous pouvez démarrer le serveur wireguard :
wg-quick up wg0
Vous devinerez que pour l'éteindre il s'agit de cette commande :
wg-quick down wg0
Pour activer le service à chaque démarrage, exécutez la commande suivante :
systemctl enable wg-quick@wg0.service
Installation des hôtes
Tout d'abord, installez le paquet wireguard :
apt install -y wireguard
Ensuite, créez le fichier de configuration du client /etc/wireguard/wg0.conf :
[Interface]
PrivateKey = <NODE_PRV_KEY>
Address = <NODE_VPN_IP>/<CIDR_IP>
[Peer]
PublicKey = <SRV_PUB_KEY>
AllowedIPs = <NET_ID>/<CIDR_MASK>
Endpoint = <PUBLIC_SRV_IP>:51820
Et démarrez wireguard :
wg-quick up wg0
Générateur de configuration
Si vous êtes habituez à la configuration de Wireguard, vous verrez que vous pouvez gagner du temps grâce à ce générateur de fichier de config :
Script d'installation automatique
Pour lancer le script :
curl -O https://raw.githubusercontent.com/angristan/wireguard-install/master/wireguard-install.sh && chmod +x wireguard-install.sh && ./wireguard-install.sh
[Debian] SSHS
Introduction
Ce gestionnaire de connexions SSH permet d'avoir une interface graphique pour ne plus avoir à retenir vos identifiants et les IP des connexions. Cet outil fonctionne en ligne de commande pour le bonheur de tous.
Installation
Vous devez récupérer le binaire depuis le Github du projet et le rendre exécutable :
wget -O /usr/local/bin/sshs https://github.com/quantumsheep/sshs/releases/download/4.3.0/sshs-linux-amd64 && chmod +x /usr/local/bin/sshs
Configuration
Le fichier de configuration se trouve dans ~/.ssh/config et prend ce format :
Host "<NAME>"
Hostname <IP|FQDN>
User root
Port 2222
IdentityFile "~/.ssh/id_rsa"
Remplacez les champs appropriés par vos valeurs.
Utilisation
sshs
[Debian] GlusterFS
Introduction
GlusterFS permet de créer des espaces de données partagées ce qui peut servir pour faire répliquer deux partitions identiques entre deux serveurs distants.
Source
Installation du cluster
Pour la haute disponibilité il est recommandé d'utiliser au moins trois instances sur lesquels nous aurons notre partitions partagée.
Pour le tutoriel nous utiliserons trois machines sur Debian 11.
- Tout d'abord, toutes les machines du cluster doivent posséder un hostname, pour cela on définit le hostname avec la commande suivante :
hostnamectl set-hostname <FQDN>
Puis ajoutez les entrées dans le fichier /etc/hosts dans le format suivant :
<IP> <FQDN>
Vérifiez que le ping fonctionne en utilisant les noms d'hôtes.
Ensuite, nous devons préparer la partition qui va accueillir les données sur les trois machines (notre disque sera /dev/sdb) :
apt install -y parted
parted /dev/sdb mklabel gpt mkpart SHARE ext4 1MiB 100%
Maintenant, nous devons préparer le dossier qui va accueillir le point de montage (ici /share) :
mkdir /share
Puis ajoutez cela dans le /etc/fstab pour être persistant après redémarrage :
/dev/sdb1 /share ext4 defaults 0 1
Pour appliquer les changements et détecter les erreurs :
mount -a
Ne laissez pas d'erreur, sinon vous risquez de ne pas pouvoir démarrer au prochain redémarrage du système !
Créer le dossier /share/brick0 qui va accueillir les fichiers partagés :
mkdir -p /share/brick0
Désormais, nous pouvons installer le serveur GlusterFS sur nos trois machines :
apt install -y gnupg2 apt-transport-https software-properties-common curl && curl https://download.gluster.org/pub/gluster/glusterfs/10/rsa.pub | gpg --dearmor > /usr/share/keyrings/glusterfs-archive-keyring.gpg && DEBID=$(grep 'VERSION_ID=' /etc/os-release | cut -d '=' -f 2 | tr -d '"') && DEBVER=$(grep 'VERSION=' /etc/os-release | grep -Eo '[a-z]+') && DEBARCH=$(dpkg --print-architecture) && echo "deb [signed-by=/usr/share/keyrings/glusterfs-archive-keyring.gpg] https://download.gluster.org/pub/gluster/glusterfs/LATEST/Debian/${DEBID}/${DEBARCH}/apt ${DEBVER} main" | sudo tee /etc/apt/sources.list.d/gluster.list && apt update && apt install -y glusterfs-server
Activer le service et démarrez le :
systemctl enable --now glusterd
systemctl enable glusterd
On peut initialiser le cluster depuis le premier noeud (Node 1) du cluster avec la commande suivante :
gluster peer probe <FQDN_NODE_2> && gluster peer probe <FQDN_NODE_3>
On peut vérifier que les noeuds ont bien rejoins le cluster avec la commande gluster pool list .
On peut vérifier l'état du cluster avec la commande gluster peer status .
On peut maintenant créer un premier volume partagé
gluster volume create <VOL_NAME> replica 3 <FQDN_NODE_1>:/share/brick0 <FQDN_NODE_2>:/share/brick0 <FQDN_NODE_3>:/share/brick0
On démarrer le volume :
gluster volume start <VOL_NAME>
On peut afficher les informations du volume avec la commande gluster volume info .
Montage côté client
Comme on le ferait avec un partage réseau type NFS ou Samba par exemple, nous allons monter notre volume glusterfs sur notre ou nos clients.
Pour cela, on installe d'abord le paquet glusterfs-client :
apt install -y glusterfs-client
On peut créer le point de montage :
mkdir -p /mnt/share
Et on monte le volume :
mount.glusterfs <FQDN_NODE_1>:/<VOL_NAME> /mnt/share
Pour un partage persistant, on ajoute une entrée dans le /etc/fstab :
<FQDN_NODE_1>:<VOL_NAME> /mnt/share glusterfs defaults,_netdev 0 0
Puis :
mount -a
Le volume distribué est prêt et tolère la panne pour supporter la HA !
[Debian] Corosync
Introduction
Corosync permet de faire de la haute disponiblité sur vos services systemd ce qui peut être utile pour un serveur web ou une base de données par exemple. À noter que corosync est utilisé par Proxmox pour sa HA.
Installation
[Debian] OpenSSL
Introduction
Openssl est une bibliothèque standard de chiffrement disponible sur les systèmes Unix.
Chiffrement de fichier
Vous pouvez chiffrer un fichier en AES-256-CBC avec un mot de passe grâce à la commande suivante :
openssl enc -aes-256-cbc -salt -pbkdf2 -in <INPUT_FILE> -out <OUTPUT_FILE> -base64 -k <PASSPHRASE>
Et pour déchiffrer :
openssl enc -d -aes-256-cbc -pbkdf2 -in <INPUT_FILE> -out <OUTPUT_FILE> -base64 -k <PASSPHRASE>
Pour créer une paire de clés publique/privée RSA puis chiffrer un fichier avec, on peut utiliser openssl.
Tout d'abord, générez la paire de clés :
- Clé privée :
openssl genpkey -algorithm RSA -out priv.pem -aes-256-cbc -pass pass:mypass
- Clé publique :
openssl rsa -pubout -in key.pem -out pub.pem -passin pass:mypass
Puis chiffrez un fichier avec la clé publique :
openssl pkeyutl -encrypt -inkey pub.pem -pubin -in plain.txt -out cypher.enc && openssl base64 -in cypher.enc -out cypher.enc.base64
Puis pour déchiffrer avec la clé privée :
openssl base64 -d -in cypher.enc.base64 -out cypher.enc && openssl pkeyutl -decrypt -inkey priv.pem -in cypher.enc -out plain_decrypted.txt
Échange de clé
On peut utiliser Diffie Hellman pour échanger des clés.
Pour cela, commencez par créer un paramètre DH :
openssl genpkey -genparam -algorithm DH -out dhp.prem
Puis on peut générer une première clé :
openssl genpkey -paramfile dhp.pem -out dhkey1.pem
On peut afficher les informations de cette clé :
openssl pkey -in dhkey1.pem -text -noout
Et on peut créer une deuxième clé :
openssl pkey -in dhkey1.pem -pubout -out dhpub1.pem
On peut afficher les informations de cette clé :
openssl pkey -pubin -in dhpub1.pem -text
On peut ensuite créer une dérivation de ces clés :
openssl pkeyutil -derive -inkey dhkey1.pem -peerkey dhpub1.pem -out secret1.bin
openssl pkeyutil -derive -inkey dhkey2.pem -peerkey dhpub2.pem -out secret2.bin
On peut ensuite comparer les deux secrets et s'apercevoir qu'ils sont identiques :
cmp secret1.bin secret2.bin
Génération de clés ECC
Les clés ECC suivent les courbes elliptiques ce qui permet une taille de clé réduite en conservant un bon niveau de sécurité.
Création d'une clé ECC
openssl ecparam -genkey -name prime256v1 -out ecc.key
Demande de certificat
openssl req -new -sha256 -key ecc.key -nodes -out ecc.csr
Signer le certificat
Ici nous allons auto-signer le certificat, si vous utilisez une autorité de certification (CA), utilisez la clé privée du CA :
openssl req -x509 -sha256 -days 365 -key ecc.key -in ecc.csr -out ecc.crt
Extraire la clé publique
openssl ec -in net-sec.key -pubout
[Debian] LVM
Introduction
LVM (Logical Volume Manager) permet de créer des volumes logiques, ce qui permet une grande flexibilité.
Manuel
Installation
Installez le paquet lvm2 :
apt install -y lvm2
Admettons que nous voulons créer un volume logique pour accueillir nos musiques et des films (des médias).
Pour cela nous allons utiliser deux disques (volumes) physiques de 50Go chacun.
Tout d'abord, initialisez les volumes physiques (PV) :
wipefs -a /dev/sdX && wipefs -a /dev/sdY && pvcreate /dev/sdX /dev/sdY
Créez votre groupe de volume (VG) :
vgcreate vg_medias /dev/sdX /dev/sdY
Vous pouvez maintenant créer deux volumes logiques, LV, (un pour les musiques et un pour les films) :
lvcreate -L 10G -n lv_musics vg_medias
lvcreate -L 90G -n lv_movies vg_medias
Désormais, il ne vous reste plus qu'à formater les volumes logiques :
- lv_musics en ext4 :
mkfs.ext4 /dev/vg_medias/lv_musics
- lv_movies en xfs :
mkfs.xfs /dev/vg_medias/lv_movies
Et enfin, montez vos volumes logiques :
mount /dev/vg_medias/lv_musics /mnt/musics && mount /dev/vg_medias/lv_movies /mnt/movies
Vous pouvez créer les entrées correspondantes dans le /etc/fstab .
Ajout d'un disque
Admettons que je manque d'espace sur mon volume logiques correspondant à mes musiques (lv_musics), je vais ajouter un disque dans mon serveur, puis je vais l'initialiser :
wipefs -a /dev/sdZ && pvcreate /dev/sdZ
Ajoutez le volume physique à votre groupe de volumes :
vgextend vg_medias /dev/sdZ
Puis agrandissez votre volume logique :
lvextend -L +500G /dev/vg_medias/lv_musics && resize2fs /dev/vg_medias/lv_musics
Si vous souhaitez redimensionner un volume logique formaté en XFS, utilisez xfs_growfs <MOUNT_POINT>. Cela paraît contre intuitif mais le volume doit être monté pour être redimensionné. Mettez bien le point de montage et pas l'identifiant du disque !
Supprimer un volume logique
umount /mnt/musics && lvremove /dev/vg_medias/lv_musics
Debug
Affichez les volumes physiques :
pvs
Affichez les groupes de volumes :
vgs
Ou :
vgdisplay
Affichez les volumes logiques :
lvs
[Debian] LUKS
Introduction
LUKS permet le chiffrement de partition sur les systèmes Linux.
Installation
Debian
apt install -y cryptsetup
Manuel
Création partition
fdisk /dev/sdX
Puis N > P > ENTER > ENTER > ENTER.
Chiffrement partition
cryptsetup luksFormat --cipher aes-xts-plain64 --key-size 256 --hash sha256 --verify-passphrase /dev/sdhX1
Déchiffrement partition
cryptsetup luksOpen /dev/sdX1 sdX1_crypt
Par défaut, le nom du volume chiffré s'appelle sdX_crypt.
Formatage partition
mkfs.ext4 /dev/mapper/sdX_crypt
Montage partition
mount /dev/mapper/sdX_crypt
mount /dev/mapper/sdX_crypt /mnt/crypt_part