Deblan blog

Tag #Web

Sharepoint Office365 sur Linux : automatiser l'authentification

Suite de l'aventure avec Sharepoint !

On a pu passer 2 étapes cruciales pour jouer avec Sharepoint Online :

Après quelques jours d'utilisation, il s'avère que les cookies d'authentification ne sont plus valables. C'est un gros problème car c'est pénible de les récupérer manuellement pour ensuite les injecter dans le fichier de configuration Davfs.

J'ai planché quelques heures sur une solution : réaliser le parcours de connexion d'un utilisateur qui passerait par un navigateur web.

Le projet est libre et voici comment l'installer et l'utiliser.

Note : il faut avoir NodeJS sur sa machine. J'ai développé le code en version 6.13.0.

Il faudra déclarer 3 variables d'environnement contenant le site Sharepoint, l'identifiant de connexion et le mot de passe :

Il ne reste plus qu'à lancer le script qui devrait vous retourner du JSON avec les 2 cookies dedans :

À vous de choisir la méthode pour alimenter la configuration de Davfs avec ces données !


Sharepoint Office365 sur Linux (Webdav/Davfs) avec des fichiers accentués

Suite de l'aventure avec Sharepoint !

Je me suis rendu compte que les répertoires et les fichiers nommés avec des accents ne sont pas montés par Davfs. Le problème vient bien sur de Microsoft qui n'est pas foutu d'implémenter un protocole en suivant les standards ! Le support technique est une vraie plaie et ne veut pas comprendre que le problème vient de chez eux…

En effet, les spécifications WebDAV indiquent que les caractères spéciaux (espace compris) doivent être encodés en %XXX. Par exemple, on doit retrouver %C3%A9 à la place de é. Or, Sharepoint ne remplace que les espaces (%20). Voici une partie de la réponse HTTP formée par Sharepoint pour un fichier nommé "éducation.pdf" :

<D:href>https://foo.sharepoint.com/sites/bar/Documents%20partages/éducation.pdf</D:href>

Alors que ça devrait être sous cette forme :

<D:href>https://foo.sharepoint.com/sites/bar/Documents%20partages/%C3%A9ducation.pdf</D:href>

Du coup, j'ai du travaillé sur un correctif et voici une POC qui corrige le problème. Elle consiste à faire passer les requêtes HTTP de DavFS à travers un proxy qui fera le boulot de Sharepoint : encoder les caractères en question !

Je travaille sur ma machine de dev dans ~/www/repo/sharepoint-webdav-proxy.

J'ai choisi le proxy mitmproxy car on peut modifier les requêtes et les réponses à la volé.

Les binaires de mitmproxy sont placés dans ./bin/. Si vous lancez une première fois bin/mitmproxy, des certificats SSL seront créés dans ~/.mitmproxy/.

Configuration de DavFS :

$ sudo cp ~simon/.mitmproxy/mitmproxy-ca-cert.pem /etc/davfs2/certs/

Dans /etc/davfs2/davfs2.conf, j'ai ajouté :

[/mnt/sharepoint/]
proxy 127.0.0.1:8118
trust_ca_cert /etc/davfs2/certs/mitmproxy-ca-cert.pem
use_proxy 1
[...]

Adapteur WebDAV :

Dans src/webdav-adapter.py :

import mitmproxy.addonmanager
import mitmproxy.http
import re

