Sudo (Português) - ArchWiki

Jump to content
From ArchWiki
Status de tradução: Esse artigo é uma tradução de Sudo. Data da última tradução: 2020-06-04. Você pode ajudar a sincronizar a tradução, se houver alterações na versão em inglês.

Artigos relacionados

- Usuários e grupos
- su

Sudo possibilita que um adminitrador do sistema dê autoridade a certos usuários —ou grupos de usuários— de executar comandos como root ou outro usuário enquanto fornece uma trilha de auditoria dos comandos e seus argumentos.

Sudo é uma alternativa ao su para executar comandos como root. Diferente do su, que lança um shell root que faz todos os próximos comandos terem acesso root, sudo garante escalação de privilégio temporária para um único comando. Ao habilitar privilégios root somente quando necessário, o uso do sudo reduz a probabilidade que um erro de digitação ou bug no comando arruine o sistema.

Sudo também pode ser usado para executar comandos como outros usuários; adicionalmente, sudo faz log de todos os comandos e tentativas de acesso fracassadas para auditoria de segurança.

## Instalação

Instale o pacote sudo.

## Uso

Para começar a usar `sudo` como um usuário sem privilégios, é necessário configurá-lo apropriadamente. Veja #Configuração.

Para usar sudo, simplesmente prefixe o comando e seus argumentos com `sudo` e um espaço:

    $ sudo comando

Por exemplo, para usar pacman:

    $ sudo pacman -Syu

Veja sudo(8) para mais informações.

## Configuração

This article or section needs expansion.

Reason: Criar uma introdução discutindo `Defaults`, talvez com uma tabela que lista configurações comuns (Discuss in talk:sudo)

### Estrutura do Defaults

O site do autor tem uma lista de todas as opções (inglês) que podem ser usadas com o comando `Defaults` no arquivo `/etc/sudoers`.

Veja [1] para uma lista de opções (parseada da versão 1.8.7 do código fonte) em um formato otimizado para o `sudoers`.

Veja sudoers(5) para mais informações, como configurar o tempo antes de pedir novamente a senha.

### Ver as configurações atuais

Execute `sudo -ll` para mostrar a configuração atual do sudo, ou `sudo -lU usuário` para a configuração específica de um usuário.

### Usando visudo

O arquivo de configuração do sudo é o `/etc/sudoers`. Ele deve sempre ser editado com o comando visudo(8). `visudo` trava o arquivo `sudoers`, salva as modificações para um arquivo temporário e verifica se o arquivo foi configurado corretamente antes de copiá-las para o `/etc/sudoers`.

Atenção:

- É imperativo que `sudoers` não tenha erros de sintaxe! Qualquer erro inutiliza o sudo. Sempre edite ele com `visudo` para evitar erros.
- Do visudo(8) (traduzido): Note que isto pode ter um buraco na segurança considerando que o usuário pode executar qualquer programa ao simplesmente definir as váriaveis de ambiente VISUAL ou EDITOR.

O editor padrão do visudo é o `vi`. O sudo do repositório core é compilado com `--with-env-editor` por padrão e possibilita o uso das váriaveis `VISUAL` e `EDITOR`. `EDITOR` não é usada quando `VISUAL` está definida.

Para usar nano como o editor do visudo durante o shell atual execute `export EDITOR=nano`; para usar um editor diferente somente uma vez simplesmente defina a váriavel antes de executar o visudo:

    # EDITOR=nano visudo

Alternativamente você pode editar uma cópia do arquivo `/etc/sudoers` e verificá-lo com `visudo -c -f /cópia/do/sudoers`. Isto pode ser útil caso você queira evitar a trava do arquivo com visudo.

Para mudar o editor permanentemente, veja Variáveis de ambiente#Por usuário. Para mudar o editor permanentemente no sistema todo somente para o `visudo`, adicione o seguinte para o `/etc/sudoers` (assumindo que `nano` é o editor escolhido):

    # Reseta o ambiente para o padrão
    Defaults      env_reset
    # Define EDITOR para o nano, e não permite que o visudo use EDITOR/VISUAL.
    Defaults      editor=/usr/bin/nano, !env_editor

