Files
mkdocs/docs/Linux/executer.md
Bruno 21 e82296ba06 1er commit
De la docs au format Mkdocs
2018-09-16 14:48:15 +02:00

308 lines
7.0 KiB
Markdown
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# 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 lon place un suid sur un fichier, nimporte quel utilisateur peut lexécuter en héritant des permissions du propriétaire, comme sil é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 sactive 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 lexé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 sil est appliqué à un répertoire.
Normalement, lorsquun 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* sil a été créé par *root*).
Cependant, lorsquun 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 cest 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 lon 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 nen tient pas compte contrairement aux vieux systèmes Unix. Ainsi le sticky bit activé indique à lOS 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 dinterdire à quiconque nétant pas le propriétaire du fichier sa suppression. Cependant, il sera toujours possible de modifier le fichier dun autre si lon 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*.