So überprüfen Sie, ob in einem Bash-Skript als Root ausgeführt wird

Ich schreibe ein Skript, für das Berechtigungen auf Stammebene erforderlich sind, und ich möchte es so gestalten, dass, wenn das Skript nicht als root ausgeführt wird, einfach "Bitte als root ausführen" angezeigt wird. und geht.

Hier ist ein Pseudocode für das, wonach ich suche:

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

  else (do stuff)
fi

exit

Wie könnte ich dies am besten (sauber und sicher) erreichen? Vielen Dank!

Ah, nur um zu verdeutlichen: Der (do stuff) Teil würde das Ausführen von Befehlen beinhalten, die an und für sich root erfordern. Wenn Sie es also als normaler Benutzer ausführen, wird nur ein Fehler angezeigt. Dies ist nur dazu gedacht, ein Skript sauber auszuführen, für das Root-Befehle erforderlich sind, ohne dass sudo im Skript verwendet wird. Ich suche nur nach syntaktischem Zucker.

Die Umgebungsvariable $ EUID enthält die UID des aktuellen Benutzers. Die UID von Root ist 0. Verwenden Sie in Ihrem Skript Folgendes:

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

Hinweis: Wenn Sie erhalten, 2: [: Illegal number:überprüfen Sie, ob Sie #!/bin/shoben haben, und ändern Sie es in #!/bin/bash.

In einem Bash-Skript haben Sie verschiedene Möglichkeiten, um zu überprüfen, ob der laufende Benutzer root ist.

Überprüfen Sie als Warnung nicht, ob ein Benutzer root ist, indem Sie den rootBenutzernamen verwenden. Nichts garantiert, dass der Benutzer mit der ID 0 angerufen wirdroot . Es ist eine sehr starke Konvention, die weitgehend befolgt wird, aber jeder kann den Superuser in einen anderen Namen umbenennen.

Ich denke, der beste Weg, wenn Sie Bash verwenden, ist die Verwendung $EUIDvon der Manpage:

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

Dies ist ein besserer Weg als $UIDder, der geändert werden könnte und nicht den tatsächlichen Benutzer widerspiegelt, der das Skript ausführt.

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

Ein Weg, wie ich mich dieser Art von Problem nähere, besteht sudodarin, meine Befehle einzufügen, wenn sie nicht als root ausgeführt werden. Hier ist ein Beispiel:

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

Auf diese Weise wird mein Befehl von root ausgeführt, wenn der Superuser verwendet wird, oder von sudo wenn er von einem normalen Benutzer ausgeführt wird.

Wenn Ihr Skript immer von root ausgeführt werden soll, legen Sie einfach die entsprechenden Rechte fest ( 0500).

Es wurden einige Antworten gegeben, aber es scheint, dass die beste Methode darin besteht, Folgendes zu verwenden:

• id -u
• Wenn als root ausgeführt, wird eine ID von 0 zurückgegeben.

Dies scheint zuverlässiger zu sein als die anderen Methoden, und es scheint, dass es eine ID von 0 zurückgibt, selbst wenn das Skript ausgeführt wird sudo.

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

oder

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

:) :)

Wie @wrikken in seinen Kommentaren erwähnt hat, id -uist eine viel bessere Überprüfung auf root.

Darüber hinaus können Sie bei ordnungsgemäßer Verwendung von sudodas Skript überprüfen lassen, ob es als Root ausgeführt wird. Wenn nicht, lassen Sie es sich über zurückrufen sudound dann mit Root-Berechtigungen ausführen.

Je nachdem, was das Skript tut, besteht eine andere Möglichkeit darin, einen sudoEintrag für die speziellen Befehle einzurichten, die das Skript möglicherweise benötigt.

Es gibt eine einfache Überprüfung, ob ein Benutzer root ist.

Die [[ stuff ]]Syntax ist die Standardmethode zum Ausführen einer Check-in-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

Dies setzt auch voraus, dass Sie mit einer 1 beenden möchten, wenn Sie fehlschlagen. Die errorFunktion ist ein Flair, das den Ausgabetext auf Rot setzt (nicht erforderlich, aber ziemlich edel, wenn Sie mich fragen).

Sehr einfach ausgedrückt:

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

