Lundi 5 août 2019 (Modifié le Vendredi 1er mai 2020)

SSHFS

outil permettant d’utiliser le protocole ssh comme un système de fichiers

Liens

SSHFS permet d’utiliser un serveur ssh afin de monter des dossiers distants disponibles dans le système de fichier grâce à fuse. Il ne nécessite côté serveur que openssh-server et côté client fuse openssh-client sshfs et éventuellement tor.

Options sshfs

Les options du SSHFS :

-p PORT
    équivalent à "-o port=PORT". 
-C

équivalent à "-o compression=yes".
-F ssh_configfile
    spécifie un autre fichier de configuration ssh 
-1

équivalent à "-o ssh_protocol=1".
-o reconnect
    se reconnecter au serveur 
-o delay_connect
    retarder la connexion au serveur 
-o sshfs_sync
    écritures synchrones 
-o no_readahead
    lectures synchrones (pas de readahead spéculatif) 
-o sshfs_debug
    imprimer quelques informations de débogage 
-o cache=BOOL
    activer la mise en cache {yes, no} (par défaut : yes) 
-o cache_timeout=N
    définit le délai d'attente pour les caches en secondes (par défaut : 20) 
-o cache_X_timeout=N
    définit le délai d'attente pour le cache {stat,dir,link}. 
-o workaround=LIST
    liste de contournements séparés par deux points 
    none
        aucune solution de contournement n'est possible
    all
        toutes les solutions de contournement possibles 
    [no] renommer 
        Correction du renommage d'un fichier existant (par défaut : off)
    [no]nodelaysrv 
        set nodelay tcp flag in ssh (default : off)
     [no]truncate  
        correction de la troncature des anciens serveurs (par défaut : off)
    [no]buflimit 
        correction d'un bogue de remplissage de la mémoire tampon du serveur (par défaut : on)

-o idmap=TYPE
    la cartographie des ID d'utilisateurs/de groupes (user/group), les types possibles sont 
    none
         pas de traduction de l'espace d'identification (par défaut)
    user
         ne traduire que l'UID de l'utilisateur connecté

    file
         traduire les UID/GID en se basant sur le contenu des uidfile et gidfile 
-o uidfile=FILE
    fichier contenant le nom d'utilisateur:uid mappings for idmap=file 
-o gidfile=FILE
    fichier contenant le nom de groupe : gid mappings for idmap=file 
-o nomap=TYPE
    avec idmap=file, comment gérer les cartographies manquantes 
    ignore 
         ne pas refaire de cartographie
    error
        retourner une erreur (par défaut) 

-o ssh_command=CMD
    exécuter CMD au lieu de "ssh". 
-o ssh_protocol=N
    protocole ssh à utiliser (par défaut : 2) 
-o sftp_server=SERV
    chemin d'accès au serveur ou sous-système sftp (par défaut : sftp) 
-o directport=PORT
    se connecter directement au PORT en contournant ssh -o esclave communiquer sur le réseau stdin et stdout bypassing 
-o transform_symlinks
    transformer les liens symboliques absolus en liens symboliques relatifs 
-o follow_symlinks
    suivre les liens symboliques sur le serveur 
-o no_check_root
    ne pas vérifier l'existence d'un "dir" sur le serveur 
-o password_stdin
    lire le mot de passe depuis stdin (uniquement pour pam_mount !) 
-o SSHOPT=VAL
    Options ssh (voir man ssh_config) 

Configuration rapide client serveur

Note : Les paquets “openssh-client” et “fuse-utils” sont requis, mais il sont déjà installés par défaut

client

Il faut disposer d’un serveur ssh focntionnel

serveur

Installer sshfs

sudo apt update && sudo apt install sshfs # debian
sudo pacman -S sshfs  # archlinux/manjaro

Test rapide

Sur le système client, créer un répertoire dans lequel va être monté le système de fichiers :

mkdir /home/utilisateur/Test

Monter un répertoire distant (ici ~/Public):

sshfs utilisateur@ip_distante:/home/utilisateur/Public /home/utilisateur/Test

Le mot de passe de l’utilisateur est alors demandé.

