Come posso eseguire comandi arbitrariamente complessi usando sudo su ssh?

Ho un sistema a cui posso accedere solo con il mio nome utente (myuser), ma devo eseguire i comandi come altro utente (scriptuser). Finora, ho elaborato quanto segue per eseguire i comandi di cui ho bisogno:

ssh -tq myuser@hostname "sudo -u scriptuser bash -c \"ls -al\""

Se tuttavia, quando provo ad eseguire un comando più complesso, come ad esempio [[ -d "/tmp/Some directory" ]] && rm -rf "/tmp/Some directory"mi metto rapidamente nei guai con la citazione. Non sono sicuro di come potrei passare questo comando di esempio complesso bash -c, quando \"delimita già i limiti del comando che sto passando (e quindi non so come citare / tmp / Some directory, che include uno spazio.

Esiste una soluzione generale che mi consente di passare qualsiasi comando, non importa quanto sia complessa / folle la citazione, o è una sorta di limitazione che ho raggiunto? Esistono altre soluzioni possibili e forse più leggibili?

Un trucco che uso a volte è usare base64 per codificare i comandi e reindirizzarlo per bash sull'altro sito:

MYCOMMAND=$(base64 -w0 script.sh)
ssh user@remotehost "echo $MYCOMMAND | base64 -d | sudo bash"

Questo codificherà lo script, con eventuali virgole, barre rovesciate, virgolette e variabili all'interno di una stringa sicura e lo invierà all'altro server. ( -w0è necessario per disabilitare il ritorno a capo, che si verifica nella colonna 76 per impostazione predefinita). Dall'altro lato, $(base64 -d)decodificherà lo script e lo alimenterà a bash per essere eseguito.

Non ho mai avuto problemi con esso, non importa quanto fosse complessa la sceneggiatura. Risolve il problema con la fuga, perché non è necessario sfuggire a nulla. Non crea un file sull'host remoto e puoi eseguire facilmente script estremamente complicati.

Vedi l' -ttopzione? Leggi il ssh(1)manuale

