Sélectionnez le type d'affichage

Linux (fr)

  • Les sources de données système sous Linux avec NSS (Laboratoire Linux SUPINFO)

    Les sources de données système sous Linux avec NSS

     

    Note: ce document est le premier d'un cycle de trois articles sur l'authentification sur les systèmes Linux. Les suivants se trouvant ici et là.

    On utilise souvent la commande cat /etc/passwd pour connaitre la liste des utilisateurs d'un système Linux. Bien que le résultat renvoyé soit correct dans la grande majorité des cas, ce n'est pas la méthode que l'on devrait utiliser. En effet l'affichage du fichier /etc/passwd renvoie la liste des utilisateurs locaux uniquement. Mais si le système est relié à un serveur LDAP, les utilisateurs de ce serveur n’apparaîtront pas, bien qu'il soit possible de se connecter avec sur la machine.

     

    Name Service Switch

    La bonne méthode pour afficher la liste des utilisateurs est l'utilisation de la commande getent suivie du paramètre passwd. Celle-ci va interroger les différentes sources d'utilisateurs définies pour le système. Ces sources sont gérées par le mécanisme NSS (pour « Name Service Switch »). Et NSS ne s'occupe pas seulement des sources d'utilisateurs, mais aussi de leurs mots de passe, des groupes d'utilisateurs, des noms d'hôtes, des protocoles et services connus du système, etc.

    Cependant, bien que NSS permette de choisir les sources de données depuis lesquelles le système ira chercher les informations dont il a besoin, ce n'est pas lui qui défini les connexions vers ces sources de données.

    Voici la liste des bases de données (présentes habituellement sous la forme de fichiers plats) que l'on a l'habitude d'interroger en général et que NSS est capable de gérer :

    Bases de données Description Fichier correspondant
    aliases Alias des adresses e-mail /etc/aliases
    ethers Numéros Ethernet /etc/ethers
    group Groupes d'utilisateurs pour l'accès aux fichiers /etc/group
    hosts Correspondances entre les noms d'hôtes et les adresses IP /etc/hosts
    netgroup Groupes d'utilisateurs pour l'accès aux ressources réseau /etc/netgroup
    networks Noms et masques de réseau /etc/networks
    passwd Utilisateurs système /etc/passwd
    publickey Clés publiques utilisées par NFS et NIS+ /etc/publickey
    rpc Correspondances entre les noms et les numéros de RPC connus /etc/rpc
    services Correspondances entres les numéros de ports et les services réseau connus /etc/services
    shadow Mots de passes chiffrés des utilisateurs /etc/shadow

     

    Ces bases de données ne sont pas utilisées sur tous les systèmes, comme par exemple les aliases plutôt réservés aux serveurs mail, mais on retrouve les bases standard comme passwd, shadow ou group.

    Pour chacune de ces bases de données on va pouvoir demander à NSS d'interroger les fichiers plats locaux listés ci-dessus ainsi que diverses sources externes. Par exemple pour les noms d'hôtes, on va pouvoir configurer NSS pour interroger le fichier /etc/hosts puis les serveurs DNS.

     

    Le fichier nsswitch.conf

    La configuration de l'ordre d'interrogation des sources se fait très simplement à l'aide du fichier /etc/nsswitch.conf. Voici un fichier d'exemple issue d'un système Ubuntu :

    passwd:		compat 
group:		compat 
shadow:		compat 

hosts:		files mdns4_minimal [NOTFOUND=return] dns mdns4 
networks:	files 

protocols:	db files 
services: 	db files 
ethers:		db files 
rpc:		db files 

netgroup:	nis

    Sur chaque ligne de celui-ci, est décrit une base de données et les sources depuis lesquelles on va chercher ces données. Chaque ligne aura donc cette forme :

    base_de_données:	source1 [STATUT=action] source2 source3

    NSS ira interroger chaque source une par une dans l'ordre dans lesquelles elles sont inscrites. Chaque interrogation d'une source renverra un statut parmi ceux listés ci-dessous et sera suivie par l'action par défaut :

    Statut Description Action par défaut
    success Succès de la récupération de la donnée recherchée. return
    notfound Accès au service de donnée réussi mais donnée non trouvée. continue
    unavail Le service est indisponible de manière permanente. Cela peut indiquer que le fichier nécessaire n'est pas lisible, ou, pour les services réseau, que le serveur n'est pas disponible ou n'accepte pas les requêtes. continue
    tryagain Le service est temporairement indisponible. Cela signifie qu'un fichier est verrouillé, et qu'un serveur ne peut pas actuellement accepter davantage de connexions. continue

     

    Il est possible de demander à arrêter ou continuer le processus entre deux sources suivant ce statut grâce à une mention du type [STATUT=action]. Cela permet d'exécuter l'action de son choix et non celle par défaut.

    L'action peut être l'une des deux suivantes :

    • return : s'arrêter ici et renvoyer les résultats trouvés
    • continue : interroger le service suivant

     

    Les sources de données disponibles

    Pour obtenir les données recherchées, on peut interroger différents services locaux ou distant comme par exemple les fichiers plats, un annuaire LDAP, une base de données SQL, etc. Par défaut les services disponibles sont files, db, nis et nisplus ainsi que compat pour les bases passwd, group et shadow. De plus, la base données hosts dispose de la source dns qui n'est utilisable que sur elle.

    Mais pour se connecter à des services plus évolués il faut disposer des bons modules. Ceux-ci se trouvent le plus souvent dans le répertoire /lib et ont un nom de la forme libnss_XXX.so.Y. Avec XXX pour le nom du service et Y le numéro de version de la glibc dans laquelle il s'intègre. Ces modules sont en grande partie installables depuis le gestionnaire de paquet de votre distribution.

    Et en voici une liste des plus courants :

    Nom du module Description
    files Utiliser les fichiers plats du système local.
    compat Similaire à files mais permet en plus d'utiliser un annuaire NIS inclus directement dans les fichiers passwd, groups et shadow et non dans le fichier nsswitch.conf. Pour plus d'informations, voir le lien correspondant à la fin de cet article.
    db Utiliser les fichiers au format Berkeley Database File.
    nis Connexion à un annuaire NIS (ancêtre de LDAP).
    nisplus Connexion à un annuaire NIS+ (version plus sécurisée de NIS).
    dns Connexion aux DNS. Utilisable seulement pour la base de données hosts.
    mdns Résolution en Multicast-DNS. Utilisable seulement pour la base de données hosts.
    ldap Connexion à un serveur LDAP
    winbind Connexion à un serveur Samba (ou Active Directory).
    cache Utilisation des fichiers de cache des noms de domaines de nscd (Name Service Cache Daemon).
    extrausers Utilisation des fichiers passwd, group et shadow situés dans le dossier /var/lib/extrausers. Ce dossier permet d'accueillir les fichiers précédemment cités venant d'autres systèmes sans copier leur contenu dans les fichiers locaux situés dans /etc.
    sshsock2 Connexion à un autre système via un socket ssh afin d'utiliser les utilisateurs de celui-ci. Valable seulement pour les bases de données passwd et group.
    lwres Lire le cache fournit par lwres (lightweight resolver). Utilisable seulement pour la base de donnnées hosts.
    mysql-bg Utilisation d'une base de données MySQL.
    pgsql2 Interrogation d'une base de données PostgreSQL.
    sss Interrogation d'un démon SSSd.

     

    La commande getent

    La commande getent citée au début de cet article permet quand à elle d'effectuer une requête pour une base de données sur les services inclus dans NSS.

    La commande est de la forme suivante :

    getent base_de_données [clé]

    La base_de_données est un nom parmi ceux listés dans le premier tableau de cet article. La clé n'est, elle, pas obligatoire. Si elle est présente, la commande n'affichera que la ligne concernant le nom recherché. Au contraire, si elle est absente, getent listera tous les éléments lorsque la base permet l'énumération.

    Par exemple, un annuaire LDAP permet l'énumération, et s'il est utilisé pour l'authentification sur votre système, vous pourrez lister tous les utilisateurs disponibles. À l'inverse, les services DNS ne permettent pas l'énumération (il est impossible de lister tous les noms de domaines existants) et vous serez obligés de fournir une clé (ici un nom de domaine) pour avoir son adresse IP correspondante.

     

    Conclusion

    On l'a vu au travers de cette article, NSS est un mécanisme qui nous permet de choisir les sources de données nécessaires au système. Il permet d'utiliser les fichiers locaux ou de déléguer la gestion de ces données à des services externes. Il est donc nécessaire lors de l'intégration d'une machine à un système centralisé.

     

    Ressources supplémentaires

     

  • darktable 2.4.0 (Dépêches LinuxFR)

    Le logiciel de développement d’images brutes darktable est sorti en version 2.4.0. Comme chaque année, la liste des changements est considérable : près de 3 000 commits sur darktable et la bibliothèque rawspeed sous-jacente, 244 pull‐requests traitées et plus de 320 bogues fermés.

    Logo darktable

    Dans les nouveautés majeures, on trouve la prise en charge de Windows (introduite dans une section « Hell Froze Over », « l’enfer a gelé », dans les notes de sorties officielles !), un nouveau module « suppression de la brume », et un nouveau mode « filtre laplacien local » dans « contraste local » qui permet non seulement de jouer sur le contraste local, mais aussi de traiter les ombres et lumières avec un rendu très propre et sans halos.

    Comme d’habitude, pensez à faire une sauvegarde de votre base de données (répertoire ~/.config/darktable) : les anciennes versions de darktable ne pourront pas ouvrir les images traitées avec la 2.4.

    Quelques rappels sur ce que permet de faire darktable, et surtout, les détails des nouveautés dans la suite de la dépêche.

    Sommaire

    Introduction

    Darktable est un logiciel libre développé depuis 2009 par Johannes Hanika, puis Tobias Ellinghaus et désormais 215 contributeurs, auteurs de 20 191 commits à ce jour. Il s’agit d’un logiciel de catalogage et de développement de photos brutes de capteur (RAW), basé sur Rawspeed, qui embarque une gestion complète de la colorimétrie (profils d’entrée, de sortie et d’écran, softproofing et visualisation du gamut), ainsi que la gestion de nombreux formats RAW (plus de 550 boîtiers gérés, dont les capteurs Fuji X-Trans et Leica Monochrome), la correction des déformations optiques via la bibliothèque Lensfun (902 objectifs gérés), et le calcul sur processeur graphique via OpenCL.

    Au fil du temps, il s’est doté de fonctionnalités périphériques, comme la possibilité de générer ses propres profils de couleur cLUT à partir de mires (type ColorChecker) ou de JPG boîtier, de scripter des modules d’import‐export avancés en Lua (par exemple, fusion HDR via Enfuse, exportation vers Hugin, création automatique de planches‐contacts et de diaporamas). Il comporte aussi un module d’impression permettant d’appliquer des profils de couleur, pour les imprimantes prises en charge par CUPS. Il est également interfaçable avec GIMP en tant que greffon. Peu à peu, il s’enrichit de fonctions qui relèvent davantage de la retouche non destructive que du simple développement de « négatifs » numériques (voir plus bas).

    Souvent comparé à Adobe Lightroom en raison des similitudes de l’interface, il s’en distingue par :

    • la possibilité de créer des masques complexes (paramétriques et/ou dessinés, avec opérations booléennes) afin de restreindre la zone d’application des modules ;
    • la possibilité native d’émuler le rendu couleur de la pellicule ou les JPG boîtier ;
    • la possibilité de dupliquer, cloner ou empiler la plupart des modules ;
    • la gestion native du HDR et de la correspondance des tonalités (à partir d’une ou de plusieurs photos) et la prise en charge en entrée et sortie de formats d’images échantillonnés jusqu’à 32 bits par canal ;
    • une approche souvent plus « bare‐metal », avec des options plus proches de l’algorithmique sous‐jacente et parfois moins intuitives ;
    • une communauté de développeurs où la présence significative d’universitaires garantit l’ajout régulier d’algorithmes issus de la recherche récente.

    Fait rare pour un « dérawtiseur », il comporte également un module Liquéfier, qui permet de déplacer des pixels de la même manière que le filtre Fluidité de Photoshop, mais de façon non destructive, en entrant les vecteurs. Son usage est cependant un peu plus complexe et moins réactif que la version Photoshop, qui n’agit pas sur les données brutes.

    Sous le capot, darktable est codé en C/C++ avec la bibliothèque graphique GTK 3 pour l’interface et publié sous licence GNU GPL v3. Il effectue le traitement interne des images avec des nombres à virgule flottante sur 32 bits.

    Changements majeurs

    Nouveau module « suppression de la brume » (haze removal)

    Les photos de paysages sont souvent pâlies par un voile atmosphérique ou de la brume. Parfois, cette brume participe à l’ambiance et l’on peut vouloir l’exploiter dans le traitement, mais on peut aussi vouloir l’éliminer ou au moins l’adoucir. Vu que la brume désature l’image et lui enlève du contraste, les ingrédients pour retrouver manuellement une image bien équilibrée sont « contraste local » (ou « renforcer la netteté » avec un rayon très grand : faire un clic droit sur le curseur de rayon et entrer au clavier par exemple 20, pour dépasser le rayon maximum du curseur) et le curseur de saturation de « contraste lum. saturation ». Le voile atmosphérique ajoute souvent un peu de bleu, en particulier sur les tons sombres, ce qu’on peut rectifier avec le module « balance des couleurs ». Voir par exemple le tutoriel darktable Voile atmosphérique de Jean‐Pierre Verrue.

    Ces traitements manuels posent deux problèmes : d’une part, il faut souvent combiner plusieurs modules et donc passer relativement longtemps sur chaque image et, d’autre part, les paysages brumeux sont souvent composés de plusieurs plans, de plus en plus atteints par la brume au fur et à mesure qu’on s’éloigne du photographe. Inutile de tenter de retrouver du contraste dans un arrière‐plan totalement gris (on ne ferait qu’amplifier les artefacts de l’image), mais masquer les effets sur le premier plan n’est pas forcément évident non plus. C’est là qu’intervient le nouveau module suppression de la brume de cette nouvelle version, écrit par Heiko Bauke sur la base d’un article de chercheurs de l’université de Hong‐Kong.

    Le module se trouve dans l’onglet modules d’amélioration :
    Module suppression de la brume

    Il a deux curseurs :

    • la force permet de contrôler le voile atmosphérique (plus on l’augmente, plus le bruit devient important) ;
    • la distance permet d’agir plus ou moins sur les différents plans de la photo.

    Voici le résultat sur une photo, extraite d’une série prise pour tester les algorithmes de suppression de brume :
    Image de test pour la suppression de la brume
    Et après l’activation de la « suppression de la brume » avec les paramètres par défaut :
    Résultat de l’application de suppression de la brume

    Aucune autre correction que celles faites par darktable à l’ouverture d’un fichier RAW n’a été faite sur cet exemple, comme on peut le voir dans l’historique.

    Regardons maintenant les deux curseurs :

    • la force permet de contrôler le voile atmosphérique. Comme on peut s’y attendre, la valeur 0 signifie qu’on n’applique pas d’effet, et la valeur 1 tente de supprimer la totalité de la brume, donc de rétablir une image correctement contrastée et colorée. Bien sûr, plus on augmente cette valeur plus on risque d’amplifier les défauts de l’image, en particulier le bruit ;
    • la distance permet d’agir plus ou moins sur les différents plans de la photo. Par défaut, darktable va tenter de supprimer la brume du premier plan, mais pas de l’arrière‐plan. En jouant sur ce curseur on peut choisir à partir de quelle distance on arrête cet effet.

    Voici ce que donne ce second curseur sur une autre image de la même série. Le curseur de force est sur 0,6 (sur cette photo, au‐delà, on voit de vilains artefacts) et l’on fait varier la distance :
    Suppression de la brume : effet du curseur de distance

    À distance 0, le module ne modifie pas l’image. En passant de 0 à 0,1, on voit clairement que le premier plan est restauré, mais le curseur a peu d’effet sur l’arrière‐plan et le ciel. Les maisons au fond de l’image sont encore assez pâlies par le brouillard. Sur les tranches suivantes l’effet ne change plus sur l’herbe au premier plan : le module considère qu’il a supprimé la brume et ne cherche pas à enlever plus que ce qu’il a déjà fait. En revanche, les maisons sont de moins en moins pâles. Arrivé à 0,5, le curseur ne change plus beaucoup le paysage mais l’effet s’applique sur le ciel, ce qui n’est pas forcément du meilleur effet : il est sans doute préférable de s’arrêter avant !

    La suppression de la brume a réduit la luminosité de l’image (qui était déjà relativement sombre au départ). On peut terminer le travail en rectifiant l’exposition avec les modules exposition et niveaux. Au final, on obtient ceci (seul le module suppression de la brume diffère entre les deux côtés) :
    Suppression de la brume : avant et après

    En appliquant une force négative, on peut aussi « ajouter » de la brume. Dans ce cas, le curseur de distance est ignoré.

    Nouveau mode « filtre laplacien local » (local laplacian filter) dans « contraste local »

    Le module contraste local se voir doté d’un nouveau mode filtre laplacien local :
    Filtre laplacien local

    Jusqu’à présent, ce module utilisait un filtre bilatéral (toujours disponible, également connu sous le nom de flou de surface) pour créer un masque flou. Le filtrage laplacien donne un résultat plus subtil, en permettant une meilleure récupération des détails sans altérer le contraste local de façon aussi marquée.

    La possibilité de piloter séparément le contraste dans les hautes et basses lumières le rend aussi intéressant pour ajouter du modelé dans un portrait :
    Modelé dans un portrait : avant
    Modelé dans un portrait : après

    Dans ce contexte, l’effet se rapproche de l’utilisation d’un bol beauté (ou beauty dish, modificateur de flash rond de 30 à 45 cm de diamètre qui donne une lumière relativement ponctuelle utilisée pour découper le dessus des joues, l’arrête nasale et marquer le relief du visage).

    Comme leur nom l’indique, les curseurs ombres et hautes lumières permettent d’augmenter ou de diminuer la luminosité dans les zones sombres et claires, et le curseur étendue des tons moyens permet de décider sur quelle étendue de luminance on veut appliquer l’effet des différents curseurs : 0 revient à désactiver l’effet du curseur détail, mais applique les effets des curseurs ombres et hautes lumières, respectivement sur la moité d’image la plus sombre et la plus claire (c’est donc équivalent à désactiver le module si l’on laisse ces deux derniers curseurs sur 100 %). La valeur 1 fait l’inverse : les curseurs ombres et hautes lumières n’ont plus d’effet mais le curseur détails modifie l’ensemble de l’image. Les autres valeurs, par exemple 0,5, font un intermédiaire.

    À l’inverse, en retirant du contraste, on obtient un effet de tone‐mapping (compression de la plage dynamique) très naturel, qui peut se substituer au module Ombres et hautes lumières, en retirant du contraste global sans casser le contraste local (donc la sensation de netteté) :
    Effet HDR : avant
    Effet HDR : après

    Ce module remplace aussi Renforcer la netteté, basé sur un masque flou gaussien, et dont un intérêt est d’inverser l’effet des filtres passe‐bas présents sur les capteurs d’appareils photo afin de limiter le moiré. Les constructeurs faisant progressivement disparaître les filtres passe-bas, ce module devient progressivement moins utile, d’autant qu’il est enclin à créer des halos sur les bords durs contrastés (transitions ciel‐bâtiments, par exemple).

    Les détails sur ce module (mathématiques sous‐jacentes, exemples d’applications) sont décrits dans l’article de blog Local laplacian pyramids sur le site de darktable.

    Affichage des canaux et des masques en pseudo‐couleurs

    La quasi‐totalité des outils de darktable permettent de cibler des parties d’images (bouton fusion en bas de chaque module). On peut au choix dessiner un masque ou bien construire son masque en sélectionnant les pixels selon la valeur des canaux qui constituent ce pixel (L, a, b, saturation, couleur). Dans le second cas, la méthode classique consiste à utiliser la pipette pour trouver les caractéristiques de la zone à cibler, puis à entourer cette valeur avec les curseurs. Mais cette méthode suppose que l’on sache déjà sur quels canaux il est pertinent de filtrer. Bien souvent, l’encadrement de la valeur cible sera trop précis (et on ne sélectionnera pas toute la zone voulue), ou bien au contraire pas assez et on appliquera le traitement à une zone de l’image qu’on souhaitait exclure.

    On peut maintenant visualiser non seulement le masque actuel (clic ou contrôle clic sur le bouton en bas à droite de la partie masque paramétrique), mais aussi la valeur de chacun des canaux sur lesquels on fait la sélection (Maj + clic sur le même bouton). Voyons ceci sur un exemple. Notre objectif est d’appliquer une transformation sur le bleu du ciel (par exemple le rendre un peu plus foncé) :
    Image originale

    Vu que l’on cherche à masquer du bleu, un réflexe assez naturel serait de filtrer sur le canal h (hue, ou teinte). On peut visualiser ce canal en faisant un Maj + clic sur le bouton de visualisation du masque, puis en passant la souris sur la réglette correspondant au canal à visualiser. Voici le résultat :
    Affichage du canal h

    L’image est affichée uniquement par sa teinte : tous les pixels ont la même saturation (la même « intensité de couleur ») et la même luminance.

    Cette visualisation fait apparaître une mauvaise nouvelle : il y a du bleu un peu partout dans notre image (mais en général, il est très sombre ou très peu saturé et on ne le voit pas forcément comme du bleu). On peut tout de même encadrer la valeur cible bleue, mais ce n’est pas la peine de chercher à éliminer les autres pixels bleus avec cette réglette : nous venons de voir qu’ils ont la même teinte :
    Masque sur le canal h

    On peut parcourir les autres canaux et les visualiser pour chercher celui qui est le plus discriminant afin d’éliminer nos pixels parasites. Le canal de saturation semble être un bon candidat :
    Visualisation de la saturation

    La couleur utilisée dans l’image est la même que celle de la réglette : blanc (ou gris) pour les pixels peu saturés, violet pour les pixels les plus saturés. Clairement, le ciel est plus saturé que le reste de l’image (ce qui n’était pas nécessairement évident à l’œil sur l’image originale). On peut exclure les pixels les moins saturés :
    Sélection par saturation

    Il reste quelques zones sélectionnées hors du ciel, mais ces zones sont plus sombres que le ciel, on peut facilement les éliminer sur l’un des deux canaux L ou g.

    On peut aussi afficher les deux informations (masque et canal) en faisant un Ctrl + Maj + clic sur le bouton :
    Affichage combiné du masque et d’un canal

    En résumé :

    • clic, ou Ctrl + clic : affichage du masque ;
    • Maj + clic, puis survol d’une réglette : affichage d’un canal ;
    • Ctrl + Maj + clic : affichage combiné.

    Version Windows

    Lors de la sortie de darktable 2.2, on avait déjà parlé en octobre 2016 de la demande d’intégration de Peter Budai qui ajoutait la prise en charge de Windows. Cette pull request a été bien accueillie, longuement discutée (avec 241 commentaires) et après des mois de travail sur l’amélioration du code, intégrée à darktable en avril. En août, darktable annonçait sa première version Windows pré‐alpha, mais déjà utilisable. Cette version 2.4.0 apporte la prise en charge officielle de Windows. Il reste quelques limitations (pas de module d’impression, pilotes spécifiques requis pour pouvoir prendre des photos directement à travers USB, et sans doute encore beaucoup de bogues), mais elle est utilisable et considérée comme une version officielle au même titre que les versions GNU/Linux et macOS.

    Coïncidence intéressante, la prise en charge de Windows arrive au même moment qu’un changement de politique de licence pour Adobe Lightroom. Beaucoup d’utilisateurs de Lightroom cherchent un remplacement (voir ici ou là, par exemple) et darktable a déjà satisfait plus d’un ancien utilisateur de Lightroom. On peut donc s’attendre à une explosion du nombre d’utilisateurs de darktable.

    Avec l’arrivée de nombreux nouveaux utilisateurs sur une version Windows, pas encore aussi stable que la version GNU/Linux, on peut craindre que les forums et les systèmes de suivi de bogues soient inondés de plaintes non constructives. C’est ce que les développeurs redoutaient avec une version Windows. Espérons que les nouveaux venus seront constructifs et permettront au contraire d’agrandir la communauté et au final d’améliorer la qualité du logiciel. Voir par exemple quelques conseils à l’attention des nouveaux utilisateurs de darktable. Après tout, plusieurs développeurs actuels de darktable sont des anciens utilisateurs de Lightroom !

    Des petits détails qui peuvent changer la vie

    Possibilité de choisir la couleur de fond de l’interface via CSS

    L’interface de darktable suit le principe « les photos, rien que les photos ». Tout est fait pour éviter d’attirer l’œil vers les autres zones de l’écran. Un point important : il y a très peu de couleurs, ce qui permet à l’œil d’avoir une référence du gris non coloré. Il serait difficile d’ajuster correctement la balance des blancs sur un fond coloré par exemple.

    Un défaut potentiel de l’interface par défaut, c’est que le gris sombre peut avoir tendance à habituer l’œil aux couleurs sombres, et donc à encourager le photographe à sous‐exposer les images. Dans une de ses vidéos, Aurélien Pierre part de ce constat et propose une interface plus claire, correspondant au point gris d’une image. L’interface donne alors non seulement une référence de balance des blancs, mais aussi de luminosité. Malheureusement, pour obtenir ce résultat il fallait non seulement éditer le fichier de configuration darktable.css, mais aussi changer quelques valeurs qui étaient restées codées en dur dans le code source de darktable, et le recompiler.

    Dans la version 2.4, ces valeurs sont devenues configurables et l’on peut donc obtenir le même résultat sans recompilation. Voici un exemple de fichier, à placer dans ~/.config/darktable/darktable.css :

    @import '/usr/share/darktable/darktable.css';

@define-color bg_color #7F7F7F;
@define-color plugin_bg_color #333;
@define-color fg_color #eee;
@define-color base_color #444;
@define-color text_color #eee;
@define-color selected_bg_color #666;
@define-color selected_fg_color #eee;
@define-color tooltip_bg_color #BEBEBE;
@define-color tooltip_fg_color #111;
@define-color really_dark_bg_color #595959;

