Sudo (Français) - ArchWiki

Jump to content

# Sudo (Français)

From ArchWiki
État de la traduction: Cet article est la version francophone de Sudo. Date de la dernière traduction: 2022-10-03. Vous pouvez aider à synchroniser la traduction s'il y a eu des changements dans la version anglaise.

Related articles

- Users and groups (Français)
- su (Français)
- doas

Sudo permet à un administrateur système de déléguer l'autorité pour donner à certains utilisateurs - ou groupes d'utilisateurs - la possibilité d'exécuter des commandes en tant que root ou un autre utilisateur tout en fournissant une piste d'audit des commandes et de leurs arguments.

Sudo est une alternative à su pour exécuter des commandes en tant que root. Contrairement à su, qui lance un shell root permettant à toutes les autres commandes d'accéder à l'utilisateur root, sudo accorde une élévation temporaire des privilèges à une seule commande. En activant les privilèges root uniquement lorsque cela est nécessaire, l'utilisation de sudo réduit la probabilité qu'une faute de frappe ou un bug dans une commande invoquée ruine le système.

Sudo peut également être utilisé pour exécuter des commandes en tant qu'autres utilisateurs ; en outre, sudo enregistre toutes les commandes et les tentatives d'accès échouées à des fins d'audit de sécurité.

## Installation

Installez le paquet sudo.

## Utilisation

Pour commencer à utiliser `sudo` en tant qu'utilisateur non privilégié, il doit être correctement configuré. Consultez #Configuration.

Pour utiliser sudo, il suffit de préfixer une commande et ses arguments par `sudo` et un espace :

    $ sudo cmd

Par exemple, pour utiliser pacman :

    $ sudo pacman -Syu

Consultez sudo(8) pour plus d'informations.

## Configuration

### Squelette des paramètres par défaut

sudoers(5) § SUDOERS OPTIONS liste toutes les options qui peuvent être utilisées avec la commande `Defaults` dans le fichier `/etc/sudoers`.

Consultez [1] pour obtenir une liste d'options (analysées à partir du code source de la version 1.8.7) dans un format optimisé pour `sudoers`.

Consultez sudoers(5) pour plus d'informations, comme la configuration du délai d'expiration du mot de passe.

### Afficher les paramètres actuels

Exécutez `sudo -ll` pour imprimer la configuration sudo actuelle, ou `sudo -lU user` pour un utilisateur spécifique.

### Utilisation de visudo

Le fichier de configuration de sudo est `/etc/sudoers`. Il doit toujours être édité avec la commande visudo(8). La commande visudo verrouille le fichier `sudoers`, enregistre les modifications dans un fichier temporaire, et vérifie qu'il n'y a pas d'erreurs de syntaxe avant de le copier dans `/etc/sudoers`.

Attention

- Il est impératif que le fichier `sudoers` soit exempt d'erreurs de syntaxe ! Toute erreur rend sudo inutilisable. Il faut toujours l'éditer avec visudo pour éviter les erreurs.
- visudo(8) prévient que configurer visudo pour honorer les variables d'environnement de l'utilisateur pour l'éditeur de son choix peut être une faille de sécurité, puisqu'elle permet à l'utilisateur avec les privilèges de visudo d'exécuter des commandes arbitraires en tant que root sans journalisation simplement en définissant cette variable à quelque chose d'autre.

L'éditeur par défaut de visudo est vi. Le paquet sudo est compilé avec `--with-env-editor` et respecte l'utilisation des variables `SUDO_EDITOR`, `VISUAL` et `EDITOR`. `EDITOR` n'est pas utilisée lorsque `VISUAL` est définie.

Pour établir nano comme éditeur de visudo pour la durée de la session actuelle du shell, exportez `EDITOR=nano` ; pour utiliser un éditeur différent une seule fois, il suffit de définir la variable avant d'appeler visudo :

    # EDITOR=nano visudo

Vous pouvez également éditer une copie du fichier `/etc/sudoers` et la vérifier en utilisant `visudo -c /copy/of/sudoers`. Cela peut s'avérer pratique si vous voulez contourner le verrouillage du fichier avec visudo.

Pour changer l'éditeur de façon permanente, consultez Environment variables#Per user. Pour changer l'éditeur de choix de façon permanente dans tout le système et seulement pour visudo, ajoutez ce qui suit à `/etc/sudoers` (en supposant que nano est votre éditeur préféré) :

    # Réinitialiser l'environnement par défaut
    Defaults      env_reset
    # Définir l'ÉDITEUR par défaut à la version restreinte de nano, et ne pas autoriser visudo à utiliser EDITOR/VISUAL.
    Defaults      editor=/usr/bin/rnano, !env_editor

