hoergen - Blog

Der normale Ablauf sich per ssh einzuloggen besteht darin den Befehl abzusetzen und danach den Benutzernamen und das Passwort einzugeben. Das heißt die Verbindung ist immer interaktiv und schliesst damit das Benutzen von scp zeitgesteuert aus. Mit Hilfe von ssh keys kann man das Problem aber lösen.

Hier eine kleine Anleitung mit folgendem Szenario: Ich möchte mich von meinem Notebook auf meinen Server mit Hilfe von ssh keys einloggen:

Notebook
Auf meinem Notebook erzeuge ich mit folgendem Befehl 2 Schlüssel (privat & öffentlich):

ssh-keygen -t rsa

Das Programm fordert nun eine Passworteingabe, die man einfach mit Enter 2x bestätigt, denn sonst muß man später wieder beim Verbindungsaufbau das Passwort eingeben. Danach befinden sich im Verzeichnis ~/.ssh/ 2 Dateien:

• id_rsa privater Schlüssel
• id_rsa.pub öffentlicher Schlüssel

Damit wäre die Arbeit auf meinem Notebook erledigt.

Server
Ich kopiere jetzt die Datei id_rsa.pub auf meinen Server in das Verzeichnis ~/.ssh/ und füge den Schlüssel mithilfe folgendem Befehls der Datei authorized_keys hinzu:

cat id_rsa.pub>>~/.ssh/authorized_keys

Dann versichere ich mich, dass die Datei mir (Benutzer) und meiner Gruppe gehört (bei Kubuntu) hoergen:hoergen (chown). Und schließlich muss die Datei die Rechte 0600 haben.

chmod 0600 ~/.ssh/authorized_keys

Beim nächsten Login werde ich dann nicht mehr nach meinem Passwort gefragt.

Dank gebührt dem Madeagle Kollektiv für die erneute Erinnerung.

Nachtrag: Wenn der Dateitransfer abbricht, üblicherweise bei 80%-90%, kann man leider mit scp kein resume (kein Fortsetzen) des Transfers anstossen. Man müßte die Datei komplett neu übertragen. Eine Lösung wäre der Einsatz eines ssh getunnelten rsync:

rsync –partial –progress –rsh=ssh {source} {destiantion}

Weiterer Nachtrag: Im Netz doch noch ein Script gefunden, das mit einem reinen ssh ohne den Einsatz von rsync ein resume macht:

#!/bin/sh
# Frequently used functions:
# $Id: functions.sh 57 2004-08-07 17:34:19Z taal $

debug() {
level=${1:-"0"}
msg="$2"
if [ "$DEBUG" -ge "$level" ]; then
echo "debug($level): [$msg]"
fi
}

remove_pattern() {
string="$1"
pattern="$2"
var="$3"
result=`echo "$string" | sed -e "s/${pattern}//g"`
eval ${var}=\"$result\"
}

debug_vars() {
for var in "$@"; do
eval contents=\$${var}
echo -n "${var} = [$contents], "
done
echo
}


konsole_title() {
CURDIR=$(pwd | sed -e 's#\(/[^\/]*/[^\/]*\)/.*/\([^\/]*/[^\/]*\)\$#\1...\2#g'); # Prepare nice directory
if [ -n "$SSH_CLIENT" -o -n "$KONSOLE_DCOP" ]; then # If we are in konsole or ssh
echo -e "\e]0; ::: $@ ::: | ${USER} @ ${HOSTNAME} | $CURDIR | \a"; # Set konsole window title
fi
"$@"
}

usage()
{
echo
echo "Usage: `basename $0` -u(pload) \$localfile \$remotefile"
echo " `basename $0` -d(ownload) \$remotefile \$localfile"
echo
echo " \$remotefile should be in the scp format, i.e.: user@host:filename"
echo " and can be user@host: for uploading"
echo
exit 1
}

[ -z "$1" -o -z "$2" -o -z "$3" ] && usage

option=$1
case $option in
-u*|-U*)
localfile=$2
remote=$3

remove_pattern "${remote}" ":.*$" userhost
remove_pattern "${remote}" "^.*:" remotefile

if [ ! -f "$localfile" ]; then
echo "File not found: $localfile"
usage
fi
if [ x"$userhost" = x"$remote" ]; then usage; fi
if [ x"$remotefile" = x"$remote" -o -z "$remotefile" ]; then remotefile=`basename "$localfile"`; fi


echo "Getting size of remote file:"
localsize=`ls -l "${localfile}" | awk '{ print $5 }'`
remotesize=`ssh "$userhost" "[ -f \"${remotefile}\" ] && ls -l \"${remotefile}\"" | awk '{ print $5 }' `

if [ -z "$remotesize" ]; then remotesize=0; fi

if [ $localsize -eq $remotesize ]; then
echo "Local size equals remote size, nothing to transfer."
exit 0;
fi

echo "Resuming upload of '$localfile' at byte $remotesize..."

dd bs=1 skip=$remotesize "if=${localfile}" | \
ssh -C -c arcfour "$userhost" "cat >> \"$remotefile\""

echo "done."
;;
-d*|-D*)
localfile=$3
remote=$2

remove_pattern "${remote}" ":.*$" userhost
remove_pattern "${remote}" "^.*:" remotefile

debug_var localfile remote userhost remotefile

if [ x"$localfile" = x"." ]; then localfile=`basename "$remotefile"`; fi
if [ ! -f "$localfile" ]; then
localsize=0;
else
localsize=`ls -l "${localfile}" | awk '{ print $5 }'`
fi
if [ x"$remotefile" = x"$remote" ]; then usage; fi


if [ -z "$localsize" ]; then localsize=0; fi

echo "Resuming download of '$localfile' at byte $localsize..."
ssh -C -c arcfour "$userhost" "dd bs=1 skip=$localsize \"if=${remotefile}\"" >> $localfile

;;
*)
usage
;;
esac