Como verificar se está sendo executado como root em um script bash

Estou escrevendo um script que requer permissões de nível raiz e quero fazê-lo para que, se o script não for executado como root, ele simplesmente ecoará "Por favor, execute como root". e sai.

Aqui estão alguns pseudocódigo para o que estou procurando:

if (whoami != root)
  then echo "Please run as root"

  else (do stuff)
fi

exit

Como eu poderia (melhor e com segurança) conseguir isso? Obrigado!

Ah, só para esclarecer: a parte (do stuff) envolveria a execução de comandos que, por si só, exigem raiz. Portanto, executá-lo como um usuário normal apresentaria um erro. Isso serve apenas para executar corretamente um script que requer comandos root, sem usar o sudo dentro do script, estou apenas procurando por algum açúcar sintático.

A variável de ambiente $ EUID mantém o UID do usuário atual. O UID da raiz é 0. Use algo como isto em seu script:

if [ "$EUID" -ne 0 ]
  then echo "Please run as root"
  exit
fi

Nota: Se você conseguir 2: [: Illegal number:verificar se está #!/bin/shno topo e altere para #!/bin/bash.

Em um script bash, você tem várias maneiras de verificar se o usuário em execução é root.

Como aviso , não verifique se um usuário é root usando o rootnome de usuário. Nada garante que o usuário com o ID 0 seja chamadoroot . É uma convenção muito forte que é amplamente seguida, mas qualquer um poderia renomear o superusuário com outro nome.

Eu acho que a melhor maneira de usar o bash é usar $EUID, na página de manual:

EUID   Expands to the effective user ID of the current  user,  initialized
       at shell startup.  This variable is readonly.

Essa é uma maneira melhor do $UIDque a que poderia ser alterada e não refletir o usuário real executando o script.

if (( $EUID != 0 )); then
    echo "Please run as root"
    exit
fi

Uma maneira de abordar esse tipo de problema é injetando sudomeus comandos quando não é executado como root. Aqui está um exemplo:

SUDO=''
if (( $EUID != 0 )); then
    SUDO='sudo'
fi
$SUDO a_command

Dessa maneira, meu comando é executado pela raiz ao usar o superusuário ou sudopor um usuário comum.

Se seu script sempre deve ser executado pela raiz, simplesmente defina os direitos adequadamente ( 0500).

Algumas respostas foram dadas, mas parece que o melhor método é usar é:

• id -u
• Se executado como root, retornará um ID 0.

Isso parece ser mais confiável que os outros métodos e parece que ele retorna um ID igual a 0, mesmo que o script seja executado sudo.

if [[ $(id -u) -ne 0 ]] ; then echo "Please run as root" ; exit 1 ; fi

ou

if [[ `id -u` -ne 0 ]] ; then echo "Please run as root" ; exit 1 ; fi

:)

Como @wrikken mencionado em seus comentários, id -ué uma verificação muito melhor para o root.

Além disso, com o uso adequado de sudo, você pode fazer com que o script verifique e veja se está sendo executado como root. Caso contrário, faça com que ele se lembre via sudoe execute com permissões de root.

Dependendo do que o script faz, outra opção pode ser configurar uma sudoentrada para quaisquer comandos especializados que o script possa precisar.

Há uma verificação simples para um usuário ser root.

A [[ stuff ]]sintaxe é a maneira padrão de executar uma verificação no bash.

error() {
  printf '\E[31m'; echo "$@"; printf '\E[0m'
}

if [[ $EUID -eq 0 ]]; then
    error "Do not run this as the root user"
    exit 1
fi

Isso também pressupõe que você deseja sair com 1 se falhar. A errorfunção é um talento que define o texto de saída para vermelho (não necessário, mas bastante elegante, se você me perguntar).

Maneira muito simples, basta colocar:

if [ "$(whoami)" == "root" ] ; then
    # you are root
else
    # you are not root
fi

O benefício de usar isso em vez de idé que você pode verificar se um determinado usuário não raiz também está executando o comando; por exemplo.

if [ "$(whoami)" == "john" ] ; then
    # you are john
else
    # you are not john
fi

0- Leia a documentação oficial do GNU Linux, existem várias maneiras de fazê-lo corretamente.

1- certifique-se de colocar a assinatura do shell para evitar erros de interpretação:

 #!/bin/bash

2- este é o meu roteiro

#!/bin/bash 

if [[ $EUID > 0 ]]; then # we can compare directly with this syntax.
  echo "Please run as root/sudo"
  exit 1
else
  #do your stuff
fi

Nesta resposta, fique claro, presumo que o leitor é capaz de ler bashe scripts shell POSIX como dash.

Acredito que não há muito o que explicar aqui, já que as respostas altamente votadas fazem um bom trabalho ao explicar grande parte delas.

No entanto, se houver algo a explicar mais, não hesite em comentar, farei o meu melhor preenchendo as lacunas.

Polivalente otimizado (não apenas bashSolução ) para desempenho e confiabilidade; todas as conchas compatíveis

Nova solução:

# bool function to test if the user is root or not
is_user_root () { [ ${EUID:-$(id -u)} -eq 0 ]; }

Referência (salvar em arquivo is_user_root__benchmark)

###############################################################################
##                          is_user_root() benchmark                         ##
##                  Bash is fast while Dash is slow in this                  ##
##          Tested with Dash version 0.5.8 and Bash version 4.4.18           ##
##                     Copyright: 2020 Vlastimil Burian                      ##
##                      E-mail: info@vlastimilburian.cz                      ##
##                             License: GPL-3.0                              ##
##                               Revision: 1.0                               ##
###############################################################################

