SSH

SSH + SFTP
SSH, également connu sous le nom de Secure Shell ou Secure Socket Shell, est un protocole
réseau qui offre aux utilisateurs, en particulier aux administrateurs système, un moyen sécurisé
d'accéder à un ordinateur via un réseau non sécurisé. SSH fait également référence à la suite
d'utilitaires qui implémentent le protocole SSH. Secure Shell fournit une authentification forte
et des communications de données cryptées entre deux ordinateurs se connectant sur un réseau
ouvert tel qu'Internet. SSH est largement utilisé par les administrateurs réseau pour gérer les
systèmes et les applications à distance, leur permettant de se connecter à un autre ordinateur
via un réseau, d'exécuter des commandes et de déplacer des fichiers d'un ordinateur à un autre.
SSH fait référence à la fois au protocole réseau cryptographique et à la suite d'utilitaires qui
implémentent ce protocole. SSH utilise le modèle client-serveur, connectant une application
client shell sécurisée, la fin à laquelle la session est affichée, avec un serveur SSH, la fin à laquelle
la session tourne. Les implémentations SSH incluent souvent le support des protocoles
d'application utilisés pour l'émulation de terminal ou les transferts de fichiers. SSH peut
également être utilisé pour créer des tunnels sécurisés pour d'autres protocoles d'application,
par exemple, pour exécuter des sessions graphiques du système X Window à distance en toute
sécurité. Un serveur SSH, par défaut, écoute sur le port standard 22 du protocole TCP
(Transmission Control Protocol).

Bien qu'il soit possible d'utiliser SSH avec un nom d'utilisateur et un mot de passe ordinaires
comme identifiants, SSH utilise plus souvent des paires de clés publiques pour authentifier les
hôtes entre eux. Les utilisateurs individuels doivent toujours utiliser leur nom d'utilisateur et
leur mot de passe (ou d'autres méthodes d'authentification) pour se connecter à l'hôte distant
lui-même, mais la machine locale et la machine distante s'authentifient séparément les unes des
autres. Une seule session nécessite deux paires de clés publiques : une paire de clés publiques
pour authentifier la machine distante sur la machine locale et une seconde paire de clés
publiques pour authentifier la machine locale sur la machine distante.
Les connexions SSH ont été utilisées pour sécuriser différents types de communications entre
une machine locale et un hôte distant, y compris l'accès distant sécurisé aux ressources,
l'exécution à distance des commandes, la livraison des correctifs et mises à jour logiciels et
autres tâches administratives ou de gestion.
Les fonctions que SSH active incluent :

• Accès à distance sécurisé aux systèmes ou périphériques réseau compatibles SSH, aussi
bien pour les utilisateurs que pour les processus automatisés ;
• des sessions de transfert de fichiers sécurisées et interactives ;
• des transferts de fichiers automatisés et sécurisés ;
• l'émission sécurisée de commandes sur des dispositifs ou des systèmes distants
• la gestion sécurisée des composants de l'infrastructure réseau.

SSH peut être utilisé de manière interactive pour activer les sessions terminal et devrait être
utilisé à la place du programme Telnet moins sécurisé. SSH est également couramment utilisé
dans les scripts et autres logiciels pour permettre aux programmes et systèmes d'accéder à
distance et en toute sécurité aux données et autres ressources.

Https://doc.ubuntu-fr.org/ssh#installation_du_serveur_ssh

Tuto SSH + SFTP

Dans cet exemple, deux machines :
NGUX = 192.168.0.24
Njimx = 192.168.0.23

instal de open-ssh-server
sudo apt install openssh-server
en fait le mieux est de faire sur les deux machines pour pouvoir les faire dans les deux
sens

Si Vous Avez Activé UFW

