Cara memeriksa apakah menjalankan sebagai root di skrip bash

Saya sedang menulis skrip yang memerlukan izin tingkat root, dan saya ingin membuatnya sehingga jika skrip tidak dijalankan sebagai root, itu hanya gema "Tolong jalankan sebagai root." dan keluar.

Inilah beberapa pseudocode untuk apa yang saya cari:

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

  else (do stuff)
fi

exit

Bagaimana saya bisa melakukan yang terbaik (bersih dan aman)? Terima kasih!

Ah, hanya untuk memperjelas: bagian (melakukan hal-hal) akan melibatkan menjalankan perintah yang di-dan-dari mereka sendiri membutuhkan root. Jadi menjalankannya sebagai pengguna biasa hanya akan menghasilkan kesalahan. Ini hanya dimaksudkan untuk menjalankan skrip yang membutuhkan perintah root, tanpa menggunakan sudo di dalam skrip, saya hanya mencari beberapa gula sintaksis.

Variabel lingkungan $ EUID memegang UID pengguna saat ini. UID Root adalah 0. Gunakan sesuatu seperti ini di skrip Anda:

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

Catatan: Jika Anda mendapatkan 2: [: Illegal number:centang apakah Anda memiliki #!/bin/shdi bagian atas dan mengubahnya ke #!/bin/bash.

Dalam skrip bash, Anda memiliki beberapa cara untuk memeriksa apakah pengguna yang berjalan adalah root.

Sebagai peringatan , jangan periksa apakah pengguna root dengan menggunakan rootnama pengguna. Tidak ada yang menjamin bahwa pengguna dengan ID 0 dipanggil root. Ini adalah konvensi yang sangat kuat yang diikuti secara luas tetapi siapa pun bisa mengganti nama superuser dengan nama lain.

Saya pikir cara terbaik saat menggunakan bash adalah dengan menggunakan $EUID, dari halaman manual:

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

Ini adalah cara yang lebih baik daripada $UIDyang bisa diubah dan tidak mencerminkan pengguna nyata yang menjalankan skrip.

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

Cara saya mendekati masalah semacam itu adalah dengan menyuntikkan sudoperintah saya ketika tidak dijalankan sebagai root. Berikut ini sebuah contoh:

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

Dengan cara ini perintah saya dijalankan oleh root saat menggunakan superuser atau sudoketika dijalankan oleh pengguna biasa.

Jika skrip Anda selalu dijalankan oleh root, cukup setel hak-haknya ( 0500).

Beberapa jawaban telah diberikan, tetapi tampaknya metode terbaik yang digunakan adalah:

• id -u
• Jika dijalankan sebagai root, akan mengembalikan id 0.

Ini tampaknya lebih dapat diandalkan daripada metode lain, dan tampaknya itu mengembalikan id 0 bahkan jika skrip dijalankan sudo.

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

atau

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

:)

Seperti @wrikken disebutkan dalam komentarnya, id -uadalah pemeriksaan root yang jauh lebih baik.

Selain itu, dengan penggunaan yang benar sudo, Anda dapat meminta skrip memeriksa dan melihat apakah skrip berjalan sebagai root. Jika tidak, minta ingat kembali melalui sudodan kemudian jalankan dengan izin root.

Bergantung pada apa yang dilakukan skrip, opsi lain mungkin untuk mengatur sudoentri untuk perintah khusus apa pun yang mungkin diperlukan skrip.

Ada pemeriksaan sederhana untuk pengguna menjadi root.

The [[ stuff ]]sintaks adalah cara standar menjalankan pemeriksaan di 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

Ini juga mengasumsikan bahwa Anda ingin keluar dengan 1 jika Anda gagal. The errorfungsi beberapa bakat yang set keluaran teks ke merah (tidak diperlukan, tapi cukup berkelas jika Anda bertanya kepada saya).

Cara yang sangat sederhana:

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

