Ceci est une ancienne révision du document !
hubiC
hubiC (http://www.ovh.fr/hubiC/) est le service de stockage Cloud de OVH.
OVH met à la disposition des utilisateurs différents logiciels clients pour hubiC, dont un pour Linux.
Connexion avec le client hubiC fourni par OVH
Pré-requis
- Disposer des droits d'administration.
- Disposer d'une connexion à Internet configurée et activée.
Installation
Installation manuelle :
Télécharger, décompresser dans /opt l'archive disponible sur https://hubic.labs.ovh.com/hubic/hubiC-browser-LATEST.tar.gz :
cd /tmp wget https://hubic.labs.ovh.com/hubic/hubiC-browser-LATEST.tar.gz sudo tar xvfz hubiC-browser-LATEST.tar.gz -C /opt
Editer le fichier hubiC-browser :
gksudo gedit /opt/hubiC-browser/hubiC-browser
Et remplacer sont contenu par les instructions suivantes :
#!/bin/sh
readlinkOutput=`readlink $0`
if [ "${readlinkOutput}x" = "x" ]; then
dirname=`dirname ${readlinkOutput}`
else
dirname=`dirname $readlinkOutput`
fi
appname=`basename $0`
tmp="${dirname#?}"
if [ "${dirname%$tmp}" != "/" ]; then
dirname=$PWD/$dirname
fi
LD_LIBRARY_PATH=$dirname/.lib
export LD_LIBRARY_PATH
$dirname/.hubiC-browser-bin
Créer un lien symbolique sur le script dans /usr/bin :
sudo ln -s /opt/hubiC-browser/hubiC-browser /usr/bin/hubiC-browser
Créer et éditer le fichier lanceur :
gksudo gedit /usr/share/applications/hubiC-browser.desktop
Le contenu doit être le suivant :
[Desktop Entry] Version=1.0 Type=Application Terminal=false Categories=GNOME;GTK; Exec=hubiC-browser Name=hubiC Comment=Le navigateur de Fichier hubiC Icon=/usr/share/icons/hubiclogo.svg
Dernière étape, télécharger l'icône du lanceur :
cd /usr/share/icons sudo wget http://www.le-libriste.fr/hubiclogo.svg
Installation automatique :
Utilisation
Lancez l'application via le dash (Ubuntu 11.04 et ultérieures) ou via le terminal (toutes versions d'Ubuntu) avec la commande suivante :
hubiC-browser
Désinstallation
Désinstallation manuelle :
Pour supprimer cette application, il suffit de procéder
* à la suppression de la directory /opt/hubiC-browser ;
* à la suppression du lien symbolique /usr/bin/hubiC-browser ;
* à la suppression du lanceur /usr/share/applications/hubiC-browser.desktop.
Connexion en webdav
La connexion webdav est un peu plus complexe à mettre en œuvre mais fonctionne parfaitement avec Quantal à la date du 1er mai 2013.
Création d'un compte hubiC
Commencer par créer un compte hubiC sur le site du fournisseur. Bien noter ses identifiants (un identifiant et un mot de passe) qui seront dénommés "identifiants hubiC" dans la suite du tuto.
Récupération des identifiants webdav
Les identifiants de connexion web ne suffisent pas pour se connecter. Il est nécessaire de récupérer des identifiants spécifiques. Plusieurs scripts sont disponibles sur internet, qui fonctionnent plus ou moins bien selon les configurations. Le script suivant, en python, a bien fonctionné sur une configuration Quetzal .
Le texte du script webdav_hubic_credentials.py à copier/coller dans un fichier texte (par exemple avec gedit : copier-coller le texte intégral sans ajout puis sauvegarder par control-S) :
- webdav_hubic_credentials.py
#!/usr/bin/python # -*- coding: utf-8 -*- # Renvoie les identifiants de connexion au webdav Hubic à partir des identifiants web (saisis en dur !!!) import httplib, urllib class config: ovh_host = "ws.ovh.com" def get_webdav_info(login, password): ws_info={} null = None # Log into CloudNAS with nasLogin and retrieve a session ID print 'Logging into CloudNAS to retrieve a session ID...' params = 'session=¶ms={"email":"%s","password":"%s"}' % (urllib.quote(login), urllib.quote(password)) headers = {"Content-type": 'application/x-www-form-urlencoded', "User-Agent": 'hubiC/0.4.8 beta (Windows NT 6.1; fr_FR)'} conn = httplib.HTTPSConnection(config.ovh_host) conn.request("POST", "/cloudnas/r3/ws.dispatcher/nasLogin", params, headers) resp = conn.getresponse() s = resp.status r = resp.reason data = resp.read() try: d = eval(data) sid = d['answer']['id'] except KeyError: return ws_info finally: conn.close() print '# SID:', sid # POST on getNas using session ID to get URL print 'Retrieving user-specific URL for WebDAV...' params = 'session=%s' % sid conn = httplib.HTTPSConnection(config.ovh_host) conn.request("POST", "/cloudnas/r3/ws.dispatcher/getNas", params, headers) resp = conn.getresponse() s = resp.status r = resp.reason data = resp.read() try: d = eval(data) ws_info['url'] = d['answer'][0]['url'] except KeyError : return ws_info finally: conn.close() print '# URL:', ws_info['url'] # POST on getCredentials using session ID to get credentials print 'Retrieving user-specific credentials for WebDAV...' params = 'session=%s' % sid conn = httplib.HTTPSConnection(config.ovh_host) conn.request("POST", "/cloudnas/r3/ws.dispatcher/getCredentials", params, headers) resp = conn.getresponse() s = resp.status r = resp.reason data = resp.read() try: d = eval(data) ws_info['login'] = d['answer']['username'] ws_info['passwd'] = d['answer']['secret'] except KeyError: return ws_info finally: conn.close() print '# Ok' return ws_info if __name__ == '__main__': import sys import getpass import os.path login = 'identifiant_Hubic' password = 'mot_de_passe_Hubic' ws_info = get_webdav_info(login, password) print ''' URL: %(url)s login: %(login)s password: %(passwd)s ''' % ws_info
Il est ensuite nécessaire de modifier les lignes 79 et 80 pour y insérer les identifiants Hubic (substituer les identifiants personnalisés en respectant les apostrophes) :
login = 'identifiant_Hubic'
password = 'mot_de_passe_Hubic'
Rendre le fichier exécutable et le lancer :
usr@machine:~$ chmod +x hubic-webdav-credentials.txt usr@machine:~$ ./hubic-webdav-credentials.txt
Le programme python va se connecter au serveur OVH d'hubiC et renvoyer les éléments suivants :
Logging into CloudNAS to retrieve a session ID...
# SID: classic/xx0000-ovh.xxxxxx000000xxx0x00xxxx000xxxxx0x
Retrieving user-specific URL for WebDAV...
# URL: https://xx0000000x000000xxxxxx0000x0xx0x0.wd.hubic.ovh.net
Retrieving user-specific credentials for WebDAV...
# Ok
URL: https://xxxxxxxxx000000xxxxxxxxx000x00xx0x0.wd.hubic.ovh.net
login: xXXXXxxxX000xXXxxXXXXXX000000xxxxXXXXXXX000xxxxxXXXXXXXXXXXXXXxxxxxxx000000xxxxxXXXxxxXX0xX
password: x000000xxxxxxxxxxxx000xxxxxxx000x
Il convient de relever les éléments suivants, appelés identifiants webdav dans la suite du tuto. Attention, la suite de lettre et de chiffres est assez indigeste et doit être reproduite avec précision :
- l'adresse https (URL) au format : https://xxxxxxxxx000000xxxxxxxxx000x00xx0x0.wd.hubic.ovh.net
- l'identifiant (login) au format : xXXXXxxxX000xXXxxXXXXXX000000xxxxXXXXXXX000xxxxxXXXXXXXXXXXXXXxxxxxxx000000xxxxxXXXxxxXX0xX
- le mot de passe (password) au format : x000000xxxxxxxxxxxx000xxxxxxx000x
Installation de davfs2
S'il n'est pas présent sur le système, installer davfs2
usr@machine:~$ sudo apt-get install davfs2
Installation du partage
- créer un point de montage :
usr@machine:~$ mkdir /media/Montage_Hubic
- monter le partage de fichier :
usr@machine:~$ mount.davfs https://xxxxxxxxx000000xxxxxxxxx000x00xx0x0.wd.hubic.ovh.net /media/Montage_Hubic
Et là tout devrait fonctionner en lançant nautilus en superutilisateur (gksudo nautilus) → apparition d'un nouveau répertoire etc.
Installation du partage en "userspace"
Cette installation sera ainsi accessible sans droits superutilisateurs ce qui est plus pratique et, semble-t-il, plus sûr :
Modification des options de davfs2
usr@machine:~$ sudo dpkg-reconfigure davfs2
et répondre "oui" à la question "Autoriser les utilisateurs non privilégiés à monter les ressources WebDAV ?" (en déplaçant la surbrillance rouge avec la flèche du clavier puis en cliquant sur entrée).
Création d'un point de montage
Il s'agit de créer un répertoire qui sera relié au partage, c'est à dire le répertoire dans lequel apparaîtrons les données sauvegardées dans le cloud, dans Nautilus ou en ligne de commande par exemple. Le choix de ce répertoire et de son positionnement dans l'arborescence est libre, sous réserve qu'il se trouve dan sle répertoire personnel de l'utilisateur (/home/utilisateur/). Dans le cas d'espèce ce sera /home/utilisateur/Documents/Hubic/Montage_Hubic
1. Création du répertoire
usr@machine:~$ mkdir $HOME/Documents/Hubic/Montage_Hubic
2. Création d'une copie de sauvegarde du fichier /etc/fstab
usr@machine:~$ sudo cp /etc/fstab /etc/fstab.anc
En cas de problème de montage des disques, il sera ainsi possible de restaurer la configuration d'origine.
3. Ajout de lignes dans /etc/fstab
Ajout des lignes suivantes dans fstab (idéalement en fin de fichier pour éviter des suppressions malencontreuses), par exemple avec gedit en mode superutilisateur :
fstab
# Montage WebDav Hubic https://xxxxxxxxx000000xxxxxxxxx000x00xx0x0.wd.hubic.ovh.net /home/utilisateur/Hubic/Montage_Hubic davfs rw,user,noauto 0 0
Ajout de l'utilisateur courant au groupe davfs2
usr@machine:~$ sudo adduser $USER davfs2
Création du répertoire caché .davfs2 si nécessaire
Si le répertoire caché .davfs2 n'existe pas dans le répertoire personnel, le créer :
usr@machine:~$ mkdir $HOME/.davfs2
Ensuite, copier dans ce nouveau répertoire les fichiers secrets et dav2fs.conf" depuis le répertoire /etc/dav2fs et rendre l'utilisateur courant propriétaire de secrets. Si le répertoire .davfs2 est préexistant, vérifier que ces fichiers sont présents, sinon les copier également :
usr@machine:~$ cp /etc/davfs2/davfs2.conf ~/.davfs2 usr@machine:~$ sudo cp /etc/davfs2/secrets ~/.davfs2 usr@machine:~$ sudo chown $USER ~/.davfs2/secrets
Modification du fichier $HOME/.davfs2/secrets
Modifier le fichier $HOME/.davfs2/secrets en y ajoutant les lignes suivantes :
$HOME/.davfs2/secrets
Soit quelque chose qui ressemble à cela :
$HOME/.davfs2/secrets
Modification du fichier $HOME/.davfs2/davfs2.conf
Dans le tuto sur davfs2, il est conseillé de modifier également le fichier davfs2.conf en ajoutant (ou décommentant) la ligne suivante :
$HOME/.davfs2/davfs2.conf
À la lecture du contenu de davfs2.conf, il est apparu une ligne commentée ainsi libellée
$HOME/.davfs2/davfs2.conf
Elle a donc été décommentée, ça semble logique :
$HOME/.davfs2/davfs2.conf
Ça y est, ça fonctionne. Il est désormais possible de monter et démonter à volonté l'espace de stockage dans Nautilus ou bien naviguer en ligne de commande ou par tout autre moyen.
Mise à jour des identifiants webdav
À ce stade du tutoriel, une liaison directe webdav avec l'espace de stockage distant Hubic a été créée. Elle est accessible dans Nautilus, un nouveau périphérique apparaît dans la fenêtre de gauche de Nautilus. Dans l'exemple donné ce périphérique s'appelle Montage_Hubic et s'il n'est pas monté automatiquement à l'ouverture de Nautilus, il peut l'être par simple clic sur son nom. Malheureusement au bout de quelques temps (demain par exemple), ce bel édifice se lézardera : les identifiants webdav sont modifiés régulièrement par Hubic (une fois par jour ?) et le montage ne peut plus se faire. Comment résoudre cette difficulté ? Deux solutions sont proposées :
- Manuelle : lancement de webdav_hubic_credentials.py, récupération manuelle des identifiants webdav et modification manuelle du fichier secrets selon la méthode expliquée ci-dessus. Lors de la nouvelle tentative de connexion dans Nautilus, tout fonctionne bien à nouveau.
- Par simple clic : création d'un script bash appelé par un lanceur qui effectuera l'opération de mise à jour et de remplacement des identifiants webdav.
Création du script de mise à jour des identifiants webdav
Deux scripts seront nécessaires pour réaliser cette opération. Il est proposé de les stocker dans un nouveau répertoire à créer dans $HOME/.davfs2/montage_auto/. De nombreux ubunteros préfèrent utiliser un répertoire Scripts dédié, à chacun sa méthode.
Le nouveau répertoire est ainsi créé :
usr@machine:~$ mkdir $HOME/.davfs2/montage_auto
Opération préalable
Le script de mise à jour et les scripts de montage du répertoire crypté ont été conçus pour une machine disposant dans un répertoire dédié de scripts divers de conception personnelle dont l'un est destiné à éviter d'utiliser des noms de fichiers déjà existant. Les scripts utilisés pour la connexion en webdav font appel à ce script, il est donc proposé d'ajouter ce script dans le répertoire de webdav sauf à devoir revoir la conception des scripts proposés sur cette page. Ce script, dénommé fichier_unique.sh se contente d'indiquer si un nom de fichier est utilisé dans le répertoire courant. Il est à copier tel quel dans $HOME/.davfs2/montage_auto/ sous le nom fichier_unique.sh. Ne pas oublier de le rendre exécutable.
- fichier_unique.sh
#!/bin/bash # # Création : 7 avril 2013 # Version : 2.0 - 18 mai 2013 # # # Test du nom du fichier de sortie, on incrémente le compteur si le nom est déjà utilisé # Renvoie un nouveau nom incrémenté d'une valeur de compteur si le fichier existe déjà, # nom inchangé sinon # Options : # -e : extension du nom de fichier à tester (aucune en cas d'omission) # -d : chemin du répertoire de test (répertoire courant en cas d'omission) # -c : initialisation de la valeur du compteur, 0 si omis # -l : nombre minimal de chiffres utilisés pour le nom du compteur, 2 par défaut # -m : motif séparant le compteur du nom de fichier, "_" par défaut # -n : nom de fichier à tester # -r : le nom de fichier à tester est un chemin, ajouter / à la liste des caractères autorisés # -x : absence de recherche automatique de l'extension si omise # -z : aucun motif de séparation du nom de fichier et du compteur (annule l'option -m et permet d'éviter l'usage du motif par défaut) # # Syntaxe : # fichier_unique.sh NOM_TESTE [option] [Option]... # fichier_unique.sh [option] [Option]... NOM_TESTE # fichier_unique.sh [option] [Option]... # if [[ "$1" == "-h" ]] || [[ "$1" == "-H" ]] # 000 #---------------------------------- Aide ------------------------------------------------ then echo "# Création : 7 avril 2013" echo "# Version : 2.0 - 18 mai 2013" echo "# Nom : nom_de_fichier_unique.sh" echo "# Test du nom du fichier de sortie, on incrémente le compteur si le nom est déjà utilisé" echo "# Renvoie un nouveau nom incrémenté d'une valeur de compteur si le fichier existe déjà," echo "# nom inchangé sinon" echo "# Options :" echo "# -c : initialisation de la valeur du compteur, 0 si omis" echo "# -d : chemin du répertoire de test (répertoire courant en cas d'omission)" echo "# -e : extension du nom de fichier à tester (aucune en cas d'omission)" echo "# -h, -H : affichage de l'aide (si passé en premier paramètre)" echo "# -l : nombre minimal de chiffres utilisés pour le nom du compteur, 2 par défaut" echo "# -m : motif séparant le compteur du nom de fichier, "_" par défaut" echo "# -n : nom de fichier à tester" echo "# -r : le nom de fichier à tester est un chemin, ajouter / à la liste des caractères autorisés" echo "# -x : absence de test sur l'extension si omise" echo "# -z : aucun motif de séparation du nom de fichier et du compteur (annule l'option -m et permet d'éviter l'usage du motif par défaut)" #---------------------------------- Corps du programme ----------------------------------- else # 000 if [[ -n "$1" ]] # 001 #--------- En cas d'absence de paramètre, on ne fera pas tourner la procédure. then # -------- initialisation des valeurs par défaut chemin="" compteur=-1 le_motif="_" longueur_compteur=2 extension="" repertoire=false if [[ "$#" > "1" ]] # S'il n'y a qu'un seul paramètre, c'est forcément un nom de fichier # donc pas nécessaire de rechercher les options #--------- Il y a plusieurs paramètres, initialisation des paramètres then # 0011 nb_var=$# i=1 motif="^[-][a-zA-Z]$" # regex : un tiret suivi d'une lettre -> une option #-------- Recherche du nom de fichier if [[ !("$1" =~ $motif) ]] then # 00111 si le premier paramètre n'est pas une option, # c'est un nom de fichier nom=$1 let "i=$i + 1" # On incrémente au deuxième paramètre qui doit être une option else # 00111 Vérification de la présence d'un nom de fichier # en fin de saisie (On considère qu'un nom saisi en début # de saisie a priorité sur une saisie en fin derniere_valeur=$(eval echo "\$$nb_var") let "j=$nb_var - 1" avant_derniere_valeur=$(eval echo "\$$j") motif="^[-][cdelmn]$" # Motif de regex pour tester la présence d'une option # qui nécessite un paramètre motif2="^[-][xz]$" # Motif de regex pour tester la présence d'une option qui # ne nécessite pas de paramètre if [[ !("$avant_derniere_valeur" =~ $motif) ]] || [[ !("$derniere_valeur" =~ $motif2) ]] # Si le dernier paramètre n'est ni -x, ni -z et que l'avant-dernier n'est # pas une option nécessitant un paramètre (-c -d -e -l -m -n), alors le # dernier paramètre est un nom de fichier then # 001111 nom=$derniere_valeur fi # 001111 fi # 00111 #-------- Récupération des options while [[ "$i" < "$nb_var" ]] # On va incrémenter de 2 en 2 les couples # option / valeur option do val="echo \"$*\" | cut -d\" \" -f$i" # Attention à ne pas oublier les guillemets pour $*, sinon # même risque qu'avec les variables $1, $3, etc. # je n'utilise pas les variables $1, $3 etc car eval echo "$i" # quand $i vaut "-e" ou "-n" ne parvient pas à afficher la # valeur de $i considérée comme un paramètre de echo option=$(eval $val) case $option in # ------------------------------------------------------------ -c ) # Compteur let "i=$i + 1" # incrémentation d'une unité pour atteindre le # paramètre de l'option val="echo \"$*\" | cut -d\" \" -f$i" valeur_option=$(eval "$val") motif="^[0-9]*$" # regex : un nombre entier positif if [[ "$valeur_option" =~ $motif ]] # 004 # Paramètre numérique then let "compteur=$valeur_option - 1" # on enlève 1 pour retrouver la fi # valeur initiale à la # première incrémentation ;; # ------------------------------------------------------------ -d ) # Chemin let "i=$i + 1" # incrémentation d'une unité pour atteindre le # paramètre de l'option val="echo \"$*\" | cut -d\" \" -f$i" valeur_option=$(eval "$val") motif="/$" # regex : chaine terminée par "/" if [[ "$valeur_option" =~ $motif ]] # Le chemin se termine par "/" then # 0021 chemin="$valeur_option" else # Si non, on ajoute "/" 0021 chemin="$valeur_option/" fi # 0021 motif="^~*[a-zA-Z0-9/._\-]+$" # test de la conformité du format du # chemin, espaces non acceptés if [[ !("$chemin" =~ $motif) ]] then chemin="" # Si le chemin n'est pas conforme, on l'élimine fi ;; # ------------------------------------------------------------ "-e" ) # extension let "i=$i + 1" # incrémentation d'une unité pour atteindre le # paramètre de l'option val="echo \"$*\" | cut -d\" \" -f$i" valeur_option=$(eval "$val") motif="^[.]" # regex : un point if [[ "$valeur_option" =~ $motif ]] # L'extension commence par "." then # 0022 extension="$valeur_option" else # 0022 extension=".$valeur_option" fi ;; # ------------------------------------------------------------ "-l" ) # Nb minimal de chiffres pour le compteur let "i=$i + 1" # incrémentation d'une unité pour atteindre le # paramètre de l'option val="echo \"$*\" | cut -d\" \" -f$i" valeur_option=$(eval "$val") longueur_compteur=$valeur_option ;; # ------------------------------------------------------------ "-m" ) # Motif utilisé pour séparer le nom du fichier du compteur let "i=$i + 1" # incrémentation d'une unité pour atteindre le # paramètre de l'option val="echo \"$*\" | cut -d\" \" -f$i" valeur_option=$(eval "$val") motif="^[a-zA-Z0-9._\-]+$" # C'est le motif de la regex ! # On teste la conformité du nom de fichier aux normes Posix, soit # 26×2 lettres de l'alphabet, aux 10 chiffres et aux 3 caractères # ".", "-" et "_". Si ce n'est pas le cas, motif par défaut maintenu if [[ ("$valeur_option" =~ $motif) ]] then le_motif=$valeur_option fi ;; # ------------------------------------------------------------ -n ) # nom let "i=$i + 1" # incrémentation d'une unité pour atteindre le # paramètre de l'option val="echo \"$*\" | cut -d\" \" -f$i" valeur_option=$(eval "$val") nom=$valeur_option ;; # ------------------------------------------------------------ "-r" ) # Le fichier à tester est un répertoire, inclure / dans les caractères autorisés pour le nom repertoire=true ;; # ------------------------------------------------------------ -x ) # Blocage de la vérification automatique de l'extension # aucune action mais permet d'éviter de chercher un paramètre # qui n'a pas à être saisi avec cette option ;; # ------------------------------------------------------------ "-z" ) # Absence de motif de séparation nom fichier / compteur # aucune action mais permet d'éviter de chercher un paramètre # qui n'a pas à être saisi avec cette option ;; # ------------------------------------------------------------ * ) # sinon, on saute le parmètre & on passe au suivant let "i=$i + 1" # incrémentation d'une unité pour atteindre le # paramètre de l'option esac # --------------------------------------------------------------------- let "i=$i + 1" done # ---------- Si l'option -z est passée, aucun motif de séparation n'est retenu, # même s'il a été saisi (faut être cohérent) if [[ $(echo $* | grep "\-z") != "" ]] then le_motif="" fi # --------- S'il n'y a qu'un seul paramètre, il s'agit d'un nom de fichier ------ else # 0011 nom=$1 fi # 0011 # ------- Vérification de l'extension (quel que soit le nb d'options passées ou pas if [[ $(echo $* | grep "\-x") == "" ]] && [[ $(echo $* | grep "\-e") == "" ]] # En l'absence d'extension -e saisie en option et de blocage par l'option -x # je recherche la présence d'une extension en fin de nom de fichier then # 0012 motif="(\.[a-zA-Z0-9]{3}[a-zA-Z0-9]?)$" # se termine par un point suivi de # 3 ou 4 caractères if [[ ("$nom" =~ $motif) ]] then # 00121 Le nom du fichier se termine par une extension longueur=$(echo ${#nom}) let "longueur=$longueur - 4" if [[ ${nom:$longueur:1} == "." ]] then # 001211 extension=${nom:$longueur:4} # j'affecte l'extension à sa variable nom=${nom:0:$longueur} else # 001211 let "longueur=$longueur - 1" extension=${nom:$longueur:5} # j'affecte l'extension à sa variable nom=${nom:0:$longueur} fi # 001211 fi # 00121 fi # 0012 # ------ Conformité du nom de fichier ------------------------------------------------- if $repertoire then motif="^[a-zA-Z0-9._\/\-]+$" # c'est un répertoire else motif="^[a-zA-Z0-9._\-]+$" fi nom_complet=$nom$extension if [[ ("$nom_complet" =~ $motif) ]] # On teste tout de même la conformité du nom de fichier aux normes Posix, soit # 26×2 lettres de l'alphabet, aux 10 chiffres et aux 3 caractères . - et _ # et si ce n'est pas le cas, aucun retour then # 0013 nom_final=$chemin$nom$extension # ---------- Test du nom de fichier ---------------------------------------- while [ -e "$nom_final" ] # 005 do # On incrémente le compteur tant qu'un nom de fichier non utilisé # n'est pas trouvé let "compteur=$compteur + 1" le_compteur=$(nombre_a_n_chiffres.sh $compteur -l $longueur_compteur) # Nom complet non utilisé du fichier nom_final="$chemin$nom$le_motif$le_compteur$extension" done # 005 # ----------- Restitution du nom de fichier - C'est fini -------------------- echo "$nom_final" fi # 0013 fi # 001 fi # 000 exit 0;
Le script de connexion au webdav
Déplacer webdav_hubic_credentials.py dans le nouveau répertoire $HOME/.davfs2/montage_auto/.
usr@machine:~$ mv $HOME/repertoire/webdav_hubic_credentials.py $HOME/.davfs2/montage_auto/
Enregistrer ensuite le script bash suivant dans un fichier nommé webdav_modifs_fichier_secrets.sh et sauvegardé dans le répertoire $HOME/.davfs2/montage_auto/ (par exemple copie des lignes ci-dessous dans gedit puis enregistrement par ctrl+S dans $HOME/.davfs2/montage_auto/) :
- webdav_modifs_fichier_secrets.sh
#!/bin/bash # # Mise à jour des identifiants webdav de connexion automatique à Hubic # # Paramètres # repertoire_du_fichier_du_webdav="$HOME/.davfs2/" fichier_des_cles=$($HOME/.davfs2/montage_auto/./fichier_unique.sh -d $repertoire_du_fichier_du_webdav -n fichier_des_cles.txt) fichier_du_webdav="secrets" repertoire_de_montage="$HOME/Documents/Hubic/Montage_Hubic" fichier_temporaire=$($HOME/.davfs2/montage_auto/./fichier_unique.sh -d $repertoire_du_fichier_du_webdav -n nouveau_secret.txt) fichier_du_webdav="secrets" # Récupération des paramètres Hubic (changement régulier - Tous les jours ?) $HOME/.davfs2/montage_auto/webdav_hubic-credentials_2.py > $fichier_des_cles tartempion=$(cat $fichier_des_cles) # Insertion du texte du fichier dans la variable tartempion i=1 val="echo \"$tartempion\" | cut -d\" \" -f1" mot=$(eval $val) # Lecture mot à mot - Recherche du mot "login" while [[ "$mot" != "" ]] && [[ "$mot" != "login:" ]] do # 0000 let "i=$i + 1" val="echo \"$tartempion\" | cut -d\" \" -f$i" mot=$(eval $val) done # 0000 # Récupération du login (qui est situé juste après le mot "login") if [[ $mot == "login:" ]] then # 0001 let "i=$i + 1" val="echo \"$tartempion\" | cut -d\" \" -f$i" login=$(eval $val) fi # 0001 # Je continue la lecture mot à mot - Recherche du mot "password" let "i=$i + 1" val="echo \"$tartempion\" | cut -d\" \" -f$i" mot=$(eval $val) while [[ "$mot" != "" ]] && [[ "$mot" != "password:" ]] do # 0002 let "i=$i + 1" val="echo \"$tartempion\" | cut -d\" \" -f$i" mot=$(eval $val) done # 0002 # Récupération du password (qui est situé juste après le mot "password") if [[ "$mot" == "password:" ]] then # 0003 let "i=$i + 1" val="echo \"$tartempion\" | cut -d\" \" -f$i" password=$(eval $val) fi # 0003 # Modification du fichier du webdav cd $repertoire_du_fichier_du_webdav # Lecture ligne à ligne à la recherche de la ligne relative au montage du webdav trouve=false while read -r ligne_webdav # le -r permet d'éviter que les \ soient interprétés à la lecture do # 0004 if [[ $(echo $ligne_webdav | cut -d" " -f1) != "$repertoire_de_montage" ]] then # 00040 Si la ligne courante n'est pas reconnue (ne concerne pas le webdav) if [[ $(echo $ligne_webdav | cut -d" " -f1) = "#" ]] && [[ $(echo $ligne_webdav | cut -d" " -f2) = "mise" ]] && [[ $(echo $ligne_webdav | cut -d" " -f3) = "à" ]] then # 000400 Insertion de la date de mise à jour echo "# mise à jour du : "$(date) >> $fichier_temporaire else # 000400 Sinon copie à l'identique echo "$ligne_webdav" >> $fichier_temporaire fi # 000400 else # 00040 Si la ligne courante est celle du webdav, insertion des nouveaux paramètres echo "$repertoire_de_montage $login $password" >> $fichier_temporaire trouve=true fi # 00040 done < $fichier_du_webdav # 0004 # Si le fichier de paramétrage du webdav ne contient aucune ligne relative au montage du webdav, création de la ligne if [[ "$trouve" != true ]] then # 0005 echo "" >> $fichier_temporaire echo "# Accès Hubic" >> $fichier_temporaire echo "#--------------" >> $fichier_temporaire echo "#" >> $fichier_temporaire echo "# mise à jour du : "$(date) >> $fichier_temporaire echo "$repertoire_de_montage $login $password" >> $fichier_temporaire fi # 0005 # Remplacement du fichier de paramétrage du webdav par le nouveau fichier mv "$fichier_du_webdav" "$fichier_du_webdav.anc" mv "$fichier_temporaire" "$fichier_du_webdav" chmod 600 "$fichier_du_webdav" rm "$fichier_des_cles" exit 0;
Rendre exécutable le fichier nouvellement créé :
usr@machine:~$ chmod +x $HOME/.davfs2/montage_auto/webdav_modifs_fichier_secrets.sh
Désormais tout appel à webdav_modifs_fichier_secrets.sh entraînera la mise à jour automatique du fichier $HOME/.davfs2/.secrets et permettra la connexion à l'espace de stockage distant Hubic dans Nautilus.
usr@machine:~$ $HOME/.davfs2/montage_auto/./webdav_modifs_fichier_secrets.sh
Ajouter un message
Pour rendre l'opération un peu plus conviviale, surtout si le script est appelé par un lanceur ainsi qu'on le verra ci-dessous, il peut être intéressant de confirmer l'exécution du script par un petit message. Il est proposé d'utiliser Zenity pour afficher une fenêtre d'information. pour ce faire il faut et il suffit d'insérer les lignes suivantes en fin de script bash (juste avant la ligne exit 0; qui termine le script :
zenity --info --title='Montage du dossier distant' --text="<span color=\"green\">Montage du dossier distant demandé</span>" --timeout=3
Désormais, à l’exécution du script une fenêtre surgissante indiquera que l'opération est lancée. Elle s'effacera d'elle même au bout de 3 secondes (timeout=3). En cas de problème avec Zenity, installer le paquet zenity si celui-ci n'est pas encore présent sur le système (normalement c'est le cas).
usr@machine:~$ sudo apt-get install zenity
Création du lanceur
L'étape suivante permet de créer un lanceur qui pourra être lancé d'un clic de souris dans la barre des lanceurs (Unity launcher) et assurera la mise à jour du fichier secrets.
Création du fichier du lanceur
La création d'un lanceur se fait par copie du fichier suivant dans $HOME/.local/share/applications :
- connect_webdav.desktop
[Desktop Entry] Name=Connexion webdav Hubic GenericName=Connexion webdav Hubic X-GNOME-FullName=Connexion webdav Hubic Comment=Se connecter à un espace webdav Hubic Exec=$HOME/.davfs2/montage_auto/webdav_modifs_fichier_secrets.sh Icon=$HOME/repertoire_icones/Icone_cloud.png Terminal=false Type=Application Categories=GNOME;GTK;Core; StartupNotify=true X-Ayatana-Desktop-Shortcuts=Se connecter à Hubic; [Se connecter à Hubic] Name=Se connecter à Hubic Exec=$HOME/.davfs2/montage_auto/webdav_modifs_fichier_secrets.sh
Ce fichier doit être sauvegardé dans $HOME/.local/share/applications sous le nom connect_webdav.desktop. Le choix du nom du fichier est libre, sous la réserve qu'il se termine par .desktop (de façon à identifier le fichier comme lanceur). Le choix du nom doit être effectué avec soin car il sera utilisé par le moteur de recherche de Unity dans le Dash. Pour la suite du tutoriel on considère que le nom connect_webdav.desktop est utilisé.
Les éléments de personnalisation suivants peuvent être utilisés (pour davantage de précisions voir lanceur) :
- Nom qui apparaît en infobulle lors du survol de l'icône par la souris : ligne 2 (à dupliquer en lignes 3 et 4)
- Script lancé par un clic sur l'icône : ligne 6
- Liste des options qui apparaissent après clic droit sur l'icône dans la barre des lanceurs : ligne 13
Dans le cas où plusieurs options sont proposées, il est nécessaire de placer le nom de chacune des options à la suite de la formule X-Ayatana-Desktop-Shortcuts=, les options étant séparées par des points-virgules ";" et la liste terminée de même. L'option est reprise ensuite selon la même orthographe entre crochets pour fixer ses paramètres.
Exemple :
Personnalisation du lanceur
Le fichier du lanceur est donc sauvegardé dans $HOME/.local/share/applications sous le nom connect_webdav.desktop.
Ajouter une icône
Ce lanceur ayant vocation à apparaître dans la barre de lanceur, il est plus esthétique de lui affecter une icône personnalisée. Totale liberté est laissée à l'ubuntero, il est conseillé une icône au format png, carrée, 128 x 128 px.
Cette icône (ou une autre) doit être enregistrée sur le disque de l'utilisateur. Dans le tutoriel elle a été enregistrée dans le répertoire $HOME/repertoire_icones/ sous le nom Icone_cloud.png (ligne 7 du fichier de lanceur).
Il est ensuite possible d'ajouter ce lanceur personnalisé à la barre des lanceurs : saisie du mot "webdav" (ou autre selon le nom retenu pour le lanceur) puis, une fois l'icône apparue dans le Dash, de la faire glisser dans la barre des lanceurs.
Cryptage du partage
Les données stockées chez hubiC sont "en clair" pour l'hébergeur, elles ne sont pas non plus cryptées lorsqu'elle transitent entre l'utilisateur et le serveur. Il est possible, en utilisant la méthode indiquée à la page davfs2, d'utiliser EncFS pour chiffrer la partition.
Création du répertoire crypté
Si on considère que le partage Hubic a été créé dans le répertoire /home/utilisateur/Hubic/Montage_Hubic, un répertoire crypté pourrait être créé à l'intérieur du répertoire Hubic qui serait donc situé à l'emplacement /home/utilisateur/Hubic/Montage_Hubic/Répertoire_crypté. Le répertoire "en clair" pourrait être situé à l'emplacement suivant : /home/utilisateur/Hubic/Hubic_en_clair (c'est à dire sur le disque de l'utilisateur et non pas sur le réseau). L'utilisateur devra donc monter son répertoire distant (automatique avec la technique proposée ci-dessus) puis monter son répertoire crypté dans /home/utilisateur/Hubic/Hubic_en_clair. En sauvegardant les données dans /home/utilisateur/Hubic/Hubic_en_clair, celles-ci seront automatiquement cryptées et transférées dans le répertoire distant.
Les instructions à passer en ligne de commande pour crypter ses données sont les suivantes :
usr@machine:~$ mkdir $HOME/Hubic/Hubic_en_clair/ usr@machine:~$ mkdir $HOME/Hubic/Montage_Hubic/Répertoire_crypte/ usr@machine:~$ encfs $HOME/Hubic/Montage_Hubic/Répertoire_crypte/ $HOME/Hubic/Hubic_en_clair/
Les deux premières lignes ne sont à saisir qu'une seule fois, lors de la création du répertoire crypté. Ensuite il suffit de monter ou de démonter le répertoire crypté lorsque vous en avez besoin :
Accès et verrouillage au dossier crypté
Pour le montage du répertoire (déjà utilisé) :
usr@machine:~$ encfs /home/utilsateur/Hubic/Montage_Hubic/Répertoire_crypté/ /home/utilsateur/Hubic/Hubic_en_clair/
Et pour le démontage :
usr@machine:~$ fusermount -u /home/utilsateur/Hubic/Hubic_en_clair/
Renforcement de la confidentialité : déplacement de la clé
Dans le schéma "classique" de encfs, le fichier permettant le déverrouillage du dossier crypté est palcé au même niveau que celui-ci, ce qui signifie, dans le cas d'un dossier distant, que ce fichier se trouve sur le serveur distant. C'est un peu ennuyeux si ce cryptage a été réalisé pour accroître la confidentialité des données vis à vis du fournisseur de stockage. Il convient donc de déplacer le fichier de déverrouillage dans un endroit sûr, d'en effectuer une copie elle-même sécurisée placée dans un autre endroit sûr (avec ccrypt) et d'indiquer à encfs à quel endroit se trouve ce fichier. Tout cela est clairement expliqué ici. Pour la suite du tutoriel on suppose que cette clé de déverrouillage est désormais sauvegardée sur votre disque dur, dans le répertoire $HOME/Documents/Hubic/, sous le nom .encfs6.xml. La commande de montage du dossier crypté devient donc :
usr@machine:~$ ENCFS6_CONFIG=$HOME/Documents/Hubic/.encfs6.xml encfs $HOME/Hubic/Montage_Hubic/Répertoire_crypté/ $HOME/Hubic/Hubic_en_clair/
La commande de démontage est sans changement.
Création d'un script pour monter et démonter le répertoire crypté
De façon à faciliter ces manipulations de montage et de démontage, il est proposé de confier ces missions à un script. Est utilisée dans ce cadre l'option –extpass de EncFS qui permet de récupérer le mot de passe de cryptage/décryptage en sortie d'un programme externe. Ce sont donc deux scripts qui vont être créés :
- Un script de récupération du mot de passe ;
- Un script de verrouillage / déverrouillage du répertoire crypté.
Le script de récupération du mot de passe
Le script de récupération du mot de passe utilise Zenity qu'il faudra peut être installer. Ce script sera sauvegardé dans le répertoire $HOME/.davfs2/montage_auto/ sous le nom webdav_recup_mdp_cryptage.sh. Le script :
- webdav_recup_mdp_cryptage.sh
#!/bin/bash # # Récupération du mdp pour connection à l'espace sécurisé (cryptage encfs) installé sur Hubic # # Se connecter à l'espace crypté if mot_de_passe=`zenity --password --title='Connection serveur distant' --text="Saisissez votre mot de passe pour déverouiller votre espace sécurisé dans le \"nuage\" : "` then if [ "$mot_de_passe" = "" ] then `zenity --error --title="Pas de saisie" --text="Aucun mot de passe saisi, connexion au webdav impossible" --timeout=6` exit fi else `zenity --error --title="Annulation" --text="Annulation, connexion au webdav impossible" --timeout=6` exit fi echo $mot_de_passe exit 0;
Ce script doit donc être téléchargé par l'utilisateur et sauvegardé dans le répertoire $HOME/.davfs2/montage_auto/ sous le nom webdav_recup_mdp_cryptage.sh.
Création du script de décryptage et de cryptage
La récupération du mot de passe étant organisée, il est maintenant possible de mettre en place le script qui permettra de monter et démonter les dossiers cryptés.
Le script proposé sera sauvegardé dans le répertoire $HOME/.davfs2/montage_auto/ sous le nom webdav_ouverture_dossier_crypte.sh.
- webdav_ouverture_dossier_crypte.sh
#!/bin/bash # # Connexion et deconnexion à l'espace sécurisé (cryptage encfs) installé sur Hubic # # Paramètres (Attention il est impératif de saisir le "/" de fin de chemin) chemin_complet_cle_encfs="$HOME/Documents/Hubic/.encfs6.xml" repertoire_de_stockage_des_donnees_cryptees="$HOME/Documents/Hubic/Montage_Hubic/Répertoire_crypte/" repertoire_de_stockage_des_donnees_decryptees="$HOME/Documents/Hubic/Hubic_en_clair/" repertoire_hubic_webdav="$HOME/Documents/Hubic/Montage_Hubic/" # Vérifier si l'espace crypté n'est pas déjà monté encfs_deja_monte=$(mount | grep ${repertoire_de_stockage_des_donnees_decryptees%?}) # Si déjà monté, on démonte if [[ "$encfs_deja_monte" != "" ]] then fusermount -u "$repertoire_de_stockage_des_donnees_decryptees" zenity --info --title='Dossier déjà monté' --text='<span color=\"blue\">Les données cryptées sont déjà montées, démontage en cours</span>' --timeout=3 exit else # N'est pas déjà monté, donc il faut se connecter # Se connecter à l'espace crypté webdav_monte=$(mount | grep ${repertoire_hubic_webdav%?}) # Vérification du montage du dossier Hubic, s'il ne l'est pas il est illusoire de vouloir accéder à son contenu if [[ "$webdav_monte" == "" ]] then zenity --error --title='Webdav non monté' --text="<span color=\"red\">Le webdav n'est pas monté, impossible par conséquent de monter le dossier crypté</span>" --timeout=6 exit # Si le dossier distant Hubic est monté, montage du dossier crypté avec indication de localisation de la clé else ENCFS6_CONFIG=$chemin_complet_cle_encfs encfs --extpass=$HOME/.davfs2/montage_auto/webdav_recup_mdp_cryptage.sh $repertoire_de_stockage_des_donnees_cryptees $repertoire_de_stockage_des_donnees_decryptees zenity --info --title='Montage du dossier crypté' --text="<span color=\"green\">Montage du dossier crypté demandé</span>" --timeout=3 fi fi exit 0;
Ce script doit donc être téléchargé par l'utilisateur, modifié si nécessaire (lignes 7 à 10) et sauvegardé dans le répertoire $HOME/.davfs2/montage_auto/ sous le nom webdav_ouverture_dossier_crypte.sh.
Le script permet de monter le répertoire crypté après avoir demandé le mot de passe ou, si le répertoire crypté est déjà présent, de le démonter.
Utilisation
- L'utilisation du script suppose que le webdav soit actif et monté. Si le webdav n'est pas monté, zenity affichera un avertissement qui s'effacera au bout de 6 secondes et rien ne se passera.
- L'usage du script suppose aussi que le répertoire crypté ait d'ores et déjà été créé (voir ci-dessus pour création en mode console) et que le répertoire de montage du fichier décrypté (Montage_en_clair) existe également.
- Pour monter le webdav, se rendre dans Nautilus après avoir lancé webdav_modifs_fichier_secret et monter le répertoire distant par un clic sur le périphérique. Lorsque le périphérique est monté, il est possible de lancer le script webdav_ouverture_dossier_crypte.sh.
- Lors de son lancement, le script vérifie si le dossier crypté est monté ou ne l'est pas (lignes 14 à 18).
- Si le dossier crypté n'est pas encore monté, une première vérification est réalisée. Cette première vérification a pour objet de déterminer si le webdav Hubic est monté car s'il ne l'est pas, il n'est pas possible d'accéder aux fichiers qu'il contient. Ce contrôle est réalisé par les lignes 27 à 35.
- Si l'espace distant est monté, alors le script de récupération du mot de passe webdav_recup_mdp_cryptage.sh est appelé par EncFS (ligne 39) via l'option –extpass. Ce dernier ouvre une fenêtre de saisie pour le mot de passe puis, une fois celui-ci renseigné par l'utilisateur, envoie le mot de passe à EncFS qui monte le répertoire. Zenity (ligne 40) informe alors l'utilisateur que cette partie du script a été appelée (mais pas qu'elle s'st déroulée avec succès) par une fenêtre surgissante qui disparaît au bout de 3 secondes (timeout=3).
- Si, au contraire, le dossier crypté est déjà monté, celui-ci est alors démonté (lignes 18 à 21) et l'utilisateur est informé de la tentative (mais pas de son résultat, une fois encore).
Création du lanceur
Afin de rendre toutes ces manipulations le plus simple possible, il est proposé de créer un lanceur dans la barre des lanceurs, ou plus précisément d'étendre les fonctions du lanceur créé un peu plus haut pour permettre la connexion à Hubic. Deux options sont ajoutées au lanceur, Monter le répertoire crypté et Démonter le répertoire crypté. Compte tenu du mode de fonctionnement du script webdav_ouverture_dossier_crypte.sh une seule option est nécessaire puisque l'appel au script monte et démonte alternativement le dossier crypté, toutefois en terme d'ergonomie la distinction peut avoir son utilité. C'est ce qui est retenu. Le lanceur est donc ainsi modifié :
- connect_webdav.desktop
[Desktop Entry] Name=Connexion webdav Hubic GenericName=Connexion webdav Hubic X-GNOME-FullName=Connexion webdav Hubic Comment=Se connecter à un espace webdav Hubic Exec=$HOME/.davfs2/montage_auto/webdav_modifs_fichier_secrets.sh Icon=$HOME/repertoire_icones/Icone_cloud.png Terminal=false Type=Application Categories=GNOME;GTK;Core; StartupNotify=true X-Ayatana-Desktop-Shortcuts=Se connecter à Hubic;Monter le répertoire crypté;Démonter le répertoire crypté; [Se connecter à Hubic] Name=Se connecter à Hubic Exec=$HOME/.davfs2/montage_auto/webdav_modifs_fichier_secrets.sh [Monter le répertoire crypté] Name=Monter le répertoire crypté situé dans le dossier distant Hubic Exec=$HOME/.davfs2/montage_auto/webdav_ouverture_dossier_crypte.sh [Démonter le répertoire crypté] Name=Démonter le répertoire crypté situé dans le dossier distant Hubic Exec=$HOME/.davfs2/montage_auto/webdav_ouverture_dossier_crypte.sh
Ce lanceur doit donc être sauvegardé dans $HOME/.local/share/applications sous le nom connect_webdav.desktop, il prendra la place du précédent. Sans surprise les lignes "Exec" des deux dernières options sont identiques mais c'est plus clair pour l'utilisateur.
Le lanceur doit être utilisé ainsi :
- On commence par mettre à jour le dossier secrets : clic sur l'icône Connexion webdav Hubic dans la barre des lanceurs avec le bouton gauche de la souris ou bien clic bouton droit puis sélection de l'option Se connecter à Hubic;
- Montage du dossier distant Hubic dans Nautilus (clic sur le nom dans la liste des périphériques);
- Montage du répertoire crypté par clic bouton droit sur l'icôneConnexion webdav Hubic dans la barre des lanceurs puis sur l'option Monter le répertoire crypté
Le répertoire distant crypté devient ainsi directement accessible dans Nautilus, sous la forme d'un périphérique autonome.
- La fermeture du répertoire crypté est obtenue par un nouveau clic bouton droit sur l'icône Connexion webdav Hubic dans la barre des lanceurs puis sur l'option Démonter le répertoire crypté. Le dossier distant Hubic reste accessible mais pas le répertoire crypté.
Suppression du partage
Pour supprimer le compte hubiC, se référer aux conditions du fournisseur. Pour supprimer la connexion à la plate-forme distante, il suffit de supprimer les lignes insérées dans /etc/fstab ou, mieux, de restaurer l'ancienen version (attention à la gestion des droits). Pour parfaire les choses, vous pouvez aussi supprimer la ligne ajoutée au fichier $HOME/.davfs2/secrets.
Voir aussi
- Discussion « Installer Hubic sous ubuntu » sur le forum Ubuntu-fr
- Discussion « [Script] Client Hubic pour linux ;) » sur le forum Ubuntu-fr
- Discussion « installation de Hubic sur xubuntu 12.04 » sur le forum Ubuntu-fr
—- Contributeurs principaux : Libaud Zococo.
Basé sur « Installer sur Ubuntu hubiC proposant 25 Go gratuit sur le cloud » par Stéphane Robert.