@define-color darkroom_bg_color #777777;
@define-color darkroom_preview_bg_color shade(@darkroom_bg_color, .8);
@define-color lighttable_bg_color @darkroom_bg_color;
@define-color lighttable_preview_bg_color shade(@lighttable_bg_color, .8);

    Et voici le résultat sur l’interface :
    darktable avec une interface gris neutre

    Curseur « biais d’exposition » dans le mode « fusion d’exposition » du module « courbe de base »

    Souvenez‐vous : la version 2.2 avait vu arriver une option fusion d’exposition dans le module courbe de base. C’est un des meilleurs moyens de réduire le contraste global d’une image en préservant le contraste local et sans introduire de halo, et cela permet de faire le même genre de traitement qu’en exportant plusieurs images et en les fusionnant avec enblend, mais sans quitter darktable. Mais obtenir les bons réglages n’était pas toujours facile : le seul curseur disponible agissait à la fois sur la force de réduction du contraste et sur l’exposition globale de l’image. On devait donc souvent combiner le module courbe de base et exposition, et faire plusieurs allers‐retours entre les deux pour trouver la combinaison gagnante.

    Fatigué de ces allers‐retours, votre serviteur a ajouté un curseur de « biais » au module courbe de base qui permet de modifier la signification du curseur décalage d’exposition. Le principe reste de créer plusieurs images avec une exposition différente et de les fusionner. Par défaut, on crée des images surexposées et on les fusionne avec l’image d’origine. C’est adapté quand on a réglé l’exposition sur les zones les plus claires de l’image : le résultat est de déboucher les zones sombres. Mais bien souvent, le résultat est de surexposer l’ensemble de l’image. Avec le curseur de biais, on peut choisir entre fusionner avec des images surexposées (biais de 1), des images sous‐exposées (biais de -1), ou un intermédiaire, par exemple un biais de 0 avec une fusion de trois expositions fusionnera l’image d’origine avec une version surexposée et une version sous‐exposée.

    Voyons cela sur un exemple :
    Image originale

    L’écart de contraste entre le ciel et les arbres est important. Essayons de le réduire pour que les arbres soient moins bouchés, mais sans surexposer le ciel. Première étape : prendre un instantané et afficher l’image avant/après, cet affichage va servir à régler le curseur de biais. Puis, application de la fusion d’exposition. Avec les paramètres par défaut pour trois expositions, on obtient ceci :
    Résultat avec les paramètres par défaut

    Comme on s’y attendait, le résultat a globalement surexposé l’ensemble de l’image. La photo est prise au lever du soleil, on souhaite garder cette ambiance matinale, donc cette version ne convient pas. On règle maintenant le biais pour retrouver une exposition correcte sur l’ensemble de l’image. Une solution pour faire cela est de prendre une partie de l’image qui était à l’origine dans les tons moyens (ici le ciel en dehors des nuages) et de s’arranger pour que la fusion d’exposition ne modifie pas cette partie de l’image. Avec notre instantané avant/après, c’est assez facile à faire :
    Réglage du biais

    Finalement, on se rend compte que le principal effet de la fusion d’exposition a été de surexposer l’image, mais la réduction de dynamique entre les zones claires et les zones sombres n’était pas si forte. Voyons ce qu’il se passe si l’on pousse le curseur « décalage d’exposition » plus loin (sans toucher au curseur de biais) :
    Paramètres poussés trop fort

    Ce n’est pas très joli, mais la bonne nouvelle est que, même en poussant ce curseur au maximum, on n’a ni surexposé ni sous‐exposé l’image : une fois le curseur de biais bien placé, le curseur de décalage d’exposition agit uniquement sur la dynamique de l’image. On peut donc choisir la force de l’effet en agissant sur ce curseur. Par exemple, avec une valeur un peu en dessous de 2, on obtient une image relativement équilibrée :
    Version finale de l’image

    Le premier plan n’est plus bouché, on retrouve du contraste dans la neige alors qu’il était quasi‐invisible dans l’ombre, mais le ciel reste correctement exposé. Il reste beaucoup de marge de manœuvre pour la suite du traitement, le photographe va pouvoir jouer sur le contraste local sans risquer de surexposer ou sous‐exposer par exemple.

    Amélioration de la fonction « annuler » en chambre noire

    La version 2.2 avait vu arriver une fonction « annuler » en chambre noire : les raccourcis clavier Ctrl + Z et Ctrl + Y permettent d’annuler ou de refaire les dernières actions. Ceci vient en complément de l’historique (dans la barre latérale de gauche) et permet de gérer les actions à annuler avec une granularité plus fine.

    La version 2.4 apporte les touches finales à cette fonctionnalité :

    • une meilleure gestion des groupements d’actions : en version 2.2, la granularité était en fait un peu trop fine, certaines actions à annuler correspondaient à des changements internes non pertinents pour l’utilisateur ; le résultat : parfois rien ne se passait sur un Ctrl + Z et il fallait taper plusieurs fois cette combinaison pour avoir un effet ;
    • la gestion des masques, qui était absente jusqu’ici : un Ctrl + Z permet maintenant d’annuler une action sur un masque dessiné (création, déplacement, suppression de formes), ceci est primordial puisque les masques ne sont pas dans l’historique et le Ctrl + Z est alors la seule manière de revenir sur les accidents de déplacement.

    Une brosse transparente

    Beaucoup d’utilisateurs se plaignaient du fait que l’outil brosse, pour dessiner un masque à la souris, était opaque : une fois une zone couverte, plus moyen de savoir ce qu’il s’y trouvait, et même le curseur était opaque.

    Avec la nouvelle version, on a maintenant une légère transparence :
    Brosse transparente

    Si ce n’est pas assez transparent, pas de panique : c’est configurable en CSS. Avec ceci dans le fichier darktable.css :

    @import '/usr/share/darktable/darktable.css';

@define-color brush_cursor alpha(white, .5);
@define-color brush_trace alpha(black, .4);

    On obtient ce résultat :
    Brosse très transparente

    L’opacité du masque est toujours réglable avec la molette de la souris. Pour vous indiquer quand l’opacité du masque atteint 100 %, l’épaisseur du contour du curseur change quand c’est le cas.

    Mode « absolu » dans la table de correspondance des couleurs

    La table de correspondance des couleurs permet de modifier sélectivement les couleurs d’une image. Une utilisation type est de prendre en photo une mire dont on connaît la couleur de chacune des pastilles (patch).

    On pouvait régler la couleur cible de chaque pastille avec des curseurs permettant de rendre les pastilles plus vertes, plus rouges, plus bleues, plus jaunes, plus claires ou plus foncées. Mais pour forcer une couleur en particulier (celle attendue pour une pastille donnée), on était obligé de procéder à tâtons en bougeant les curseurs et en regardant la valeur de couleur à l’aide de la pipette. C’est maintenant réparé, on peut entrer directement les valeurs cibles en Lab :
    Mode « absolu » pour choisir la couleur cible dans le module CLUT

    Profils OpenCL

    Il est désormais possible de choisir comment répartir la charge de calcul entre le processeur et le processeur graphique, en utilisant plusieurs profils de planification OpenCL. Les trois options proposées sont :

    • standard : le processeur calcule les prévisualisations (version réduite de l’image affichée en haut à gauche), le processeur graphique calcule l’affichage principal et l’exportation ;
    • GPU rapide : tout le calcul est effectué par le processeur graphique, pour une retouche beaucoup plus réactive ; en revanche, exporter une image en arrière‐plan pendant la retouche d’une autre image devient pratiquement impossible ;
    • GPU multiples : prévisualisations et exportations sont réparties entre les différents processeurs graphiques.

    On peut aussi forcer l’utilisation d’OpenCL en préfixant une entrée d’un + dans la variable de configuration opencl_device_priority.

    Autres changements

    • Dans les modules courbe de base et courbe des tonalités, les coordonnées du point courant sont affichées pendant l’édition. On peut faire un clic droit sur un point pour le supprimer (même action que pour supprimer des formes de masques).

    • On peut maintenant créer une nouvelle instance de module en cliquant avec le bouton du milieu sur l’icône multi‐instances (au lieu de faire un clic gauche et de choisir l’entrée nouvelle instance du menu).

    • Une recherche dans le module carte affiche un contour autour de la zone au lieu de colorer toute la zone :
      Curseurs colorés dans la balance des blancs

    • Un clic sur le bouton réinitialiser les paramètres du module trouver la localisation du mode carte efface la liste des résultats et le contenu de champ texte de ce module.

    • Avec une version d’osm-gps-map récente, des informations de copyright sont affichées.

    • Les variables utilisées par l’exportation et le module filigrane ont maintenant une syntaxe de substitution inspirée de celle de Bash. Par exemple, $(TITLE-Mon titre par défaut) sera étendu avec le contenu de la variable TITLE si elle est définie, et « Mon titre par défaut » sinon.

    • Quand on tente d’ouvrir darktable alors qu’une instance tourne déjà, darktable affiche maintenant une boîte de dialogue expliquant la situation :
      Curseurs colorés dans la balance des blancs

    • Les opérations d’import‐export affichent maintenant une barre de progression dans le dock si l’environnement de bureau le permet :
      Curseurs colorés dans la balance des blancs

    • Le curseur de détail du module contraste local, dans le mode grille bilatérale (l’ancien mode), peut maintenant être poussé plus loin qu’avant.

    • L’utilisateur peut choisir d’avoir une confirmation avant de supprimer un répertoire vide.

    • Le module balance des couleurs est maintenant plus rapide grâce à une optimisation utilisant du code SSE.

    • Le niveau de compression des images PNG est maintenant réglable.

    • Sous macOS, on peut ouvrir des images individuellement en ligne de commande ou via glisser‐déposer.

    • Une option permet de supprimer la hiérarchie intermédiaire et de n’exporter que le dernier niveau de chaque mot clef.

    • Dans le module filigrane, la liste des fichiers SVG est maintenant triée et omet l’extension.

    • Le profil XYZ est maintenant disponible dans les options d’épreuvage.

    • Deux nouveaux scripts sont fournis avec darktable :

      • purge_from_cache.sh pour supprimer du cache (~/.cache/darktable/mipmaps-*) les images absentes de la base de données ;
      • watch_folder.sh qui utilise inotify pour surveiller un répertoire et ouvrir les nouveaux fichiers dans darktable.

    • Un nouvel algorithme de dématriçage (demosaic) « chroma de domaine fréquentiel » (Frequency Domain Chroma), applicable aux capteurs X-Trans (et seulement à ceux‐là), qui produit moins d’effets de moiré dans certains cas. Attention, il n’est pas toujours meilleur que l’algorithme de Markesteijn utilisé par défaut sur ces capteurs (voir par exemple cette discussion, comparatifs à l’appui). Une bonne stratégie est d’essayer chaque algorithme pour voir quel algorithme est le meilleur sur les images problématiques et de garder la valeur par défaut dans le cas général.

    • De nouveaux modes de fusions sont apparus pour fusionner spécifiquement sur un canal (RGB canal rouge/vert/bleu et Lab canal a/b). L’exemple qui a justifié cette introduction est celui d’une image bruitée sur un canal et moins sur les autres : on peut maintenant appliquer un « débruitage » violent sur le canal problématique et laisser les autres canaux intacts. Sur le module courbe de base, en instanciant le module une fois sur chacun des canaux rouge, vert et bleu, on peut obtenir un réglage par courbes RVB, qui manque à certains sous darktable.

    • Le module courbe des tonalités a maintenant un mode de mise à l’échelle des canaux a et b automatique RGB, qui produit l’équivalent d’un réglage par courbe dans l’espace de couleur ProPhoto RGB.

    • Les fichiers .xmp ne sont maintenant plus écrits sur le disque quand leur contenu n’a pas changé. Ceci évite des sauvegardes inutiles aux outils de sauvegarde incrémentales et permet d’éviter une latence inutile sur des disques réseaux lents par exemple.

    • Sur un ordinateur disposant de plus de 8 Gio de mémoire vive, la configuration par défaut utilise maintenant la moitié de cette mémoire pour chaque module.

    • La limite supérieure d’ISO dans l’interface a été remontée (elle était à 51 200 ISO).

    • Les modules courbe de base et reconstruire hautes lumières peuvent maintenant être instanciés plusieurs fois et peuvent utiliser la fusion.

    • Dans la table lumineuse, la touche 1 bascule par défaut de zéro à une étoile (appuyer deux fois revient à la situation initiale). Cette fonctionnalité ne plaisait pas à tout le monde et est maintenant configurable (dans options d’interface, option appliquer une étoile deux fois ne supprimera pas l’étoile).

    • On peut demander une confirmation avant de réinitialiser l’historique d’une image depuis la table lumineuse.

    • Le module grain a été modifié pour donner un rendu plus proche de celui des photos argentiques, en appliquant plus de grain dans les tons moyens et moins dans les zones d’ombre et de lumière.

    • Le module table correspondance couleurs permet maintenant de faire un passage en noir et blanc selon l’effet Helmholtz‐Kohlrausch, qui tient compte de la sensibilité de l’œil dans les différentes couleurs pour obtenir un rendu le plus naturel possible.

    • Les traductions ont été mises à jour pour le catalan, le tchèque, le danois, le néerlandais, le français, l’allemand, le grec, l’hébreu, le hongrois, l’italien, le japonais, le russe, le polonais, le slovaque, le slovène, l’espagnol, le suédois et l’ukrainien.

    • L’API Lua a reçu quelques modifications mineures (voir les notes de sorties officielles pour les détails).

    • Il faut maintenant au moins CMake 3.1, GCC 4.9 ou clang 3.4 (GCC 5.0 fortement recommandé) et Lua 5.3 pour compiler darktable. La bibliothèque zlib est maintenant requise.

    • Les couleurs primaires et le point blanc sont maintenant lus en ouvrant les fichiers .hdr et ils sont utilisés dans le profil de couleur d’entrée.

    Prise en charge de nouveaux boîtiers et types d’images

    Désormais, darktable est capable de lire les images RAF Fujifilm compressées, les fichiers DNG en virgule flottante produits par HDRMERGE.

    Et, comme d’habitude, la prise en charge de nouveaux boîtiers se poursuit avec une grosse soixantaine d’appareils en plus : voir les notes de sorties officielles pour la liste complète.

    Nouveau site darktable.org

    Le site darktable.org fait peau neuve. L’ancien site, basé sur Wordpress, est remplacé par un site statique généré via Python/Pelican. On peut y contribuer via des pull‐requests sur le projet GitHub dtorg. Un gros intérêt du site statique est qu’il pose beaucoup moins de problèmes de sécurité que les sites dynamiques. Voir l’article A new website pour les détails. Le nouveau site marque aussi un rapprochement avec pixls.us, le site de la communauté libriste sur la photographie. Les commentaires sont de retour sur darktable.org via une intégration des forums de pixls.us. En bref : comme le dit maintenant chaque page du site, « pixls.us ♡’s darktable » !

    Nouvelle collection d’échantillons de fichiers RAW

    Aujourd’hui darktable gère plus de 550 boîtiers. On peut remercier les développeurs, car même si beaucoup codent sur darktable pour leurs besoins personnels, énormément d’efforts sont faits pour gérer un maximum de boîtiers, y compris ceux qu’aucun développeur ne possède. La mauvaise nouvelle étant que pour chaque boîtier, il peut y avoir des variantes du format de fichier, des paramètres différents, etc. Ajouter la prise en charge d’un boîtier représente du travail et tester que cette prise en charge continue à fonctionner de versions en versions est un travail gigantesque. Un outil indispensable pour le faire est d’avoir une image pour chaque boîtier et pour chaque format d’image RAW possible (par exemple, 12 bits, 14 bits, compressée ou non…).

    Le site de référence était jusqu’à l’année dernière rawsamples.ch. Le site a été victime d’une attaque (injection SQL), et l’absence de sauvegarde n’a pas aidé à sa remise en route… Heureusement, la communauté pixls.us, très active, a lancé un nouveau site pour remplacer le défunt : raw.pixls.us. Une différence est la licence : raw.pixls.us publie les fichiers sous licence CC0 (qui s’apparente au domaine public) pour éviter les éventuelles incompatibilités de licences entre ces images et les logiciels qui les utilisent. L’ensemble des images des rawsample.ch a servi de point de départ pour raw.pixls.us, mais le but est de couvrir un maximum de boîtiers avec des images sous licence CC0.

    Si vous avez lu jusqu’ici, filez donc sur le site pour vérifier que tous les échantillons sont disponibles pour votre boîtier, et sinon soumettez le vôtre. Pas besoin d’être un artiste, ni un informaticien : n’importe quelle photo convient.

    Pour plus d’information, lire les articles New Year, New Raw Samples Website, Keep the Raws Coming et Raw Samples Wanted sur pixls.us.

    Et après ?

    Rêvons un peu pour la prochaine version. Qui n’a jamais raté une photo (mise au point ratée, flou de bougé…) importante, et qui n’a jamais espéré un module magique qui retrouve l’image nette tout seul ? Un tel module est envisageable, Aurélien Pierre travaille sur une implémentation de plusieurs articles de recherche récents, en cours d’intégration dans darktable. Voir la discussion Possible module de déconvolution sur le forum darktable.fr. Le module possède déjà un prototype fonctionnel (quoique peu utilisable).

    Il s’agit d’apprentissage machine supervisé réalisant une optimisation par descente de gradient, basé sur une déconvolution aveugle (cours en anglais) par l’algorithme de Richardson‐Lucy. Cette déconvolution est connue pour générer des artefacts au niveau des bordures et pour amplifier le bruit, mais ici, elle est régularisée par une méthode statistique et une analyse des gradients (variation totale). Au final, la méthode peut récupérer aussi bien du flou de bougé que d’objectif, à la manière de l’outil Lens softness de DXO, Netteté optimisée de Photoshop ou piccure+. Le vrai défi est la gestion des temps de traitement et donc l’efficacité du code (révisions et contributions bienvenues, notamment sur la partie OpenCL).

    Voici un exemple, zoomé à 100 % sur une photo originale de 4 Mpx :

    Image floutée (flou gaussien de 5 px) :
    image floutée

    Image défloutée (réglages exagérés pour l’exemple) :
    Image défloutée

    Image source :
    Image source

    Un autre outil très attendu est un outil de suppression des taches plus intelligent. Le module correction des taches actuel fait simplement un clone d’une zone de l’image vers une autre, mais cela suppose qu’il existe une autre zone de l’image ayant les mêmes couleurs (par exemple, il est assez délicat à utiliser dans un ciel dégradé). Bonne nouvelle : Edgardo Hoszowski (qui travaille aussi avec Aurélien sur la déconvolution) planche sur la question, il a proposé un morceau de code qui combine le module actuel de darktable, le greffon wavelet decompose de GIMP, et l’outil correcteur (heal) de GIMP dans un module retouche.

    Le module est opérationnel mais pas encore intégré à darktable, il reste du travail de revue et de nettoyage de code. S’il est intégré, le nouveau module permettra par exemple d’effectuer des retouches de portrait avancées de manière non destructrice et sans quitter darktable. Pour l’instant, ce genre de peaufinage demande de passer par GIMP, voir par exemple ce tuto sur la retouche par séparation de fréquence ou celui‐ci en anglais qui utilise le greffon GIMP Wavelet decompose.

    Comme d’habitude, c’est plus le temps que les idées d’améliorations qui manque.

    Lire les commentaires

  • Lister rapidement les liens d'une page web (Journaux LinuxFR)

    Il y a quelques jours je suis tombé sur une page web cul-de-sac. Pas un rongeur pour se la rat-comté.

    J'ai donc tenté une inspection du HTML pour tenter d'y voir plus clair, et là j'me suis dit qu'une petite formule de JavaScript me donnerait une réponse limpide quant à la présence de lien dans la page :

    javascript:document.querySelectorAll('a').forEach(console.log)
    Ça rentre à l'aise dans un marque page, et ça peut dépanner. En plus l'affichage est celui, enrichi, des nœuds HTML dans la console de Firefox. Évidemment, ça marche pour l'importe quelle balise citée dans le querySelectorAll : img ? link ?

    J'ai ajouté la formule à mon http://www.grimoire-command.es/post/2018/List-web-page-links-in-Firefox

    Lire les commentaires

  • Présentation d'iPXE, un chargeur d'amorçage en PXE (Dépêches LinuxFR)

    Il est parfois nécessaire de faire démarrer une machine sur le réseau (par exemple, une machine sans disque dur) : la technologie la plus courante utilisée sur x86 s'appelle PXE et permet l'amorçage depuis un serveur TFTP. La plupart des cartes réseau modernes intègrent une implémentation de PXE, cependant la spécification ne décrit que le protocole susnommé dont les limitations se font vite sentir sur des configurations un peu complexes.

    Heureusement pour nous, il existe depuis 1995 un projet libre qui a pour but le développement d'un firmware de carte réseau bien plus flexible que ce que l'on peut trouver actuellement, il s'agit d'iPXE.

    Dans la suite de cette dépêche, vous trouverez une explicitation détaillée de l'étape d'amorçage d'une machine ainsi qu'une présentation des possibilités offertes par iPXE.

    Merci à Nÿco, Sébastien Koechlin, ZeroHeure, Xavier Teyssier, Nils Ratusznik, tankey, Xavier Claude, oinkoink_daotter et Benoît pour avoir participé à la rédaction de cette dépêche.

    Sommaire

    Rappels historiques

    Lors de l'apparition des machines sans disque, un certain nombre de protocoles, parfois propriétaires, ont dû être développés pour permettre l'assignation d’adresses à celles-ci. Le premier à être normalisé par l'IETF se nomme (RARP), pour Reverse-ARP, qui ressemble beaucoup, dans sa forme, au protocole ARP. Il n'offre cependant que la possibilité d'assigner une adresse à une machine et ne permet pas de communiquer d'autres informations essentielles comme la localisation d'une image à charger. Pour pallier ces limitations, le protocole BootP a ensuite été mis au point, il a finalement été rendu obsolète par l'apparition de DHCP, qui est beaucoup plus flexible.

    En 1999, Intel et SystemSoft mettent au point Wired for Management (WFM), un système permettant la gestion de machines sans système d'exploitation, WFM décrit également une technique d'amorçage par le réseau, qui est alors nommée Preboot Execution Environment (PXE), et qui permet de télécharger un chargeur d'amorçage et d'offrir à celui-ci une API pour qu'il puisse charger facilement un noyau via le réseau. De nombreux constructeurs de cartes réseau se sont mis à embarquer des ROM d'extensions sur leurs cartes pour permettre l'amorçage par le réseau.

    Bien que six architectures matérielles soient décrites par la spécification, à ce jour seule x86 possède une couverture complète. Cependant, les stations sans disque dur étant un concept assez ancien, on retrouve des solutions rendant un service similaire sur de nombreuses architectures et pour de nombreux systèmes. À noter aussi que l'Unix Libre NetBSD fournit et documente des solutions pour un grand nombre d'architectures. Enfin, SUN Solaris propose un service similaire dans son OpenROM pour son service Jumpstart.

    L'amorçage d'une machine

    L'amorçage d'une machine de type PC à base de processeur x86/x86-64 se fait généralement en plusieurs étapes, chacune ayant pour but de récupérer un exécutable de plus en plus évolué pour enfin arriver à charger le noyau d'un système d'exploitation.

    Amorcer depuis un disque dur

    Pour bien comprendre comment l'amorçage par le réseau fonctionne, il convient de savoir comment se passe l'amorçage « classique », c'est à dire depuis un disque dur.

    Lors de l'initialisation de la machine, le BIOS détecte les périphériques amorçables (disque dur, disquette, CD-ROM…) et tente de les démarrer l'un après l'autre selon l'ordre configuré. Pour cela il charge en mémoire le premier secteur du périphérique (soit ses 512 premiers octets), et vérifie que les deux derniers octets correspondent bien aux valeurs hexadécimales AA 55. Si ce n'est pas le cas, il considère que les données chargées ne sont pas destinées à être exécutées et passe au périphérique suivant.
    Une fois qu'un programme valide est chargé en mémoire, un certain nombre de valeurs sont placées dans les registres du processeur, comme le numéro du périphérique courant par exemple. Enfin, la première instruction du programme est exécutée.

    Dans le cas d'un système Linux, le programme en question est généralement un stage1 de GRUB dont le but va être de lire le contenu de la partition /boot pour en extraire un stage2, qui est un programme bien plus évolué. Il ne faut pas oublier que le stage1 est limité à 510 octets (512 moins les deux derniers octets), ce qui est vraiment peu pour faire quoi que ce soit d'un tant soit peu avancé, d'où la nécessité d'aller chercher un stage2. Heureusement, pour faciliter la vie des concepteurs de chargeurs de démarrage, le BIOS fournit une fonction pour charger un ou plusieurs secteurs d'un périphérique en mémoire. Cette méthode est basée sur une interruption logicielle et le passage des paramètres se fait en utilisant les registres du processeur, la plupart des chargeurs d'amorçage étant écrit en assembleur, ce type d'opération est très facile à réaliser et permet de ne pas avoir à écrire un pilote pour disque-dur, ce qui est très appréciable quand on est limité en taille.

    Le stage2 est alors lancé. Celui-ci peut configurer plus largement la machine (disposition de la mémoire, mode de fonctionnement du processeur, clavier, écran…). Il peut présenter un menu pour permettre de choisir certaines options; et finalement il va récupérer les éléments de l'étape suivante: le noyau d'un système d'exploitation et un éventuel initramfs pour leur passer la main. (Note: Dans le cas de Grub, celui-ci dispose d'une étape intermédiaire, le stage1.5 qui permet de charger des drivers pour les différents systèmes de fichiers et évite d'avoir à réinstaller GRUB à chaque modification de la configuration)

    Amorcer depuis le réseau

    Pour amorcer la machine depuis le réseau, le principe général reste le même, mais, le BIOS n'ayant pas été conçu pour démarrer depuis une carte réseau, il est un peu détourné. La carte va embarquer une ROM d’extension qui sera mise à disposition du BIOS à une certaine adresse. Lors de l'étape du Power-On Self-Test, le BIOS va reconnaitre une séquence d'octets spécifiques indiquant la présence de l'extension. Cette extension de la carte réseau va s'enregistrer comme périphérique amorçable auprès du BIOS qui sera alors capable de démarrer dessus.

    Cette ROM contient un micrologiciel qui est divisé en plusieurs modules :

    • le premier est une pile PXE qui implémente une partie de la spécification PXE et dont le comportement sera détaillé plus bas;
    • le second est une série de fonctions respectant l'API UNDI pour Universal Network Device Interface permettant d'utiliser la carte réseau sans avoir à fournir un pilote. Ces fonctions pourront être utilisées par la pile PXE et par le programme que celle-ci chargera.

    Reprenons le processus de démarrage avec l'exécution de la pile PXE. Son objectif est de récupérer sur le réseau un Network Bootstrap Program (NBP) pour l'exécuter. Pour cela, il faut obtenir une adresse IP afin de pouvoir communiquer sur le réseau, puis localiser, récupérer et exécuter ce NBP. La spécification PXE adresse ces questions en faisant d'une pierre deux coups : le protocole DHCP est utilisé avec deux options particulières : next-server et filename. DHCP est en effet un protocole flexible qui permet de spécifier de nombreux paramètres personnalisés, aussi bien dans la requête que dans la réponse. La norme PXE demande que dans la réponse, le serveur DHCP spécifie dans le paramètre next-server l'adresse IP d'un serveur TFTP et dans le paramètre filename le chemin du fichier NBP sur ce serveur. UNDI proposant dans son API un client TFTP, la pile PXE n'a plus grand-chose à faire, elle va charger le NBP en mémoire puis l'exécuter à son tour.

    Ici les choses varient en fonction du NBP choisi par l'utilisateur. Très souvent il s'agit de PXELINUX, qui fait partie du projet SYSLINUX et qui est en quelque sorte l'équivalent du stage2 de GRUB. Il est capable de chercher à son tour sur le serveur TFTP un fichier de configuration, puis un noyau et un initramfs.

    iPXE

    Historique du projet

    Etherboot

    Le projet Etherboot vu le jour en 1995, avant l'apparition de la spécification PXE donc, il avait pour but développer un microgiciel embarquable dans une ROM d'extension pour BIOS afin de permettre l'amorçage par le réseau, le principe est alors sensiblement le même que celui qui sera retenu par PXE plus tard, la différence principale entre les deux approches étant qu'Etherboot récupérait directement un noyau tandis que PXE passe par un NBP.

    gPXE

    En 1999, Intel publie la spécification PXE, la question de savoir si Etherboot doit abandonner son approche actuelle pour implémenter une pile PXE divise alors les développeurs du projet. Trois développeurs, Marty Connor, H. Peter Anvin et Michael Brown prennent alors la décision de forker le projet, donnant naissance à gPXE. Marty Connor en profite pour créer rom-o-matic.net qui permet de générer des images gPXE facilement et qui connaît un succès rapide.

    Entre temps, le mainteneur d'Etherboot n'ayant plus de temps à y consacrer abandonne le projet qui est donc réintégré dans gPXE.

    En 2006, gPXE participe à la seconde édition du Google Summer of Code, sous l'égide de la fondation linux, à cette occasion, une pile TCP complète est implémentée par un étudiant indien. gPXE participera à tous les Google Summer of Code suivant jusqu'en 2011.

    iPXE

    En 2011, un différend oppose Marty Connor et Michael Brown conduisant à un fork du projet par ce dernier et donnant naissance à iPXE, gPXE ne donnant plus de signe de vie depuis presque un an, il est considéré comme mort à l'heure actuelle.

    En 2012, iPXE participe à la septième édition du Google Summer of Code, prenant la place de gPXE.

    Utiliser iPXE

    Il est possible, à partir des sources d'iPXE, de générer un grand nombre d'images différentes, chacune répondant à une utilisation précise du programme. Cette partie recense les utilisations les plus courantes et les images qu'il faudra utiliser.

    Chainloading

    iPXE peut être chargé depuis une implémentation de PXE existante, il faudra donc utiliser une image de type NBP, c'est le cas d'undionly.kpxe par exemple. Il est également possible de charger iPXE depuis un autre chargeur d'amorçage comme GRUB ou LILO, dans ce cas de figure, une image de type bzImage est nécessaire, il faudra donc utiliser ipxe.lkrn.

    Plus d'informations

    Démarrer sur CD-ROM, disquette ou clé USB

    Il existe également des images spécifiques chacun de ces supports, ipxe.iso, ipxe.dsk et ipxe.usb pour l'amorçage depuis, respectivement, un CD-ROM, une disquette ou une clé USB.

    Flasher la ROM de sa carte réseau

    Les plus téméraires d'entre vous pourront flasher la ROM de leur carte réseau afin de disposer d'iPXE de façon permanente. Ceci permet d'éviter le chainloading et économise donc une étape, sans parler du gain évident en sécurité si vous embarquez une clé privée dans iPXE : avoir une clé qui se balade en clair sur le réseau, ce n'est jamais une très bonne chose. Dans ce cas de figure, vous devez compiler une image de type .rom ou .mrom et il vous faudra connaître le pilote précis utilisé par votre carte réseau.

    Plus d'informations

    Fonctionnalités

    iPXE, en plus du respect de la spécification PXE, propose un grand nombre de fonctionnalités qui ne sont pas décrites par celle-ci.

    Protocoles

    Là où la spécification PXE ne se limite qu'aux protocoles TFTP et Multicast TFTP, iPXE intègre un certain nombre d'autres protocoles. Les plus utilisés étant bien sûr HTTP et FTP, mais sont également disponibles :

    • Scalable Local Area Multicast protocol (SLAM) : un protocole conçu pour être plus efficace que Multicast TFTP et qui n'est à ma connaissance implémenté que dans iPXE.
    • HTTPS : HTTP sécurisé qui offre un certain nombre de possibilités combiné avec l'intégration de certificats dans iPXE, voir la partie Cryptographie.
    • iSCSI / AoE / FCoE : permet l'amorçage depuis un SAN, voir la partie Sanboot ci-dessous.
    • NFS : implémenté cette année dans le cadre d'un Google Summer of Code par l'auteur de cette dépêche. Devrait être intégré dans la branche principale sous peu.

    Sanboot

    iPXE permet l'amorçage sur un SAN, il va procéder exactement comme le BIOS pour un amorçage sur disque classique, sauf qu'il va intercepter les interruptions utilisées pour demander la lecture de secteurs afin d'émuler un disque physiquement présent dans la machine. Le chargeur d’amorçage de la cible distante sera donc tout à fait capable de faire son travail et de charger un noyau. Pour poursuivre l'amorçage, il faudra bien évidemment que le système d'exploitation ait des pilotes chargés pour le protocole utilisé (iSCSI, AoE ou FCoE). Cette technique permet d'installer et amorcer des stations Windows sans disque.

    Cryptographie

    iPXE possède une implémentation de TLS, qui est utilisée pour le support d'HTTPS, et permet lors de la compilation d'embarquer une ou plusieurs Autorités de certification. Il est donc possible d'amorcer une machine avec des images téléchargées depuis l'Internet en toute sécurité. Si une autre solution qu'HTTPS est choisie, il est également possible de signer l'image et de demander à iPXE de ne la charger que si la signature est valide. Pour permettre l'authentification des clients, iPXE permet aussi d'embarquer un certificat et la clé correspondante.

    Plus d'informations

    Scripting

    L'une des fonctionnalités les plus appréciables d'iPXE est probablement la possibilité qui est offerte de le scripter. En effet, il embarque un petit interpréteur qui, bien que rudimentaire, offre des possibilités que ne fournissent pas les autres chargeurs d'amorçage. Ces scripts peuvent être soit embarqués dans l’exécutable à la compilation, soit exécutés comme des images classiques.

    La syntaxe ressemble beaucoup à du shell édulcoré, les boucles y sont absentes mais peuvent être construite à partir de goto, de même pas d'instruction if mais une alternative un tout petit peu moins intuitive. Ces choix s'expliquent par le fait que l’interpréteur doit rester le plus petit possible, faisant partie du cœur du programme, il n'est pas possible de le désactiver à la compilation contrairement à la plupart des autres fonctionnalités.

    Le classique hello world : 

    #!ipxe

