Como posso limitar ou restringir o acesso a um aplicativo?

Meu filho recebeu um novo laptop no Natal passado, principalmente para uso em sua nova escola ... E agora que ele tem seu próprio laptop, ele está feliz por ter o Steam instalado.

Mas a esposa quer que eu remova o Steam, porque o laptop é principalmente para uso escolar ... Prefiro não fazer isso, se não for necessário.

Existe uma maneira de restringir ou limitar o acesso ao Steam? Talvez uma senha no próprio Steam, ou definir horários durante os quais ele possa ser executado?

Idealmente , deve ser algo bem simples de usar, porque meu trabalho muitas vezes me mantém longe de casa (e computadores, telecomunicações e ...) por longos períodos de tempo e enquanto minha esposa não se sente tão à vontade com computadores quanto eu, mais fácil de usar é muito, muito melhor.

Certamente há algo por aí que pode realizar essa tarefa?

Defina um prazo para um processo ou aplicativo

Com um pequeno script em segundo plano, você pode definir um prazo para um processo ou aplicativo.
Desde que o usuário não saiba a senha do administrador , ela não será superada com muita facilidade.

A solução abaixo

É um script de plano de fundo tão pequeno. Limita o uso por dia a um número definido de minutos, a ser definido no cabeçalho do script. Uma vez configurado (o que não é muito difícil), ele é executado com muita facilidade e nenhuma ação adicional é necessária posteriormente.

O script

#!/usr/bin/python3
import subprocess
import os
import sys
import time

#--- set the time limit below (minutes)
minutes = 1
#--- set the process name to limit below
app = "gedit"

uselog = "/opt/limit/uselog"
datefile = "/opt/limit/currdate"

def read(f):
    try:
        return int(open(f).read().strip())
    except FileNotFoundError:
        pass

currday1 = read(datefile)

while True:
    time.sleep(10)
    currday2 = int(time.strftime("%d"))

    # check if the day has changed, to reset the used quantum
    if currday1 != currday2:
        open(datefile, "wt").write(str(currday2))
        try:
            os.remove(uselog)  
        except FileNotFoundError:
            pass

    try:
        # if the pid of the targeted process exists, add a "tick" to the used quantum
        pid = subprocess.check_output(["pgrep", app]).decode("utf-8").strip()
        n = read(uselog)
        n = n + 1 if n != None else 0
        # when time exceeds the permitted amount, kill the process
        if n > minutes*6: 
            subprocess.Popen(["kill", pid])
        open(uselog, "wt").write(str(n))
    except subprocess.CalledProcessError:
        pass

    currday1 = currday2

Como usar

1. Na área de trabalho (ou em qualquer outro lugar), crie uma pasta chamada: limit
2. Copie o script em um arquivo vazio, salve-o como limit_use(sem extensão) dentro da pasta e torne-o executável

3. Edite no cabeçalho do script o nome do processo a limitar e o número máximo de minutos permitidos. No exemplo:

   #--- set the time limit below (minutes)
   minutes = 1
   #--- set the process name to limit below
   app = "gedit"

4. Copie a pasta para o diretório /opt:

   cp -r /path/to/limit /opt

5. Agora edite /etc/rc.localpara fazer o script executá-lo como rootna inicialização:

   sudo -i gedit /etc/rc.local

   Pouco antes da linha

   exit 0

   outra linha:

   /opt/limit/limit_use &

É isso aí

Quando alguém tenta matar o script em segundo plano:

(ação não permitida)

Explicação; como funciona

• Uma vez a cada 10 segundos, o script verifica se o processo de destino está em execução. Nesse caso, "adiciona" um "ponto" a um uso total, para ser gravado em um arquivo ( /opt/limit/uselog). Se o limite diário for atingido, o script não permitirá mais a execução do processo, eliminando-o, se existir.
• Na mudança do dia (a data é registrada em um arquivo, portanto, a reinicialização não ajudará), o arquivo de log é excluído, permitindo que uma nova quantidade de tempo de uso seja acumulada.
• Como o script é executado na inicialização , rc.localsomente usuários com privilégios de sudo podem parar o script, mesmo assim, apenas se o usuário souber o nome do processo.

Pare o script

Caso você queira interromper o script, use o comando:

sudo kill "$(pgrep limit_use)"

Mas, novamente, você precisaria da senha do sudo para fazer isso.

EDITAR

Embora o script acima deva fornecer uma maneira razoavelmente segura de limitar o uso de um aplicativo, conforme mencionado pelo @Bytecommander, ele pode ser superado, embora não com muita facilidade. A combinação com a medida abaixo tornará muito improvável que isso aconteça, a menos que seu filho conheça a configuração e tenha bastante experiência com Linux / Ubuntu.