Manfaat menggunakan ini alih-alih idadalah Anda dapat memeriksa apakah pengguna non-root tertentu juga menjalankan perintah; misalnya.

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

0- Baca dokumentasi resmi GNU Linux, ada banyak cara untuk melakukannya dengan benar.

1- pastikan Anda meletakkan tanda tangan shell untuk menghindari kesalahan dalam interpretasi:

 #!/bin/bash

2 - ini skrip saya

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

Dalam jawaban ini, biarkan itu menjadi jelas, saya kira pembaca dapat membaca bashdan POSIX shell scripts like dash.

Saya percaya tidak ada banyak yang bisa dijelaskan di sini karena jawaban yang dipilih dengan sangat baik menjelaskan banyak hal.

Namun, jika ada sesuatu untuk dijelaskan lebih lanjut, jangan ragu untuk berkomentar, saya akan melakukan yang terbaik untuk mengisi kekosongan ini.

bashSolusi serba optimal (tidak hanya ) untuk kinerja dan keandalan; semua kerang kompatibel

Solusi baru:

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

Benchmark (simpan ke file 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

Solusi asli:

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

^^^ Solusi striked-out terbukti tidak mempercepat, tetapi sudah ada sejak lama, jadi saya akan menyimpannya di sini selama saya melihat perlu.

Penjelasan

Karena banyak kali lebih cepat untuk membaca variabel $EUIDstandar bash, nomor ID pengguna yang efektif, daripada menjalankan id -uperintah untuk POSIX - hanya menemukan ID pengguna, solusi ini menggabungkan keduanya menjadi fungsi yang dikemas dengan baik. Jika, dan hanya jika, $EUIDkarena alasan apa pun tidak tersedia, id -uperintah akan dieksekusi, memastikan kami mendapatkan nilai pengembalian yang tepat, apa pun kondisinya .

Mengapa saya memposting solusi ini setelah bertahun-tahun OP bertanya

Nah, jika saya melihat dengan benar, sepertinya ada kode yang hilang di atas.

Soalnya, ada banyak variabel yang harus diperhitungkan, dan salah satunya adalah menggabungkan kinerja dan keandalan .

Solusi POSIX portabel + Contoh penggunaan fungsi di atas

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

Kesimpulan

Sebanyak mungkin Anda tidak menyukainya, lingkungan Unix / Linux telah sangat beragam. Berarti ada orang yang bashsangat menyukai, mereka bahkan tidak memikirkan portabilitas ( cangkang POSIX ). Orang lain seperti saya lebih suka kerang POSIX . Sekarang ini masalah pilihan dan kebutuhan pribadi.

Jika skrip benar-benar membutuhkan akses root maka izin file-nya harus mencerminkan itu. Memiliki skrip root yang dapat dieksekusi oleh pengguna non-root akan menjadi bendera merah. Saya mendorong Anda untuk tidak mengontrol akses dengan ifcek.

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

Salah satu cara sederhana untuk membuat skrip hanya dapat dijalankan oleh root adalah memulai skrip dengan baris:

#!/bin/su root

coba kode berikut:

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

ATAU

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

Sejauh yang saya tahu cara yang benar untuk memeriksanya adalah:

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

Lihat bagian "Menguji Root" di sini:

http://linuxcommand.org/lc3_wss0080.php

id -ujauh lebih baik daripada whoami, karena beberapa sistem seperti android mungkin tidak menyediakan kata root.

Contoh:

# 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

Catatan editor: Jika Anda tidak membutuhkan tanda kurung ganda, gunakan tanda kurung tunggal untuk portabilitas kode.

Periksa apakah Anda root dan berhenti jika Anda tidak:

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

Atau dalam contoh ini, cobalah untuk membuat direktori di lokasi root lalu coba setelah hak ditingkatkan.

Periksa apakah Anda root dan jika tidak meningkat jika memungkinkan:

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

Periksa 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

Diuji dan berjalan di root.