Catégories
Sécurité informatique

Sécu­ri­ser les nouveaux mots de passe

J’ai récem­ment parlé complexité de mot de passe mais en réalité le problème est souvent ailleurs. La taille et la complexité n’ont aucune impor­tance si quelqu’un peut devi­ner quel mot de passe vous utili­sez après juste quelques essais.

Jean réuti­lise son mot de passe

Je connais l’email de Jean ? Il me suffit de regar­der quels mots de passe il a utilisé sur d’autres sites, et de les tester un à un.

La plupart des sites ont un problème de sécu­rité un jour ou l’autre. Souvent les données extraites se retrouvent publiques d’une façon ou d’une autre. Parfois on y trouve des mots de passe en clair ou mal proté­gés. Il suffit de piocher dedans.

Testez Have I Been Pwned, vous verrez que des tiers peuvent déjà connaitre plusieurs de vos mots de passe.

Paul n’a aucune imagi­na­tion

Je ne connais pas l’email de Paul ? Qu’im­porte. Je peux déjà tester les mots de passe les plus courants, et les varia­tions de ceux-ci.

Ne vous croyez pas origi­nal. Même ajou­ter une date, un chiffre, un symbole, chan­ger une lettre, inver­ser le mot de passe, quelqu’un l’a déjà fait. En quelques milliers de combi­nai­sons j’ai déjà énor­mé­ment de mots de passe habi­tuels.

Même les méthodes « choi­sir x mots du diction­naire » sont vulné­rables si c’est l’uti­li­sa­teur qui choi­sit ses mots dans sa tête. Le plus souvent on tombera dans quelques centaines de mots, toujours les mêmes.

Par le passé j’ai utilisé un person­nage de litté­ra­ture, auquel j’ai ajouté un chiffre et un symbole. Croyez-le ou non, on trouve plus d’une dizaine d’oc­cur­rences sur Have I Been Pwned.

Have I Been Pwned

J’ai cité Have I Been Pwned. Ils mettent à dispo­si­tion une base de tous les mots de passe qui ont publique­ment fuité.

Si vous lais­sez des tiers saisir des mots de passe sur votre service, vous devriez télé­char­ger leur base, puis cher­cher dedans à chaque fois qu’un de vos utili­sa­teur saisit un nouveau mot de passe. Le mot de passe est déjà dedans ?

Alors il y a un risque de sécu­rité et vous devriez en aler­ter l’uti­li­sa­teur.

Si vous voulez aller plus loin, tentez quelques varia­tions simples : Si le mot de passe se termine par un nombre, essayez les deux ou trois nombres précé­dents. Si le mot de passe à des symboles ou chiffres en début ou fin, reti­re­rez-les et testez le mot de passe résul­tant.

Tout ça ne vous coûte quasi­ment rien si ce n’est un peu de stockage et le télé­char­ge­ment de la nouvelle base Have I Been Pwned de temps en temps, mais ça va éviter bien des risques à vos utili­sa­teurs.

Catégories
Développement informatique Licences logicielles

Éthique et poli­tique dans les licences logi­cielles

Je conti­nue mes réflexions sur comment nous, infor­ma­ti­ciens, parti­ci­pons à la poli­tique par nos actions.

Il ne tient qu’à nous de refu­ser de parti­ci­per à des projets et des orga­ni­sa­tions du mauvais côté de la ligne morale. Contrai­re­ment à d’autres profes­sions, nous avons le choix. Utili­sons-le.


Plus que le choix, nous avons un pouvoir, énorme. C’est un des appren­tis­sages des logi­ciels libres. Nous avons quand même réussi que les plus grandes corpo­ra­tions se sentent obli­gées de contri­buer, même de façon mineure, à des logi­ciels communs profi­tant à tous. Nous avons réussi à en faire un argu­ment dans les proces­sus de recru­te­ment.

Imagi­nez, le temple du capi­ta­lisme, les méga star­tup techno qui contrôlent jusque notre vie privée, obli­gées de fait de se plier à contri­buer au domaine commun. Quel pouvoir !


Nous avons utilisé ce pouvoir pour impo­ser le libre accès au logi­ciel et au code source, en nous moquant de qui l’uti­lise et pour faire quoi, comme si cela ne nous concer­nait pas.

Que nous importe que l’im­pri­mante gère des listes de personnes à abattre tant que nous avons accès au code source du pilote pour en corri­ger les défauts. Je ne peux m’exo­né­rer des consé­quences de ce que je créé et de ce que je diffuse.

Avec tout le respect que j’ai pour l’énorme œuvre du logi­ciel libre, j’ai l’im­pres­sion que nous avons partiel­le­ment fait fausse route, privi­lé­giant une vision liber­taire amorale plutôt qu’as­su­mer les consé­quences de ce que nous créons.

Pire, en faisant le logi­ciel libre comme l’al­pha et l’oméga de toute notion poli­tique et éthique dans le logi­ciel, nous nous sommes reti­rés toute capa­cité à inter­ve­nir sur d’autre critères.


Je repense à la licence JSON qui avait fait grand bruit par le passé.

The Soft­ware shall be used for Good, not Evil.

https://www.json.org/license.html

Cette notion m’at­tire, aussi floue et aussi problé­ma­tique soit-elle.

Oui, cette licence n’est pas libre. La licence GPL serait incom­pa­tible avec icelle. Qu’im­porte : L’ac­cès au logi­ciel et à son code source ne me semble pas une valeur si abso­lue qu’il me faille aban­don­ner tout recul sur ce qui est fait avec le logi­ciel.

Je ne suis pas seul, en paral­lèle d’autres ont mis à jour la licence Hippo­cra­tic, qui va globa­le­ment dans le même sens.

The soft­ware may not be used by indi­vi­duals, corpo­ra­tions, govern­ments, or other groups for systems or acti­vi­ties that acti­vely and knowin­gly endan­ger, harm, or other­wise threa­ten the physi­cal, mental, econo­mic, or gene­ral well-being of indi­vi­duals or groups in viola­tion of the United Nations Univer­sal Decla­ra­tion of Human Rights

https://first­do­no­harm.dev/version/1/1/license.html

J’ajou­te­rais proba­ble­ment la conven­tion de Genève, celle des droits de l’en­fant, peut-être un texte de portée simi­laire parlant d’éco­lo­gie (lequel ?), un lié à la vie privée, etc.

Ça reste flou mais ça permet de tout de même donner un cadre, surtout si on ajoute que l’in­ter­pré­ta­tion à donner à ces textes ne doit pas être moins stricte que celle de l’Eu­rope occi­den­tale de notre décen­nie.

Peu importe en réalité. Il s’agit de donner une inten­tion. Je n’ai pas cette préten­tion mais si l’ar­mée ou une corpo­ra­tion sans éthique veut réuti­li­ser mon code, ce n’est pas la licence qui les en empê­chera, flou ou pas.

