web-dev-qa-db-fra.com

Autoriser les utilisateurs à changer la propriété d'un fichier spécifique sans sudo

Disons que nous avons cette situation:

-rwxrwx-r- 1 user1 mygroup  0 Sep 12 16:53 testfile

Un groupe de développeurs travaillent sur le même VM (Linux). Je dois simuler le concept de checkout/checkin. Si un utilisateur extrait un fichier, personne ne devrait pouvoir l'écrire avant de l'avoir archivé.

J'ai essayé de changer de propriétaire de fichier; chaque fois qu'un utilisateur souhaite passer à la caisse, il devient le propriétaire du fichier et empêche les autres utilisateurs de l'écrire, puis se connecte en modifiant le propriétaire du fichier par défaut et en rétablissant les autorisations par défaut du fichier. Cela signifie que j'aurai besoin de chown et de chmod, mais ces commandes requièrent de Sudo et je ne peux pas donner le droit Sudo aux développeurs.

Puis-je donner à un utilisateur la possibilité de chown et chmod uniquement un fichier spécifique?

permissionssudochown
4
ILY

Vous devrez écrire un script qui vérifie les conditions, puis donner à vos utilisateurs Sudo l'accès à that script seul. Quelque chose comme:

#! /bin/bash
set -e
die()
{
    printf "%s\n" "$@"
    exit 1
}

if [[ $EUID != 0 ]]
then
    die "This script must be run with Sudo."
fi

DEFAULT_USER=nobody
SOURCE_DIR=/some/dir

cd "$SOURCE_DIR"

# Get path of file relative to the source directory
# Then we can check if it is actually in the directory.
FILE=$(realpath -e --relative-base="$SOURCE_DIR" "${1?}")    
if [[ $FILE == /* ]]
then
    die "$1 is outside $SOURCE_DIR."
fi

FILE_OWNER=$(stat -c %U "$FILE")

case $FILE_OWNER in
    $DEFAULT_USER)
        # checkout
        echo "Checking out $FILE..."
        chown "$Sudo_USER" "$FILE"
        ;;
    $Sudo_USER)
        # checkin
        echo "Checking in $FILE..."
        chown nobody "$FILE"
        ;;
    *)
        die "Sorry, this file is checked out by $FILE_OWNER."
        ;;
esac

Enregistrez-le sous, par exemple, /usr/local/bin/check, ajoutez la règle sudoers suivante:

%dev ALL = (root) /usr/local/bin/check

C'est en supposant que:

  • Les développeurs appartiennent tous au groupe dev (sinon, utilisez les noms d'utilisateur ou les groupes en conséquence).
  • Les fichiers sont en /some/dir. Modifiez $SOURCE_DIR en conséquence.
  • L'utilisateur par défaut est nobody et les fichiers non vérifiés appartiennent à l'utilisateur par défaut.
  • Personne n'a les autorisations d'écriture sur le répertoire source sauf root.

Ensuite, les développeurs peuvent faire:

Sudo check some/file

pour extraire /some/dir/some/file, puis exécutez-le à nouveau pour l'archiver.

6
muru

Vous pouvez le faire, bien que je pense qu’il existe probablement une solution plus pratique conçue pour ce type de collaboration.

Quoi qu'il en soit, voici ce qu'il faut faire:

Créez un groupe, ajoutez les utilisateurs au groupe et donnez au groupe le droit d'écriture sur le répertoire parent. Ils pourront alors chown et chmod le fichier sans utiliser Sudo

Manifestation:

Sudo addgroup devs
Sudo adduser zanna devs
Sudo adduser pixie devs
mkdir development
chmod g+w development 
Sudo chown root:devs development 
touch development/testfile
cd development
Sudo chown root:devs testfile

C'est la configuration faite. Testons le:

zanna@xubi:~/development$ chown $USER testfile
$ stat -C "%U %G" testfile
zanna devs
$ chmod 600 testfile
$ stat -c %a testfile
600
$ su pixie
[enter password...]
pixie@xubi:/home/zanna/development$ chown $USER testfile
$ stat -c %U testfile
pixie

et ainsi de suite ... mais cela ne fonctionnera du tout que si les personnes vérifient les autorisations ou tentent d'écrire dans le fichier avant de commencer à exécuter chown et chmod, ce qui n'est probablement pas intuitif ... Et si elles ont l'autorisation d'écriture sur le parent répertoire, ils seront toujours en mesure de forcer l’écriture dans le fichier, mais ils devraient recevoir un avertissement, selon l’éditeur qu’ils utilisent.

6
Zanna

Si un utilisateur a la possibilité d'exécuter la commande Sudosuivante:

Sudo bash

Il sera en mesure d'exécuter n'importe quelle commande en tant que root, y compris chownsur n'importe quel fichier.

Vous pouvez configurer /etc/sudoers pour permettre à un utilisateur spécifique d’exécuter des commandes spécifiques.

par exemple. vous pouvez définir la ligne suivante dans /etc/sudoers:

user2 ALL=(ALL) NOPASSWD: /bin/chown
user2 ALL=(ALL) NOPASSWD: /bin/chmod

Remarque: si quelqu'un a la capacité d'exécuter chownet chmoden tant que rootname__, il peut facilement obtenir un accès complet à root(par exemple, en éditant /etc/passwd)

3
Yaron

Je conviens qu’un sccs (système de contrôle de code source), y compris celui qui date du début des années 70, pourrait constituer une bonne solution pour archiver des fichiers partagés, car il conserve le contrôle de version ainsi que la documentation relative aux modifications.

En tant que complément à la proposition de Zanna, un court script vérifie si l'utilisateur est le propriétaire, puis, si ce n'est pas le cas, vérifie si le groupe dispose du droit d'écriture. Cela signifierait qu'il a été archivé. Si disponible, il serait chown puis changerait les permissions en 600 (le fichier est occupé). Pour le libérer, il ramènerait les autorisations à 660. Ainsi, le nom du propriétaire indiquerait qui l'a verrouillé ou qui l'a verrouillé pour la dernière fois, et l'autorisation de groupe, si elle était disponible ou encore en cours d'utilisation.

2
jpezz