sudo adduser user_a
cat /etc/passwd
#... d'autres utilisateurs listés
user_a:x:1003:1003:,,,:/home/user_a:/bin/bash

aptitude install ssh openssh-client keychain

aptitude install ssh openssh-server

/etc/ssh/ssh_config

/etc/ssh/sshd_config

# trouver et modifier la ligne « Port 22 » comme suit :
Port 222

# s'assurer que cette ligne ne soit pas commentée
# et supprimer le « protocole 1 » s'il apparaît en seconde option
# tel que dans cette ligne : Protocol 2,1
Protocol 2

# S'assurer que l'option est décommentée et réglée sur « No »
PermitRootLogin no

/etc/init.d/ssh stop
/etc/init.d/ssh start
# ou en alternative : /etc/init.d/ssh reload

netstat -na | grep 222
tcp        0      0 0.0.0.0:222          0.0.0.0:*               LISTEN     
tcp6       0      0 :::222               :::*                    LISTEN

#!/bin/sh
# SERVICES «INUTILES»
echo -n "Removing and shutting down unsecure services: "
[[ $(dpkg -l | grep portmap | cut -d" " -f1) = "ii" ]] && aptitude remove portmap && update-rc.d -f portmap remove
update-rc.d -f inetd remove 1>/dev/null
[[ $(dpkg -l | grep ppp | cut -d" " -f1) = "ii" ]] && aptitude remove ppp
[[ $(dpkg -l | grep telnet | cut -d" " -f1) = "ii" ]] && aptitude remove telnet
echo "done"

# PERMISSIONS du compilateur et installateur
echo -n "Removing compile and install rights to others: "
chmod o-x /usr/bin/gcc-4.3
chmod o-x /usr/bin/make
chmod o-x /usr/bin/apt-get
chmod o-x /usr/bin/aptitude
chmod o-x /usr/bin/dpkg
echo "done"

# installer l'utilitaire
aptitude install john

# lancer l'utilitaire sur le fichier des mots de passe
john /etc/shadow

# on se connecte en tant que user_a
su user_a

# on se place dans le répertoire HOME de user_a
cd ~

# on génère le jeu de clés (publique et privée):
ssh-keygen -t dsa

# qui demande la saisie d'une passphrase:
Generating public/private dsa key pair.
Enter file in which to save the key (/home/user_a/.ssh/id_dsa): 
Created directory '/home/user_a/.ssh'.
Enter passphrase (empty for no passphrase): doit être robuste
Enter same passphrase again: 
Your identification has been saved in /home/user_a/.ssh/id_dsa.
Your public key has been saved in /home/user_a/.ssh/id_dsa.pub.
The key fingerprint is:
54:3e:fc:3d:bd:b3:55:bb:2e:ed:78:ed:4c:b3:6c:6e user_a@machineA
The key's randomart image is:
+--[ DSA 1024]----+
|          .      |
|         +       |
|        . +      |
|       .   o . . |
|        S   . o o|
|               .+|
|              .=+|
|             .oEO|
|             .OXo|
+-----------------+

ssh-copy-id -p222 -i ~/.ssh/id_dsa.pub user_b@ip_machine_B

# Copier la clé publique de A vers B
scp -P 222 /home/user_a/.ssh/id_dsa.pub user_b@ip_machineB:~/.ssh

# Ajouter le contenu de la clé publique dans le fichier authorized_keys de la machine B
ssh -p 222 user_b@ip_machineB "cat ~/.ssh/id_dsa.pub >> ~/.ssh/authorized_keys"

# Supprimer la clé publique (celle de la machine A) sur la machine B
ssh -p 222 user_b@ip_machineB "rm ~/.ssh/id_dsa.pub"

# Vérifier en comparant le contenu du fichier authorized_keys de la machine B avec la clé publique de la machine A

# afficher le fichier de la machine B (depuis la machine A)
ssh -p 222 user_b@ip_machineB "cat ~/.ssh/authorized_keys"

# afficher la clé de la machine A 
cat ~/.ssh/id_dsa.pub

# copier le fichier de base ssh_config
sudo cp /etc/ssh/ssh_config /home/user_a/.ssh/ssh_config

# Attribuer cette config ssh à l?utilisateur user_a
sudo chown user_a:user_a /home/user_a/.ssh/ssh_config