echo Hello World!

    Un script qui demande à l'utilisateur d'entrer une valeur et envoie cette valeur ainsi que son adresse MAC à un serveur HTTP, ce script a été utilisé par l'auteur de cette dépêche à plusieurs reprises pour s’épargner le relevé fastidieux des adresses MAC d'une centaine de machines : 

    #!ipxe

# Effectue une requête dhcp
dhcp

# Affiche "Nom de la machine : " et attends une entrée de l'utilisateur pour continuer, la valeur saisie est placée dans la variable 'name'.
echo -n Nom de la machine : && read name

# Exécute l'image renvoyée par le serveur HTTP tout en lui transmettant la saisie de l'utilisateur et l'adresse MAC de la machine. 
chain http://${next-server}/?name=${name}&mac=${mac}

    Une boucle qui effectue une requête dhcp tant qu'une réponse n'a pas été reçue : 

    #!ipxe

# Déclare le label 'retry_dhcp'
:retry_dhcp

# Effectue une requête DHCP puis 'isset' teste si la variable 'filename' contient une valeur, ce qui est le cas quand une réponse DHCP valide à été reçue.
# Si 'isset' renvoie faux, le goto nous renvoie au début du script.
dhcp && isset ${filename} || goto retry_dhcp

# La commande 'chain' télécharge l'image dont l'URI est passé en paramètre et l’exécute.
chain ${filename}

    iPXE embarque aussi un shell où toutes ces commandes, à l'exception de goto, sont disponibles.

    Plus d'informations

    Menu graphique

    Si PXELINUX et GRUB offrent la possibilité d'afficher des menus depuis longtemps, l'implémentation de cette fonctionnalité dans iPXE date seulement de quelques mois. Contrairement à ce que l'on peut trouver ailleurs, il n'y a pas de fichier de configuration pour décrire le menu, il faut utiliser le langage de script intégré à iPXE et en particulier les commandes menu, item et choose.

    Un exemple simple : 

    #!ipxe

menu
item linux    Boot Linux
item shell    Enter iPXE shell
item exit     Exit to BIOS

# Affiche le menu à l'utilisateur et place le nom de l'élément choisi dans la variable 'target'
choose --default exit --timeout 3000 target && goto ${target}

:linux
# Amorce sur Linux
chain ftp://${server}/bzImage

:shell
# Propose un shell iPXE à l'utilisateur
shell

:exit
# Termine la session iPXE
exit

    L'affichage d'un menu plus complet, avec des séparateurs :

    menu

    DNS

    Contrairement à une implémentation classique de PXE, iPXE est capable de comprendre des URI passé par l'option DHCP filename, dans cet URI, la cible peut être un nom de domaine. Afin de pouvoir les résoudre, iPXE intègre un petit client DNS. Ceci ouvre un certain nombre de possibilités, comme la répartition de charge par round-robin DNS qui est particulièrement utile quand on veut amorcer un très grand nombre de machines.

    VLAN

    Enfin, iPXE est capable de configurer une interface comme un VLAN trunk c'est à dire qu'il peut générer des interfaces virtuelles, une pour chaque VLAN, qui se retrouveront sur des segments Ethernet différents. Pour que ceci fonctionne, il faut bien sûr que la machine soit reliée à un commutateur capable de comprendre le protocole IEEE 802.1Q.

    Plus d'informations

    Alternatives à iPXE

    Je ne connais pas d'alternative libre à iPXE en tant que microgiciel embarquable, en revanche il existe d'autres chargeurs d'amorçage qui peuvent être utilisés comme NBP :

    • PXELINUX du projet SYSLINUX
    • pxegrub du projet GRUB

    Lire les commentaires

  • Agility Training - Un site internet pour créer et partager des parcours d’agility (Dépêches LinuxFR)

    Agility Training est un site internet permettant aux utilisateurs de créer et partager des parcours d’agility : http://agility-training.fr/fr/.

    L'agility consiste à réaliser un parcours composé d'agrès avec son chien. Les agrès sont divers : saut, passerelle, tunnel… Le maître doit guider le chien afin qu'il réalise le parcours. Cette discipline est connue pour créer une grande complicité entre le maître et le chien.


    source de l'image: Wikipedia

    La discipline est de plus en plus populaire, il y a de plus en plus de compétiteurs et de concours. Les compétiteurs créent régulièrement de nouvelles méthodes d'entraînement et de nouveaux parcours. C'est ce dernier point qui nous intéresse.

    Tous les jours de nouveaux parcours sont créés et partagés sur Internet, le partage se fait par le biais d'un fichier image qui est un dessin du parcours. L'idée est donc de créer un site internet permettant de créer des parcours en ligne, de les partager, les modifier et permettre de faire des recherches.

    La première étape consistait à permettre la création et le partage d'un parcours. C'est aujourd'hui fini et utilisable sur le site internet Agility-Training.

    La seconde étape va consister à permettre la recherche dans la bibliothèque de parcours, allant de la recherche par nom ou par tag jusqu'à la recherche sur des critères tels que le nombre d'obstacles. Beaucoup de personnes possèdent des obstacles chez eux à la maison mais sont limités ( 3 sauts, 1 tunnel, …), il est donc intéressant de leur permettre d'utiliser ce type de critères lors des recherches.

    Informations techniques

    Le site internet est écrit en Python avec le framework Django. L'éditeur de parcours est écrit en Javascript. Le code source et les médias sont sous licence Apache Version 2.

    Le site internet Agility-Training est exactement le code disponible sur github, vous pouvez donc allez dessus pour voir l'application.

    Lire les commentaires

  • Microcontrôleur de DEL basé sur ESP8266 (Dépêches LinuxFR)

    ANAVI Light Controller est une nouvelle carte matérielle libre pour contrôler un ruban de DEL (LED strip RGB). Ce projet est libre et conçu avec KiCAD, et disponible à l’achat à partir de 25 € jusqu’au 27 juin 2018.
    plan du Anavi Light Controller sur KiCAD
    La carte peut être utilisée de façon autonome avec le logiciel embarqué de démo en se connectant sur une page Web (MQTT d’Eclipse Paho). Mais passer par Internet via un broker MQTT public n’est peut‐être pas idéal pour tous, donc une autre solution est tout aussi envisageable via une passerelle locale (et optionnellement accessible à distance).

    Naturellement, ce microcontrôleur (MCU) ESP8266 peut être aussi reprogrammé, c’est une alternative intéressante aux populaires Arduino car un bloc Wi‐Fi (pas libre ?) est intégré au MCU.

    Pour ma part, j’ai eu la chance de tester le produit, ça fait le job comme on dit ! Mais je vous invite à lire la revue en français sur le blog Framboise314.

    Pour utiliser une passerelle locale, il faut préalablement installer Mozilla IoT Gateway sur Raspberry Pi et reprogrammer le MCU avec mon implémentation de RGBLamp qui utilise l’API WebThings de Mozilla se connectant ensuite via mDNS, HTTP, REST (voir vidéo)…

    webthing-esp8266-webapp-20180602rzr

    Pour ceux qui ne veulent pas faire un pas hors de leur système d’exploitation préféré, considérez le précédent produit de Léon pour Raspberry Pi.

    Finalement, si vous utilisez Mozilla IoT, les retours sont bienvenus.

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Comment taper les accents sur un clavier QWERTY? (Journaux LinuxFR)

    Tout lien avec mon journal d'hier serait bien entendu purement fortuit.

    Comment taper les caracteres accentues sur un clavier QWERTY standard sans (trop) se casser les cHpieds?

    On m'a propose "setxkbmap fr" mais franchement je ne me rappelle plus trop bien la disposition fr. En plus, cette disposition n'offre meme pas tous les caracteres speciaux (comme l'e-dans-l'o et les caracteres accentues majuscules).

    On m'a aussi propose des outils d'accentuation automatique, mais cote grammaire ils en sont a peu pres au niveau CP.

    Ce qui me conviendrait bien, ca serait une touche "compose". Par exemple, compose+apostrophe+e = é

    Y a-t-il une telle solution, pas trop difficile a mettre en oeuvre, sous linux+x11 ?

    Lire les commentaires

  • Sauvegarde incrémentiel de container lxc sous proxmox (Journaux LinuxFR)

    Introduction

    Proxmox c'est bon, c'est libre et ça marche bien.
    Par contre il a une faiblesse, ce sont les sauvegardes.
    Ils vous pond un gros .lzo par sauvegarde, certes on dit dans l'espaces de sauvegarde combien nous voulons garder de sauvegardes, et
    il effacera les vielles sauvegardes.

    C'est suffisant pour des petits containers ou vm par exemple, mais pour un gros container ça ne va pas le faire.

    Ma solution

    Description de ma situation

    Pour faire simple prenons mon cas.

    J'ai une instance de proxmox qui tourne dans ma cave, dessus il n'y a que des containers lxc, j'ai quelques petits containers et un gros qui s'appelle NAS et qui fait dans les 300Go.

    Mais le problème c'est mon NAS. Dedans il y a toutes notre musique, toutes nos photos/vidéos, bref toute notre vie, qu'il faut bien sauvegarder.
    Par contre je me vois mal me prendre 300Go par nuit, ma machine de sauvegarde va vite être saturée.

    A côté du serveur il y a un petit serveur (un vieux microcube proserv d'hp), il a 4 disques de 2to en raid 5. Dessus tourne une debian qui offre un partage nfs
    au proxmox.
    J'ai également une instance de rsnapshot sur mon hp qui sauvagarde le contenu de mon container NAS.

    Cela fonctionne bien, mais je me suis dit si je pouvait prendre tous le container par passage de rsnaphot, histoire que si un jour le proxmox casse il n'y aurait plus qu'a recopier l’intégralité du contenus sur le nouveau proxmox (ça marche j'ai fait le test avec un container d'essai le week-end passé).

    Ce qui est cool c'est que avec rsnapshot on peut remplacer les sauvegardes de proxmox pour les containers (attention que ceux qui sont dans des rpool zfs ou dans des lv de lvm).

    Un bout de mon fichier de configuration

    Comme c'est plus facile avec un exemple, voici un bout de mon fichier de config qui permet de sauvegarder un container, au préalable il faut que la machine de sauvegarde puisse se connecter au proxmox en ssh avec identification par clé.

    Dans l'exemple notre container est le 202 et l'adresse du proxmox est 192.168.2.190
    Dans le fichier de configuration il vous faut passer ce argument sinon il risque d'être bizarre votre container avec le temps qui s'écoule.

    rsync_long_args --delete

    en ZFS

    La section pour la sauvegarde du container 202:

    #NAS
backup_exec ssh root@192.168.2.190 "zfs snapshot rpool/data/subvol-202-disk-1@backup"
backup  root@192.168.2.190://rpool/data/subvol-202-disk-1/.zfs/snapshot/backup/ nas-202/
backup_exec ssh root@192.168.2.190 "zfs destroy rpool/data/subvol-202-disk-1@backup"

    C'est vraiment simple après il faut pas oublier de prendre les fichiers de configuration de votre container sur l'hyperviseur, mais à la limite vous en foutez vous recréer un container avec la même id et même capacité de disque et vous passer la commande rsync dans l'autre sens.

    Voilà vous avez des sauvegardes incrémental de vos containers et si vous avez un mysql dedans il devrait pas y avoir de problème vu que vous copiez un snapshot.

    en LVM

    Si vous avez vos containers dans des lv sous lvm ça marche aussi, voici un exemple que vous pouvez adapter à rsnapshot, je l'ai pas encore adapté mais j'ai testé les commandes à la main sur la grappe de proxmox de mon employeur.

    lvcreate -n backup-308 -l 10%ORIGIN -s /dev/pve/vm-308-disk-1
mount /dev/pve/backup-308 /snapshots/308
rsync ...
umount /snapshots/308
lvremove -f /dev/pve/backup-308

    Pour les VM ? Je n'ai pas encore penché la dessus, si quelqu'un à une idée.

    Lire les commentaires

  • Du reverse tethering sur Android (sans root) (Dépêches LinuxFR)

    Je vous présente un outil que j’ai développé, qui permet aux appareils Android d’utiliser la connexion du PC sur lequel ils sont branchés. On appelle ça du « reverse tethering ».

    Je l’ai appelé gnirehtet (rev <<< tethering en bash).

    Il ne nécessite pas d’accès root, que ce soit sur le téléphone ou sur le PC. En revanche, il nécessite Java 8 et les Android tools (adb).

    Comment l’utiliser ?

    Il suffit de télécharger la dernière publication, de l’extraire et d’exécuter la commande suivante sur le PC :

    ./gnirehtet rt

    La première fois, Android demande une confirmation : VPN request

    Une fois activé, un logo en forme de clef apparaît dans la barre de statut du téléphone : Key

    Pour l’arrêter : Ctrl + C.

    Le fichier README donne plus de détails.

    Comment ça marche ?

    Très succinctement, l’application s’enregistre en tant que réseau privé virtuel (VPN) pour intercepter tout le trafic réseau du téléphone, qu’il transmet à un serveur tournant sur le PC, qui ouvre les connexions et relaie le contenu dans les deux sens.

    Voici un beau dessin pour faire joli (c’est l’architecture du serveur relais) : Architecture du serveur relais

    Vers l’∞ (et au‐delà)

    Notez qu’il est possible d’activer en même temps le tethering (de manière à ce que le PC utilise la connexion du téléphone), et le reverse tethering (pour que le téléphone utilise la connexion du PC). Ne faites pas ça ! :D

    En parlant d’infini (même si ça n’a rien à voir), savais‐tu, cher journal, qu’une boucle infinie était un undefined behavior (Ah bon, pourquoi ? Quel rapport avec le dernier théorème de Fermat ?) ?

    Lire les commentaires

  • Un décalage de 64 bits, ça vous inspire comment ? (Journaux LinuxFR)

    Salut à tous,
    après l'excellent journal d'Anaseto sur le fameux "1+3a", un pote à moi, prof de maths à L'INSA de Rouen, m'a demandé de faire ce petit journal après une "découverte" faite par ses étudiants.
    Ceux-ci écrivant des tests unitaires en Free Pascal sont tombés sur un comportement non documenté qui nous a amené à nous poser la question du "comment ksa fait sur les autres langages" :)

    Le problème

    Le problème vient de l'opérateur de décalage de bits à droite.
    Si je prend un entier initialisé à 1, le décalage d'un bit vers la droite retourne 0. Si l'on décale de 2 bits, on s'attend à avoir 0… Et c'est toujours le cas.
    Par contre, le code suivant ne retourne pas 0

    program beBitwise;
var
a, b: integer;