Je ne prétends certai­ne­ment pas aller devant au tribu­nal. Ma seule arme est l’op­probre publique et le flou n’est ici pas un problème. La préci­sion juri­dique n’est pas un besoin. Au contraire, rester au niveau de l’in­ten­tion permet d’évi­ter les pirouettes en jouant sur les mots ou en trou­vant les failles. Quelque part la formu­la­tion de la licence JSON a ma préfé­rence, juste­ment pour ça.

Ça vous parait fou, irréa­liste, inap­pli­cable, mais combien d’entre nous auraient trou­vés la GPL raison­nable, réaliste et appli­cable à ses débuts ? Les débats n’ont d’ailleurs pas manqué.


Le seul vrai problème, à mon niveau, est bien celui du logi­ciel libre, et plus parti­cu­liè­re­ment de la GPL, incom­pa­tible avec toute autre licence qui fait des choix diffé­rents. Or la GPL est incon­tour­nable dans de nombreuses situa­tions, dans de nombreux contextes.

Une solu­tion pour­rait être de propo­ser une double licence : une licence basée sur l’éthique, tout en prévoyant une excep­tion qui permet de passer sur une AGPL au besoin.

Catégories
Développement web Sécurité informatique

Déve­lop­peurs, vous devriez avoir honte — Règles de mots de passe

Je rage à chaque fois que je saisis un mot de passe fort et que le site m’en­voie bouler parce que je n’ai pas de carac­tère autre qu’al­pha­nu­mé­rique.

Essayons quelque chose d’un peu plus smart pour évaluer la robus­tesse d’un mot de passe

Déve­lop­peurs, vous savez proba­ble­ment tout ça, mais conti­nuez à lire parce que la fin vous est adres­sée

Si j’en crois Hacker­noon on peut calcu­ler envi­ron 800 millions de SHA256 par seconde sur un maté­riel qui coûte 0,82 € par heure sur AWS. Ça fait 3,5 10^12 combi­nai­sons par euro.

Traduit autre­ment, voici le nombre de combi­nai­sons qu’on peut tester, et le même chiffre écrit en puis­sance de deux (arrondi à la déci­male infé­rieure) :

1 €3,5 × 10^122^41,6
10 €3,5 × 10^132^44,9
100 €3,5 × 10^142^48,3
1 000 €3,5 × 10^152^51,6
10 000 €3,5 × 10^162^54,9
100 000 €3,5 × 10^172^58,2

Quand on vous parle ailleurs de bits d’en­tro­pie, ça corres­pond à ces puis­sances de 2. Avec 1 000 € on peut tester toutes les combi­nai­sons de SHA 256 d’une chaîne aléa­toire de 51 bits.

Ok, mais ça me dit quoi ? Une lettre c’est 26 combi­nai­sons, envi­ron 4,7 bits. Si vous ajou­tez les majus­cules vous doublez le nombre de combi­nai­sons et vous ajou­tez 1 bit. Si vous ajou­tez les chiffres et quelques carac­tères spéciaux on arrive à à peine plus de 6 bits.

Petit calcul, en utili­sant juste les 26 lettres de l’al­pha­bet, on peut tester toutes les combi­nai­sons de 8 carac­tères pour moins de 1 €. Vu qu’on aura de bonnes chances de tomber dessus avant d’avoir testé toutes les combi­nai­sons, autant dire que même avec 9 carac­tères, votre mot de passe ne vaut pas plus de 1 €.

Combien faut-il de carac­tères pour se trou­ver rela­ti­ve­ment à l’abri (c’est à dire que la somme inves­tie ne peut pas tester plus de 1% des combi­nai­sons) ? Ça va dépendre de ce que vous y mettez comme types de carac­tères. J’ai fait les calculs pour vous :

a-za-z
A-Z
a-z
A-Z
0–9
a-z
A-Z
0–9
+-%
1 €11998
10 €111099
100 €12101010
1 000 €13111010
10 000 €14111111
100 000 €14121111

Et là magie : 8 carac­tères, même avec des chiffres, des majus­cules et des symboles, ça résiste tout juste à 1 €. Et encore, là c’est en partant du prin­cipe que vous choi­sis­sez réel­le­ment les carac­tères de façon aléa­toire, pas que vous ajou­tez juste un symbole à la fin ou que vous trans­for­mez un E en 3.

Vous voulez que votre mot de passe résiste à un voisin malveillant prêt à mettre plus de 10 € sur la table ? Prévoyez au moins 10 carac­tères.

Et là, seconde magie : Si vous mettez 10 carac­tères on se moque de savoir si vous y avez mis des chiffres ou symboles. La longueur a bien plus d’im­por­tance que l’éven­tail de carac­tères utilisé.


Main­te­nant que vous savez ça, tous les sites qui vous imposent au moins une majus­cule et un symbole mais qui vous laissent ne mettre que 8 carac­tères : Poubelle.

Je ne suis pas en train de vous apprendre à faire un mot de passe fort. Vous devriez utili­ser un gestion­naire de mots de passe et le géné­ra­teur auto­ma­tique qui y est inclus.

Je suis en train d’es­sayer de rendre honteux tous les déve­lop­peurs qui acceptent de mettre ces règles à la con sur les sites web dont ils ont la charge : Vous impo­sez des mots de passe qui sont à la fois imbi­tables et peu robustes.


Vous voulez faire mieux ?

Regar­dez dans quelle colonne est l’uti­li­sa­teur en fonc­tion des carac­tères qu’il a déjà tapé et donnez-lui un indi­ca­teur en fonc­tion de la longueur de son mot de passe.

  • Mot de passe refusé s’il est sur « Have I Been Pwned? »
  • Moins de 10 € ? mot de passe insuf­fi­sant, refusé
  • Moins de 100 € ? mot de passe faible, couleur rouge
  • Moins de 1 000 € ? mot de passe moyen, couleur orange
  • Mot de passe sûr, couleur verte, à partir de 10 000 €

Si vous gérez un site central, par exemple un réseau social public, vous pouvez proba­ble­ment rele­ver tout ça d’un cran.

Si ça donne accès à des données sensibles, à des possi­bi­li­tés d’achat, à la boite e-mail ou à l’opé­ra­teur télé­pho­nique, mieux vaux rele­ver tout ça de deux crans.

Le tout prend proba­ble­ment moins de 10 lignes en javas­cript. C’est une honte que vous accep­tiez encore d’im­plé­men­ter des règles à la con « au moins une majus­cule, un chiffre et un symbole, voici les symboles auto­ri­sés […] ».

Déve­lop­peurs, vous devriez avoir honte.

Catégories
Geek Sécurité informatique Technique

Dis tonton, comment ça fonc­tionne la sécu­rité d’un gestion­naire de mots de passe ? — Intro­duc­tion cryp­to­gra­phique

Il y a peut-être des erreurs, proba­ble­ment des mauvais termes, certai­ne­ment des fautes ou mauvaises formu­la­tions. Vous êtes bien­ve­nus à parti­ci­per en propo­sant des correc­tions.


