Comment puis-je exécuter des commandes arbitrairement complexes en utilisant sudo sur ssh?

J'ai un système auquel je ne peux me connecter que sous mon nom d'utilisateur (myuser), mais je dois exécuter des commandes en tant qu'autre utilisateur (scriptuser). Jusqu'ici, je suis venu avec ce qui suit pour exécuter les commandes dont j'ai besoin:

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

Si toutefois, lorsque j'essaie d'exécuter une commande plus complexe, telle que [[ -d "/tmp/Some directory" ]] && rm -rf "/tmp/Some directory"j'ai rapidement des problèmes avec les citations. Je ne sais pas comment je pourrais passer cet exemple de commande complexe à bash -c, alors que \"les limites de la commande que je passe sont déjà délimitées (et que je ne sais donc pas comment citer / tmp / Some directory, qui inclut des espaces.

Existe-t-il une solution générale me permettant de passer n’importe quelle commande, quelle que soit la complexité / folie de la citation, ou s’agit-il d’une limite quelconque que j’ai atteinte? Existe-t-il d'autres solutions possibles et peut-être plus lisibles?

Une astuce que j’utilise parfois est d’utiliser base64 pour encoder les commandes et de la diriger vers bash sur l’autre site:

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

Ceci encodera le script, avec des virgules, des barres obliques inverses, des guillemets et des variables dans une chaîne sécurisée, et l'enverra à l'autre serveur. ( -w0est nécessaire pour désactiver le retour à la ligne, ce qui se produit par défaut à la colonne 76). De l’autre côté, $(base64 -d)décodera le script et le transmettra à bash pour qu’il soit exécuté.

Je n’ai jamais eu de problème, peu importe la complexité du script. Résout le problème de l'évasion, car il n'est pas nécessaire d'échapper à rien. Il ne crée pas de fichier sur l'hôte distant et vous pouvez facilement exécuter des scripts extrêmement complexes.

Voir l' -ttoption? Lire le ssh(1)manuel.

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

Une chose que je fais souvent est d’utiliser vim et le :!cat % | ssh -tt somemachinetruc.

Je pense que la solution la plus simple réside dans une modification du commentaire de @ thanasisk.

Créez un script, scpsur la machine, puis exécutez-le.

Avoir le script rmlui-même au début. Le shell a ouvert le fichier, il a donc été chargé et peut ensuite être supprimé sans problèmes.

En faisant les choses dans cet ordre (le rmpremier, les autres ensuite), il sera même supprimé s'il échoue à un moment donné.

Vous pouvez utiliser le %qspécificateur de format avec printfpour prendre en charge la variable qui s’échappe pour vous:

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

printf -vécrit la sortie dans une variable (dans ce cas, $cmd_str). Je pense que c'est la manière la plus simple de le faire. Il n'est pas nécessaire de transférer des fichiers ou d'encoder la chaîne de commande (autant que j'aime le truc).

Voici un exemple plus complexe montrant que cela fonctionne aussi bien entre crochets et esperluettes:

$ 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

Je ne l'ai pas testé avec sudomais cela devrait être aussi simple que:

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

Si vous le souhaitez, vous pouvez ignorer une étape et éviter de créer la variable intermédiaire:

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

Ou même simplement éviter de créer une variable entièrement:

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

Voici la manière "correcte" (syntaxique) d'exécuter quelque chose comme ceci dans 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
)"

Pour une explication détaillée du fonctionnement de cette procédure, veuillez consulter https://stackoverflow.com/a/21761956/111948.

Êtes-vous conscient que vous pouvez utiliser sudopour vous donner un shell où vous pouvez exécuter des commandes en tant qu'utilisateur choisi?

-i, --login

Exécutez le shell spécifié par l'entrée de la base de données de mots de passe de l'utilisateur cible en tant que shell de connexion. Cela signifie que les fichiers de ressources spécifiques à la connexion, tels que .profile ou .login, seront lus par le shell. Si une commande est spécifiée, elle est transmise au shell pour exécution via l'option -c du shell. Si aucune commande n'est spécifiée, un shell interactif est exécuté. sudo tente de passer au répertoire de base de cet utilisateur avant d'exécuter le shell. La commande est exécutée dans un environnement similaire à celui qu'un utilisateur recevrait lors de la connexion. La section relative à l'environnement de commande dans le manuel de sudoers (5) explique comment l'option -i affecte l'environnement dans lequel une commande est exécutée lorsque la politique sudoers est en cours d'utilisation.

Vous pouvez définir le script sur votre machine locale, puis le catdiriger vers la machine distante:

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

Simple et facile.

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

Si vous utilisez un shell Bash suffisamment moderne, vous pouvez placer vos commandes dans une fonction et l’imprimer sous forme de chaîne export -p -f function_name. Le résultat de cette chaîne peut alors contenir des commandes arbitraires qui ne doivent pas nécessairement être exécutées en tant que root.

Un exemple utilisant les tuyaux de ma réponse sur 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 exemple qui récupère enregistre le fichier pour l'utilisateur connecté et installe un programme racine:

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"

Si vous souhaitez exécuter toute la commande en utilisant sudo, vous pouvez utiliser ceci:

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"

Voici ma solution (pas vraiment testée) pourrie:

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

Non vous pouvez faire:

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

La prochaine étape consiste à créer un bettersshscript qui effectue déjà ceci:

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

Pour ceux qui ont besoin de passer des paramètres au script, cela devrait être comme suit:

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

Commencez par créer un script local, puis exécutez-le à distance à l'aide de la commande suivante:

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