### Exemples d'entrées

Pour permettre à un utilisateur d'obtenir tous les privilèges de root lorsqu'il fait précéder une commande de `sudo`, ajoutez la ligne suivante :

    USER_NAME   ALL=(ALL:ALL) ALL

Pour permettre à un utilisateur d'exécuter toutes les commandes comme n'importe quel utilisateur mais uniquement sur la machine dont le nom d'hôte est `HOST_NAME` :

    USER_NAME   HOST_NAME=(ALL:ALL) ALL

Pour permettre aux membres du groupe wheel d'accéder à sudo :

    %wheel ALL=(ALL:ALL) ALL

Astuce Lors de la création de nouveaux administrateurs, il est souvent souhaitable d'activer l'accès sudo pour le groupe `wheel` et ajouter l'utilisateur à ce groupe, car par défaut Polkit traite les membres du groupe `wheel` comme des administrateurs. Si l'utilisateur n'est pas membre du groupe `wheel`, les logiciels utilisant Polkit peuvent demander à s'authentifier en utilisant le mot de passe root au lieu du mot de passe utilisateur.

Pour désactiver la demande de mot de passe pour l'utilisateur `USER_NAME` :

Attention Cela permettra à tout processus s'exécutant sous votre nom d'utilisateur d'utiliser sudo sans demander la permission.

    Defaults:USER_NAME      !authenticate

Active les commandes explicitement définies uniquement pour l'utilisateur `USER_NAME` sur l'hôte `HOST_NAME` :

    USER_NAME HOST_NAME=/usr/bin/halt,/usr/bin/poweroff,/usr/bin/reboot,/usr/bin/pacman -Syu

Note L'option la plus personnalisée doit être placée à la fin du fichier, car les lignes suivantes remplacent les précédentes. En particulier, cette ligne doit se trouver après la ligne `%wheel` si votre utilisateur fait partie de ce groupe.

Activer les commandes explicitement définies uniquement pour l'utilisateur `USER_NAME` sur l'hôte `HOST_NAME` sans mot de passe :

    USER_NAME HOST_NAME= NOPASSWD: /usr/bin/halt,/usr/bin/poweroff,/usr/bin/reboot,/usr/bin/pacman -Syu

Un exemple détaillé de `sudoers` est disponible à `/usr/share/doc/sudo/examples/sudoers`. Sinon, consultez le sudoers(5) pour des informations détaillées.

### Permissions par défaut des fichiers Sudoers

Le propriétaire et le groupe du fichier `sudoers` doivent tous deux être 0. Les permissions du fichier doivent être définies sur 0440. Ces permissions sont définies par défaut, mais si vous les modifiez accidentellement, vous devez les rétablir immédiatement, sinon sudo échouera.

    # chown -c root:root /etc/sudoers
    # chmod -c 0440 /etc/sudoers

## Trucs et astuces

### Désactiver la temporisation de l'invite de mot de passe

Un ennui courant est un processus de longue durée qui s'exécute sur un terminal en arrière-plan quelque part, qui fonctionne avec des permissions normales et ne s'élève que si nécessaire. Cela conduit à une demande de mot de passe sudo qui passe inaperçue et se termine, à ce moment-là le processus meurt et le travail effectué est perdu ou, au mieux, mis en cache. Les conseils les plus courants sont d'activer sudo sans mot de passe ou d'allonger le délai de mémorisation d'un mot de passe par sudo. Ces deux solutions ont des conséquences négatives sur la sécurité. Le délai d'attente de l'"invite" peut également être désactivé et puisque cela ne sert aucun objectif de sécurité raisonnable, ce devrait être la solution ici :

    Defaults passwd_timeout=0

### Ajouter une cloche de terminal à l'invite de mot de passe

Pour attirer l'attention sur une invite sudo dans un terminal en arrière-plan, les utilisateurs peuvent simplement lui faire renvoyer un caractère «cloche» :

    Defaults passprompt="^G[sudo] password for %p: "

Notez que le `^G` est un caractère de cloche littéral. Par exemple, dans vim, insérer en utilisant la séquence `Ctrl+v` `Ctrl+g`, ou dans nano, `Alt+v` `Ctrl+g`.

### Passer des alias