# Se connecter en tant que user_a
su user_a

# vider le fichier known_hosts
# (ou supprimer la clé hôte de la machine B si vous avez d'autres
# connexions à maintenir)
> /home/user_a/.ssh/known_hosts

# Editer le fichier de config de l'utilisateur user_a
vim /home/user_a/.ssh/ssh_config

# voilà ce que vous allez conserver :
Host *
CheckHostIP no
StrictHostKeyChecking no
Port 222
Protocol 2
SendEnv LANG LC_*
HashKnownHosts yes
GSSAPIAuthentication yes
GSSAPIDelegateCredentials no

# sortez de l'éditeur en sauvegardant (ESC +:wq!)

# on ajoute l'option -F fichier de config à utiliser par ssh
ssh -p 222 -F /home/user_a/.ssh/ssh_config user_b@ip_machineB

# Si cette option a résolu le problème de connexion, couper la connexion
exit

# et reprenez les étapes précédentes en ajoutant l'option -F
# remarque: notez au passage le "P" majuscule pour le port
scp -P 222 -F /home/user_a/.ssh/ssh_config /home/user_a/.ssh/id_dsa.pub user_b@ip_machineB:~/.ssh

ssh -p 222 -F /home/user_a/.ssh/ssh_config user_b@ip_machineB "cat ~/.ssh/id_dsa.pub >> ~/.ssh/authorized_keys"

# Supprimer la clé publique (celle de la machine A) sur la machine B
ssh -p 222 -F /home/user_a/.ssh/ssh_config user_b@ip_machineB "rm ~/.ssh/id_dsa.pub"

eval $(ssh-agent)
Agent pid 29993

ssh-add ~/.ssh/id_dsa
Enter passphrase for /home/user_a/.ssh/id_dsa: entrez votre passphrase
Identity added: /home/user_a/.ssh/id_dsa

# Intégrons le lancement de keychain au profil de l'utilisateur user_a
MON_PROFIL=~/.bashrc
test -f $MON_PROFIL && echo "profil: ok" || echo "Cherchez le fichier de votre profil svp (dépend de votre distribution)"
echo "# SSH machine A vers machine B" >> $MON_PROFIL
echo "/usr/bin/keychain ~/.ssh/id_dsa" >> $MON_PROFIL
echo "source ~/.keychain/$HOSTNAME-sh >/dev/null" >> $MON_PROFIL

# nota 1: si vous utilisez csh ou fish, adapter avec ceci
# source ~/.keychain/$HOSTNAME-csh >/dev/null
# source ~/.keychain/$HOSTNAME-fish >/dev/null
# nota 2: "source" s'écrit aussi avec un point

# il faut se reconnecter pour que le profil soit pris en considération
exit
su user_a
# entrer la passphrase de votre clé une dernière fois

#!/bin/bash
# mon script de cron

KEYCHAIN_INSTALLED=$(aptitude search keychain | egrep "^i")
[[ ! -z $KEYCHAIN_INSTALLED ]] && [[ -f ~/.keychain/$HOSTNAME-sh ]] && source ~/.keychain/$HOSTNAME-sh
[[ ! -f ~/.keychain/$HOSTNAME-sh ]] && (echo "Backup stopped: keychain problem" | tee -a $LOG) && exit 1

# la suite de votre script avec les commandes utilisant le protocole ssh (ssh, scp ou rsync)
# ...

SSH_PORT_B=222
SSH_PORT_C=222
ssh -A -p $SSH_PORT_B user_b@ip_machineB "ssh -p $SSH_PORT_C user_C@ip_machineC"

aptitude install rsync

su user_b
mkdir ~/backup

#!/bin/bash
# Remote backup machine A to machine B

# SOURCE
SRC=~

# DESTINATION
DEST="user_b@ip_machineB:~/backup"

# EXCLUDED DIRS
EXCLUDED_DIRS="--exclude-from=/etc/rsync.exclude"

# LOG
LOG="/var/log/rsync.log"

# LOG HEADER
DELIMITER="-----------------------\n"
WHEN=$(date "+%F %H:%M:%S")
WHO=$(whoami)
WHAT=$(echo "$0 (PID $$)")
echo -e $DELIMITER $WHEN $WHO $WHAT >> $LOG

# RSYNC OPTIONS
REMOTE_SSH="-e ssh"
OPTIONS="-avrz --stats --force --delete-excluded"