Ouvrir l gestionnaire de fichiers pour accèder à vos fichiers distants.

Enfin, penser à démonter :

fusermount -u /home/utilisateur/Test

SSHFS avec clés et port différent

sshfs -oIdentityFile=<clé privée> utilisateur@domaine.tld:<dossier distant> <dossier local> -C -p <port si différent de 22>

SSHFS fstab

Comment puis-je monter de façon permanente le système de fichiers distant en mettant à jour /etc/fstab ?

Pour les montages permanents, vous devez créer une connexion basée sur les clés ssh

ssh-keygen -t rsa
ssh-copy-id -i ~/.ssh/id_rsa.pub vivek@server1.cyberciti.biz

Maintenant, éditez le fichier /etc/fstab

sudo nano /etc/fstab

La syntaxe est :

userNameHere@FQDN_OR_IP_HERE:/path/to/source/  /local/mountdir/  fuse.sshfs  defaults,_netdev  0  0

Ajoutez l’entrée suivante au bas du fichier fstab :

user@192.168.1.142:/ /mnt/server1

Un autre exemple avec des options supplémentaires :

user@192.168.1.142:/ /mnt/server1 fuse defaults,idmap=user,allow_other,reconnect,_netdev,users,IdentityFile=/path/to/.ssh/keyfile 0 0

Option de montage à la demande avec systemd :

USERNAME@HOSTNAME_OR_IP:/REMOTE/DIRECTORY  /LOCAL/MOUNTPOINT  fuse.sshfs x-systemd.automount,_netdev,user,idmap=user,transform_symlinks,identityfile=/home/USERNAME/.ssh/id_rsa,allow_other,default_permissions,port=22,uid=USER_ID_N,gid=USER_GID_N 0 0
vivek@server1.cyberciti.biz:/project/www/ /mnt/server1  fuse.sshfs noauto,x-systemd.automount,_netdev,users,idmap=user,IdentityFile=/home/vivek/.ssh/id_rsa,allow_other,reconnect 0 0

Descripton des options

  • user@192.168.1.142 : Serveur distant avec sshd
  • fuse : Type de système de fichiers.
  • idmap=user : Ne traduit que l’UID de l’utilisateur connecté.
  • allow_other : Autorise l’accès aux autres utilisateurs.
  • reconnect : Se reconnecter au serveur.
  • _netdev : Le système de fichiers réside sur un périphérique qui nécessite un accès au réseau (utilisé pour empêcher le système de tenter de monter ces systèmes de fichiers tant que le réseau n’a pas été activé sur le système).
  • users : Permet à chaque utilisateur de monter et de démonter le système de fichiers.
  • IdentityFile=/chemin/vers/.ssh/keyfile : fichier de clés SSH.

Autorisations : “utilisateur” et/ou “root” des supports FUSE

Accès utilisateur

  • Exécuter sshfs (ou toute autre commande de montage FUSE) avec l’option -o allow_other

Accès root
Il y a des endroits que même les root ne peuvent pas atteindre. L’un de ces endroits est un volume monté sur FUSE. Je l’ai découvert en essayant d’accéder à un répertoire monté sshfs en tant que root et je me suis vu refuser la permission.

# ls /home/user/dossier
ls: impossible d'accéder à '/home/user/dossier': Permission non accordée

Pour contourner ce problème, faites ce qui suit (ce que j’ai appris en me renseignant sur la défaillance du serveur) :

  1. Ajoutez user_allow_other au fichier /etc/fuse.conf
  2. Exécutez sshfs (ou toute autre commande de montage FUSE) avec l’option -o allow_root

Configurer le serveur SSH

Installez les pré-requis

sudo apt-get install tor openssh-server

Créez un utilisateur dédié

sudo adduser userCommunSFTP

Générez de nouvelles clés de sécurité pour l’utilisateur précédemment créé

su userCommunSFTP
ssh-keygen -t ed25519 -o -a 1666
ssh-keygen -t rsa -b 4096 -o -a 1666

Configurer le(s) client(s) GNU/Linux

Installez les pré-requis

sudo apt-get install openssh-client sshfs fuse

