Jak sprawdzić, czy działa jako root w skrypcie bash

Piszę skrypt, który wymaga uprawnień na poziomie administratora, i chcę go wykonać, aby jeśli skrypt nie był uruchamiany jako root, po prostu powtarza „Uruchom jako root”. i wychodzi.

Oto pseudokod tego, czego szukam:

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

  else (do stuff)
fi

exit

Jak mogę najlepiej (czysto i bezpiecznie) to osiągnąć? Dzięki!

Ach, dla wyjaśnienia: część (zrób rzeczy) wymagałaby wykonywania poleceń, które same w sobie wymagają rootowania. Tak więc uruchomienie go jako zwykłego użytkownika spowoduje błąd. Ma to na celu wyłącznie uruchomienie skryptu, który wymaga poleceń roota, bez używania sudo wewnątrz skryptu, szukam tylko cukru syntaktycznego.

Zmienna środowiskowa $ EUID przechowuje identyfikator UID bieżącego użytkownika. Identyfikator UID roota to 0. Użyj w skrypcie czegoś takiego:

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

Uwaga: jeśli dostaniesz, 2: [: Illegal number:sprawdź, czy masz #!/bin/shna górze i zmień na #!/bin/bash.

W skrypcie bash istnieje kilka sposobów sprawdzenia, czy działający użytkownik jest rootem.

Jako ostrzeżenie , nie sprawdzaj, czy użytkownik jest rootem, używając rootnazwy użytkownika. Nic nie gwarantuje, że użytkownik o identyfikatorze 0 zostanie wywołany root. Jest to bardzo silna konwencja, która jest szeroko stosowana, ale każdy może zmienić nazwę administratora na inną nazwę.

Myślę, że najlepszym sposobem korzystania z bash jest użycie $EUIDstrony man:

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

Jest to lepszy sposób niż ten, $UIDktóry można zmienić i nie odzwierciedla rzeczywistego użytkownika uruchamiającego skrypt.

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

Podchodzę do tego rodzaju problemu przez wstrzykiwanie sudomoich poleceń, gdy nie są uruchamiane jako root. Oto przykład:

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

W ten sposób moje polecenie jest uruchamiane przez użytkownika root podczas korzystania z administratora lub przez sudozwykłego użytkownika.

Jeśli twój skrypt ma być zawsze uruchamiany przez root, po prostu ustaw odpowiednio uprawnienia ( 0500).

Podano kilka odpowiedzi, ale wydaje się, że najlepszą metodą jest użycie:

• id -u
• Jeśli zostanie uruchomiony jako root, zwróci identyfikator 0.

Wydaje się to być bardziej niezawodne niż inne metody i wydaje się, że zwraca identyfikator 0, nawet jeśli skrypt zostanie uruchomiony sudo.

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

lub

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

:)

Jak wspomniano w jego komentarzach @wrikken, id -ujest znacznie lepszym sprawdzeniem roota.

Ponadto przy właściwym użyciu sudomożesz sprawdzić skrypt i sprawdzić, czy działa on jako root. Jeśli nie, poproś o ponowne wywołanie, sudoa następnie uruchom z uprawnieniami administratora.

W zależności od tego, co robi skrypt, inną opcją może być ustawienie sudopozycji dla wszelkich specjalistycznych poleceń, których skrypt może potrzebować.

Istnieje proste sprawdzenie, czy użytkownik jest rootem.

[[ stuff ]]Składnia jest standardowym sposobem prowadzenia sprawdzić w 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

Zakłada się również, że chcesz wyjść z 1, jeśli ci się nie powiedzie. Ta errorfunkcja ma pewien talent, który ustawia tekst wyjściowy na czerwony (niepotrzebny, ale dość elegancki, jeśli mnie zapytasz).

Bardzo prosty sposób po prostu:

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

Zaletą korzystania z tego zamiast idjest to, że możesz sprawdzić, czy pewien użytkownik inny niż root również uruchamia polecenie; na przykład.

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

0- Przeczytaj oficjalną dokumentację GNU Linux, istnieje wiele sposobów, aby zrobić to poprawnie.

