Wie kann ich eine Bash-Funktion mit sudo ausführen?

Ich habe eine Bash-Funktion in einem globalen Bash-Code definiert, für deren Ausführung Root-Rechte erforderlich sind. Wie kann ich es mit sudo ausführen, z sudo myfunction. Standardmäßig gibt es einen Fehler:

sudo: myfunction: befehl nicht gefunden

Luca hat mich freundlich auf diese Frage hingewiesen. Hier ist mein Ansatz: Erweitern Sie die Funktion / den Alias ​​vor dem Aufruf von sudo und übergeben Sie sie vollständig an sudo, ohne dass temporäre Dateien erforderlich sind.

Erklärt hier auf meinem Blog . Es gibt eine Menge Angebotsabwicklung :-)

# Wrap sudo to handle aliases and functions
# Wout.Mertens@gmail.com
#
# Accepts -x as well as regular sudo options: this expands variables as you not root
#
# Comments and improvements welcome
#
# Installing: source this from your .bashrc and set alias sudo=sudowrap
#  You can also wrap it in a script that changes your terminal color, like so:
#  function setclr() {
#   local t=0               
#   SetTerminalStyle $1                
#   shift
#   "$@"
#   t=$?
#   SetTerminalStyle default
#   return $t
#  }
#  alias sudo="setclr sudo sudowrap"
#  If SetTerminalStyle is a program that interfaces with your terminal to set its
#  color.

# Note: This script only handles one layer of aliases/functions.

# If you prefer to call this function sudo, uncomment the following
# line which will make sure it can be called that
#typeset -f sudo >/dev/null && unset sudo

sudowrap () 
{
    local c="" t="" parse=""
    local -a opt
    #parse sudo args
    OPTIND=1
    i=0
    while getopts xVhlLvkKsHPSb:p:c:a:u: t; do
        if [ "$t" = x ]; then
            parse=true
        else
            opt[$i]="-$t"
            let i++
            if [ "$OPTARG" ]; then
                opt[$i]="$OPTARG"
                let i++
            fi
        fi
    done
    shift $(( $OPTIND - 1 ))
    if [ $# -ge 1 ]; then
        c="$1";
        shift;
        case $(type -t "$c") in 
        "")
            echo No such command "$c"
            return 127
            ;;
        alias)
            c="$(type "$c")"
            # Strip "... is aliased to `...'"
            c="${c#*\`}"
            c="${c%\'}"
            ;;
        function)
            c="$(type "$c")"
            # Strip first line
            c="${c#* is a function}"
            c="$c;\"$c\""
            ;;
        *)
            c="\"$c\""
            ;;
        esac
        if [ -n "$parse" ]; then
            # Quote the rest once, so it gets processed by bash.
            # Done this way so variables can get expanded.
            while [ -n "$1" ]; do
                c="$c \"$1\""
                shift
            done
        else
            # Otherwise, quote the arguments. The echo gets an extra
            # space to prevent echo from parsing arguments like -n
            while [ -n "$1" ]; do
                t="${1//\'/\'\\\'\'}"
                c="$c '$t'"
                shift
            done
        fi
        echo sudo "${opt[@]}" -- bash -xvc \""$c"\" >&2
        command sudo "${opt[@]}" bash -xvc "$c"
    else
        echo sudo "${opt[@]}" >&2
        command sudo "${opt[@]}"
    fi
}
# Allow sudowrap to be used in subshells
export -f sudowrap

Der einzige Nachteil dieses Ansatzes besteht darin, dass nur die aufgerufene Funktion erweitert wird, keine zusätzlichen Funktionen, auf die Sie von dort aus verweisen. Kyles Ansatz geht damit wahrscheinlich besser um, wenn Sie auf Funktionen verweisen, die in Ihrem bashrc geladen sind (vorausgesetzt, sie werden beim bash -cAufruf ausgeführt).

Sie können exportIhre Funktion verwenden, um es einer bash -cSubshell oder Skripten zur Verfügung zu stellen, in denen Sie es verwenden möchten.

your_function () { echo 'Hello, World'; }
export -f your_function
bash -c 'your_function'

Bearbeiten

Dies funktioniert für direkte Subshells, leitet aber anscheinend sudokeine Funktionen weiter (nur Variablen). Selbst unter Verwendung von verschiedenen Kombinationen von setenv, env_keepund negiert env_resetnicht zu helfen scheint.

Bearbeiten 2

Allerdings scheint es , dass su tut Unterstützung exportierten Funktionen.

your_function () { echo 'Hello, World'; }
export -f your_function
su -c 'your_function'

Vielleicht können Sie tun:

function meh() {
    sudo -v
    sudo cat /etc/shadow
}

Dies sollte funktionieren und erspart Ihnen die Eingabe von sudo in der Befehlszeile.