L’idée de base : Tous les mots de passe sont chif­frés. Personne d’autre que vous ne peut les relire sans votre accord. Ni le serveur sur lequel vous les envoyez, ni quelqu’un qui a accès au disque où vous les stockez, ni quelqu’un qui a ponc­tuel­le­ment accès à votre poste de travail.

Chif­frer c’est simple.

Pour chif­frer on a le choix. On va sépa­rer deux caté­go­ries prin­ci­pales de chif­fre­ment : les chif­fre­ments symé­triques et les asymé­triques.

La plupart des gestion­naires de mots de passe ont choisi un chif­fre­ment symé­trique (une seule clef secrète qui sert à la fois à chif­frer et à déchif­frer). C’est simple à gérer, rapide à l’exé­cu­tion, et il n’y a pas besoin de clef de grande taille. Tous ceux que j’ai vu utilisent de l’AES avec une clef de 256 bits. Au moins pour Bitwar­den et Keepass, c’est le mode CBC, et un contrôle HMAC avec SHA256 comme fonc­tion de hachage (mais vous pouvez igno­rer tous ces détails s’ils ne vous disent rien).

J’ai dit « la plupart des gestion­naires de mots de passe ». Un projet au moins a fait un choix diffé­rent. L’ou­til pass utilise un chif­fre­ment asymé­trique (une clef publique et une clef privée, l’une sert à chif­frer et l’autre à déchif­frer). Plus exac­te­ment, ils utilisent l’ou­til GnuPG. Même si le choix de la clef est libre, par défaut on y utilise géné­ra­le­ment une clef RSA de 2048 bits. Pass a fait ce choix en consi­dé­rant le partage de mots de passes comme la fonc­tion­na­lité prin­ci­pale. On verra pourquoi quand on parlera partage. Entre temps on va se concen­trer sur ceux qui font du chif­fre­ment symé­trique.

Dans les deux cas, on est là dans de l’ul­tra-stan­dard au niveau cryp­to­gra­phie. Je serais étonné de voir autre chose ailleurs (et c’est une bonne chose).

Une clef ? quelle clef ?

Ok, nos mots de passe sont chif­frés mais où est la clef ?

Impos­sible de deman­der à l’uti­li­sa­teur de se rappe­ler une clef de 256 bits. Ce serait plus de 40 signes entre minus­cules, majus­cules, chiffres et carac­tères spéciaux. Même avec une très bonne mémoire, ce serait ingé­rable à l’usage.

Stocker la clef de chif­fre­ment en clair sur le disque n’est pas beau­coup mieux. Ce serait comme avoir coffre-fort haute sécu­rité dont on cache la clef sous le paillas­son.

Ce qu’on demande à l’uti­li­sa­teur c’est un mot de passe prin­ci­pal. Vu qu’il va permettre de déchif­frer tous les autres, on va l’ap­pe­ler « mot de passe maître ». Il faut qu’il soit assez long et complexe pour éviter qu’un tiers ne puisse le devi­ner ou le trou­ver en essayant toutes les combi­nai­sons une à une, mais assez court pour pouvoir s’en rappe­ler et le taper sans erreur.

Le mot de passe maître ne chiffre rien lui-même. Accom­pa­gné d’autres para­mètres, il sert à calcu­ler une clef de taille suffi­sante qui, elle, servira au chif­fre­ment décrit plus haut et qu’on va appe­ler « clef maîtresse ». La fonc­tion qui fait cette opéra­tion est dite fonc­tion de déri­va­tion de clef.

Bitwar­den utilise le très clas­sique PBKDF2 avec un hachage SHA256. Pour faire simple on prend le mot de passe, on le mélange à une chaîne aléa­toire (stockée quelque part pour réuti­li­ser la même à chaque fois), et on opère la fonc­tion de hachage prévue. Norma­le­ment ça suffit pour avoir un résul­tat consi­déré comme rela­ti­ve­ment aléa­toire et impos­sible à remon­ter en sens inverse.

En pratique on cherche aussi à ralen­tir quelqu’un qui cher­che­rait à tester tous les mots de passe possibles un à un. Pour ça on va simple­ment répé­ter l’opé­ra­tion précé­dente un certain nombre de fois. Chaque itéra­tion prend en entrée le résul­tat de l’étape précé­dente. Si je fais 10 itéra­tions, il faudra 10 fois plus de temps à un attaquant pour tester toutes les combi­nai­sons. Ici on consi­dère le résul­tat comme assez confor­table à partir de 100.000 itéra­tions.

Keepass utilise une fonc­tion plus récente et consi­dé­rée comme plus robuste aux possi­bi­li­tés des maté­riels actuels : Argon2.

Là aussi tout est très clas­sique. Je n’ai pas regardé tous les gestion­naires de mots de passe mais je serais étonné de trou­ver autre chose que ces deux solu­tions stan­dards.

On résume

À l’ou­ver­ture le gestion­naire de mots de passe vous demande votre mot de passe maître. À partir de ce mot de passe et de para­mètres prédé­ter­mi­nés, il utilise une fonc­tion de déri­va­tion de clef et en sort une clef maitresse.

C’est cette clef maitresse qui permet de chif­frer ou déchif­frer vos mots de passe. Celui qui n’a pas accès à votre clef ne pourra rien faire des mots de passe chif­frés sur le disque.

Sécu­rité

À l’ou­ver­ture, le gestion­naire de mot de passe vous deman­dera votre mot de passe maître que pour calcu­ler la clef maîtresse à l’aide d’une fonc­tion de déri­va­tion de clef. Une fois ceci fait, il garde la clef maîtresse en mémoire et oublie le reste. Quoi qu’il se passe, personne ne connaî­tra votre mot de passe maître.

Le logi­ciel utilise cette clef maîtresse pour chif­frer et déchif­frer vos mots de passe. Cette clef maîtresse n’est jamais écrite nulle part. La plupart des gestion­naires de mots de passe oublie­ront volon­tai­re­ment cette clef en mémoire après un certain temps d’inac­ti­vité, ou à la mise en veille de votre poste de travail. L’idée c’est de limi­ter le risque de lais­ser qui que ce soit d’autre que vous y avoir accès. Dans ces cas là, on vous invi­tera à saisir de nouveau votre mot de passe maître pour retrou­ver la clef oubliée.

Une fois la clef maîtresse hors de la mémoire, vous n’avez que des blocs chif­frés que personne ne pourra déchif­frer sans le mot de passe maître. Pas même vous. Si vous oubliez votre mot de passe maître, vous ne pour­rez plus jamais relire ce que vous avez stocké. Même votre ami qui s’y connait ne pourra rien pour vous.

Ne vous lais­sez toute­fois par leur­rer. On parle sécu­rité, chif­fre­ment, complexité des fonc­tions de déri­va­tion de clef, mais en réalité tout ça a peu d’im­por­tance comparé à votre mot de passe maître. C’est un peu comme un coffre-fort : Discu­ter du diamètre des barres de renfort n’a aucun inté­rêt s’il s’ouvre avec une combi­nai­son de trois chiffres seule­ment.

