gouttegd a écrit 1805 commentaires

Il y a une prise en charge d’EteSync depuis mars 2017, selon cette demande d’intégration Git.

La prise en charge d’EteSync par vdirsyncer a été retirée de la branche principale de vdirsyncer un an plus tard. :(

La dernière version publiée (0.16.8) offre toujours cette prise en charge, mais ce ne sera pas le cas de la future 0.17. Il faudra passer par le pont etesync-dav mentionné pour continuer à utiliser EteSync avec vdirsyncer.

(J’avais vu passer la dépêche dans l’espace de rédaction mais n’avais pas trouvé le temps de corriger le paragraphe sur OpenPGP. Du coup, je fais part de mes commentaires chipotages ici.)

GPG est un ancien système de chiffrement de courriel.

• Le « système », c’est OpenPGP. GPG (GnuPG) est une de ses implémentations¹ — largement la plus répandue et celle qui fait office de référence, certes, mais quand même une implémentation parmi d’autres.
• Si OpenPGP est « ancien », alors HTTPS l’est tout autant. Les deux protocoles ont quasiment le même âge (environ 25 ans, ils sont nés vers le milieu des années 1990).
• OpenPGP est surtout un système de vérification d’intégrité de paquetages logiciels, occasionnellement utilisé pour chiffrer des courriels. :D

Lors des fameuses « key signing parties », les personnes donnaient une carte de visite avec l’empreinte de leur clef publique et montraient une pièce d’identité pour prouver qu’ils étaient bien les personnes qu’ils affirmaient être.

C’est un mode de fonctionnement possible, c’est loin d’être le seul.

Le nombre de signatures sur la clef publique distribuée par les serveurs de clefs était la garantie de leur authenticité.

Le nombre de signatures portées par une clef publique n’a jamais été une garantie de l’authenticité de la clef. Dans le modèle de la toile de confiance, Alice considère que la clef de Bob est authentique parce qu’elle porte quelques signatures émises par des personnes en lesquelles Alice a confiance, pas parce qu’elle porte un grand nombre de signatures émises par des personnes dont Alice n’a probablement jamais entendu parler.

Le système était alourdi par la distribution de la liste des clefs révoquées, qui devenait toujours plus grande.

J’ai l’impression que ce passage fait davantage référence aux Certificate Revocation Lists (CRL) du monde X.509, dont l’usage a effectivement été abandonné (pour HTTPS du moins — les navigateurs web ne vérifient plus les CRL). Il n’y a pas de « liste des clefs révoquées » dans le monde OpenPGP. Quand une clef est révoquée, le certificat de révocation est attachée à la clef elle-même et distribué en même temps que la clef (typiquement via les serveurs de clefs).

24 h ? Chez moi c’est au bout de même pas 24 minutes… ><

C’était une partition (un volume LVM plus exactement) dédiée aux données mais pas spécialement dédiée à YaCy. Ça représentait le plus gros de mon disque dur, l’espace n’y manquait pas et les inodes non plus…

Merci. Pas sûr d’avoir envie de ré-essayer de sitôt du coup… :(

Je dis ça et je dis rien, mais le projet trouverait peut-être plus facilement des volontaires prêts à contribuer à la DHT s’il offrait un certain contrôle sur l’utilisation des ressources…

Ça m’aurait convenu aussi. Ce qui m’importait était de pouvoir maîtriser l’espace disque consommé, quelle que soit la méthode (« tu fais comme tu veux, mais tu n’utilises jamais plus de 10 Go »).

J’avais essayé YaCy il y a maintenant plusieurs années (2011 ou 2012… je crois ?).

Les deux problèmes qui m’avaient fait abandonner l’expérience à l’époque :

• Le logiciel n’offrait aucune option pour contrôler la croissance de l’index. En gros ce que je voulais, c’était pouvoir dire « je contribue à l’index distribué, mais seulement à hauteur de (par exemple) 10 Go — lorsque ma part de l’index atteint cette limite, je veux que mon instance arrête de crawler et se contente de servir ce qu’elle a déjà indexé ». Ça ne semblait pas être possible à l’époque, je ne sais pas si ça a changé.
• Dès que l’index atteignait une certaine taille (environ 20 Go si je me souviens bien), il n’était simplement plus possible de redémarrer le serveur. Toute tentative de charger l’index depuis le disque échouait systématiquement. La seule solution était de purger l’index manu militari (rm -rf …) et de repartir de zéro.

Un de ces jours il faudrait que je ré-essaye.

cependant nous espèrons qu'à l'avenir nous pourrons avoir le temps d'implémenter les fonctionnalités PGP sur l'appareil (ou peut être un futur contributeur?)

Je ne sais pas quel microcontrôleur vous utilisez (je n’ai trouvé cette information nulle part sur votre site, et je ne sais pas interpréter les fichiers disponibles dans le dépôt minible_hw), mais pour information, il existe une implémentation complètement libre de la carte OpenPGP pour contrôleur STM32F103 : Gnuk.

(Je n’ai pas la moindre idée de l’effort que demanderait le portage de cette implémentation sur le contrôleur du Mooltipass, si ce n’est pas un STM32…)

Debian ne filtre pas ses paquets.

Euh, si, un peu quand même.

C'est voulu comme comportement ?

Apparemment oui.

Ça peut se corriger ?

Non, cf. les réponses des développeurs au rapport de bug ci-dessus.

Pour ce que ça vaut, le support natif d’OpenPGP est annoncé comme “feature-complete” dans Thunderbird 78.1.0 (toujours désactivé par défaut, comme prévu).

“Feature-complete” ne voulant pas bien sûr pas dire “bug-free”, ni que les fonctionnalités sont équivalentes à celles de feu Enigmail.

Je suppose que si tu fais reconnaître ton usurpation, le fichage est automatiquement levé (puisque maintenant la Banque de France sait que ce n’est pas toi qui est mauvais payeur). Du coup maintenant que tu n’es plus fiché, tu peux à nouveau souscrire un crédit mais ton usurpateur aussi !

Je pense que parfois il faut aussi être indulgent car critiquer au moindre pet de travers est ridicule. Des erreurs, ça arrive, surtout dans ce genre de situations.

Désolé, mon indulgence est réservée à ceux qui sont capables d’admettre quand ils ont fait des erreurs, ce qui manifestement exclut tout « responsable » politique.

on saura pas si ils sont lavés correctement

Pour info au cas où, si pour une raison ou pour une autre il n’est pas possible ou pas pratique certains jours de le laver, un masque en tissu peut être mis au four. Une vingtaine de minutes à 100°C, c’est bien assez pour détruire n’importe quel virus.

Je trouverais donc quand même plus logique que wpa_supplicant soit présent par défaut dans SlackWare.

Il l’est. Le mode d’installation par défaut (et recommandé) est l’installation complète, donc wpa_supplicant est installé par défaut. S’il n’était pas installé, c’est soit que tu l’as explicitement dé-selectionné en mode « expert », soit que tu as utilisé des tagfiles qui ne l’incluaient pas…

Au-delà du bien connu SSL Labs, ce ne sont pas les vérificateurs qui manquent, par exemple :

• ImmuniWeb
• Internet.nl
• Hardenize

Et si on ne se limite pas aux vérificateurs TLS :

• Security Headers pour les en-têtes HTTP (genre Content-Security-Policy et assimilés)
• ZoneMaster pour la configuration DNS/DNSSEC
• dane.sys4.de pour DANE
• dnsops.gov pour DANE

Pour ceux que ça intéresse, on peut assez facilement simuler une touche Compose sur Mac OS X.

Contexte : Je travaille sur un Mac au labo (on ne m’a laissé le choix qu’entre ça ou un PC sous Windows ; GNU/Linux ? pas de ça chez nous), et j’ai naturellement cherché à reproduire un environnement de travail qui me soit le plus familier possible, ce qui passe entre autres choses par la touche Compose (que j’utilise intensément sur ma machine personnelle sous GNU/Linux). Petite difficulté : je ne suis pas administrateur de la machine, donc il me fallait une solution accessible à un utilisateur non-privilégié, en particulier qui ne nécessite pas d’installer un quelconque logiciel tiers (donc, pas de Karabiner-Elements par exemple).

Tout se passe dans un fichier ~/Library/KeyBindings/DefaultKeyBinding.dict (à créer si nécessaire). Ce fichier permet d’associer à chaque touche du clavier (ou combinaison de touches) une action arbitraire. Par exemple, ci-dessous on associe à la touche du trait d’union (aka le « tiret du 6 ») une commande insérant un tiret cadratin (c’est évidemment un exemple caricatural à ne surtout pas utiliser tel quel, sous peine de ne plus jamais pouvoir saisir un trait d‘union normal…) :

{
    "-" = ("insertText:", "\U2014");
}

Pour des combinaisons de touches, on procédera ainsi :

{
    "-" = {
        "-" = ("insertText:", "\U2014");
        "." = ("insertText:", "\U2013");
    };
}

Ici, frapper deux fois la touche du trait d’union insérera un tiret cadratin, tandis que frapper successivement le trait d’union et le point insérera un tiret demi-cadratin.

À partir de là, on peut aisément simuler une touche Compose, il suffit de choisir la touche que l’on veut utiliser comme tel et de définir une série de combinaisons qui commencent toutes par cette touche. Dans mon cas, j’ai utilisé la touche « menu » à droite de la barre espace, qui sur ma machine a le code \U0010 (trouvé par essai et erreur, vu qu’il n’y a pas l’air d’avoir d’outil équivalent à xev sous Mac OS X — ou s’il y en a un je ne l’ai pas trouvé…). Au final ça donne le fichier suivant :

{
    "\U0010" = { /* Compose-like key */

        "-" = {
            "m" = ("insertText:", "\U2212"); /* MINUS SIGN */
            "+" = ("insertText:", "\U2213"); /* MINUS-OR-PLUS SIGN */
            "-" = {
                "." = ("insertText:", "\U2013"); /* EN DASH */
                "-" = ("insertText:", "\U2014"); /* EM DASH */
            };
            "0" = ("insertText:", "\U2080"); /* SUBSCRIPT 0 */
            "1" = ("insertText:", "\U2081"); /* SUBSCRIPT 1 */
            "2" = ("insertText:", "\U2082"); /* SUBSCRIPT 2 */
            "3" = ("insertText:", "\U2083"); /* SUBSCRIPT 3 */
            "4" = ("insertText:", "\U2084"); /* SUBSCRIPT 4 */
            "5" = ("insertText:", "\U2085"); /* SUBSCRIPT 5 */
            "6" = ("insertText:", "\U2086"); /* SUBSCRIPT 6 */
            "7" = ("insertText:", "\U2087"); /* SUBSCRIPT 7 */
            "8" = ("insertText:", "\U2088"); /* SUBSCRIPT 8 */
            "9" = ("insertText:", "\U2089"); /* SUBSCRIPT 9 */
        };

        "_" = {
            "0" = ("insertText:", "\U2070"); /* SUPERSCRIPT 0 */
            "1" = ("insertText:", "\U2071"); /* SUPERSCRIPT 1 */
            "2" = ("insertText:", "\U00B2"); /* SUPERSCRIPT 2 */
            "3" = ("insertText:", "\U00B3"); /* SUPERSCRIPT 3 */
            "4" = ("insertText:", "\U2074"); /* SUPERSCRIPT 4 */
            "5" = ("insertText:", "\U2075"); /* SUPERSCRIPT 5 */
            "6" = ("insertText:", "\U2076"); /* SUPERSCRIPT 6 */
            "7" = ("insertText:", "\U2077"); /* SUPERSCRIPT 7 */
            "8" = ("insertText:", "\U2078"); /* SUPERSCRIPT 8 */
            "9" = ("insertText:", "\U2079"); /* SUPERSCRIPT 9 */
        };

        "g" = { /* Fly pushing stuff */
            "m" = ("insertText:", "\U2642"); /* MALE */
            "f" = ("insertText:", "\U2640"); /* FEMALE */
            "F" = ("insertText:", "\U263F"); /* VIRGIN FEMALE */
            "y" = ("insertText:", "\U21C1"); /* Y CHROMOSOME */
        };

        "G" = { /* Greek letters */
            "A" = ("insertText:", "\U0391");    /* GREEK CAPITAL LETTER ALPHA */
            "B" = ("insertText:", "\U0392");    /* GREEK CAPITAL LETTER BETA */
            "G" = ("insertText:", "\U0393");    /* GREEK CAPITAL LETTER GAMMA */
            "D" = ("insertText:", "\U0394");    /* GREEK CAPITAL LETTER DELTA */
            "E" = ("insertText:", "\U0395");    /* GREEK CAPITAL LETTER EPSILON */
            "Z" = ("insertText:", "\U0396");    /* GREEK CAPITAL LETTER ZETA */
            "Y" = ("insertText:", "\U0397");    /* GREEK CAPITAL LETTER ETA */
            "H" = ("insertText:", "\U0398");    /* GREEK CAPITAL LETTER THETA */
            "I" = ("insertText:", "\U0399");    /* GREEK CAPITAL LETTER IOTA */
            "K" = ("insertText:", "\U039A");    /* GREEK CAPITAL LETTER KAPPA */
            "L" = ("insertText:", "\U039B");    /* GREEK CAPITAL LETTER LAMBDA */
            "M" = ("insertText:", "\U039C");    /* GREEK CAPITAL LETTER MU */
            "N" = ("insertText:", "\U039D");    /* GREEK CAPITAL LETTER NU */
            "C" = ("insertText:", "\U039E");    /* GREEK CAPITAL LETTER XI */
            "O" = ("insertText:", "\U039F");    /* GREEK CAPITAL LETTER OMICRON */
            "P" = ("insertText:", "\U03A0");    /* GREEK CAPITAL LETTER PI */
            "R" = ("insertText:", "\U03A1");    /* GREEK CAPITAL LETTER RHO */
            "S" = ("insertText:", "\U03A3");    /* GREEK CAPITAL LETTER SIGMA */
            "T" = ("insertText:", "\U03A4");    /* GREEK CAPITAL LETTER TAU */
            "U" = ("insertText:", "\U03A5");    /* GREEK CAPITAL LETTER UPSILON */
            "F" = ("insertText:", "\U03A6");    /* GREEK CAPITAL LETTER PHI */
            "X" = ("insertText:", "\U03A7");    /* GREEK CAPITAL LETTER CHI */
            "Q" = ("insertText:", "\U03A8");    /* GREEK CAPITAL LETTER PSI */
            "W" = ("insertText:", "\U03A9");    /* GREEK CAPITAL LETTER OMEGA */

            "a" = ("insertText:", "\U03B1");    /* GREEK SMALL LETTER ALPHA */
            "b" = ("insertText:", "\U03B2");    /* GREEK SMALL LETTER BETA */
            "g" = ("insertText:", "\U03B3");    /* GREEK SMALL LETTER GAMMA */
            "d" = ("insertText:", "\U03B4");    /* GREEK SMALL LETTER DELTA */
            "e" = ("insertText:", "\U03B5");    /* GREEK SMALL LETTER EPSILON */
            "z" = ("insertText:", "\U03B6");    /* GREEK SMALL LETTER ZETA */
            "y" = ("insertText:", "\U03B7");    /* GREEK SMALL LETTER ETA */
            "h" = ("insertText:", "\U03B8");    /* GREEK SMALL LETTER THETA */
            "i" = ("insertText:", "\U03B9");    /* GREEK SMALL LETTER IOTA */
            "k" = ("insertText:", "\U03BA");    /* GREEK SMALL LETTER KAPPA */
            "l" = ("insertText:", "\U03BB");    /* GREEK SMALL LETTER LAMBDA */
            "m" = ("insertText:", "\U03BC");    /* GREEK SMALL LETTER MU */
            "n" = ("insertText:", "\U03BD");    /* GREEK SMALL LETTER NU */
            "c" = ("insertText:", "\U03BE");    /* GREEK SMALL LETTER XI */
            "o" = ("insertText:", "\U03BF");    /* GREEK SMALL LETTER OMICRON */
            "p" = ("insertText:", "\U03C0");    /* GREEK SMALL LETTER PI */
            "r" = ("insertText:", "\U03C1");    /* GREEK SMALL LETTER RHO */
            "v" = ("insertText:", "\U03C2");    /* GREEK SMALL LETTER FINAL SIGMA */
            "s" = ("insertText:", "\U03C3");    /* GREEK SMALL LETTER SIGMA */
            "t" = ("insertText:", "\U03C4");    /* GREEK SMALL LETTER TAU */
            "u" = ("insertText:", "\U03C5");    /* GREEK SMALL LETTER UPSILON */
            "f" = ("insertText:", "\U03C6");    /* GREEK SMALL LETTER PHI */
            "x" = ("insertText:", "\U03C7");    /* GREEK SMALL LETTER CHI */
            "q" = ("insertText:", "\U03C8");    /* GREEK SMALL LETTER PSI */
            "w" = ("insertText:", "\U03C9");    /* GREEK SMALL LETTER OMEGA */
        };

        "?" = {
            "?" = ("insertText:", "\U2E2E");    /* IRONY MARK */
            "-" = ("insertText:", "\U2243");    /* ASYMPTOTICALLY EQUAL TO */
            "=" = ("insertText:", "\U2248");    /* ALMOST EQUAL TO */
        };

        "d" = {
            "d" = ("insertText:", "\U00B0");    /* DEGREE SIGN */
            "C" = ("insertText:", "\U2103");    /* CELSIUS DEGREE */
            "F" = ("insertText:", "\U2109");    /* FARENHEIT DEGREE */
        };

        "x" = {
            "x" = ("insertText:", "\U2A09");    /* N-ARY TIMES OPERATOR */
        };

        "\U0020" = {
            "\U0020" = ("insertText:", "\U00A0");   /* NO-BREAK SPACE */
            "." = ("insertText:", "\U2008");    /* PUNCTUATION SPACE */
            "," = ("insertText:", "\U202F");    /* NARROW NO-BREAK SPACE */
            "!" = ("insertText:", "\U200B");    /* ZERO WIDTH SPACE */
        };

        "c" = {
            "o" = ("insertText:", "\U00A9"); /* COPYRIGHT SIGN */
        };
    };
}

Voilà, si ça peut aider des Linuxiens coincés sous Mac OS X…

La documentation d’Apple sur le sujet.

et qu'ils doivent pouvoir utiliser les droits UGO ou numériques 755 par exemple pour gérer qui peut lire/ecrire dedans

À ce sujet, il faut noter que la page de manuel de unix(7) sous GNU/Linux semble erronée. Elle indique que la prise en compte des permissions de fichier sur la socket ne serait pas spécifiée par POSIX et qu’un programme portable ne devrait pas compter dessus (“POSIX does not make any statement about the effect of the permissions on a socket file, and on some systems, the socket permissions are ignored. Portable programs should not rely on this feature for security.”).

Cela semble clairement faux car le standard POSIX indique bien que les fonctions qui écrivent sur des sockets renvoient EACCES en cas de défaut de droit d’écriture sur la socket. Une rapide vérification montre que tous les *BSD modernes (e.g. Free-, Net-, Open-BSD) par exemple implémentent ce comportement, pas seulement GNU/Linux.

J'ai l'impression qu'en général les socket Unix sont plus souvent utilisé pour ce logiciel mais je ne saurais dire pourquoi :/

Une autre raison possible est que pour des communications strictement locales, les sockets Unix sont plus performantes, au moins en principe (dans les faits je ne suis pas certain que la différence soit réellement notable, à moins que le volume des communications ne soit particulièrement élevé).

En effet, sur la plupart des systèmes, les messages échangés à travers une socket AF_INET passent à travers toute la pile réseau, avec tout l’overhead que ça implique : même dans le cas où la socket n’est liée qu’à une adresse locale (et donc jamais en contact avec un « vrai » réseau), il n’y a pas de chemin privilégié qui autoriserait à « court-circuiter » la pile réseau.

À l’inverse, les messages échangés à travers une socket Unix ont un chemin beaucoup plus simple.

Est-ce que par “socket”, tu entends “sockets unix” ? Si oui, en effet les sockets unix sont uniquement accessibles depuis la machine locale. Du coup si certains composants doivent être accessibles à distance, ça règle la question…

(Sinon, ta question est confuse parce qu’en réalité, pour utiliser un port TCP tu utilises aussi une socket, simplement d’un type différent — AF_INET pour une socket TCP et AF_UNIX pour une socket unix.)

Est-ce qu'on peux utiliser TPM pour chiffrer une partition (avec LUKS, cryptoloop ou autre) ?

Je n’ai personnellement pas encore étudié ça, mais c’est définitivement possible, oui.

autant pour chiffrer ma partition root avec mon empreinte de doigt sur ledit matériel

Ça en revanche, je ne m’avancerai pas à dire que c’est possible. Et je suis dans l’incapacité de tester ça (quand bien même je le voudrais, ce qui n’est pas le cas vu ce que je pense de l’authentification biométrique…) vu que ma machine n’a pas de lecteur d’empreinte de toute façon.

Pendant que j’y suis, je partage un autre souvenir qui peut intéresser des utilisateurs de vpnc.

Une des choses qui me dérangeaient était que, lors de l’établissement de la connexion, le client installait une route par défaut qui envoyait tout le trafic à travers le VPN, y compris le trafic qui n’était pas destiné à l’université. Non seulement c’était peu efficace, mais il n’y avait aucune raison pour que l’université voit tout mon trafic réseau, y compris mes activités n’ayant aucun rapport avec mon travail au sein de ladite université.

La consigne standard de l’université face à cela était de ne lancer le VPN que lorsqu’on avait besoin d’accéder à une ressource du réseau universitaire, et de le couper juste après. Faisable, certes, mais pas vraiment satisfaisant.

Dans mon cas, comme la seule ressource à laquelle je voulais accéder était le serveur de messagerie, j’avais remplacé le script par défaut de vpnc par celui-ci :

#!/bin/bash

case "$reason" in
pre-init)
    ;;

connect)
    # Setup interface for the tunnel
    /sbin/ifconfig $TUNDEV inet $INTERNAL_IP4_ADDRESS \
      pointopoint $INTERNAL_IP4_ADDRESS \
      netmask 255.255.255.255 mtu 1412 up
    # Setup a route to the mail server through the tunnel
    /sbin/route add mail.university.example dev $TUNDEV
    ;;