Medida adicional

Um pouco mais longe de uma "solução simples", mas ainda não muito difícil de configurar, é a medida adicional abaixo. Se nosso suspeito delinquente descobrir que o script é chamado /etc/rc.local, conseguir tornar-se root e remover a linha /etc/rc.local, ou conseguir parar o script dessa maneira, podemos enfrentá-lo com o próximo problema: a tela escurece após Além disso, a solução verifica se o script em segundo plano está em execução após 5 minutos após a reinicialização, ocultando se não estiver.

A medida extra é uma verificação de inicialização, se a linha /opt/limit/limit_use &está presente /etc/rc.local, e uma verificação após 5 minutos, se o script ainda estiver em execução. Como o script é executado a partir de um iniciador (oculto nos aplicativos de inicialização) /etc/xdg/autostart, será bastante difícil descobrir o que está acontecendo, a menos que você saiba como isso é feito. A combinação dessas duas medidas torna improvável que seu filho descubra, e se o fizer, provavelmente nada o impedirá.

Como configurar

Duas etapas simples estão envolvidas:

1. Copie o código abaixo em um arquivo vazio e salve-o blackout.desktopna área de trabalho:

   [Desktop Entry]
   Name=not allowed
   Exec=/bin/bash -c "sleep 15 && /usr/local/bin/blackout.py"
   Type=Application
   Terminal=false
   NoDisplay=true

   Copie o arquivo para /etc/xdg/autostart:

   sudo cp /path/to/blackout.desktop /etc/xdg/autostart

2. Copie o script abaixo em um arquivo vazio, salve-o blackout.pyna área de trabalho, torne-o executável e copie-o para /usr/local/bin:

   cp /path/to/blackout.py /usr/local/bin

   O script

   #!/usr/bin/env python3
   import subprocess
   import time
   
   def dim_screen():
       screen = [
           l.split()[0] for l in subprocess.check_output(["xrandr"]).decode("utf-8").splitlines()\
           if " connected" in l
           ]
       for scr in screen:
           subprocess.Popen(["xrandr", "--output", scr, "--brightness", "0"])
   
   if not "/opt/limit/limit_use &" in open("/etc/rc.local").read():
       dim_screen()
   
   time.sleep(300)
   
   try:
       pid = subprocess.check_output(["pgrep", "limit_use"]).decode("utf-8").strip()
   except subprocess.CalledProcessError:
       dim_screen()

Explicação

Os lançadores /etc/xdg/autostartiniciam um aplicativo (neste caso, a verificação de segurança extra) para todos os usuários. Isso pode ser substituído localmente, mas você deve saber que a verificação é executada. Ao colocar a linha NoDisplay=trueem nosso iniciador, ele não aparecerá localmente Startup Applications; portanto, sem saber que ele existe, é improvável que seja descoberto.

Além disso, seu filho tem apenas 15 segundos para descobrir (a tela fica apagada); portanto, ele teria um problema sério, a menos que seja um gênio, tenha muita experiência com o Ubuntu e uma mente criativa.

Pela minha própria experiência, restringir o acesso a jogos de computador é uma das tarefas mais desafiadoras na educação de nossos filhos. É claro que os pais querem que eles usem seus computadores principalmente na escola, mas isso entra em conflito com as intenções da criança. Eles vão nos odiar por oferecerem hardware utilizável apenas para a escola.

E é claro que também queremos que eles aprendam a usar o computador de maneira sensata, incluindo como usá-lo não apenas no trabalho, mas também no lazer. Isso inclui jogos e assistir a vídeos.

Infelizmente, controles parentais bem mantidos e funcionando para restringir a computação do garoto quase não estão disponíveis para o Ubuntu. Outra questão importante é que, assim que são crianças inteligentes, todas as medidas que tomamos se tornam em vão. Eles sempre encontrarão maneiras de superar nossas restrições, caso sejam realmente inteligentes sem que possamos perceber.

Qualquer software de bloqueio ou restrição de PAM em execução no computador da criança será apenas temporário e poderá, mais cedo ou mais tarde, ser superado com muita facilidade. Portanto, decidimos deixar o roteador protegido por senha fazer o trabalho, onde o acesso físico pode ser controlado com muito mais facilidade.

Então, o que fazemos aqui para limitar um pouco os jogos no momento é uma combinação de todos os seguintes itens:

• Converse com eles para educá-los sobre como e quando usar computadores para lazer e quando usá-los na escola. Esse é um processo constantemente entediante e bastante tedioso, que leva a inúmeras discussões e argumentos. Mas é o que sentimos ser a única coisa que durará a longo prazo.
• Nenhuma permissão de administrador em sua conta. Isso é uma coisa temporária. Nós sabemos que eles serão capazes de se colocar no sudogrupo mais cedo ou mais tarde. O plano é que eles nos solicitem isso em vez de esconder isso.
• Faça um contrato para tempos de computação claramente definidos. Eles precisam saber por quanto tempo e por quanto tempo podem usar suas máquinas. Eles precisam aprender como dividir esse tempo na escola e no lazer.
• Bloqueie toda a Internet durante o horário de sono .

Para facilitar o cumprimento do contrato de uso do computador, tanto para crianças quanto para nós, instalamos as seguintes restrições:

• Use um roteador protegido por senha que permita a restrição de acesso à Internet em uma combinação de hardware (MAC) e horário. Contanto que eles não saibam sobre falsificação de MAC, isso funcionará muito bem. Também restringirá o acesso através de seus smartphones e tablets. Obviamente, isso não funcionará se houver uma rede sem fio aberta no seu bairro.
• Instale um servidor SSH nos computadores das crianças para desconectar, caso elas se percam em suas próprias intenções. Isto é para casos de emergência, estamos contentes por não termos precisado muito.
• Instalou uma lista negra de DNS (através do roteador, não do computador!) Que deve bloquear o acesso ao pior.

O bloqueio do acesso à Internet desativará efetivamente os jogos se esse jogo precisar de acesso à Internet, como Steam , Minecraft ou outros servidores gamig. No entanto, isso não terá efeito para jogos que ficam fora de linha.

Isso pode ser alcançado usando scripts de shell.

O primeiro script é matar Steamassim que é executado:

#!/bin/bash

while true
do
    pkill steam
    sleep 1
done

exit 0

Salve-o como /path/to/anyname.she adicione-o à lista de aplicativos de inicialização.

O que esse script fará é que ele verifique qualquer processo aberto nomeado a steamcada segundo e, se encontrar algum, o matará.

Mas você precisa de uma solução em que steampossa ser executada em um momento específico, para que seu filho possa jogar durante esse intervalo. Para fazer isso, você precisa escrever outro script:

#!/bin/bash

    echo "pkill anyname.sh" | at 10:00

exit 0

Salve-o como /path/to/anyname2.she também adicione-o à sua lista de aplicativos de inicialização.

Este script irá matar o primeiro script às 10:00 hrs. Então, quando seu filho corre Steamàs 10:00 hrs. Ele será capaz de jogar agora.

O terceiro script é reiniciar o primeiro script em outro ponto do tempo, para que ele apague Steamapós um intervalo de tempo e seu filho não consiga mais jogar Steam.

#!/bin/bash

    echo "bash /path/to/anyname.sh" | at 12:00

exit 0

Salve-o como /path/to/anyname3.she adicione-o à sua lista de aplicativos de inicialização.

Mantenha esses caminhos escondidos, para que seu filho não descubra.

Por que não usar uma nova conta de usuário (através das configurações do sistema ). Este é o único método no Linux para "permissões".

1. O novo usuário "SteamUser" não deve estar em sudoers (apenas uma conta limitada).
2. Em seguida, crie uma segunda conta chamada "SuperAdmin" e faça com que ela sofraers account (acesso root). Mas mantenha sua senha apenas com você.
3. Em seguida, remova a conta do seu filho dos sudoers. ( sudogrupo). Então, esta conta não terá acesso root, não poderá instalar ou remover software, alterar as configurações do sistema.
4. Entre na sua conta "SuperAdmin" e altere a propriedade dos binários e da pasta de jogos a vapor para impedir que sejam executados por qualquer pessoa, exceto "SteamUser". Isso inclui remover o acesso de leitura, gravação e execução de qualquer pessoa, exceto o "SteamUser"

Algumas notas ..

• Não há capacidade de deixar um acesso root na conta do seu filho, caso contrário, o controle de permissões é ignorado facilmente com chown / chmod.
• Outras sugestões baseadas em scripts em segundo plano são apenas uma bagunça instável. Isso significa que eles não são promissores. No entanto, eles são fáceis de configurar, talvez.
• Os caminhos da pasta a serem transferidos para o "SteamAccount" são: /home/son/.steame, é claro, o arquivo binário/usr/games/steam
• Para reproduzir o vapor, é necessária uma senha "SteamUser" (você precisará fazer login com "SteamUser" e executar o steam. Você pode tentar métodos para expirar a sessão após algum tempo bloqueando-a, para impedir a reprodução por muito tempo. não tenho certeza se existem ferramentas como essa, mas é tecnicamente possível definir limites de tempo, mas para sessões, não para programas.