Jak zablokować otwieranie określonych aplikacji na określonych kontach

Jak zablokować otwieranie niektórych aplikacji na niektórych kontach (np .: Zatrzymaj otwieranie konta John lub Firefox lub Gimp). Zakłada się, że dotyczy to GUI, a nie terminala i dotyczyłoby tylko określonych użytkowników, więc na przykład użytkownik X może otworzyć Gimp, ale nie Firefox, użytkownik Z może otworzyć Centrum oprogramowania, ale nie VirtualBox.

Jaki jest dobry i łatwy sposób, aby to zrobić dla nowego użytkownika Ubuntu.

A. Opcje konfiguracyjne

Jeśli blok ma blokować niezbyt doświadczonym użytkownikom korzystanie z niektórych aplikacji, edycja (lokalna kopia) pliku aplikacji na pulpicie (jak opisano w [1]) jest prawdopodobnie najszybszym i najłatwiejszym sposobem.
Można zrobić dodatkowe rzeczy, aby stworzyć dodatkową barierę i / lub zapobiec temu, że użytkownik zbyt łatwo dowie się, co zrobiliśmy, aby zablokować aplikację ( [2]i [3]).

Konfiguracja nie nadaje się do sytuacji bez nadzoru z doświadczonymi użytkownikami. W sytuacjach domowych z przeciętnymi użytkownikami w wielu przypadkach wystarczy.

1. Przykład blokowania programu gedit przez edycję (lokalnej wersji) pliku .desktop

• Skopiuj plik pulpitu aplikacji /usr/share/applicationsdo ~/.local/share/applications:

  cp /usr/share/applications/gedit.desktop ~/.local/share/applications/gedit.desktop
  

• Edytuj plik: otwórz go za pomocą gedit (póki jeszcze możesz :)), przeciągając go nad otwartym oknem gedit.

  • wymienić linię

    Exec=gedit %U
    

    przez:

    Exec=zenity --info --text 'You are not allowed to use this application'
    

  • usuń (możliwe) skróty, aby uniemożliwić uruchomienie aplikacji z jednego ze skrótów:

    usuń linię (na przykład gedit):

    Actions=Window;Document;
    

    oraz sekcje takie jak:

    [Desktop Action Window]
    Name=Open a New Window
    Exec=gedit --new-window
    OnlyShowIn=Unity;
    

  Od tego momentu (po wylogowaniu / zalogowaniu) użytkownik zobaczy ten komunikat, jeśli spróbuje otworzyć gedit z Dash lub spróbuje otworzyć plik powiązany z aplikacją:

  

  • Ukrywanie aplikacji przed Dash (środek opcjonalny)

    Po wprowadzeniu powyższych zmian, mając gedit.desktopnadal otwarty plik, możemy dodać dodatkowy wiersz:

    NoDisplay=true
    

    Dodanie tego wiersza geditnie będzie nawet wyświetlane w Dash.

  Cofnij

  Aby cofnąć, po prostu usuń .desktopplik lokalny z~/.local/share/applications

2. Uczynienie tego nieco trudniejszym do znalezienia

Podczas gdy po edycji .desktoppliku aplikacja nie będzie już wyświetlana w Dash, wyszukiwanie Dash nadal pokaże nasz nowo utworzony gedit.desktopplik, co może przypadkowo dać wskazówkę, jak wyjść z bloku aplikacji.

Aby tego uniknąć, powinniśmy wykluczyć katalog ~/.local/share/applicationsz wyszukiwania Dash i wyczyścić historię wyszukiwania.
Otwórz Ustawienia systemu> „Bezpieczeństwo i prywatność”> „Pliki i aplikacje” (karta). Dodaj katalog ~/.local/share/applicationsdo listy, aby wykluczyć z wyszukiwania.

3. (Nie) za pomocą terminala / wiersza poleceń

Przekierowanie geditpolecenia(1)