Les alias dans Zsh et Bash ne sont normalement développés que pour le premier mot d'une commande. Cela signifie que vos alias ne seront normalement pas développés lors de l'exécution de la commande `sudo`. Une façon de faire en sorte que le mot suivant soit développé est de créer un alias pour sudo se terminant par un espace. Ajoutez ce qui suit à votre fichier de configuration du shell :

    alias sudo='sudo '

zshmisc(1) § ALIASING décrit comment cela fonctionne :

  Si le texte de remplacement se termine par un espace, le mot suivant dans l'entrée du shell est toujours éligible pour les expansions d'alias.

De même que bash(1) § ALIASES :

  Si le dernier caractère de la valeur de l'alias est un espace, alors le mot de commande suivant l'alias est également vérifié pour l'expansion d'alias.

### Désactiver un sudo par terminal

Attention Cela laissera n'importe quel processus utiliser votre session sudo.

Si vous êtes gêné par les valeurs par défaut de sudo qui vous obligent à entrer votre mot de passe chaque fois que vous ouvrez un nouveau terminal, définissez `timestamp_type` à `global` :

    Defaults timestamp_type=global

### Réduire le nombre de fois où vous devez taper un mot de passe

Si vous êtes agacé par le fait de devoir saisir à nouveau votre mot de passe toutes les 5 minutes (valeur par défaut), vous pouvez changer cela en définissant une valeur plus longue pour `timestamp_timeout` (en minutes) :

    Defaults timestamp_timeout=10

Si vous utilisez beaucoup de commandes sudo à la suite, il est plus logique de rafraîchir le délai d'attente à chaque fois que vous utilisez sudo que de d'augmenter `timestamp_timeout`. Le rafraîchissement du délai d'attente peut être effectué avec `sudo -v`. (alors que `sudo -K` révoque immédiatement).

Vous pouvez automatiser cette opération en ajoutant ce qui suit à votre `.bashrc` :

    alias sudo='sudo -v ; sudo '

Il est également possible d'utiliser une fonction bash ; pour plus de détails, consultez stackexchange.

### Variables d'environnement

Si vous avez beaucoup de variables d'environnement, ou si vous exportez vos paramètres de proxy via `export http_proxy="..."`, lorsque vous utilisez sudo, ces variables ne sont pas transmises au compte root, sauf si vous exécutez sudo avec l'option `-E`.

    $ sudo -E pacman -Syu

La méthode recommandée pour préserver les variables d'environnement est de les ajouter à `env_keep` :

    /etc/sudoers

    Défauts env_keep += "ftp_proxy http_proxy https_proxy no_proxy"

### Mot de passe root

Les utilisateurs peuvent configurer sudo de manière à ce qu'il demande le mot de passe root au lieu du mot de passe utilisateur en ajoutant `targetpw` (utilisateur cible, par défaut root) ou `rootpw` à la ligne Defaults de `/etc/sudoers` :

    Defaults targetpw

Pour éviter d'exposer votre mot de passe root aux utilisateurs, vous pouvez le restreindre à un groupe spécifique :

    Defaults:%wheel targetpw
    %wheel ALL=(ALL) ALL

### Désactiver la connexion root

Les utilisateurs peuvent souhaiter désactiver la connexion root. Sans root, les attaquants doivent d'abord deviner un nom d'utilisateur configuré comme sudoer ainsi que le mot de passe de l'utilisateur. Consultez par exemple OpenSSH#Deny.

Attention

- Prenez garde, vous pouvez vous bloquer en désactivant la connexion root. Sudo n'est pas automatiquement installé et sa configuration par défaut ne permet ni l'accès root sans mot de passe ni l'accès root avec votre propre mot de passe. Assurez-vous qu'un utilisateur est correctement configuré comme sudoer avant de désactiver le compte root !
- Si vous avez modifié votre fichier sudoers pour utiliser rootpw par défaut, alors ne désactivez pas l'accès root avec l'une des commandes suivantes !
- Si vous êtes déjà coincé, consultez Password recovery pour obtenir de l'aide.

Le compte peut être verrouillé via `passwd` :

    # passwd -l root

Une commande similaire permet de déverrouiller root.

    $ sudo passwd -u root

Vous pouvez également éditer `/etc/shadow` et remplacer le mot de passe chiffré de root par "!":

    root:!:12345::::: :

Pour réactiver la connexion de root :

    $ sudo passwd root

