# 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

<u>Reduire le temps de grâce:</u>

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