S’il est possible de trou­ver votre mot de passe avec un nombre de tenta­tives limité, tout le reste ne servira à rien. « Limité » dans ce cas, ça dépasse la centaine de milliards de combi­nai­sons. Il vaut mieux un mot de passe maître complexe avec une fonc­tion de déri­va­tion simple qu’un mot de passe maître simple avec une fonc­tion de déri­va­tion complexe.

Chan­ger le mot de passe

Les plus alertes d’entre vous auront remarqué que si tout est déchif­fré indi­rec­te­ment à partir du mot de passe, chan­ger le mot de passe fait perdre l’ac­cès à tout ce qui est déjà chif­fré.

Quand vous chan­gez votre mot de passe maître, Keepass déchiffre toutes les données en mémoire, calcule la nouvelle clef et rechiffre l’in­té­gra­lité des données. Même si vous gérez une centaine de mots de passe, c’est quelque chose qui se fait rapi­de­ment sans avoir besoin de vous faire patien­ter long­temps.

Bitwar­den utilise lui une clef inter­mé­diaire tota­le­ment aléa­toire appe­lée clef de chif­fre­ment. C’est cette clef qui sert en réalité à chif­frer et déchif­frer les données stockées. Elle est elle-même chif­frée, à partir de la clef maîtresse, et stockée à côté des données.

On a donc un mot de passe maître qui sert à calcu­ler une clef maîtresse. La clef maîtresse sert à déchif­frer la clef de chif­fre­ment. La clef de chif­fre­ment sert à chif­frer et déchif­frer les données sur le disque.

Lorsqu’on veut chan­ger de mot de passe il suffit de chif­frer la clef de chif­fre­ment avec la nouvelle clef maitresse. Il n’y a pas besoin de rechif­frer chaque donnée (vu que la clef de chif­fre­ment ne change pas, elle).

L’avan­tage n’est pas tant dans le temps gagné (peu signi­fi­ca­tif) mais dans la résis­tance aux accès concur­rents : On peut avoir plusieurs clients qui lisent et écrivent en paral­lèle des données diffé­rentes dans le même trous­seau sans crainte que l’un d’eux n’uti­lise encore une ancienne clef de chif­fre­ment et envoie des données illi­sibles par les autres.

Et juste­ment, et si je partage ?

Avec ce qu’on a vu jusqu’à présent, si je partage des mots de passe je dois aussi parta­ger la clef de chif­fre­ment utili­sée.

Bitwar­den permet de parta­ger des mots de passe à un groupe de plusieurs personnes (appelé « orga­ni­sa­tion »). Au lieu d’être chif­frés avec ma clef de chif­fre­ment person­nelle, ces mots de passe sont chif­frés avec une clef de chif­fre­ment dédiée à l’or­ga­ni­sa­tion.

Le gros enjeu n’est pas dans le chif­fre­ment mais dans comment trans­mettre cette clef d’or­ga­ni­sa­tion à chaque utili­sa­teur de l’or­ga­ni­sa­tion.

Il faut un moyen pour que l’ad­mi­nis­tra­teur de l’or­ga­ni­sa­tion chiffre la clef d’or­ga­ni­sa­tion, me l’en­voie sur le serveur d’une façon que seul moi puisse la relire.

Jusqu’à main­te­nant c’est impos­sible parce que nous utili­sons des clefs symé­triques. C’est la même clef qui sert au chif­fre­ment et au déchif­fre­ment. Si l’ad­mi­nis­tra­teur pouvait chif­frer avec ma clef, il pour­rait aussi déchif­frer tous mes mots de passes person­nels et ça c’est inac­cep­table.

C’est donc ici qu’on reparle des clefs asymé­triques RSA. Chacun a une clef publique (diffu­sée à tout le monde) et une clef privée (garder secrète par chaque utili­sa­teur). La clef publique sert à chif­frer. La clef privée sert à déchif­frer. Tout le monde est donc capable de chif­frer quelque chose avec ma clef publique, mais seul moi pour­rait le déchif­frer.

La clef RSA fait 2048 bits mais ne vous lais­sez pas impres­sion­ner, ces 2048 bits sont en fait moins robustes que les 256 bits d’AES.

L’ad­mi­nis­tra­teur de l’or­ga­ni­sa­tion récu­père ma clef publique, chiffre la clef d’or­ga­ni­sa­tion à l’aide de ma clef publique, et envoie ça sur le serveur. Quand je voudrais chif­frer ou déchif­frer quelque chose dans l’or­ga­ni­sa­tion, je récu­père la clef d’or­ga­ni­sa­tion chif­frée avec ma clef publique, je la déchiffre avec ma clef privée, et je m’en sers dans mes opéra­tions de chif­fre­ment.

Ok, mais il va me falloir sécu­ri­ser ma clef privée. On a déjà les outils pour ça, il suffit de la chif­frer ! Bitwar­den la chiffre donc avec la clef de chif­fre­ment, celle dont on a déjà parlé plus haut.

On a donc un mot de passe maître qui sert à calcu­ler une clef maîtresse. La clef maîtresse sert à déchif­frer la clef de chif­fre­ment. La clef de chif­fre­ment sert à déchif­frer ma clef RSA privée. La clef RSA privée sert à déchif­frer la clef d’or­ga­ni­sa­tion. La clef d’or­ga­ni­sa­tion sert à chif­frer et déchif­frer les données.

Pfiou! Ça semble long et complexe mais tout utilise toujours le même prin­cipe et la plupart de ces opéra­tions ne servent qu’à l’ini­tia­li­sa­tion logi­ciel quand vous le déver­rouillez.

Rappe­lez-vous, votre clef de chif­fre­ment ne change pas quand vous chan­gez votre mot de passe. Pas besoin donc de chan­ger ou rechif­frer vos clefs RSA non plus.

Et Pass alors ?

Pass fait le choix de sauter tout le chif­fre­ment symé­trique et de n’uti­li­ser que l’asy­mé­trique. Un dépôt contient les clefs GPG de tous les membres (clefs publiques). Chaque fois qu’un mot de passe est chif­fré, il l’est avec toutes ces clefs. Quand un membre veut lire un des mots de passe, il le déchiffre avec sa propre clef privée.

Quand on ajoute un membre, quand on change une clef, il faut tout rechif­frer.

Catégories
Développement informatique

[code] Liste des imports

J’au­rais évité autant que possible il y a 15 ans, aujourd’­hui je suis amou­reux des import expli­cites en début de fichier, sans aucun symbole externe qui ne soit importé expli­ci­te­ment. Pas de symbole chargé ou défini dans un autre fichier magique­ment acces­sible ailleurs, pas même d’import *. Si je m’écou­tais en ce moment je voudrais même impor­ter les types de base du langage.