Der Vorteil dieser Funktion idbesteht darin, dass Sie überprüfen können, ob ein bestimmter Nicht-Root-Benutzer den Befehl ebenfalls ausführt. z.B.

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

0- Lesen Sie die offizielle GNU Linux-Dokumentation. Es gibt viele Möglichkeiten, dies richtig zu machen.

1- Stellen Sie sicher, dass Sie die Shell-Signatur eingeben, um Interpretationsfehler zu vermeiden:

 #!/bin/bash

2- das ist mein Skript

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

In dieser Antwort sei klar, ich gehe davon aus, dass der Leser POSIX- Shell-Skripte lesen bashund mögen kann .dash

Ich glaube, hier gibt es nicht viel zu erklären, da die hoch bewerteten Antworten viel davon gut erklären.

Wenn es jedoch noch etwas zu erklären gibt, zögern Sie nicht zu kommentieren, ich werde mein Bestes tun, um die Lücken zu schließen.

Optimierte Allround- bashLösung (nicht nur ) für Leistung und Zuverlässigkeit; Alle Muscheln kompatibel

Neue Lösung:

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

Benchmark (in Datei speichern 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

Ursprüngliche Lösung:

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

^^^ Es hat sich gezeigt, dass die durchgestrichene Lösung die Dinge nicht beschleunigt, aber es gibt sie schon lange, also werde ich sie hier behalten, solange ich es für notwendig halte.

Erläuterung

Da das Lesen der $EUIDStandardvariablen bash, der effektiven Benutzer-ID-Nummer, um ein Vielfaches schneller ist als das Ausführen eines id -uBefehls zum POSIX- Finden der Benutzer-ID, kombiniert diese Lösung beides zu einer gut gepackten Funktion. Wenn und nur wenn der $EUIDaus irgendeinem Grund nicht verfügbar ist, wird der id -uBefehl ausgeführt, um sicherzustellen, dass wir unabhängig von den Umständen den richtigen Rückgabewert erhalten .

Warum ich diese Lösung nach so vielen Jahren poste, hat das OP gefragt

Nun, wenn ich richtig sehe, scheint oben ein fehlender Code zu fehlen.

Sie sehen, es gibt viele Variablen, die berücksichtigt werden müssen, und eine davon ist die Kombination von Leistung und Zuverlässigkeit .

Tragbare POSIX- Lösung + Beispiel für die Verwendung der oben genannten Funktion

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

Fazit

So sehr es Ihnen auch nicht gefällt, die Unix / Linux-Umgebung hat sich stark verändert. Das heißt, es gibt Leute, die bashso sehr mögen , dass sie nicht einmal an Portabilität denken ( POSIX- Shells). Andere wie ich bevorzugen die POSIX- Shells. Es ist heutzutage eine Frage der persönlichen Wahl und der Bedürfnisse.

Wenn das Skript wirklich Root-Zugriff erfordert, sollten seine Dateiberechtigungen dies widerspiegeln. Ein Root-Skript, das von Nicht-Root-Benutzern ausgeführt werden kann, wäre eine rote Fahne. Ich ermutige Sie, den Zugang nicht mit einem ifScheck zu kontrollieren.

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

Eine einfache Möglichkeit, das Skript nur für root ausführbar zu machen, besteht darin, das Skript mit der folgenden Zeile zu starten:

#!/bin/su root

Versuchen Sie den folgenden Code:

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

ODER

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

Soweit ich weiß, ist der richtige Weg, dies zu überprüfen ,:

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

Siehe Abschnitt "Testen auf Root" hier:

http://linuxcommand.org/lc3_wss0080.php

id -u ist viel besser als whoami , da einige Systeme wie Android möglicherweise nicht das Wort root liefern.

Beispiel:

# 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

Anmerkung des Herausgebers: Wenn Sie keine doppelten Klammern benötigen, verwenden Sie für die Code-Portabilität einzelne.

Überprüfen Sie, ob Sie root sind, und beenden Sie, wenn Sie nicht:

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

Versuchen Sie in diesem Beispiel, ein Verzeichnis im Stammverzeichnis zu erstellen, und versuchen Sie es dann, nachdem die Rechte erhöht wurden.

Überprüfen Sie, ob Sie root sind und wenn nicht, wenn möglich:

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

Auf root prüfen:

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

Getestet und läuft in root.