Si vous ne l’avez jamais fait depuis votre installation, générez de nouvelles clés

ssh-keygen -t ed25519 -o -a 16669
ssh-keygen -t rsa -b 4096 -o -a 16669

-o -a 100 : permet de faire boucler l’algorithme 100 fois -b 4096 : précise qu’on veut une clé à 4096 bits (au début des années 2k la France interdisait plus de 126 bit ;) ) -t rsa : on utilise l’algorithme RSA -t ed25519 : on utilise l’algorithme EdDSA

Exportez votre clé publique sur le serveur

ssh-copy-id -i ~/.ssh/id_ed25519.pub userCommunSFTP@adresseServerSSH

Ajoutez votre utilisateur à la liste des utilisateurs autorisés à utiliser fuse

sudo adduser $USER fuse
  • Note : remplacez $USER par l’utilisateur de votre choix (par défaut $USER = votre utilisateur courant (celui qui a ouvert la session sur votre machine)). Sur Raspberry Pi cette commande peut échouer sans que cela ne pose problème.

Autoriser les autres utilisateurs à monter un dossier avec fusermount

sudo nano /etc/fuse.conf
  • Décommentez (enlevez le # devant) user_allow_other puis tapez CTRL+X pour sauver et quitter.

Pour effectuer le montage SSHFS au démarrage il est fort possible que la machine passe par root.

Connectez-vous en root (admin)

sudo su

Générez une paire de clés solide pour root

ssh-keygen -t rsa -b 4096 -o -a 16666
ssh-keygen -t ed25519 -o -a 16666
  • La deuxième (ed25519) ne fonctionne pas sur Raspberry Pi

Exportez la clé publique de root sur la machine distante

ssh-copy-id -i /root/.ssh/id_rsa.pub userCommunSFTP@adresseServerSSH

Testez si l’ajout a bien fonctionné (ne doit pas demander de mot de passe)

ssh userCommunSFTP@adresseServerSSH

Quittez root

exit

Montage au démarrage sur le(s) client(s) via fstab et hostname fixe

Installez les pré-requis

sudo apt-get install openssh-client

Créer le point de montage local (adaptez à vos envies)

sudo mkdir /media/monPointDeMontageLocal

Accorder les bons droits à notre point de montage

  • Spécifiez les propriétaires
sudo chown root:$USER -R /media/monPointDeMontageLocal
  • Note : $USER = votre utilisateur courant par défaut, changez si besoin

  • Spécifiez aussi les droits d’accès des propriétaires

sudo chmod 770 -R /media/monPointDeMontageLocal
  • Note : si vous souhaitez que le montage soit accessible à tous vos utilisateurs systèmes remplacez 770 par 774 pour lecture uniquement ou 777 s’ils (tous les utilisateurs) peuvent avoir les mêmes droits que votre utilisateur principal sur ce point de montage. ( voir chmod )

Éditez le fichier /etc/fstab (CTRL+X pour sauver&quitter)

sudo nano /etc/fstab

Ajoutez le montage afin de le monter au boot

userCommunSFTP@adresseServerSSH:/home/userCommunSFTP/                /media/monPointDeMontageLocal          fuse.sshfs           port=22,user,noatime,reconnect,_netdev,nofail,allow_other     0 0
  • Note : :/dossier/distant/ n’est pas obligatoire ; nofail permet d’empêcher le boot de crasher si le montage ne réussit pas, _netdev ordonne d’attendre que le réseau soit fonctionnel avant d’effectuer le montage; allow_other autorise les autres utilisateurs à monter le dossier. Ajoutez noauto si vous voulez que le montage ne s’effectue qu’à la demande et non au démarrage de la machine.

Testez votre montage

sudo mount /media/monPointDeMontageLocal

Montage au démarrage sur le(s) client(s) via script DIY compatible cross-canal (LAN, WAN, TOR)

Installez les pré-requis

sudo apt-get install openssh-client tor

Créer le point de montage local (adaptez-le à vos envies)

sudo mkdir /media/monPointDeMontageLocal

Accorder les bons droits à notre point de montage

  • Spécifiez les propriétaires
sudo chown root:$USER -R /media/monPointDeMontageLocal
  • Note : $USER = votre utilisateur courant par défaut, changez si besoin

  • Spécifiez aussi les droits d’accès des propriétaires

sudo chmod 770 -R /media/monPointDeMontageLocal
  • Note : si vous souhaitez que le montage soit accessible à tous vos utilisateurs système remplacez 770 par 774 pour lecture uniquement ou 777 s’ils (tous les utilisateurs) peuvent avoir les mêmes droits que votre utilisateur principal sur ce point de montage. ( voir chmod )

Créez le script

sudo nano /opt/scripts/mountSSHFS.sh

Collez le code suivant en l’adaptant

#!/bin/bash
#licence WTFPL - script infos : https://www.0rion.netlib.re/forum4/viewtopic.php?f=68&t=339&p=893#p893
#github : https://github.com/voxdemonix/divers-script/blob/master/mountSSHFS_crosscanal.sh
#work on raspbian, ubuntu, debian and possibly Arch


if [ ! "$SUDO_USER" ]; then
echo "i need root => $0"
exit 0
fi
sleep 60 # petit délai d'attente afin que le réseau soit prêt


IpServerLocale="192.168.1.42" # server IP LAN
AdresseServerOnion="blablablablabla1.onion" # tor hidden service OR Hostname WAN
MacServerLocale="00:00:00:00:00:00" #l'adresse mac du serveur SSH (tapez ifconfig dans un terminal sur votre server pour la voir)
UserRemoteForSsh="user_sur_server" # l'utilisateur à utiliser côté serveur ( /!\ n'utilisez jamais root !)
port="22" # le port sur le server
monPointDeMontageLocal="/media/monPointDeMontageLocal"
monPointDeMontageDistant="/home/user_sur_serveur/"

umount $monPointDeMontageLocal -f >> /dev/null 2>&1
ping $IpServerLocale -c 1 >> /dev/null 2>&1
macRecover=$(arp -n | grep -i -o $MacServerLocale)

if [ "$macRecover" == "$MacServerLocale" ]; then
   sshfs -o allow_other -o reconnect -o ServerAliveInterval=15 $UserRemoteForSsh@$IpServerLocale:$monPointDeMontageDistant $monPointDeMontageLocal -p $port -C
else
   sshfs -o allow_other -o reconnect -o ServerAliveInterval=15 $UserRemoteForSsh@$AdresseServerOnion:$monPointDeMontageDistant $monPointDeMontageLocal -p $port -C
fi
  • IpServerLocale=”192.168.1.42” => l’adresse IP LAN de votre serveur
  • AdresseServerOnion=”blablablablabla1.onion” => l’hostname de votre serveur. Au choix un Tor Hidden Service, une IP WAn ou un Hostname WAN (exemple.com)
  • MacServerLocale=”00:00:00:00:00:00” => l’adresse MAC de votre server (tapez ifconfig sur votre serveur pour la voir)
  • UserRemoteForSsh=”user_sur_server” => utilisateur sur le serveur SSH à utiliser pour la connexion
  • port=”22” => le port d’écoute du serveur ssh (par défaut 22)
  • monPointDeMontageLocal=”/media/monPointDeMontageLocal” => où rendre disponible le montage sur votre client
  • monPointDeMontageDistant=”/home/user_sur_server/” => Le dossier sur le serveur à partir du quel effectuer le montage

Rendez le script exécutable

sudo chmod +x /opt/scripts/mountSSHFS.sh

Lancez-le au boot en éditant /etc/rc.local

sudo nano /etc/rc.local
  • Et ajoutez la ligne suivante avant “exit 0” ###
sudo /opt/scripts/mountSSHFS.sh

Rendez compatible votre client SSH avec le réseau tor

sudo nano /etc/ssh/ssh_config
  • Et collez les lignes suivantes puis tapez CTRL+X pour sauver&quitter
    Host *.onion
       ProxyCommand nc -xlocalhost:9050 -X5 %h %p

Testez votre montage

sudo /opt/scripts/mountSSHFS.sh