### Exemplos de entradas

Para permitir um usuário à ganhar todos os privilégios root quando precedido com o comando `sudo`, adicione a seguinte linha:

    NOME_DO_USUÁRIO   ALL=(ALL) ALL

Para permitir que um usuário execute todos os comandos como qualquer usuário mas somente na máquina com o nome `NOME_DA_MÁQUINA` (hostname):

    NOME_DO_USUÁRIO   NOME_DA_MÁQUINA=(ALL) ALL

Para permitir que membros do grupo `wheel` usem o sudo:

    %wheel      ALL=(ALL) ALL

Dica: Quando criar novos administradores, é geralmente desejável habilitar acesso ao sudo pelo grupo `wheel` e adicionar o usuário nele, considerando que o Polkit por padrão trata os membros do grupo `wheel` como administradores. Se o usuário não é membro do `wheel`, programas usando Polkit pode pedir autentificação pela senha do root ao invês de pedir a do usuário.

Para desabilitar a solicitação de senha para o usuário `NOME_DO_USUÁRIO`:

Atenção: Isto vai deixar qualquer processo em execução do seu usuário executar o sudo sem pedir permissão.

    Defaults:NOME_DO_USUÁRIO      !authenticate

Para habilitar explicitamente comandos definidos somente pelo usuário `NOME_DO_USUÁRIO` na máquina `NOME_DA_MÁQUINA`:

    NOME_DO_USUÁRIO NOME_DA_MÁQUINA=/usr/bin/halt,/usr/bin/poweroff,/usr/bin/reboot,/usr/bin/pacman -Syu

Nota: A opção mais customizada deve ir para o fim do arquivo, já que as linhas posteriores sobrescrevem as anteriores. Particularmente uma linha deve estar depois da linha do `%wheel` se seu usuário está nesse grupo.

Para habilitar explicitamente comandos definido somente para o usuário `NOME_DO_USUÁRIO` na máquina `NOME_DA_MÁQUINA` sem senha:

    NOME_DO_USUÁRIO NOME_DA_MÁQUINA= NOPASSWD: /usr/bin/halt,/usr/bin/poweroff,/usr/bin/reboot,/usr/bin/pacman -Syu

Um exemplo detalhado do `sudoers` está disponível em `/usr/share/doc/sudo/examples/sudoers`. De outro modo, veja sudoers(5) para informações detalhadas.

### Permissões padrão do arquivo sudoers

O dono e grupo para o arquivo `sudoers` devem ser ambos 0. As permissões do arquivo devem ser definidas para 0440. Estas permissões são definidas por padrão, mas se você acidentalmente mudá-las, elas devem ser mudadas de volta imediatamente ou sudo vai dar erro.

    # chown -c root:root /etc/sudoers
    # chmod -c 0440 /etc/sudoers

## Dicas e truques

### Desabilitar o tempo de solicitação da senha

Um incômodo comum é um processo com grande tempo de execução que é executado em segundo plano com permissões normais e as eleva somente quando necessário. Isto leva a solicitação da senha não ser notada e esgotar o tempo dela, fazendo com que o processo morra e o trabalho feito seja perdido, ou no melhor caso, salvo em cache. O conselho comum é habilitar o sudo sem senha, ou extender o tempo que o sudo se lembra da senha. Ambos tem implicações negativas de segurança. O tempo de solicitação pode ser desabilitado e considerando que isto não serve qualquer próposito de maior segurança, esta deve ser a solução aqui:

    Defaults passwd_timeout=0

### Adicionar toque no terminal na solicitação de senha

Para chamar atenção na solicitação de senha do sudo em um terminal no segundo plano, usuários podem simplesmente fazé-lo tocar um caractere bell

    Defaults passprompt="^G[sudo] password for %p: "

