Exclure l'utilisateur de l'utilisation des programmes installés dans l'ensemble du système

Vous trouverez ci-dessous une combinaison de mesures que vous pouvez prendre pour restreindre les utilisateurs. localement d'utiliser des applications définies. Ils ne sont pas conçus (ni adaptés) pour une utilisation sans surveillance, dans les espaces publics par exemple, mais ils créent un bureau restreint utilisable. C'est principalement le combinaison de mesures qui le rendent plus difficile à contourner. En outre, si quelqu'un parvient à lancer une application "interdite", elle sera enregistrée.

La réponse est un peu longue. La configuration ne l'est pas, et vous êtes aidé par deux scripts.

Ce qui existe dans la configuration

• Une sélection de logiciels, rendus indisponibles depuis l'interface en modifiant leur fichier de bureau local par un script (plus loin).
• Rendre le terminal uniquement accessible par mot de passe, ce qui rend plus difficile l'exécution d'applications à partir du terminal.
• Changement de la combinaison de touches par défaut pour ouvrir le terminal, au lieu de ctrlaltt
• Enregistrement de l'utilisation d'une "liste noire" de logiciels que vous définissez, au cas où un utilisateur malin dépasserait votre configuration.

Comment configurer

Mise en place d'une large sélection de logiciels, non disponibles à partir de l'interface.

• Connectez-vous au compte de l'utilisateur que vous voulez restreindre
• Créez un dossier (temporaire) (peu importe l'endroit, sur le bureau par exemple) pour éditer quelques fichiers fichiers.
• Naviguez dans le répertoire /usr/share/applications Sélectionnez toutes les applications (fichiers de bureau) dont vous voulez exclure l'utilisateur (ne sélectionnez pas toutes les applications sans regarder, certaines sont nécessaires pour configurer votre bureau).
• Copiez ces fichiers de bureau dans le répertoire temporaire que vous avez créé, pour une édition en masse.
• Copier le texte ci-dessous, le coller dans un fichier vide, l'enregistrer dans le même dossier temporaire que no_openapp.py .
• CD dans le répertoire ( !) et exécutez-le avec la commande : python3 no_openapp.py .

Le script a fait plusieurs choses :

1] Créer une liste noire de commandes (pour une utilisation ultérieure, voir plus loin) 2] Modifier les fichiers du bureau pour afficher un message au lieu de lancer l'application. Si vous déplacez les fichiers du bureau vers ~/.local/share/applications Lors de la prochaine connexion, les applications ne fonctionneront pas à partir de Unity ou de Dash.

#!/usr/bin/python3

import os
import getpass
import subprocess

desktopfile_dir = os.getcwd()
file_list = os.listdir(os.getcwd())
edit_subjects = [desktopfile_dir+"/"+item for item in file_list]

def create_blacklist():
    command_list = []
    for item in edit_subjects:
        with open(item) as blacklist_source:
            searchlines = blacklist_source.readlines()
        try:
            native_command = [
                line for line in searchlines if line.startswith("Exec=")
                ][0].replace("Exec=", "").replace("\n", "")
            cleaned_command = native_command.split(" ")[0]
            command_list.append(cleaned_command)
        except IndexError:
            pass

    with open(desktopfile_dir+"/blacklist.txt", "wt") as created_blacklist:
        created_blacklist.write(str(command_list))

def make_unavailable():
    for item in edit_subjects:
        try:
            with open(item, "r") as make_unav:
                lines = make_unav.readlines()
                line_range = range(0, len(lines))
                for index in line_range:
                    if lines[index].startswith("Exec="):
                        lines[index] = 'Exec=zenity --info --text="You are not allowed to use this application"\n'
                    else:
                        pass
            with open(item, "wt") as make_unav:
                for line in lines:
                    make_unav.write(line)
        except (IsADirectoryError, IndexError, PermissionError):
            pass

create_blacklist()
make_unavailable()

Restreindre l'utilisation du terminal

• rendre le terminal accessible avec un mot de passe, comme dans ce poste .

• si l'utilisateur est familier avec la combinaison de touches de ctrlaltt pour modifier la combinaison par défaut :

  Système>Préférences>Raccourcis clavier > combinaisons de touches (onglet).

Si un jeune homme contourne vos mesures, attrapez-le.

• Si un utilisateur parvient à faire fonctionner une application interdite, assurez-vous de l'attraper. Pour cela, nous utilisons la liste noire, créée à l'étape 1.
• créer un dossier sur un emplacement caché. Copiez le fichier "blacklist.txt", créé à l'étape 1, dans le répertoire.
• copier le texte ci-dessous, le coller dans un fichier texte vide et le sauvegarder dans le même répertoire que la liste noire, sous la forme suivante processes.py .