class WebdavAdapter:
    def response(self, flow: mitmproxy.http.HTTPFlow):
        data = flow.response.text
        urls = re.findall('(https?[^<\'"]+)', data)

        sorted(urls, key=len)

        for url in reversed(urls):
            data = data.replace(url, self.fixAccents(url))

        flow.response.text = data

    def fixAccents(self, data):
        data = data.replace('\xc3\xb4', '%C3%B4') # ô
        data = data.replace('\xc3\x94', '%C3%94') # Ô
        data = data.replace('\xc3\xa0', '%C3%A0') # à
        data = data.replace('\xc3\x80', '%C3%80') # À
        data = data.replace('\xc3\xa2', '%C3%A2') # â
        data = data.replace('\xc3\x82', '%C3%82') # Â
        data = data.replace('\xc3\xa4', '%C3%A4') # ä
        data = data.replace('\xc3\x84', '%C3%84') # Ä
        data = data.replace('\xc3\xa9', '%C3%A9') # é
        data = data.replace('\xc3\x89', '%C3%89') # É
        data = data.replace('\xc3\xa8', '%C3%A8') # è
        data = data.replace('\xc3\x88', '%C3%88') # È
        data = data.replace('\xc3\xaa', '%C3%AA') # ê
        data = data.replace('\xc3\x8a', '%C3%8A') # Ê
        data = data.replace('\xc3\xab', '%C3%AB') # ë
        data = data.replace('\xc3\x8b', '%C3%8B') # Ë
        data = data.replace('\xc3\xaf', '%C3%AF') # ï
        data = data.replace('\xc3\x8f', '%C3%8F') # Ï
        data = data.replace('\xc3\xae', '%C3%AE') # î
        data = data.replace('\xc3\x8e', '%C3%8E') # Î
        data = data.replace('\xc3\xb4', '%C3%B4') # ô
        data = data.replace('\xc3\x94', '%C3%94') # Ô
        data = data.replace('\xc3\xb6', '%C3%B6') # ö
        data = data.replace('\xc3\x96', '%C3%96') # Ö
        data = data.replace('\xc3\xb9', '%C3%B9') # ù
        data = data.replace('\xc3\x99', '%C3%99') # Ù
        data = data.replace('\xc3\xbb', '%C3%BB') # û
        data = data.replace('\xc3\x9b', '%C3%9B') # Û
        data = data.replace('\xc3\xbc', '%C3%BC') # ü
        data = data.replace('\xc3\x9c', '%C3%9C') # Ü
        data = data.replace('\xc3\xbf', '%C3%BF') # ÿ
        data = data.replace('\xc5\xb8', '%C5%B8') # Ÿ
        data = data.replace('\xc3\xa7', '%C3%A7') # ç
        data = data.replace('\xc3\x87', '%C3%87') # Ç

        return data

addons = [
    WebdavAdapter()
]

Lancement du proxy :

./bin/mitmdump --mode regular --listen-host 127.0.0.1 --listen-port 8118 -s ./src/webdav-adapter.py

Une fois tout ça réalisé, mount.davfs va pouvoir monter les répertoires/fichiers accentués.


Monter un partage Sharepoint Office365 sur Linux (Webdav/Davfs)

Dans le cadre de mon travail, je développe une application web (nommée Tools) qui fait office de boite à outils pour le groupe Zenitude. L'idée de l'application est de fournir un ensemble d'outils pour faciliter le travail de mes collaborateurs.

Parmi la flopée de fonctionnalités, on trouve des interfaces qui affichent des données récupérées depuis des fichiers Excel. Elles sont analysées et mises en page par l'application (graphiques et tableaux).

Ces fichiers sont initialement déposés sur un espace collaboratif Sharepoint délivré par Office365. J'avais pour objectif de travailler avec les API de Microsoft mais c'est un véritable calvère. C'est mal documenté et le support technique de premier niveau est complètement naze. Du coup, je me suis résolu à faire des formulaires pour déposer les fichiers manuellement.

Pour éviter d'avoir des formulaires d'upload de fichier, je souhaite monter le partage Sharepoint sur le serveur afin d'accéder, en quasi temps réel, au contenu des fichiers qui m'intéressent. Microsoft fournit OneDrive qui est un outil de synchronisation pour monter le partage Sharepoint sur son ordinateur mais seul Microsoft Windows et IOS sont supportés. Il s'appuie sur le protocole WebDAV mais authentifie les utilisateurs avec le protocole OAuth2.

Sous Linux, davfs2 permet de faire des montages WebDAV dans son système de fichiers. La problématique d'authentification via OAuth2 est réelle car impossible de passer un couple login/mot de passe classique. Une solution existe et consiste à récupérer des cookies générés après l'authentification OAuth2 via un navigateur et indiquer à davfs2 de les injecter dans les requêtes HTTP WebDAV.