Sur ngux on fait des règles de pare-feu pour laisser passer njimx
ngux@ngux-pc:~$ sudo ufw verbose
[sudo] password for ngux:
Status: active
To Action From
-- ------ ----
Samba ALLOW Anywhere
Samba (v6) ALLOW Anywhere (v6)
ngux@ngux-pc:~$ sudo ufw allow from 192.168.0.23
Rule added
ngux@ngux-pc:~$ sudo ufw allow 22
Rule added
Rule added (v6)
ngux@ngux-pc:~$ sudo ufw verbose
Status: active
To Action From
-- ------ ----
Samba ALLOW Anywhere
Anywhere ALLOW 192.168.0.23
22 ALLOW Anywhere
Samba (v6) ALLOW Anywhere (v6)
22 (v6) ALLOW Anywhere (v6)

sur njimx ont connecte avec ngux

:~$ ssh ngux@192.168.0.24 -p 22
exit pour fermer

sur la machine njimx pour aller dans un dossier

Ouvrir une fenêtre quelconque de Fichiers (Nautilus) [Ctrl + l] et copie de l'adresse qui vient de
s'ouvrir en haut
sftp://ngux@192.168.0.24/home/ngux/NguxPart
tester cette ligne de commande :
$ for ip in $(seq 1 254); do ping -c 1
192.168.5.$ip>/dev/null; [ $? -eq 0 ] && echo
"192.168.5.$ip est en ligne" || : ; done
192.168.5.1 est en ligne
192.168.5.5 est en ligne
192.168.5.102 est en ligne
192.168.5.103 est en ligne
192.168.5.105 est en ligne

Pour Copier Entre Deux Ordis  :

/!\ il ne fait pas de commande "echo" dans le .bashrc

• Copie d’un fichier d’une machine serveur1(IP) vers une autre machine
serveur2(IP):
> scp Login1@Serveur1:Chemin1/NomFichier1
Login2@Serveur2:Chemin2/NomFichier2
• Copie d’un fichier depuis le répertoire courant vers un répertoire du serveur:
> scp Fichier login@serveur:Chemin
• Copie d’un répertoire, avec éventuellement ses sous-répertoires, vers un
répertoire du serveur:
> scp -r Repertoire login@serveur:Chemin
• Copie d’un fichier du serveur vers le répertoire courant:
> scp login@serveur:Chemin/Fichier .
• Copie d’un répertoire du serveur vers un rep local:
> scp -r -p utilisateur@adressip:le/chemin/de/la/source
/le/chemin/du/destinataire
• -r # récursive
-p # préserves les attributs du fichier original
• Copie de plusieurs fichiers
> scp -T ngu@10.40.10.150:/home/ngu/"aa.txt bb.txt
dpkg.log.OLD" .

Utiliser SFTP
/!\ il ne faut pas de commande "echo" dans le .bashrc

sftp utilisateur@adressip
sftp> ?
> ls #on remote
> lls #on local
> cd #on remote
> lcd #on local
> mkdir #on remote
> lmkdir #on local
> ! # retour au local
> exit # retour au remote

Télécharger Avec SFTP (download):

> get <fichierDistant> <dossierLocal>
> mget *.pdf #pour plusieurs fichiers
Téléverser Avec SFTP (upload)
> put <dossierLocal> <fichierDistant> # le fichier distant peut
être nomé pareil que le dossier local.
> mput *.pdf #pour plusieurs fichiers

SFTP Avec Sudo

sftp -s "sudo /usr/lib/openssh/sftp-server" targethost.fqdn

TP usage SSH:

1. Sur le client, préparer :