1- upewnij się, że umieściłeś podpis powłoki, aby uniknąć błędów w interpretacji:

 #!/bin/bash

2 - to jest mój skrypt

#!/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

W tej odpowiedzi, niech będzie jasne, zakładam, że czytelnik jest w stanie czytać, basha skrypty powłoki POSIX- a takie dash.

Uważam, że nie ma tu wiele do wyjaśnienia, ponieważ wysoko głosowane odpowiedzi dobrze tłumaczą wiele z nich.

Jeśli jednak jest coś, co można wyjaśnić dalej, nie wahaj się komentować, zrobię co w mojej mocy, aby wypełnić luki.

Zoptymalizowane kompleksowe (nie tylko bash) rozwiązanie zapewniające wydajność i niezawodność; kompatybilne z wszystkimi powłokami

Nowe rozwiązanie:

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

Benchmark (zapisz do pliku 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: [email protected]                      ##
##                             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

Oryginalne rozwiązanie:

#!/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

^^^ Udowodniono, że przekreślone rozwiązanie nie przyspiesza, ale działa już od dłuższego czasu, więc zamierzam go tu trzymać tak długo, jak będzie to konieczne.

Wyjaśnienie

Ponieważ odczytanie zmiennej $EUIDstandardowej bash, efektywnego numeru identyfikatora użytkownika jest wiele razy szybsze niż wykonanie id -upolecenia POSIX -lyby znaleźć identyfikator użytkownika, to rozwiązanie łączy obie funkcje w ładnie zapakowaną funkcję. Jeśli i tylko wtedy, gdy $EUIDz jakiegokolwiek powodu nie jest dostępny, id -upolecenie zostanie wykonane, zapewniając, że otrzymamy odpowiednią wartość zwracaną bez względu na okoliczności .

Dlaczego publikuję to rozwiązanie po tylu latach, o które pytał OP

Cóż, jeśli dobrze widzę, powyżej brakuje fragmentu kodu.

Widzisz, istnieje wiele zmiennych, które należy wziąć pod uwagę, a jedną z nich jest połączenie wydajności i niezawodności .

Przenośne rozwiązanie POSIX + Przykład użycia powyższej funkcji

#!/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

Wniosek

O ile ci się to nie podoba, środowisko Unix / Linux jest bardzo zróżnicowane. Oznacza to, że są ludzie, którzy bashtak bardzo lubią , nawet nie myślą o przenośności ( powłoki POSIX ). Inni, tacy jak ja, wolą powłoki POSIX . Obecnie jest to kwestia osobistego wyboru i potrzeb.

Jeśli skrypt naprawdę wymaga dostępu do konta root, jego uprawnienia do plików powinny to odzwierciedlać. Posiadanie skryptu root wykonywalnego przez użytkowników innych niż root byłoby czerwoną flagą. Zachęcam do nie kontrolowania dostępu ifczekiem.

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

Jednym prostym sposobem, aby skrypt mógł być uruchamiany tylko przez root, jest uruchomienie skryptu za pomocą wiersza:

#!/bin/su root

spróbuj następującego kodu:

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

LUB

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

O ile wiem, poprawnym sposobem sprawdzenia jest:

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

Zobacz sekcję „Testowanie rootowania” tutaj:

http://linuxcommand.org/lc3_wss0080.php

id -ujest znacznie lepszy niż whoami, ponieważ niektóre systemy, takie jak Android, mogą nie zapewniać słowa root.

Przykład:

# 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

Uwaga edytora: Jeśli nie potrzebujesz podwójnych nawiasów, użyj pojedynczych nawiasów do przenoszenia kodu.

Sprawdź, czy jesteś rootem i wyjdź, jeśli nie jesteś:

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

Lub w tym przykładzie spróbuj utworzyć katalog w lokalizacji głównej, a następnie spróbuj po podniesieniu uprawnień.

Sprawdź, czy jesteś rootem, a jeśli nie, to jeśli to możliwe:

# 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)

Sprawdź root:

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

Testowane i działające w katalogu głównym.