Pour des questions de sécurité, j'ai ajouté à l'organisation Office365 un compte utilisateur qui, par défaut, ne peut lire que les fichiers du partage. Lorsque que je me connecte à Office365 via un navigateur web en utilisant ce compte, 2 cookies sont créés : rtFa et FedAuth. Il faut conserver leur valeur respective car nous en auront besoin pour configurer le montage.

On va installer le driver davfs2 pour réaliser le montage :

# aptitude install davfs2

Je décide que le point de montage sera dans /mnt/sharepoint. Dans /etc/davfs2/davfs2.conf, on indique à davfs2 d'ajouter les cookies. Il faut bien évidement remplacer XXXXXX et YYYYYY par ce que vous avez récupéré :

[/mnt/sharepoint/]
ask_auth 0
add_header Cookie rtFa=XXXXXX;FedAuth=YYYYYY

Il reste maintenant à faire le montage :

# mount.davfs -o ro "https://foo.sharepoint.com/bar/Documents partages" /mnt/sharepoint

Si tout se passe bien, vous devrier avoir le montage fonctionnel. Ça ne sera pas détaillé ici mais vous pouvez maintenant affiner la configuration, faire du cache sur les fichiers, gérer les permissions plus finement, passer par /etc/fstab pour automatiser le montage, etc.


Remote i3-wm WS : ma télécommande pour bureau Debian GNU/Linux

Il m'arrive d'avoir besoin de prendre le contrôle de ma machine via mon Android (bouger la souris, scroller et taper du texte).

J'ai quasiment toujours utilisé l'application Pointer Host. elle s'appuie sur un serveur Java lancé sur ma machine. Pour bouger la souris et générer des cliques, elle est très efficace. Cependant, l'écriture de caractères a toujours posé problème (chiffres et lettres accentuées erronés).

Depuis quelques semaines, j'ai envie de jouer avec les websockets et réécrire une appli du genre m'a semblé être un bon exercice.

Ce que je vais vous présenter est une POC. Cette application n'est pas sécurisée et est orientée pour mes besoins. Il est cependant très simple de la faire évoluer.

Voici mon cahier des charges :

  1. aucune application ne doit être installée sur mon téléphone
  2. utilisation du navigateur web pour le pilotage
  3. pouvoir bouger la souris
  4. pouvoir générer des cliques
  5. pouvoir scroller
  6. pouvoir taper des mots
  7. pouvoir lancer des raccouris claviers
  8. pouvoir gérer le volume du son
  9. pour Spotify : lancer et mettre en pause la musique, avancer et reculer dans la playlist en cours de lecture
  10. pouvoir changer de workspace dans mon gestionnaire de fenêtres i3-wm

Les outils pour scripter tout ça sont connus :

  • xdotool pour simuler un clavier et une souris (3, 4, 5, 6, 7) :
    • xdotool type "ceci va être tapé"
    • xdotool key Enter (touche Entrée)
    • xdotool click 1 (clique gauche)
  • amixer pour gérer le volume (8) :
    • amixer set Master 50% (volume à 50%)
  • playerctl pour piloter Spotify (9) :
    • playerctl -p spotify next (titre suivant)
  • i3-msg pour piloter i3-wm (10) :
    • i3-msg 'workspace "Foo"' (affichage du workspace Foo)

Websocket est un protocole réseau issu du web qui permet de créer un canal full-duplex entre un client et un serveur. Ils peuvent donc communiquer en temps réel dans une connexion TCP.

Comme à mon habitude et par esprit de contradiction (pas de NodeJS), j'ai décidé d'écrire la partie serveur en PHP 7. La partie cliente est en HTML 5 avec un peu de javascript.

Entre le serveur et le client, ce sont des messages textes qui sont échangés. J'ai décidé de les formater en JSON et seul le client va en envoyer. Ils sont toujours sous cette forme : {"type":"un type de message", [données complémentaires]}. Voici quelques exemples :

  • {"type":"workspace","value":"1. IRC"}
  • {"type":"pointer","click":"left"}
  • {"type":"media","value":"next"}
  • {"type":"volume","value":"down"}
  • {"type":"scroll","value":"up"}
  • {"type":"pointer","x":"-2","y":"3"}
  • {"type":"text","value":"Un texte"}