ssh -tt root@host << EOF
sudo some # sudo shouldn't ask for a password, otherwise, this fails. 
lines
of
code 
but be careful with \$variables
and \$(other) \`stuff\`
exit # <- Important. 
EOF

Una cosa che faccio spesso è usare vim e usare il :!cat % | ssh -tt somemachinetrucco.

Penso che la soluzione più semplice risieda in una modifica del commento di @ thanasisk.

Crea uno script, scpeseguilo sulla macchina, quindi eseguilo.

Avere lo script rmstesso all'inizio. La shell ha aperto il file, quindi è stato caricato e può quindi essere rimosso senza problemi.

Facendo le cose in questo ordine ( rmprima, altre cose secondo) verrà anche rimosso quando fallisce ad un certo punto.

Puoi utilizzare l' %qidentificatore di formato con printfper occuparti della variabile escape per te:

cmd="ls -al"
printf -v cmd_str '%q' "$cmd"
ssh user@host "bash -c $cmd_str"

printf -vscrive l'output in una variabile (in questo caso, $cmd_str). Penso che questo sia il modo più semplice per farlo. Non è necessario trasferire alcun file o codificare la stringa di comando (per quanto mi piaccia il trucco).

Ecco un esempio più complesso che mostra che funziona anche con parentesi quadre e e commerciali:

$ ssh user@host "ls -l test"
-rw-r--r-- 1 tom users 0 Sep  4 21:18 test
$ cmd="[[ -f test ]] && echo 'this really works'"
$ printf -v cmd_str '%q' "$cmd"
$ ssh user@host "bash -c $cmd_str"
this really works

Non l'ho provato con, sudoma dovrebbe essere semplice come:

ssh user@host "sudo -u scriptuser bash -c $cmd_str"

Se lo desideri, puoi saltare un passaggio ed evitare di creare la variabile intermedia:

$ ssh user@host "bash -c $(printf '%q' "$cmd")"
this really works

O anche semplicemente evitare di creare una variabile interamente:

ssh user@host "bash -c $(printf '%q' "[[ -f test ]] && echo 'this works as well'")"

Ecco il modo "corretto" (sintattico) di eseguire qualcosa di simile in bash:

ssh user@server "$( cat <<'EOT'
echo "Variables like '${HOSTNAME}' and commands like $( uname -a )"
echo "will be interpolated on the server, thanks to the single quotes"
echo "around 'EOT' above.
EOT
)"

ssh user@server "$( cat <<EOT
echo "If you want '${HOSTNAME}' and $( uname -a ) to be interpolated"
echo "on the client instead, omit the the single quotes around EOT."
EOT
)"

Per una spiegazione approfondita di come funziona, consultare https://stackoverflow.com/a/21761956/111948

Sai che puoi usare sudoper darti una shell in cui puoi eseguire comandi come l'utente scelto?

-i, --login

Eseguire la shell specificata dalla voce del database delle password dell'utente di destinazione come shell di accesso. Ciò significa che i file di risorse specifici per l'accesso come .profile o .login verranno letti dalla shell. Se viene specificato un comando, viene passato alla shell per l'esecuzione tramite l'opzione -c della shell. Se non viene specificato alcun comando, viene eseguita una shell interattiva. sudo tenta di passare alla home directory dell'utente prima di eseguire la shell. Il comando viene eseguito con un ambiente simile a quello che un utente riceverebbe al momento del login. La sezione Ambiente di comando nei documenti manuali sudoers (5) in che modo l'opzione -i influenza l'ambiente in cui viene eseguito un comando quando la politica sudoers è in uso.

È possibile definire lo script sul computer locale e quindi catinviarlo al computer remoto:

user@host:~/temp> echo "echo 'Test'" > fileForSsh.txt
user@host:~/temp> cat fileForSsh.txt | ssh localhost

Pseudo-terminal will not be allocated because stdin is not a terminal.
stty: standard input: Invalid argument
Test

Semplice e facile.

ssh user @ servidor "bash -s" <script.sh

Se usi una shell Bash sufficientemente moderna, puoi mettere i tuoi comandi in una funzione e stampare quella funzione come stringa usando export -p -f function_name. Il risultato di quella stringa può quindi contenere comandi arbitrari che non devono necessariamente essere eseguiti come root.

Un esempio usando le pipe dalla mia risposta su Unix.SE :

#!/bin/bash
remote_main() {
   local dest="$HOME/destination"

   tar xzv -C "$dest"
   chgrp -R www-data "$dest"
   # Ensure that newly written files have the 'www-data' group too
   find "$dest" -type d -exec chmod g+s {} \;
}
tar cz files/ | ssh user@host "$(declare -pf remote_main); remote_main"

Un esempio che recupera salva il file per l'utente di accesso e installa un programma come root:

remote_main() {
    wget https://example.com/screenrc -O ~/.screenrc
    sudo apt-get update && sudo apt-get install screen
}
ssh user@host "$(declare -pf remote_main); remote_main"

Se si desidera eseguire l'intero comando utilizzando sudo, è possibile utilizzare questo:

remote_main() {
    wget https://example.com/screenrc -O ~user/.screenrc
    apt-get update && apt-get install screen
}
ssh user@host "$(declare -pf remote_main);
    sudo sh -c \"\$(declare -pf remote_main); remote_cmd\""
# Alternatively, if you don't need stdin and do not want to log the command:
ssh user@host "$(declare -pf remote_main);
    (declare -pf remote_main; echo remote_cmd) | sudo sh"

Ecco la mia soluzione scadente (non realmente testata) per questo:

#!/usr/bin/env ruby
# shell-escape: Escape each argument.
ARGV.each do|a|
  print " '#{a.gsub("'","\'\\\\'\'")}' "
end

Non puoi fare:

ssh -tq myuser@hostname "$(shell-escape sudo -u scriptuser bash -c "$(shell-escape ls -al)")"

Il prossimo passo è creare uno bettersshscript che già lo fa:

betterssh -tq myuser@hostname sudo -u scriptuser bash -c "$(shell-escape ls -al)"

Per quelli di voi che hanno bisogno di passare parametri allo script dovrebbe essere il seguente:

ssh user@remotehost "echo `base64 -w0 script.sh` | base64 -d | sudo bash -s <param1> <param2> <paramN>"

Innanzitutto, crea uno script locale e quindi eseguilo in remoto utilizzando il seguente comando:

cat <Local Script.sh> | ssh user@server "cat - | sudo -u <user> /bin/bash"