# intentionally, the file does not have executable bit, nor it has no shebang
# to use it, please call the file directly with your shell interpreter like:

# bash is_user_root__benchmark
# dash is_user_root__benchmark

# bool function to test if the user is root or not
is_user_root () { [ ${EUID:-$(id -u)} -eq 0 ]; }

# helper functions
print_time   () { date +"%T.%2N"; }
print_start  () { printf '%s' 'Start  : '; print_time; }
print_finish () { printf '%s' 'Finish : '; print_time; }

readonly iterations=10000

printf '%s\n' '______BENCHMARK_____'
print_start

i=1; while [ $i -lt $iterations ]; do
    is_user_root
    i=$((i + 1))
done

print_finish

Solução original:

#!/bin/bash

is_user_root()
# function verified to work on Bash version 4.4.18
# both as root and with sudo; and as a normal user
{
    ! (( ${EUID:-0} || $(id -u) ))
}

if is_user_root; then
    echo 'You are the almighty root!'
else
    echo 'You are just an ordinary user.'
fi

^^^ A solução riscada foi comprovada para não acelerar as coisas, mas existe há muito tempo, então vou mantê-la aqui pelo tempo que achar necessário.

Explicação

Como é muito mais rápido ler a variável $EUIDpadrão bash, o número de ID do usuário efetivo, do que executar o id -ucomando para POSIX - apenas encontrar o ID do usuário, esta solução combina ambos em uma função bem compactada. Se, e somente se, $EUIDpor algum motivo não estiver disponível, o id -ucomando será executado, garantindo que obtemos o valor de retorno adequado, independentemente das circunstâncias .

Por que postei esta solução após tantos anos que o OP perguntou

Bem, se eu entendi corretamente, parece haver um pedaço de código ausente acima.

Veja bem, existem muitas variáveis que precisam ser levadas em consideração, e uma delas é combinar desempenho e confiabilidade .

Solução portátil POSIX + Exemplo de uso da função acima

#!/bin/sh

# bool function to test if the user is root or not (POSIX only)
is_user_root() { [ "$(id -u)" -eq 0 ]; }

if is_user_root; then
    echo 'You are the almighty root!'
    exit 0 # unnecessary, but here it serves the purpose to be explicit for the readers
else
    echo 'You are just an ordinary user.' >&2
    exit 1
fi

Conclusão

Por mais que você não goste, o ambiente Unix / Linux se diversificou bastante. Ou seja, existem pessoas que gostam bashtanto, que nem pensam em portabilidade ( cartuchos POSIX ). Outros como eu preferem as conchas POSIX . Hoje em dia é uma questão de escolha e necessidades pessoais.

Se o script realmente requer acesso root, suas permissões de arquivo devem refletir isso. Ter um script raiz executável por usuários não raiz seria uma bandeira vermelha. Convido você a não controlar o acesso com um ifcheque.

chown root:root script.sh
chmod u=rwx,go=r script.sh

Uma maneira simples de tornar o script apenas executável pela raiz é iniciar o script com a linha:

#!/bin/su root

tente o seguinte código:

if [ "$(id -u)" != "0" ]; then
    echo "Sorry, you are not root."
    exit 1
fi

OU

if [ `id -u` != "0" ]; then
    echo "Sorry, you are not root."
    exit 1
fi

Tanto quanto eu sei a maneira correta de verificar é:

if [ $(id -u) = "0" ]; then
    echo "You are root"
else
    echo "You are NOT root"
fi

Consulte a seção "Teste de raiz" aqui:

http://linuxcommand.org/lc3_wss0080.php

id -ué muito melhor do que whoami, já que alguns sistemas como o Android podem não fornecer a palavra raiz.

Exemplo:

# whoami
whoami
whoami: unknown uid 0

#!/bin/bash

# GNU bash, version 4.3.46
# Determine if the user executing this script is the root user or not

# Display the UID
echo "Your UID is ${UID}"

if [ "${UID}" -eq 0 ]
then
    echo "You are root"
else
    echo "You are not root user"
fi

Nota do editor: Se você não precisar de colchetes duplos, use um para a portabilidade do código.

Verifique se você é root e saia se não for:

if ((EUID != 0)); then
    echo "Root or Sudo  Required for script ( $(basename $0) )"
    exit
fi

Ou, neste exemplo, tente criar um diretório no local raiz e tente depois que os direitos forem elevados.

Verifique se você é root e, caso contrário, eleve, se possível:

# Fails to create these dirs (needs sudo)
mkdir /test-dir-$(basename $0)
rmdir /test-dir-$(basename $0)

if ((EUID != 0)); then
    echo "Granting root privileges for script ( $(basename $0) )"
    if [[ -t 1 ]]; then
        sudo "$0" "$@"
    else
        exec 1> output_file
        gksu "$0" "$@"
    fi
    exit
fi
echo "Root privileges granted..."
# Creates Dirs as it now has rights
mkdir /test-dir-$(basename $0)
rmdir /test-dir-$(basename $0)

Verifique a raiz:

ROOT_UID=0   # Root has $UID 0.

if [ "$UID" -eq "$ROOT_UID" ]
then
  echo "You are root."
else
  echo "You are just an ordinary user."
fi

exit 0

Testado e executando na raiz.