On peut aussi envoyer plusieurs messages dans un seul. Voici un exemple qui va permettre d'ouvrir urxvt via dmenu que je lance avec win+d :

{"type":"messages","value":[{"type":"keys","value":"win,d"},{"type":"text","value":"urxvt"},{"type":"key","value":"enter"}]}

Ces messages sont générés par le client et sont interprétés par des messageHandler une fois transmis au serveur. En voici un exemple :

Le code source de l'application est disponible sur deblan/remote-i3wm-ws et la procédure d'installation est simple :

Pour lancer le serveur websocket, il faut exécuter server/server start (@see restart et stop). Le serveur va écouter sur le port 14598. Concernant la partie cliente, vous pouvez créer un vhost Apache/Nginx qui pointera sur client/ ou lancer le serveur web built-in de PHP via php -S 0.0.0.0:15000 -t client/. Il faudra à présent vous connecter au serveur web depuis un navigateur.

Quelques captures de la partie cliente :

Remote i3-wm WS: keyboardRemote i3-wm WS: i3Remote i3-wm WS: mouseRemote i3-wm WS: media

Je vais essayer de faire une vidéo de démonstration. Depuis mon Samsung S8, ça fonctionne du feu de dieu et sur un petit Iphone 4S, c'est tout aussi fonctionnel (à part l'interface web un peu étriquée).

Edit 1

  • dbus-send a été remplacé par playerctl (merci Thomas L)
  • le type messages a été ajouté et permet d'envoyer plusieurs messages (cf l'exemple avec urxvt) et les mises à jour du code

Edit 2

  • Le code PHP du serveur a été déplacé dans server/src/resource/server.php
  • server/server est à présent un script shell et permet de lancer, relancer et stopper le serveur websocket (server/server start|restart|stop)

Uzbl-tabbed, mon nouveau navigateur hors développement, scripts

J'utilise à présent Uzbl-tabbed comme navigateur (hormis quand je fais du développement web). Il fonctionne à merveille, sans compter l'incroyable facilité de personnalisation.

Voici quelques éléments de ma configuration :

Clique molette : ouverture dans un onglet
@bind  <Button2>  = sh 'if [ "$1" ]; then echo "event NEW_TAB $1" > "$UZBL_FIFO"; else echo "uri $(xclip -o | sed s/\\\@/%40/g)" > "$UZBL_FIFO"; fi' '\@SELECTED_URI'
Divers binds
@cbind <Ctrl>n = event REQ_NEW_WINDOW # nouvelle fenêtre
@cbind <Ctrl>r = reload # rechargement
@cbind <Ctrl>R = reload_ign_cache # rechargement sans cache
@cbind <Mod1>b = back # précédent
@cbind <Mod1>n = forward  suivant 
@cbind <Ctrl>w = exit # fermerture d'onglet/fenêtre

@on_event NEW_WINDOW  sh 'uzbl-tabbed "$1"' %r
@cbind  clone = event REQ_NEW_WINDOW \@uri # copie de fenêtre/fenêtre
Gestion de bookmarks avec des tags

Ce script est un hack de celui présent sur le site d'Uzbl.

  • Emplacement : @scripts_dir/bookmark_with_tags_for_folders.sh
  • Bind : @cbind <Ctrl>d = spawn @scripts_dir/bookmark_with_tags_for_folders.sh
#!/bin/bash
# @scripts_dir/bookmark_with_tags_for_folders.sh
#NOTE: it's the job of the script that inserts bookmarks to make sure there are no dupes.

file=${XDG_DATA_HOME:-$HOME/.local/share}/uzbl/bookmarks

[ -r "$file" ] || exit

DMENU_SCHEME="bookmarks"
DMENU_OPTIONS="xmms vertical resize"

. "$UZBL_UTIL_DIR/dmenu.sh"
. "$UZBL_UTIL_DIR/uzbl-dir.sh"