disconnect)
    /sbin/ifconfig $TUNDEV down
    ;;
esac

qui ne faisait que le strict minimum pour me permettre d’accéder au serveur de messagerie (mettre en place le tunnel et installer une route bien spécifique pour que seul le trafic destiné au serveur de messagerie ne soit envoyé dans le tunnel) sans rien toucher au reste de ma configuration réseau.

Voilà, ce n’est pas nécessairement applicable à tout le monde, mais si ça peut être utile à quelqu’un… (Merci barmic de m’avoir donné une raison de me replonger dans mes vieilles archives. :D )

J’ai utilisé vpnc de 2008 à 2013 pour accéder au serveur IMAP de mon université¹. Pour ce que ça vaut, chez moi non plus ça n’a jamais été stable.

À l’époque j’avais une solution à LA RACHE pour botter le cul du client. Il n’était pas nécessaire de pinguer une mire à travers le VPN, il suffisait de vérifier si le démon était toujours vivant :

#!/bin/bash
while true ; do
    if [ ! -s /var/run/vpnc/pid ] || ! kill -0 $(< /var/run/vpnc/pid) ; then
        logger -t vpnc "VPN connection seems down, kicking the client"
        /usr/sbin/vpnc
    fi
    sleep 600
done

---

¹ Serveur IMAP qui n’était accessible que depuis le réseau de l’université, ce que je trouve personnellement assez stupide — autant pour un serveur d’envoi de mails je peux comprendre qu’on ne veuille pas accepter de connexions depuis n’importe où, autant pour un serveur de réception l’intérêt m’a toujours échappé…

