parametry w stylu dd do skryptu bash

Chciałbym przekazać parametry do skryptu bash w stylu dd. Zasadniczo chcę

./script a=1 b=43

mieć taki sam efekt jak

a=1 b=43 ./script

Myślałem, że mogę to osiągnąć za pomocą:

for arg in "$@"; do
   eval "$arg";
done

Jaki jest dobry sposób na zapewnienie evalbezpieczeństwa, tzn. Że "$arg"odpowiada statycznemu (bez wykonywania kodu), przypisaniu zmiennej?

Czy jest na to lepszy sposób? (Chciałbym, żeby to było proste).

Możesz to zrobić w bashu bez eval (i bez sztucznego ucieczki):

for arg in "$@"; do
  if [[ $arg =~ ^[[:alpha:]_][[:alnum:]_]*= ]]; then
    declare +i +a +A "$arg"
  fi
done

Edycja: Na podstawie komentarza Stéphane'a Chazelasa dodałem flagi do deklaracji, aby uniknąć przypisania zmiennej już zadeklarowanej jako zmienna tablicowa lub całkowita, co pozwoli uniknąć szeregu przypadków, w których declarewartość części key=valargumentu będzie oceniana . ( +aSpowoduje błąd, jeśli zmienna, która ma zostać ustawiona, jest już zadeklarowana na przykład jako zmienna tablicowa.) Wszystkie te luki dotyczą użycia tej składni do ponownego przypisania istniejących zmiennych (tablica lub liczba całkowita), które zwykle byłyby dobrze znane zmienne powłoki.

W rzeczywistości jest to tylko przypadek klasy ataków iniekcyjnych, które będą w równym stopniu wpływać na evalrozwiązania oparte na rozwiązaniach: naprawdę byłoby znacznie lepiej zezwolić tylko na znane nazwy argumentów niż na ślepo ustawić dowolną zmienną, która pojawiła się w wierszu poleceń. (Zastanów się, co się stanie, jeśli PATHna przykład wiersz polecenia zostanie ustawiony . Lub zresetuje się, PS1aby uwzględnić ocenę, która nastąpi przy następnym wyświetleniu monitu).

Zamiast używać zmiennych bash, wolałbym użyć tablicy asocjacyjnej nazwanych argumentów, która jest łatwiejsza do ustawienia i znacznie bezpieczniejsza. Alternatywnie może ustawić rzeczywiste zmienne bash, ale tylko wtedy, gdy ich nazwy znajdują się w tablicy asocjacyjnej uzasadnionych argumentów.

Jako przykład tego drugiego podejścia:

# Could use this array for default values, too.
declare -A options=([bs]= [if]= [of]=)
for arg in "$@"; do
  # Make sure that it is an assignment.
  # -v is not an option for many bash versions
  if [[ $arg =~ ^[[:alpha:]_][[:alnum:]_]*= &&
        ${options[${arg%%=*}]+ok} == ok ]]; then
    declare "$arg"
    # or, to put it into the options array
    # options[${arg%%=*}]=${arg#*=}
  fi
done

POSIX jeden (zestawy $<prefix>varzamiast $varproblemów uniknąć specjalnymi zmiennymi podoba IFS/ PATH...):

prefix=my_prefix_
for var do
  case $var in
    (*=*)
       case ${var%%=*} in
         "" | *[!abcdefghijiklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_]*) ;;
         (*) eval "$prefix${var%%=*}="'${var#*=}'
       esac
  esac
done

Nazywany jako myscript x=1 PATH=/tmp/evil %=3 blah '=foo' 1=2, przypisuje:

my_prefix_x <= 1
my_prefix_PATH <= /tmp/evil
my_prefix_1 <= 2

Rozwiązanie lcd047 refaktoryzowane z DD_OPT_prefiksem na stałe :

while [[ $1 =~ ^[[:alpha:]_][[:alnum:]_]*= ]]; do
  eval "DD_OPT_${1%%=*}"='${1#*=}'; shift;