function pls_wait(){
    local count=$1
    local total=$2
    local progress=$(((100*$count/$total)))
    local char="\x08\x08"
    [[ $progress -lt 10 ]] && char="\x08"
    echo -ne "$char$progress%$char"
}

# STARTED
STARTED=$(date "+%s")

# wait for other rsync pid if running
TIMEOUT=300
SLEEP_FREQ=$((TIMEOUT/10))
other_rsync_running=$(ps -ef | grep rsync | grep -v grep)
[[ ! -z $other_rsync_running ]] && \
echo "Other rsync process(es) are running, - pls wait till 100% of $TIMEOUT sec"

while :; do

    other_rsync_running=$(ps -ef | grep rsync | grep -v grep)
    [[ -z $other_rsync_running ]] && echo -e "\nno other rsync running: Ok" && break

    CURRENT=$(date "+%s")
    RUNNING_SINCE=$(( CURRENT - STARTED ))
    [[ "$RUNNING_SINCE" -ge "$TIMEOUT" ]] && \
	echo -e "\nOther rsync's pid running for too long Vs TimeOut $TIMEOUT - process aborted" | tee -a $LOG && \
	exit 1

    pls_wait $RUNNING_SINCE $TIMEOUT

    sleep $SLEEP_FREQ
done

#SSH KEYCHAIN -for user_a-
KEYCHAIN_INSTALLED=$(aptitude search keychain | egrep "^i")
[[ ! -z $KEYCHAIN_INSTALLED ]] && [[ -f ~/.keychain/$HOSTNAME-sh ]] && source ~/.keychain/$HOSTNAME-sh
[[ ! -f ~/.keychain/$HOSTNAME-sh ]] && (echo "Backup stopped: keychain problem" | tee -a $LOG) && exit 1

# RSYNC GLOBAL
echo "Running /usr/bin/rsync $REMOTE_SSH $OPTIONS $EXCLUDED_DIRS $SRC $DEST" | tee -a $LOG
(/usr/bin/rsync $REMOTE_SSH $OPTIONS $EXCLUDED_DIRS $SRC $DEST >> $LOG) &
RET=$(echo $?)

# WAIT
echo -n "Waiting for the rsync pid's end: " | tee -a $LOG
wait
echo "Ok" | tee -a $LOG

# Directory or file PATTERNS contained to be excluded from SRC the copy to DEST
# So these are RELATIVE pathes to the SRC directory
# Warning: if SRC does not contain anymore these directories or files, THEY WILL BE DELETED on DEST


# Les répertoires système exclus
/tmp/
/proc/
/sys/
/dev/
/mnt/
/sys/

# divers
/media/
/lost+found/

# Evidemment auto exclusions
/var/log/rsync.log
/etc/rsync.exclude

# on se connecte en tant qu'utilisateur user_a
su user_a

# on édite la table des tâches de fond (la «crontab»)
crontab -e

# voilà ce qu'on va y insérer
SHELL=/bin/bash
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

# m h dom mon dow usercommand
50 23 * * * user_a test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.daily )

# quitter en sauvegardant (dans mon cas, ESC+:wq ! avec l'éditeur vim)

# vérifier en listant les tâches de fond de l'utilisateur user_a
crontab -l

# Créer les utilisateurs ssh sur A et B
adduser user_a # sur la machine A
adduser user_b # sur la machine B

# Installer les outils sur la machine A
aptitude install ssh openssh-client keychain john

# Installer les outils sur la machine B
aptitude install ssh openssh-server

# Configurer le client ssh (machine A)
vim /etc/ssh/ssh_config

# Configurer le serveur ssh (machine B)
vim /etc/ssh/sshd_config

# Vérifier la "robustesse" de ses mots de passe
john /etc/shadow

# Créer le jeu de clés sur A
ssh-keygen -t dsa

# Copier et autoriser la clé publique de A sur B
ssh-copy-id -p222 -i ~/.ssh/id_dsa.pub user_b@ip_machine_B

# Lancer l'agent ssh sur A
eval $(ssh-agent)
ssh-add ~/.ssh/id_dsa

# Automatiser la connexion de A vers B dans le profil utilisateur
/usr/bin/keychain ~/.ssh/id_dsa
source ~/.keychain/$HOSTNAME-sh >/dev/null