begin
   a := 1;
   b := a >> 64; (* la, on s'attend normalement à obtenir un 0 *)
   writeln('Valeur de b ', b );
end.

    Le code retourne 1 à savoir a.

    Si l'on remplace 64 par 63 ou 65, on obtient bien 0.
    Bien sûr, sur une machine 32 bits, on obtient le même comportement avec un décalage de 32 bits.

    Si le comportement peut s'expliquer, le fait que le compilateur ne prévienne pas du risque et qu'aucune documentation ne le spécifie est un poil gênant.

    Résultat, les étudiants sont en train de remplir un rapport de bug pour Free Pascal, ne serait-ce que pour que le comportement soit documenté quelque part.

    Et chez les autres ?

    En C/C++

    #include <iostream>

using namespace std;

int main(int argc, char** argv)
{
  unsigned long long a = 1;
  unsigned long long b = a << 64;
  cout << "b vaut " << b << endl;
}

    Au moins, le compilateur GCC nous prévient du problème en affichant le warning si on travaille en statique

    shift.cpp: In function ‘int main(int, char**)’:
    shift.cpp:8:31: warning: left shift count >= width of type [-Wshift-count-overflow]
    unsigned long long b = a << 64;
    Dans le cas où c'est l'utilisateur qui rentrerait le décalage à l'exécution, il n'y aurait aucun message… Logique !

    En Java

    public class Shift
{
    public static void main(String[] args)
    {
    int a = 1;

    System.out.println("Resultat : " + (a >> 64));
    }
}

    Même punition et surtout pas de warning.

    En Ada

    Vous n'y couperez pas, je vais forcément donner un exemple en Ada

    with Interfaces; use Interfaces;
with Ada.Text_Io; use Ada.Text_Io;

Procedure Shift is
begin
   Put_Line("Resultat " & Unsigned_64'Image(Shift_Right(Unsigned_64(1), 64))); 
end Shift;

    Là, pas de message d'erreur ni de warning mais au final pas d'erreur non plus, le résultat est bien 0.

    En OCAML

    Il s'agit juste d'une ligne de commande dans l'interpréteur:

    # open Int64;;
# shift_right one 64;;
- : int64 = 1L
#

    J'avoue que je ne m'attendais pas à ce résultat mais OCAML retourne lui aussi 1 en lieu et place de 0.

    En Python

    >>> 1 >> 64
0

    Ce qui est normal pour un langage typé canard ;)

    Que disent les docs ?

    Le reproche que l'on peut faire à Free Pascal, c'est justement de ne rien dire quant à ce fonctionnement.
    Par contre, si l'on prend OCAML, la documentation du module Int64 précise que le comportement est non spécifié.

    val shift_right : int64 -> int -> int64
     Int64.shift_right x y shifts x to the right by y bits. This is an arithmetic shift: the sign bit of x is replicated and inserted in the vacated bits. The result is unspecified if y < 0 or y >= 64.

    Si on prend les deux langages normalisés, à savoir C++ et Ada, la documentation est claire.
    Pour C++, dans le draft de la prochaine norme, page 126, le comportement est implementation defined.

    Pour Ada, il n'y a aucune restriction et la norme ne fournit donc que les exigences d'implémentation.

    Voilà pour les langages que j'ai eu envie d'explorer.
    Et vous, votre langage préféré, il fait quoi ?

    Lire les commentaires

  • Cartographie et images de rues : Mapillary et OpenStreetCam (Dépêches LinuxFR)

    Vous connaissez probablement déjà OpenStreetMap, la base de données cartographique libre. Mais vous connaissez sans doute aussi des concurrents qui proposent en plus des cartes d’autres services, comme les images aériennes, et depuis une dizaine d’années vous avez peut‐être pris l’habitude des images prises directement dans les rues : StreetView chez Google, StreetSide chez Microsoft…

    Des alternatives libres se mettent en place, et c’est ce dont nous allons parler : OpenStreetCam, né en 2013, et Mapillary. Les deux initiatives sont ouvertes, tout le monde peut participer facilement via une application pour mobile.

    Ces solutions permettent une alternative libre pour les utilisateurs et sont une aide très précieuse pour les contributeurs d’OpenStreetMap.

    Sommaire

    Réunir une telle collection d’images aurait pu paraître impossible il y a peu, mais l’avènement des smartphones change la donne : cartographier une rue peut être aussi simple que de fixer son téléphone sur son vélo, sa voiture, ou le tenir à la main en marchant. Une application s’occupe de prendre des photos (géolocalisées, bien sûr) périodiquement et de les envoyer vers les serveurs qui s’occupent du reste.

    Dur d’atteindre la qualité des images panoramiques à 360° des concurrents, mais, à l’inverse, permettre à tout le monde de contribuer permet aussi de couvrir les zones inaccessibles en voiture.

    En cinq ans, Mapillary a collecté 179 millions d’images (après avoir passé les 100 millions il y a moins d’un an), soit plus de trois millions de kilomètres couverts. La couverture OpenStreetCam n’est pas encore aussi bonne, mais c’est quand même plus de 50 millions d’images, et la croissance est très forte de ce côté aussi (multiplication par quatre depuis novembre 2016).

    À quoi tout ceci peut‐il servir ?

    • Pour tout le monde : comme la concurrence, à savoir à quoi ressemble un endroit sans y être allé, à planifier un itinéraire… On peut accéder aux images depuis un navigateur via le site des deux projets. Mapillary est intégré à l’application libre Android OsmAnd depuis la version 2.7 de juillet 2017 (disponible sur le dépôt F-Droid sous le nom OsmAnd~). On peut maintenant visualiser les séquences Mapillary directement sur la carte :

    Mapillary dans OsmAnd : séquences visibles sur la carte

    Ou plus simplement, une section « photos en ligne » est maintenant disponible quand on examine les détails d’un lieu :

    Mapillary dans OsmAnd : photos des lieux

    • Pour les contributeurs OpenStreetMap, c’est un outil précieux pour la cartographie de fauteuil, c’est‐à‐dire la possibilité d’éditer la carte OpenStreetMap sans être sur le lieu qu’on édite et éventuellement sans avoir fait de reconnaissance au préalable. L’éditeur ID en ligne sur https://openstreetmap.org permettait déjà d’éditer sur fond d’images aériennes ou de plan de cadastre par exemple. On peut maintenant visualiser les images de Mapillary directement depuis l’éditeur et, mieux encore, voir directement les panneaux de signalisation détectés par Mapillary en analysant les images.

    Mapillary

    Le principe de Mapillary est de récolter puis d’analyser un maximum d’images. L’analyse d’image permet de repérer les panneaux, feux tricolores, et aussi d’autres éléments comme les voitures, garages à vélo, verdure, poubelles… Ces données sont utilisables librement par OpenStreetMap, et l’entreprise derrière Mapillary monnaye ces données.

    Voici par exemple ce que Mapillary détecte place du Trocadéro :
    Données détectées place du Trocadéro

    Ces données sont utilisables directement depuis les éditeurs OpenStreetMap ID (éditeur par défaut depuis le site Web) et JOSM (client lourd). Lire l’article de blog et les vidéos associées pour les détails. Les éléments de carte peuvent être associés à une image Mapillary via l’étiquette mapillary=….

    Mapillary est également intégré dans l’application Android OsmAnd.

    OpenStreetCam

    OpenStreetCam est mené par Telenav, qui s’appuie sur OpenStreetMap pour les outils de navigation qu’elle commercialise.
    OpenStreetCam en ligne

    Une originalité d’OpenStreetCam est sa manière d’encourager les contributeurs par un système de points : on gagne des points en contribuant des images, et d’autant plus de points qu’on couvre des zones non couvertes.

    OpenStreetCam est intégré dans l’éditeur JOSM, mais pas (encore ?) dans ID ni OsmAnd.

    Historiquement, le projet s’est lancé sous le nom OpenStreetView pour reprendre le nom de domaine d’un projet lancé en 2009 qui n’avait pas réussi à devenir populaire. Il a été renommé plus tard en OpenStreetCam pour éviter la confusion possible avec la solution de Google.

    Est‐ce vraiment libre ?

    On lit çà et là sur le Web des controverses comme quoi l’une des solutions est commerciale et l’autre libre. En réalité, les deux solutions sont supportées par des entités commerciales (Mapillary AB est une entreprise basée en Suède centrée sur le service mapillary.com, et OpenStreetCam est mené par l’entreprise Telenav qui vend des systèmes de navigation pour voiture qui utilisent OpenStreetMap). Et les deux solutions sont « en grande partie libre ».

    Les deux services distribuent les images sous licence CC-BY-SA, et dans les deux cas les contributeurs donnent au service une licence qui lui permet d’utiliser les images sans restrictions.

    Chez OpenStreetCam, le code du site Web et des applications pour Android et pour iOS sont libres (mais au moins l’application Android a des dépendances non libres qui empêchent, entre autres, son inclusion dans F-Droid). Mapillary fournit plusieurs logiciels libres, par exemple mapillary-js, le code qui permet l’affichage des images sur leur site Web, mais l’application pour Android et iOS n’est pas libre (elle pourrait le devenir prochainement).

    Pour Mapillary, il faut distinguer les conditions d’utilisation du service et la licence des images. Les conditions pour le service ne permettent pas l’usage commercial hors contrat avec lui (d’après la partie 1.2 de ses conditions d’utilisations) et limitent par défaut les téléchargements à 50 000. La licence des images est la licence CC-by-SA et il est possible de re‐licencier les travaux dérivés dans le cadre d’OpenStreetMap selon les conditions de la fondation OpenStreetMap. En d’autres termes, il y a des restrictions sur le téléchargement d’images, mais une fois les images téléchargées, elles sont utilisables librement. Les images sont libres, mais le service n’est pas entièrement gratuit (250 €/mois pour le pack « professional », par exemple).

    Pour un comparatif des conditions des deux services (écrite par un employé Mapillary), voir par exemple ici.

    Et la pérennité ?

    L’ouverture est souvent citée comme gage de pérennité. Si l’auteur d’un logiciel libre décide de passer à autre chose, quelqu’un d’autre peut, au moins en théorie, prendre le relai.

    Pour OpenStreetCam et Mapillary, la situation est un peu plus compliquée. Le scénario catastrophe où l’un des deux arrête son activité ou se fait racheter par une entreprise qui décide d’arrêter de diffuser les images sous licence libre est tout à fait possible. Pour qu’une autre entité puisse reprendre la suite, il faut que deux conditions soient réunies : que les images soient réutilisables (c’est le cas avec la licence CC-BY-SA), et que quelqu’un ait gardé les images avant qu’elles ne disparaissent. C’est le deuxième point qui est problématique : les bases d’images sont colossales (plus de 500 téraoctets pour Mapillary, un peu moins pour OpenStreetCam, mais fort taux de croissance dans les deux cas) donc maintenir un stockage correctement fiabilisé pour un miroir aurait un coût de l’ordre de la centaine de milliers d’euros par an (en calcul de coin de table…). Ajouté à la limite de téléchargement pour Mapillary, maintenir un miroir n’est clairement pas à la porté du premier venu (même si en comparaison une fondation comme celle de Wikipédia gère un budget autrement plus élevé). Côté OpenStreetCam, certains en ont discuté, mais toujours pas de miroir non plus.

    On peut espérer que les deux services ne fermeront pas en même temps, donc une solution pour les contributeurs pour pérenniser leurs images est d’envoyer les images aux deux, mais ce n’est pas faisable directement depuis les applications pour mobile. Certains contributeurs conservent également une copie de leurs images localement, « au cas où ».

    Comment contribuer ?

    Contribuer est très facile si vous avez un smartphone. Un contributeur peut installer l’application et prendre des images de sa rue à pied et sans matériel supplémentaire en quelques minutes, ou se fixer des objectifs plus ambitieux comme certains contributeurs qui s’imposent de dépasser le million d’images contribuées en un mois. Pour contribuer en voiture ou à vélo, il est recommandé d’avoir un support, Mapillary en envoie gratuitement sur demande aux contributeurs si besoin. Toute la richesse de ces bases d’images vient de la diversité des contributeurs, donc de la diversité des images qu’elles contiennent.

    Alors, vous avez commencé ? Qu’attendez‐vous ? ;-)

    Lire les commentaires

  • Colortest.it - simuler le daltonisme avec des filtres CSS SVG (Journaux LinuxFR)

    Sommaire

    Chers et chères camarades, trichromates ou pas, bonsoir,

    Depuis assez longtemps je cherche un moyen de tester l'accessibilité de sites ou de graphiques aux daltoniens. Il existe un certain nombre de sites qui proposent ce genre de service, mais aucun qui m'ait convaincu. J'avais déjà tenté de mettre en place moi-même un tel service il y a des années, mais les technologies du web ne permettaient pas à l'époque de faire ce la. Les choses ont changé aujourd'hui, en particulier grâce à CSS3.

    Bon… je vois que c'est bien long, alors si vous avez la flemme allez directement à la fin ou bien allez juste faire un test sur le site en question, colortest.it

    Ce qui existe

    • Etre Colsim http://www.colsim.com
      Pour commencer le service est payant, et 1,20€ la page web ou l'image testée, ça fait un peu cher.
      Il fonctionne avec un form à soumettre, et on reçoit les images simulées par email, autant dire que c'est râpé pour tester un site avec des éléments interactifs, et j'imagine qu'il faut oublier tout le contenu généré en JavaScript. Je ne l'ai pas testé, parce que je ne veux pas payer.

    • Coblis http://www.color-blindness.com/coblis-color-blindness-simulator/
      Ce simulateur est assez bon, il semble reproduire précisément les couleurs perçues et fournit même un lien vers les matrices de transformation des couleurs (dommage que le lien soit down depuis longtemps maintenant).
      Malheureusement, il ne fonctionne qu'avec les images, et de moins de 600 ko. Impossible donc de tester un site facilement.

    • Chromatic Vision Simulator http://asada.tukusi.ne.jp/cvsimulator/e/
      Une application Android/iOS. Si j'ai bien compris, elle applique la simulation à ce que voit la caméra de l'appareil, ou éventuellement à une image statique. Une version web est disponible, et c'est ce qu'elle propose (le navigateur doit supporter WebGL).
      Toujours pas de support des sites web dynamiques, à moins de filmer un écran d'ordinateur pendant qu'on utilise le site.

    • ColorBlindness SimulateCorrect https://play.google.com/store/apps/details?id=com.SeewaldSolutions.ColorBlindnessSimulator
      Une application Android qui fait la même chose, mais qui propose aussi de corriger les couleurs pour les daltoniens (je reste dubitatif devant la possibilité technologique de faire ça, mais n'étant pas daltonien moi-même je ne peux pas réellement juger).

    • L'extension Firefox que j'avais testée a semble-t-il été supprimée par son auteur.

    • Vischeck http://www.vischeck.com/vischeck/vischeckURL.php
      Le seul service gratuit permettant la simulation d'un site, mais apparemment il est maintenant down.
      Je ne me souviens plus trop à quel point il fonctionnait, mais il ne supportait pas la simulation sur les <canvas>

    Ce que je cherche

    Peut-être n'êtes-vous pas sans savoir qu'un de mes loisirs est la création de graphiques divers, en voici une petite sélection :
    * http://ssz.fr/bac/ Résultats du Bac 2013, moyenne par département
    * http://ssz.fr/subventions/ Utilisation de la réserve parlementaire 2011
    * http://ssz.fr/finances/ Résultat comptable 2011 par commune, en euros par habitant
    * http://ssz.fr/presidents/ Chefs de l'état et chefs du gouvernement français depuis 1800
    * http://ssz.fr/vaches/ Population de la France en porcs, vaches, humains, moutons et chèvres
    * http://ssz.fr/eez/ Rapport ZEE/superficie des pays du monde

    Voilà donc des graphiques qui sont pour certains en SVG, pour d'autres en canvas, tous générés en JavaScript (je ne suis pas responsable de l'éventuel plantage de votre navigateur /o/). Certains dépendent directement de la vision des couleurs pour être lisibles, d'autres non grâce à plusieurs techniques.

    Dans tous les cas, il est rapidement évident que les services précédemment cités ne sont d'aucune utilité pour tester l'accessibilité de ce type de graphiques.

    L'autre possibilité est de montrer les graphiques sur la tribune et d'attendre les retours, mais les daltoniens eux-mêmes ne sont pas les mieux placés pour tester l'accessibilité d'un site puisqu'ils ne savent justement pas forcément ce qu'ils ne peuvent pas distinguer !

    Ce qui est possible

    Je me suis donc mis en quête d'un système qui permettrait de tester tout ça facilement, rapidement, en même temps que je développerais mes sites ou graphiques.

    La façon la plus courante de modifier les couleurs d'un site semble être de le proxyfier et de modifier au passage les valeurs de couleurs dans les styles, mais cela pose problème à plusieurs égards :
    Il est impossible par cette méthode de toucher aux couleurs des <canvas> à moins de modifier sans discrimination toutes les références à des couleurs dans le code - et même là, difficile de remplacer "red" ou "teal" sans risquer de modifier du texte important, sans compter les couleurs générées à partir d'échelles dans d3js.

    L'autre façon est évidemment de faire un rendu de la page et d'appliquer les modifications idoines à l'image résultante, au prix de la perte de l'interactivité. Même si les sites qui tentent de faire ça échouent souvent lamentablement, il suffirait d'utiliser PhantomJS pour avoir un rendu tout à fait correct, y compris des canvas et du SVG. Seulement, c'est lourd et très peu pratique pendant le développement.

    Je me suis donc tourné vers les filtres CSS SVG :
    Parmi les filtres SVG se trouve le filtre feColorMatrix qui permet d'appliquer une matrice de transformation aux couleurs. Exactement ce que je veux !

    Après avoir créé la matrice, il suffit d'appliquer le style filter: url(#id-du-filtre) à l'élément dont je veux ajuster les couleurs. Contre toute attente, aucun navigateur ne restreint l'application d'un tel filtre à une <iframe>, il ne reste donc qu'à afficher dans une iframe le site à tester, et tout se passe tout seul.

    Il y a bien deux ou trois inconvénients :

    • Le plus important, une matrice de transformation n'est pas vraiment assez puissante pour simuler précisément le daltonisme. La vision humaine est plus complexe qu'une simple transformation linéaire de valeurs RVB, les capteurs ont des plages de réception complexes, qui se chevauchent. Des méthodes existent pour faire ces calculs de manière précise, mais d'après ce que je comprends des résultats que j'ai eus les navigateurs ne calculent pas les couleurs avec une précision suffisante pour les mettre en application.
    • Les performances, bien qu'acceptables, ne sont pas exceptionnelles. Elles dépendent beaucoup du site affiché, par exemple on peut tester des vidéos mais elles rament un petit peu, ou du SVG interactif mais là aussi les performances ne sont pas au top.
    • Certains sites refusent de s'afficher dans une <iframe>, en particulier les sites de Google. C'est légitime, il y a même un header HTTP spécifique pour ça (x-frame-options: SAMEORIGIN) et je ne peux rien y faire (bien qu'il reste possible de passer par un deuxième site servant de proxy, disons Proxfree par exemple, pour tester une vidéo sur Youtube).
    • L'iframe empêche le site de savoir ce qu'il se passe à l'intérieur de l'iframe, impossible de donc de mettre à jour l'url comme dans une vraie barre d'adresse lorsqu'on clique sur des liens à l'intérieur.

    Au final, la solution des filtres CSS SVG reste satisfaisante malgré ces petits défauts (et c'est surtout la seule solution viable).

    L'autre option, qui me semblait prometeuse, se basait sur les WebGL custom filters, mais WebGL a l'inconvénient de ne pas fonctionner partout, et de toute façon… après une courte période de test sur Chromium, ces filtres ne sont plus supportés par aucun navigateur aujourd'hui.

    Ma solution

    Bref, après ce pâté de texte, que j'espère vous avez lu sans rien sauter, vous avez le droit au lien vers mon site de simulation de daltonisme, et n'hésitez pas sur les rapports de bug :

    http://colortest.it

    En plus de simuler les trois types de daltonisme les plus courants, le menu à gauche de la barre d'adresse propose deux entrées, "enhance green" et "enhance red", qui peuvent aider les daltonien à distinguer les dégradés ou autres graphiques qui vont du vert au rouge. Ces filtres transforment respectivement le vert ou le rouge en bleu, que la plupart des daltoniens voient distinctement, en laissant l'autre canal tel qu'il est.

    Lire les commentaires

  • VDR 2.4.0 Box TV et multimédia à tout faire (Dépêches LinuxFR)

    Rarement évoqué dans les colonnes de LinuxFr.org, le projet VDR est pourtant une perle du monde libre : Video Disk Recorder est initialement une application qui permet de recevoir toute sorte de signaux TV, DVB-S,C,T. Mais au‐delà de cette fonction de démodulateur TV, les nombreux greffons (plus de 200) permettent de transformer VDR en une solution multimédia complète. Bien évidemment, l’intégration avec Kodi (ex‐XBMC) est parfaite et des modules comme TVHEADEND seront appréciés pour le transcodage des flux. Le tout se pilote par un menu sur l’écran du téléviseur (OSD). N’importe quelle plate‐forme PC équipée d’une carte TV sur connecteur PCI ou sur port USB fera l’affaire.

    Depuis quelques jours, le version stable 2.4 est sortie avec plus de seize années de développement. Bonne réalisation !

    N. D. M. : En page d’accueil de VDR, on profitera d’un paragraphe délectable sur les canaux de télévision en « HD+ ».

    VDR LCAR Skin
    VDR Skin

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Des alternatives à grep, ls et find (Dépêches LinuxFR)

    Les outils en ligne de commande comme ls, grep et find existent depuis de nombreuses années et, même s’ils continuent de s’améliorer, il est parfois intéressant de regarder les alternatives. Je vais vous parler de ripgrep, exa et fd.

    Ripgrep

    Les alternatives à grep ne manquent pas. Déjà, la commande grep de son shell peut être soit le grep du projet GNU ou celui du projet BSD. Il y a aussi le grep intégré à Git. Et d’autres outils sont apparus ces dernières années, citons ack-grep, ag (the silver searcher), pt (the platinum searcher) et le petit dernier ripgrep.

    Ces outils se battent pour savoir lequel est le plus rapide ou a le plus de fonctionnalités. Personnellement, j’utilise ripgrep car il est très rapide, réalise par défaut une recherche récursive dans les répertoires (un gros manque de GNU grep selon moi, mais c’est probablement bien trop tard pour changer le comportement de GNU grep), a une présentation par défaut des résultats que j’apprécie, et il sait chercher dans des fichiers compressés (gzip, bzip2, xz) avec l’option -z.

    Exa

    Lister des fichiers est un besoin de base dans un terminal et ls remplit bien ce besoin. Exa est une alternative à ls que j’utilise pour ses couleurs, qui viennent par défaut et que je trouve plus agréables que celles de ls. Il propose également une vue arborescente des répertoires et fichiers, qui remplace plutôt tree. Exa est aussi capable d’afficher le statut Git des fichiers et répertoires.

    Fd

    Fd peut remplacer avantageusement find. Je n’utilise que très peu l’un ou l’autre, mais fd a une syntaxe plus facile à retenir et il est, d’après ses tests, plus rapide que find. Il utilise par défaut l’encodage UTF-8, il a une sortie colorée et ignore les fichiers listés dans un .gitignore. Et surtout, ça fait deux fois moins de caractères à taper pour le nom de la commande. ;-)

    Les points communs

    Vitesse

    On retrouve beaucoup de benchmarks autour de ces outils, les performances sont un vrai enjeu. Mettre trois secondes au lieu de quinze secondes peut paraître anecdotique pour des recherches un peu compliquées, mais cette différence peut casser le rythme : si une commande prend plus de dix secondes, je vais sûrement commencer à aller voir ailleurs.

    Fonctionnalités et comportement par défaut

    Ces outils ont beaucoup de fonctionnalités : les options que l’on peut passer en ligne de commande permettent de changer fortement leurs comportements. Ceci dit, en pratique, je n’utilise que peu d’options (et quasiment toujours les mêmes). En revanche, j’apprécie beaucoup que ces outils cherchent à avoir le comportement par défaut le plus utile.

    Intégration avec Git

    Ces outils ont tous une intégration avec Git : ripgrep et fd savent lire les fichiers .gitignore et exa sait afficher l’état Git des fichiers. Ce n’est pas un critère très important à mes yeux car je suis à l’aise avec Git en ligne de commande. Mais c’est intéressant de noter à quel point git est devenu incontournable en ligne de commande.

    Rust

    Un fait remarquable est que les trois outils présentés sont écrits en Rust. Il faut croire que ce langage convient bien pour écrire des outils en ligne de commande. C’est un domaine où le temps d’exécution est important (quand on lance une commande, c’est appréciable que le retour soit instantané ou en tout cas très rapide). Les langages de script (JavaScript, Ruby, Python) ont un temps de lancement de leur machine virtuelle qui peut casser cette impression de vitesse, je comprends donc que les développeurs d’outils en ligne de commande puissent s’en éloigner. En revanche, il est plus surprenant de ne pas retrouver d’outils en Go, en D, en OCaml ou en Haskell. Peut‐être que les lecteurs de LinuxFr.org auront une explication à cela.

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Le logiciel libre dont on ne peut utiliser les libertés (Journaux LinuxFR)

    Sommaire

    Dans mon entreprise, on utilise des logiciels libres. Il arrive qu'on aie besoin de modifier ces logiciels tiers, pour gérer un cas spécifique ou pour une meilleure intégration dans l'application.

    Et parfois, en se lançant dans ce genre de travaux, on tombe sur une surprise :

    Il existe des logiciels libres dont il est presque impossible d'utiliser les libertés sans une quantité déraisonnable de travail.

    Je ne parle pas d'openwashing ici, cette technique qui consiste à faire croire qu'un logiciel est libre mais ne l'est pas et dont on a récemment parlé ici. Non, je parle de programmes véritablement libres (sous licence Apache ou MIT généralement, notre code n'étant pas libre ça ne peut être des licences contaminantes comme la GPL) mais dont les subtilités font que… visiblement quelqu’un ne veut pas que les libertés soient trop utilisées. On notera déjà que c'est souvent des logiciels dont il existe une version avancée commerciale.

    Les libertés d'exécution et de redistribution sont généralement faciles à appliquer ; le problème survient souvent quand on veut étudier le programme et l'améliorer. Voici quelques exemples de techniques utilisées ; certaines peuvent être expliquées par un simple manque de volonté d'adhérer à l'esprit du logiciel libre ou par une mauvaise organisation interne ; d'autres s'approchent du sabotage. Dans tous les cas, la licence est respectée à la lettre.

    Toutes les techniques ci-dessous ont été croisées dans des cas réels (heureusement pas toutes sur le même projet) :

    Aucune documentation technique

    Il n'existe aucune documentation technique d'aucune sorte. Selon la taille du logiciel, ça peut être plus ou moins gênant (je vous laisse imaginer quand le workspace du projet fait plusieurs centaines de Mo).

    Parfois, rien qu'obtenir une version exécutable du logiciel à partir des sources est un calvaire.

    Une version avancée consiste à utiliser des frameworks, compilateurs ou réglages exotiques, sans que ce soit documenté publiquement.

    Les dépendances cachées

    Les dépendances du projet vont par défaut se télécharger depuis un serveur qui appartient à la même organisation que le projet, et pas depuis les dépôts standards. Et surprise, ce serveur ne contient (en public) que les dernières versions des dépendances.

    Au pire, ces dépendances sont elles-mêmes libres, on peut toujours aller les chercher et les compiler à la main, mais la quantité de travail pour obtenir une version fonctionnelle explose dès qu'on veut autre chose que la toute dernière version. Et je ne parle pas de la galère quand on veut mettre à jour un fork depuis l'origine.

    Le faux dépôt de sources

    Celle-ci est subtile : le dépôt des sources public n'est d'évidence pas un dépôt de travail, puisqu'il ne contient qu'un seul commit par version, sans le moindre commentaire. Ça n'est pas gênant tant qu'on essaie pas de maintenir un fork.

    La version avancée, qui consiste à ne fournir les sources que sous la forme d'un dossier compressé sans le moindre historique, semble avoir à peu près disparue, du moins dans mon domaine.

    Le tapis et le labyrinthe mouvant

    Deux variantes d'une même technique :

    1. Les sources peuvent être planquées à un endroit inaccessible, voire carrément absentes du site éditorial – rien, pas même un lien, pas même une mention claire de la licence : si tu ne sais pas déjà que le logiciel est libre… tu le découvres en lisant la licence après avoir donné toutes tes informations pour la fameuse « version de démonstration 30 jours ».
    2. Le site change tout le temps, et la manière d'accéder aux sources n'est jamais la même d'un mois sur l'autre.

    À noter que quelques entreprises ne fournissent les sources qu'aux clients de l'entreprise, ce qui est généralement autorisé.

    Une variante intéressante du point 2, c'est quand le logiciel change régulièrement de grands pans de son architecture.

    Le code qui fait des suppositions sur l'environnement de développement

    Généralement à base de chemins en dur dans le code ou de réglages spécifiques à un IDE. C'est rare, mais on en croise…

    La ressource libre-mais-déposée

    Ici ça s'applique plus aux ressources qu'au code, principalement aux logos : votre ressource est libre, mais est une marque déposée. Il y a plein de cas où on ne peut pas l'utiliser. Par exemple, le logo GNU n'illustre pas la version d'origine de cet article, parce que, je cite (le gras est d'origine) :

    Ce dessin est utilisable conformément à la GNU FDL v1.3, à la licence Art libre ou à la Creative Commons CC-BY-SA 2.0 (résumé en français ici). Toutefois, c'est aussi un logo déposé du projet GNU. Si vous voulez vous servir de cette tête de GNU pour mettre en lien un site web de la Free Software Foundation ou du projet GNU, n'hésitez pas ; de même, vous n'avez pas besoin de permission supplémentaire pour l'utiliser dans des contextes qui parlent de GNU de manière positive et exacte. Pour tout autre usage, veuillez au préalable demander la permission à licensing@fsf.org.
    Source: La page du logo GNU sur le site de la FSF

    Et donc ce logo est disponible sous 3 licences libres différentes, mais a des restrictions très fortes sur l'usage qui peut en être fait. C'est en fait valable avec à peu près tous les logos et toutes les marques – et les règles d'utilisations de logos et marques d'entreprises peuvent être bien plus restrictives.

    La conclusion de tout ceci ?

    Qu'un logiciel soit libre n'impose pas que son développeur doive vous faciliter l'application des libertés.

    C'est quelque chose qu'on croit trop souvent, de même qu'on mélange souvent « libre » et « gratuit ».

    Ce texte, placé sous licence CC BY 4.0, est une légère adaptation pour LinuxFR.org de l'original disponible sur Zeste de Savoir.

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Tracim sera à l'honneur aux RPLL (dans le cadre des RMLL) (Journaux LinuxFR)

    Bonjour à toutes et tous,

    Comme vous le savez sans doute, Saint-Étienne accueille dès samedi les Rencontres Mondiales du Logiciel Libre 2017. Mais comme vous ne le savez peut-être pas, les mardi 4 et mercredi 5 juillet se tiendront au même endroit les Rencontres Professionnelles du Logiciel Libre.

    Tracim, logiciel libre pour la mise en place d'extranet professionnels, dont j'ai déjà parlé à plusieurs reprises dans les colonnes de LinuxFR, sera mis à l'honneur par la société algoo (dont je suis le dirigeant).

    Mercredi 5 juillet de 10h à 10h40, j'animerai un atelier intitulé : « Venez découvrir Tracim, le logiciel libre d'extranet professionnel développé par algoo, à travers quelques cas client. »

    Capture d'écran de Tracim

    En attendant Tracim 1.0 prévue pour septembre 2017 — et la dépêche LinuxFR qui accompagnera bien évidemment cette sortie, cet atelier sera l'occasion de découvrir des cas d'utilisation réels, de se faire une idée de la mouture à venir de Tracim, ou tout simplement de se rencontrer.

    A noter que la société algoo aura un stand aux RPLL : celles et ceux qui rodent sur LinuxFR et qui me connaissent à travers mes interventions virtuelles, n'hésitez pas à passer sur le stand algoo : ce sera l'occasion mutuelle de mettre (enfin!) des visages sur tous ces avatars :)

    Note : le stand algoo et l'atelier tracim sont dans le cadre des RPLL et non des RMLL (c'est le bâtiment d'à côté si j'ai bien compris)

    Lire les commentaires

  • G’MIC 1.6.2.0 : Colorisation de BD, transfert de couleurs, aide au détourage et autres réjouissances (Dépêches LinuxFR)

    À l'occasion de la sortie toute récente de la version 1.6.2.0 de G'MIC (GREYC's Magic for Image Computing), framework libre pour le traitement d'image, je vous propose de poursuivre ma petite série d'articles de résumés sur les avancées de ce logiciel libre sympathique, voire indispensable aux traiteurs d'images.

    Cette dépêche présente un ensemble significatif des nouveautés ajoutées à G'MIC depuis la version 1.5.9.3 présentée il y a environ 10 mois, à savoir l'apparition de nouveaux traitements liés à la couleur, l'aide au détourage avant-plan / arrière-plan, de nouveaux filtres artistiques et d'autres faits notables.

    Sommaire

    1. Le projet G'MIC : contexte et présentation.

    gmic_logo
    Fig.1. Mascotte et logo du projet G'MIC, framework libre pour le traitement d'image.

    Le projet G'MIC a vu le jour en Août 2008, dans l'équipe IMAGE du laboratoire GREYC (Unité Mixte de Recherche du CNRS, située à Caen) et évolue depuis à un rythme soutenu. Il est distribué sous licence libre CeCILL.
    Il propose plusieurs interfaces utilisateurs pour la manipulation d'images génériques (images ou séquences d'images 2D ou 3D, multi-canaux, à valeurs flottantes, incluant donc les images couleurs classiques).
    Son interface la plus populaire aujourd'hui est un greffon disponible pour le logiciel GIMP.

    G'MIC for GIMP
    Fig.1.1. Aperçu du greffon G'MIC pour GIMP.

    Mais G'MIC peut aussi s'utiliser en ligne de commande, de façon similaire à ImageMagick (pour des fonctionnalités optimales), ou directement via la page web G'MIC Online. D'autres interfaces existent (ZArt, un greffon pour Krita, des greffons pour Photoflow…) mais celles-ci restent pour le moment plus confidentielles.
    Toutes ces interfaces se basent sur la bibliothèque libgmic, écrite en C++, portable, thread-safe et multi-threadée (via l'utilisation d'OpenMP notamment), qui implémente toutes les fonctions de calculs proprement dites, et qui embarque son propre langage de script permettant aux utilisateurs avancés d'y ajouter leurs fonctions personnalisées de traitement d'image. Aujourd'hui, G'MIC comprend plus de 900 commandes de traitement différentes, toutes paramètrables, pour une bibliothèque d'un peu moins de 5 Mo. Les commandes que propose G'MIC couvrent un large spectre du traitement d'image, avec des algorithmes pour la manipulation géométrique, les changements colorimétriques, le filtrage (débruitage, rehaussement de détails par méthodes spectrales, variationnelles, non-locales…), l'estimation de mouvement / le recalage, l'affichage de primitives, la détection de contours/la segmentation, le rendu d'objets 3d, le rendu artistique, etc.
    C'est un ensemble d'outils très utiles, d'une part pour convertir, visualiser et explorer des données images, et d'autre part pour la construction de pipelines élaborés de traitements.
    Il est entendu qu'étant le programmeur principal de ce logiciel, les avis que je vais exprimer ci-dessous sont totalement partiaux et mon enthousiasme forcément débordant.

    2. Nouveaux traitements liés à la couleur.

    Voici quelques unes des nouvelles commandes et filtres qui ont été ajoutés dans G'MIC récemment, et qui concernent la création ou la modification de couleurs dans des images.

    Application de courbes dans des espaces couleurs quelconques.

    Le concept de courbes de couleurs est bien connu des artistes et photographes désirant retoucher les couleurs de leurs images. Basiquement, un outil de courbes de couleur permet d'appliquer à chaque composante R,G,B d'une image, une fonction 1d continue f:[0,255] -> [0,255] qui va transformer chaque valeur rouge, verte ou bleue x de chaque pixel (supposée initialement comprise entre 0 et 255) en la valeur f(x) donnée par la courbe (fonction) définie par l'utilisateur (et dont les valeurs sont également comprises entre 0 et 255). Très souvent, ces fonctions sont construites par l'utilisateur, par la donnée de quelques points clés interpolés par des splines.

    Mais que se passe-t-il si l'on veut appliquer une fonction de transformation des composantes couleurs dans un espace colorimétrique autre que RGB ? Et bien, on se brosse… Parce que la plupart des logiciels de retouche d'image ne permettent que l'application de courbes couleurs dans l'espace RGB.

    Depuis peu, j'ai donc intégré dans G'MIC un outil de réglage de courbes couleurs dans des espaces colorimétriques autres que RGB, à savoir : CMY, CMYK, HSI, HSL, HSV, Lab, LCh ou YCbCr. C'est la commande -x_color_curves qui s'occupe de cette tâche (en ligne de commande), ou le filtre Colors / Curves [interactive] dans le greffon G'MIC pour GIMP. Un exemple d'utilisation est visible dans la figure ci-dessous (ici avec des courbes définies dans l'espace Lab). Un tutoriel vidéo d'utilisation de ce filtre dans le greffon est également disponible. L'utilisation du filtre dans le greffon permet, par ailleurs, de sauver ses courbes favorites pour une application ultérieure sur un lot d'images par exemple.

    gmic_colors_curves
    Fig.2.1. Définition interactive de courbes de couleurs dans l'espace colorimétrique Lab et application sur une image couleur. À gauche, les courbes définies par l'utilisateur pour les 3 composantes L (clarté), a et b (chrominances). À droite, le résultat de la transformation colorimétrique correspondante.

    Colorisation de BD / Comics.

    C'est en discutant avec David Revoy, illustrateur français de talent, et auteur entre autres du webcomics Pepper & Carrot (dont les moules de LinuxFr.org ont parlé dans ce journal, ou encore celui-ci), qu'a germé l'idée d'un filtre qui pourrait aider les dessinateurs de BD à coloriser leurs images. Le travail de colorisation d'une BD est en effet quelque chose de long et de contraignant, même sur ordinateur, comme l'explique David Revoy sur son blog.
    Il existe déjà des outils d'aide à la colorisation, mais ceux-ci sont fermés, et il y avait donc un manque de ce côté-là pour les utilisateurs de logiciels libres.

    J'ai donc pris mon courage (plutôt mon clavier) à deux mains, et j'ai implémenté dans G'MIC un filtre d'interpolation de couleurs « intelligent » (toute mesure gardée) qui essaye de générer un calque complet de couleurs, à partir seulement d'un nuage de points colorés. L'idée est de demander à l'illustrateur de positionner seulement quelques points-clés colorés sur son image (par exemple à l'intérieur des différentes zones), et de laisser l'algorithme en déduire une colorisation probable de tout le dessin (en analysant les contours et les objets qu'il contient). Avec David Revoy et Timothée Giet nous avons échangé via irc sur la façon d'avoir une interface de colorisation la plus intuitive possible, et le résultat, c'est une nouvelle commande G'MIC -x_colorize (utilisable en ligne de commande) et le filtre correspondant Black & White / Colorize [interactive] pour le greffon G'MIC de GIMP . Et apparemment, ça ne marche pas trop mal !

    Il semblerait même que cet unique algorithme ait suffisamment intéressé les utilisateurs de Krita pour qu'il motive les développeurs à retravailler sur leur propre greffon G'MIC pour Krita pour inclure cet algorithme dedans.
    Depuis, David Revoy a utilisé cet algorithme régulièrement pour ses créations (notamment pour Pepper & Carrot). Ci-dessous, vous pouvez voir un exemple d'une phase de colorisation d'une case de BD de Pepper & Carrot initialement en niveau de gris, avec l'ajout des points-clés colorés et le résultat de la colorisation réalisée par l'algorithme de G'MIC (tout ceci réalisé avec le greffon sous Krita).
    Sur son site, David a posté des vidéos détaillant tout le processus de colorisation qu'il utilise, et dont G'MIC fait maintenant partie.

    gmic_lineart0
    Fig.2.2. Utilisation de G'MIC pour la colorisation de BD : Étape 1, ouverture du dessin à coloriser, ici sous Krita.
    (Cette image provient du site web de David Revoy : http://www.davidrevoy.com/article240/gmic-line-art-colorization)

    gmic_colorize_lineart
    Fig.2.3. Utilisation de G'MIC pour la colorisation de BD. Étape 2, mise en place de quelques points-clés couleurs et colorisation automatique obtenue par G'MIC.
    (Cette image provient du site web de David Revoy : http://www.davidrevoy.com/article240/gmic-line-art-colorization)

    Après cette première étape de colorisation automatique, l'artiste peut ajouter à sa guise ombres et lumières sur les aplats couleurs générés, pour finaliser son œuvre. À noter que cette dernière étape est facilitée car chaque couleur est, de fait, facilement sélectionnable de manière séparée sur le calque couleur généré par l'algorithme. Et, pour ceux qui préfèrent travailler sur des calques de couleurs séparés plutôt que sur des sélections, le filtre de colorisation propose aussi la possibilité de générer N calques couleurs de sortie, chacun contenant une couleur unique.

    Encore un grand merci donc à David Revoy et Timothée Giet pour leurs retours enthousiastes et pédagogiques, nous disposons donc maintenant d'un outil de colorisation de BDs libre que mon dentier nous envie :)
    Voilà un exemple de collaboration entre recherche académique et artistes "libres" qui a porté ses fruits.

    Colorisation de photographies Noir & Blanc.

    Mais ce qu'on peut faire avec des BDs, peut-on le faire avec de vieilles photographies en noir et blanc, me demanderez-vous ? Hé bien oui ! En modifiant légèrement l'algorithme, nous pouvons de la même manière reconstruire la chrominance d'une photographie initialement en niveaux de gris, pour la coloriser à partir de points-clés couleurs définis par l'utilisateur. C'est ce qu'illustre l'exemple ci-dessous, avec la colorisation d'une vieille photo d'indien. À noter que le contenu de l'image étant sensiblement plus complexe qu'une case de BD, il est souvent nécessaire de placer beaucoup plus de points-clés pour coloriser une photographie. C'est le même filtre que précédemment, à savoir Black & white / Colorize [interactive] dans le greffon G'MIC pour GIMP, qui permet cela.

    gmic_colorize
    Fig.2.4. Colorisation d'une vieille photo Noir & Blanc avec l'algorithme de colorisation de G'MIC. (Ugh, vieil indien, excuse-moi pour la couleur improbable de tes cheveux, qui te fait ressembler à Kim Kardashian…)

    Transfert de couleurs.

    Ici, le concept de « transfert de couleurs » correspond au fait de vouloir modifier les couleurs d'une image A en les remplaçant par les couleurs présentes dans une autre image B (l'image de référence), de telle sorte que l'image modifiée A' ait la même « ambiance colorimétrique » que l'image référence B, et ceci bien évidemment, de manière complètement automatique.
    C'est un problème mal posé, complexe à résoudre, et il y a déjà pas mal d'articles de recherche parus à ce sujet (ce papier par exemple). La difficulté c'est d'arriver à générer une image A' en gardant un aspect « naturel », sans création d'aplats de couleurs ou au contraire sans apparition de discontinuités qui ne seraient pas présents initialement dans l'image A originale. Bref, ce n'est pas trivial.

    Récemment, un algorithme de transfert de couleurs a été implémenté et intégré dans G'MIC, et il fonctionne de façon plutôt satisfaisante. Ce n'est pas parfait, certes, mais c'est un bon début. Le filtre Colors / Transfer colors [advanced] du greffon G'MIC pour GIMP permet d'appliquer facilement cet algorithme de transfert. C'est un filtre qui nécessite plusieurs calques d'entrée, dont un calque contenant l'image avec les couleurs de référence à transférer sur les images des autres calques. Voici comment cela se présente dans le greffon. On y voit l'image originale (à gauche dans la fenêtre de prévisualisation), l'image contenant les couleurs de référence (en bas à gauche), et l'image résultat (à droite).

    gmic_transfer0
    Fig.2.5. Aperçu du filtre de transfert de couleurs dans le greffon G'MIC pour GIMP.

    Ce filtre réalise parfois des merveilles avec certaines paires d'images ! Deux exemples de transfert sont illustrés sur la figure ci-dessous. Bien sûr n'espérez pas de résultats miraculeux avec des cas pathologiques (transfert d'une image avec plein de couleurs sur une image monochrome par exemple) ! Mais globalement, ça fonctionne pas mal.

    gmic_transfer2

    gmic_transfer3
    Fig.2.6. Deux exemples de résultats de transfert de couleurs d'une photo de référence (image du milieu) vers une photo source (image de gauche). Les images de droite sont les résultats générés par l'algorithme de transfert de G'MIC.

    Il existe également un tutoriel vidéo qui illustre comment faire fonctionner ce filtre dans le greffon G'MIC pour GIMP.
    On peut également penser à d'autres applications plus « subtiles » de ce filtre, par exemple pour l'homogénéisation de couleurs entre les frames ou les plans successifs d'une même vidéo, ou d'une paire d'images stéréoscopiques, par exemple.

    Simulation de films argentiques.

    Pat David est un photographe amateur américain très actif dans la communauté du logiciel libre orienté photographie, de par ses tutoriels et son expérience qu'il partage sur son blog. J'ai eu la chance d'interagir avec lui à de nombreuses occasions (dont une rencontre en live à LGM'2014 à Leipzig), et cela a donné naissance à pas mal de filtres différents implémentés dans G'MIC. En particulier, nous avons proposé des filtres de simulation de films argentiques, comme ceux présentés ci-dessous. C'est seulement un petit échantillon des plus de 300 transformations couleurs qui ont été concoctées par Patrick et que nous avons rendu facilement accessibles.

    gmic_film
    Fig.2.7. Aperçu de quelques résultats de simulation de films argentiques, disponibles dans G'MIC.
    (Cette image provient du site web de Pat David : http://blog.patdavid.net/2013/08/film-emulation-presets-in-gmic-gimp.html)

    Ces filtres ont assez vite suscité un certain intérêt dans la communauté libre de retouche photo, et ont par la suite été repris et ré-implémentés dans le logiciel RawTherapee.
    Pour rendre ces filtres encore plus visibles, une page web dédiée a été mise au point, qui recense l'ensemble des transformations couleurs proposées et propose de télécharger les CLUTs (fonctions de transfert) utilisées pour chaque transformation. À noter que vous pouvez retrouver ces filtres également sur G'MIC Online pour les tester directement sur vos propres images, directement via votre navigateur web.
    Là encore, c'est une fonctionalité qui manquait dans le logiciel libre (une sorte d'équivalent du logiciel propriétaire DXO FilmPack), et qui a pu être comblée assez rapidement via l'infrastructure proposée par G'MIC.

    3. Aide à la décomposition avant-plan / arrière-plan.

    Quand on fait de la retouche photo, il est assez courant que l'on veuille traiter de manière séparée les objets présents à l'avant-plan et dans le fond. Pour cela, on a souvent besoin de faire une décomposition d'image en avant-plan/arrière plan, en effectuant un détourage (avec l'outil de sélection "lasso" par exemple). Pour des objets un peu complexes, réaliser cette sélection est quelque chose de fastidieux. G'MIC incorpore maintenant un filtre permettant d'accélérer ce travail de découpe des objets. C'est la commande -x_segment (en ligne de commande) ou le filtre Contours / Extract foreground [interactive] du greffon G'MIC pour GIMP qui permet de réaliser cette tâche.

    Le principe est exactement le même que pour le filtre de colorisation présenté précédemment : L'utilisateur place des points-clés, ayant pour label soit « avant-plan », soit « arrière-plan », et l'algorithme interpole ces labels en prenant en compte les contours présents dans l'image, et en déduit ainsi une carte binaire de détourage. Le filtre décompose ensuite l'image en deux calques distincts, un calque contenant les points d'avant-plan uniquement, et un autre avec les points d'arrière-plan. La figure ci-dessous présente un exemple de détourage effectué en utilisant ce filtre : L'utilisateur place quelques points-clés sur une image originale d'une fleur (image en haut à gauche). Les points verts correspondent aux objets d'avant-plan, tandis que les rouges sont placés dans le fond (image en haut à droite). À partir de ces données très éparses, et de l'analyse des contours de l'image, le filtre détermine automatiquement pour chaque pixel son appartenance au calque d'arrière-plan (image en bas à gauche) ou d'avant-plan (image en bas à droite).
    Effectuer ce détourage ne prend ici que quelques secondes, alors que la même opération effectuée manuellement serait beaucoup plus longue (le contour de la fleur n'ayant pas une forme simple). Un tutoriel vidéo illustrant l'utilisation de ce filtre dans le greffon G'MIC pour GIMP est disponible.

    gmic_select
    Fig.3.1. Décomposition avant-plan / arrière plan avec le filtre « Contours / Extract foreground » de G'MIC.

    Cette décomposition de l'image d'origine permet par la suite d'appliquer des traitements différenciés sur l'avant-plan et sur l'arrière-plan. Par exemple ci-dessous nous modifions la teinte et la saturation du calque d'avant-plan uniquement, pour jouer sur la couleur de la fleur, sans modifier la couleur de l'arrière-plan. Le détourage d'objet étant un besoin très fréquent en retouche photo, je vous laisse imaginer le nombre d'utilisations possibles de ce filtre.

    gmic_select
    Fig.3.2. Après modification de la teinte et de la saturation des couleurs de l'avant-plan uniquement.

    4. Nouveaux filtres artistiques.

    G'MIC, c'est aussi tout une floppée de filtres amusants pour créer des effets artistiques sur vos images. En voici quelques-uns notables qui ont été ajoutés dernièrement.

    Effet gravure.

    Le filtre Black & White / Engrave tente de transformer une image en gravure. Le nombre relativement élevé de paramètres permet d'obtenir beaucoup de contrôle sur le type de rendu obtenu.

    gmic_engrave
    Fig.4.1. Aperçu du filtre « Gravure » dans le greffon G'MIC pour GIMP.

    Là où ce filtre est particulièrement intéressant, c'est qu'il permet (en choisissant des paramètres adaptés) de transformer une image en version Comics, comme illustré avec les deux exemples ci-dessous. Un tutoriel vidéo existe également pour montrer les différentes étapes nécessaires à l'obtention de ce type de résultats, qui ne prend au final que quelques secondes (minutes pour les plus lents).

    gmic_engrave2
    Fig.4.2. Conversion de photo (en haut à gauche) sous forme de dessin façon Comics, avec le filtre "Engrave" de G'MIC.

    gmic_engrave3
    Fig.4.3. Conversion d'une photo de chimpanzé (à gauche) sous forme de dessin façon Comics (à droite), avec le filtre "Engrave" de G'MIC.

    Triangulation de Delaunay.

    Un algorithme de calcul de la triangulation de Delaunay 2D/3D a été ajoutée à G'MIC (commande -delaunay3d), et le filtre Artistic / Polygonize [delaunay] du greffon GIMP l'utilise pour transformer une image sous la forme d'ensemble de triangles de Delaunay, qui s'adaptent plus ou moins aux contours de l'image. Chaque triangle généré peut prendre une couleur, soit aléatoire, soit constante, soit liée aux pixels de l'image qui appartiennent au triangle.
    C'est un filtre permettant de créer des abstractions géométriques intéressantes.

    gmic_delaunay
    Fig.4.4. Aperçu du filtre "Polygone [delaunay]" et application sur une image pour un rendu de type "vitrail".

    C'est un filtre qui donne également des choses sympathiques sur des séquences d'images. Je me demande si l'importation de ces images triangulées sous Blender n'aurait pas un intérêt (et même plus loin, carrément un greffon G'MIC pour Blender ?).

    gmic_delaunay
    Fig.4.5. Application de la triangulation de Delaunay sur une séquence d'images.

    Autres filtres artistiques, en vrac.

    Comme vous le voyez, G'MIC est un projet assez actif et le nombre de filtres disponibles (notamment artistiques) augmente de manière assez régulière. On ne peut donc pas décrire en détails tous les ajouts de ces dix derniers mois, et comme quelques images valent mieux qu'un long discours, voici un aperçu rapide de quelques-uns de ces filtres, présenté dans les figures ci-dessous.

    gmic_hexagonal
    Fig.4.6. Aperçu du filtre "Arrays & Tiles / Grid [hexagonal]", potentiellement utile pour les créateurs de cartes des jeux de type Wargames ?

    gmic_crystal
    Fig.4.7. Aperçu du filtre "Patterns / Crystal" qui transforme vos images en cristaux multicolores.

    gmic_lightning
    Fig.4.8. Aperçu du filtre "Rendering / Lightning" qui dessine un éclair dans une image.

    gmic_ministeck
    Fig.4.9. Aperçu du filtre "Arrays & Tiles / Ministeck" qui transforme vos images en représentation de type Ministeck (jeu pour enfants).

    gmic_transition
    Fig.4.10. Aperçu du filtre "Sequences / Spatial transition", qui prend en entrée plusieurs calques et qui génère une séquence d'images de transition entre chaque calque consécutif, avec des motifs de transition réglables.

    5. Autres faits notables.

    Bien sûr, les quelques filtres présentés ci-dessus ne constituent qu'une toute petite partie (la plus visible) du travail effectué sur le code du projet G'MIC durant ces derniers mois. Voici en vrac, les autres aspects (plus techniques) du logiciel qui ont été améliorés.

    Améliorations globales et bibliothèque libgmic. 

    • Énormément d'efforts ont été faits pour le nettoyage et l'optimisation du code : la taille de la bibliothèque libgmic a pu être réduite drastiquement (moins de 5 Mo actuellement), avec une API améliorée. L'utilisation de quelques fonctionnalités du C++11 (rvalue-references) permet d'éviter les copies intempestives de buffers temporaires, ce qui est vraiment appréciable dans le cas du traitement d'image où la mémoire allouée devient vite importante. Avec l'aide de Lukas Tvrdy développeur de Krita, nous avons pu améliorer la compilation du projet sous Visual Studio (Windows), appliquer des analyseurs statiques de code (PVS Studio), empiler des sessions de valgrind / gprof / g++ avec l'option -fsanitize=address pour obtenir un code plus propre et plus efficace. Pas vraiment drôle pour les développeurs, mais au final très satisfaisant pour l'utilisateur ! La conséquence directe de ce processus est de pouvoir proposer des versions pre-release intermédiaires qui restent stables tout en incorporant les dernières nouveautés ajoutées. La méthode de distribution de G'MIC se rapproche ainsi d'une méthode rolling-release.

    • La compilation du projet sous Windows a été également améliorée, avec l'utilisation de g++-4.9.2 / MinGW comme compilateur par défaut pour la génération des binaires, et la création d'installeurs pour les architectures 32 bits et 64 bits.

    • G'MIC possède de nouvelles commandes pour compresser/décompresser des données quelconques à la volée (via l'utilisation de la zlib). De cette façon, nous avons pu réduire la taille des définitions de commandes, des exécutables, et accélérer le processus de mise à jour des filtres via Internet.

    • Le projet G'MIC possède maintenant son propre nom de domaine http://gmic.eu, indépendant de SourceForge, son ancien hébergeur. Nous avons enrichi le contenu des pages web, grâce notamment à de très bons tutoriels sur l'utilisation de l'outil gmic en ligne de commande (écrits par Garry Osgood, un grand merci à lui !). Une page à retenir pour tous ceux qui voudraient se mettre à G'MIC en douceur.

    Quelques nouveautés pour le filtrage d’images.

    Pas mal de nouvelles commandes dédiées au filtrage d'image, et leurs entrées associées dans le greffon G'MIC pour GIMP ont été ajoutées : en vrac, des algorithmes de sharpening ("Mighty Details"), de déconvolution par noyau arbitraire (algorithme de Richardson-Lucy), de filtrage guidé rapide, de Non-Local-Means rapide, de régularisation type Perona-Malik, de filtrage rapide à support fini, de DCT (et son inverse) sont maintenant disponibles.
    G'MIC possède aujourd'hui une foultitude d'opérateurs pour le filtrage linéaire et non-linéare d'image, qui en fait un logiciel libre à posséder absolument pour les traiteurs d'image de tout poil (ne serait-ce pour les méthodes de débruitage qu'il propose). Pour les utilisateurs du greffon, cela signifie potentiellement des filtres encore plus riches dans le futur. Ci-dessous, un aperçu d'application du filtre Details / Mighty details sur une image de portrait, à partir du greffon pour GIMP, pour un effet de type Dragan.

    gmic_mighty
    Fig.5.1 Application du filtre « Mighty Details » sur un portrait pour le rehaussement de détails.

    Amélioration du greffon G'MIC pour GIMP.

    Le greffon G'MIC pour GIMP étant l'interface de G'MIC la plus utilisée à ce jour, il était important de lui apporter son lot d'améliorations :

    • Le greffon possède maintenant un système de mise à jour automatique qui permet d'avoir une liste de filtres avec toutes les dernières améliorations/nouveautés. Au jour de la sortie de la version 1.6.2.0, le greffon possède 430 filtres différents à appliquer sur vos images, auxquels s'ajoutent 209 filtres qui sont considérés comme étant en phase de test (Catégorie Testing/). Pour un greffon de 5,5 Mo, on peut considérer que ça fait un bon rapport nombre de filtres / mémoire occupée ! Une liste de l'ensemble des filtres disponibles dans le greffon est visible ici.

    • Lors de l'exécution d'un filtre un peu gourmand en temps de calcul, le greffon affiche maintenant quelques informations sur le temps écoulé et l'utilisation mémoire du filtre dans la barre de progression correspondante.

    gmic_info.jpg
    Fig.5.2. Affichage des ressources prises par un filtre dans le greffon G'MIC pour GIMP.

    • L'interface du greffon a été améliorée : la fenêtre de pré-visualisation est plus précise dans le cas des filtres prenant plusieurs calques en entrées. Les filtres peuvent être maintenant interactifs : ils peuvent ouvrir leur propre fenêtre de visualisation et gérer des évènements provenant de l'utilisateur. Un filtre peut également décider de modifier l'interface de ses paramètres. Tout ceci nous a permis de proposer de nouveaux filtres interactifs intéressants, comme celui pour la colorisation de BDs, pour le réglage des courbes couleurs, ou encore pour l'extraction d'objets (décrits plus haut), qu'il n'était pas possible de réaliser dans le greffon pour GIMP précédemment (ça n'était possible qu'avec l'outil gmic en ligne de commande).

    • Les filtres du greffon ont maintenant connaissance des informations de base des calques d'entrées (label, position, opacité, mode de mixage), et peuvent modifier ces informations sur les calques de sortie.

    • Un nouveau filtre About / User satisfaction survey a été ajouté, permettant aux utilisateurs de donner quelques informations sur leur utilisation de G'MIC. Le résultat de ce sondage est visible en temps réel ici. Bien sûr, cette image est elle-même générée par une commande G'MIC :).

    Débrider G'MIC : utilisation en ligne de commande.

    gmic est l'interface « ligne de commande » de G'MIC, qui s'utilise à partir d'un shell. C'est l'interface la plus puissante de G'MIC, sans limitations inhérentes aux contraintes d'entrées-sorties des autres interfaces (par exemple, images 2D à 8bits/canal et 4 canaux maximum sous GIMP, une seule image d'entrée 2D avec G'MIC Online, etc.). Ici, on peut charger/sauver et manipuler des séquences d'images 3D multi-canaux à valeurs flottantes sans limites (autres que la mémoire disponible). L'interface ligne de commande a également connu son lot d'améliorations.

    • OpenCV est maintenant utilisé par défaut pour charger/sauver des séquences d'images. On peut donc appliquer des traitements frame par frame sur des vidéos (commande -apply_video), des streamings de la webcam (command -apply_camera), ou générer des fichiers vidéos à partir d'images fixes par exemple. De nouvelles commandes -video2files et -files2video pour décomposer des fichiers vidéos en plusieurs frames ou les recomposer ont été ajoutées. Le traitement de fichiers vidéos devient maintenant (presque) un jeu d'enfant avec G'MIC en ligne de commande ! L'aide (commande -h) a également été améliorée, avec une sortie en couleur, des corrections proposées en cas d'erreur de frappe sur une commande, des liens éventuels vers des tutoriels, etc.

    gmic_cli
    Fig.5.3. Aperçu du fonctionnement de l'aide en ligne de commande.

    • L'appel à gmic sans arguments en ligne de commande active maintenant un mode démo où l'on peut sélectionner différentes petites animations interactives à partir d'un menu, pour voir ce que G'MIC a dans le ventre ! Une bonne occasion pour jouer à Pacman, Tetris ou au démineur en prétextant le fait de tester un logiciel de traitement d'images sérieux !

    gmic_demo
    Fig.5.4. Aperçu de G'MIC, lancé en mode démo !

    Autres interfaces G’MIC en cours de développement.

    • ZArt est une interface de G'MIC initialement développée comme plateforme de démonstration pour le traitement des images provenant d'une webcam. Nous l'utilisons classiquement lors de la Fête de la Science, pour illustrer ce que peuvent réaliser des algorithmes de traitement, pour le grand public. ZArt s'est enrichi significativement, d'une part en permettant d'importer des fichiers vidéos quelconques, et d'autre part, en proposant quasiment l'ensemble des filtres du greffon G'MIC pour GIMP. Cette vidéo illustre ces nouvelles possibilités, avec par exemple la simulation de films photo argentiques sur une vidéo en temps réel. Il pourrait vraiment être très intéressant de disposer d'un greffon G'MIC pour des logiciels d'effets vidéos, comme le tout nouveau Natron par exemple. On a déjà des contacts avec eux, donc on peut espérer que ça puisse se faire dans un futur plus ou moins proche. À noter que ZArt est également passé sans douleur de Qt 4 à Qt 5.

    ZArt
    Fig.5.5. Aperçu du logiciel ZArt traitant une vidéo en temps réel.

    • Depuis quelques temps, Lukas Tvrdy membre de l'équipe de développement du logiciel Krita a commencé à développer un greffon G'MIC pour Krita. Ce greffon est prometteur, il reprend l'ensemble des éléments du greffon déjà disponible pour GIMP, et il fonctionne déjà bien sous GNU/Linux. On travaille ensemble pour régler les quelques problèmes qui subsistent sous Windows. L'utilisation du greffon sous Krita est intéressante car il génère des résultats à 16 bits par composante, voire plus encore (flottants 32 bits), alors que le greffon pour GIMP est pour le moment limité à 8 bits par composante pour les entrées-sorties. C'est quelque chose qui pourrait changer dans le futur avec l'utilisation de GEGL, mais le manque de documentation actuel sur GEGL est un frein au support du 16 bits par composante dans le greffon G'MIC pour GIMP. Donc pour le moment, appliquer des traitements G'MIC sur des images en 16 bits par composantes ou plus nécessite l'utilisation de la ligne de commande ou du greffon Krita.

    gmic_krita
    Fig.5.6. Aperçu du greffon G'MIC pour Krita en action.
    (Cette image provient du site web de Krita : https://krita.org/wp-content/uploads/2014/11/gmic-preview.png)

    • L'intégration de certains traitements de G'MIC dans Photoflow est également en cours. PhotoFlow est un logiciel libre très récent et prometteur qui se focalise sur le développement d'images RAW en JPEG, ainsi que sur la retouche photo.

    gmic_photoflow
    Fig.5.7. Aperçu du filtre "Dream Smoothing" de G'MIC inclus dans PhotoFlow.
    (Cette image provient du site web de PhotoFlow : http://photoflowblog.blogspot.fr/2014/12/news-gmic-dream-smoothing-filter-added.html)

    6. Perspectives et conclusions.

    Voilà ! Le tour des nouveautés notables de ces dix derniers mois est terminé. À noter que tout ceci a été rendu possible grâce aux différents contributeurs (programmeurs, artistes, et utilisateurs en général) de plus en plus nombreux, donc merci à eux.
    Dans le futur, on rêve de toujours plus d'intégration de la libgmic dans d'autres logiciels libres. Un greffon pour Natron serait idéal pour qu'on explore un peu plus les possibilités de traitement de vidéos avec G'MIC. Un greffon pour Blender serait pas mal aussi d'ailleurs ! Un noeud pour GEGL serait intéressant également, pour le prochain GIMP 3.0 (mais bon, on a encore probablement une bonne dizaine d'années pour se décider avant que ça sorte :)).
    Bref, on cherche toujours des contributeurs compétents et intéressés pour explorer ces différentes pistes (et les autres qu'on ne connait pas encore), et on risque de pas s'ennuyer avec G'MIC dans les prochaines années.

    Sur ce, j'y retourne, et je vous donne rendez-vous dans quelques mois pour des nouvelles fraîches du projet GMIC !

    Lire les commentaires

  • HOW TO : Bench this SSD (Journaux LinuxFR)

    Salutations

    Bon, voilà, j'ai voulu voir ce que pouvait donner un petit bench (test de performances) sur mon SSD, histoire de me familiariser avec les outils à disposition pour le faire, et également dans un but de découverte.

    • Conditions de tests

    A ma disposition, j'ai donc un disque SSD de capacité 256 Go, et de marque Transcend. Avec plus de détails via la commande smartctl (dispo via le paquet smartmontools):

    sudo smartctl -a /dev/sda
     Device Model: TS256GSSD370S
    Serial Number: C571740122
    Firmware Version: O0919A
    User Capacity: 256 060 514 304 bytes [256 GB]
    Sector Size: 512 bytes logical/physical
    Rotation Rate: Solid State Device
    Device is: Not in smartctl database [for details use: -P showall]
    ATA Version is: ACS-2 (minor revision not indicated)
    SATA Version is: SATA 3.1, 6.0 Gb/s (current: 6.0 Gb/s)

    J'ai pas mis la totalité des informations retournés, mais ces quelques lignes sont déjà importantes. Notamment la vitesse théorique du port SATA qui est de 6 G/s. Vu la version (3.1), on sait qu'on a affaire à du mSATA (adaptation du SATA destinée aux portables, SSD…). Le débit théorique sera difficilement atteignable, on va donc plutôt parler de débit crête pratique qui va se situer pour ce modèle aux alentours de 600 Mo/s (comme on le voit plus bas).

    • Tests du SSD en écriture

    Pour les premiers tests, je vais me baser sur la commande « dd » très souvent utilisée lorsque l'on parle de bench.
    On va utiliser un fichier de 1G (1024 bloc de 1M) :

    dd if=/dev/zero of=tempfile bs=1M count=1024
     1024+0 enregistrements lus
    1024+0 enregistrements écrits
    1073741824 octets (1,1 GB) copiés, 3,39989 s, 316 MB/s

    On a donc écrit ce fichier en 3.39s, ce qui nous a donné une vitesse d’écriture de 316M/s. C'est pas mal, même si on est assez loin des 600.

    Pour info, le fichier a été écrit sur une partition utilisateur (home), donc pas nécessairement perturbé par des processus I/O. J'ai voulu faire la même chose sur une partition virtualisée pour voir si on avait le même type de performance :

    dd if=/dev/zero of=tempfile bs=1M count=1024
     1024+0 enregistrements lus
    1024+0 enregistrements écrits
    1073741824 bytes (1,1 GB, 1,0 GiB) copied, 1,82052 s, 590 MB/s

    Non mais ! Pas d'excitation, même s'il est vrai que le débit est excellent…
    Ce qu'on peut déjà souligné, c'est que le fait de lancer ma copie « dd » sur une VM n'a pas plus d'incidence que sur ma session hôte.
    Par contre, là où il ne fallait pas s'étonner, c'est sur le débit. En effet, le débit est extrêmement variable : il me suffit juste de relancer la commande à la suite pour afficher une autre vitesse. J'ai lancé la commande sur 4 passes, pour vérifier que ce n'est pas l'opération précédente qui influençait le résultat :

    for i in {0..3};do dd if=/dev/zero of=tempfile bs=1M count=1024 conv=sync;done
     1024+0 enregistrements lus
    1024+0 enregistrements écrits
    1073741824 bytes (1,1 GB, 1,0 GiB) copied, 1,91371 s, 561 MB/s
    1024+0 enregistrements lus
    1024+0 enregistrements écrits
    1073741824 bytes (1,1 GB, 1,0 GiB) copied, 2,60669 s, 412 MB/s
    1024+0 enregistrements lus
    1024+0 enregistrements écrits
    1073741824 bytes (1,1 GB, 1,0 GiB) copied, 1,95611 s, 549 MB/s
    1024+0 enregistrements lus
    1024+0 enregistrements écrits
    1073741824 bytes (1,1 GB, 1,0 GiB) copied, 2,60068 s, 413 MB/s

    Une remarque au passage…

    J'ai utilisé ici le périphérique /dev/zero pour générer mon fichier de sortie. Si j'utilise le « urandom » à la place, le débit est nettement plus réduit :

    dd if=/dev/urandom of=tempfile bs=1M count=1024
     1024+0 enregistrements lus
    1024+0 enregistrements écrits
    1073741824 bytes (1,1 GB, 1,0 GiB) copied, 8,00623 s, 134 MB/s

    Autre remarque. Je suis également parti sur le montage d'une partition dédiée avec la désactivation du cache au mount :
    ext4 sync 0 0

    dd if=/dev/zero of=tempfile bs=1M count=1024
     1024+0 enregistrements lus
    1024+0 enregistrements écrits
    1073741824 bytes (1,1 GB, 1,0 GiB) copied, 3,20391 s, 335 MB/s

    On constate nettement la perte de débit sur ce type de partition.

    • Tests du SSD en lecture

    Idem qu'au dessus, toujours avec la commande « dd », et on va jouer sur la taille des blocs :

    dd if=tempfile of=/dev/null bs=1M
     1024+0 enregistrements lus
    1024+0 enregistrements écrits
    1073741824 bytes (1,1 GB, 1,0 GiB) copied, 0,235401 s, 4,6 GB/s

    dd if=tempfile of=/dev/null bs=512k conv=sync
     2048+0 enregistrements lus
    2048+0 enregistrements écrits
    1073741824 bytes (1,1 GB, 1,0 GiB) copied, 0,213183 s, 5,0 GB/s

    On constate qu'on a pas d'influence sur la taille des blocs, et qu'on est assez proche de la vitesse théorique du port. On va essayer de faire la même chose en vidant cette fois le cache mémoire avant de lire le fichier:

    sudo sh -c "free && sync && echo 3 > /proc/sys/vm/drop_caches && free"; dd if=tempfile of=/dev/null bs=512K
     total utilisé libre partagé tamp/cache disponible
    Mem: 1593340 293032 1188332 3272 111976 1167924
    Partition d'échange: 1638396 32792 1605604
    total utilisé libre partagé tamp/cache disponible
    Mem: 1593340 291312 1192672 3272 109356 1170944
    Partition d'échange: 1638396 32792 1605604
    2048+0 enregistrements lus
    2048+0 enregistrements écrits
    1073741824 bytes (1,1 GB, 1,0 GiB) copied, 2,91954 s, 368 MB/s

    Ah oui, effectivement, ca change tout de vider un cache mémoire ! D'un autre côté, ca ne surprend pas tant que çà, c'est un peu le but en perf d'accéder à l'information en priorité sur le cache.

    Ce que j'ai remarqué également, c'est que même en désactivant le cache via la commande « hdparm », ca me remontait des débits proche du 5G/s. De ce que j'en ai compris, la commande ne désactive que les blocs. Le cache mémoire est de plus haut niveau.

    La partition dédiée, comme vu plus haut, n'apporte pas de plus par rapport à une partition habituelle :

    dd if=tempfile of=/dev/null bs=1M
     1024+0 enregistrements lus
    1024+0 enregistrements écrits
    1073741824 bytes (1,1 GB, 1,0 GiB) copied, 0,227458 s, 4,7 GB/s

    • D'autres alternatives de tests

    En dehors de la fameuse commande « dd », il y aurait d'autres façons de mesurer les performances de son SSD, et de façon bien plus détaillé. On va mettre tout ca en pratique…

    Une des commandes phares, car elle permet d'affiner les variables à prendre en compte lors du bench, et d'afficher en sortie des détails très poussés sur les performances du disque, est la commande « fio ». Vous trouverez bien plus de détails sur le portail git du projet: https://github.com/axboe/fio

    Appliquons la commande à notre SSD :
    sudo fio --name=filerand --ioengine=libaio --iodepth=1 --rw=randwrite --bs=4k --direct=0 --size=256M --numjobs=4 --runtime=60 --group_reporting

    En gros, on va générer 4 fichiers filerand d'une taille de 256M chacun (taille du bloc 4K), écrit aléatoirement (comme le /dev/urandom?), soit une opération fio de 1G pour une durée max de 60 secondes. La taille de l'opération ne doit pas excéder la taille de la RAM. Dans mon cas, c'est parfait, puisque j'ai une ram dispo de 1.5G.
    L'option concernant le moteur d'io utilisé par fio (ioengine) sont couramment soit la libaio, soit la sync (appels asynchrones, ou pas).
    L'iodepth n'a pas d'importance au délà de « 1 » pour un ioengine en mode synchrone. Après, certains OS limite cette possibilité, donc au final, on commence avec 1, et on peut éventuellement augmenter la valeur.
    L'option « direct » va essentiellement jouer sur les performances en lecture, soit avec une mise en cache, soit en accès direct. En mettant l'option à « 0 », on va utiliser le cache, et donc améliorer les performances en read.

    Plus de détails ici : https://wiki.mikejung.biz/Benchmarking

    Parmi les nombreuses lignes de résultat, une des plus importantes à checker est celle-ci :

    write: io=1024.0MB, bw=45541KB/s, iops=11385, runt= 23025msec
    Donc, pour résumer, l'opération pour écrire 1G a duré 23s, pour un débit en iops de 11385, soit une vitesse en écriture de 45.54Mb/s, mais plus précisément(11385 * 4 (taille du bloc) / 1024 = 44.47 Mbs) - Pour le calcul, je me suis basé sur le site : http://www.ssdfreaks.com/content/599/how-to-convert-mbps-to-iops-or-calculate-iops-from-mbs

    Avec l'option ioengine à « sync », cela nous donne :
    write: io=1024.0MB, bw=71056KB/s, iops=17764, runt= 14757msec
    soit un taux de 71Mbs

    Pour un fichier plus gros, et donc en augmentant le nombre de jobs à 8, ca se corse :
    write: io=2048.0MB, bw=42642KB/s, iops=10660, runt= 49181msec
    soit un taux de 42.64Mbs

    Il y a énormément d'options, ce sera difficile de tout détailler ici, mais je vous conseille d'aller faire un tour sur le git, et d'essayer sur vos disques.
    Par contre, on voit bien l'intérêt de tels outils (notamment le fio) lorsque l'on désire vérifier le bon fonctionnement du disque, avant d'impacter la cause d'un ralentissement à des processus trop gourmands (bien que cela peut effectivement jouer). Mais c'est plus dans le sens d'analyse de l'état d'un périphérique avant d'en demander la maintenance.

    Lire les commentaires

  • Défragmenter une partition FAT32 sous Linux … (Journaux LinuxFR)

    Ho putain ce titre de journal, bienvenue dans les années 90 !

    Le FAT32 reste, pour notre plus grand malheur, le seul format dont on soit à peu près sûr qu'il soit entièrement utilisable partout. J'utilise donc ce format pour stocker sur clé USB ma collection musicale afin d'en profiter en voiture.
    Mais ma voiture semblait bouder certains morceaux, de manière reproductible, sans que je ne comprenne le problème : on entendait une saccade 3, 4, 10 fois sur certains fichiers. TRÈS désagréable. Je supputais un problème avec certains codecs (j'ai du flac et du vorbis, qui sont rarement testés par les fabricants). Mais une idée m'est venue : et s'il s'agissait de fragmentation et que le lecteur de la voiture ne pré-chargeait pas correctement le fichier, provoquant donc des saccades ensuite à la lecture ? Je souffre déjà de problèmes similaires sur un disque dur avec des vidéos en HD ou en UHD, il faut réduire au maximum le nombre d'extent pour que la lecture ne soit pas saccadée… Se peut-il ?

    0) Rappel sur ce qu'est la fragmentation

    La fragmentation, c'est stocker un fichier en plusieurs parties sur le disque dur au lieu d'un ensemble contigu de blocs. Elle se produit quand un disque devient trop rempli, ou quand le système de fichiers est mal ficelé et ne gère pas correctement certaines opérations.

    1) Les outils pour gérer la fragmentation sous linux

    C'est simple, y'a pas grand monde… Pour vérifier l'état de fragmentation, il y a filefrag, du paquet e2fsprogs, qui marche pour la plupart des systèmes de fichiers. Et il y a les outils spécifiques à certains systèmes de fichier, btrfs filesystem defragment par exemple.

    Et c'est tout. Tristesse

    2) Comment corriger…

    Ma clé USB a beaucoup de place libre. La fragmentation a du se produire lors de l'import de la collection musicale (j'avais copié jusqu'à 3 dossiers en parallèle). Donc a priori une simple copie de chaque fichier devrait être suffisante en FAT32 (il ne fait pas de copy-on-write…)
    Mais j'ai une centaine de fichiers à corriger, dans une grand arborescence… Donc scriptons !

    #!/usr/bin/env python3