Note que ^G é um caractere bell literal. E.x. no vim, insira usando a sequência ^V ^G.

### Utilizando aliases

Se você usa muitas aliases, você pode ter notado que elas não são levadas a conta root quando o sudo é usado. No entanto, tem uma maneira fácil de fazê-los funcionar. Simplesmente adicione o seguinte para seu `~/.bashrc` ou `/etc/bash.bashrc`:

    alias sudo='sudo '

### Desabilitar sudo por terminal

Atenção: Isto vai deixar qualquer processo usar sua sessão sudo.

Se você está incomodado pelo padrão do sudo em solicitar a senha toda vez que você abre um novo terminal, defina `timestamp_type` para `global`:

    Defaults timestamp_type=global

### Reduzir o número de vezes que você tem que digitar a senha

Se você está incomodado em ter que entrar com sua senha a cada 5 minutos (padrão), você pode mudar isto ao definir um valor maior para `timestamp_timeout` (em minutos):

    Defaults timestamp_timeout=10

Se você está usando vários comandos sudo em sequência, é mais lógico atualizar o tempo de solicitação da senha toda vez que você usa o sudo do que aumentar `timestamp_timeout`. Essa atualização pode ser feita com `sudo -v` (onde `sudo -K` revoca imediatamente).

Você pode querer automatizar isto ao adicionar o seguinte para seu `.bashrc`:

    alias sudo='sudo -v; sudo '

É também possível usar uma função bash; para mais detalhes veja stackexchange.

### Variáveis de ambiente

Se você tem várias variáveis de ambiente, ou você exporta suas configurações de proxy com `export http_proxy="..."`, quando você usar o sudo estas variáveis não vão ser passadas para a conta root a menos que você o execute com a opção `-E`.

    $ sudo -E pacman -Syu

A maneira recomendada de preservar as variáveis de ambiente é adicioná-las ao `env_keep`:

    /etc/sudoers

    Defaults env_keep += "ftp_proxy http_proxy https_proxy no_proxy"

### Senha do root

Usuários podem configurar o sudo para pedir a senha do root ao invês da senha do usuário ao adicionar `targetpw` (usuário alvo, o padrão é o root) ou `rootpw` para a linha Defaults em `/etc/sudoers`:

    Defaults targetpw

Para evitar a exposição da sua senha root para os usuários, você pode restringir isto para um grupo específico:

    Defaults:%wheel targetpw
    %wheel ALL=(ALL) ALL

### Desabilitar o login do root

Usuários podem desejar desabilitar o login do root. Sem o root, atacantes devem primeiro supor o nome do usuário configurado como um sudoer e também a senha dele. Veja por exemplo OpenSSH#Deny.

Atenção:

- Tenha cuidado, você pode se trancar fora do sistema ao desabilitar o login do root. Sudo não é automaticamente instalado e sua configuração padrão não permite acesso ao root sem senha e nem com a senha do seu usuário. Garanta que um usuário está configurado apropriadamente como um sudoer antes de desabilitar a conta root!
- Se você modificou seu arquivo sudoers para usar rootpw por padrão, então não desabilite o login do root com qualquer um dos comandos a seguir!
- Se você já está trancado fora do sistema, veja Recuperação de senha para ajuda.

A conta pode ser bloqueada com `passwd`:

    # passwd -l root

Um comando similar desbloqueia o root.

    $ sudo passwd -u root

Alternativamente, edite `/etc/shadow` e troque a senha criptografada do root com "!":

    root:!:12345::::::

Para habilitar o login do root novamente:

    $ sudo passwd root

Dica: Para ter um shell root interativo, até mesmo depois de desabilitar a conta root, use `sudo -i`.

#### kdesu

kdesu pode ser usado no KDE para lançar programas gráficos com privilégios root. É possível que por padrão kdesu vai tentar usar su até mesmo se a conta root está desabilitada. Felizmente, você pode configurar o kdesu para usar sudo ao invês do su. Crie/edite o arquivo `~/.config/kdesurc`:

    [super-user-command]
    super-user-command=sudo