Mon histo­rique PHP et Ruby m’ont long­temps fait voir l’ab­sence de tout ça comme un avan­tage. Ça n’est vrai qu’a­vec de très bon IDE. En pratique ça ne permet pas de savoir où est défini le symbole, s’il existe vrai­ment, ni de gérer correc­te­ment les conflits de noms et surcharges locales.

Il y a souvent telle­ment peu de modules, classes et fonc­tions externes diffé­rentes dans un fichier bien struc­turé que l’ex­pli­cite apporte bien plus de béné­fices que de péni­bi­lité. Si on dépasse la dizaine c’est le symp­tôme que quelque chose ne va pas par ailleurs


Côté syntaxe j’ap­pré­cie celle de Python qui montre ce qui est impor­tant systé­ma­tique­ment en fin de ligne.

from xxx import A, B, C as D

Les imports Javas­cript sont pratiques mais la partie la plus signi­fi­ca­tive se retrouve en milieu de ligne, pas toujours là où c’est visuel­le­ment le plus iden­ti­fiable (sans comp­ter la dualité entre import A et import { A })


Soyons fous, on pour­rait même impor­ter les objets de base du langage avec un import { String, Integer, Array } from StdLib. On n’en utilise pas plus d’une poignée dans un même fichier. Point bonus si ça permet que "hello", 42, ou [1, 2, 3] soient des raccour­cis de syntaxe vers les classes ainsi décla­rées en haut de fichier et n’uti­lisent pas forcé­ment les classes natives du langage.

import { String, Integer } from Stdlib
import { MyArray as Array } from MaLibPerso
import { MACONSTANTE, MaClasse } from MonAutreLibPerso

Quitte à faire une liste de course, pour­rait-on faire que les imports avec un chemin absolu « /dir/sub/fichier » réfé­rencent la racine du projet et pas la racine du système de fichier ?

Catégories
CSS javascript React

Où je dis du bien du CSS-in-JS

Il n’y a que les imbé­ciles qui ne changent pas d’avis et c’est mon avis depuis toujours

Coluche

J’ai toujours regardé avec dédain les tenta­tives des dev JS pour contour­ner l’écri­ture de CSS mais je commence à consi­dé­rer que les outils de CSS-in-JS type Emotion sont la bonne solu­tion pour les webapp React.


J’ai été inté­gra­teur, à faire de la belle CSS sépa­rée du code HTML. On finit quand même vite par construire des monstres ou se prendre les pieds dans le tapis dès qu’on fait plus de quelques pages types.

Pour résoudre le problème, élimi­nons le. C’est ce que proposent les conven­tions comme BEM. Si je cari­ca­ture, il s’agit prin­ci­pa­le­ment de reti­rer les sélec­teurs CSS un attri­buant une ou plusieurs classes spéci­fiques à chaque contexte. C’est fran­che­ment moche mais ça fonc­tionne.

CSS-Modules va un peu plus loin. Le prin­cipe est le même mais on permet au déve­lop­peur d’uti­li­ser un nommage plus agréable. C’est l’ou­til de géné­ra­tion qui gère la complexité au lieu du déve­lop­peur.


J’avoue que j’aime bien CSS-modules. C’était mon favori jusqu’à présent.

Ça revient à juste gérer un fichier par compo­sant en se limi­tant à des sélec­teurs très simples pour ne pas créer de conflits de spéci­fi­cité. On reste sur du CSS stan­dard et sur une approche proche de mes habi­tudes histo­riques. Mieux : L’in­té­gra­tion peut se faire indé­pen­dam­ment du langage de déve­lop­pe­ment de l’ap­pli­ca­tif.

C’est top mais ça se base sur des compo­sants qui ne bougent pas beau­coup, dont on connait à l’avance tous les états.

Dès qu’il s’agit de cumu­ler plusieurs états, le résul­tat dépend de l’ordre d’écri­ture dans la CSS. Parfois c’est bien prévu, parfois non.

Dès qu’il s’agit de rendre des choses très dyna­miques, il faut de toutes façons sortir des CSS modules. Vous voulez que dans la vue large les items de navi­ga­tion se colorent au survol en fonc­tion de la caté­go­rie desti­na­tion déter­mi­née dyna­mique­ment mais qu’ils utilisent la couleur neutre dans la vue réduite desti­née aux mobiles ? Vous êtes à poil et il va falloir compo­ser avec d’autres façons d’injec­ter des CSS, peut-être même tâton­ner sur les prio­ri­tés entre classes.


Les classes utili­taires et CSS atomiques à la Tachyon sont là pour indus­tria­li­ser en pous­sant encore plus loin.

J’ai une classe par valeur à appliquer : .ms7-ns applique la septième valeur du cata­logue (7) comme taille hori­zon­tale maxi­mum (ms pour max-width) si la fenêtre a une taille supé­rieure au point de rupture « small » (ns pour non-small).

Ça n’offre quasi­ment aucune abstrac­tion utile (unifor­mi­ser les valeurs on a déjà plein d’ou­tils plus effi­caces). C’est vite cryp­tique, lourd, et mons­trueux dès qu’on multi­plie les valeurs et les points de rupture possibles.

Le seul inté­rêt par rapport à écrire direc­te­ment les attri­buts style c’est que ça permet d’ac­cé­der aux media query et aux pseudo-sélec­teurs.

Malheu­reu­se­ment non seule­ment ça ne résout pas les conflits de prio­ri­tés mais ça les empire. Si je spécia­lise un compo­sant exis­tant en y ajou­tant une classe liée à une direc­tive déjà présente, je joue à la roulette russe. Il faut abso­lu­ment que mon compo­sant initial prévoit lui-même tous les cas possibles pour savoir quelle classe injec­ter et ou ne pas injec­ter. Pas d’al­ter­na­tive.

J’ai vrai­ment l’im­pres­sion d’un retour en arrière mons­trueux avec ces CSS atomiques, cumu­ler les défauts sans aucun avan­tage, et c’est proba­ble­ment ce qui m’a fait reje­ter par prin­cipe les CSS-in-JS jusqu’a­lors.


Les CSS-in-JS c’est fina­le­ment pous­ser la logique de Tachyons un cran plus loin. Quitte à déci­der de tout dans le code HTML, autant écrire direc­te­ment les styles à cet endroit là en utili­sant la vraie syntaxe CSS et en y ajou­tant la possi­bi­lité d’ac­cé­der aux media query et aux pseudo-sélec­teurs.

Emotion c’est ça. On est à la croi­sée entre le « j’écris tout dans un attri­but style » et le « j’at­tache un module CSS ».

En fonc­tion­ne­ment basique c’est comme un CSS module sans le sélec­teur. Je donne les direc­tives en CSS on ne peut plus clas­siques et j’ai accès aux media query, aux pseudo-sélec­teurs et aux anima­tions avec une syntaxe proche de ce que font les prépro­ces­seurs habi­tuels (et en phase avec la direc­tion que prend la syntaxe CSS elle-même).

