Amis SH

POSIX

Définition de POSIX

POSIX est une famille de normes techniques définie depuis 1988 par l'Institute of Electrical and Electronics Engineers (IEEE), et formellement désignée par IEEE 1003. Définition de POSIX sur wikipédia.
Ces normes ont émergées d'un projet de standardisation des interfaces de programmation des logiciels destinés à fonctionner sur les variantes du système d'exploitation UNIX.
Utiliser la norme POSIX permet de coder un script pour qu'il puisse fonctionner directement sur n'importe quel shell, ou, après recompilation en C, sur la plupart des machines Linux ainsi que sur des plates-formes conformes au standard POSIX comme Cygwin ou Android.

Bash devient partiellement compatible POSIX lorsqu'il est utilisé par l'interpréteur sh.
Les distributions GNU/Linux lient généralement /bin/sh à un shell compatible POSIX comme dash ou ksh.

Définir l'interpréteur de commande shell a utiliser par défaut au début de chaque script :

Utiliser le shebang conforme POSIX : #!/bin/sh Utiliser le shebang bash pour les scripts interactifs bash : #!/bin/bash

Vérifier la compatibilité POSIX

Vérifier si POSIX est reconnu et activé

Vérifier si POSIX est reconnu par l'environnement :

man getenv CONFORMING TO getenv(): POSIX.1-2001, POSIX.1-2008, C89, C99, SVr4, 4.3BSD.

Vérifier si POSIX est activé depuis le terminal :

echo "$SHELLOPTS" | grep -o posix

Vérifier la compatibilité POSIX avec checkbashisms

Utiliser checkbashisms présent dans le paquet devscripts de debian pour tester partiellement la conformité POSIX.
Par défaut checkbashisms est dash orienté Debian.

Installer le paquet devscripts :

sudo apt install devscripts

Utiliser checkbashisms avec le drapeau posix -p pour identifier les erreurs du script :

checkbashisms -p script.sh

Consulter le manuel de checkbashisms.

Vérifier la compatibilité POSIX avec shellcheck

Vérifier si un script est conforme POSIX en ligne avec l'outil shellcheck :

#!/bin/sh read -r a b <<<"$1" echo $((a+b))

Le message d'erreur suivant est retourné : (warning): In POSIX sh, here-strings are undefined.

Installer et utiliser shellcheck depuis le terminal pour vérifier la conformité POSIX d'un script :

sudo apt install shellcheck -y shellcheck --shell=sh script.sh

Le paquet shellcheck permet d'identifier les problèmes suivants :
- Erreurs de syntaxe et fautes de frappe.
- Variables non citées et substitutions de commandes.
- Utilisation de variables non définies.
- Failles de sécurité comme l'injection de commandes et l'injection de shell.
- Problèmes de performances, substitutions de commandes inutiles et constructions inefficaces.

Garantir la portabilité des scripts avec Ruby, Perl ou Python

Un script conforme POSIX ne garantit pas la portabilité.
Rendre un script shell conforme POSIX est généralement plus facile que de le faire réellement fonctionner sur l'ensemble des shells existants.
Rendre un script shell conforme POSIX demande du temps pour un script de plusieurs centaines de lignes.

Pour garantir une bonne portabilité, utiliser des langages de programmation interprétés sur différents systèmes d'exploitation.
Utiliser des langages comme Ruby, Perl ou Python permet d'améliorer la portabilité du programme.
Le code fonctionne de la même manière sur tous les systèmes d'exploitation à condition d'avoir la bonne version du langage.

Un langage de programmation permet de diviser un script complexe en modules plus faciles à utiliser.
Utiliser des langages évolués apporte de nombreuses fonctionnalités et des bibliothèques sophistiquées.

Interpreteurs POSIX

Les shells bournesh, dash, posh, lksh ou yash sont conforme POSIX et idéaux pour développer des scripts conforme POSIX.

Utiliser le shell bash comme interpréteur POSIX

Utiliser les options du shells bash pour activer POSIX :

bash -o posix bash --posix