• ouvrez une fenêtre de terminal, tapez crontab -e . ajoutez la ligne suivante au fichier crontab :

  * * * * * cd /path/to/script; python3 processes.py

La liste noire est une liste de noms de processus. Le script vérifie toutes les minutes si l'une des applications de la liste noire est en cours d'exécution, et en garde trace dans un fichier journal (dans le même répertoire que celui où se trouve le script). Le nom du fichier journal est log.txt. En option, vous pouvez faire en sorte que le script tue l'application interdite (pas par défaut). Pour qu'il tue l'application ou les applications, modifiez la ligne suivante kill_apps = "no" en kill_apps = "yes" (dans l'en-tête du script).

#!/usr/bin/python3

import os
import datetime
import subprocess
import getpass

curr_dir = os.getcwd()
curruser = getpass.getuser()

# should forbidden applications be killed?
kill_apps = "yes"

def produce_commands_ofapp():
    with open(curr_dir+"/blacklist.txt", "r") as blacklist:
        blacklist = eval(blacklist.read())
    return blacklist

def createlist_runningprocs():
    processesb = subprocess.Popen(["ps", "-u", curruser], stdout=subprocess.PIPE)
    process_listb = (processesb.communicate()[0].decode("utf-8")).split("\n")
    return process_listb

def runsornot():
    check_blacklist = produce_commands_ofapp()
    runningprocs_list = createlist_runningprocs()
    found_matches = [item for item in check_blacklist
                       if item[:15] in str(runningprocs_list)]
    if len(found_matches) != 0:
        with open(curr_dir+"/log.txt", "a+") as logfile:
            logfile.write(str(found_matches)+" "+str(datetime.datetime.now())+"\n")
    else:
        pass
    if kill_apps == "yes":
        for application in found_matches:
            kill_forbidden(application)
    else:
        pass

def kill_forbidden(app_command):
    # get the pid length of system
    get_size = subprocess.Popen(
        ["cat", "/proc/sys/kernel/pid_max"],
        stdout=subprocess.PIPE
        )
    size = len((get_size.communicate()[0].decode("utf-8")).replace("\n", ""))
    # get the appropriate pid line & pid
    process_list = createlist_runningprocs()
    appr_pid = [
        line for line in process_list if \
        app_command[:15] in line][0][:size+1].replace(" ", "")
    # kill the found process
    subprocess.Popen(["kill", "-9", appr_pid])

runsornot()

Comme indiqué, la configuration peut être contournée. Cependant, la combinaison des mesures, et le fait que vous devez savoir ce qu'elles sont, en font une défense raisonnable dans le cas d'un utilisateur moyen ayant une connaissance moyenne de la façon de manipuler le système.

Merci pour vos réponses. J'y suis déjà parvenu en manipulant les permissions des fichiers binaires des programmes. J'ai installé l'ancien outil d'administration des utilisateurs de gnome, qui permet de gérer les groupes. Décoché les jeux de groupe pour l'utilisateur, qui n'est pas autorisé à ouvrir certains programmes. Puis j'ai changé le groupe et les permissions des fichiers binaires :

sudo chgrp games /path/to/game

sudo chmod 750 /path/to/game

Maintenant, l'utilisateur peut voir les fichiers de bureau dans le Dash, mais ils ne s'exécutent pas après un clic.

Salutations

C'est très, très difficile. Je n'ai jamais vu de configuration qui s'en approche et la plupart du temps, lorsque les gens veulent cela, j'ai été en mesure de fournir des solutions bien meilleures parce qu'il n'y avait pas vraiment d'intérêt à restreindre l'utilisateur au départ - ils ne savaient tout simplement pas quelles autres options Ubuntu avait.

Cependant, vous pourriez y parvenir en exécutant toute la session de l'utilisateur dans un conteneur lxc exécutant Xspice, qui n'a simplement pas d'autres applications installées. Ce sera tout un projet, mais si et quand cela fonctionnera, ce sera probablement la meilleure isolation que vous pourrez obtenir. Cette idée est basée sur un article de blog de Serge Hallyn récemment trouvé sur Planet Ubuntu et vous voudrez certainement le lire : http://s3hh.wordpress.com/2014/04/18/xspice-in-containers/

C'est compliqué, c'est basé sur de nouvelles technologies qui ne sont même pas encore disponibles, je ne connais personne qui l'ait réellement essayé pour ce genre d'usage - mais en théorie, ça devrait marcher :)

Je vous recommanderais certainement d'étudier d'autres moyens d'atteindre votre véritable objectif, qui n'est probablement pas d'empêcher l'utilisation des applications, mais quelque chose d'autre.