1. Dans votre dossier utilisateur créer un dossier tpSSHc
2. Entrer dans ce dossier et n'en sortez plus jusqu'à la fin de l'exercice
3. créer 4 fichiers en .txt (a.txt, b.txt, c.txt, d.txt)
4. créer 2 fichiers en .md (x.md, y.md)
5. Chercher le plus gros fichier de log existant dans le dossier habituellement réservé
aux logs
6. Copier ce fichier dans votre dossier tpSSHc en le renommant fatLog
2. Accéder au serveur en utilisant son user (pas en root)
1. Dans le dossier utilisateur, créer un dossier tpSSHs
3. déconnectez-vous du serveur
4. Copier le fichier fatLog dans le dossier tpSSHs (sur le serveur)
5. Copier les 4 fichiers .txt dans le dossier tpSSHs en une seule commande
6. Connectez vous au serveur avec sftp
7. Afficher les commande disponibles de sftp
8. Transferer le fichier x.md du client au serveur avec sftp
9. Sans clore la connexion sftp :
1. Retourner dans le client
2. créer un nouveau fichier z.md
3. sortez du client pour revenir dans le serveur
10. Effacer le fichier x.md dans le serveur (toujours en connexion sftp, le prompt reste
"sftp>")
11. Televerser les 3 fichiers .md en une fois du client au serveur
12. Lister tous les fichiers du client en une seule commande (sans retourner dans le client, le
prompt reste "sftp>")
13. Effacer tous les fichiers du client en une seule commande (sans retourner dans le client, le
prompt reste "sftp>")
14. Télécharger le dossier tpSSHs dans tpSSHc (une commande)
15. Vérifier l'existance du dossier tpSSHs sur le client (sans sortir de sftp ni retourner dans le
client, le prompt reste "sftp>")
16. Vérifiez l'existance des fichiser dans le dossier tpSSHs sur le client (sans sortir de sftp ni
retourner dans le client, le prompt reste "sftp>")
17. Effacer le dossier tpSSHs (et son contennu) sur le serveur en 2 commandes
18. Vérifiez
19. Déconnectez-vous du serveur

---Le scp--- (5)