Edycja .desktoppliku uniemożliwia korzystanie z aplikacji z Dash, ale jeśli użytkownik zna AltF2kombinację i polecenie uruchomienia aplikacji, nadal będzie mógł uruchomić aplikację, podobnie jak w terminalu. Przyjemnym i łatwym do skonfigurowania dodatkowym środkiem jest utworzenie (jeśli jeszcze nie istnieje) katalogu ~/bini utworzenie małego skryptu w katalogu:

#!/bin/bash
zenity --info --text 'You are not allowed to use this application'

Spraw, by był wykonywalny i nazwij go po aplikacji; geditw tym przypadku.

Ponieważ ~/binjest PATH, uruchamiając komendę wywoła skrypt zamiast „prawdziwego” geditaplikacji. W rezultacie You are not allowed to use this applicationpojawi się ten sam komunikat

Przekierowanie geditpolecenia(2)

Innym sposobem (z bardziej ograniczonym efektem, patrz uwaga) przekierowania polecenia aplikacji jest dodanie aliasu do .bashrcpliku:

gedit ~/.bashrc

dodaj linię (przykład gedit):

alias gedit='zenity --info --text "You are not allowed to use this application"'

Uwaga : służy to wyłącznie jako dodatkowy środek, ponieważ uniemożliwia bezpośrednie wywołanie aplikacji z terminala. .txtJednak dwukrotne kliknięcie (np.) Pliku nadal otworzy aplikację.

Uczyń korzystanie z terminalu w ogóle trudnym lub niemożliwym

Aby uniemożliwić korzystanie z terminala, możesz wykonać tę samą sztuczkę w gnome-terminal.desktoppliku - co w pliku [1]i / lub zmienić domyślną kombinację klawiszy skrótu, aby uruchomić terminal (Ustawienia systemowe> „Klawiatura”> „Skróty”> „Startery” )

4. Małe narzędzie do automatycznego tworzenia (lub cofania) edytowanej wersji .desktoppliku (jak w 1.)

Po uruchomieniu skryptu poniżej albo argumentu blocklub unblock(użytkownik musi uruchomić go z obu jednego), zostanie przedstawiony z listy (globalne) plików stacjonarnych, reprezentujących zainstalowanych aplikacji:

Wybierz jeden, a aplikacja zostanie zablokowana lub odblokowana, w zależności od argumentu, z którym ją uruchomisz.

Uwaga

Może być konieczne wylogowanie / zalogowanie się, aby działało.

Scenariusz

#!/usr/bin/env python3

import os
import shutil
import sys

mode = sys.argv[1]

home = os.environ["HOME"]
global_dir = "/usr/share/applications/"

files = [file for file in os.listdir(global_dir) if file.endswith(".desktop")]
relevant = []
for i in range(len(files)):
    file = files[i]
    with open(global_dir+file) as src:
        text = src.read()
    if not "NoDisplay=true" in text:
        relevant.append((file))
for i in range (len(relevant)):
    print(str(i+1)+".", relevant[i])

choice = int(input("\nplease enter the number of the corresponding .desktop file: "))
filename = relevant[choice-1]

local_file = home+"/"+".local/share/applications/"+filename
global_file = global_dir+filename

def block_application(filename):
    if not os.path.exists(local_file):
        shutil.copyfile(global_file, local_file)
    with open(local_file) as src:
        lines = src.readlines()
    shortcuts_section = [i for i in range(len(lines)) if lines[i].startswith("Actions=")]
    if len(shortcuts_section) != 0:
        lines = lines[:shortcuts_section[0]]
    command = [i for i in range(len(lines)) if lines[i].startswith("Exec=")]
    if len(command) != 0:
        lines[command[0]] = 'Exec=zenity --info --text "You are not allowed to use this application"\n'
    with open(local_file, "wt") as out:
        for line in lines:
            out.write(line)

if mode == "block":
    block_application(filename)
elif mode == "unblock":
    os.remove(local_file)

Skopiuj skrypt do pustego pliku, zapisz go jako block_apps.pyi uruchom go:

python3 /path/to/block_apps.py block

lub

python3 /path/to/block_apps.py unblock

