Debian

La distribution de la sagesse et des gens stables.

[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

image.png

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 :

image.png

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.

Image collée 2.png

Une fois la machine redémarrée, le raid passe en état inactif comme on peut le voir :

image.png

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.

image.png

Installation

apt update && apt install -y bind9 
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

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)

// 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.

$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).

$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 
cd /etc/bind/
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; };
};
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";
};
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";
};
// 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";
};
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";
};
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";
};
mkdir localzone && cd localzone
$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
$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
$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
$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

image.pngInstallation

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.

image.png

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

image.png

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

image.png

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 :

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 :

image.png

Il nous est demandé si on souhaite créer une nouvelle table des partitions, faites Oui :

image.png

On réitère pour le disque sdb :

image.png

image.png

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 :

image.png

image.png

image.png

image.png

image.png

image.png

On peut maintenant créer les partitions qui seront utilisés comme volume physique pour RAID :

image.png

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 :

image.png

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 :

image.png

image.png

On commence par le RAID0 de la SWAP :

image.png

On sélectionnes les deux partitions de 1Go :

image.png

On réitère l'opération pour le RAID du système:

image.png

Cette fois on configure un RAID1 :

image.png

image.png

Dans notre configuration, nous n'aurons pas de disque de réserve (spare), laissez 0 :

image.png

On sélectionnes les deux partitions de 20Go :

image.png

Et on peut Terminer la configuration des périphériques RAID :

image.png

Désormais, on sélectionne le Périphérique RAID0 pour configurer la SWAP :

image.png

image.png

Puis on sélectionne le périphérique RAID1 pour configurer la racine du système :

image.png

image.png

On peut enfin Terminer le partitionnement et appliquer les changements :

image.png

image.png

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 :

image.png

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 :

image.png

Puis on peut vérifier l'état du RAID0 grâce à la commande mdadm --detail /dev/md0 :

image.png

Et enfin, l'état du RAID1 grâce à la commande mdadm --detail /dev/md1 :

image.png

[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 :

Image collée.png

Cliquez sur Ajouter des horloges pour des fuseaux horaires variés :

Image collée 1.png

Accédez à l'onglet Temps Internet et cliquez sur Modifier les paramètres :

Image collée 2.png

Et enfin vous pouvez saisir l'adresse IP ou le FQDN de votre serveur de temps et cliquer sur Mettre à jour puis OK :

Image collée 3.png

[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.

image.png

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>

 

image.png

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.

image.png

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>

image.png

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.

image.png

Sources

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.

image.png

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.

image.png

Installation du serveur

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é :

image.pngEnsuite, vous devez choisir le protocole qu'OpenVPN utilisera :

image.pngPuis saisissez le numéro de port que le service OpenVPN devra utiliser :

image.png

Vient après la configuration du serveur DNS :

image.pngSaisissez le nom d'un premier client :

image.png

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.

image.png

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.

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
  1. La clé privée du serveur :
    wg genkey | sudo tee /etc/wireguard/wg-private.key
  2. 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.

image.png

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.

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.

image.png

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 :

openssl genpkey -algorithm RSA -out priv.pem -aes-256-cbc -pass pass:mypass
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é.

image.png

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 :

mkfs.ext4 /dev/vg_medias/lv_musics
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.

image.pngInstallation

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