scp *.txt ngu-ser:~/tpSSHs #ou ngu@10.40.10.144:~/tpSSHs
---Le sftp---
put x.md tpSSHs
rm x.md
mput /home/ngu/tpSSHc/*.md tpSSHs
lls
!rm *
lls
ls
get -r tpSSHs/ .
lls
lls /tpSSHs
rm tpSSHs/*
rmdir tpSSHs

Productivité  SSH :
L'un des plus importants boosters de productivité lorsque vous utilisez SSH, est de configurer
une configuration qui mémorise tous vos paramètres de connexion dans le fichier'~/.ssh/config'.
Si vous n'avez pas déjà un de ces fichiers, vous pouvez le créer. Le but de ce fichier est qu'au lieu
de taper ça à chaque fois :
ssh robert@192.168.0.123 -p 1800 -i ~/.ssh/my_private_key

   Vous pouvez taper à la place :

ssh robert-server

Tant que vous avez dans le fichier '~/.ssh/config' du client l’entrée suivante :
Host robert-server
HostName 192.168.0.123
Port 1800
User robert
IdentityFile ~/.ssh/my_private_key

Ouvrir Une Application GUI En SSH (dans Le Remote)

Log into a remote machine using SSH:

$ ssh 192.168.1.100
Tell GUI applications to be launched on the local screen (so, any graphical program that you run,
will be displayed on the remote computer’s screen):
$ export DISPLAY=:0
Execute GUI Program. For, example lets start Firefox browser that will be launched and
displayed on the remote machine’s screen in which we logged in:
$ firefox "www.shellhacks.com"
Use nohup to prevent a process from being stopped after closing SSH session:

$ nohup firefox "www.shellhacks.com"

Autres Exemples
Send a pop-up notification (notify-send) that will be shown on the remote computer’s screen:
$ ssh 192.168.0.100 'DISPLAY=:0 nohup notify-send "Hello" "World"'
Start a music player (rhythmbox) on the remote computer:
$ ssh 192.168.0.100 'DISPLAY=:0 nohup rhythmbox ./Smoke-on-the-
Water.mp3'
sometimes you want to do the opposite and run the X app locally just
connect using -Y and then run your app ssh -Y <remoteip>

SSH  : OUVRIR UNE APP DISTANTE SUR ÉCRAN LOCAL

$ ssh -XC user@IP-ADDRESS
si les paquets ne sont pas installés mettre les gestionnaires de fenètres
$ sudo apt install xauth # Debian/Ubuntu
$ sudo yum install xorg-x11-xauth # CentOS
et redémarrer sshd
$ sudo systemctl restart sshd
se déconnecter et se reconnecter
$ echo $DISPLAY
localhost:10.0
installons un truc simple comme une montre et mettons là à l'écran (local)
$ sudo apt install x11-apps # Debian/Ubuntu
$ sudo yum install x11-apps # CentOS
$ xclock ou autre

OUVRIR UN BUREAU DISTANT SUR ÉCRAN LOCAL

Installation d'un bureau léger : XFCE qui demande peu de ressources (1,2 Go)
Tuto : https://linuxize.com/post/how-to-install-xrdp-on-debian-10/
Bug : https://unix.stackexchange.com/questions/523152/xrdp-disconnects-immediately-after-
connection-from-windows10-centos-to-centos7

Debian/Ubuntu
$ sudo touch /dev/fuse
$ sudo apt install xfce4 xfce4-goodies gnome-icon-theme
$ sudo apt install xfce4 xfce4-goodies xorg dbus-x11 x11-xserver-
utils
$ sudo apt install xrdp
$ sudo systemctl status xrdp
$ sudo systemctl stop xrdp
$ sudo adduser xrdp ssl-cert
$ sudo systemctl restart xrdp
Assuming you use ufw to manage the firewall, run the following
command to allow access to the Xrdp server from a specific IP
address or IP range, in this example 192.168.1.0/24:
$ sudo ufw allow from 192.168.1.0/24 to any port 3389
If you want to allow access from anywhere (which is highly discouraged for security
reasons) run:
$ sudo ufw allow 3389

Connecter par RDP à l'adresse du serveur :

ou bien
si bug à l'ouverture alors :
$ sudo service xrdp stop
éditer :
$ sudo nano /etc/xrdp/startwm.sh
commenter les lignes :
test -x /etc/X11/Xsession && exec /etc/X11/Xsession
exec /bin/sh /etc/X11/Xsession
ajouter
startxfce4
Résultat à obtenir :

Une fois le bureau installé

$ xfce4-session

via VNC et non seulement VPS il faut installer un server VNC sur le VPS

$ sudo apt-get install tightvncserver # Debian/Ubuntu

$ sudo yum install tigervnc-server # CentOS

La première fois avant d'utiliser le serveur VNC lui-même il faudra créer un password

$ vncserver :1 -geometry 800x600 -depth 24

You will require a password to access your desktops.
Password:
Verify:
xauth: file /home/user/.Xauthority does not exist
New 'user:1 (user)' desktop is hostname:1
Creating default startup script /home/user/.vnc/xstartup
Starting applications specified in /home/user/.vnc/xstartup
Log file is /home/user/.vnc/hostname:1.log
Finally, start up your favorite VNC client. A number of options exist depending on your operating
system:

• Vinagre [Linux]
• Real VNC [Windows/OS X/Linux/iOS/Android]
• TightVNC [Windows/OS X/Linux]
• TigerVNC [Linux/Windows/OS X]
Connect to your VNC server by appending :1 to the IP address of your VPS. You’ll have access to
the full desktop!
Note: The default VNC server isn’t very secure, and creates another potential attack vector. Be
sure to check out the resources below for more information about securing your VNC server.

SSH SUR AWS

SSH SUR RAPSBERRYPI  : 192.168.0.36
SSH SUR WINDOWS
Mise à jour : Le client SSH intégré est maintenant activé par défaut dans la mise à jour d'avril
2018 de Windows 10.
PuTTY peut avoir encore plus de fonctionnalités. Selon le bug tracker du projet sur GitHub, le
client SSH intégré ne supporte que les clés ed25519 pour le moment.
http://www.kevinsubileau.fr/informatique/astuces-tutoriels/windows-10-client-serveur-
ssh-natif.html

PuTTY :

Accès Avec Une Paire De Clefs

Générer Une Paire De Clé
▸ $ ssh-keygen
▸ Generating public/private rsa key pair.
Enter file in which to save the key (/root/.ssh/id_rsa): ;
▸ On accepte le chemin par defaut et on ne met pas de password
▸ $ ls -la ~/.ssh
1. total 20
2. drwx------ 2 root root 4096 févr. 23 13:33 .
3. drwxr-xr-x 21 root root 4096 févr. 23 13:33 ..
4. -rw------- 1 root root 1811 févr. 23 13:33 id_rsa
5. -rw-r--r-- 1 root root 391 févr. 23 13:33 id_rsa.pub # clé
publique
6. -rw-r--r-- 1 root root 222 févr. 23 12:47 known_hosts
▸ cat ~/.ssh/id_rsa.pub
▸ copier la clé
▸ se connecter au serveur en ssh (utilisteur@xxx.xxx.xx.xxx)
▸ sudo mkdir .ssh
 ▸ cd .ssh
▸ sudo vim authorized_keys #ou nano
▸ coller la clé
▸ ssh ngu@192.168.84.100 -i .ssh/id_rsa
N'authoriser La Connection Ssh Que Par Les Clefs (pas Les
Mots De Passe)
le fichier sshd-config concerne le deamon ssh (le serveur), le fichier
ssh_config est pour le client
▸ cp sshd_config{,.BK}
▸ sudo vim /etc/ssh/sshd_config

▸ rechercher PermitRootLogin | décommanter la ligne et la mettre en no

▸ PermitRootLogin no
▸ décommanter la ligne PubkeyAuthentification
▸ PubkeyAuthentification yes
▸ decommanter la ligne PasswordAuthentification et passer à no
▸ PasswordAuthentification no
▸ redémarrer SSH
▸ sudo systemctl restart ssh
▸ on se déconnecte
▸ exit
▸ on se reconnecte avec la clef privée
▸ ssh ngu@192.168.84.100 -i .ssh/id_rsa
▸ la prochaine connexion n'aura plus besoin de clef

Je Passe À Une Autre Machine Et Tente Un Connexion

▸ Cela ne fonctionne pas
▸ ssh ngu@10.40.10.144
▸ The authenticity of host '10.40.10.144 (10.40.10.144)' can't
be established.
ECDSA key fingerprint is
SHA256:iPDOrUCwFpsRlP/mvlMjNmvTBaJPp2Y0VTG1PTNT9UI.
Are you sure you want to continue connecting
(yes/no/[fingerprint])? yes
Warning: Permanently added '10.40.10.144' (ECDSA) to the list
of known hosts.
ngu@10.40.10.144: Permission denied (publickey).

Changer Le Port De Connexion De Ssh

▸ rechercher Port | décommanter la ligne et mettre le chiffre de votre choix

▸ Port 1800
▸ redémarrer SSH
▸ sudo systemctl restart ssh
▸ on se déconnecte
▸ exit
▸ on se reconnecte avec la clef privée
▸ ssh ngu@10.40.10.144 -p 1800 -i .ssh/id_rsa
 ▸ la prochaine connexion n'aura plus besoin de clef

Productivité  SSH :
L'un des plus importants boosters de productivité lorsque vous utilisez SSH, est de configurer
une configuration qui mémorise tous vos paramètres de connexion dans le fichier'~/.ssh/config'.
Si vous n'avez pas déjà un de ces fichiers, vous pouvez le créer. Le but de ce fichier est qu'au lieu
de taper ça à chaque fois :
$ ssh ngu@10.40.10.144 -p 1800 -i .ssh/id_rsa
   Vous pouvez taper à la place :
$ ssh ngu-ser
Si vous avez dans le fichier '~/.ssh/config' du client l’entrée suivante :
Host ngu-ser
HostName 10.40.10.144
Port 1800
User ngu
IdentityFile ~/.ssh/id_rsa

CONFIGURER LE PARE-FEU DU SERVEUR

Avec Ubuntu le pare-feu est UFW (Uncomplicated FireWall)
Il permet de gerer les règles de iptables qui gère le fitrage.
Il faut authoriser le port 22 avant de démarrer le pare-feu
▸ sudo ufw allow 22/tcp
▸ sudo ufw enable
▸ Command may disrupt existing ssh connections. Proceed with operation (y|
n)? y
▸ Firewall is active and enabled on system startup
▸ pour connaitre les règles disponibles du FW
▸ sudo ufw status
▸ Si ce serveur hébergait un serveur web https
▸ sudo ufw allow 443/tcp
▸ Pour lister les application que le pare-feu a vu
▸ sudo ufw app list
▸ Pour connaitre la liste des ports et les protocoles
▸ cat /etc/services

Pour verifier l'état des ports, de l'interieur et de l'exerieur voici deux outils
La commande ss sert à voir les ports qui sont actifs même si le FW leur empèchait
d'acceder
C'est une sorte d'audit interne

ngu@nguser:~$ sudo ss -anpt

State Recv-Q Send-Q Local Address:Port Peer Address:Port
LISTEN 0 128 127.0.0.53%lo:53 0.0.0.0:* users:(("systemd-
resolve",pid=1990,fd=13))
LISTEN 0 128 0.0.0.0:22 0.0.0.0:* users:
(("sshd",pid=12122,fd=3))
ESTAB 0 0 192.168.84.100:22 192.168.84.136:59004 users:
(("sshd",pid=12823,fd=3),("sshd",pid=12756,fd=3))
LISTEN 0 128 [::]:22 [::]:* users:
(("sshd",pid=12122,fd=4))
ngu@nguser:~$ exit
logout
Connection to 192.168.84.100 closed.
sudo nmap -sS 192.168.84.100
Starting Nmap 7.70 ( https://nmap.org ) at 2020-02-23 17:45 CET
Nmap scan report for 192.168.84.100
Host is up (0.00056s latency).
Not shown: 998 filtered ports
PORT STATE SERVICE
22/tcp open ssh
443/tcp closed https
MAC Address: 00:0C:29:D5:13:C5 (VMware)

Nmap done: 1 IP address (1 host up) scanned in 4.78 seconds

On voit les deux ports en fonction dont le 443 sans connection.

Bonne pratiques :
1. S'assurer que le service est disponible
2. S'assurer que le pare-feu prend en charge le services
3. Verifier l'accès grace à un systeme distant
4. Regarder le journal du pare-feu au cas où : /var/log/ufw.log

BASTION SSH

Le plus simple est se connecter au bastion en ssh puis, de l'interieur faire une nouvelle
commande ssh pour atteindre les serveursA ou serveurB
Il est aussi possible d'utiliser le flag -J comme Jump pour aller directement au serverA
client> ssh -J user@62.23.55.220 user@192.168.0.10
LE TUNNELING SSH
voir ce tuto

pour faire transiter un protocol htttp dans un tunnel ssh la commande prend la forme :

ssh -f user@monserveur -L 2500:localhost:80 -N

• "-f" : Permet de mettre la commande SSH en tâche de fond une fois lancée, cela nous
donne la possibilité d'exécuter d'autres commandes une fois que le tunnel SSH est
établie.

• "-L" : C'est l'option qui nous permet d'initialiser le tunnel, son argument prend la forme
"port local : cible en sortie de tunnel : port cible en sortie de tunnel". .

• "-N" : Indique "Do not execute a remote command". C'est une option qui va souvent de
paire avec l'utilisation de l'option "-L".
ssh -f mickael@1.2.3.4 -L 2500:192.168.1.10:80 -N