const style = css`
padding: 32px;
background-color: hotpink;
font-size: 24px;
border-radius: 4px;
&:hover {
color: blue;
}
`

Je peux direc­te­ment ajou­ter le résul­tat aux classes CSS de mon compo­sant. Il se char­gera de géné­rer un nom de classe, de créer la CSS corres­pon­dante dans le docu­ment, et de lier les deux, comme avec CSS-Modules.

L’exemple est peu parlant. On a juste l’im­pres­sion d’un CSS-Modules écrit dans le fichier JS.

L’avan­tage c’est que je ne suis pas limité aux valeurs en dur. Je peux avoir des valeurs dyna­miques venant de mon Javas­cript ou de mon thème, et je n’en limite pas les effets à ce que me permettent les variables CSS.

Je peux aussi réuti­li­ser, compo­ser ou surchar­ger un élément ou un bloc de styles avec un autre sans risque de conflit de prio­rité.


Tachyons me donnait l’im­pres­sion de cumu­ler les incon­vé­nients, ici j’ai vrai­ment l’im­pres­sion de cumu­ler les avan­tages.

La seule contrainte c’est que mon code CSS se retrouve dans mes fichiers JS. C’est moche quand c’est dit ainsi mais pour une app en React, on a de toutes façons un fichier par compo­sant HTML et ça a du sens de grou­per HTML, JS et CSS lié au compo­sant ensemble quand ils sont forte­ment liés. C’est d’ailleurs le choix de VueJS.

Ce n’est forcé­ment pas adapté à tout, et si vous voulez rester géné­riques les CSS-Modules sont à mon avis l’op­tion la plus saine, mais pour un code React je crois que c’est là que je commen­ce­rai par défaut désor­mais.

Catégories
git

Les petits plus : gitup

J’ai toujours été gêné par l’in­té­gra­tion de grosses modi­fi­ca­tions dans git.

Dans l’idéal on fait une série de modi­fi­ca­tions auto­nomes, on les soumet à la revue des pairs puis on les intègre dans les branche prin­ci­pale qui peut partir en produc­tion à tout moment.

Ça c’est la théo­rie. En pratique je fais des erreurs que je ne vois qu’à la fin des modi­fi­ca­tions. Mes collègues auront de toutes façons des retours sur ce que j’ai poussé en ligne et me deman­de­ront des modi­fi­ca­tions avant l’in­té­gra­tion finale. Si ce n’est pas le cas au moins une fois sur deux, c’est que nous travaillons mal.

Et là… les ennuis commencent.

Mes modi­fi­ca­tions ne sont plus auto­nomes. J’ai des correc­tifs à la fin. Poten­tiel­le­ment mes modi­fi­ca­tions précé­dentes sont donc incom­plètes, de mauvaise qualité ou même défaillantes. Si j’in­tègre mon code à la fin de la revue, je casse toute la belle théo­rie.

J’ai vu deux pratiques suivant les équipes :

La première pratique c’est d’in­té­grer le code tel quel sur la branche master. C’est ce qui m’ap­pa­rait le plus cohé­rent. Le code de la branche est poten­tiel­le­ment instable mais tous les points d’étape de master sont de qualité. Pour parcou­rir les modi­fi­ca­tions de la branche master on ajoute --merges --first-parent histoire de ne pas voir les modi­fi­ca­tions internes des sous-branches. Ni vu, ni connu mais le débo­gage de la branche après coup en cas de besoin ne sera pas idéal.

L’al­ter­na­tive est de fusion­ner en une seule toutes les modi­fi­ca­tions de la branche lors de son inté­gra­tion. On perd toute la granu­la­rité et ça peut rendre bien plus diffi­cile de tracer l’ori­gine d’une anoma­lie par la suite, ou de comprendre le pourquoi et le comment d’un chan­ge­ment. C’est encore viable sur 100 voire 200 lignes bien grou­pées mais ça devient fran­che­ment liti­gieux au delà.

La seule pratique que je réprouve tota­le­ment est celle du rebase sans squash. On importe tous les chan­ge­ments direc­te­ment sur master et on perd tota­le­ment la capa­cité d’avoir un master stable. Ne faites pas ça.

La troi­sième voie c’est la réécri­ture de l’his­to­rique.

En théo­rie c’est mal, au moins pour les branches déjà publiées. En pratique tant qu’au­cun autre code ne se base dessus, ça ne pose pas vrai­ment de problèmes. Sur des équipes en entre­prise ça se maitrise assez bien. Sur du code open source ça me semble plus liti­gieux. Github le gère parfai­te­ment dans les pull-request en cours de revue.

Les vrais, les purs, le font en ligne de commande. Je suis admi­ra­tif devant ceux qui savent décou­per une modi­fi­ca­tion ou ajou­ter un correc­tif dix chan­ge­ments en arrière dans l’his­to­rique sans réflé­chir ni tout casser. Tech­nique­ment ça ne pose pas vrai­ment de diffi­cul­tés mais c’est long, propice aux erreurs, et le moindre faux pas peut faire de gros dégâts irré­mé­diables. Je ne trouve pas les inter­faces graphiques inutiles pour tout ça.

Et là, merci Patrick, gitup vient désor­mais à ma rescousse. L’in­ter­face est simpliste, pas toujours pratique, mais elle fait ce que je n’ai pas vu ailleurs.

  • Je suis capable de sépa­rer un chan­ge­ment en deux quelle que soit sa posi­tion dans l’his­to­rique ;
  • Je suis capable de dépla­cer un chan­ge­ment en haut ou en bas dans l’his­to­rique d’un simple raccourci clavier ;
  • Je suis capable de faire un correc­tif, le descendre dans l’his­to­rique, puis le fusion­ner avec le chan­ge­ment initial qu’il faut corri­ger.

Tout ça graphique­ment, avec la possi­bi­lité de reve­nir en arrière quand je veux si jamais je fais des bêtises.

Catégories
Architectures ouvertes Geek Humeur Numérique

Éthique et Lima

Le projet Lima s’éteint. C’est dommage. Je suis convaincu que les équipes de Lima ont fait tout ce qu’elles pouvaient pour que ça n’ar­rive pas. Des fois « on n’y arrive pas ». C’est dommage mais c’est ainsi et on doit plutôt remer­cier les gens d’avoir essayé.

Les appa­reils concer­nés vont à terme deve­nir inuti­li­sables. C’est un bon exemple de « n’uti­li­sez pas d’ap­pa­reils connec­tés qui dépendent d’un service centra­lisé » mais à mon sens la leçon n’est pas celle là.

Je n’aime pas tirer sur l’am­bu­lance mais mon problème est un problème éthique.

What happens if CGC dies ?

What’s good with Lima is that it’s enti­rely private and decen­tra­li­zed. So Lima can work inde­pen­dently from any servers, and conti­nue mana­ging your data even if our star­tup dies (disclo­sure: we don’t plan anything like that)