Full disclosure : Je suis un contributeur occasionnel de GnuPG, mainteneur de Scute (l’interface PKCS#11 pour les cartes OpenPGP), membre du GnuPG e.V. (une association allemande de personnes impliquées dans OpenPGP — pas seulement GnuPG contrairement à ce que le nom peut laisser croire), et animateur régulier d’ateliers consacrés entre autres au chiffrement d’e-mails au sein des cryptoparties londoniennes. Avec cet éclairage, interprétez le commentaire ci-dessous comme vous voudrez. Il va sans dire que ce message n’engage que moi et aucunement lesautres contributeurs à GnuPG.

Si une entreprise avait communiquée comme ils l’ont fait ces derniers temps on l’aurait largement critiqué.

Parce que les développeurs de GnuPG ne sont pas critiqués peut-être ? Ils s’en prennent plein la gueule, oui, et pas seulement depuis « ces derniers temps ».

En raison vraisemblablement de son statut « d’implémentation libre de référence » d’OpenPGP (qui au passage entraîne l’éternelle confusion entre OpenPGP, PGP, GPG, que j’essaye régulièrement de dissiper chaque fois que j’en ai l’occasion tellement elle fait du tort à tout le monde), le moindre problème dans l’écosystème est mis sur le dos de GnuPG.

Le fonctionnement des serveurs de clefs en mode append-only, qui les rend vulnérables aux empoisonnements ? « C’est de la faute de GnuPG, ses développeurs étaient au courant mais ils n’ont rien fait. » Alors que ① aucun développeur de GnuPG n’est impliqué dans les logiciels serveurs de clefs, et ② GnuPG propose depuis plusieurs années maintenant une méthode alternative de distribution des celfs précisément dans le but de se passer du réseau des serveurs HKP et leurs problèmes inhérents.

La complexité de la toile de confiance, qui est imbitable pour tout le monde ? C’est GnuPG bien sûr. Alors que ① le concept de la toile de confiance a été inventé par Phil Zimmerman dès 1995, au moins deux ans avant que le première ligne de code de GnuPG ne soit écrite, et ② GnuPG est à ce jour la seule implémentation d’OpenPGP à avoir proposé de dépasser le modèle de la toile de confiance pour le remplacer par un modèle à la fois plus simple et plus en accord avec les pratiques réelles des utilisateurs (trust-on-first-use).

La faille E-FAIL ? Le papier décrivant l’attaque mentionnait clairement que, parmi tous les clients e-mail testés, seuls Thunderbird (avec le plugin Enigmail) et Outlook (avec le plugin GpgOL) étaient vulnérables. Tous les autres (Claws-Mail, KMail, Mutt, Evolution…) déjouaient l’attaque. Ça indique bien que le problème venait des clients mails plutôt que de GnuPG lui-même (sinon tous les clients utilisant GnuPG en arrière-plan auraient été vulnérables), mais non, « c’est de la faute de GnuPG. Et en plus ils n’assument pas, regardez quand on tente de leur faire remarquer ils se défaussent sur le code des autres ».

Je ne m’attarderai pas sur les attaques de certains universitaires à la Matthew Green, qui font preuve d’une mauvaise foi rarement égalée. (J’ai particulièrement aimé la fois où Matthew Green a déclaré qu’il s’amusait à faire lire le code de GnuPG à ses étudiants, qui après une semaine revenaient le supplier de ne plus jamais les soumettre à une torture pareille tellement le code serait imbitable. Que le code de GnuPG soit critiquable, je veux bien — montrez-moi du code vieux de vingt ans qui ne le soit pas —, mais de là à dire qu’il est illisible, je m’insurge. Pour ce que ça vaut, quand je me suis penché pour la première fois sur le code de GnuPG il y a six ans, j’ai au contraire trouvé qu’il était assez facile de s’y retrouver — c’est bien d’ailleurs ce qui m’a permis de soumettre mon premier patch, alors que je ne suis même pas développeur ; serais-je plus doué que les étudiants du Professeur Green ?).

Je ne prétends pas que GnuPG est parfait. Certaines critiques à son encontre sont parfaitement justifiées et oui, il y a des bugs. C’est un fait, par exemple, que l’empoisonnement des serveurs SKS aurait été beaucoup moins grave s’il n’avait pas été accompagné d’une conception critiquable de la gestion des trousseaux de clefs dans GnuPG¹.

Mais face aux critiques débordantes de mauvaise foi et/ou visant GnuPG alors que ce sont d’autres composantes de l’écosystème OpenPGP qui sont concernés, face aux GnuPG haters qui ont du mal à cacher leur jubilation à chaque annonce d’un nouvelle faille (peu importe que la faille touche réellement GnuPG ou pas), face à tous ceux qui réclament à cors et à cri la mort de GnuPG et disent à tout le monde d’utiliser Signal (peu importe que Signal et GnuPG ne remplissent pas du tout la même fonction et n’offrent pas du tout les mêmes garanties)… ben je ne jetterai pas la pierre aux développeurs de GnuPG d’ignorer royalement ces gens-là.

Merde. Si vous avez un problème avec GnuPG, il y a d’autres implémentations. Aucune n’a toutes les fonctionnalités de GnuPG, mais certaines sont prometteuses.

---

¹ En gros, l’insertion d’une nouvelle clef dans le trousseau était une opération dont la complexité variait avec le carré du nombre de signatures portées par la clef, ce qui rendait très facile de faire un déni de service. Quelques milliers de signatures sur une clef suffisaient à mettre GnuPG à genou, là où d’autres implémentations ne rencontraient aucune difficulté. (Le problème a été corrigé depuis.)

Oui mais est-ce qu'elles stipulent que tu acceptes que tu leur délègues la gestion du spam ?

Tu as du temps à perdre, vérifie toi-même.

(Spoiler alert: Non. Nulle part ce document ne dit que l’utilisateur accepte que le fournisseur de service peut bien faire ce que bon lui semble des messages qui lui sont normalement destinés.)

Je n'ai d'adresse chez eux alors j'ignore quelles sont les conditions d'utilisations de outlook.com

Il se trouve que j’en ai une (créée à l’époque où ça s’appelait encore Hotmail, et toujours active).

Et je te le donne en mille : il n’y a aucune option accessible à l’utilisateur permettant de désactiver le filtrage des spams. La seule action possible est de whitelister certains émetteurs, pour dire « s’il te plaît, n’envoie pas les e-mails de cette personne dans la boîte indésirable ».

En particulier, il n’est pas possible pour l’utilisateur de dire « je veux pouvoir tout voir, n’envoie jamais un message qui m’est destiné dans un trou noir sans que j’ai une chance d’en prendre connaissance ».

il n'y a aucun standard qui impose que le spam aille dans telle ou telle boite.

Il y a un standard qui dit qu’un serveur s’engageant à délivrer un message doit le délivrer.

Sur ce, j’abandonne, même pour un vendredi il y a des limites.