Astuce Pour obtenir une invite interactive pour root, même après avoir désactivé le compte root, utilisez `sudo -i`.

#### kdesu

kdesu peut être utilisé sous KDE pour lancer des applications GUI avec les privilèges de root. Il est possible que par défaut, kdesu essaie d'utiliser su même si le compte root est désactivé. Heureusement, on peut dire à kdesu d'utiliser sudo au lieu de su. Créez/éditez le fichier `~/.config/kdesurc` :

    [super-user-command]
    super-user-command=sudo

ou utilisez la commande suivante :

    $ kwriteconfig5 --file kdesurc --group super-user-command --key super-user-command sudo

### Exemple de durcissement avec sudo

Disons que vous créez 3 utilisateurs : admin, devel, et joe. L'utilisateur "admin" est utilisé pour journalctl, systemctl, mount, kill et iptables ; "devel" est utilisé pour installer des paquets et éditer des fichiers de configuration ; et "joe" est l'utilisateur avec lequel vous vous connectez. Pour permettre à "joe" de redémarrer, d'arrêter et d'utiliser netctl, nous ferions ce qui suit :

Éditez `/etc/pam.d/su` et `/etc/pam.d/su-l`. Demandez à l'utilisateur d'être dans le groupe wheel, mais n'y mettez personne.

    #%PAM-1.0
    auth            sufficient      pam_rootok.so
    # Uncomment the following line to implicitly trust users in the "wheel" group.
    #auth           sufficient      pam_wheel.so trust use_uid
    # Uncomment the following line to require a user to be in the "wheel" group.
    auth            required        pam_wheel.so use_uid
    auth            required        pam_unix.so
    account         required        pam_unix.so
    session         required        pam_unix.so

Limite la connexion SSH au groupe 'ssh'. Seul "joe" fera partie de ce groupe.

    # groupadd -r ssh
    # gpasswd -a joe ssh
    # echo 'AllowGroups ssh' >> /etc/ssh/sshd_config

Redémarrez `sshd.service`.

Ajouter des utilisateurs à d'autres groupes.

    # for g in réseau puissance ;do ;gpasswd -a joe $g ;done
    # for g in network power storage ;do ;gpasswd -a admin $g ;done

Définissez les permissions sur les configs pour que devel puisse les modifier.

    # chown -R devel:root /etc/{http,openvpn,cups,zsh,vim,screenrc}

    Cmnd_Alias  POWER       =   /usr/bin/shutdown -h now, /usr/bin/halt, /usr/bin/poweroff, /usr/bin/reboot
    Cmnd_Alias  STORAGE     =   /usr/bin/mount -o nosuid\,nodev\,noexec, /usr/bin/umount
    Cmnd_Alias  SYSTEMD     =   /usr/bin/journalctl, /usr/bin/systemctl
    Cmnd_Alias  KILL        =   /usr/bin/kill, /usr/bin/killall
    Cmnd_Alias  PKGMAN      =   /usr/bin/pacman
    Cmnd_Alias  NETWORK     =   /usr/bin/netctl
    Cmnd_Alias  FIREWALL    =   /usr/bin/iptables, /usr/bin/ip6tables
    Cmnd_Alias  SHELL       =   /usr/bin/zsh, /usr/bin/bash
    %power      ALL         =   (root)  NOPASSWD: POWER
    %network    ALL         =   (root)  NETWORK
    %storage    ALL         =   (root)  STORAGE
    root        ALL         =   (ALL)   ALL
    admin       ALL         =   (root)  SYSTEMD, KILL, FIREWALL
    devel	    ALL         =   (root)  PKGMAN
    joe	    ALL         =   (devel) SHELL, (admin) SHELL

Avec cette configuration, vous n'aurez presque jamais besoin de vous connecter en tant qu'utilisateur root.

"joe" peut se connecter au WiFi de sa maison.

    $ sudo netctl start home
    $ sudo poweroff

"joe" ne peut pas utiliser netctl comme un autre utilisateur.

    $ sudo -u admin -- netctl start home

Lorsque "Joe" a besoin d'utiliser journalctl ou de tuer un processus en cours, il peut passer à cet utilisateur.

    $ sudo -i -u devel
    $ sudo -i -u admin

Mais "joe" ne peut pas passer à l'utilisateur root.

    $ sudo -i -u root

Si "Joe" veut démarrer une session gnu-screen en tant qu'administrateur, il peut le faire comme suit :

    $ sudo -i -u admin
    [admin]$ chown admin:tty `echo $TTY`
    [admin]$ screen