B. Skrypty (opcje)

Blokowanie niektórych aplikacji można również wykonać, uruchamiając skrypt w tle. Skrypt musiałby podjąć pewne działania, jeśli uruchomiona zostanie jedna z „zabronionych” aplikacji.

1. Skrypt do manipulowania ekranem, gdy używane są zabronione aplikacje.

Poniższy skrypt oferuje elastyczny sposób blokowania aplikacji zdefiniowanych przez użytkownika. Działa z prostym poleceniem, z niedozwolonymi aplikacjami jako argumentem, np. (Zakładając, że skrypt został wykonany):

    /path/to/block_apps.py firefox gedit gnome-terminal

Zaletą blokowania takich aplikacji jest to, że jest elastyczny; nawet w ramach jednego konta można użyć różnych ustawień, po prostu używając innych aplikacji jako argumentu.

Co to robi

Usuwając komentarz z jednej z linii:

# action = "xrandr --output "+screen+" --brightness 0"

lub

# action = "xrandr --output "+screen+" --rotate inverted"

Skrypt albo:

przyciemnia ekran ( action = "xrandr --output "+screen+" --brightness 0"):

lub odwraca go do góry nogami ( action = "xrandr --output "+screen+" --rotate inverted"):
( kto powiedział, że Unity nie pozwala umieścić programu uruchamiającego po prawej stronie? )

Scenariusz

#!/usr/bin/env python3
import subprocess
import getpass
import sys
import time

applications = []
i = 1

while True:
    try:
        applications.append(sys.argv[i])
        i = i+1
    except IndexError:
        break

cmd1 = "xrandr"
get = subprocess.check_output(["/bin/bash", "-c", cmd1]).decode("utf-8").split()
screen = [get[i-1] for i in range(len(get)) if get[i] == "connected"][0]

#-- uncomment (only) one of the options below
# action = "xrandr --output "+screen+" --brightness 0"
action = "xrandr --output "+screen+" --rotate inverted"
#--

while True:
    cmd2 = "ps -u "+getpass.getuser()
    applist = subprocess.check_output(["/bin/bash", "-c", cmd2]).decode("utf-8")
    for application in applications:
        if application in applist:
            subprocess.Popen(["/bin/bash", "-c", action])
    time.sleep(5)

Jak używać

• Skopiuj skrypt do pustego pliku, zapisz go jako block_apps.py, aby był wykonywalny

• uruchom go za pomocą polecenia:

  /path/to/block_apps.py <application_1> <application_2> <application_3> etc...
  

• Ważne
  Aby zabić ten block_apps.pyskrypt i przywrócić „normalny” ustawienia, należy skorzystać z poniższego skryptu (udostępnić go pod kombinacją klawiszy skrótów):

#!/usr/bin/env python3
import subprocess

cmd = "ps -ef | grep block_apps.py"
run = subprocess.check_output(["/bin/bash", "-c", cmd]).decode("utf-8").split("\n")
match = [line for line in run if "block_apps.py" in line]
command = "kill "+match[0].split()[1]
subprocess.Popen(["/bin/bash", "-c", command])

cmd1 = "xrandr"
get = subprocess.check_output(["/bin/bash", "-c", cmd1]).decode("utf-8").split()
screen = [get[i-1] for i in range(len(get)) if get[i] == "connected"][0]

restore_1 = "xrandr --output "+screen+" --brightness 1"
restore_2 = "xrandr --output "+screen+" --rotate normal"

for item in [restore_1, restore_2]:
    subprocess.Popen(["/bin/bash", "-c", item])

Jak zawsze w przypadku skryptów, skopiuj go do pustego pliku, zapisz jako kill_blockapps.py, uczyń go wykonywalnym i uruchom:

/path/to/kill_blockapps.py

Prawdopodobnie będziesz chciał mieć ten pod klawiszem skrótu: Wybierz: Ustawienia systemu> „Klawiatura”> „Skróty”> „Skróty niestandardowe”. Kliknij „+” i dodaj polecenie jak wyżej.