Si un script bash est appelé avec la commande sh, il active un mode de compatibilité lui permettant d'agir d'avantage comme un shell plus ancien conforme POSIX en modifiant le comportement de bash pour qu'il corresponde à celui spécifié par POSIX dans les zones où la valeur par défaut de bash différent.
Dans ce mode de compatibilité, bash continue de fournir un certain nombre de fonctionnalités optionnelles qui ne sont pas disponibles dans le shell sh ou dans le standard POSIX.
Même en mode POSIX, bash autorisera toujours certaines fonctionnalités non POSIX telles que [[.
POSIX impose l'usage d'un simple crochet [] pour utiliser des conditionnelles.
Préférer l'utilisation du shell dash qui est plus strict et conforme POSIX.

...

Bash utilisé avec --posix, set -o posix ou sh proposera de corriger certaines incompatibilités du script testé pour se rapprocher de la conformité POSIX.
Le shell bash POSIX autorise toujours de nombreuses extensions spécifiques à bash ce qui empêche de respecter la stricte conformité POSIX.
Préférer un shell comme dash pour tester des scripts shell devant être rendu conforme POSIX.

La commande set provient du bourne shell sh et fait partie du standard POSIX.
La commande shopt ne fait pas partie des standards POSIX, elle est spécifique au shell bash.

Activer POSIX sur le terminal :

# Un bash avec set -o posix actif n'est toujours pas conforme à POSIX/UNIX. # Activer POSIX set -o posix # Définir shopt -s xpg_echo pour augmenter la conformité POSIX/UNIX. shopt -s xpg_echo shopt -o posix # Affiche si le mode POSIX est activé ou désactivé sur le shell bash. posix on shopt -s shopt -u # La commande bash shopt n'est pas conforme POSIX. # Elle peut être utilisé depuis un script bash pour activer POSIX. # Vérifier son bon fonctionnement dans un script ! shopt -o posix posix on # Désactiver POSIX set +o posix

Contraindre bash a se rapprocher du comportement POSIX avec un lien local symbolique vers ./sh :

ln -s /bin/bash ./sh

Un script avec une syntaxe spécifique à bash peut donner une erreur dans un shell commençant par #!/bin/sh, même avec le lien symbolique sh vers bash en place :
Le script logfile.sh avec une syntaxe spécifique à bash :

#!/bin/sh exec > >(tee logfile.txt)

Le lancement du script bash avec la commande sh affiche une erreur :

sh logfile.sh logfile.sh: 2: Syntax error: redirection unexpected

Le lancement du script bash avec la commande bash fonctionne :

bash logfile.sh

Utiliser le shell dash comme interpréteur POSIX

Utiliser le shell dash comme interpréteur shell conforme POSIX pour tester la comptabilité POSIX des scripts.
Il implémente uniquement les fonctionnalités du shell POSIX et renvoie une erreur s'il rencontre des bashismes comme des variables de tableau ou une substitution de processus.
Lancer un script shell avec l'interpréteur dash :

dash script.sh

Utiliser le shell lksh comme interpréteur POSIX

Utiliser les options du shell lksh pour activer POSIX :

lksh -o posix -o sh

Utiliser le projet shall pour interpréter du code shell sur différents shells

Le projet shall permet d'interpréter un script ou une commande avec plusieurs shells en même temps.

Consulter le github officiel du projet shall.

Télécharger shall pour paramétrer son installation :

wget https://raw.githubusercontent.com/mklement0/shall/stable/bin/shall -P ~/Bureau/ chmod +x ~/Bureau/shall sudo mv ~/Bureau/shall /usr/bin

Configurer les shells utilisés par défaut, à la ligne 247 du fichier /usr/bin/shall :

nano /usr/bin/shall # kDEFAULT_SHELLS=( sh dash bash zsh ksh ) kDEFAULT_SHELLS=( sh dash bash zsh ksh rbash)

Lire le manuel de shall :

shall --man

Afficher les noms des shells existants :

shall -c 'echo "Hello from $0."' ✓ sh@ (-> dash) [0,00s] Hello from sh. ✓ bash [0,00s] Hello from bash. ✓ zsh [0,00s] Hello from zsh. OK - All 3 shells (sh, bash, zsh) report success.

Tester la commande suivante : set -o posix; echo "$SHELLOPTS" | grep -o posix

shall -c 'set -o posix; echo "$SHELLOPTS" | grep -o posix' ✗ sh@ (-> dash) [0,00s] sh: 1: set: Illegal option -o posix ✓ bash [0,00s] posix ✗ zsh [0,00s] zsh:set:1: no such option: posix

Demander ou est which avec type which :

shall -w bash,rbash,zsh -c 'type which' ✓ bash [0,00s] which est /usr/bin/which ✓ rbash [0,00s] which est /usr/bin/which ✓ zsh [0,00s] which is a shell builtin OK - All 3 shells (bash, rbash, zsh) report success.

La liste des commandes POSIX inclut command et type mais pas which.

Spécifier les shells puis vérifier une commande avec shall depuis l'invitation de commande qui s'affiche :

SHELLS=bash,dash shall -i

Vérifier le comportement d'un script script.sh sur l'ensemble des shells disponibles avec shall :

shall script.sh

Différences entre un terminal et un shell

Console = Terminal physique.

Dans sa signification la plus courante, le mot terminal est synonyme du mot TTY TeleTYpewriter : Environnement d'entrée / sortie texte
Terminal = TTY = Environnement d'entrée/sortie de texte.
Le terminal est appelé prompt ou invite de commande depuis l'écran noir d'un ordinateur.
Le terminal est l'interface de ligne de commande qui permet aux utilisateurs d'accéder au shell.
Les émulateurs de terminal reproduisent les fonctionnalités des terminaux informatiques traditionnels avec certaines similitudes.

Shell = Le shell interprète les lignes de commandes. Un terminal n'est pas un shell.
Les commandes shell sont saisies depuis le terminal encore appelé prompt ou invite de commande.
Il peut prendre différentes formes, plein écran ou fenêtré, austère ou évolué.

---

Reconnaître un utilisateur d'un super utilisateur root

En général un terminal ouvert affiche le nom de l'utilisateur (user), un arrowbase (@) le nom de la machine (localhost), puis le répertoire courant (pwd), et enfin un dièse (#) pour le super utilisateur (root), le signe supérieur (>) ou le signe pourcentage (%) ou encore le signe dollar ($) pour un simple utilisateur.

utilisateur@machine /home $

La commande su nous bascule sur le compte d'utilisateur root et requiert le mot de passe du compte root.
La commande sudo exécute une seule commande avec les privilèges root, il ne passe pas à l'utilisateur root et ne nécessite pas le mot de passe de l'utilisateur root.
Utiliser la commande sudo -s utilisateur pour devenir utilisateur root et lancer plusieurs commandes.

root@machine:/home#

---

Terminal vs XTerm

Le terminal et xterm sont des programmes d'émulation de terminal qui permettent d'utiliser un terminal dans un environnement graphique.
L'émulateur de terminal xterm est installé par défaut avec le système d'exploitation Linux.
Les systèmes Linux et UNIX exécutant le système X Windows utilisent le terminal xterm comme programme d'émulation de terminal par défaut.
La commande xterm (/usr/bin/xterm) depuis la fenêtre du terminal courant permet de lancer l'environnement X11 avec une fenêtre Xterm.
XTerm peut être utilisé simultanément par plusieurs utilisateurs.
Xterm permet de personnaliser les polices et les couleurs.

La variable $TERM est héritée par tous les processus lancés par init.
Il garantit que tous les processus générés par init utilisent le formatage de terminal approprié pour la sortie vers la console.
Le système X Window définit automatiquement « xterm » ou « xterm-256color » comme valeur pour $TERM dans une fenêtre de terminal xterm.

echo $TERM xterm-256color

Émuler un terminal permet d'utiliser une fenêtre terminal depuis une interface graphique ce qui permet aux utilisateurs d'exécuter des commandes shell.
Linux propose un certain nombre d'émulateurs de terminal pour chaque version d'interface graphique.
Les émulateurs de terminal peuvent avoir différents degrés de personnalisation.
La commande /etc/alternatives/x-terminal-emulator lance le terminal par défaut sur le système.

Afficher le nom de l'émulateur de terminal X utilisé par le système :

ps -o sid= -p "$$" | xargs ps -o ppid= -p | xargs ps -o comm= -p xfce4-terminal

Sous GNU/Linux Debian et Ubuntu, la commande x-terminal-emulator est un "raccourci" vers la commande de l'émulateur de terminal par défaut xfce4-terminal.

Afficher le nom du terminal X et le nom du shell utilisé.
Le shell utilisé avec l'émulateur de terminal par défaut xfce4-terminal est bash.

pstree -s $PPID | awk -F '---' '{print $6}' xfce4-terminal-+-bash-+-awk

Comparer	XTerm	Terminal
Assistance	Il prend en charge par défaut le tampon primaire.	Il prend en charge à la fois le tampon principal et le tampon du presse-papiers.
Accès	Il est accessible en tapant xterm dans la fenêtre du terminal. Il affichera l'environnement X11 et une fenêtre XTerm.	Il s'ouvre en maintenant les touches CTRL + Alt + T.
Processus	Il permet à plusieurs instances de s'exécuter simultanément dans le même affichage.	Une seule instance à la fois. Chaque session se déroulera séparément.
Émulation	Émulation de terminal par défaut pour les systèmes Linux exécutant X Windows System.	Émulateur de terminal par défaut pour les systèmes basés sur Linux et UNIX.
Utilisation	Plusieurs utilisateurs peuvent y accéder simultanément.	Pas plus d'un utilisateur ne peut l'utiliser en même temps.

Modifier le choix du terminal utilisé par défaut

sudo update-alternatives --config x-terminal-emulator

Sur GNU/Linux Mint il existe 6 choix proposés pour l'alternative x-terminal-emulator pour renseigner le fichier /usr/bin/x-terminal-emulator.

Sélection Chemin Priorité État ------------------------------------------------------------------------------- * 0 /usr/bin/xfce4-terminal.wrapper 40 mode automatique 1 /usr/bin/koi8rxterm 20 mode manuel 2 /usr/bin/lxterm 30 mode manuel 3 /usr/bin/uxterm 20 mode manuel 4 /usr/bin/xfce4-terminal.wrapper 40 mode manuel 5 /usr/bin/xterm 20 mode manuel

La librairie terminfo contient des définitions pour les différents émulateurs de terminaux définies dans les dossiers correspondant :

ls /lib/terminfo a c d E h l m p r s t v w x

Utiliser plusieurs terminaux

Si aucun terminal n'est ouvert, CTRL + Alt + T permet d'ouvrir un terminal dans le répertoire utilisateur.
Si le terminal est ouvert, utiliser le menu Fichier / "Ouvrir un terminal" pour ouvrir un nouveau terminal.
Si le terminal est déjà ouvert, CTRL + Maj + N pour ouvrir une fenêtre de terminal dans le même répertoire.
Si le terminal est déjà ouvert, CTRL + Shift + T pour ouvrir un nouvel onglet dans le même répertoire.

Régler les dimensions de la fenêtre du terminal par exemple à 108 colonnes et 24 lignes.
Menu > préférence > Apparence > Géométrie par défaut 80x24, ou 108x24 par exemple.

# Redimensionner le terminal : xfce4-terminal --geometry=108x24

Exporter le résultat d'une commande vers le terminal xterm

Utiliser le terminal xterm ou uxterm, un terminal très austère visuellement.
Astuce pour afficher le résultat d'un script shell bash dans une nouvelle fenêtre du terminal xterm :

xterm -hold -e "echo X" & uxterm -hold -e "echo X" &

 

---

Shell de connexion, shell interactif, shell non interactif

Shell de connexion utilisateur : Il demande a saisir le login et le mot de passe pour ouvrir un shell interactif qui permet alors de saisir des commandes.
Les commandes logout et exit sont disponibles pour quitter le shell de connexion.

Shell interactif : Un shell est dit interactif lorsqu'il affiche un prompt pour saisir une commande directement dans le terminal et attendre qu'elle s'exécute.
Pour démarrer un shell non connexion dans un émulateur de terminal, lancer l'émulateur de terminal, par exemple, xfce4-terminal, depuis l'interface graphique.
Un shell interactif "non connexion" s'ouvre.

Shell non interactif : Les tâches exécutées en arrière plan sont des exemples de shell non interactif, le shell lit les commandes d'un script enregistré dans un fichier.

Vérifier si le shell est interactif :

[[ $- == *i* ]] && echo 'Interactif' || echo 'non-interactif'

La commande logout est spécifique à un shell de connexion.
Utiliser la commande logout depuis un shell interactif retourne une erreur :

logout bash: logout: ce n'est pas un shell de connexion : utilisez « exit »

Vérifier si le shell est un shell de connexion :

shopt -q login_shell && echo 'Shell de connexion' || echo 'Ce n est pas un shell de connexion'

Un terminal peut utiliser différents types de shell

Démarrer un terminal et lancer la commande ps pour identifier le shell utilisé par le terminal.
La commande ps affiche le nom de l'interpréteur shell.

ps

L'interpréteur de commandes shell utilisé par défaut est affiché comme étant bash.
Les lignes affichées sont le résultat de la commande ps suite à son interprétation par le shell bash.

PID TTY TIME CMD 315607 pts/0 00:00:00 bash 557889 pts/0 00:00:00 ps

La variable d'environnement $SHELL permet d'identifier le shell utilisé par défaut par le terminal.
La variable d'environnement $0 affiche le nom du shell actuel.

echo $SHELL echo $0

Afficher la variable d'environnement $SHELL permet de lire l'emplacement du shell par défaut et son nom.

/bin/bash

Lister des shells disponibles par défaut sur le système GNU/Linux Mint 20 Ulyana.

cat /etc/shells

Affiche :

# /etc/shells: valid login shells /bin/sh /bin/dash /bin/bash /bin/rbash

Changer de shell sur GNU/Linux

La commande chsh permet de changer un shell de connexion avec l'option -s ou -shell.
Saisir le chemin du nouveau shell pour qu'il soit modifié sur l'utilisateur courant :

sudo chsh -s /bin/sh utilisateur Changing shell for utilisateur. Shell changed. grep utilisateur /etc/passwd utilisateur:x:1000:1000::/home/utilisateur:/bin/sh

La commande usermod est utilisée pour modifier les détails d'un compte utilisateur y compris son shell :

sudo usermod utilisateur -s /bin/bash grep utilisateur /etc/passwd utilisateur:x:1000:1000::/home/utilisateur:/bin/bash

Modifier le shell manuellement à l'aide d'un éditeur de texte :

sudo nano /etc/passwd utilisateur:x:1000:1000::/home/utilisateur:/bin/bash

Appliquer une modification de shell à tous les nouveaux utilisateurs créés sur l'environnement.
Modifier le fichier "/etc/adduser.conf", éditer sa variable d'environnement DSHELL avec le chemin du shell à appliquer aux nouveaux utilisateurs.

sudo nano /etc/adduser.conf DSHELL=/bin/bash

---

Bloquer le shell de certains comptes

Pour des raisons de sécurité, il est possible de bloquer les connexions shell d'un compte Linux en précisant comme shell "/usr/sbin/nologin" ou "/bin/false".
La commande "nologin" permet de retourner un message clair à l'utilisateur comme "This account is currently not available". Ce message est personalisable depuis le fichier "/etc/nologin.txt".
La commande "false" bloquera la connexion de l'utilisateur sans informations sur le refus.

Installer un multiplexeur de terminaux

Utiliser un multiplexeur de terminaux comme GNU Screen, Tmux ou Terminator améliore votre terminal.

GNU Screen est un multiplexeur de terminaux personalisable qui permet de séparer plusieurs fenêtres dans un seul terminal.
Utiliser le multiplexeur de terminaux screen pour diviser le terminal.
GNU Screen est un multiplexeur de terminaux sous licence GPL.

Tmux est un multiplexeur de terminaux personalisable qui permet de séparer plusieurs fenêtres dans un seul terminal.
Utiliser le multiplexeur de terminaux Tmux pour diviser le terminal.
Tmux est un multiplexeur de terminaux sous licence BSD.

Terminator est un multiplexeur de terminaux personalisable qui permet de séparer plusieurs fenêtres dans un seul terminal.
Utiliser le multiplexeur de terminaux terminator pour diviser le terminal.
Terminator est un multiplexeur de terminaux sous licence GPL-2.0 ou version ultérieure.

PID UID GID UUID PPID

PID

PID est l'abréviation de Process IDentifier ou Process ID, il s'agit du numéro d'identification d'un processus en cours d'exécution dans la mémoire. Un processus fait référence à un programme en exécution.

Afficher le PID d'un processus en exécution avec la commande pidof.

pidof firefox 167784

La commande ps -ef affiche la liste des différents processus.
On retrouve la ligne contenant le PID du processus firefox.

utilisateur 167784 1 19 16:08 ? 00:18:55 /usr/lib/firefox/firefox

Forcer la fermeture du processus firefox en utilisant la commande kill et le PID du processus.

kill -9 167784

Les commandes suivantes permettent d'afficher le PID du shell et les shells ouvert dans la session :

echo $BASHPID ps -l

UID et GID

À chaque processus est associé un identifiant utilisateur UID pour identifier le compte avec lequel le processus s'exécute et déterminer ses droits.
Les UID sont stockés dans le fichier /etc/passwd.

Un utilisateur est rattaché à un ou plusieurs groupes. Un groupe est identifiable par son GID.
Les groupes sont stockés dans le fichier /etc/groups.

Trouver l'UID et le GID d'un utilisateur :

id uid=1000(amissh) gid=1000(amissh) groupes=1000(amissh),4(adm),7(lp),24(cdrom),27(sudo) (...) id root uid=0(root) gid=0(root) groupes=0(root)

UUID

Il s'agit d'une suite plus ou moins longue de caractères alpha-numériques qui permet d'identifier de façon absolument sûre chaque périphérique de stockage et partition.

La commande blkid liste des UUIDs, les Labels et Types de toutes les partitions montées.

sudo blkid

PARTUUID et PTUUID

PARTUUID est un UUID au niveau de la table de partition pour la partition.
C'est une fonctionnalité standard pour toutes les partitions sur les disques partitionnés GPT.

PTUUID est l'UUID de la table de partition elle-même, un identifiant unique pour l'ensemble du disque attribué au moment où le disque a été partitionné.
C'est l'équivalent de la signature de disque sur les disques partitionnés MBR mais avec plus de bits et une procédure standardisée.

PPID

PPID signifie Parent Process ID, le processus parent est responsable de la création d'un processus enfant qui possède un PID unique mais toujours le même PPID du parent.

Avec la commande pstree -p qui affiche la liste des différents processus sous Linux sous forme d'arborescence on retrouve la ligne contenant le PID du processus firefox.
Les PPID sont lisibles plus facilement avec cette méthode d'affichage.

firefox-bin(167784)─┬─Isolated Web Co(173736)─┬─{Isolated Web Co}(173741)

Créer un script shell sur GNU/Linux

Utiliser un fichier au format texte avec pour extension .sh pour contenir les instructions shell qui seront exécutées par un interpréteur de commandes shell.

Le début du script commence par #!/chemin/vers/interpreteur

Coquille POSIX : #!/bin/sh

Préférer un script compatible POSIX quand c'est possible et utiliser #!/bin/sh.
Utiliser le lien symbolique #!/bin/sh pour utiliser l'interpréteur de commande Bourne shell /bin/sh
Le raccourci /bin/sh devrait dans chaque installation toujours pointer vers le shell système préféré compatible POSIX.
La commande sh est un lien symbolique vers l'interpréteur de commandes par défaut : /bin/dash.
Utiliser la commande sh signifie que le script va s'exécuter en mode de compatibilité (POSIX) même si /bin/sh est un alias de bash.

ls -l /bin/sh lrwxrwxrwx 1 root root 4 mars 23 2022 /bin/sh -> dash

Dash est un shell compatible Posix.
#!/bin/dash

#!/bin/sh echo "Bienvenue sur Amis SH"

GNU Bash : #!/bin/bash

Si le script utilise des fonctionnalités uniquement prises en charge par bash, utiliser #!/bin/bash.
Si le script est écrit en langage bash, on utilise un interpréteur de commandes bash.
Utiliser la commande bash signifie que le script va s'exécuter en mode bash.

#!/bin/bash echo "Bienvenue sur Amis SH"

---

Modifier les droits de votre script shell

Pour exécuter un fichier .sh sur Linux, on utilise la commande chmod pour lui attribuer le droit en exécution.
On peut alors utiliser le fichier contenant le script sans avoir a préciser sh ou bash en début de commande :

chmod +x /tmp/amis.sh ./tmp/amis.sh

Si on ne modifie pas les autorisations avec chmod, la commande sh ou bash permet de lancer l'exécution du script.
Dans le terminal, exécuter le script en le précédent par la commande sh ou bash.

sh amis.sh

---

Ajouter un répertoire au PATH du système

Il peut être intéressant d'ajouter un répertoire au "PATH" du système pour y placer ses scripts et pouvoir les exécuter de n'importe ou sans avoir à se placer dans le dossier qui contient les scripts personnalisés.
A la saisie d'une commande, le shell regarde dans le PATH qui lui indique où chercher le code de la commande.
Le shell va aller voir si la commande a exécuter se trouve dans /usr/local/bin puis dans /usr/bin … jusqu'à trouver la commande.

Lire le PATH du système :

echo $PATH /usr/local/bin:/usr/bin:/bin:/usr/bin/X11:/usr/games

Par convention, ce répertoire s'appelle bin et se place dans votre répertoire personnel.
Votre répertoire personnel est /home/USER, le répertoire personnel ajouté au PATH sera /home/USER/bin.
Pour utiliser vos scripts sans avoir a saisir le "./" depuis n'importe quel répertoire, ajouter votre répertoire personnel au PATH du système.
Cette procédure est une modification temporaire du PATH et sera effacée à la fin de la session :

export PATH=$PATH:$HOME/bin

Afficher les PATH du système :

echo $PATH

Retourne :

/usr/local/bin:/usr/bin:/bin:/usr/bin/X11:/usr/games:/home/USER/bin

Le script appelé "script.sh" situé dans "/home/USER/bin" peut être appelé directement avec la commande "script".

D'autres répertoires peuvent être utilisés :

~/opt/bin/ /usr/bin/ /root/bin/

Pour rendre la modification permanente, ajouter la commande suivante dans le fichier texte caché .bashrc ou .profile se trouvant dans votre dossier personnel.

export PATH=$PATH:$HOME/bin

Pour rendre la modification permanente accessible à tous les utilisateurs, ajouter la commande dans le fichier /etc/profile :

sudo nano /etc/profile export PATH=$PATH:$HOME/bin

Dans les dernières versions de ubuntu (12.04 +) si le dossier $HOME/bin existe il est automatiquement ajouté au PATH.
La commande est incluse dans le fichier ~/.profile lancé lors de toutes sessions graphique ou console.

Les variables

En bash les variables sont toutes des chaînes de caractères.
Il est recommandé de toujour affecter une valeur à la variable.
Aucun espace ni avant ni après le signe "=".

ma_variable=unmot

Exemple pour utiliser une commande avec arguments.
La variable nbre_lignes contiendra le nombre de ligne du fichier.ext :

nbre_lignes=$(wc -l < fichier.ext)

Afficher le contenu d'une variable avec echo :

echo $ma_variable echo "$ma_variable" echo ${ma_variable} echo "${ma_variable}"

Utiliser des chemins de répertoires dans une variable :

chemin_de_base="/home/USER/un repertoire avec des espaces" chemin_complet="$chemin_de_base/repertoire"

Exemples pour créer un script shell :

Imbrications de shells

Pour des questions de sécurité il est possible d'utiliser plusieurs shells pour gagner en confiance.
Les shells peuvent être imbriqués les uns dans les autres ce qui permet de changer de shell à l'intérieur d'une même session.
Cette technique peut être utilisée pour des mesures de renforcement de sécurité.
Le shell du premier cercle est bridé avec des commande exécutables très restricitives mais il permet avec un mot de passe d'accéder au shell du deuxième cercle dont la marge de manoeuvre est plus importante, et, ainsi de suite, jusqu'au dernier cercle où tout est permis pour les administrateurs en fonction de la politique de sécurité qui a été mise en place pour un ou plusieurs administrateurs.

Afficher sur le terminal le niveau d'imbrication du shell sur lequel on se trouve avec la variable d'environnement $SHLVL :

echo $SHLVL 1 bash echo $SHLVL 2 bash echo $SHLVL 3 exit exit echo $SHLVL 1

Afficher la valeur d'imbrication du shell sur le terminal, modifier le fichier ~/.bashrc :

nano ~/.bashrc

Ajouter cette ligne à la fin du fichier ~/.bashrc :

export PS1='$SHLVL'":$SHLVLn$PS1"

Le niveau d'imbrication du shell est maintenant affiché sur le terminal :

1:utilisateur@machine ~ $ bash 2:utilisateur@machine ~ $ bash 3:utilisateur@machine ~ $ bash 4:utilisateur@machine ~ $

Pour démarrer un shell non connexion il suffit d'utiliser la commande bash :

bash

Pour démarrer un shell de connexion (login vers shell de connexion) :

bash -l Mot de passe :

// Le mot de passe ne m'est pas demandé sous xfce4-terminal depuis GNU/Linux Mint.
L'affichage du nombre d'imbrication n'est plus indiqué par la commande PS1.

Sécuriser une imbrication de shells

Utiliser la commande sudo au lieu de passer au compte root avec la commande su est plus sécuritaire.

Utilisateurs et groupes d'utilisateurs

Identifier l'utilisateur courant :

whoami

Changer d'utilisateur :

sudo - utilisateur

Utiliser le paramètre -c ou --command pour exécuter des commandes avec un utilisateur différent :

sudo --command=whoami - utilisateur

Lister les utilisateurs :

# Ouvrir le fichier des utilisateurs : nano /etc/passwd # Afficher la liste des utilisateurs : # Si LDAP est utilisé pour l'authentification de l'utilisateur, le getent affichera tous les utilisateurs Linux à partir de la base de données /etc/passwd ET de la base de données LDAP. getent passwd # Filtrer uniquement les noms des utilisateurs avec awk ou cut ou getent : # Les lignes affichent le même résultat : awk -F: '{ print $1}' /etc/passwd cut -d: -f1 /etc/passwd getent passwd | awk -F: '{ print $1}' getent passwd | cut -d: -f1

Connaître le nombre de comptes utilisateurs :

getent passwd | wc -l

Filtrer les utilisateurs actifs ayant un accès shell bash :

less /etc/passwd|grep "/bin/bash" root:x:0:0:root:/root:/bin/bash utilisateur:x:1000:1000:utilisateur,,,:/home/utilisateur:/bin/bash

Chercher un utilisateur :

getent passwd | grep utilisateur # Ou : getent passwd utilisateur

Lister les utilisateurs par leur UID :
Afficher les valeurs UID_MIN et UID_MAX sur le système.
Les utilisateurs normaux devraient avoir un UID entre 1000 et 60000 :

grep -E '^UID_MIN|^UID_MAX' /etc/login.defs

Afficher tous les utilisateurs " normaux " du système :

getent passwd {1000..60000} utilisateur:x:1000:1000:utilisateur,,,:/home/utilisateur:/bin/bash

La commande passwd

La commande passwd permet de modifier les mots de passe des comptes utilisateurs et de gérer la période de validité des mots de passe.

Afficher l'état d'un compte utilisateur :

passwd --status passwd -S utilisateur P 05/10/2018 0 99999 7 -1

Le nom de connexion d'un utilisateur.
Si un utilisateur a un mot de passe verrouillé (L), aucun mot de passe (NP) ou un mot de passe (P).
La date du dernier changement de mot de passe.
L'âge minimum du mot de passe en nombre de jours.
Âge maximal du mot de passe en nombre de jours.
Période d'avertissement pour le changement de mot de passe en nombre de jours.
Période d'inactivité pour le changement de mot de passe en nombre de jours.

Afficher les informations sur l'état du mot de passe pour tous les comptes :

sudo passwd --status --all sudo passwd -S -a

Modifier le mot de passe d'un utilisateur :

sudo passwd utilisateur

Désactiver un mot de passe pour un compte utilisateur :

sudo passwd --delete utilisateur sudo passwd -d utilisateur

Afficher les informations de vieillissement d'un compte utilisateur :

chage -l utilisateur Dernier changement de mot de passe : mai 10, 2018 Fin de validité du mot de passe : jamais Mot de passe désactivé : jamais Fin de validité du compte : jamais Nombre minimum de jours entre les changements de mot de passe : 0 Nombre maximum de jours entre les changements de mot de passe : 99999 Nombre de jours d'avertissement avant la fin de validité du mot de passe : 7

Expiration d'un mot de passe :
Une fois le compte d'un utilisateur verrouillé, il doit contacter l'administrateur du système avant de pouvoir à nouveau utiliser le système.

sudo passwd --expire utilisateur sudo passwd -e utilisateur

Désactiver le mot de passe et le compte utilisateur automatiquement après un certain nombre de jours si le mot de passe n'a pas été modifié.

sudo passwd --inactive <nombre de jours> utilisateur sudo passwd -i <nombre de jours> utilisateur

Définir le nombre minimum de jours entre les changements de mot de passe :

sudo passwd --mindays <nombre de jours> utilisateur sudo passwd -n <nombre de jours> utilisateur

Définir le nombre maximum de jours durant lesquels le mot de passe reste valide :

sudo passwd --maxdays <nombre de jours> utilisateur sudo passwd -x <nombre de jours> utilisateur

Afficher un message d'avertissement pour un mot de passe arrivant à expiration :

sudo passwd --warndays <nombre de jours> utilisateur sudo passwd -w <nombre de jours> utilisateur

Verrouiller le mot de passe d'un compte utilisateur :
Le verouillage d'un mot de passe empêche l'utilisateur de se connecter en utilisant son mot de passe.
L'utilisateur reste en mesure de se connecter en utilisant d'autres méthodes d'authentification comme un accès SSH.

sudo passwd --lock utilisateur sudo passwd -l utilisateur

Débloquer un compte utilisateur verrouillé :

sudo passwd --unlock utilisateur sudo passwd -u utilisateur

La commande --quiet permet de ne pas afficher sur l'écran le nom d'utilisateur pour lequel le mot de passe est modifié.

passwd --quiet passwd -q

Utilisateurs et groupes ? // Comment avoir un super utilisateur pour un certain shell seulement

Créer un utilisateur

La commande useradd crée un nouveau compte utilisateur en fonction des options spécifiées sur la ligne de commande et les valeurs par défaut définies dans le fichier /etc/default/useradd.
La commande useradd lit également le contenu du fichier /etc/login.defs qui contient la configuration du mot de passe shadow, avec la stratégie d'expiration du mot de passe et la plage des ID utilisateurs a utiliser lors de la création de systèmes et d'utilisateurs réguliers.

La commande useradd sans option crée un nouveau compte utilisateur à l'aide des paramètres par défaut spécifiés dans le fichier /etc/default/useradd.
Sur la plupart des distributions Linux, lors de la création d'un nouveau compte d’utilisateur avec useradd, le répertoire home de l'utilisateur n'est pas créé.
Créer un nouveau compte utilisateur :

sudo useradd utilisateur

Ajouter un nouvel utilisateur et créer un répertoire personnel (/home)
Utiliser l'option -m (-create-home) pour créer le répertoire domestique utilisateur /home/utilisateur
La commande ci-dessous crée le répertoire home du nouvel utilisateur et copie des fichiers de /etc/skel dans le répertoire de base de l'utilisateur.

sudo useradd -m nomutilisateur

Ajouter un nouvel utilisateur et créer un répertoire personnel autre que /home

sudo useradd -m -d /opt/utilisateur utilisateur

Créer un utilisateur avec un ID utilisateur spécifique

Les stratégies UID sont utilisées pour déterminer les types d'actions qu'un utilisateur peut effectuer sur les ressources système.
Lorsqu'un nouvel utilisateur est créé, le système attribue la prochaine UID disponible à partir de la plage spécifiée depuis le fichier login.defs.

sudo useradd -u 1500 utilisateur

Vérifier l'UID de l'utilisateur à l'aide de la commande ID :

id -u utilisateur # Exemple de la sortie de la commande id : uid=1500(mak) gid=1500(mak) groups=1500(mak) https://www.malekal.com/la-commande-useradd-utilisations-et-exemples/#Ajouter_un_utilisateur_avec_un_ID_de_groupe_specifique

Utilisateurs et groupes ? // Comment avoir un super utilisateur pour un certain shell seulement ( MAIS Avec 3 niveaux d'imbrication par exemple !!!??? )

Utiliser un autre shell

Monter en droits vers un ou plusieurs shell / plus élevés ? / avec un ou plusieurs autres utilisateurs ?

Il est possible de déplacer l'emplacement du shell pour améliorer la sécurité du système.

Comment déplacer un shell Linux ?

Utiliser un nouveau shell bash :

bash

Utiliser le paramètre -s ou --shell pour utiliser un autre shell que celui en cours :

sudo --shell=/bin/bash - utilisateur

Comment demander un mot de passe sur la connexion à un shell ?

Utiliser des clés SSH ...

CHROOT + shell ??

Attention ~~ Expiration des utilisateurs, des mots de passe, des clés ~~ voir des shells ~~

--Notes--

Administrer un serveur hôte avec SSH

Pour une machine on parle généralement de serveur hôte.
Pour un logiciel qui s'exécute sur la machine on parle généralement d'un serveur Web.

Commande de connexion au serveur avec SSH :

ssh admin@adresse-ip-du-serveur-hote

Vérifier si screen et sudo sont disponibles :

apt list --installed search screen apt list --installed search sudo # Installer screen et sudo si nécessaire : apt install screen sudo

Mise à jour :

sudo apt update sudo apt upgrade # Garder la version actuellement installée pour la configuration de SSH. # Fichier de configuration « /etc/cloud/cloud.cfg » (Oui) sudo apt dist-upgrade

Reconfigurer les variables locales :

sudo dpkg-reconfigure locales

La variable LANGUAGE surcharge toutes les autres variables (LANG, LC_* et LC_ALL).
On peut ajouter LANGUAGE=fr_FR.UTF-8 dans le fichier "/etc/environment".
Ce fichier est vide par défaut depuis une installation du serveur Debian Bookworm.

nano /etc/environment # Ajouter la ligne suivante : LANGUAGE=fr_FR.UTF-8 nano /etc/locale.conf # Ajouter la ligne suivante : fr_FR.UTF-8

Quitter et relancer le terminal pour rafraîchir les valeurs locales et les vérifier avec la commande locale :

locale LANG=fr_FR.UTF-8 LANGUAGE=fr_FR.UTF-8 LC_CTYPE="fr_FR.UTF-8" LC_NUMERIC=fr_FR.UTF-8 LC_TIME=fr_FR.UTF-8 LC_COLLATE="fr_FR.UTF-8" LC_MONETARY=fr_FR.UTF-8 LC_MESSAGES="fr_FR.UTF-8" LC_PAPER=fr_FR.UTF-8 LC_NAME=fr_FR.UTF-8 LC_ADDRESS=fr_FR.UTF-8 LC_TELEPHONE=fr_FR.UTF-8 LC_MEASUREMENT=fr_FR.UTF-8 LC_IDENTIFICATION=fr_FR.UTF-8 LC_ALL=

Mettre le serveur à l'heure de Paris :

sudo /usr/sbin/dpkg-reconfigure tzdata

Mettre à jour le dépôt :

cd /etc/apt sudo nano sources.list

Il est préférable d'installer directement la dernière version stable de Debian 12 Bookworm plutôt que de changer de version majeur de Debian par un processus de mise à jour.
Configurer le source.list avec les adresses URL officielles de Debian 12 Bookworm.
Bookworm est le nom de code de développement de Debian 12, publié le 10/06/2023.
Le dépôt Bookworm a modifié sa valeur firmware component de non-free à non-free-firmware.
Désactiver la liste de paquets non-free-firmware en n'affichant pas ce paramètre si il n'est pas nécessaire.

deb http://deb.debian.org/debian/ bookworm main #non-free-firmware deb-src http://deb.debian.org/debian/ bookworm main deb http://deb.debian.org/debian/ bookworm-updates main deb-src http://deb.debian.org/debian/ bookworm-updates main deb http://security.debian.org/debian-security bookworm-security/updates main deb-src http://security.debian.org/debian-security bookworm-security/updates main

Finaliser la mise à jour :

sudo apt update sudo apt upgrade sudo apt autoremove sudo apt clean sudo apt update

Facultatif :

sudo apt install task-french manpages-fr-dev # Les paquets supplémentaires suivants seront installés : aspell aspell-fr ifrench-gut libaspell15 manpages-fr wfrench

Redémarrer :

shutdown -r now

Sécuriser la connexion SSH

Se connecter en SSH avec l'utilisateur root pour administrer le serveur Debian Bookworm :

# Le compte utilisateur root est le compte administrateur Linux par défaut. # Le mot de passe de l'utilisateur root et l'adresse IP du serveur sont généralement transmis par mail. # Se connecter au serveur : ssh root@185.209.228.195

Modifier le mot de passe de l'utilisateur root.
Ayant été réceptionné par mail, le mot de passe de l'utilisateur root est considéré comme compromis.

passwd root Enter new UNIX password: MOTDEPASSE

Identifier un utilisateur qui pourra administrer le serveur :
L'utilisateur amis_sh et son

Vérifier si l'utilisateur amis_sh existe sur le serveur :

getent passwd amis_sh || { echo "L'utilisateur n'existe pas."; }

Créer un utilisateur sudoer pour administrer le serveur VPS

Pour installer un paquet sur le serveur, la plupart des commandes seront à lancer avec sudo.

sudo -s

Vérifier si sudo est déjà installé :

whereis sudo sudo: /usr/bin/sudo /usr/libexec/sudo /usr/share/man/man8/sudo.8.gz

Installer le paquet sudo :

apt install sudo

Créer un utilisateur amis_sh qui sera sudoer

sudo adduser amis_sh Ajout de l'utilisateur « amis_sh » ... Ajout du nouveau groupe « amis_sh » (1000) ... Ajout du nouvel utilisateur « amis_sh » (1000) avec le groupe « amis_sh » (1000) ... Création du répertoire personnel « /home/amis_sh » ... Copie des fichiers depuis « /etc/skel » ... Nouveau mot de passe : MOTDEPASSE Retapez le nouveau mot de passe : MOTDEPASSE passwd : mot de passe mis à jour avec succès Modifier les informations associées à un utilisateur pour amis_sh Entrer la nouvelle valeur, ou appuyer sur ENTER pour la valeur par défaut NOM []: Numéro de chambre []: Téléphone professionnel []: Téléphone personnel []: Autre []: Cette information est-elle correcte ? [O/n]o Ajout du nouvel utilisateur « amis_sh » aux groupes supplémentaires « users » ... Ajout de l'utilisateur « amis_sh » au groupe « users » ...

Donner les droits sudoer à l'utilisateur amis_sh :

sudo usermod -a -G sudo amis_sh

Se connecter au serveur avec l'utilisateur amis_sh:

ssh amis_sh@185.209.228.195 Host key fingerprint is SHA256:MmetzuesHYe7OzgbiTl1ITxaLwGVr5K65btXAIiZhc0 +--[ED25519 256]--+ | O...... | | = E .o. | | .*.. | | o.*.. | | +.So+ | | oO.=.. | | .=.+oo . | | .o +++o+ | | ..++=*B+ | +----[SHA256]-----+ amis_sh@185.209.228.195's password:

Créer un utilisateur elevation-restart

Créer un utilisateur elevation-restart aux droits limités pour redémarrer certains services :

sudo adduser elevation-restart Enter new UNIX password: MOTDEPASSE

Ajouter les élévations de droits pour redémarrer les services apache2, mysql, php8.2-fpm.
Ne pas utiliser cette méthode qui va alourdir le fichier de visudo rendant le suivi des droits compliqué.
Utiliser la proposition par après, considérée comme bonne pratique.

# sudo visudo # elevation-restart ALL=/usr/sbin/service apache2 restart,/usr/sbin/service mysql restart,/usr/sbin/service php8.2-fpm restart

La pratique recommandée consiste à placer un fichier elevation-restart dans le dossier "/etc/sudoers.d/" :

sudo nano /etc/sudoers.d/elevation-restart

Coller les lignes suivantes :

elevation-restart ALL=/usr/sbin/service apache2 restart,/usr/sbin/service mysql restart,/usr/sbin/service php8.2-fpm restart ALL ALL=(ALL) PASSWD: /usr/sbin/shutdown

Ajout des droits d'élévation dans /etc/sudoers.d/elevation-restart avec un script EOF :
Attention si le fichier existe il sera écrasé du fait du caractères unique strictement suppérieur ">".

# Afficher la date en français en exportant la variable LC_TIME : LC_TIME=fr_FR.UTF-8 cat <<EOF> /etc/sudoers.d/elevation-restart # Le fichier /etc/sudoers.d/elevation-restart a été créé le $(date +"%A %d %B %Y à %T %Z"). # Les élévations accordées à l'utilisateur elevation-restart sont les suivantes : elevation-restart ALL=/usr/sbin/service apache2 restart,/usr/sbin/service mysql restart,/usr/sbin/service php8.2-fpm restart ALL ALL=(ALL) NOPASSWD: /usr/sbin/shutdown EOF

Se connecter en SSH avec l'utilisateur elevation-restart :

ssh elevation-restart@185.209.228.195

Actions autorisées :

sudo service apache2 restart sudo service mysql restart sudo service php8.2-fpm restart sudo shutdown -r

Les autres actions root sont refusées :

sudo apt update Sorry, user elevation-restart is not allowed to execute '/usr/bin/apt update' as root on vmi1448006.contaboserver.net.

Créer un utilisateur elevation-readlogs

Créer un utilisateur elevation-readlogs et l'ajouter au groupe adm pour consulter les logs du serveur :

sudo adduser elevation-readlogs Enter new UNIX password: MOTDEPASSE # Le groupe d'utilisateurs adm est utilisé pour permettre à ses membres de lire le contenu des fichiers journaux. # Ajouter au groupe sudo usermod -a -G adm elevation-readlogs

Se connecter en SSH avec l'utilisateur elevation-readlogs :

ssh elevation-readlogs@185.209.228.195

Créer un utilisateur elevation-backup

Créer un utilisateur elevation-backup aux droits limités pour sauvegarder le serveur :

sudo adduser elevation-backup Enter new UNIX password: MOTDEPASSE Ne pas utiliser cette première proposition qui va alourdir le fichier de visudo rendant le suivi des droits compliqué. Utiliser la proposition par après, considérée comme bonne pratique. # sudo visudo # Ajout des limitations de droits pour autoriser uniquement le script de backup elevation-backup.sh, sans avoir à saisir le mot de passe. # elevation-backup ALL=NOPASSWD: /root/scripts-de-maintenance/elevation-backup.sh

La meilleure pratique consiste à placer la ligne elevation-backup dans un fichier nommé au choix dans le dossier "/etc/sudoers.d/".
On nomme le fichier contenant le script "elevation-backup".
Créer le fichier "elevation-backup" :

sudo nano /etc/sudoers.d/elevation-backup

Coller les lignes :

# elevation-backup ALL=NOPASSWD: /usr/bin/sh /root/scripts-de-maintenance/elevation-backup.sh # EN PREMIERE SITUATION DE TEST REUSSI, IL N'ETAIT PAS NECESSAIRE DE PRECISER /usr/bin/sh !!! # Est-ce ouvrir un risque d'utiliser cette syntaxe en rajoutant /usr/bin/sh ? # Sans le /usr/bin/sh, avant, sudo sh marchait et demandait le mot de passe utilisateur. # Actuellement "sudo sh" ne permet plus de lancer le script avec cette configuration. elevation-backup ALL=NOPASSWD: /root/scripts-de-maintenance/elevation-backup.sh

Se connecter en SSH avec l'utilisateur elevation-backup :

ssh elevation-backup@185.209.228.195

Actions autorisées :

# Lancer le script elevation-backup.sh depuis /root/scripts-de-maintenance/ # sudo sh /root/scripts-de-maintenance/elevation-backup.sh # Avoir effectué un chmod 755 sur le script permet de lancer le script avec sudo sh path.sh # Actuellement le script est en 644. sudo sh /root/scripts-de-maintenance/elevation-backup.sh

Créer le fichier qui va contenir les actions de sauvegarde :

sudo mkdir /root/scripts-de-maintenance/ sudo touch /root/scripts-de-maintenance/elevation-backup.sh

Le fichier elevation-backup.sh ne doit pas pouvoir être modifié par l'utilisateur elevation-backup. L'utilisateur pourrait modifier le script et lancer des commandes malveillantes.

sudo chown root:root /root/scripts-de-maintenance/elevation-backup.sh

Créer le script de sauvegarde des données présentes sur le serveur :

sudo nano /root/scripts-de-maintenance/elevation-backup.sh #/bin/sh echo "Script de sauvegarde !" # ...

Lancer le script :

sudo sh /root/scripts-de-maintenance/elevation-backup.sh

Créer les clés SSH pour les différents utilisateurs

Les clés SSH et les passphrases pour l'accès au serveur par les différents utilisateurs sont à créer et a sauvegarder dans un fichier Keepass.

Créer les clés SSH pour l'utilisateur amis_sh

Générer une clé ed25519 directement sur le client local.
Génère la clé dans le répertoire SSH de l'utilisateur si l'emplacement n'est pas spécifié lors de la création.

ssh-keygen -t ed25519 -C "Commentaire" -b 384 -f "/home/utilisateur-local/dossier-ssh/nom-de-la-cle-sans-extension-par-defaut"

ssh-keygen -t ed25519 -C "Clé amis_sh" -b 384 -f "/home/amissh/.ssh/vps-2024/id_ed25519_amis_sh" Generating public/private ed25519 key pair. Enter passphrase (empty for no passphrase): Enter same passphrase again: Your identification has been saved in /home/amissh/.ssh/vps-2024/id_ed25519_amis_sh Your public key has been saved in /home/amissh/.ssh/vps-2024/id_ed25519_amis_sh.pub The key fingerprint is: SHA256:GPG8sa/80A0GW1dwGJX9DVGIjOUXRvQ503xhVmQeNeA Clé amis_sh The key's randomart image is: +--[ED25519 256]--+ | . ++X@&O| | + ..=+**B| | . = . oE.=O| | o B . . *| | . S o | | + o | | . o . | | . o | | o.. | +----[SHA256]-----+

L'image générée permet un rendu visuel de cette clé SSH.
Afficher la randomart image de notre clé [ED25519 256].
Cette commande doit être utilisée sur la clé publique mais fonctionne également sur la clé privée :

ssh-keygen -lvf /home/amissh/.ssh/vps-2024/id_ed25519_amis_sh.pub

Facultatif - Renommer la clé privée avec l'extension private :

mv /home/amissh/.ssh/vps-2024/id_ed25519_amis_sh /home/amissh/.ssh/vps-2024/id_ed25519_amis_sh.private

Restreindre les droits de la clé privée :

chmod 600 /home/amissh/.ssh/vps-2024/id_ed25519_amis_sh.private chown amissh:amissh /home/amissh/.ssh/vps-2024/id_ed25519_amis_sh.private

La clé publique est ajoutée sur le serveur distant sur lequel on se connecte en SSH.
La clé est ajoutée dans un fichier spécifique au compte utilisateur auquel on se connecte qui se nomme ~/.ssh/authorized_keys.

Exporter l'empreinte locale de la clé publique avec ssh-copy-id vers le serveur distant :

ssh-copy-id -f -i /home/amissh/.ssh/vps-2024/id_ed25519_amis_sh.pub amis_sh@185.209.228.195 /usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/home/amissh/.ssh/vps-2024/id_ed25519_amis_sh.pub" Host key fingerprint is SHA256:MmetzuesHYe7OzgbiTl1ITxaLwGVr5K65btXAIiZhc0 +--[ED25519 256]--+ | O...... | | = E .o. | | .*.. | | o.*.. | | +.So+ | | oO.=.. | | .=.+oo . | | .o +++o+ | | ..++=*B+ | +----[SHA256]-----+ amis_sh@185.209.228.195's password: Number of key(s) added: 1 Now try logging into the machine, with: "ssh 'amis_sh@185.209.228.195'" and check to make sure that only the key(s) you wanted were added.

Connexion au serveur avec la nouvelle clé SSH :
On spécifie l'emplacement de la clé privée sur la machine locale et on demande l'affichage de la randomart image pour vérifier l'identité du serveur.

ssh amis_sh@185.209.228.195 -i /home/amissh/.ssh/vps-2024/id_ed25519_amis_sh.private -o VisualHostKey=yes Host key fingerprint is SHA256:MmetzuesHYe7OzgbiTl1ITxaLwGVr5K65btXAIiZhc0 +--[ED25519 256]--+ | O...... | | = E .o. | | .*.. | | o.*.. | | +.So+ | | oO.=.. | | .=.+oo . | | .o +++o+ | | ..++=*B+ | +----[SHA256]-----+ Enter passphrase for key '/home/amissh/.ssh/vps-2024/id_ed25519_amis_sh.private':

Si la connexion s'effectue sans erreur, la passe phrase a bien été reconnue.

Alternatives pour exporter l'empreinte locale de la clé publique vers le serveur

Export des clés vers le serveur avec un autre port de connexion SSH :

ssh -p3333 amis_sh@ADRESSEIPDUSERVEUR 'cat >> ~/.ssh/authorized_keys' < ~/.ssh/vps-2024/id_ed25519_amis_sh.pub

Export des clés vers le serveur avec ssh-copy-id et une séquence de frappe en cas de port knocking :

for x in 1420 2710 42000; do nmap -Pn --host_timeout 201 --max-retries 0 -p $x ADRESSEIPDUSERVEUR && sleep 1; done && ssh-copy-id -i /home/amissh/.ssh/vps-2024/id_ed25519_amis_sh.pub"-p 3333 amis_sh@ADRESSEIPDUSERVEUR -o VisualHostKey=yes"

Export des clés vers le serveur avec une séquence de frappe en cas de port knocking et un autre port de connexion SSH :

for x in 1420 2710 42000; do nmap -Pn --host_timeout 201 --max-retries 0 -p $x ADRESSEIPDUSERVEUR && sleep 1; done && ssh -p3333 amis_sh@ADRESSEIPDUSERVEUR 'cat >> ~/.ssh/authorized_keys' < ~/.ssh/vps-2024/id_ed25519_amis_sh.pub

Copier coller la ligne du fichier de la clé publique vers le fichier authorized_keys de l'utilisateur sur le serveur distant si la commande ssh-copy-id ne fonctionne pas.

Créer les clés SSH pour l'utilisateur elevation-restart

Générer une clé ed25519 directement sur le client local : Générer la clé dans le répertoire SSH de l'utilisateur si l'emplacement n'est pas spécifié lors de la création.

ssh-keygen -t ed25519 -C "Commentaire" -b 384 -f "/home/utilisateur/dossier-cle/nom-de-la-cle-sans-extension-par-defaut" ssh-keygen -t ed25519 -C "Clé elevation-restart" -b 384 -f "/home/amissh/.ssh/vps-2024/id_ed25519_elevation-restart" Generating public/private ed25519 key pair. Enter passphrase (empty for no passphrase): Enter same passphrase again: Your identification has been saved in /home/amissh/.ssh/vps-2024/id_ed25519_elevation-restart Your public key has been saved in /home/amissh/.ssh/vps-2024/id_ed25519_elevation-restart.pub The key fingerprint is: SHA256:DUVUrURiz297ZVa5hLs3BNvn2D1Br7Uww4MfImYh9Kg Clé elevation-restart The key's randomart image is: +--[ED25519 256]--+ | . o*oo. | | . oo +. o .| | o.o .o+ +.| | . .o. +.B +| | E S+.o Xo=B| | o . o.OX*| | o+==| | ..o| | | +----[SHA256]-----+

L'image générée permet un rendu visuel de cette clé SSH [ED25519 256].

Afficher la randomart image de notre clé [ED25519 256].
Cette commande doit être utilisée sur la clé publique mais fonctionne également sur la clé privée :

ssh-keygen -lvf /home/amissh/.ssh/vps-2024/id_ed25519_elevation-restart.pub

Facultatif - Renommer la clé privée avec l'extension private :

mv /home/amissh/.ssh/vps-2024/id_ed25519_elevation-restart /home/amissh/.ssh/vps-2024/id_ed25519_elevation-restart.private

Restreindre les droits de la clé privée :

chmod 600 /home/amissh/.ssh/vps-2024/id_ed25519_elevation-restart.private chown amissh:amissh /home/amissh/.ssh/vps-2024/id_ed25519_elevation-restart.private

Exporter l'empreinte de la clé avec ssh-copy-id vers le serveur distant :

ssh-copy-id -f -i /home/amissh/.ssh/vps-2024/id_ed25519_elevation-restart elevation-restart@185.209.228.195 Host key fingerprint is SHA256:MmetzuesHYe7OzgbiTl1ITxaLwGVr5K65btXAIiZhc0 +--[ED25519 256]--+ | O...... | | = E .o. | | .*.. | | o.*.. | | +.So+ | | oO.=.. | | .=.+oo . | | .o +++o+ | | ..++=*B+ | +----[SHA256]-----+ elevation-restart@185.209.228.195's password: Number of key(s) added: 1 Now try logging into the machine, with: "ssh 'elevation-restart@185.209.228.195'" and check to make sure that only the key(s) you wanted were added.

Connexion au serveur avec la nouvelle clé SSH :
On spécifie l'emplacement de la clé privée sur la machine locale et on demande l'affichage de la randomart image pour vérifier l'identité du serveur.

ssh elevation-restart@185.209.228.195 -i /home/amissh/.ssh/vps-2024/id_ed25519_elevation-restart.private -o VisualHostKey=yes Host key fingerprint is SHA256:MmetzuesHYe7OzgbiTl1ITxaLwGVr5K65btXAIiZhc0 +--[ED25519 256]--+ | O...... | | = E .o. | | .*.. | | o.*.. | | +.So+ | | oO.=.. | | .=.+oo . | | .o +++o+ | | ..++=*B+ | +----[SHA256]-----+ Enter passphrase for key '/home/amissh/.ssh/vps-2024/id_ed25519_elevation-restart.private':

Si la connexion s'effectue sans erreur, la passe phrase a bien été reconnue.

Créer les clés SSH pour l'utilisateur elevation-backup

Générer une clé ed25519 directement sur le client local :
Générer la clé dans le répertoire SSH de l'utilisateur si l'emplacement n'est pas spécifié lors de la création.

ssh-keygen -t ed25519 -C "Commentaire" -b 384 -f "/home/utilisateur/dossier-cle/nom-de-la-cle-sans-extension-par-defaut" ssh-keygen -t ed25519 -C "Clé elevation-backup" -b 384 -f "/home/amissh/.ssh/vps-2024/id_ed25519_elevation-backup" Generating public/private ed25519 key pair. Enter passphrase (empty for no passphrase): Enter same passphrase again: Your identification has been saved in /home/amissh/.ssh/vps-2024/id_ed25519_elevation-backup Your public key has been saved in /home/amissh/.ssh/vps-2024/id_ed25519_elevation-backup.pub The key fingerprint is: SHA256:u7sJZmhJrO7+TlF4pBZcXeiTKLyhF2vtinWrikhO73k Clé elevation-backup The key's randomart image is: +--[ED25519 256]--+ | ...o. o. | | .= o | | .+ oo . | | o=o. + | | .+B S. | | .o=+. . | | o.o*.= . | |=o.=.E.o o | |o+BB*o. =o | +----[SHA256]-----+ L'image générée permet un rendu visuel de cette clé SSH [ED25519 256].

Afficher la randomart image de notre clé [ED25519 256].
Cette commande doit être utilisée sur la clé publique mais fonctionne également sur la clé privée :

ssh-keygen -lvf /home/amissh/.ssh/vps-2024/id_ed25519_elevation-backup.pub

Facultatif - Renommer la clé privée avec l'extension private :

mv /home/amissh/.ssh/vps-2024/id_ed25519_elevation-backup /home/amissh/.ssh/vps-2024/id_ed25519_elevation-backup.private

Restreindre les droits de la clé privée :

chmod 600 /home/amissh/.ssh/vps-2024/id_ed25519_elevation-backup.private chown amissh:amissh /home/amissh/.ssh/vps-2024/id_ed25519_elevation-backup.private

Exporter l'empreinte de la clé avec ssh-copy-id vers le serveur distant :

ssh-copy-id -f -i /home/amissh/.ssh/vps-2024/id_ed25519_elevation-backup elevation-backup@185.209.228.195 Host key fingerprint is SHA256:MmetzuesHYe7OzgbiTl1ITxaLwGVr5K65btXAIiZhc0 +--[ED25519 256]--+ | O...... | | = E .o. | | .*.. | | o.*.. | | +.So+ | | oO.=.. | | .=.+oo . | | .o +++o+ | | ..++=*B+ | +----[SHA256]-----+ elevation-backup@185.209.228.195's password: Number of key(s) added: 1 Now try logging into the machine, with: "ssh 'elevation-backup@185.209.228.195'" and check to make sure that only the key(s) you wanted were added.

Connexion au serveur avec la nouvelle clé SSH :
On spécifie l'emplacement de la clé privée sur la machine locale et on demande l'affichage de la randomart image pour vérifier l'identité du serveur.

ssh elevation-backup@185.209.228.195 -i /home/amissh/.ssh/vps-2024/id_ed25519_elevation-backup.private -o VisualHostKey=yes Host key fingerprint is SHA256:MmetzuesHYe7OzgbiTl1ITxaLwGVr5K65btXAIiZhc0 +--[ED25519 256]--+ | O...... | | = E .o. | | .*.. | | o.*.. | | +.So+ | | oO.=.. | | .=.+oo . | | .o +++o+ | | ..++=*B+ | +----[SHA256]-----+ Enter passphrase for key '/home/amissh/.ssh/vps-2024/id_ed25519_elevation-backup.private': Si la connexion s'effectue sans erreur, la passe phrase a bien été reconnue.

Créer les clés SSH pour l'utilisateur elevation-readlogs

Générer une clé ed25519 directement sur le client local :
Générer la clé dans le répertoire SSH de l'utilisateur si l'emplacement n'est pas spécifié lors de la création.

ssh-keygen -t ed25519 -C "Commentaire" -b 384 -f "/home/utilisateur/dossier-cle/nom-de-la-cle-sans-extension-par-defaut" ssh-keygen -t ed25519 -C "Clé elevation-readlogs" -b 384 -f "/home/amissh/.ssh/vps-2024/id_ed25519_elevation-readlogs" Generating public/private ed25519 key pair. Enter passphrase (empty for no passphrase): Enter same passphrase again: Your identification has been saved in /home/amissh/.ssh/vps-2024/id_ed25519_elevation-readlogs Your public key has been saved in /home/amissh/.ssh/vps-2024/id_ed25519_elevation-readlogs.pub The key fingerprint is: SHA256:zs9q7X4Xc7OARTeDD6+tj7ioIwWSXKQRklIBN7KrG24 Clé elevation-readlogs The key's randomart image is: +--[ED25519 256]--+ |o+*+o. . | |.=..o. + + | |o ..o . = o| | . + . . o | |. . . S o o | |. + . ooo.| |o . o. o+o| |.E . ..oo o.o. | |o. .o+==+.o.. | +----[SHA256]-----+ L'image générée permet un rendu visuel de cette clé SSH [ED25519 256].

Afficher la randomart image de notre clé [ED25519 256].
Cette commande doit être utilisée sur la clé publique mais fonctionne également sur la clé privée :

ssh-keygen -lvf /home/amissh/.ssh/vps-2024/id_ed25519_elevation-readlogs.pub

Facultatif - Renommer la clé privée avec l'extension private :

mv /home/amissh/.ssh/vps-2024/id_ed25519_elevation-readlogs /home/amissh/.ssh/vps-2024/id_ed25519_elevation-readlogs.private

Restreindre les droits de la clé privée :

chmod 600 /home/amissh/.ssh/vps-2024/id_ed25519_elevation-readlogs.private chown amissh:amissh /home/amissh/.ssh/vps-2024/id_ed25519_elevation-readlogs.private

Exporter l'empreinte de la clé avec ssh-copy-id vers le serveur distant :

ssh-copy-id -f -i /home/amissh/.ssh/vps-2024/id_ed25519_elevation-readlogs elevation-readlogs@185.209.228.195 /usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/home/amissh/.ssh/vps-2024/id_ed25519_elevation-readlogs.pub" Host key fingerprint is SHA256:MmetzuesHYe7OzgbiTl1ITxaLwGVr5K65btXAIiZhc0 +--[ED25519 256]--+ | O...... | | = E .o. | | .*.. | | o.*.. | | +.So+ | | oO.=.. | | .=.+oo . | | .o +++o+ | | ..++=*B+ | +----[SHA256]-----+ elevation-readlogs@185.209.228.195's password: Number of key(s) added: 1 Now try logging into the machine, with: "ssh 'elevation-readlogs@185.209.228.195'" and check to make sure that only the key(s) you wanted were added.

Connexion au serveur avec la nouvelle clé SSH :
On spécifie l'emplacement de la clé privée sur la machine locale et on demande l'affichage de la randomart image pour vérifier l'identité du serveur.

ssh elevation-readlogs@185.209.228.195 -i /home/amissh/.ssh/vps-2024/id_ed25519_elevation-readlogs.private -o VisualHostKey=yes Host key fingerprint is SHA256:MmetzuesHYe7OzgbiTl1ITxaLwGVr5K65btXAIiZhc0 +--[ED25519 256]--+ | O...... | | = E .o. | | .*.. | | o.*.. | | +.So+ | | oO.=.. | | .=.+oo . | | .o +++o+ | | ..++=*B+ | +----[SHA256]-----+ Enter passphrase for key '/home/amissh/.ssh/vps-2024/id_ed25519_elevation-readlogs.private': Si la connexion s'effectue sans erreur, la passe phrase a bien été reconnue.

Modifier la configuration du client SSH de la machine locale

Modifier la configuration du client SSH de la machine locale pour ne pas avoir à ajouter le paramètre "-o VisualHostKey=yes" à chaque tentative de connexion.

Soit depuis le fichier de configuration globale du client SSH :

sudo nano /etc/ssh/ssh_config VisualHostKey yes

Soit depuis le fichier de configuration personnalisé de l'utilisateur de la machine locale :

nano .ssh/config VisualHostKey=yes

Connaître les randomart dans le fichier known_hosts de la machine locale

Afficher les randomart connus et enregistrés dans le fichier known_hosts de la machine locale (ECDSA) : ssh-keygen -lvf ~/.ssh/known_hosts

Si la randomart image est différente lors de la connexion, c'est certainement que l'on est victime d'une attaque de l'homme du milieu.

Remplacer les messages de connexion

Se connecter au serveur avec l'utilisateur amis_sh et sa clé SSH :

ssh amis_sh@185.209.228.195 -i /home/amissh/.ssh/vps-2024/id_ed25519_amis_sh.private -o VisualHostKey=yes

Remplacer le message initial affiché lors de la demande de connexion au serveur SSH depuis le fichier "/etc/issue" :

sudo nano /etc/issue ############################################# # Demande de connexion au serveur Contabo ! # #############################################

Remplacer le message initial affiché une fois la connexion SSH établie avec le serveur :

sudo nano /etc/motd ##################################### # Connexion au serveur VPS établie! # #####################################

Configurer le serveur SSH

Copier la configuration SSH d'origine dans un fichier d'archive :

sudo cp /etc/ssh/sshd_config /etc/ssh/sshd_config.ori.bak

Accepter uniquement les connexions par clés SSH depuis le serveur.
Se connecter au serveur VPS pour configurer le serveur SSH afin d'accepter uniquement les connexions par clés SSH.
Ne pas se déconnecter de ce terminal avant d'avoir vérifié depuis un deuxième terminal que la connexion par clé fonctionne.

Remplacer la configuration par défaut par la configuration optimisée proposée par après.
Cette configuration autorise uniquement la connexion au serveur à l'aide de clés SSH ed25519.
Il est indispensable de renseigner les noms des utilisateurs autorisés à se connecter au serveur dans cette configuration.

sudo nano /etc/ssh/sshd_config ################################ # Configuration du Serveur SSH # ################################ # Le Protocole 2 est mieux sécurisé : Protocol 2 # Port à utiliser : # Port 22 Port 2226 # Clé publique du serveur à utiliser pour identifier le serveur : # HostKey /etc/ssh/ssh_host_rsa_key HostKey /etc/ssh/ssh_host_ed25519_key ########################################## # A désactiver pour utiliser ssh-copy-id # ########################################## # Oblige l'authentification par clé SSH : # Valeur commentée par défaut ! AuthenticationMethods publickey # Interdire l'authentification par mot de passe : PasswordAuthentication no # Interdire les mots de passe vide : PermitEmptyPasswords no # Le serveur d'authentification challenge-response PAM n'est pas configuré par défaut : # Commande obsolète remplacée par KbdInteractiveAuthentication. # ChallengeResponseAuthentication no # Certains modules et threads PAM KbdInteractiveAuthentication no # PAM fournit la gestion des sessions et des comptes ! UsePAM yes # Autoriser la connexion pour les utilisateurs suivants : AllowUsers amis_sh elevation-restart elevation-backup elevation-readlogs # Autoriser la connexion pour les groupes suivants : # AllowGroups # Choix de connexion pour l'utilisateur root sur le serveur SSH : PermitRootLogin no # Interdire certains utilisateurs séparés par un espace : DenyUsers root # Interdire certains groupes séparés par un espace : # DenyGroups ########################################## # Durée maximum autorisée pour établir la connexion : LoginGraceTime 25s # Limiter a un nombre maximum les tentatives de connexions SSH non authentifiée : MaxStartups 3:50:5 # Maximum de 3 essais pour renseigner la passe phrase : MaxAuthTries 3 # Maximum de 3 sessions ouvertes en même temps : MaxSessions 3 # Autorise l'authentification par clé SSH : PubkeyAuthentication yes # Clés publiques autorisées pour établir une connexion : AuthorizedKeysFile .ssh/authorized_keys .ssh/authorized_keys2 # Interdire la prise en compte des fichiers de configuration des commandes r avec SSH : IgnoreRhosts yes # Refuser l'export display : X11Forwarding no #X11DisplayOffset 10 #X11UseLocalhost yes # La valeur no désactive l'impression de motd. # Le motd s'affiche quand même si UsePAM vaut yes. PrintMotd no #PrintLastLog yes # Refuser l'authentification basée sur les DNS : UseDNS no # Refuser l'authentification basée sur l'hôte : HostbasedAuthentication no #PidFile /run/sshd.pid # Permet au client de définir des variables d'environnement dès l'établissement de la connexion : AcceptEnv LANG LC_* # Loguer les tentatives de connexions dans /var/log/auth.log en ajoutant la ligne suivante : SyslogFacility AUTH # Permet d'avoir une trace d'audit claire de la clé utilisée pour se connecter : LogLevel VERBOSE # Journaliser les accès aux fichiers de niveau sftp qui ne seraient pas journalisés autrement : # Subsystem sftp /usr/lib/openssh/sftp-server Subsystem sftp /usr/lib/openssh/sftp-server -f AUTHPRIV -l INFO # Timeout value = ClientAliveInterval * ClientAliveCountMax # La valeur Timeout = 300 * 3 = 900 secondes = 15 minutes. # La session ssh restera active pendant une période d'inactivité de 15 minutes sans interruption. # Contacte le serveur pour empêcher la déconnexion : ClientAliveInterval 300 # Concerne le nombre maximal de requêtes : ClientAliveCountMax 3 # Vérifie les modes et le propriétaire des fichiers et du répertoire home de l'utilisateur avant de se connecter : StrictModes yes # La mort de la connexion ou le crash de la machines sera remarqué pour mettre fin à la connexion : TCPKeepAlive yes #PermitUserEnvironment no #Compression delayed # Afficher un message pour l'utilisateur suite à une demande de connexion : # Banner none Banner /etc/issue # En règle général les entreprises préfèrent désactiver le Port Forwarding pour éviter la fuite d'informations : AllowTcpForwarding no # Spécifie si le transfert de sockets de domaine Unix est autorisé : AllowStreamLocalForwarding no # Spécifie si les hôtes distants sont autorisés à se connecter aux ports transférés pour le client : GatewayPorts no # Spécifie si le transfert de périphérique est autorisé : PermitTunnel no # Spécifie les destinations vers lesquelles le transfert de port TCP est autorisé : PermitOpen any # Spécifier les algorithmes KEX (échange de clés) disponibles : KexAlgorithms curve25519-sha256@libssh.org,ecdh-sha2-nistp521,ecdh-sha2-nistp384,ecdh-sha2-nistp256,diffie-hellman-group-exchange-sha256 # Spécifier les ciphers autorisés : Ciphers chacha20-poly1305@openssh.com,aes256-gcm@openssh.com,aes128-gcm@openssh.com,aes256-ctr,aes192-ctr,aes128-ctr # Spécifier les algorithmes MAC (Message authentication code) : MACs hmac-sha2-512-etm@openssh.com,hmac-sha2-256-etm@openssh.com,umac-128-etm@openssh.com,hmac-sha2-512,hmac-sha2-256,umac-128@openssh.com #ChrootDirectory none #VersionAddendum none # Example of overriding settings on a per-user basis # Match User anoncvs # X11Forwarding no # AllowTcpForwarding no # PermitTTY no # ForceCommand cvs server # PermitRootLogin yes

L'utilisateur root a été interdit pour la connexion SSH et le port SSH par défaut a été modifié pour utiliser le port 2226.

Depuis un second terminal, se reconnecter et recharger la configuration :

ssh amis_sh@185.209.228.195 -i /home/amissh/.ssh/vps-2024/id_ed25519_amis_sh.private -o VisualHostKey=yes sudo systemctl reload ssh

Dans un troisième terminal, tester les connexions des utilisateurs autorisés par clé SSH depuis un nouveau terminal :
L'utilisateur amis_sh peut se connecter au serveur uniquement avec sa clé privée et sa passphrase via le nouveau port ssh 2226 :

ssh -p2226 amis_sh@185.209.228.195 -i /home/amissh/.ssh/vps-2024/id_ed25519_amis_sh.private -o VisualHostKey=yes

La configuration pour les clés SSH est fonctionnelle.
On peut se connecter au serveur depuis un second terminal. Fermer le premier terminal.
Si la connexion ne fonctionne pas depuis le nouveau terminal, utiliser le premier terminal pour recharger la configuration par défaut précédemment sauvegardée pour ne pas être éjecté du serveur.

sudo mv /etc/ssh/sshd_config /etc/ssh/sshd_config.new.ko sudo cp /etc/ssh/sshd_config.ori.bak /etc/ssh/sshd_config sudo service ssh reload

Les logs de SSH peuvent aider à identifier un problème de connexion.
Si les logs sont vides, il faudra certainement installer et configurer rsyslog.
Lors de ce premier déploiement, le fichier de logs SSH /var/log/auth.log est correctement renseigné sans avoir eu besoin d'activer ou de démarrer rsyslog.

nano /var/log/auth.log

Afficher des messages système personnalisés en fonction de l'utilisateur

Afficher des messages système personnalisés une fois connecté au serveur en fonction de l'utilisateur.
Personnaliser un message pour chaque utilisateur afin d'obtenir des informations sur le système ou les commandes autorisées suite à la connexion SSH.
Modifier le fichier suivant pour chacun des utilisateurs :

sudo nano /home/USER/.bash_profile

Configuration /home/amis_sh/.bash_profile

sudo nano /home/amis_sh/.bash_profile

Ajouter les lignes :

echo "############################################################" echo "Connexions SSH actuellement établies avec w:" w echo "" echo "Mémoire RAM et swap disponible avec free -m :" free -m echo "" echo "Espace disque et pourcentage d'occupation avec df -h -x tmpfs :" df -h -x tmpfs echo "" echo "Utilisation de tmpfs avec df -h | grep tmpfs :" df -h | grep tmpfs echo "############################################################"

Configuration /home/elevation-restart/.bash_profile

sudo nano /home/elevation-restart/.bash_profile

Ajouter les lignes :

echo "############################################################" echo "############################################################" echo "" echo "Commandes autorisées :" echo "" echo "sudo systemctl restart php8.2-fpm" echo "sudo systemctl restart apache2" echo "sudo systemctl restart mysql" # Vérifier pour la commande mysql pour mariaDB. echo "sudo shutdown -r" echo "" echo "############################################################" echo "############################################################"

Configuration /home/elevation-backup/.bash_profile

sudo nano /home/elevation-backup/.bash_profile

Ajouter les lignes :

echo "############################################################" echo "############################################################" echo "" echo "Commandes autorisées :" echo "" echo "Effectuer une sauvegarde des données :"; echo "sudo /root/scripts-de-maintenance/elevation-backup.sh" echo "" echo "############################################################" echo "############################################################"

Configuration /home/elevation-readlogs/.bash_profile

sudo nano /home/elevation-readlogs/.bash_profile

Ajouter les lignes :

echo "############################################################" echo "############################################################" echo "" echo "Commandes autorisées :" echo "Consulter les fichiers ajoutés au groupe adm." echo "" echo "Consulter les logs dans /var/logs" echo "cd /var/logs" echo "" echo "Consulter les logs de SSH :" echo "nano /var/log/auth.log" echo "" echo "############################################################" echo "############################################################"

Consulter les droits sur Visudo

Ajouter les insultes de courtoisie en cas de connexion avec erreurs de mot de passe.

visudo Defaults env_reset,insults

Vérifier les droits des clés SSH sur la machine locale

Par défaut les fichiers créés localement depuis l'interface graphique, avec un clique droit créer un fichier, ont les droits CHMOD à 644.
Ajouter des contenus de clés par copier coller dans des fichiers créés manuellement ne va donc pas respecter le contexte de sécurité recommandé.
Suite à une identification en simple utilisateur, un message d'alerte rappel qu'il est indispensable de donner des droits moindre à la clé privée, sinon, la clé privée sera ignorée.

@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ @ WARNING: UNPROTECTED PRIVATE KEY FILE! @ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ Permissions 0664 for '/home/utilisateur/.ssh/dossier/id_rsa_exemple.private' are too open. It is required that your private key files are NOT accessible by others. This private key will be ignored.

Passer les droits du dossier .ssh et des sous dossiers à 700 :

cd ~/ sudo chmod -R 700 .ssh/ sudo chown -R utilisateur:utilisateur .ssh/

Passer les droits des fichiers à 644 et les clés privées à 600 :

cd ~/.ssh/ sudo find . -type f -exec chmod 644 {} ; sudo chmod 600 *.private sudo chmod 644 *.pub sudo chmod 600 authorized_keys

Configurer le client SSH

Configurer le client SSH de la machine locale pour ne pas avoir à ajouter le paramètre "-o VisualHostKey=yes" à chaque tentative de connexion.

Configurer le client SSH :

sudo nano /etc/ssh/ssh_config

Ajouter les lignes suivantes dans le fichier de configuration du client local :

Host * PasswordAuthentication no VisualHostKey yes StrictHostKeyChecking yes # Timeout value = ClientAliveInterval * ClientAliveCountMax # La valeur Timeout = 150 * 2 = 300 secondes = 5 minutes. # La session ssh restera active pendant une période d'inactivité de 5 minutes sans interruption. # Éviter la déconnexion par timeout peut être utilisé en paramètre ssh : # ssh -o "ServerAliveInterval 150" user@domain ServerAliveInterval 150 ServerAliveCountMax 2

Configurer le fichier de configuration config de l'utilisateur local :

sudo nano .ssh/config

Ajouter les lignes suivantes dans le fichier de configuration de l'utilisateur local :

############################ # nano ~/.ssh/config # # Configuration par défaut # ############################################################## Host * VisualHostKey=yes # Maintenir la connexion ouverte : # Peut aussi être passé en paramètre : ssh -o "ServerAliveInterval 60" user@domain ServerAliveInterval 100 ServerAliveCountMax 2 ############################################################## # [vps2024 Contabo] Sudoers amis_sh Host amis IdentityFile ~/.ssh/vps-2024/id_ed25519_amis_sh.private HostName 185.209.228.195 User amis_sh Port 2226 PubKeyAuthentication yes IdentitiesOnly yes # Configurer le multiplexage : # Configurer SSH pour conserver une connexion persistante au serveur distant. # Configurer les options ControlMaster, ControlPath et ControlPersist. # Le réglage ControlMaster sur auto permet à ssh de réutiliser une connexion existante ou de créer une nouvelle connexion si nécessaire. ControlMaster auto # Le paramètre ControlPath active le partage de connexion. ControlPath ~/.ssh/sockets/socket-%C # Le paramètre ControlPersist permet à la connexion de rester active pendant un certain temps après la fin de la dernière session SSH. ControlPersist 30m # La commande de connexion : # ssh -p2226 amis_sh@185.209.228.195 -i ~/.ssh/vps-2024/id_ed25519_amis_sh.private -o VisualHostKey=yes # Est remplacée par le raccourci configuré depuis ~/.ssh/config : # ssh amis-sh ############################################################## # [vps2024 Contabo] elevation-restart Host elevation-restart IdentityFile ~/.ssh/vps-2024/id_ed25519_elevation-restart.private HostName 185.209.228.195 User elevation-restart Port 2226 PubKeyAuthentication yes IdentitiesOnly yes # [vps2024 Contabo] elevation-backup Host elevation-backup IdentityFile ~/.ssh/vps-2024/id_ed25519_elevation-backup.private HostName 185.209.228.195 User elevation-backup Port 2226 PubKeyAuthentication yes IdentitiesOnly yes # [vps2024 Contabo] elevation-readlogs Host elevation-readlogs IdentityFile ~/.ssh/vps-2024/id_ed25519_elevation-readlogs.private HostName 185.209.228.195 User elevation-readlogs Port 2226 PubKeyAuthentication yes IdentitiesOnly yes ##############################################################

La connexion SSH reste active et ne redemande pas la passe phrase.

ssh amis exit ssh amis

Voir l'option ControlPersist 30m dans le fichier ~/.ssh/config :

nano ~/.ssh/config

Afficher le pid de la connexion persistante :

ssh -O check amis Master running (pid=9778)

Vérifier si le socket présent dans le dossier socket est utilisé par la connexion "amis" :

cd .ssh/sockets/ ls socket-4120b668e19cca0307a19ba4ef8e2c783fcf80ac ssh -o ControlPath=~/.ssh/sockets/socket-4120b668e19cca0307a19ba4ef8e2c783fcf80ac -O check amis Master running (pid=9778)

Fermer la persistance de la connexion "amis" :

ssh -o ControlPath=~/.ssh/sockets/socket-4120b668e19cca0307a19ba4ef8e2c783fcf80ac -O exit amis Exit request sent.

Gestion du temps d'inactivité du shell sur la machine locale

Ajouter TMOUT=300 (5minutes) sur le serveur va contre la configuration du serveur ssh de conserver la connexion ouverte pendant 15 minutes.
Ajouter TMOUT=300 (5minutes) respecte la configuration du client de conserver la connexion ouverte pendant 5 minutes.
Ajouter TMOUT permet de déconnecter une session du terminal au bout de 5 minutes.
La session reste active avec le paramètre ssh de persistence ControlPersist 30m.
La connexion au serveur peut être relancée en une ligne sans identification.

sudo nano ~/.bashrc

Ajouter :

# Déconnecter une session au bout de 5 minutes : TMOUT=300 # Empêcher les utilisateurs normaux de modifier cette variable : readonly TMOUT export TMOUT

(Ne fonctionne pas sur le serveur ? Mais en local.)

sudo nano /root/.bashrc

Ajouter :

# Déconnecter une session au bout de 5 minutes : TMOUT=300 # Empêcher les utilisateurs normaux de modifier cette variable : readonly TMOUT export TMOUT

(Ne fonctionne pas sur le serveur ? Mais en local.)

Recharger la session :

source .bashrc

Pour appliquer ce paramètre à tous les utilisateurs, configurer le fichier « /etc/bash.bashrc » qui est le fichier sur lequel se base tous les « ~/.bashrc » des utilisateurs.

sudo nano /etc/bash.bashrc # Déconnecter une session au bout de 5 minutes : TMOUT=300 # Empêcher les utilisateurs normaux de modifier cette variable : readonly TMOUT export TMOUT

Exécuter la commande suivante afin de mettre à jour les bash :

source /etc/bash.bashrc

Fonctionne sur le serveur pour déconnecter l'utilisateur élevé en sudoers et le passer en simple utilisateur.

Un message d'erreur s'affiche une fois le temps d'inactivité atteint :

attente de données expirée : déconnexion automatique

L'inactivité d'une session n'est donc plus un problème car celle-ci est déconnectée automatiquement après un certain laps de temps.

Le fichier profile peut également être utilisé pour utiliser TMOUT :
Pour activer TMOUT à l'échelle du système pour tous les utilisateurs, définir la variable dans le fichier d'initialisation du shell /etc/profile.

sudo nano /etc/profile # Déconnecter une session au bout de 5 minutes : TMOUT=300 # Empêcher les utilisateurs normaux de modifier cette variable : readonly TMOUT export TMOUT

Fonctionne sur le serveur pour l'utilisateur non sur élevé en droits et ferme le terminal :

attente de données expirée : déconnexion automatique

Recharger le fichier profile :

source ~/.profile

Désactiver la déconnexion automatique TMOUT :

export TMOUT=0 # Ou : unset TMOUT

Vérifier les sessions en cours d'exécution :

w

Exemple de commande de connexion SSH au serveur en cas de port knocking :

for x in 1420 2710 42000; do nmap -Pn --max-retries 0 -p $x ADRESSEIPDUSERVEUR && sleep 1; done && ssh amis_sh@ADRESSEIPDUSERVEUR -i /home/amissh/.ssh/vps-2024/id_ed25519_amis_sh.private -o VisualHostKey=yes

Pour optimiser la sécurité du système d'exploitation, il est préférable de désactiver le mot de passe et de verrouiller l'utilisateur root une fois SSH configuré.

Erreur rencontrées

sshd: pam_env(sshd:session): deprecated reading of user environment enabled

Proposition de correctif, manque de documentation :

sudo nano /etc/pam.d/sshd # session required pam_env.so user_readenv=1 envfile=/etc/default/locale session required pam_env.so user_readenv=0 envfile=/etc/default/locale

Supprimer un utilisateur sur Linux

Ne jamais supprimer l'utilisateur root.
Sous Linux (comme Unix), un grand nombre de processus système dépendent de la présence de l'utilisateur root dans la configuration du serveur.

Désactiver et bloquer l'utilisateur root

Créer un nouveau compte utilisateur avec les droits sudoer avant de désactiver l'utilisateur par défaut "root".
Voir l'étape précédente, Sécuriser la connexion SSH.

Supprimer le mot de passe de l'utilisateur root pour ne pas conserver le hash du mot de passe en mémoire :
Pour supprimer un mot de passe, utiliser "passwd -d ou --delete" :

sudo passwd -d root

Recréer un mot de passe pour réactiver l'utilisateur root si nécessaire :

sudo passwd root

Verrouiller un utilisateur

Le verrouillage d'un mot de passe empêche l'utilisateur de se connecter en utilisant son mot de passe.
L'utilisateur reste en mesure de se connecter en utilisant d'autres méthodes d'authentification.
Si l'utilisateur root est verrouillé de la sorte, il ne pourra pas executer toutes les tâches du système, des erreurs concernant les tâches cron seront affichées dans les logs de journalctl. Verrouiller un mot de passe avec "passwd -l ou --lock" et déverouiller avec "passwd -u ou --unlock":

# Verrouiller complètement l'accès d'un utilisateur : sudo passwd --lock utilisateur # Réactiver l'utilisateur si nécessaire : sudo passwd --unlock utilisateur

Désactiver et supprimer un utilisateur Linux autre que root

Désactiver et supprimer un utilisateur nommé "debian".

Commenter les élévations de droit de l'utilisateur debian dans les fichiers présents dans le répertoire /etc/sudoers.d/ :

sudo bash cd /etc/sudoers.d/ ls # Exemple : nano /etc/sudoers.d/debian-cloud-init # Affiche les droits de l'utilisateur debian et les commenter : ### Droits de l'utilisateur debian - root sans mot de passe. ### debian ALL=(ALL) NOPASSWD:ALL

Avant de supprimer un utilisateur, il est important de verrouiller son compte.
La commande suivante verrouille le mot de passe de l'utilisateur debian et donc désactive le compte de l'utilisateur debian :

sudo passwd -l debian Le compte utilisateur debian a bien été désactivé !

La commande suivante déverrouille le mot de passe, donc, déverrouille le compte de l'utilisateur debian.

sudo passwd -u debian

Supprimer l'utilisateur debian et son répertoire "home" ainsi que sa boîte mail avec la commande userdel et l'option -r :

sudo userdel -r debian

L'utilisateur debian est maintenant supprimé.

Verrouiller et déverrouiller les utilisateurs avec la commande chage

La commande chage est utilisée pour modifier les informations d'expiration du mot de passe utilisateur.
Fixer la date d'expiration au 1970-01-02 et verrouiller l'utilisateur avec 1 :

sudo chage -E 1 utilisateur

Supprimer la date d'expiration et déverrouiller l'utilisateur avec -1 :

sudo chage -E -1 utilisateur

Vérifier le statut d'un utilisateur avec la commande passwd

Vérifier si un utilisateur est verrouillé ou déverrouillé avec "passwd -S ou --status" :

passwd -S root root L 2024-01-03 0 99999 7 -1

Le deuxième champ dans la sortie indique le statut du compte :
– P ou PS : Le mot de passe est défini, l'utilisateur est déverrouillé.
– L ou LK : L'utilisateur est verrouillé.
– N ou NP : Aucun mot de passe n'est requis par l'utilisateur.