### Configurer sudo en utilisant les fichiers de dépôt dans /etc/sudoers.d

sudo analyse les fichiers contenus dans le répertoire `/etc/sudoers.d/`. Cela signifie qu'au lieu de modifier `/etc/sudoers`, vous pouvez changer les paramètres dans des fichiers autonomes et les déposer dans ce répertoire. Cela présente deux avantages :

- Il n'est pas nécessaire d'éditer un fichier `sudoers.pacnew` ;
- S'il y a un problème avec une nouvelle entrée, vous pouvez supprimer le fichier en question au lieu de modifier `/etc/sudoers` (mais consultez l'avertissement ci-dessous).

Le format des entrées dans ces fichiers de dépôt est le même que pour `/etc/sudoers` lui-même. Pour les modifier directement, utilisez `visudo -f /etc/sudoers.d/somefile`. Consultez sudoers(5) § Inclure d'autres fichiers dans sudoers pour plus de détails.

Les fichiers du répertoire `/etc/sudoers.d/` sont analysés par ordre lexicographique, les noms de fichiers contenant `.` ou `~` sont ignorés. Pour éviter les problèmes de tri, les noms de fichiers doivent commencer par deux chiffres, par exemple `01_foo`.

Note L'ordre des entrées dans les fichiers de dépôt est important : veillez à ce que les déclarations ne s'écrasent pas entre elles.
Attention Les fichiers de `/etc/sudoers.d/` sont tout aussi fragiles que `/etc/sudoers` lui-même : tout fichier mal formaté empêchera `sudo` de fonctionner. Ainsi, pour la même raison, il est fortement conseillé d'utiliser `visudo`

### Édition de fichiers

`sudo -e` ou `sudoedit` vous permet de modifier un fichier en tant qu'autre utilisateur tout en exécutant l'éditeur de texte en tant que votre utilisateur.

Ceci est particulièrement utile pour éditer des fichiers en tant que root sans élever les privilèges de votre éditeur de texte, pour plus de détails lisez sudo(8) § e.

Notez que vous pouvez définir l'éditeur sur n'importe quel programme, donc par exemple on peut utiliser meld pour gérer les fichiers pacnew :

    $ SUDO_EDITOR=meld sudo -e /etc/fichier{,.pacnew}

### Activer les insultes

Les utilisateurs peuvent activer l’œuf de Pâques des insultes dans sudo en ajoutant la ligne suivante dans le fichier `sudoers` avec `visudo`.

    /etc/sudoers

    Defaults insults

Lors de la saisie d'un mot de passe incorrect, ceci remplacera le message `Sorry, try again.` par des insultes humoristiques.

## Dépannage

### Problème de SSH sans TTY

SSH n'alloue pas de tty par défaut lors de l'exécution d'une commande distante. Sans un tty alloué, sudo ne peut pas empêcher l'affichage du mot de passe. Vous pouvez utiliser l'option `-t` de ssh pour le forcer à allouer un tty.

L'option `Defaults requiretty` ne permet à l'utilisateur d'exécuter sudo que s'il dispose d'un tty.

    # Désactivez "ssh hostname sudo <cmd>", car il affichera le mot de passe en clair. Vous devez exécuter "ssh -t hostname sudo <cmd>".
    #
    #Defaults requiretty

### Permissive umask

Sudo fusionnera la valeur umask de l'utilisateur avec son propre umask (qui a la valeur 0022 par défaut). Cela empêche sudo de créer des fichiers avec des permissions plus ouvertes que celles autorisées par l'umask de l'utilisateur. Bien qu'il s'agisse d'une valeur par défaut saine si aucun umask personnalisé n'est utilisé, cela peut conduire à des situations où un utilitaire exécuté par sudo peut créer des fichiers avec des permissions différentes de celles de l'utilisateur root. Si des erreurs surviennent, sudo fournit un moyen de corriger l'umask, même si l'umask souhaité est plus permissif que celui que l'utilisateur a spécifié. L'ajout de cette option (en utilisant `visudo`) annulera le comportement par défaut de sudo :

    Defaults umask = 0022
    Defaults umask_override

Ceci définit l'umask de sudo sur l'umask par défaut de root (0022) et annule le comportement par défaut, en utilisant toujours l'umask indiqué, quel que soit l'umask défini par l'utilisateur.

Categories:

- Security (Français)
- Commands (Français)

Sudo (Français)
Add topic