from pathlib import Path
import re
import shutil
import subprocess
import sys

# /my/beautiful/path/filename: 42 extents found

ffrag_re = re.compile(r".*: (\d+) extents? found$")
FRAGMENT_LIMIT = 5

def get_fragments_count(file_path):
    f_frag = subprocess.check_output(["filefrag", file_path.as_posix()])
    m = ffrag_re.match(f_frag.decode('utf-8'))
    assert(m is not None)
    return int(m.group(1))

def defrag(file_path):
    temp_file = Path(file_path.with_name(file_path.name + '.new'))
    shutil.copy(file_path, temp_file)
    new_frags = get_fragments_count(temp_file)
    if new_frags > FRAGMENT_LIMIT:
        print("New file %s still has too many fragments - %s", (temp_file.as_posix(), new_frags))
        temp_file.unlink()
    else:
        file_path.unlink()
        temp_file.rename(file_path)
        print("New file has %s fragments" % new_frags)

def check_folder(folder, recurse = True):
    for item in folder.iterdir():
        if recurse and item.is_dir():
            check_folder(item)
        else:
            frags = get_fragments_count(item)
            if frags > FRAGMENT_LIMIT:
                print("File %s: TO DEFRAG - %s" % (item.as_posix(), frags))
                defrag(item)
            else:
                #print("File %s: OK" % item.as_posix())
                pass

