git - generate - ssh add key mac
Inicie ssh-agent al iniciar sesión (10)
Agregue esto a su ~/.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
Esto solo debería solicitar una contraseña la primera vez que inicie sesión después de cada reinicio. Seguirá reutilizando el ssh-agent mientras siga funcionando.
Tengo un sitio como un repositorio de Git remoto que extrae de Bitbucket.com con un alias de SSH. Puedo iniciar manualmente el ssh-agent en mi servidor, pero tengo que hacer esto cada vez que inicio sesión a través de SSH.
Comienzo manualmente el ssh-agent:
eval ssh-agent $SHELL
Luego agrego el agente:
ssh-add ~/.ssh/bitbucket_id
Luego aparece cuando lo hago:
ssh-add -l
Y estoy listo para irme. ¿Hay alguna forma de automatizar este proceso para que no tenga que hacerlo cada vez que inicie sesión? El servidor ejecuta RedHat 6.2 (Santiago).
En Arch Linux, lo siguiente funciona realmente bien (debería funcionar en todas las distribuciones basadas en systemd):
Cree un servicio de usuario systemd, poniendo lo siguiente en ~/.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
Setup shell para tener una variable de entorno para el socket ( .bash_profile, .zshrc, ... ):
export SSH_AUTH_SOCK="$XDG_RUNTIME_DIR/ssh-agent.socket"
Habilite el servicio, por lo que se iniciará automáticamente al iniciar sesión y lo iniciará:
systemctl --user enable ssh-agent
systemctl --user start ssh-agent
Agregue la siguiente configuración a su archivo de configuración ssh ~/.ssh/config (esto funciona desde SSH 7.2):
AddKeysToAgent yes
Esto le indicará al cliente ssh que siempre agregue la clave a un agente en ejecución, por lo que no es necesario agregarlo de antemano.
Entonces solía usar los enfoques descritos anteriormente, pero prefiero que el agente muera cuando finaliza mi última sesión de bash. Esto es un poco más largo que las otras soluciones, pero es mi enfoque preferido. La idea básica es que la primera sesión bash inicie el ssh-agent. Luego, cada sesión adicional bash comprueba el archivo de configuración ( ~/.ssh/.agent_env ). Si está ahí y hay una sesión ejecutándose, proceda con el entorno y cree un enlace fijo al archivo de socket en /tmp (debe estar en el mismo sistema de archivos que el archivo de socket original). A medida que se cierran las sesiones bash, cada una borra su propio enlace permanente. La última sesión para cerrar encontrará que los enlaces duros tienen 2 enlaces (el enlace fijo y el original), la eliminación del propio socket del proceso y la eliminación del proceso dará como resultado 0, dejando un entorno limpio después de que se cierre la última sesión de bash.
# 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 $2}''`
if [[ "$nhard" -eq 2 ]]; then
rm ~/.ssh/.agent_env
ssh-agent -k
fi
rm $SSH_AUTH_SOCK
}
trap end_agent EXIT
set +x
La solución aceptada tiene los siguientes inconvenientes:
- es complicado de mantener;
- evalúa el archivo de almacenamiento que puede conducir a errores o violación de seguridad;
- inicia el agente pero no lo detiene, lo que equivale a dejar la llave en ignición.
Si sus claves no requieren escribir la contraseña, sugiero seguir la solución. Agregue lo siguiente a su final .bash_profile (edite la lista de claves según sus necesidades):
exec ssh-agent $BASH -s 10<&0 << EOF
ssh-add ~/.ssh/your_key1.rsa /
~/.ssh/your_key2.rsa &> /dev/null
exec $BASH <&10-
EOF
Tiene las siguientes ventajas:
- solución mucho más simple;
- la sesión del agente finaliza cuando termina la sesión de bash.
Tiene posibles desventajas:
- El comando interactivo
ssh-addsolo influirá en una sesión, que de hecho es un problema solo en circunstancias muy atípicas; - inutilizable si se requiere escribir la contraseña;
- shell iniciado se convierte en no iniciar sesión (que no influye en nada AFAIK).
Tenga en cuenta que varios procesos de ssh-agent no son una desventaja, ya que no requieren más memoria o tiempo de CPU.
Lo resolví agregando esto a / etc / profile - system wide (o al usuario local .profile, o .bash_profile).
# SSH-AGENT
#!/usr/bin/env bash
SERVICE=''ssh-agent''
WHOAMI=`who am i |awk ''{print $1}''`
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
Esto inicia un nuevo ssh-agent si no se ejecuta para el usuario, o restablece el parámetro de env de ssh-agent si se está ejecutando.
Me gustan mucho tus respuestas. Hizo mucho más fácil trabajar desde hosts cygwin / linux . Combiné las funciones de inicio y fin para asegurarlo.
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 $2}''`
if [[ "$nhard" -eq 2 ]]; then
rm ${SSH_ENV}
/usr/bin/ssh-agent -k
fi
rm $SSH_AUTH_SOCK
}
trap end_agent EXIT
set +x
gracias de nuevo
Perdón por llegar tan tarde:
Los usuarios de la concha de pez pueden usar esta script de script para hacer lo mismo.
# 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
Por favor revisa este artículo. Puede encontrar esto muy útil:
http://mah.everybody.org/docs/ssh
En caso de que el enlace de arriba desaparezca algún día, estoy capturando la pieza principal de la solución a continuación:
Esta solución de Joseph M. Reagle por medio de Daniel Starin:
Agregue esto siguiente a su
.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
Esta versión es especialmente buena ya que verá si ya ha iniciado ssh-agent y, si no puede encontrarlo, lo iniciará y almacenará las configuraciones para que puedan ser utilizadas la próxima vez que inicie una cáscara.
Solo para agregar otra solución: P, fui con una combinación de las soluciones de @spheenik y @ collin-anderson.
# 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
Podría ser un poco más elegante pero simple y legible. Esta solución:
- asegura que
AddKeysToAgent yesestá en su configuración de ssh así que las claves se agregarán automáticamente al usarlas - no le solicita que ingrese ninguna frase de contraseña al iniciar sesión (de nuevo, la contraseña de una sola vez ingresa al primer uso)
- inicia silenciosamente un ssh-agent si aún no ha comenzado uno
Comentarios bienvenidos :)
Una vieja pregunta, pero encontré una situación similar. No piense que la respuesta anterior logra completamente lo que se necesita. La pieza faltante es keychain ; instálalo si aún no lo está.
sudo apt-get install keychain
A continuación, agregue la siguiente línea a su ~/.bashrc
eval $(keychain --eval id_rsa)
Esto iniciará el ssh-agent si no se está ejecutando, conéctese si lo hace, cargue las variables de entorno ssh-agent en su shell y cargue su clave ssh.
Cambia id_rsa a cualquier clave privada en ~/.ssh que quieras cargar.
Referencia