LINUX > SSH

INSTALLER ET DÉMARRER LE SERVEUR SSH

sudo apt install openssh-server -y

 

Pour vérifier que ssh est bien installé :

systemctl is-enabled ssh

 

On peut voir si ssh est démarré :

systemctl status sshd

 

Tester l’accès à SSH :

ip a
2: ens33:  mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 00:0c:29:d3:f5:b0 brd ff:ff:ff:ff:ff:ff
    inet 192.168.0.20/24 brd 192.168.0.255 scope global dynamic ens33

 

root n’est pas accessible par ssh. Pour cela, changer la valeur de PermitRootLogin dans /etc/ssh/sshd_config puis redémarrer SSH.

CHANGER LE PORT PAR DÉFAUT

NOTE : Le nouveau port SSH ne doit pas être en conflit avec les ports connus ou bloqués.

 

Se connecter au serveur via SSH :

ssh utilisateur@adresse_IP:port

 

Passer en root :

su -

 

Dans le fichier /etc/ssh/sshd_config :

# Port 22

Supprimez # et remplacer 22 par le port souhaité.

 

Redémarrer sshd :

service sshd restart
sudo systemctl restart ssh

 

Vérifier les changements (ici, port 123) :

sudo netstat -tlpn| grep ssh
tcp    0  0  0.0.0.0:123  0.0.0.0:*  LISTEN  5214/sshd: /usr/s
tcp6   0  0  :::123       :::*       LISTEN  5214/sshd: /usr/s
sudo ss -tlpn| grep ssh
LISTEN  0  128  0.0.0.0:123  0.0.0.0:*  users:(("sshd",pid=5214,fd=3))
LISTEN  0  128  :::123       :::*       users:(("sshd",pid=5214,fd=4))

CONNEXION SANS MOT DE PASSE

Il faut créer une clé publique et l’envoyer dans ~/.ssh/authorized_keys des machines distantes.

 

1 - Vérifier si une paire de clés SSH existe déjà :

ls -al ~/.ssh/id_*.pub
ls: impossible d'accéder à '/home/toto/.ssh/id_*.pub': Aucun fichier ou dossier de ce nom

Cela veut dire qu’il n’existe pas de clé. Sinon, si une clé existe, aller directement à l’étape 3.

 

2 - Créer la paire de clés SSH :

ssh-keygen -t rsa -b 4096 -C "email@site.com"

Ici, une clé de 4096 bits avec l’adresse mail en commentaire.

Presser Enter pour accepter le nom et la destination du fichier (~/.ssh/id_rsa)

 

Puis, il sera demandé une phrase de sécurité. On peut s’en passer en appuyant sur Enter

Pour s’assurer que les clés ont été créées :

ls ~/.ssh/id_*
/home/toto/.ssh/id_rsa /home/toto/.ssh/id_rsa.pub

 

3 - Copier la clé publique :

Sur la machine locale :

ssh-copy-id distant_user@distant_ip

La clé sera copiée dans ~/.ssh/authorized_keys et la connexion prendra fin.

 

Si ssh-copy-id n’est pas installé sur la machine :

cat ~/.ssh/id_rsa.pub | ssh remote_user@dest_ip "mkdir -p ~/.ssh && chmod 700 ~/.ssh && cat >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys"

 

4 - Tester que tout fonctionne correctement :

ssh foo@machine2

La connexion devrait se faire sans mot de passe.

Désactiver l’authentification SSH par mot de passe

Pour créer un user sudo, il faut se loguer avec un compte déjà sudo :

ssh sudo_user@server_ip

 

Ouvrir le fichier de configuration SSH (/etc/ssh/sshd_config) et modifier les directives suivantes :

PasswordAuthentication no
ChallengeResponseAuthentication no
UsePAM no

 

Sauvegarder et redémarrer SSH :

sudo systemctl restart ssh

Configuration pour automatiser SSH

Pour automatiser la connexion aux machines distantes, on peut créer des sortes d’alias spéciales pour SSH :