The only thing we manage on our side of the equa­tions are updates of our app and the web inter­face of Lima. In case of company crash, we’ll do our best to open source at least the most criti­cal parts of our code, so the commu­nity conti­nues impro­ving the solu­tion every night.

FAQ sur la page Kicks­tar­ter, le 6 août 2013

La dispa­ri­tion de l’en­tre­prise a été envi­sa­gée dès le début de l’aven­ture (c’est bien) et des éléments de réas­su­rance ont été posés (c’est bien aussi, même si ce n’est que du best effort).

J’ai un problème éthique parce que toutes les équipes de Lima, des fonda­teurs jusqu’aux déve­lop­peurs ont accepté de poser ces éléments de réas­su­rance alors qu’ils semblent faux.


En pratique le serveur de l’in­fra­struc­ture Lima est un compo­sant essen­tiel et les boitiers vont progres­si­ve­ment arrê­ter de fonc­tion­ner. Ce n’est pas moi qui le dit, c’est Lima eux-mêmes. Là on est dans la trom­pe­rie pure et simple par rapport à la promesse affi­chée.

While your Lima product synchro­nises with your devices without servers, our servers are still needed to make your devices find each other and esta­blish a connec­tion.

Unfor­tu­na­tely, as our services shut down, your Lima will progres­si­vely stop to work.

This time, it’s Good­bye. Page d’ac­cueil Lima

La promesse de l’open source est simi­laire. En pratique il est impos­sible de passer le code open source une fois la société en liqui­da­tion. C’est confirmé par les réponses sur Twit­ter.

C’est simple­ment légal. Les action­naires perdent le contrôle de la société et le liqui­da­teur a l’obli­ga­tion légale de tirer le maxi­mum des posses­sions de la société. Ça inclut le code source et la propriété intel­lec­tuelle. Libé­rer le code source gratui­te­ment n’est léga­le­ment plus possible.

Le problème c’est que ce n’est pas une surprise.

Il aurait fallu s’y prendre avant le début des diffi­cul­tés. Il aurait fallu dépo­ser le code source régu­liè­re­ment chez un tiers de confiance et s’en­ga­ger contrac­tuel­le­ment avec lui sur une cession de droits qui ne devien­dra effec­tive qu’à certaines condi­tions pré-établies.

Même si la FAQ parle de « do our best », on est dans la trom­pe­rie. Il n’est pas imagi­nable que la ques­tion ait été abor­dée dans la FAQ et que les colla­bo­ra­teurs de l’en­tre­prise aient pu igno­rer les enjeux ci-dessus. Ils semblent pour­tant ne rien avoir prévu, consciem­ment, et avoir parti­cipé là aussi à un déca­lage signi­fi­ca­tif entre le discours et les actions.


J’en veux aux déve­lop­peurs qui ont parti­cipé à ça, et qui vont mettre le doute sur tous les autres.

Déve­lop­peurs, vous ne devriez pas mettre l’éthique de côté. Vous ne devriez pas appor­ter votre concours à des socié­tés qui trichent, qui trompent, peu importe le degré de cooli­tude du produit ou du service.

Catégories
Méthodes agiles scrum

Les esti­ma­tions de petites tâches ne sont pas plus précises

Un des premiers mensonges qu’on vous livre trop souvent avec SCRUM c’est qu’on peut esti­mer des petites tâches avec bien plus de préci­sion que des grandes, et qu’en consé­quence on peut être assez fiable dans l’es­ti­ma­tion des une à trois semaines de chaque itéra­tion.

Foutaises !

Combien de temps faut-il pour mettre les blou­sons avant d’al­ler à l’école ? Mettons 30 secondes si on ne se presse pas. La réalité c’est que ça mettra plus souvent 5 minutes que 30 secondes, et ça c’est si on n’a pas besoin de se battre.

400% de marge d’er­reur ? Comment voulez-vous faire un plan­ning avec de telles esti­ma­tions. Pour­tant on est sur une tâche connue, répé­tée chaque jour. Seule solu­tion, on triche et on compte 2 minutes 30. Même ainsi on a une marge d’er­reur de 100%. Hallu­ci­nant !

Ce n’est pas un exemple choisi. J’ai le même problème pour termi­ner la tartine, pour boire le verre d’eau ou pour passer aux toilettes avant de partir, pour descendre dans la rue, pour faire le trajet, pour trou­ver le badge et passer le portail de l’école, pour montrer ma carte au vigile, pour les 10 mètres dans l’école au milieu des copains et autres parents d’élèves, pour le bisou de bonne jour­née avant de pouvoir repar­tir…

Ce n’est pas non plus la faute d’une mauvaise analo­gie. Esti­mer une petite tâche est juste impos­sible parce que le moindre aléa fait tout explo­ser.

Ajou­ter un lien sur une page ça prend 30 secon­des… sauf si on vous dit de chan­ger l’URL au dernier moment et qu’il faut faire deux fois le travail, sauf si c’est le seul lien à cet endroit et qu’il faut retou­cher les règles de style, sauf si le lien passe à la ligne en plein milieu et que visuel­le­ment ça ne le fait pas du tout sur ce compo­sant, sauf si l’es­pace pris fait glis­ser le bouton qui suit sous le clavier sur un smart­phone une fois le clavier déplié, sauf s’il faut partir à la chasse de la bonne URL parce que c’était « ça n’a pas d’im­pact, on donnera le lien au dernier moment », sauf si on se rend compte qu’il faut mutua­li­ser ce lien avec autre chose ailleurs dans l’ap­pli­ca­tion, sauf si ajou­ter un lien casse le test end-to-end et qu’il faut le réécrire pour faire passer le serveur d’in­té­gra­tion conti­nue au vert, sauf si… pour un simple foutu lien !


Et pour­tant, on n’est jamais en retard à l’école. Malgré les aléas infi­nis à chaque tâche, le projet « aller à l’école » prend 45 minutes à ±15 minutes. Pas plus.

Ce n’est même pas qu’es­ti­mer le projet dans son ensemble permet de lisser les risques de déra­pages, c’est que le temps que prend chaque tâche dépend de toutes les tâches précé­dentes et des options qu’il nous reste pour les suivantes.

S’il faut lutter pour termi­ner le crois­sant alors on active sérieu­se­ment la suite. Si les toilettes s’éter­nisent je prépare le blou­son et le bonnet pendant ce temps. S’il le faut on presse un peu le pas. À l’école, si on arrive dans les derniers, aucun parent d’élève ou cama­rade ne nous retient dans les dix derniers mètres et le bisou sera vite fait. Si vrai­ment on est super en retard on peut toujours sortir le vélo ou prendre le tram.


En réalité si SCRUM estime les fonc­tion­na­li­tés unitaires ce n’est pas pour s’en­ga­ger sur un résul­tat donné à l’avance, ni même pour mesu­rer si l’ité­ra­tion a été une réus­site ou un succès lors de la rétros­pec­tive. C’est unique­ment pour savoir où on va dans la boîte de temps qu’on s’est donnée. Rien de plus.

