Démarrer ssh-agent à l'ouverture de session
j'ai un site comme un git repo à distance Bitbucket.com utilisant un alias SSH. Je peux démarrer manuellement l'agent ssh sur mon serveur mais je dois le faire chaque fois que je me connecte via SSH.
je démarre manuellement l'agent ssh:
eval ssh-agent $SHELL
puis j'ajoute l'agent:
ssh-add ~/.ssh/bitbucket_id
puis il apparaît quand je le fais:
ssh-add -l
et je peux y aller. Est-il possible d'automatiser ce processus de sorte que je n'avez pas à faire à chaque fois je me connecter? Le serveur lance RedHat 6.2 (Santiago).
10 réponses
s'il vous Plaît aller à travers cet article. Vous pouvez trouver cela très utile:
http://mah.everybody.org/docs/ssh
juste au cas où le lien ci-dessus disparaît un jour, je capture la pièce principale de la solution ci-dessous:
cette solution de Joseph M. Reagle en passant par Daniel Starin:
ajouter ce qui suit à votre
.bash_profile
SSH_ENV="$HOME/.ssh/environment"
function start_agent {
echo "Initialising new SSH agent..."
/usr/bin/ssh-agent | sed 's/^echo/#echo/' > "${SSH_ENV}"
echo succeeded
chmod 600 "${SSH_ENV}"
. "${SSH_ENV}" > /dev/null
/usr/bin/ssh-add;
}
# Source SSH settings, if applicable
if [ -f "${SSH_ENV}" ]; then
. "${SSH_ENV}" > /dev/null
#ps ${SSH_AGENT_PID} doesn't work under cywgin
ps -ef | grep ${SSH_AGENT_PID} | grep ssh-agent$ > /dev/null || {
start_agent;
}
else
start_agent;
fi
cette version est particulièrement agréable car elle va voir si vous avez déjà démarré ssh-agent et, si elle ne peut pas le trouver, va le démarrer et stocker les paramètres afin qu'ils soient utilisables La prochaine fois que vous démarrez un shell.
sur Arch Linux, les travaux suivants vraiment grand (devrait fonctionner sur tous les systèmes basés distros):
créer un service d'utilisateur systemd, en mettant ce qui suit à ~/.config/systemd/user/ssh-agent.service
:
[Unit]
Description=SSH key agent
[Service]
Type=forking
Environment=SSH_AUTH_SOCK=%t/ssh-agent.socket
ExecStart=/usr/bin/ssh-agent -a $SSH_AUTH_SOCK
[Install]
WantedBy=default.target
Configuration du shell d'avoir une variable d'environnement pour le socket ( .bash_profile, .zshrc, ...
):
export SSH_AUTH_SOCK="$XDG_RUNTIME_DIR/ssh-agent.socket"
activer le service, il sera donc lancé automatiquement lors de la connexion, et le démarrer:
systemctl --user enable ssh-agent
systemctl --user start ssh-agent
ajouter le suivant la configuration de votre fichier de configuration ssh ~/.ssh/config
(cela fonctionne depuis ssh 7.2):
AddKeysToAgent yes
Cela donnera l'instruction au client ssh de toujours ajouter la clé à un agent courant, donc il n'est pas nécessaire de l'ajouter à l'avance.
la solution acceptée présente les inconvénients suivants:"
- c'est compliqué à maintenir;
- il évalue le fichier de stockage qui peut entraîner des erreurs ou une atteinte à la sécurité;
- il démarre l'agent mais ne l'arrête pas, ce qui équivaut à laisser la clé allumée.
si vos clés ne nécessitent pas de mot de passe, je suggère la solution suivante. Ajouter ce qui suit à votre .bash_profile
very end (Modifiez la liste des touches à vos besoins):
exec ssh-agent $BASH -s 10<&0 << EOF
ssh-add ~/.ssh/your_key1.rsa \
~/.ssh/your_key2.rsa &> /dev/null
exec $BASH <&10-
EOF
il a les avantages suivants:"
- solution beaucoup plus simple;
- la session agent se termine à la fin de la session bash.
Il en avoir les inconvénients possibles:
- interactive
ssh-add
la commande n'influencera qu'une seule session, ce qui est en fait un problème circonstances très atypiques; - inutilisable si un mot de passe est requis;
- shell démarré devient non-login (ce qui n'influence rien AFAIK).
notez que plusieurs processus ssh-agent
ne sont pas un inconvénient, car ils ne prennent pas plus de mémoire ou de temps CPU.
question ancienne, mais j'ai rencontré une situation similaire. Ne pensez pas que la réponse ci-dessus atteint pleinement ce qui est nécessaire. La pièce manquante est keychain
; installez-la si elle ne l'est pas déjà.
sudo apt-get install keychain
ajouter la ligne suivante à votre ~/.bashrc
eval $(keychain --eval id_rsa)
cela lancera le ssh-agent
s'il ne tourne pas, connectez-le s'il l'est, chargez les variables d'environnement ssh-agent
dans votre shell, et chargez votre clé SSH.
changer id_rsa
à la clé privée dans ~/.ssh
que vous voulez charger.
référence
ajoutez ceci à votre ~/.bashrc
:
if [ ! -S ~/.ssh/ssh_auth_sock ]; then
eval `ssh-agent`
ln -sf "$SSH_AUTH_SOCK" ~/.ssh/ssh_auth_sock
fi
export SSH_AUTH_SOCK=~/.ssh/ssh_auth_sock
ssh-add -l | grep "The agent has no identities" && ssh-add
ceci ne devrait vous demander un mot de passe que la première fois que vous vous connectez après chaque redémarrage. Il va continuer à réutiliser le ssh-agent
tant qu'il reste en marche.
donc j'avais l'habitude d'utiliser les approches décrites ci-dessus, mais je préfère en quelque sorte que l'agent meure quand ma dernière séance de bash se termine. C'est un peu plus long que les autres solutions, mais ses mon approche préférée. L'idée de base est que la première session de bash démarre l'agent ssh. Ensuite chaque session de bash supplémentaire vérifie pour le fichier de configuration ( ~/.ssh/.agent_env
). Si c'est là et qu'il y a une session en cours d'exécution, puis source l'environnement et créer un lien dur vers le fichier socket en /tmp
(doit être sur le même système de fichiers que le fichier socket original). Quand les sessions de bash s'arrêtent, chacun supprime son propre lien dur. La dernière session à fermer verra que les liens durs ont 2 liens (le lien dur et l'original), la suppression de la propre socket des processus et la destruction du processus aboutira à 0, laissant un environnement propre après la dernière session de bash ferme.
# Start ssh-agent to keep you logged in with keys, use `ssh-add` to log in
agent=`pgrep ssh-agent -u $USER` # get only your agents
if [[ "$agent" == "" || ! -e ~/.ssh/.agent_env ]]; then
# if no agents or environment file is missing create a new one
# remove old agents / environment variable files
kill $agent running
rm ~/.ssh/.agent_env
# restart
eval `ssh-agent`
echo 'export SSH_AUTH_SOCK'=$SSH_AUTH_SOCK >> ~/.ssh/.agent_env
echo 'export SSH_AGENT_PID'=$SSH_AGENT_PID >> ~/.ssh/.agent_env
fi
# create our own hardlink to the socket (with random name)
source ~/.ssh/.agent_env
MYSOCK=/tmp/ssh_agent.${RANDOM}.sock
ln -T $SSH_AUTH_SOCK $MYSOCK
export SSH_AUTH_SOCK=$MYSOCK
end_agent()
{
# if we are the last holder of a hardlink, then kill the agent
nhard=`ls -l $SSH_AUTH_SOCK | awk '{print }'`
if [[ "$nhard" -eq 2 ]]; then
rm ~/.ssh/.agent_env
ssh-agent -k
fi
rm $SSH_AUTH_SOCK
}
trap end_agent EXIT
set +x
Désolé d'être si en retard:
les utilisateurs du Fish shell peuvent utiliser ce script pour faire la même chose.
# content has to be in .config/fish/config.fish
# if it does not exist, create the file
setenv SSH_ENV $HOME/.ssh/environment
function start_agent
echo "Initializing new SSH agent ..."
ssh-agent -c | sed 's/^echo/#echo/' > $SSH_ENV
echo "succeeded"
chmod 600 $SSH_ENV
. $SSH_ENV > /dev/null
ssh-add
end
function test_identities
ssh-add -l | grep "The agent has no identities" > /dev/null
if [ $status -eq 0 ]
ssh-add
if [ $status -eq 2 ]
start_agent
end
end
end
if [ -n "$SSH_AGENT_PID" ]
ps -ef | grep $SSH_AGENT_PID | grep ssh-agent > /dev/null
if [ $status -eq 0 ]
test_identities
end
else
if [ -f $SSH_ENV ]
. $SSH_ENV > /dev/null
end
ps -ef | grep $SSH_AGENT_PID | grep -v grep | grep ssh-agent > /dev/null
if [ $status -eq 0 ]
test_identities
else
start_agent
end
end
juste pour ajouter une autre solution :P, je suis allé avec une combinaison de @spheenik et @collin-anderson 's solutions.
# Ensure that we have an ssh config with AddKeysToAgent set to true
if [ ! -f ~/.ssh/config ] || ! cat ~/.ssh/config | grep AddKeysToAgent | grep yes > /dev/null; then
echo "AddKeysToAgent yes" >> ~/.ssh/config
fi
# Ensure a ssh-agent is running so you only have to enter keys once
if [ ! -S ~/.ssh/ssh_auth_sock ]; then
eval `ssh-agent`
ln -sf "$SSH_AUTH_SOCK" ~/.ssh/ssh_auth_sock
fi
export SSH_AUTH_SOCK=~/.ssh/ssh_auth_sock
Pourrait être un peu plus élégant, mais simple et lisible. Cette solution:
- assure que
AddKeysToAgent yes
est dans votre configuration ssh de sorte que les clés seront automatiquement ajoutées lors de l'utilisation - ne vous invite pas à entrer de phrase de passe lors de la connexion (encore une fois, la saisie de phrase de passe unique se produit le première utilisation)
- commence silencieusement un ssh-agent si elle n'a pas déjà commencé un
les Commentaires sont les bienvenus :)
Je l'ai résolu en ajoutant ceci au /etc/profile - system wide (ou à l'utilisateur local .de profil, ou .bash_profile).
# SSH-AGENT
#!/usr/bin/env bash
SERVICE='ssh-agent'
WHOAMI=`who am i |awk '{print }'`
if pgrep -u $WHOAMI $SERVICE >/dev/null
then
echo $SERVICE running.
else
echo $SERVICE not running.
echo starting
ssh-agent > ~/.ssh/agent_env
fi
. ~/.ssh/agent_env
démarre un nouveau ssh-agent s'il n'est pas exécuté pour user, ou réinitialise le paramètre env ssh-agent s'il est exécuté.
comme vos réponses. Il a rendu le travail de cygwin / linux
hôtes beaucoup plus facile. J'ai combiné les fonctions de début et de fin pour le rendre sûr.
SSH_ENV="$HOME/.ssh/.agent_env"
function start_agent {
echo "Initialising new SSH agent..."
eval `/usr/bin/ssh-agent`
echo 'export SSH_AUTH_SOCK'=$SSH_AUTH_SOCK >> ${SSH_ENV}
echo 'export SSH_AGENT_PID'=$SSH_AGENT_PID >> ${SSH_ENV}
echo succeeded
chmod 600 "${SSH_ENV}"
. "${SSH_ENV}" > /dev/null
/usr/bin/ssh-add;
}
# Source SSH settings, if applicable
if [ -f "${SSH_ENV}" ]; then
. "${SSH_ENV}" > /dev/null
#ps ${SSH_AGENT_PID} doesn't work under cywgin
ps -ef | grep ${SSH_AGENT_PID} | grep ssh-agent$ > /dev/null || {
start_agent;
}
else
start_agent;
fi
# create our own hardlink to the socket (with random name)
MYSOCK=/tmp/ssh_agent.${RANDOM}.sock
ln -T $SSH_AUTH_SOCK $MYSOCK
export SSH_AUTH_SOCK=$MYSOCK
end_agent()
{
# if we are the last holder of a hardlink, then kill the agent
nhard=`ls -l $SSH_AUTH_SOCK | awk '{print }'`
if [[ "$nhard" -eq 2 ]]; then
rm ${SSH_ENV}
/usr/bin/ssh-agent -k
fi
rm $SSH_AUTH_SOCK
}
trap end_agent EXIT
set +x
merci encore