SSH Config File Location

Si le fichier ~/.ssh/config n’existe pas :

touch ~/.ssh/config
chmod 600 ~/.ssh/config

SSH Config File Structure and Patterns

Host hostname1
    SSH_OPTION value
    SSH_OPTION value

Host hostname2
    SSH_OPTION value

Host *
    SSH_OPTION value

 

Chaque section (stanzas) commence par la directive Host et contient les options SSH adéquates :

Host * matches all hosts, while 192.168.0.* matches hosts in the 192.168.0.0/24.

? pour un seul caractère => Host 10.10.0.? -> tous les hosts in 10.10.0.[0-9].

! au début du pattern, exclu l’hôte => Host 10.10.0.* !10.10.0.5 -> tous les 10.10.0.0/24 sauf 10.10.0.5.

 

NOTE: Dès qu’un pattern matche, alors les options rencontrées seront prioritaires aux suivantes. Voir la page ssh_config man.

Exemple 1

Exemple,au lieu de taper :

ssh john@dev.example.com -p 2322 -> ssh jj

 

Écrire dans ~/.ssh/config :

Host jj
   HostName dev.example.com
   User john
   Port 2322

 

On peut maintenant taper :

ssh jj

Exemple 2

Host targaryen
   HostName 192.168.1.10
   User daenerys
   Port 7654
   IdentityFile ~/.ssh/targaryen.key

Host tyrell
   HostName 192.168.10.20

Host martell
   HostName 192.168.10.50

Host *ell
   user oberyn

Host * !martell
   LogLevel INFO

Host *
   User root
   Compression yes

 

Avec ssh targaryen, les options seront donc :

HostName 192.168.1.10
User daenerys
Port 7654
IdentityFile ~/.ssh/targaryen.key
LogLevel INFO
Compression yes

 

Avec ssh tyrell :

HostName 192.168.10.20
User oberyn
LogLevel INFO
Compression yes

 

Avec ssh martell :

HostName 192.168.10.50
User oberyn
Compression yes

Ordre des options

Les options seront lues dans l’ordre : depuis la ligne de commande > puis ~/.ssh/config > puis /etc/ssh/ssh_config.

 

ssh -o "User=root" dev

COPIER DES FICHIERS VIA SCP

scp <options> user1@SOURCE_IP:fichier1 user2@DEST_IP:/chemin/fichier2

 

-P Specifies the remote host ssh port.

-p Conserve les dates de modification et d’access.

-q Suppress the progress meter and non-error messages.

-C Compresses the data as it is sent to the destination machine.

-r Copy directories recursively.

 

NOTE: scp écrasera un fichier déjà existant sans avertissement !

NOTE: Pour les gros fichiers, utliser scp au sein de screen ou tmux.

Copie LOCAL -> DISTANT

scp fichier toto@10.10.0.2:/chemin/distant
toto@10.10.0.2's password:
fichier                             100%    0     0.0KB/s   00:00

 

Ne pas donner de nom au dossier distant, donnera e même nom que le local. Sinon, donner un autre nom.

scp fichier nom@DEST_IP:/chemin/dossier/nouveau_nom
scp -P 2322 fichier nom@DEST_IP:/chemin/dossier

 

Pour cxopier tout un dossier, utiliser l’option -r (recursive):

scp -r /local/dossier nom@DEST_IP:/chemin/dossier

Copie DISTANT -> LOCAL

scp nom@DISTANT_IP:/chemin/fichier /local/dossier

Copie DISTANT_1 -> DISTANT_2

Copier le fichier /dossier/fichier depuis MACHINE_1 vers le dossier /dossier de MACHINE_2 :

scp user1@MACHINE_1:/dossier/fichier user2@MACHINE_2:/dossier

 

Pour router le traffic à travers la machine exécutant la commande, utiliser l’option -3 :

scp -3 user1@MACHINE_1:/dossier/fichier user2@MACHINE_2:/dossier