Wenn Sie eine Funktion im Kontext eines Sudo aufrufen müssen, möchten Sie Folgendes verwenden declare:

#!/bin/bash

function hello() {
  echo "Hello, $USER"
}

sudo su another_user -c "$(declare -f hello); hello"

Ich würde eine neue Shell ausführen, indem sudo die Shell selbst ausführt, dann wird die Funktion mit root-Rechten ausgeführt. Zum Beispiel so etwas wie:

vim myFunction
#The following three lines go in myFunction file
function mywho {
    sudo whoami
}

sudo bash -c '. /home/kbrandt/myFunction; mywho'
root

Sie können auch dann gehen, um einen Alias ​​für die sudo bashLeitung zu erstellen.

#!/bin/bash

function smth() {
    echo "{{"
    whoami
    echo "}}"
}

if [ $(whoami) != "root" ]; then
    whoami
    echo "i'm not root"
    sudo $0
else
    smth
fi

Wie Legolas in den Kommentaren der Antwort von Dennis Williamson hervorhob, sollten Sie die Antwort von bmargulies auf eine ähnliche Frage lesen, die auf stackoverflow veröffentlicht wurde.

Ausgehend davon habe ich eine Funktion geschrieben, die dieses Thema behandelt und die Idee der Margulies im Grunde verwirklicht.

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
# EXESUDO
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
#
# Purpose:
# -------------------------------------------------------------------- #
# Execute a function with sudo
#
# Params:
# -------------------------------------------------------------------- #
# $1:   string: name of the function to be executed with sudo
#
# Usage:
# -------------------------------------------------------------------- #
# exesudo "funcname" followed by any param
#
# -------------------------------------------------------------------- #
# Created 01 September 2012              Last Modified 02 September 2012

function exesudo ()
{
    ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ##
    #
    # LOCAL VARIABLES:
    #
    ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ##

    #
    # I use underscores to remember it's been passed
    local _funcname_="$1"

    local params=( "$@" )               ## array containing all params passed here
    local tmpfile="/dev/shm/$RANDOM"    ## temporary file
    local filecontent                   ## content of the temporary file
    local regex                         ## regular expression
    local func                          ## function source


    ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ##
    #
    # MAIN CODE:
    #
    ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ##

    #
    # WORKING ON PARAMS:
    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    #
    # Shift the first param (which is the name of the function)
    unset params[0]              ## remove first element
    # params=( "${params[@]}" )     ## repack array


    #
    # WORKING ON THE TEMPORARY FILE:
    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    content="#!/bin/bash\n\n"

    #
    # Write the params array
    content="${content}params=(\n"

    regex="\s+"
    for param in "${params[@]}"
    do
        if [[ "$param" =~ $regex ]]
            then
                content="${content}\t\"${param}\"\n"
            else
                content="${content}\t${param}\n"
        fi
    done

    content="$content)\n"
    echo -e "$content" > "$tmpfile"

    #
    # Append the function source
    echo "#$( type "$_funcname_" )" >> "$tmpfile"

    #
    # Append the call to the function
    echo -e "\n$_funcname_ \"\${params[@]}\"\n" >> "$tmpfile"


    #
    # DONE: EXECUTE THE TEMPORARY FILE WITH SUDO
    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    sudo bash "$tmpfile"
    rm "$tmpfile"
}

Anwendungsbeispiel:
Ausführen des folgenden Snippets

#!/bin/bash

function exesudo ()
{
    # copy here the previous exesudo function !!!
}

test_it_out ()
{
    local params=( "$@" )
    echo "Hello "$( whoami )"!"
    echo "You passed the following params:"
    printf "%s\n" "${params[@]}" ## print array
}

echo "1: calling without sudo"
test_it_out "first" "second"

echo ""
echo "2. calling with sudo"
exesudo test_it_out -n "john done" -s "done"

exit

Wird ausgegeben

1. ohne sudo
   telefonieren Hallo dein Name!
   Sie haben folgende Parameter bestanden:
   erste
   Sekunde
   

2. mit sudo telefonieren
   Hallo root!
   Sie haben die folgenden Parameter übergeben:
   -n
   john done
   -s
   foo
   

Wenn Sie dies in einer Shell verwenden möchten, die eine in Ihrem bashrc definierte Funktion aufruft, müssen Sie die vorherige exesudo-Funktion ebenfalls in dieselbe bashrc- Datei einfügen , wie im Folgenden beschrieben:

function yourfunc ()
{
echo "Hello "$( whoami )"!"
}
export -f yourfunc

function exesudo ()
{
   # copy here
}
export -f exesudo

Dann musst du dich abmelden und wieder einloggen oder benutzen

source ~/.bashrc

Schließlich können Sie exesudo wie folgt verwenden:

$ yourfunc
Hello yourname!

$ exesudo yourfunc
Hello root!