ou use o seguinte comando:

    $ kwriteconfig5 --file kdesurc --group super-user-command --key super-user-command sudo

### Exemplo de como aumentar a segurança com sudo

Vamos supor que você criou 3 usuários: admin, devel, e joe. O usuário "admin" é usado para journalctl, systemctl, mount, kill, e iptables; "devel" é usado para instalar pacotes, e editar arquivos de configuração; e "joe" é o usuário que você entra no sistema. Para permitir que "joe" reinicie e desligue o sistema e use netctl, devemos fazer o seguinte:

Edite `/etc/pam.d/su` e `/etc/pam.d/su-l` Faça necessário que o usuário esteja no grupo wheel, mas não coloque ninguém nele.

    #%PAM-1.0
    auth            sufficient      pam_rootok.so
    # Uncomment the following line to implicitly trust users in the "wheel" group.
    #auth           sufficient      pam_wheel.so trust use_uid
    # Uncomment the following line to require a user to be in the "wheel" group.
    auth            required        pam_wheel.so use_uid
    auth            required        pam_unix.so
    account         required        pam_unix.so
    session         required        pam_unix.so

Limite o login pelo SSH para o grupo 'ssh'. Somente "joe" vai ser parte desse grupo.

    groupadd -r ssh
    gpasswd -a joe ssh
    echo 'AllowGroups ssh' >> /etc/ssh/sshd_config

Reinicie `sshd.service`.

Adicione usuários para outros grupos.

    for g in power network ;do ;gpasswd -a joe $g ;done
    for g in network power storage ;do ;gpasswd -a admin $g ;done

Defina permissões nos arquivos de configuração para que devel possa editá-los.

    chown -R devel:root /etc/{http,openvpn,cups,zsh,vim,screenrc}

    Cmnd_Alias  POWER       =   /usr/bin/shutdown -h now, /usr/bin/halt, /usr/bin/poweroff, /usr/bin/reboot
    Cmnd_Alias  STORAGE     =   /usr/bin/mount -o nosuid\,nodev\,noexec, /usr/bin/umount
    Cmnd_Alias  SYSTEMD     =   /usr/bin/journalctl, /usr/bin/systemctl
    Cmnd_Alias  KILL        =   /usr/bin/kill, /usr/bin/killall
    Cmnd_Alias  PKGMAN      =   /usr/bin/pacman
    Cmnd_Alias  NETWORK     =   /usr/bin/netctl
    Cmnd_Alias  FIREWALL    =   /usr/bin/iptables, /usr/bin/ip6tables
    Cmnd_Alias  SHELL       =   /usr/bin/zsh, /usr/bin/bash
    %power      ALL         =   (root)  NOPASSWD: POWER
    %network    ALL         =   (root)  NETWORK
    %storage    ALL         =   (root)  STORAGE
    root        ALL         =   (ALL)   ALL
    admin       ALL         =   (root)  SYSTEMD, KILL, FIREWALL
    devel	    ALL         =   (root)  PKGMAN
    joe	    ALL         =   (devel) SHELL, (admin) SHELL

Com esta configuração, você quase nunca vai precisar logar como o usuário root.

"joe" pode se conectar ao WiFi de sua casa.

    sudo netctl start home
    sudo poweroff

"joe" não pode usar netctl como qualquer outro usuário.

    sudo -u admin -- netctl start home

Quando "joe" precisa usar journalctl ou matar processos ele pode trocar para outro usuário.

    sudo -i -u devel
    sudo -i -u admin

Mas "joe" não pode trocar para o usuário root.

    sudo -i -u root

Se "joe" quer iniciar uma sessão do gnu-screen como admin ele pode fazer isto:

    sudo -i -u admin
    admin% chown admin:tty `echo $TTY`
    admin% screen