done

frostschutz zasługuje na uznanie za większość refaktoryzacji.

Umieszczam to w pliku źródłowym jako zmienną globalną:

DD_OPTS_PARSE=$(cat <<'EOF'
  while [[ $1 =~ ^[[:alpha:]_][[:alnum:]_]*= ]]; do
    eval "DD_OPT_${1%%=*}"='${1#*=}'; shift;
  done
EOF
)

eval "$DD_OPTS_PARSE" robi całą magię.

Wersja dla funkcji to:

DD_OPTS_PARSE_LOCAL="${PARSE_AND_REMOVE_DD_OPTS/DD_OPT_/local DD_OPT_}"

W użyciu:

eval "$DD_OPTS_PARSE_LOCAL"

Zrobiłem z tego repo , wraz z testami i README.md. Następnie użyłem tego w opakowującym interfejsie API Github API, które pisałem, i użyłem tego samego opakowania, aby skonfigurować klon github wspomnianego repozytorium (ładowanie jest fajne).

Bezpieczne przekazywanie parametrów dla skryptów bash w jednym wierszu. Cieszyć się. :)

Obsługiwana jest klasyczna skorupa Bourne'a, a skorupa Bash i Korn nadal obsługują -kopcję. Gdy ma to zastosowanie, wszelkie „ ddpodobne” opcje polecenia w dowolnym miejscu wiersza poleceń są automatycznie konwertowane na zmienne środowiskowe przekazywane do polecenia:

$ set -k
$ echo a=1 b=2 c=3
$ 

Nieco trudniej jest przekonać, że są to zmienne środowiskowe; uruchomienie tego działa dla mnie:

$ set -k
$ env | grep '^[a-z]='   # No environment a, b, c
$ bash -c 'echo "Args: $*" >&2; env' a=1 b=2 c=3 | grep '^[a-z]='
Args: 
a=1
b=2
c=3
$ set +k
$ bash -c 'echo "Args: $*" >&2; env' a=1 b=2 c=3 | grep '^[a-z]='
Args: b=2 c=3
$

Pierwszy env | greppokazuje brak zmiennych środowiskowych z pojedynczą małą literą. Pierwszy bashpokazuje, że do skryptu nie są przekazywane argumenty -c, a środowisko zawiera trzy jednoliterowe zmienne. set +kAnuluje -ki pokazuje, że ta sama komenda ma teraz argumenty przekazywane do niej. ( a=1Traktowano to jak $0scenariusz; można to również udowodnić za pomocą odpowiedniego echa).

Uzyskuje się to, o co pyta pytanie - pisanie ./script.sh a=1 b=2powinno być takie samo jak pisanie a=1 b=2 ./script.sh.

Pamiętaj, że napotkasz problemy, jeśli wypróbujesz takie sztuczki w skrypcie:

if [ -z "$already_invoked_with_minus_k" ]
then set -k; exec "$0" "$@" already_invoked_with_minus_k=1
fi

"$@"Traktuje dosłownie; nie jest ponownie analizowany w celu znalezienia zmiennych w stylu przypisania (zarówno w, jak bashi ksh). Próbowałem:

#!/bin/bash

echo "BEFORE"
echo "Arguments:"
al "$@"
echo "Environment:"
env | grep -E '^([a-z]|already_invoked_with_minus_k)='
if [ -z "$already_invoked_with_minus_k" ]
then set -k; exec "$0" "$@" already_invoked_with_minus_k=1
fi

echo "AFTER"
echo "Arguments:"
al "$@"
echo "Environment:"
env | grep -E '^([a-z]|already_invoked_with_minus_k)='

unset already_invoked_with_minus_k

i tylko already_invoked_with_minus_kzmienna środowiskowa jest ustawiona w execskrypcie 'd.

Moja próba:

#! /usr/bin/env bash
name='^[a-zA-Z][a-zA-Z0-9_]*$'
count=0
for arg in "$@"; do
    case "$arg" in
        *=*)
            key=${arg%%=*}
            val=${arg#*=}

            [[ "$key" =~ $name ]] && { let count++; eval "$key"=\$val; } || break

            # show time
            if [[ "$key" =~ $name ]]; then
                eval "out=\${$key}"
                printf '|%s| <-- |%s|\n' "$key" "$out"
            fi
            ;;
        *)
            break
            ;;
    esac
done
shift $count

# show time again   
printf 'arg: |%s|\n' "$@"

Działa z (prawie) arbitralnymi śmieciami na RHS:

$ ./assign.sh Foo_Bar33='1 2;3`4"5~6!7@8#9$0 1%2^3&4*5(6)7-8=9+0' '1 2;3`4"5~6!7@8#9$0 1%2^3&4*5(6)7-8=9+0=33'
|Foo_Bar33| <-- |1 2;3`4"5~6!7@8#9$0 1%2^3&4*5(6)7-8=9+0|
arg: |1 2;3`4"5~6!7@8#9$0 1%2^3&4*5(6)7-8=9+0=33|

$ ./assign.sh a=1 b=2 c d=4
|a| <-- |1|
|b| <-- |2|
arg: |c|
arg: |d=4|

Jakiś czas temu zdecydowałem się aliasna tego rodzaju pracę. Oto moja kolejna odpowiedź:

Czasami jednak możliwe jest rozdzielenie oceny i wykonania takich oświadczeń. Na przykład aliasmożna użyć do wstępnej oceny polecenia. W poniższym przykładzie definicja zmiennej jest zapisywana w aliasie, który można pomyślnie zadeklarować tylko wtedy, gdy $varoceniana zmienna nie zawiera bajtów, które nie pasują do znaków alfanumerycznych ASCII lub _.

LC_OLD=$LC_ALL LC_ALL=C
for var do    val=${var#*=} var=${var%%=*}
    alias  "${var##*[!_A-Z0-9a-z]*}=_$var=\$val" &&
    eval   "${var##[0-9]*}" && unalias "$var"
done;       LC_ALL=$LC_OLD

evalsłuży tutaj do obsługi wywoływania nowego aliasz kontekstu cytowanej nazwy zmiennej - nie do przypisania dokładnie. I evalw ogóle wywoływany jest tylko wtedy, gdy poprzednia aliasdefinicja się powiedzie, i chociaż wiem, że wiele różnych implementacji zaakceptuje wiele różnych rodzajów nazw aliasów, nie znalazłem jeszcze powłoki, która zaakceptuje całkowicie pustą .

Definicja w aliasie ma _$varjednak na celu zapewnienie, że żadne znaczące wartości środowiska nie zostaną zapisane. Nie znam żadnych wartych uwagi wartości środowiskowych zaczynających się od _ i zwykle jest to bezpieczny zakład na deklarację półprywatną.

W każdym razie, jeśli definicja aliasu zakończy się powodzeniem, zadeklaruje alias nazwany na $varwartość. I evalwywoła to tylko, aliasjeśli również nie zaczyna się od liczby - w przeciwnym razie evaldostaje tylko zerowy argument. Jeśli więc oba warunki są spełnione, evalwywoływana jest aliasi zapisywana aliasjest definicja zmiennej , po czym nowy alias jest natychmiast usuwany z tabeli skrótów.

W aliastym kontekście przydatne jest również to, że możesz wydrukować swoją pracę. po zapytaniu aliaswydrukuje podwójnie cytowane oświadczenie o bezpiecznej wymianie powłoki .

sh -c "IFS=\'
    alias q=\"\$*\" q" -- \
    some args which alias \
    will print back at us

WYNIK

q='some'"'"'args'"'"'which'"'"'alias'"'"'will'"'"'print'"'"'back'"'"'at'"'"'us'