Quand on vous dit que ça permet d’être plus fiable, derrière se cache l’hydre du « on va trans­for­mer vos esti­ma­tions en enga­ge­ment » voire du « on va ajou­ter vos esti­ma­tions une à une et ça donnera la dead­line de fin de projet si rien ne change ».

Catégories
Fournisseurs d'accès Internet Geek

Ne fais pas atten­tion au débit de ta fibre

Ami, tu viens d’être éligible à la fibre ou de démé­na­ger là où la fibre est présente. Tu cherches un opéra­teur.

Ne fais pas atten­tion au débit. Si tu viens de l’ADSL ça va être le jour et la nuit quoi que tu choi­sisses comme offre fibre. Tu auras des offres allant de 200 Mb/s à 10 Gb/s, à compa­rer à ton ADSL qui se situe quelque part entre 8 et 20 Mb/s en descen­dant et au mieux 1 Mb/s en montant.

En réalité tu ne verras pas de diffé­rence signi­fi­ca­tive au jour le jour entre les offres à 300 Mb/s et les offres à 1 Gb/s. Tu n’at­tein­dras de toutes façons que rare­ment de tels débits de toutes façons. Ne parlons même pas du 10 Gb/s, là on est dans du marke­ting.

Regarde tout le reste : la qualité de la box, regarde le prix initial mais aussi si ce n’est pas une offre promo­tion­nelle pour les 12 premiers mois qui va doubler au bout d’un an, regarde les frais d’ins­tal­la­tion ou de rési­lia­tion, regarde s’il y a une offre TV qui te corres­pond, regarde les délais habi­tuel de l’opé­ra­teur pour les instal­la­tions, regarde la qualité de leur support client, etc. Tout ça a bien plus d’im­por­tance que le débit des offres fibre, et te touchera de façon bien plus forte.


La réalité est plus complexe que le dépliant du four­nis­seur d’ac­cès

On a tous envie de se dire qu’entre 10 Gb/s (10 000 Mb/s) et 300 Mb/s, ça se voit un peu quand même. La réalité est plus complexe. Ce chiffre ne reflète que le débit théo­rique entre la box et le four­nis­seur d’ac­cès.

Déjà chez toi : Si tu es sur WIFI, tu peux oublier l’idée d’al­ler à plus de 500 Mb/s en pratique même en t’as­seyant juste à côté de ta box. Pour aller plus loin il faudrait un câble ether­net. Ils sont déjà loin les 10 Gb/s. En réalité sur un appar­te­ment un peu bruité, avec un peu de distance, c’est déjà très bien si on arrive à faire du 300 Mb/s en pratique. Ne parlons même pas d’avoir un mur entre le poste infor­ma­tique et la box. Si c’est pour travailler à partir d’une carte SD tu n’ap­pro­che­ras de toutes façons même pas les 100 Mb/s.

Ensuite en face : Non le serveur d’en face ne te permet­tra géné­ra­le­ment pas d’échan­ger en Gb/s de toutes façons. Même 300 Mb/s tu ne le trou­ve­ras pas si souvent. On en est au point où régu­liè­re­ment il y a des bisbilles avec Youtube, Netflix et les autres parce que les échanges entre eux et les four­nis­seurs d’ac­cès ne dépassent pas la dizaine de Mb/s aux heures de pointe.

Et de toutes façons sur l’usage : Les hauts débits se trouvent quand tu télé­charges un gros contenu de façon soutenu. Tu envoies des fichiers de quelques Mo ou moins ? le temps sera plus dépen­dant du nombre de fichiers que de la bande passante dispo­nible. Tu fais de la navi­ga­tion web ? à ces vitesses le temps d’af­fi­chage dépend bien plus du déve­lop­peur du site que de la capa­cité de ta ligne.

Et fais atten­tion à SFR : Si tu démé­nages dans un appar­te­ment exis­tant et que ni Orange ni Free ne proposent pas d’offre fibre pour ton appar­te­ment, il est probable que ton immeuble soit câblé et non fibré (oui, même si SFR conti­nuera à te dire que c’est de la fibre). Tu peux le véri­fier faci­le­ment : Si ça ressemble à une prise d’an­tenne TV, que ça a un diamètre plus proche d’un câble d’an­tenne TV que d’un petit cable USB, c’est du câble coaxial et pas de la fibre.

Là (coaxial SFR) toutes les instal­la­tions ne sont pas équi­va­lentes. Certaines montent effec­ti­ve­ment jusqu’à 1 Gb/s, d’autres non. Tu auras souvent toutes les peines du monde à obte­nir le vrai chiffre de la part de leur service commer­cial qui te servira du « jusqu’à 1 Gb/s » ad libi­tum . Bref, ache­ter une offre plus chère afin d’avoir un plus haut débit théo­rique et remarquer que c’est fina­le­ment bridé par l’ins­tal­la­tion en place, ça serait dommage.


Je ne dis pas que tu ne dépas­se­ras jamais les 300 Mb/s mais ça ne repré­sen­tera pas ton quoti­dien. Même s’il t’ar­rive de télé­char­ger des conte­nus vidéos ou des grosses archives à partir d’un ordi­na­teur bran­ché par câble, la diffé­rence entre 300 Mb/s et 1 Gb/s, c’est télé­char­ger un DVD complet en envi­ron 100 secondes au lieu de 30. Je doute que l’at­tente supplé­men­taire soit de nature à influen­cer sur le choix de l’offre Inter­net.

Si vrai­ment tu veux regar­der le débit, regarde le débit montant

Le débit descen­dant c’est celui que tu utilises pour télé­char­ger quelque chose en prove­nance d’In­ter­net. C’est celui qui est géné­ra­le­ment mis en avant parce que le plus gros des deux.

Celui qui peut t’in­té­res­ser c’est le second, qui sert à envoyer des conte­nus vers Inter­net. Il doit t’in­té­res­ser parce qu’il est géné­ra­le­ment bien plus petit.

Ce n’était pas impor­tant sur ADSL parce que le débit ne te permet­tait pas grand chose d’autre que du descen­dant. Avec la fibre tu vas proba­ble­ment bran­cher un Google Drive, un Drop­box, peut-être un logi­ciel de sauve­garde. Tu vas vouloir envoyer d’énormes photos voire des vidéos ou de mons­trueux docu­ments bureau­tiques pas opti­mi­sés. Bref, l’usage va chan­ger et ce serait dommage d’avoir un débit trop ridi­cule en montant.

Entre le 200 (descen­dant) / 50 (montant) de SFR et le 300 (descen­dant) / 300 (montant) de Sosh, tu as beau­coup plus de chances de ressen­tir la diffé­rence de débit montant que la diffé­rence de débit descen­dant (même si 50 Mb/s en montant ça reste 50 fois mieux que ce que tu avais en ADSL, et pas ridi­cule du tout, donc pas forcé­ment le critère).