### Configurar o sudo usando arquivos presentes no /etc/sudoers.d

sudo lê os arquivos contidos no diretório `/etc/sudoers.d/`. Isto significa que ao invês de editar `/etc/sudoers`, você pode mudar as configurações em arquivos separados e jogá-los nesse diretório. Isto tem duas vantagens:

- Não há necessidade de editar um arquivo `sudoers.pacnew`;
- Se existe um problema com uma nova entrada, você pode remover o respectivo arquivo ao invês de editar o `/etc/sudoers` (mas veja o aviso abaixo).

O formato para entradas nestes arquivos é o mesmo do `/etc/sudoers`. Para editá-los diretamente, use `visudo -f /etc/sudoers.d/algum_arquivo`. Veja a seção "Including other files from within sudoers" do sudoers(5) para detalhes.

Os arquivos no diretório `/etc/sudoers.d/` são lidos em ordem lexicográfica, nomes do arquivos contendo `.` ou `~` são ignorados. Para evitar problemas de ordenamento, o nome dos arquivos devem começar com dois dígitos, e.x. `01_foo`.

Nota: A ordem das entradas nos arquivos é importante: tenha certeza que as declarações não se sobrescrevem.
Atenção: Os arquivos no `/etc/sudoers.d/` são tão frágeis quanto o próprio `/etc/sudoers`: qualquer arquivo com formatação errada vai impedir o funcionamento do `sudo`. Então, pelo mesmo motivo, é recomendado fortemente o uso do `visudo`

### Editando arquivos

`sudo -e` ou `sudoedit` possibilita que você modifique um arquivo como outro usuário enquanto ainda executa o editor de texto com seu usuário.

Isto é especialmente útil para editar arquivos como root sem elevar o privilégios do seu editor de texto, para mais detalhes leia sudo(8) § e.

Note que você pode definir o editor para qualquer programa, por exemplo, pode usar o meld para gerenciar arquivos pacnew:

    $ SUDO_EDITOR=meld sudo -e /etc/file{,.pacnew}

### Habilitar insultos

Usuários podem habilitar insultos ao adicionar a seguinte linha no arquivo sudoers com `visudo`.

Ao entrar com uma senha incorreta, a mensagem `Sorry, try again.` (ou `Sinto muito, tente novamente.`) será trocada por uma com insultos engraçados.

    /etc/sudoers

    Defaults insults

## Resolução de problemas

### Problema do SSH sem TTY

SSH não aloca uma tty por padrão quando executa um comando remotamente. Sem um tty alocado, o sudo não pode impedir a senha de ser exibida. Você pode executar o ssh com a opção `-t` para forçá-lo a alocar uma tty.

A opção `requiretty` do `Defaults` somente permite que o usuário execute sudo se ele tiver uma tty.

    # Disable "ssh hostname sudo <cmd>", because it will show the password in clear text. You have to run "ssh -t hostname sudo <cmd>".
    #
    #Defaults    requiretty

### Umask permissivo

Sudo vai unir o valor umask do usuário com o seu próprio (que por padrão é 0022). Isto evita que o sudo crie arquivos com permissões mais abertas que o umask do usuário permite. Enquanto isto é um padrão válido se nenhum umask customizado é usado, isto pode levar a situações onde um utilitário executado com sudo crie arquivo com permissões diferentes das que seriam criadas se fosse executado diretamente pelo root. Se erros aparecerem devido a isto, sudo fornece uma forma de consertar o umask, até mesmo se o umask desejado é mais permissivo que o especificado do usuário. Adicionar isto (usando `visudo`) vai sobrescrever o comportamento padrão do sudo:

    Defaults umask = 0022
    Defaults umask_override

Isto define o umask do sudo para o padrão do root (0022) e sobrescreve o comportamento padrão, sempre usando o umask indicado não importando como o umask do usuário está definido.

Categories:

- Security (Português)
- Commands (Português)

Hidden category:

- Pages or sections flagged with Template:Expansion