if __name__ == "__main__":
    if len(sys.argv) != 2:
        sys.exit(1)
    folder = Path(sys.argv[1])
    check_folder(folder)

    Ce script est assez basique, je vous laisse rajouter l'aide, le decorum usuel… En gros, on le lance en donnant en paramètre le dossier à défragmenter, il va interroger filefrag pour chaque fichier de chaque dossier récursivement, et si ce fichier a plus de 5 fragments (valeur obtenue par le lancer d'un dé), alors on fait une copie du fichier et l'on écrase l'original. Cela a pour effet de forcer le noyau à créer un nouveau fichier qui ne sera pas fragmenté…

    Exemple de sortie :

    File /media/snoopy/KINGSTON/Renaud/A la Belle de Mai/07 - Le petit chat est mort.mp3: TO DEFRAG - 108
New file has 1 fragments
File /media/snoopy/KINGSTON/Celtas Cortos - Vamos!/02 - 20 de Abril.flac: TO DEFRAG - 166
New file has 1 fragments

    Maintenant il n'y a plus qu'à attendre et écouter, j'espère que le problème ne se produira plus, je déteste qu'on abîme ma musique.

    Et n'hésitez pas à reprendre ce script, l'améliorer, en faire des papillotes ou des tee-shirts ou que sais-je ! :)

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • OpenDBViewer 1.0.1, lecteur de base de données léger SQLite & MySQL (Dépêches LinuxFR)

    OpenDBViewer est un petit logiciel qui permet dans une interface très simple de se connecter à une base de données SQLite ou MySQL.

    Je l’avais d’abord conçu en Python pour mes besoins personnels et professionnels. Ce logiciel a été ensuite converti en C++ avec Qt. Bien qu’il soit opérationnel, beaucoup de choses pourraient l’améliorer. Pour cela, les contributions des utilisateurs et des développeurs sont chaleureusement espérées.

    OpenDBViewer utilise un système d’onglets pour visualiser plusieurs tables et bases en même temps.

    Capture d’écran d’OpenDBViewer

    Après avoir eu la volonté de migrer ce logiciel en C++ avec Qt, j’ai eu l’opportunité de proposer ce travail comme mini projet de stage au sein de mon entreprise, sous ma tutelle. Une stagiaire a donc effectué le gros du travail et après un peu de remise en forme du code, nous avons choisi de mettre les sources à disposition de la communauté sous la licence GNU GPL v3. la compilation nécessite Qt5 base devel et Qt5 qttranslations. Les chaînes de compilation de mon entreprise me permettent ainsi de facilement empaqueter l’application pour GNU/Linux (Debian), Windows et macOS.

    J’avoue que nous avons peu de temps pour travailler sur ce projet, mais nous allons continuer à lui apporter quelques améliorations petit à petit en fonction nos besoins. Vos êtes invités à vous joindre à nous : toutes les contributions et les retours de bogues seront traités dans les meilleurs délais. ;)

    Lire les commentaires

  • Lancement de GapMea logiciel de modélisation de données (Dépêches LinuxFR)

    GapMea est un outil de conception de bases de données (code sous licence GPL v3+ et documentation sous GFDL v1.3+).

    GapMea est un outil graphique de modélisation des données écrit en C++ à l’aide de la bibliothèque Qt. Il permet de formaliser des schémas recueillant et structurant les informations nécessaires à un domaine de gestion. Le schéma obtenu est enregistré dans un fichier texte au format XML. Le logiciel permet la génération du code SQL nécessaire à la création des tables de la base de données qui vont accueillir les informations.

    Cet outil permet un apprentissage rapide de la modélisation des données. Il offre une représentation synthétique des relations entre les tables d’une base de données.
    Voici un aperçu du genre de schémas que l’on peut créer :
    schéma des tables créé avec GapMea

    L’auteur

    Professeur certifié en Informatique de Gestion, j’enseigne depuis plus de vingt ans en section de Technicien supérieur en informatique, aujourd’hui dénomméee BTS « Services Informatiques aux Organisations ».

    Je suis donc en premier lieu enseignant, mais aussi développeur, administrateur système, dompteur de routeurs et autres commutateurs…

    Le projet

    Il est né d’un besoin, ni Umbrello ni Dia ne me satisfaisaient pour cet objectif particulier.

    Historique

    GapMea est un projet que je traîne depuis très longtemps : un premier jet a été développé avec Delphi et Interbase, puis un portage sous feu Kilix, une reprise complète et salutaire en Qt4 et enfin un portage sous Qt5.

    De très nombreuses heures de travail donc… Il est maintenant temps pour ce code de quitter mon disque dur poussiéreux.

    Longue vie à lui et au logiciel libre.

    Lire les commentaires

  • Kit de construction du village global (Dépêches LinuxFR)

    Le précédent article de ce type (« Do It Yourself ») portait sur les fermes de fenêtres (« windowfarms »). Il s'agissait d'enchaîner verticalement et près des fenêtres, dans des bouteilles en plastique coupées, un véritable potager. Une autre conférence TED (Technology Entertainment Design, cycles de conférences sur « la science, les arts, la politique, les questions mondiales, l'architecture, la musique et plusieurs autres sphères de compétences. ») nous présente le « Kit de construction du village global ».

    Appel à contributions LinuxFr.org : l'espace de rédaction collaborative est maintenant connu de tous, et très mûr. Nous vous encourageons à publier des articles sur le « bricolage » ou « Do It Yourself » libre et open source.

    Le « Global Village Construction Set » (GVCS) est un projet exposé par Marcin Jakubowski : le « kit de construction du village global », ou « Global Village Construction Set » (GVCS) est une plateforme modulaire, à faire soi-même, à bas coût et haute performance, qui permet la fabrication facile de 50 machines industrielles nécessaires pour construire une civilisation petite et néanmoins durable avec le confort moderne. Nous sommes en train de développer des machines industrielles open source qui peuvent être fabriquées pour une partie des prix commerciaux, et partageons nos conceptions en ligne, gratuitement.

    Planter une graine

    Comme beaucoup de projets libres, celui-ci est né d'un seul homme : Marcin, polonais sur-diplômé (PhD in Fusion Energy), parti vivre aux USA, pour finalement se rendre compte que ses diplômes étaient inutiles, il a créé sa ferme. Mais son tracteur ayant lâché, il s'est retrouvé ruiné. Il a donc essayé et construit ses propres machines et publié ses conceptions en ligne sur un wiki, incluant les modèles 3D, les schémas, des tutoriels vidéo et même les budgets. Il a vu les contributions arriver progressivement, à base de prototypes.

    Global Village Construction Set

    50 machines

    Ces 50 machines couvrent des domaines allant de l'agriculture à la génération d'énergie, du transport à l'hébergement, et cela inclut la fabrication de toutes ces machines. Par exemple, un four, une scie industrielle, une plate-forme de forage de puits, une turbine à vent, une scie laser, une micro-maison, et il y en a d'autres.

    Décentralisation de la fabrication

    Dans un monde commercial, basé sur la rareté et le renouvellement (certains appelleront cela l'obsolescence programmée), il est possible, grâce à l'OpenHardware et le DIY, de créer et fabriquer les machines les plus indispensables à l'humanité, de les maintenir et les réparer à des coûts bien moindres. Le but du projet GVCS est donc d'abaisser les barrières d'entrée, par la décentralisation, à la construction, la fabrication et l'agriculture.

    Lire les commentaires

  • Sortie de poezio 0.9 (Dépêches LinuxFR)

    Poezio est un client de messagerie instantanée en console (licence zlib) pour le réseau XMPP (Jabber) (pour plus de détails, voir la série de très bons journaux rédigés par goffi qui vont en détail dans le protocole et ce qu’il permet d’accomplir).

    Poezio est conçu pour être rapide à utiliser au quotidien, avec une utilisation se rapprochant des clients IRC bien connus comme weechat et irssi. Dans cet esprit, il est avant tout conçu pour les salons de discussions (MUC) et ne gérait même pas la connexion à un compte (on peut maintenant en avoir un) dans les premières versions, dans l’idée d’avoir le même genre de client qui ne nécessite pas de configuration préalable.

    Poezio offre néanmoins un certain nombre de fonctionnalités avancées liées à XMPP, comme la correction de messages, les accusés de réception, les message carbons (duplication de messages vers tous les périphériques), le formatage xhtml-im, une interface de debug XML complète, et bien plus encore. Un certain nombre de compromis sont malheureusement réalisés du fait de l’interface en ncurses qui limite un peu les options niveau interface utilisateur.

    Du point de vue de la sécurité, poezio force le chiffrement avec le serveur en utilisant des ciphers corrects (l’utilisateur peut cependant désactiver le chiffrement ou réduire la qualité des ciphers), fait du cert pinning (via un hash du certificat à la première connexion, et un gros avertissement si ça change ensuite). Il intègre également un plugin GPG (que personne n’utilise) et OTR.

    Côté technologie, poezio dépend généralement de la dernière version de python en date à chaque nouvelle release, ce qui est rarement du goût de debian stable.

    Sommaire

    Nouveautés de poezio 0.9

    (NdM: l'auteur du journal mathieui est membre du projet et s'exprime à la première personne dans la suite.)

    Python 3.4 et slixmpp

    Une fois de plus, la version de python requise est incrémentée (pour 3.4).

    Cette fois c’est parce que nous avons changé de bibliothèque XMPP pour slixmpp, qui est notre fork de SleekXMPP (bibliothèque utilisée auparavant), en y substituant le multithreading événementiel par asyncio. Pour comprendre les raisons de ce fork, référez-vous à l’article de louiz’ donné en lien ci-dessus. (pour résumer : un code plus lisible, pas de race conditions, plus de facilité à raisonner sur le code)

    Cela ne veut pas dire pour autant qu’on se désolidarise complètement de SleekXMPP qui reste une excellente bibliothèque, puisque slixmpp partage toujours avec elle la majorité de son code sans modification. Nous pourrons donc appliquer des nouvelles fonctionnalités et corrections sans ou avec peu de modifications, et leur envoyer les nôtres en retour également.

    Greffon OTR amélioré

    Le greffon OTR qui avait été réécrit avec poezio 0.8 manquait encore des fonctionnalités communément attendues dans un greffon de chiffrement, c’est maintenant corrigé.

    La nouvelle fonctionnalité majeure est le Socialist Millionaire’s Protocol (SMP) qui permet à deux personnes de vérifier l’identité de leur correspondant respectif, à travers un secret partagé ou une question (auparavant il était possible de vérifier les identités, mais seulement en communiquant les empreintes de clefs sur un autre canal).

    D’autres améliorations sont présentes comme un peu de traitement de HTML pour améliorer l’expérience utilisateur, et d’autres options de sécurité pour forcer le chiffrement et la négociation de session.

    OTR

    Connexion avec des certificats clients

    Poezio permet désormais de se connecter sans mot de passe à son serveur en utilisant des certificats X.509 et un mécanisme décrit dans la XEP-0178, et également de gérer ces derniers à travers les fonctionnalités décrites dans la XEP-0257.
    Avec ces fonctionnalités vous pouvez, une fois connecté, ajouter, désactiver, lister ou supprimer ces certificats du serveur.
    Un bug dans le module prosody empêche malheureusement l’utilisation de la XEP-0257 pour l’ajout d’un certificat, mais on peut le patcher en attendant.

    Commandes ad-hoc

    Les commandes ad-hoc dans XMPP permettent à un humain d’interagir avec une entité sans qu’il existe de spécification précise quant à la nature de l’interaction (en dehors XEP-0050, justement). Par exemple, prosody permet avec le chargement du bon module de charger/décharger des modules, de déconnecter ou supprimer des utilisateurs, etc, juste avec des commandes ad-hoc.
    Dorénavant, poezio peut donc lister et exécuter ces commandes ad-hoc à travers une interface dédiée.

    Couleurs de pseudo

    Auparavant, les couleurs de pseudos étaient attribuées selon l’ordre d’entrée des participants dans le salon, ce qui était mémorisable en gardant poezio ouvert plusieurs mois, mais restait perturbant quand la même personne avait une couleur différente selon le salon dans laquelle elle était.
    À partir de maintenant, les pseudos seront hashés avant d’être projetés sur la liste des couleurs disponibles, ce qui permet d’obtenir une distribution relativement uniforme, aléatoire, et surtout fixe des couleurs. Les gens qui utilisent le même pseudo partout devraient donc toujours garder la même couleur.
    Si vous préfériez l’ancien comportement (pour des raisons étranges sûrement valides), il existe toujours et peut être réactivé en changeant une option.

    De plus, Perdu a ajouté une commande pour régler définitivement la couleur d’un pseudo, donc si vous trouvez qu’une couleur attribuée ne convient pas à quelqu’un, vous pouvez le modifier.

    Accusés de réception

    Les messages envoyés par poezio demandent maintenant des accusés de réception, si le correspondant les prend en charge. Évidemment, poezio répond également aux demandes d’accusés de réception, ce qui devrait permettre aux clients mobiles plus de fiabilité.
    Ce comportement peut être personnalisé, mais il est activé par défaut. Si un accusé de réception est reçu pour un message envoyé, un caractère de validation en vert s’affichera à côté du message.

    poezio receipts

    Gestion de marque-pages

    La commande /bookmarks permettait auparavant de lister tous les marque-pages connus, de façon un peu brute. Désormais cette commande ouvre un onglet vous permettant d’éditer les marque-pages, mots de passe, et de choisir l’emplacement de stockage ainsi que l’autojoin à l’ouverture du client.

    poezio bookmarks

    Performance

    Certains bouts de poezio étaient affreusement mal optimisés. Certains le sont certainement encore, mais quelques scénarios assez communs devraient être plus rapides de façon exponentielle (par exemple rejoindre un salon avec plusieurs milliers de participants). La lenteur est habituellement invisible dans les cas normaux (comme quelqu’un utilisant poezio sur un ordinateur construit après 2002 en ayant quelques tabs ouverts), mais ça devient plus problématique quand poezio tourne sur une carte ARMv7 à faible consommation avec plusieurs centaines de salons ouverts et un flux constant de nouveaux messages ou présences.

    Greffon IRC

    louiz’ a écrit entre temps un composant IRC appelé biboumi (qui est pour moi la meilleure passerelle IRC disponible). Malheureusement, mélanger des onglets IRC et des MUC normaux est un peu perturbant, j’ai donc écrit un greffon IRC simpliste qui, une fois configuré correctement, gère l’authentification avec nickserv et la connexion aux salons ensuite, ainsi que des commandes préfixées par irc_ pour plus de fluidité dans un fonctionnement normal. Le fonctionnement interne est un hack, mais ça reste bien plus agréable que de tout faire soi-même à chaque fois.

    Reconnexion aux salons

    Le problème quand une connexion timeout ou qu’un serveur redémarre est que vous pouvez ne jamais être prévenu que vous n’êtes en fait plus dans le salon avant que vous n’essayiez d’envoyer un message ou une présence et que ce dernier vous réponde par une erreur. Cette nouvelle version introduit un mécanisme appelé le self-ping qui, une fois activé (et éventuellement configuré plus finement), fera en sorte que poezio s’envoie un ping à travers chaque salon au bout d’un certain temps d’inactivité. Si le salon lui reçoit par une erreur, il va quitter le salon (afin d’être certain de ne plus y être) puis y revenir.
    Cela devrait permettre de ne plus découvrir le matin que l’on a été déconnecté de tous les salons juste après avoir été se coucher parce qu’un serveur a redémarré quelque part.

    Et bien plus encore

    Bien évidemment, il y a plus de commits que ça (plus de 500), que ce soit pour des nouvelles fonctionnalités ou des corrections de bugs. Par exemple, des améliorations de la commande /set, une refonte de l’onglet de debug XML, une commande de destruction de salon, le passage au SHA-2 pour la vérification du certificat, etc…
    Vous pouvez regarder le CHANGELOG ou l’historique git pour plus de nouveautés.

    Packaging

    Comme dit précédemment, poezio dépend maintenant de la bibliothèque slixmpp, cette dernière dépendant d’aiodns, ainsi qu’optionnellement de cython afin d’optimiser un module (et dans ce cas libidn sera requis également, ainsi que ses en-têtes pendant la compilation).

    Contributeurs

    En dehors de moi (mathieui), louiz’, et Link Mauve, je veux remercier les autres contributeurs Perdu, Ge0rG, eijebong, Florian Duraffour et Akim Sadaoui pour leur apport en fonctionnalités et corrections.

    Bugs

    Comme toujours, si vous essayez la version et que vous remarquez un bug également non corrigé dans la version git, merci de le rapporter.

    Lire les commentaires

  • Gestion de versions et sauvegarde de données (Journaux LinuxFR)

    Est-ce que la gestion de versions peut être considérée comme de la sauvegarde de données et inversement ?

    L'hypothèse

    La gestion de versions permet essentiellement de garder un historique des modifications sur les fichiers et de garder une cohérence entre les fichiers (je laisse volontairement de côté pour l'instant la gestion des branches de développement et le travail collaboratif).
    La sauvegarde de données permet essentiellement de garder un historique des fichiers.

    Donc à priori la gestion de versions peut servir comme sauvegarde de données (d'ailleurs des logiciels de sauvegarde comme bup s'appuient sur git pour fonctionner). Mais dès que l'on creuse un peu, on se rend compte que cet amalgame provoque des réactions épidermiques chez certains administrateurs systèmes ou spécialiste de la sauvegarde de données.

    Le problème

    En effet j'ai eu une discussion plutôt animée à ce sujet [1] car je sauvegardais mes données sur ma propre machine (sauvegarde locale, sur le même disque dur donc) avant d'envoyer la sauvegarde ailleurs (sauvegarde distante, sur un serveur distant) pour des raisons de performances et de souplesse [2].
    En pratique je procède comme de la gestion de versions distribuée avec un dépôt local et un dépôt distant.

    Le point qui fait hurler c'est le fait de sauvegarder sur sa propre machine, ce qui est parfois considéré comme une hérésie. On me dit alors que ce n'est pas une « sauvegarde », et que c'est au mieux un miroir temporaire, un cache, un instantané (snapshot), une bidouille bancale, etc. Bref tout sauf une sauvegarde. Donc la seule vraie sauvegarde c'est celle qui est présente sur le serveur distant.

    L'argumentation

    Pourtant pour moi j'utilise la sauvegarde locale comme une vraie sauvegarde : je stocke mes fichiers, je restaure mes fichiers, je vérifie mes fichiers, etc. Et la sauvegarde distante n'est là qu'en cas d'extrêmes accidents (cambriolage, feu, foudre, etc.) et je ne l'ai jamais encore vraiment utilisé (sauf pour tester de temps en temps que cela marche bien).
    Ne pas considérer ma sauvegarde locale comme une « vraie » sauvegarde c'est comme dire qu'un dépôt local n'est pas un vrai dépôt, et que seul le dépôt distant est valide, ce qui me semble à moi un hérésie.

    Alors il est vrai que pour certains une sauvegarde, c'est une sauvegarde qui est « sécurisée » (i.e dans un endroit sûr [3]) et sauvegarder sur sa propre machine n'est pas considérée comme étant « sécurisé ». Pourtant je trouve que la distinction est vraiment artificielle car si on considère qu'un NAS externe est une « vraie » sauvegarde, cette solution partage beaucoup d'accidents potentiels avec ma « mauvaise » sauvegarde locale (cambriolage, feu, foudre, etc.).

    Là où je doute un peu de mon système, c'est que comme j'utilise des snapshots pour faire mes sauvegardes locales, en pratique il n'y a qu'une copie physique de chaque donnée (deux copies en fait car mon disque est en RAID1 pour éviter les corruptions de données ou bit rot). Je fais donc confiance à fond au Copy-on-Write (CoW) pour ne pas détruire ma sauvegarde au cas où je fais une bêtise avec la donnée d'origine. Là aussi on me traite d'hérétique de faire confiance au CoW et qu'il faut absolument une copie/duplication physique pour « sécuriser » la donnée de manière sûre (la copie qui est dû au RAID1 ne compte apparemment pas).

    LA question

    Donc sans tomber dans la paranoïa (la valeur de mes données est surtout sentimentale), que pensez-vous de cette approche (snapshot) pour sauvegarder ? Pour moi j'avais fondé mon approche sur de la gestion de version distribuée mais j'ai peut-être tout faux…

    [1] avec un « responsable de l'architecture informatique d'un grand groupe multinational avec un chiffre d'affaire de plusieurs milliards », ses propres mots, oui je sais c'est un argument d'autorité.
    [2] Btrfs snapshot et send/receive
    [3] https://stackoverflow.com/questions/549600/is-there-a-fundamental-difference-between-backups-and-version-control/549621#549621

    Lire les commentaires

  • A.M. Turing Award 2015 - Cryptographie (Dépêches LinuxFR)

    Diffie et Hellman ont été récompensés par l'ACM (Association for Computing Machinery) de l'A.M. Turing Award 2015 pour leurs contributions à la cryptographie moderne.

    ACM

    Sommaire

    Whitfield Diffie, CSO (responsable sécurité) chez Sun Microsystems, et Martin E. Hellman, professeur émérite en ingénierie électrique à l’université de Stanford, pionniers de la cryptographie, ont obtenu cette distinction de l’ACM pour leurs travaux sur la cryptographie à clé publique et les signatures numériques.

    L'association

    L’ACM est une organisation à but non lucratif fondée en 1947. À l’origine, l'association avait décidé de prendre pour nom « Eastern Association for Computing Machinery » lors d’une réunion tenue en 1947 à l’université Columbia à New York. C’était la suite logique d’un intérêt croissant pour l’informatique, notamment pour ce qui avait trait aux machines de calculs, comme en témoigne cette notice établie lors de cette réunion :

    « The purpose of this organization would be to advance the science, development, construction, and application of the new machinery for computing, reasoning, and other handling of information. »

    « Le but de cette organisation est de faire avancer la science, l’innovation, la création, et l’application aux nouvelles machines de calculs, de raisonnement et de manipulation de l’information. »

    ou encore celle-ci :

    « The Association is an international scientific and educational organization dedicated to advancing the art, science, engineering, and application of information technology, serving both professional and public interests by fostering the open interchange of information and by promoting the highest professional and ethical standards. »

    « L’association est une organisation scientifique et éducative internationale, dédiée aux avancées concernant l’art, la science, l’ingénierie et l’application des technologies de l’information, servant aussi bien les intérêts du public que des professionnels, en favorisant l’ouverture aux échanges d’informations et la promotion des meilleurs standards éthiques et professionnels. »

    En janvier 1948, l’association supprimera le mot Eastern de son appellation et deviendra l’ACM.

    Sa structure est composée de personnes (estimation de 100 000 au niveau mondial), aussi bien de professionnels que d’étudiants, en provenance de tous les secteurs en lien avec les sciences informatiques et leurs applications. Pour différencier ses membres, elle reconnaît trois grades, ou distinctions selon leurs contributions :

    • Senior member (regroupe les professionnels qui ont 10 ans d’expérience et qui sont membres de l’ACM depuis 5 ans) ;
    • Distinguished Member (professionnels avec 15 ans d’expérience et membre depuis 5 ans) ;
    • Fellow (rang le plus prestigieux qui nécessite d’être membre depuis 5 ans, d’avoir contribué à des travaux dans les sciences informatiques, des technologies de l’information ou au sein de l’association, mais qui nécessite également d’être nommé par un membre professionnel).

    On peut remarquer que les étudiants n’ont pas droit à ces statuts, probablement du fait qu’ils n’ont pas encore contribué significativement en informatique. Toutefois, ils peuvent bénéficier autant que les professionnels d’avantages au sein de l’organisation, comme des opportunités d’emplois, un vaste réseau, des accès à des ressources (cours, livres, etc.).

    En plus de ces distinctions offertes aux professionnels, l’organisation en propose une autre qui s’accompagne cette fois-ci d’un crédit.

    L'A.M Turing

    Il s’agit de la plus prestigieuse distinction au sein de l’association. Elle a été nommée ainsi en mémoire des travaux d’Alan Turing, mathématicien britannique et pionnier dans le domaine de l’informatique, connu pour ses travaux sur Enigma durant la Seconde Guerre mondiale. La récompense s’accompagne de la remise d’une somme d’un million de dollars, financée par Google. Elle est décernée à une personne choisie pour sa contribution de grande valeur dans le domaine informatique.

    Pour l’année 2015, la récompense souligne l’importance des travaux de Diffie et Hellman, travaux qui permettent de faire communiquer deux parties de façon privée à travers un canal sécurisé, comme la connexion sécurisée en ligne vers les banques, les sites de commerce en ligne et autres serveurs d’email, ou encore le cloud. Les deux chercheurs ont introduit dans une publication datée de 1976 et intitulée « New Directions in Cryptography » l’idée de clés publiques et de signature numérique. Ces idées sont à la base de beaucoup de protocoles de sécurité actuels permettant de sécuriser les communications quotidiennes sur Internet.

    Récompenser la cryptographie

    C’est donc la cryptographie qui a été mise à l’honneur à l’occasion de la remise de cette récompense. Cette distinction de la cryptographie apporte un message intéressant dans le contexte actuel, après les révélations d’Edward Snowden sur la surveillance généralisée et au moment où les États occidentaux veulent limiter son accès aux citoyens.

    Selon les mots du président de l’ACM, Alexander L. Wolf : « En 1976, Diffie et Hellman ont pensé un futur où les gens communiqueraient régulièrement dans les réseaux et seraient vulnérables à des vols ou des altérations au sein de leurs communications. Maintenant, après près de 40 ans, nous constatons que leurs prévisions se sont avérées. »

    Des propos appuyés par un chercheur de Google, Andrei Broder : « La cryptographie à clés publiques est fondamentale au sein de nos industries ». Il poursuit en disant que « la capacité à protéger des données privées repose sur des protocoles qui confirment l’identité du propriétaire et ainsi assurent l’intégrité et la confidentialité des communications ». « Ces protocoles largement utilisés ont pu être concrétisés grâce aux idées de Diffie et Hellman », termine Andrei.

    Depuis longtemps, la cryptographie s’est imposée comme un moyen pour sécuriser les flux d’échanges entre parties. On est passé de chiffrement à base de charabia (calcul de clé générée par l’humain) à des chiffrements plus évolués, plus sûrs, plus rapides à faire, mais surtout plus difficiles à décrypter, grâce au calcul de clés générées par des machines. C’est par ailleurs après la Première Guerre mondiale que les machines à calculer ont commencé à se développer.

    Dans la notion de chiffrement, la clé est un élément d’information qui va permettre de traduire du texte lisible en texte chiffré et illisible (brouillé). C’est comme la création d’une serrure qui n’autorise qu’une clé spécifique pour la déverrouiller. Auparavant, lorsque deux individus cherchaient à établir une communication chiffrée, ils avaient besoin de clés identiques, c’est ce que l’on appelle la cryptographie symétrique. La gestion de ces clés limitait fortement la portée de ces communications. Mais ce système de chiffrement posait un problème au niveau de la sécurité : la clé unique peut être interceptée par une tierce partie, notamment au moment de l’échange, et lui permettre ainsi de déchiffrer le message sans que les deux parties le sachent ou même de chiffrer un message frauduleux sans que la partie récipiendaire puisse douter de l’origine du message.

    Dans la publication « New Directions in Cryptography », Diffie et Hellman ont présenté un algorithme qui montre que le chiffrement à clé publique ou à clés asymétriques est possible. Ils établissent la notion de couple clé publique/clé privée. La clé publique permet le chiffrement du message. Elle est non secrète et est échangeable librement. La clé privée est quant à elle secrète. Elle permet de déchiffrer le message chiffré avec la clé publique associée. Bien entendu, il ne doit pas être possible de déduire la clé privée de la clé publique associée, au risque de rendre la sécurité apportée nulle.

    Ce concept se décline en deux grandes utilisations :

    • le chiffrement de messages en utilisant la clé publique du destinataire. Seul le destinataire possédant la clé privée associée pourra déchiffrer le message ;
    • la signature numérique de message en utilisant sa propre clé privée. Le destinataire peut vérifier la signature en utilisant la clé publique de l’émetteur. Lui seul connaissant la clé privée aura pu émettre la signature.

    Pour finir sur ce Turing Award, on peut remarquer que cette distinction a mis en avant deux personnalités célèbres, en se basant sur une de leurs publications, et probablement sur d’autres critères (comme les précédentes récompenses reçues au sein de l’ACM). Pourtant, une autre personne a également été un pionnier de ce concept à la même époque. Il n’est pas difficile de trouver son nom associé à ces personnalités, pour des méthodes de cryptographie asymétriques : Ralph Merkle.

    Pour résumer, avant la publication de Diffie et Hellman, Merkle, encore étudiant, avait émis l'idée d'une cryptographie à base de clé publique. Cette idée reposait sur une méthode de génération de puzzle aléatoire pour construire un échange sécurisé en deux parties. Merkle ayant trouvé peu de soutien et d’écoute pour ses idées, c’est la publication de Diffie et Hellman qui fut considérée comme l’origine du concept de clé asymétrique. Cela n’a pas empêché Merkle de devenir un professeur distingué en informatique au Georgia Tech’s Information Security Center.

    Quelques liens

    Lire les commentaires

  • Obtenir un inventaire ansible depuis GLPI (Journaux LinuxFR)

    Bonjour

    Il y a peu j'ai découvert ansible, enfin devrais je dire, j'ai décidé de l'expérimenter dans ma vraie vie.
    La prise en main a été très rapide, ssh est déjà installé sur mes machines et il est simple d'alimenter son premier inventaire ansible. J'ai fait mon premier fichier /etc/ansible/hosts et j'ai pu faire mes premiers :
    ansible monserveur -m ping

    Ensuite j'ai découvert qu'on pouvait fournir dynamiquement le contenu de /etc/ansible/hosts car il faut reconnaître quand on a un peu de machines devoir le remplir manuellement ça fait ….

    Comme par hasard j'ai un inventaire exhaustif de mes machines grâce à GLPI. Ma première idée (oui oui c'est plein de première dans ce premier journal) a été de chercher sur le grand nain ternet s'il existait un script gérant l'export des hosts depuis GLPI, que nenni.

    En contre partie j'ai découvert une documentation et des exemples fournis par ansible :

    Ce qui est bien fait aussi c'est que du coté GLPI, se trouvent des webservices pour interagir avec :

    En fouillant un peu, en testant, etc, j'ai donc fait mon premier script d'inventaire ansible depuis GLPI :

    Pour le moment il est assez fruste, ce script génère :

    • un export de toutes les machines référencées dans l'inventaire GLPI via leur fqdn complet
    • les groupes et sous groupes de machines selon l'arborescence des entités

    J'espère que cela pourra intéresser un peu de monde et peut être avoir des premières contributions.

    Lire les commentaires

  • Une faille nommée « shellshock » (Dépêches LinuxFR)

    « ShellShock », une faille dans l'usage du shell Bash, est sous les projecteurs depuis quelques jours. Le terme est un jeu de mot entre la stupeur propre à l'obusite des combattants de la première guerre mondiale et l'interface système shell. Nous vous proposons des explications sur cet évènement particulier, son périmètre, les conditions de son exploitation, les surfaces d'attaques, et les solutions proposées, déjà mises en œuvre ou à venir. Enfin, une revue de presse sera dressée, cette faille s'étant transformée en évènement.

    Sommaire

    Contexte et histoire

    Bash est l'interpréteur par défaut du projet GNU, c'est une amélioration du Shell Bourne, reprenant des idées du Korn Shell (ksh). Il est développé depuis 1988 et n'a cessé de s'améliorer.

    Bash est le shell par défaut d'un grand nombre de distributions GNU/Linux, mais pas toutes. Par exemple Ubuntu ne lance pas Bash avec son /bin/sh, mais dash, Bash n'étant disponible que pour l'utilisateur en session interactive. Bash se retrouve également dans Apple Mac OS X et dans Microsoft Windows via Cygwin (SFU, Services for Unix, utilise csh ou ksh).

    Quelques explications

    Il s'agit d'exploiter un bash-isme, une spécificité du shell Bash, permettant d'exporter une fonction et non seulement une variable. Les autres shells (ksh, zsh, dash, …) ne sont pas concernés par cette faille. Par ailleurs, Bash ne permet pas cet export de fonctions s'il est utilisé avec l'option -p ).

    Il est tout à fait normal de vouloir passer des variables d'environnement à un processus enfant.

    Mais Bash permet en outre de passer des fonctions vers le processus enfant. Aucun autre shell ne permet cela. Dans ce cadre relativement strict, la sécurité ne pose pas de problème : les droits et contextes d'exécution sont identiques et l'utilisateur, système ou non, est le même. Ceci est documenté, il s'agit de l'option -f de la commande export dans le shell Bash. « It is not a bug, it is a feature », le vieil adage prend ici tout son sens. Nous laissons le lecteur seul juge du bien-fondé de ce bashisme.

    Alors s'il n'y a pas de problème, où est le problème ? Le problème se situe dans l'usage de Bash par les autres programmes. Bash est devenu le shell par défaut de certaines distributions, et de nombreux programmes utilisent le shell par défaut pour passer des variables d'environnement entre leurs processus. Le contexte change donc : ce n'est plus un utilisateur local et de confiance qui utilise cela, mais une multitude de programmes, parfois distants.

    Ces programmes ne valident pas eux mêmes les données qu'ils donnent à Bash, et ne font souvent que passe-plat. Dans ce contexte, ce qui était auparavant une fonctionnalité se transforme alors en faille. Ceci explique l'ancienneté du problème.

    Explications techniques

    Une fonction dans le shell bash

    #!/bin/bash
# déclaration de la fonction d'affichage du message "bonjour vous", nommée mafonction :
mafonction() {
echo "bonjour vous";
}
# exécution de la fonction :
mafonction

    La même chose, pour passer la fonction à un sous-shell

    env mafonction='() { echo "bonjour vous"; }' bash -c 'mafonction;'

    On prefixe avec la commande env pour faire tourner un programme dans un environnement modifié. Et à la fin on fait exécuter la fonction par un autre bash. OK ?

    La même chose, en détournant l'usage

    env mafonction='() { echo "bonjour vous"; }; echo "voici shellshock"' bash -c "mafonction;"

    Ici, l'exécution de la fonction mafonction ne se limite pas à un écho "bonjour vous", mais exécute aussi le code echo "voici shellshock" On notera la place du délimiteur '
    OK ?

    Et en fait il n'est même pas nécessaire d'exécuter la fonction définie :

    env mafonction='() { echo "bonjour vous"; }; echo "voici shellshock"' bash -c "true"
voici shellshock

    Donc, le simple () { :;} suffit à résumer la situation.
    OK !

    Surfaces d'attaques et exploitabilité

    Les conditions de l'exploitation à distance de la faille sont relativement simples :

    • /bin/sh pointe sur /bin/bash ;
    • avoir SELinux désactivé ou non configuré ;
    • avoir un service qui écoute le réseau et qui va exécuter bash.

    L'exploitation de cette faille est très simple, et de nombreux preuves de concepts et exploits circulent actuellement sur Internet. Voici une liste non-exhaustive des logiciels qui peuvent être utilisés en passe-plat :

    • dhclient ;
    • apache, via mod_cgi (et sans mod_security correctement configuré) ;
    • exim ; postfix ; qmail ; procmail ;
    • OpenVPN ;
    • stunnel ;
    • probablement de très nombreux logiciels privateurs …
    • SIP, FTP, probablement d'autres …

    Preuves de Concept
    Un projet hébergé sur github rassemble une série de POC à cette adresse

    À noter que SELinux ne va pas bloquer un usage de « shellshock », il va cependant en réduire fortement les possibilités d'exploitation. Par exemple le contexte httpd_sys_script_t est attribué à tout CGI, contexte qui ne permet l'écriture que dans … /tmp! Le lecteur trouvera des explications complètes sur le blog de Dan Walsh à ce sujet.

    Ne sont donc pas concernées : toutes les distributions ayant un autre shell que Bash. Toutes les distributions ayant SELinux activé bénéficient d'une protection contre des exploitations de ce type. Mais également : tous les matériels embarqués et objets connectés, contrairement à ce que des articles de presse affirment, car ces matériels utilisent la plupart du temps busybox et son implémentation inline de Bash n'est pas vulnérable. Ne sont pas concernés non plus les téléphones portables (pas plus les Android que les iPhones). Les "box" internet ne le sont pas davantage, ni les télévisions, ni les lecteurs de salon, les autoradios, ni les avions, drones, missiles, sous-marins… Bref, nous avons eu le plaisir de lire un peu n'importe quoi sur le sujet et la revue de presse contient quelques jolies perles.

    NdM : le fabriquant de NAS QNAP vient d'alerter ses utilisateurs (cf article Next INpact)

    Chronologie des évènements

    • Stéphane Chazelas rapporte le problème à Redhat (bug déclaré le 14 septembre) ;
    • Le CVE-2014-6271 lui est attribué ;
    • Le 24 septembre, ce CVE est rendu public et un premier correctif est mis à disposition ;
    • Le jour même la communauté pointe l'insuffisance de ce correctif ;
    • Le CVE-2014-7169 est alors ouvert et attribué à Tavis Ormandy ;
    • Le 27 septembre le second correctif est publié

    Solutions mises en œuvre

    Correctifs disponibles et annonces des distributions

    La faille, CVE-2014-6271

    • Le test :
      env 'x=() { :;}; echo vulnerable' 'BASH_FUNC_x()=() { :;}; echo vulnerable' bash -c "echo test" Ne doit pas retourner le terme "vulnérable", quelque soit le formattage retour.

    • Les annonces :

    Le second problème, CVE-2014-7169

    • Le test :
      cd /tmp; rm -f echo; env 'x=() { (a)=>\' bash -c "echo date"; cat echo doit retourner que le fichier "/tmp/echo" n'existe pas.

    • Les annonces :

    Les CVE-2014-6277, CVE-2014-7186 et CVE-2014-7187 ne sont pas publics à ce jour (infos chez Redhat 0, 1 et 2).
    • D'autres correctifs sont à venir.
    mod_security, le filtrage

    Mod_security est un pare-feu applicatif pour le serveur Apache. Il peut être configuré pour filtrer certains caractères et expressions régulières. C'est donc un moyen efficace pour se prémunir contre le principal vecteur d'attaque : les scripts CGI. Si vous utilisez Redhat, vous pouvez l'installer ou le mettre à jour : il contient les règles tout prêtes pour filtrer « shellshock ». Ces règles sont de types : SecRule REQUEST_HEADERS "^\(\) {" & request_line.

    Le cas FreeBSD

    Le projet FreeBSD a décidé de désactiver la possibilité d'importation de fonction de Bash. Le système FreeBSD n'utilise pas Bash comme shell par défaut, mais tcsh, Bash n'étant même pas inclus dans une installation de base. Mais pour prémunir de tout problème lié à un changement de shell par défaut, le projet a décidé de supprimer la fonctionnalité incriminée, avec ce message laconique : « cela retire le risque de nouveaux problèmes conduisant à l’exécution de code, et le risque pour les scripts suid, aussi pour les applications mal écrites qui ne nettoient pas leurs environnements » Radical.

    Revue de presse

    Après les annonces sécurité et la réaction des projets (Bash, FSF - traduite en français par l'April), la presse spécialisée puis la presse généraliste ont multiplié les articles : pire que la faille Heartbleed ? (Slate.fr, LMI, Silicon.fr, L'Express, 20minutes, HuffingtonPost, New Zealand Herald), « panique » (Courrier International), « mégafaille » (01Net), « horrible » (ZdNet), « premières attaques » (01net), « plus grande menace de l'histoire du web » (ParisMatch, si si), « 500 millions de serveurs web vulnérables » (La Tribune, Washington Post), « Google et Amazon ont patchés » - super on est sauvés alors - (WallStreetJournal), d'autres failles Bash à prévoir (ArsTechnica), « ver fou ShellShock » (Wired ou le blog de R. Graham), « internet bâti sur de la glace fine » (Financial Times), etc.

    Conclusion

    D'une rencontre entre une fonctionnalité et des usages nait une faille qui fait grand bruit. Bruit généré par l'importance du problème, certes, mais également par le manque de discernement et le FUD autour. Ce qui met en valeur la place qu'ont pris les Logiciels Libres dans nos vies quotidiennes, sans que cela se voie. Il aura fallu moins de 4 jours entre la publication du problème (à ne pas confondre avec le signalement initial aux équipes sécurité) et sa résolution. Peu d'éditeurs peuvent se targuer d'être aussi rapides sur la résolution d'un problème de ce type et sur la transparence pour l'accès à l'information.

    Dans le même temps, l'inquiétude de savoir que cette possibilité existe depuis de nombreuses années est légitime. Et elle renforce la nécessité de participation. Combien d'éditeurs de solutions s'appuient sur des briques libres sans jamais rien verser aux projets ?

    Mettez et maintenez vos systèmes à jour! Et ne pensez pas qu'un programme qui n'a pas connu beaucoup de failles est forcément très sûr, peut-être que personne ne l'avait vraiment regardé jusque là.

    Lire les commentaires

  • Recherche d'un laptop compatible linux tout terrain (haut de gamme) (Journaux LinuxFR)

    Bonjour nal,

    Heureux possesseur d'un Lenovo X201 depuis presque 8 ans, je vais malheureusement devoir m'en séparer car il commence à montrer des signes de fatigues:
    - ventilateur qui vibre (j'ai du le changer il n'y a pas longtemps, le dernier ayant rendu l'âme)
    - disque dur (500 Go) qui toussote (oui docteur, mon disque dur fait un peu de bruit… rien de grave hein, mais bon)
    - coque qui montre bien que les années ont passées (et que le petit dernier adoooore tester la résistance des joujous de papa)
    En plus côté configuration, on date aussi un peu:
    un des tout premier i7
    8 Go de Ram (je suis au taquet)
    un écran qui fait 'seulement' du 1280 * 800

    Bref, mon anniversaire (40 piges) approchant (fin mars), il est temps de tourner la page de ces bon moments passés avec mon X201.

    Pré requis de l'élu de mon cœur:
    * <2000 €. oui c est une grosse somme, mais j'ai déjà vu des laptops plus chers. Je l'avais même dépassé pour le X201. La qualité ça se paie (pour ce qui est du hardware). Si mon Graal est à +5% je peux encore faire un effort…

    • Doit tourner sous linux (bah oui, sinon j'aurai demandé de l'aide sur le forum du wingeekpourlesnuls). Actuellement j'évolue sous kubuntu, mais mon grand amour c est debian. Idéallement sans dual boot.

    • Coté taille (oui ça compte), bien qu'utilisant majoritairement mon PC sur mes genoux et sur le coin du canapé, je ne suis pas totalement fermé coté taille. Actuellement je suis sur un format 12", mais j'aimerai bien un peu plus grand (15" ?), voir beaucoup plus ( 17" ? ).

    • Côté puissance, je vise i7 / 16 Go (avec possibilité de passer à + de Ram idéalement).
      Avec ça je devrais pouvoir couvrir tout mes besoins niveau puissance (KDE effets kisskool activés (même si au final je ne les active que quand j'ai quelqu'un d'autre qui regarde mon écran), une 50aine d'onglets sous firefox / arduino & eclipse en arrière plan (dev level newbi) / compilation de plein de petit prog (merci à la communauté) juste-comme-ca-pour-voir / Un peu de jeu (surtout de l'émulation / Vive l'arcade).

    • Côté espace de stockage, idéalement SSD 128 Go (min) + Sata 1TO, mais je pourrais vivre avec uniquement un SSD 512 Go.

    • Pour ce qui est de la partie graphisme, j'aimerai bien un écran 4k (vous avez des retours sur l'utilisation d'un laptop à cette résolution sous linux / KDE ? ) et une carte Nvidia 970M au minimum (au cas où, est que la techno Optimus (switch carte graphique NVidia / carte graphique intégrée) est maintenant bien gérée sous linux ? ). J'ai rien contre le tactile s'il est bien géré sous linux.

    • Les options en plus qui seraient bien: lecteur de carte, ne chauffe pas (trop), écran mat, lecteur d'empreinte (c'est plus sympa pour allumer le laptop que de devoir taper son mot de passe bios).

    Bon, si vous m'avez lu jusqu'ici je vous remercie. Si vous avez une réponse à m'apporter (réflexion sur ce que je veux, retour sur un laptop que vous avez vous même récemment acheté et qui pourrait me convenir, ou juste un lien vers un laptop qui pourrait me convenir), un second merci à vous.

    En espérant que les réponses qui seront apportées ici serviront aussi à d'autres.

    Lire les commentaires

  • Gestionnaires de mot de passe (Dépêches LinuxFR)

    La tâche première d'un gestionnaire de mot de passe est de garder en sécurité des informations sensibles (mot de passe, identifiant, URL…), et de pouvoir les restituer de façon commode.

    Certains gestionnaires permettent de générer des mots de passe à la demande : l'utilisateur n'a alors même plus besoin de voir ou de connaître le mot de passe, hormis le mot de passe maître (qui donne accès à tous les autres), et peut multiplier l'opération pour créer autant de mots de passe qu'il le souhaite. Sans avoir la prétention de résoudre toutes les questions relatives à la sécurité et à l'usage de mots de passe, cette pratique pourrait contribuer à augmenter leur sûreté d'un cran en dissuadant les usagers de réutiliser le même mot de passe pour des comptes différents, réduisant ainsi l'impact de leur compromission sur les serveurs (qui est un problème concret, comme peut l'illustrer le site Have I Been Pwned).

    Il existe pléthore de gestionnaires, qui se distinguent par plusieurs critères :

    • logiciel libre ou propriétaire ;
    • sécurité (audits réalisés, utilisation d'algorithmes de chiffrement sérieux et non dépassés…) ;
    • synchronisation possible ou non entre plusieurs emplacement ou appareils ;
    • facilité d’utilisation (intégration avec les navigateurs) ;
    • disponibilité sur différents OS ;
    • format de stockage (portabilité) ;
    • type d'utilisation (personnel, groupe).

    Nous n'en présentons ici qu'une sélection. Notre choix s'est d'abord porté sur des logiciels libres et supportés par une communauté active ; de même il est important qu'ils soient disponibles sur un maximum de plate-formes avec au moins une possibilité de synchronisation (git, webdav, dropbox…) pour pouvoir fonctionner au sein d'une famille ou d'un groupe. Le choix est forcément arbitraire et dépend aussi de la disponibilité et des bonnes volontés des rédacteurs.

    Sommaire

    Keepass

    Ce système de gestion de mot de passe par le biais d'une base de données possède plusieurs interfaces graphiques très agréables et modernes, il y a de multiples options de configuration, et il est à la portée d'un utilisateur lambda sans grande connaissance de l'informatique.
    Son format (kdbx) est très largement utilisé sur la plupart des plates-formes. Tous les mots de passe ainsi que les autres informations (identifiants, URL, notes) se trouvent dans une base de données chiffrée ; ainsi il n'y a qu'un seul fichier à gérer.
    Il est soutenu par une importante et vivante communauté qui écrit de nombreux plugins.
    Il est publié sous licence GPL v2+.

    Clients graphiques

    Il existe de nombreuses applications utilisant le format .kdbx, elles ont des interfaces plus ou moins évoluées, certaines permettent la synchronisation, d'autres non, le nombre d'options dans la configuration diffère (j'ai mis en lien celles qui me paraissaient les plus importantes).
    On peut même s'en servir sous forme de webapp, il vous suffit donc d'un navigateur et d'une clef usb contenant votre base de données et vous pouvez utiliser vos mots de passe à l'aide de Keeweb.

    Sécurité

    Keepass va être audité prochainement par le biais d'une entreprise pour améliorer sa sécurité grâce à un financement de la commission européenne.
    Il est même recommandé par l'État français et l'ANSSI.

    • Fichier maître ;
    • Mot de passe ;
    • OTP ;
    • Empreinte digitale ;
    • Partage.

    Synchronisation

    Il est possible de l'utiliser en local ou si vous utilisez plusieurs appareils, même sur différents systèmes, de synchroniser votre base de données par divers protocoles ou services que ce soit en auto-hébergement ou par le biais de services propriétaires.

    • Dropbox ;
    • Onedrive ;
    • Google drive ;
    • Owncloud/Nextcloud ;
    • ssh file transfert sftp ;
    • ftp ;
    • http/https.

    Importation / Exportation

    On peut exporter et importer plusieurs types de format, cela vous permettra ainsi de rapatrier vos données depuis d'autres gestionnaires de mot de passe pour les convertir en .kdbx, ainsi que d'utiliser vos données dans d'autres gestionnaires.

    • Types de fichier importés : csv, xml, kdbx et kdb;
      Ceci permet de récupérer ses mots de passe sur des services tiers (1Password, Lastpass, Enpass …).
    • Types de fichier exportés : html,csv, xml, kdbx et kdb ; Ainsi il est possible de changer pour Password-store ou d'autre gestionnaires (propriétaires ou pas).

    Fonctionnalités

    • Autofill : auto-complétion, intégration au navigateur grâce à cette extension KeePassHttp-Connector pour Chrome et Firefox ;
    • Firefox : Kee, Passifox, Keepass XC, KeePass Tusk, KeePassHelper Password Manager ;
    • Chrome : Passifox, Chromeipass ;
    • Safari : Passafari;
    • Générateur de mot de passe ;
      • Nombre de caractères, types de caractères (nombres spéciaux, chiffres, majuscules, minuscules …) ;
      • Répétition ou non des caractères ;
      • Inclure des caractères personnalisés ;
      • Suivant un algorithme ;
      • Prévisualisation ;
    • Expiration du mot de passe ;
    • Gestion presse-papier ;
    • Durée de disponibilité.

    Password-store

    Password Store ou pass, est un gestionnaire de mots de passe minimaliste d'abord conçu pour être utilisable en ligne de commande, mais sur lequel peuvent se greffer d'autres interfaces. Il permet de stocker les mots de passe, ou bien des textes arbitrairement formés, dans des fichiers textes chiffrés avec GPG. Il est publié sous licence GPL v2+.

    L'outil est plutôt agnostique de son environnement, c’est-à-dire que vous devrez vous-mêmes réaliser l'intégration pour qu'il corresponde à vos usages.

    La première étape consiste donc à décider sous quelle forme les mots de passe seront stockés. Un besoin courant étant de stocker les mots de passe de sites web, il est suggéré de créer un fichier pour chaque site, contenant le mot de passe suivi du login dans une seconde ligne, ce qui donnerait par exemple, pour un fichier nommé web/linuxfr.org :

    SuPeR_mOt_De_PaSsE
login: jean-yvonne

    Il semble en effet judicieux de structurer un minimum le fichier, comme ici avec YAML. Cette convention simple (1ʳᵉ ligne = mot de passe, 2ᵈᵉ ligne = login) est déjà utilisée par d'autres outils écrits par la communauté, comme les extensions navigateur et certains scripts.

    Pass propose de se greffer sur un dépôt Git pour accroître ses fonctionnalités. Chaque opération réalisée sur les mots de passe entraînera un commit. Outre le versionnage, cela peut permettre de synchroniser plus facilement ses mots de passe entre différents postes.

    Pass est donc un bon candidat pour s'imbriquer à d'autres outils, cependant les navigateurs sont rarement pensés pour être modulaires (à quelques exceptions près comme uzbl), ce qui fait que l'intégration sera difficilement parfaite.

    En cadeau pour les administrateurs utilisant ansible, celui-ci intègre un plugin de type Lookups qui vous permettra de chiffrer des fichiers de variables via votre instance pass, tenant un rôle similaire à Ansible Vault.

    Clients graphiques

    Des interfaces sont disponibles pour de nombreux systèmes et sont déjà utilisables tout en étant en développement actif.

    Sécurité

    L'intégration d'Openkeychain dans la version Android permet d'importer sa clé PGP très facilement, il en est de même sur votre ordinateur, il est aussi possible d'importer ou de générer une clef SSH.

    • PGP ;
    • SSH ;
    • Mot de passe.

    Synchronisation

    Il vous faudra connaître les rudiments de git si vous voulez l'utiliser sur plusieurs appareils avec une synchronisation, il existe pour cela plusieurs tutoriels. Sinon l'usage de git n'est pas obligatoire et vous pouvez utiliser pass sans nécessairement y associer un dépôt.

    • Git.

    Importation / Exportation

    De nombreux scripts ont été écrits par la très active communauté pour faciliter la migration vers Password-store. Que ce soit en provenance d'outils propriétaires ou libres.

    Voir l'outil pass-import

    • 1password ;
    • keepass ;
    • lastpass ;
    • firefox ;
    • kwallet ;
    • etc.

    Fonctionnalités

    • Autofill : auto-complétion, intégration au navigateur ;
    • Firefox : passff, browserpass ;
    • Chrome : browserpass;
    • Générateur de mot de passe ;
      • Répétition ou non des caractères ;
      • Inclure des caractères personnalisés ;
      • Suivant un algorithme ;
      • Prévisualisation ;
    • Expiration du mot de passe ;
    • Gestion presse-papier ;
    • Effacement automatique ;
    • Suppression de l'historique ;
    • Durée de disponibilité.

    Universal Password Manager (UPM)

    UPM est un gestionnaire de mots de passe écrit en Java, multi-plateformes et protégé par un mot de passe maître. Chaque entrée comporte plusieurs champs : compte, identifiant, mot de passe, URL et notes. Il est publié sous licence GPL v2+.

    Client graphique

    Le seul client compatible est le client UPM disponible sur Linux, Windows, Mac OS et Android (pas de version iOs à ce jour).

    Sécurité

    Les fichiers de mots de passe sont chiffrés par l'algorithme AES.

    Synchronisation

    Avec UPM il est possible de synchroniser le fichier de mot de passe via un serveur Web (par http) ou bien, plus récemment, par Dropbox.

    Importation / Exportation

    Il est possible d'exporter/importer la base de données en fichiers CSV… qui ne sont plus chiffrés (du coup).

    Fonctionnalités

    Les versions desktop (seulement testé Linux) et Android ne sont pas complètement identiques… mais on retrouve les mêmes fonctionnalités :

    • recherche sur le champ compte ;
    • copier/coller de l'identifiant et du mot de passe par boutons (ou clic droit) ;
    • lancement de l'URL ;
    • génération d'un mot de passe aléatoire ;
    • multi-langues.

    Limitations

    • UPM ne gère pas de hiérarchie sur les entrées : on ne peut pas saisir une sous-entrée d'une entrée existante.
    • Pour pouvoir effectuer une modification d'une entrée, il faut d'abord effectuer une synchronisation, si le fichier est synchronisé (cela peut être un problème avec la version Android si on n'a pas de connexion réseau).
    • Pas de listes de fichiers récents de mots de passe, il faut aller chercher le fichier, à chaque fois qu'on change de fichier.
    • Il y avait des bugs de synchronisation (perte de la dernière version) qui semblent résolus.

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Animation 2D vectorielle : sortie de Synfig Studio 1.0 (Dépêches LinuxFR)

    Du nouveau dans le graphisme libre, la version stable 1.0 de Synfig, incluant une quantité énorme de modifications, vient de sortir.

    Vous pouvez la télécharger depuis le site officiel, afin de l'installer sur les trois types de systèmes d'exploitation principaux ou la fabriquer vous-même à partir du code source.

    Petit rappel, Synfig est un logiciel d'animation d'image vectorielle 2D dont le développement a été grandement accéléré par des campagnes successives de financement participatif.

    Synfig Studio

    Sommaire

    L’interface à fenêtre unique

    Un peu comme pour Gimp, Synfig a eu son lot de critiques concernant le choix d'une interface multi-fenêtres, pas complètement encastrables. La fenêtre unique met un terme aux ALT-TAB qui étaient nécessaires pour faire apparaître les différents panneaux de l'interface. Maintenant, quasiment toutes les fenêtres sont des panneaux (il reste quand même quelques boîtes de dialogue, comme la sélection de couleur, préférences…) et tous les panneaux sont encastrables.

    Un widget a été créé pour l'occasion, situé dans le coin haut droit de chaque panneau, c'est une sorte de boussole de l'interface utilisateur. Il permet d'ancrer et disposer un panneau à côté ou à l'intérieur d'un autre.

    Fenêtre unique

    Des agencements prédéfinis de panneaux, mode Composition ou Animation, ont été ajoutés, permettant de modifier la disposition générale de l'interface d'un clic. Dorénavant, le panneau « Boîte à outils » ne contient que des outils, les fonctions anciennement présentes (enregistrer / ouvrir…) ont été déplacées dans une barre d'outils, située en dessous de la barre des menus (barres, qui optionnellement peuvent être masquées). De nombreux autres aspects de l'interface ont subi des coups de fignolage, comme le panneau « Options des outils » qui maintenant arbore de jolies icônes au lieu de cases à cocher - et l'activation des options y est contextuelle - ou encore l'amélioration générale des boites de dialogues dont les choix OK/Cancel ont été bannis au profit d'un verbiage plus situationnel.

    Outil Papier découpé (Cut-Out)

    Evgenij Katunov a développé un outil un peu spécial, il aide à la création d'animation papier découpé. Vous pouvez voir une vidéo de démonstration de cet outil simple mais efficace. Ce nouvel outil a été ajouté dans SynfigStudio entre la V1-RC1 et la V1-RC2 ce qui est un peu inhabituel mais c'était trop tentant ;-)

    New feature : Cut out tool

    Mouvements basé sur la dynamique

    Une des particularités de Synfig est de permettre la conversion puis la liaison des paramètres des calques. Ainsi, par un habile usage de cette fonctionnalité, il est possible d'automatiser la couleur d'une forme suivant sa position dans la scène, de faire pointer une flèche dans la direction de son déplacement (tuto - vidéo) ou même de faire de la pseudo 3D !

    Avec le nouveau type de conversion Dynamique (Dynamic), il est maintenant possible de simuler la vie réelle avec un Système masse-ressort qui permet de contrôler la masse, l'inertie, la friction et d'autres paramètres de la liaison. Une courte vidéo rose et souriante pour expliquer cela en images mouvantes.

    Animation image par image matricielles

    Avec l'apport d'un calque Groupe sélecteur et la possibilité de modifier directement dans Synfig les images matricielles, il est maintenant possible de réaliser des animations image par image matricielles.

    Calque Groupe sélecteur

    Le calque de Groupe sélecteur permet de définir le moment et la quantité de visibilité des sous-calques qui y sont inclus. Grâce au paramètre "Nom du calque actif" ("Active Layer Name") on détermine quel est le calque du groupe visible à l'avant-plan. De plus, il devrait être possible de réaliser des fondus enchaînés de calques en augmentant l'ouverture de la visibilité (Range-visibility)

    Group Switch Layer

    Modification des images matricielles

    Prise en charge de la bibliothèque de brosses MyPaint.

    Animation par ossatures

    Calques vectoriels

    L'ossature de calques vectoriels était déjà présente dans la précédente version stable (0.64.1 sortie en novembre 2013) de Synfig, mais en mode expérimental uniquement. Depuis, elle a été totalement ré-écrite pour devenir aussi simple que puissante. Plus besoin d'avoir un mode construction et de définition de l'ossature comme précédemment.

    Avec la v1.0, la création puis la liaison d'une ossature à des calques est plus intuitive ; en outre, avec la gestion de l'influence de l'ossature, l'interaction croisée de plusieurs parties de l'ossature sur une surface unique, le re-positionnement manuel d'un sommet sous ossature, ainsi que la gestion de la profondeur d'un os, l'animateur a une grande liberté de peaufinement du rendu de mouvement.

    Bones animation Part 7

    Images matricielles

    Le style d'animation Papier découpé (Cut-Out) utilisé, par exemple, dans les Simpsons, était déjà possible. Il suffisait de découper son personnage en plusieurs morceaux, de les organiser par groupe, puis d'y insérer des calques rotations pour obtenir un personnage à animer.

    Avec le calque Déformation par ossature (Skeleton Deformation Layer) et l'outil Cut-Out, il est maintenant encore plus simple de courber, tordre, voire torturer une image matricielle sans avoir besoin de la pré-découper.

    Bone-driven Image Distortion

    Outil de transformation

    Un outil de transformation des groupes (groupe et groupe sélecteur) a fait son apparition. Il permet d'avoir le contrôle sur le positionnement, l'échelle, la rotation ainsi que le cisaillement d'un calque groupe et donc de tout ce qu'il contient.

    Group transformation tool

    Format de fichier SFG

    Englobant

    Plus besoin de faire à la main un dossier contenant le projet et autres médias (images / sons…), tout ceci peut être géré directement par le nouveau format de fichier SFG et depuis le panneau des calques : en choisissant quels calques images doivent être incorporés au projet. Il est par ailleurs possible d'extraire une image contenue dans un projet, afin de la récupérer en tant que fichier sur le disque.

    Historique

    Lors de l'ouverture d'un fichier de projet, on peut accéder à l'historique des révisions, la boîte « Ouvrir un fichier » proposant un bouton d'accès aux différentes révisions réalisées.

    Gestion du son

    Synchronisation Jack

    Elle ne fonctionne que si la présence d'un serveur Jack a été détectée, étonnant non ? Cet apport fait rentrer Synfig dans la boucle des nombreuses applications connectables à Jack, parmi lesquelles je citerais Ardour, Gnusound, Audacity, Hydrogen, Renoise, Qtractor, Blender, VLC… Ce serveur son permet d'interconnecter les entrées / sorties (un méga pipe sonore pour simplifier) des différents logiciels et de synchroniser les différentes TimeLines (l'Axe Temporel dans Synfig). Une sorte de chaîne MIDI inter-logiciels qui permet de caler, dans ce cas, images et sons (et autres) au poil de zébu près.

    Une vidéo Synfig vs Ardour qui présente la toute première intégration de Jack dans Synfig en Mai 2014.

    Calque Son

    Cette fonctionnalité est basée sur MLT.

    Améliorations mineures et autres corrections de bug

    Bien entendu, cette nouvelle version signée V1… contient de nombreuses améliorations mineures, et autres rectification de dysfonctionnements. Voir les liens vers les différentes RC en attendant une note de publication.

    Ce qui est dans la file d'attente pour le futur

    Étant donné que le moteur de rendu basé sur Cairo ne donne pas une totale satisfaction dans l'état actuel, et que le projet n'a plus les moyens humains de le maintenir (un des principaux contributeurs du projet 'Genete' n'a malheureusement plus le temps de bidouiller le code pendant des heures), un nouveau moteur de rendu est en train d'être fabriqué, il sera basé sur OpenGL.

    Lire les commentaires