# Excecuter une application en root ### A) Sudo Avec sudo, on prend les droits root pour exécuter une commande. ```bash $ sudo opkg update ``` Le mot de passe est mémorisé pendant x minutes, pendant les lesquelles pour les commandes lancées avec sudo, le mot-de-passe n'est pas demandé. On peut "oublier" le mot de passe mémorisé. ```bash $ sudo -k ``` On peut ouvrir une "session root" avec sudo. ```bash $ sudo -i ``` Avec **sudo -i**, le mot de passe **utilisateur** est demandé. Avec **su -**, le mot de passe **root** est demandé. Obtenir la listes des commandes dispos: ```bash $ sudo -l Password: Matching Defaults entries for bruno on DS916: syslog=authpriv User bruno may run the following commands on DS916: (ALL) ALL ``` ### B) sudoers Plutot que d'éditer `sudoers`, on peut créer des fichiers de personnalisation dans `/etc/sudoer.d/` ```bash /etc/sudoers.d$ ls -la total 28 drwxr-xr-x 2 root root 4096 sept. 11 20:02 . drwxr-xr-x 144 root root 12288 sept. 11 19:52 .. -r--r----- 1 root root 180 mars 22 2017 mintupdate -r--r----- 1 root root 958 janv. 18 2018 README -r--r----- 1 root root 51 août 26 10:20 vagrant ``` `chmod 440` sur ces fichier. #### options Reduire le temps de grâce: Ajouter `timestamp_timeout=X` à la ligne `Defaults` ```bash Defaults env_reset,timestamp_timeout=X ``` #### Cmnd alias Il faut éditer `/etc/sudoers` avec visudo: ```bash $ sudo visudo -s ``` ou avec nano: ```bash $ sudo nano /etc/sudoers ``` ```bash # /etc/sudoers # # This file MUST be edited with the 'visudo' command as root. # # See the man page for details on how to write a sudoers file. # Host alias specification # User alias specification # Cmnd alias specification Cmnd_Alias NETWORK=/sbin/ifconfig, /sbin/iwconfig, /sbin/dhclient # Defaults Defaults !lecture,tty_tickets,!fqdn,insults # User privilege specification root ALL=(ALL) ALL # Members of the admin group may gain root privileges %admin ALL=(ALL) ALL, NOPASSWD:NETWORK ``` root a tous les droits. le groupe (%) admin peut lancer `ifconfig` avec un sudo mais SANS mot-de-passe, et tout le reste avec sudo Et mot-de-passe. ```bash $ sudo ifconfig ``` username n'a le droit d'exécuter sudo que pour le seul script.sh (et sans mot-de-passe) ``` username ALL=NOPASSWD: /mon/script.sh ``` ```bash $ sudo /mon/script.sh ``` autres exemples: ```bash nano vagrant ``` ```bash # add vagrant user vagrant ALL=(ALL) NOPASSWD:ALL ``` ```bash nano mintupdate ``` ```bash # Allow any user to check for new system updates without # requiring user autentification Cmnd_Alias UPDATE = /usr/lib/linuxmint/mintUpdate/checkAPT.py ALL ALL = NOPASSWD:UPDATE ``` [https://doc.ubuntu-fr.org/sudoers](https://doc.ubuntu-fr.org/sudoers) ### C) Setuid ### suid Lorsque l’on place un suid sur un fichier, n’importe quel utilisateur peut l’exécuter en héritant des permissions du propriétaire, comme s’il était lui-même le propriétaire. Exemple: quand un fichier exécutable est propriété de l'[utilisateur root](https://fr.wikipedia.org/wiki/Utilisateur_root), et est rendu *setuid*, tout processus exécutant ce fichier peut effectuer ses tâches avec les permissions associées à root Le *suid* ne s’active que sur des fichiers. La valeur de *suid* est 4 sur le chiffre octal de poids fort, son flag est s ou S (s si le droit d'exécution est présent, S sinon). Pour activer le *suid* : ```bash $ chmod u+s fichier $ chmod 4755 fichier ``` Pour supprimer le *suid*: ```bash $ sudo chmod u-s fichier $ chmod 0755 fichier ``` ```bash $ ls -la -rwxr-xr-x 1 bruno users 2264 Sep 11 17:02 _npm.sh # on met le suid (exécutable + suid -> s) $ chmod u+s _npm.sh $ ls -la -rwsr-xr-x 1 bruno users 2264 Sep 11 17:02 _npm.sh # on retire le suid $ chmod u-s _npm.sh $ ls -la -rwxr-xr-x 1 bruno users 2264 Sep 11 17:02 _npm.sh # le script n'est pas exécutable $ chmod 644 _npm.sh $ ls -la $ -rw-r--r-- 1 bruno users 2264 Sep 11 17:02 _npm.sh #on met le suid (non exécutable + suid -> S) $ chmod u+s _npm.sh $ ls -la -rwSr--r-- 1 bruno users 2264 Sep 11 17:02 _npm.sh ``` ~~Un script ne peut pas être set-uid.~~ ~~c'est pas au niveau du script mais du binaire appelé qu'il faut le faire~~ Rendre root possesseur du script. ```bash $ chown root:root /path/to/root-script.sh` ``` #### sgid **Sur un fichier**: ce droit fonctionne comme le droit *suid*, mais appliqué aux groupes. Il donne à un utilisateur les droits du groupe auquel appartient le propriétaire de l’exécutable et non plus les droits du propriétaire. La valeur de *sgid* est 2 sur le chiffre octal de poids fort, son flag est s ou S (s si le droit d'exécution est présent, S sinon). Pour activer le *sgid*: ```bash $ chmod g+s fichier $ chmod 2755 fichier ``` Pour activer le *suid* et le *sgid*: ```bash $ chmod ug+s fichier # le poids fort vaut 6 (4+2) $ chmod 6755 fichier ``` Pour supprimer le *sgid*: ```bash $ chmod u-s fichier $ chmod 0755 fichier ``` **Sur un répertoire**: ce droit a une tout autre utilisation s’il est appliqué à un répertoire. Normalement, lorsqu’un fichier est créé par un utilisateur, il en est propriétaire, et un groupe par défaut lui est appliqué (généralement *users* si le fichier a été créé par un utilisateur, et *root* ou *wheel* s’il a été créé par *root*). Cependant, lorsqu’un fichier est créé dans un répertoire portant le droit SGID, alors ce fichier se verra attribuer par défaut le groupe du répertoire. De plus, si c’est un autre répertoire qui est créé dans le répertoire portant le droit *sgid*, ce sous-répertoire portera également ce droit. En revanche, si des sous-répertoires existent déjà au moment de l'ajout du *Setgid*, ils ne sont pas affectés par celui-ci. ```bash $ chmod g+s repertoire $ chmod 2755 repertoire ``` #### sticky bit Le droit d’écriture signifie que l’on peut créer et supprimer les fichiers de ce répertoire. Le sticky bit permet de faire la différence entre les deux droits. **Sur un fichier,** Gnu/Linux n’en tient pas compte contrairement aux vieux systèmes Unix. Ainsi le sticky bit activé indique à l’OS que le fichier sera utilisé fréquemment et sera ainsi stocké dans un fichier d’échange pour avoir la main dessus rapidement. La valeur du *sticky bit* est 1 sur le chiffre octal de poids fort, son flag est t ou T. ```bash $ sudo chmod +t fichier* $chmod 1750 /path/to/root-script.sh ``` **Sur un répertoire** le sticky bit aura pour effet d’interdire à quiconque n’étant pas le propriétaire du fichier sa suppression. Cependant, il sera toujours possible de modifier le fichier d’un autre si l’on possède les droits nécessaires. La création de nouveaux fichiers est toujours possible pour tous les utilisateurs possédant le droit d'écriture sur ce répertoire ```bash $ sudo chmod +t repertoire* ``` Sur certains systèmes UNIX, le sticky bit est utilisé pour le répertoire /tmp ### D) gksu & gksudo Ce sont simplement des front-end graphiques pour *su* et *sudo*.