TAG=`cat $file | cut -d" " -f2 | sort -u | $DMENU -nb \#303030 -nf khaki -sb \#CCFFAA -sf \#303030`

goto=`grep $TAG $file | cut -d" " -f1,3- | while read url name; do [ -z "\$name" ] || name="\$name "; echo "\$name: $url"; done | $DMENU $COLORS | cut -d":" -f2-`

[ -n "$goto" ] && echo "uri $goto" > "$UZBL_FIFO"
Le contrôle+L de Firefox
  • Emplacement : @scripts_dir/prompt_url.sh
  • Bind : @cbind <Ctrl>l = spawn @scripts_dir/prompt_url.sh
#!/bin/sh

goto=$(zenity --entry --text "$UZBL_TITLE" --entry-text "$UZBL_URI" --title "$UZBL_TITLE")

if [ $? -eq 0 ]; then
	echo "uri $goto" > "$UZBL_FIFO"	
fi
Le contrôle+K de Firefox
  • Emplacement : @scripts_dir/prompt_search.sh
  • Bind : @cbind <Ctrl>k = spawn @scripts_dir/prompt_search.sh
#!/bin/sh

search=$(zenity --entry --text "Effectuer une recherche" --entry-text "" --title "UZBL : Effectuer une recherche")

if [ $? -eq 0 ]; then
	echo "uri http://www.google.fr/search?q=$(echo "$search" | sed 's/ /%20/g')" > "$UZBL_FIFO"	
fi
Gestion du zoom à la Firefox (contenu + conteneur)
Binds :
@cbind <Ctrl>i         = js (function() { var event = document.createEvent('HTMLEvents'); event.initEvent('uzbl_zoom_in', true, true); document.dispatchEvent(event); } )();
@cbind <Ctrl><Shift>I  = js (function() { var event = document.createEvent('HTMLEvents'); event.initEvent('uzbl_zoom_out', true, true); document.dispatchEvent(event); } )();
@cbind <Ctrl>à         = js (function() { var event = document.createEvent('HTMLEvents'); event.initEvent('uzbl_zoom_init', true, true); document.dispatchEvent(event); } )();

@on_event   LOAD_COMMIT    script @scripts_dir/zoom.js

Dans @scripts_dir/zoom.js :

function get_cookie(name) {
	var dc = document.cookie;
	var prefix = name + '=';
	var begin = dc.indexOf('; ' + prefix);

	if (begin == -1) {
		begin = dc.indexOf(prefix);

		if (begin!= 0) {
			return null;
		}

	} 
	else {
		begin += 2;
	}

	var end = document.cookie.indexOf(';', begin);

	if (end == -1) {
		end = dc.length;
	}

	return unescape(dc.substring(begin + prefix.length, end));
}

var step = function()
{
	return 0.1;
}

var get_body = function()
{
	var body = document.getElementsByTagName('body');

	return body ? body[0] : null;
}

var get_body_zoom = function()
{
	return get_body().getAttribute('data-zoom') ? parseFloat(get_body().getAttribute('data-zoom')) : 1;
}

var set_body_zoom = function(zoom)
{
	get_body().setAttribute('data-zoom', zoom);
	get_body().style.zoom = zoom;
	document.cookie='uzbl_zoom='+zoom+';path=/;expires=Tue, 2 Jun 2020 00:00:00 UTC;'	
}

var zoom_in = function()
{
	set_body_zoom(get_body_zoom() + step());
}

var zoom_out = function()
{
	set_body_zoom(get_body_zoom() - step());
}

var zoom_init = function()
{
	set_body_zoom(1);
}

var zoom_retrieve = function()
{
	var zoom = get_cookie('uzbl_zoom');

	if (zoom) {
		set_body_zoom(zoom);
	}
}

document.addEventListener('uzbl_zoom_in', zoom_in, true);
document.addEventListener('uzbl_zoom_out', zoom_out, true);
document.addEventListener('uzbl_zoom_init', zoom_init, true);
document.addEventListener('DOMContentLoaded', zoom_retrieve, true);

J'espère que ça vous sera utile :)