Upgrade to Pro — share decks privately, control downloads, hide ads and more …

TLS RSA AES WTF

TLS RSA AES WTF

Vous avez tous entendu parler de SHA et bien entendu vous avez aussi sécurisé votre application avec un certificat SSL. Mais savez vous comment ces algorithmes vous protègent ? Nous allons nous plonger dans les mécaniques qui sécurisent nos données. Sont elles vraiment efficaces ? Ensemble éclaircissons notre connaissance des systèmes de sécurité que nous utilisons chaque jour.

B473bd9d058c922e08d57f39a4a861db?s=128

Grégoire Hébert

January 28, 2020
Tweet

Transcript

  1. @gheb_dev @gregoirehebert TITRE_FINAL_FINAL_2.ai

  2. @gheb_dev @gregoirehebert Grégoire Hébert Senior Developper — Trainer — Lecturer

    @ Les-Tilleuls.coop
  3. @gheb_dev @gregoirehebert EndtoEndEncryption

  4. @gheb_dev @gregoirehebert EndtoEndEncryption Est-ce réalisable ?
 Est-ce fiable ?

  5. @gheb_dev @gregoirehebert EndtoEndEncryption Oui.

  6. @gheb_dev @gregoirehebert THANK YOU!

  7. @gheb_dev @gregoirehebert

  8. @gheb_dev @gregoirehebert EndtoEndEncryption Lorsqu'il s'agit d'échanges de données sur les

    réseaux, que ce soit sms, email, chat… On peux vouloir empêcher que quiconque puisse y accéder qui ne soit pas notre destinataire. On peux alors imaginer un système si parfait que personne d’autre que votre destinataire puisse déchiffrer vos messages. Sauf qu'il y a eu des précédents où des réseaux terroristes et organisations criminelles utilisent ces systèmes.
  9. @gheb_dev @gregoirehebert EndtoEndEncryption Si on penses aux crimes, évidement que

    ce genre de mécanisme est absolument inadmissible, mais parce que le crime est inadmissible. Mais est-ce qu'une protection 100% sure de bout en bout est vraiment réalisable?
  10. @gheb_dev @gregoirehebert EndtoEndEncryption Admettons que oui. Si l’on voulait un

    moyen de garantir qu’un utilisation a des fin criminelle puisse être détectée et exploitable.
  11. @gheb_dev @gregoirehebert EndtoEndEncryption Il faudrait une délégation de la transmission

    via une autorité reconnue pour contrer les mauvais usages, avec un serveur intermédiaire. Pour se protéger et éviter qu'une personne ne soit capable d'écouter les échanges sur le réseau et puisse lire nos messages, nous allons chiffrer nos message à l'aide d'une clé. 
 
 En fait 2 clés. Une entre nous et le serveur, et une entre le serveur et la personne avec qui nous discutons. Ce qui fait que si un mandat juridique ordonne la récupération de messages auprès de cette autorité surgit, il sera possible d'accéder aux dits messages.
  12. @gheb_dev @gregoirehebert EndtoEndEncryption Alors l'argument évident en ce sens, serait

    que nous n'avons rien à cacher de toute façon! Sauf que de fait ce serveur est un énorme point de vulnérabilité. Et si on pouvait éviter que nos échanges soient divulgués publiquement, fappening, finalement là on a envie de se protéger sur toute la ligne.
  13. @gheb_dev @gregoirehebert EndtoEndEncryption WhatsApp - Signal - Messenger Alors aujourd'hui

    on va le vouloir ce chiffrage de bout en bout. Il existe déjà des services de messageries comme WhatsApp ou Signal (qui en passant n'utilise pas qu'une seule clé mais plusieurs) qui encode vos messages en bout en bout. Messenger de Facebook aussi, mais il faut l'activer. Alors si vous ne l'avez pas encore fait prenez un instant :) Enfin avant de rentrer dans le technique il reste un dernier point de vulnérabilité, et il est entre vos mains parce que pour que vous ayez une expérience utilisateur acceptable, tout est décodé au moment ou vous recevez le message, donc il ne vous reste plus que votre code pin, pulpe de votre doigt ou fond d'iris pour vous protéger. Si quelqu'un venait à vous piquer votre téléphone ou ordinateur, c'est fichu. Les points les plus faibles sont les endpoints. Bon alors comment ça marche cette protection?
  14. @gheb_dev @gregoirehebert TLS Transport Layer Security Secure Sockets Layer,

  15. @gheb_dev @gregoirehebert TLS

  16. @gheb_dev @gregoirehebert RSA TLS Le but de TLS est de

    protéger les échanges sur le web et dans certaines implémentations, de garantir l'intégrité des données. L'algorithme se découpe principalement en 3 moments distincts. Le premier consiste entre 2 parties de choisir une méthode d'échange de clés.
  17. @gheb_dev @gregoirehebert DES DES TLS Le second consiste en chiffrer

    les données échangées. Il y a quelques temps était utilisé le DES (Data encryption standard) qui chiffre sur 56bits.
  18. @gheb_dev @gregoirehebert 3DES 3DES TLS Qui est maintenant devenu obsolète.

    Alors est apparu le 3DES ! Qui triple la longueur. Cependant il reste vulnérable aux attaques par collision.
  19. @gheb_dev @gregoirehebert AES AES TLS Il a fallu développer un

    nouveau standard plus sécurisé, le nommé AES (Advanced Encryption Standard).
 
 Et enfin dernière étape, vérifier l'intégrité des données. La plupart du temps on utilisera HMAC ou MD5 pour hacher les données et comparer que les hash sont identiques. Les versions modernes de TLS utilisent AEAD (Authenticated Encryption with Associated Data) et ajoutent un MAC (un Message Authentication Code) dans le message afin d'en garantir l'authenticité.
  20. @gheb_dev @gregoirehebert HACHER vs CHIFFRER TLS Pour créer un certificat

    TLS, vous avez 2 solutions. Soit vous faites appel à une autorité qui créera les certificats vous en fournira un à déposer sur votre/vos serveurs et validera que vous êtes bien le possesseur du site à protéger. Lorsque votre navigateur réclamera le site internet au lieu du port 80 (port par défaut de http) il sera servi sur le port 443. Le navigateur tâchera de regarder si un certificat répondant à celui défini sur le serveur existe dans sa base de données, dans le cas contraire il contactera les services d’autorité pour prouver l’appartenance du certificat. En cas d'échec il considèrera que le certificat est auto-signé.
 Autre alternative, c'est de générer vous même le certificat avec let's encrypt. Le but n'est pas de se pencher sur la manière d'enregistrer un certificat il y a tout ce qu'il faut sur les internets. Nous allons nous pencher sur les mécaniques derrière TLS. 2 grandes méthodes sont utilisées dans TLS. RSA et Diffie-Hellmann.
  21. @gheb_dev @gregoirehebert HACHER vs CHIFFRER Pardon de repasser par cette

    étape scolaire mais je sais bien qu'on a tous nos anglicismes et notre vocabulaire alors je voulais m'assurer que l'on parle bien de la même chose pour toute la durée du talk.
  22. @gheb_dev @gregoirehebert HACHER MD5 SHA-1 SHA-2 SHA-3 HACHER vs CHIFFRER

    Un hachage est une chaîne ou un nombre généré à partir d'une chaîne de texte. La chaîne ou le nombre qui en résulte est d'une longueur fixe, et dont la sortie variera considérablement même avec un minimum de changement dans la chaîne d'entrée. Principe important c'est que pour une entrée donnée, la sortie sera toujours la même. (MD5, SHA, SHA-2, SHA-3) Un bon algorithme de hachage, est un algorithme dont on ne peux pas inverser le processus, qui va vite et sans collision.
  23. @gheb_dev @gregoirehebert CHIFFRER Clé symétrique ou Clé publique HACHER vs

    CHIFFRER Le chiffrage transforme les données en une série de caractères, qui ne sont pas d'une longueur fixe. Et lorsque l’on chiffre une chaîne, le processus peut être inversées si vous avez la bonne clé pour déchiffrer.
 Il existe deux principaux types de chiffrage, le chiffrage par clé symétrique et le chiffrage par clé publique. Dans le chiffrage à clé symétrique, la clé de chiffrage et de déchiffrage est exactement la même. C'est ce à quoi la plupart des gens pensent quand ils pensent au cryptage.
  24. @gheb_dev @gregoirehebert CHIFFRER Clé publique HACHER vs CHIFFRER Le chiffrement

    à clé publique par comparaison a deux clés différentes, l'une utilisée pour chiffrer la chaîne (la clé publique) et l'autre pour la déchiffrer (la clé privée). La clé publique est mise à la disposition de tous pour chiffrer les messages, mais seul le destinataire prévu a accès à la clé privée, et donc la possibilité de déchiffrer les messages. (AES, PGP)
  25. @gheb_dev @gregoirehebert HACHER vs CHIFFRER Chaine incomprehensible
 longueur fixe
 Irréversible

    Chaine incomprehensible
 Longueur variable
 reversible Pour résumer :
 Le hachage est un moyen idéal de stocker les mots de passe, car les hachages sont unidirectionnels par nature.
  26. @gheb_dev @gregoirehebert RSA En parlant de TLS, j’ai cité 2

    méthodes. On va commencer par RSA. RSA est issue de ce que l’on appelle un algorithme de chiffrage asymétrique. Entre 2 valeurs générées, laquelle est la publique, laquelle est la privée. Tant qu'aucune n'est partagée, les 2 peuvent assumer les 2 rôles. Parce que c’est le principe du chiffrement asymétrique de pouvoir effectuer le chiffrage déchiffrage peu importe la clé utilisée. 
 Si quelqu’un m’envoie un message chiffré avec la clé publique, seul moi qui possède la clé privée peux le lire. 
 Si j’envoie un message chiffré avec ma clé privée, tout le monde peux lire le message, mais seul moi ai pu l’écrire et personne d’autre. 
 
 Le top c’est si je combine les 2. Je chiffre avec ma clé privée, puis avec la clé publique de mon interlocuteur. Seul le destinataire peux décoder et il est certains que c’est moi l’auteur.
  27. @gheb_dev @gregoirehebert RSA

  28. @gheb_dev @gregoirehebert p = un nombre premier
 q = un

    nombre premier
 n = p × q RSA Pour générer les clés on sélectionne 2 nombre premiers (p et q) de très grande taille. Suffisamment pour qu’après avoir multiplié les 2 valeurs entre elles, il soit impossible de retrouver d’aucune manière les 2 nombres d’origine. 
 on notera le résultat du produit n. ce produit est publique. Et c'est un énorme nombre.
  29. @gheb_dev @gregoirehebert ϕ(n) = (p − 1)(q − 1) RSA

    L'étape suivante consiste à calculer le totien, c'est le nombre d'éléments dans n qui ne peuvent être divisés que par 1 ou eux même. On le note ϕ.

  30. @gheb_dev @gregoirehebert RSA 3 < Nombre Premier < ϕ(n) Clé

    publique Pour calculer la clé publique on cherche un nombre premier situé entre 3 et ϕ(n) n’ayant aucun diviseur commun avec ϕ(n) .
 On a donc notre clé publique.
  31. @gheb_dev @gregoirehebert RSA (Clé privée*Clé publique) mod ϕ(n) = 1

    Pour calculer la clé privée il faut trouver ce qu’on appelle le multiplicateur inverse avec l’algorithme d’euclide étendu. 
 On va trouver une valeur telle que son produit avec la clé publique résulte en un nombre qui vérifie 1( mod ϕ(n)).
  32. @gheb_dev @gregoirehebert RSA Exemple et p = 11 q =

    13 Choisissons deux nombres premiers : p=11 et q=13.
  33. @gheb_dev @gregoirehebert RSA Exemple et 
 p = 11 q

    = 13 n = p . q = 143 La valeur publique est donc n=p×q=143.
  34. @gheb_dev @gregoirehebert RSA Exemple et 
 
 p = 11

    q = 13 n = p ⋅ q = 143 ϕ(n) = (p − 1) ⋅ (q − 1) = 120 Le totient de n est ϕ(n)=(p-1)⋅(q-1)=120.
  35. @gheb_dev @gregoirehebert RSA Exemple et 
 
 
 
 clé

    publique p = 11 q = 13 n = p ⋅ q = 143 ϕ(n) = (p − 1) ⋅ (q − 1) = 120 e = 7 Pour la clé publique, on choisit un nombre premier aléatoire qui a le plus grand diviseur commun (gcd) de 1 avec ϕ(n) et qui est inférieur à ϕ(n). Choisissons 7.
  36. @gheb_dev @gregoirehebert RSA Exemple et 
 
 
 
 clé

    publique 
 clé privée p = 11 q = 13 n = p ⋅ q = 143 ϕ(n) = (p − 1) ⋅ (q − 1) = 120 e = 7 d = 103 Pour déterminer d, la clé privée, il faut trouver l'inverse de 7. On utilise l'Algorithme d'Euclide Etendu, et donc d=103.
  37. @gheb_dev @gregoirehebert RSA Exemple et 
 
 
 
 clé

    publique 
 clé privée 
 
 
 p = 11 q = 13 n = p ⋅ q = 143 ϕ(n) = (p − 1) ⋅ (q − 1) = 120 e = 7 d = 103 (e ⋅ d)modϕ(n) = 1 (7 ⋅ 103)mod120 = 721mod120 = 1 Ceci peut être vérifié avec : e⋅d = 1 mod ϕ(n) 7⋅103 = 721 = 1 mod 120.
  38. @gheb_dev @gregoirehebert RSA Exemple et 
 
 
 
 clé

    publique 
 clé privée 
 
 
 p = 11 q = 13 n = p ⋅ q = 143 ϕ(n) = (p − 1) ⋅ (q − 1) = 120 e = 7 d = 103 (e ⋅ d)modϕ(n) = 1 (7 ⋅ 103)mod120 = 721mod120 = 1 Notre message m a une valeur 
 numérique de 9
 
 
 
 c = memodn = 97mod143 = 48 m = cdmodn = 48103mod143 = 9 encode decode Décoder le message
  39. @gheb_dev @gregoirehebert RSA Avantages
 &
 Inconvénients Mathématiquement, tant qu’on na

    pas trouvé de moyen de remonter la piste de la multiplication des nombres premiers, on est protégé.
 Mais pour que ça fonctionne, il faut manuellement communiquer la clé publique.
 Et si on avait une procédure qui permette d'échanger les clés sans intervention humaine ?
  40. @gheb_dev @gregoirehebert KEY EXCHANGE
 Diffie-Hellmann Bon déjà le nom est

    trompeur parce qu'on ne partage pas vraiment les clés telles quelles. On va plutôt échanger des valeurs publiques combinées avec des valeurs privées pour créer une clé commune.
  41. @gheb_dev @gregoirehebert KEY EXCHANGE
 Diffie-Hellmann Pour bien appréhender la suite,

    voici l'analogie la plus fréquente. celle de la peinture, parce qu'une fois mélangée il n'est pas possible de retrouver précisément les teintes d'origine.
 Nous allons avoir chacun une couleur en commun et chacun une couleur privée. Chacun mélange lees 2 couleurs qu’il possède et on se les échange.
  42. @gheb_dev @gregoirehebert KEY EXCHANGE
 Diffie-Hellmann Ajoutons chacun notre couleur privée

    dans le mélange de l’autre et nous obtenons la même couleur. Que seul nous 2 pouvons obtenir.
 

  43. @gheb_dev @gregoirehebert KEY EXCHANGE
 Diffie-Hellmann Avant tout il va falloir

    que les 2 parties se mettent d'accord sur 2 choses, un "générateur" et un nombre premier très grand n, histoire qu’on calcule la même chose. Alice possède une clé A privée et Bob une clé B, privée également. Alice et Bob vont utiliser le générateur pour produire une clé publique.
  44. @gheb_dev @gregoirehebert KEY EXCHANGE
 Diffie-Hellmann Alice Bob A g et

    n Prenons une exemple de séquence.
  45. @gheb_dev @gregoirehebert KEY EXCHANGE
 Diffie-Hellmann Alice Bob A g et

    n B Chacun possède sa clé privée.
  46. @gheb_dev @gregoirehebert KEY EXCHANGE
 Diffie-Hellmann Alice Bob A g et

    n B Ag Bg On génère les clés publiques.
  47. @gheb_dev @gregoirehebert KEY EXCHANGE
 Diffie-Hellmann Alice Bob A g et

    n B Ag Bg ces deux valeurs sont échangées publiquement.
  48. @gheb_dev @gregoirehebert KEY EXCHANGE
 Diffie-Hellmann Alice Bob A g et

    n B Ag Bg Alice et Bob vont respectivement utiliser celle de l’autre
  49. @gheb_dev @gregoirehebert KEY EXCHANGE
 Diffie-Hellmann Alice Bob A g et

    n B ABg ABg Alice va ajouter A, à Bg, et Bob va ajouter B à Ag. On va obtenir des 2 côtés une clé conçu depuis A, B et g.
  50. @gheb_dev @gregoirehebert KEY EXCHANGE
 Diffie-Hellmann Alice Bob A g et

    n B ABg ABg Ag Bg ABgg Sans les clés privés on peux obtenir éventuellement ABgg mais pas ABg.
 En 3 passes on a maintenant une clé privée que seul les 2 interlocuteurs connaissent. On va vouloir faire ça au début de chaque échange" privés.
 
 Pour sécuriser le tout encore plus, dans les méthodes modernes que l'on utilise, on va également y ajouter des données variables pour obtenir un nombre qui sera haché pour être utilisé comme clé secrète, pour embrouiller encore plus le résultat. On retrouve ceci dans les algorithmes de chiffrage comme AES.
  51. @gheb_dev @gregoirehebert KEY EXCHANGE
 Diffie-Hellmann Maths Maintenant que le principe

    est connu, Allons couvrir les maths.
  52. @gheb_dev @gregoirehebert KEY EXCHANGE
 Diffie-Hellmann Alice Bob g et n

    Dans le domaine publique il y a g et n. g est un nombre premier, souvent petit. 
 n est un grand nombre premier. souvent autour de 2000bits, mais de plus en plus autour de 4000bits. 
 Alors Grand oui mais il ne peux pas être trop grand, sinon on perds en rapidité de calcul ce quel l'on a gagné en sécurité, il faut un juste milieu, d'ou l'importance du choix de n, même si techniquement, on peux trouver la valeur, ça prendrait tellement de temps qu'on a aucun intérêt de ne serait-ce qu'essayer.
  53. @gheb_dev @gregoirehebert KEY EXCHANGE
 Diffie-Hellmann Alice Bob A g et

    n Ak = gAmodn Alice calcule, Ak = g^A mod n. modulo c'est le restant de la division.
  54. @gheb_dev @gregoirehebert KEY EXCHANGE
 Diffie-Hellmann Alice Bob A g et

    n Ak = gAmodn n 12… Si on devait le rendre visuel, modulo est un cercle de valeur et nous allons faire autant de tours que possible avant d'arriver à la valeur désirée. Donc on va élever une valeur à une puissance monstrueusement grande, mais au final avec modulo on va restreindre le résultat dans l'espace qu'autorise n. Donc selon les facteurs initiaux il y a plusieurs possibilités d'obtenir le même résultat, et c’est ce qui rends très difficile la possibilité de retrouver la valeur de A. 
 Le seul moyen ce serait de brute-forcer les résultats et vous êtes pas couchés.
  55. @gheb_dev @gregoirehebert KEY EXCHANGE
 Diffie-Hellmann Alice Bob A g et

    n Bk = gBmodn B Bob va calculer Bk = g^B mod
  56. @gheb_dev @gregoirehebert KEY EXCHANGE
 Diffie-Hellmann Alice Bob A g et

    n Bk B Ak Ces 2 valeurs sont partagées publiquement.
  57. @gheb_dev @gregoirehebert KEY EXCHANGE
 Diffie-Hellmann Alice Bob A g et

    n Bk B Ak BkAmodn AkBmodn Alice va exécuter à nouveau le calcul mais avec la clé de bob
 et vice versa.
  58. @gheb_dev @gregoirehebert KEY EXCHANGE
 Diffie-Hellmann Alice Bob A g et

    n Bk B Ak BkAmodn AkBmodn = Clé privée = Ce qui donnera le même résultat. Ils ont donc la même clé privée en leur possession, pour chiffrer leurs échanges.
  59. @gheb_dev @gregoirehebert KEY EXCHANGE
 Diffie-Hellmann
 LIMITS La problématique de l'échange

    de clé c'est qu'il faut avoir confiance dans votre réseau internet.
  60. @gheb_dev @gregoirehebert KEY EXCHANGE Diffie-Hellmann LIMITS Si quelqu'un a la

    maitrise du réseau, il se positionne en tant qu'intermédiaire. Lorsque votre navigateur soumet les requêtes d'échanges de clés, l'attaquant peux intercepter le message, générer une clé privée et soumettre la clé publique à votre navigateur. D'un point de vue réseau aucune raison de douter qu'il ne puisse pas s'agir du serveur visé initialement. Il va ensuite demander au serveur visé d'établir un échange de clés à la place de votre navigateur. Il est maintenant capable de décoder vos messages et en faire ce qu'il veux avant de les envoyer au serveur et de vous renvoyer la réponses (en prenant soins soit d'enregistrer la réponse voir même de la modifier à votre insu). C'est un gros problème parce que Diffie-Hellmann ne permet pas de prévenir ce genre d'attaque et que votre téléphone essaie systématiquement de se connecter à un réseau publique connu ou un réseau privé déjà enregistré. il est assez facile via des outils comme shodan.io de détecter le matériel utilisé et de tenter les accès par défaut du-dit router… Méfiez vous des réseaux publiques.
  61. @gheb_dev @gregoirehebert KEY EXCHANGE Diffie-Hellmann LIMITS Key pair avec Alice

    Key pair avec Bob C'est là que RSA entre en jeu. Puisque qu'il n'est possible de décoder un message chiffré avec la clé privée uniquement avec la clé publique associée, le serveur va utiliser la clé privée pour chiffrer le résultat du nombre premier passé dans le générateur. Si je suis capable de déchiffrer, je suis donc certain que le message provient bien du destinataire. Si on considère bien sûr que la clé privée n'ai pas été rendu publique par erreur.
 
 Il y a toujours un risque bien, sûr alors il existe plusieurs variations de cet algorithme. Dans certains les clés sont renouvelés de manières régulière. Pour ajouter encore en complexité, il est possible de retrouver également des mécanismes ou l'on signe le message, pour cela on va générer un hash.
  62. @gheb_dev @gregoirehebert HASH

  63. @gheb_dev @gregoirehebert HASH SHA1 Tous le monde connais SHA 1

  64. @gheb_dev @gregoirehebert HASH SHA1
 secure hashing algorithm secure hashing algorithm

    Ce qui est amusant puisqu'il n'est plus assez "secure".
  65. @gheb_dev @gregoirehebert HASH SHA1
 secure hashing algorithm
 
 2005 ->

    2,7milliard d’€ en matériel Des recherches ont démontrés des failles dans l'algorithme, dès 2005. mais pas de souci, car avec les technologies de l'époque, il fallait injecter l'équivalent de 2,7milliard€ en matériel. C'était donc une attaque théorique.
  66. @gheb_dev @gregoirehebert HASH SHA1
 secure hashing algorithm
 
 2005 ->

    2,7milliard d’€ en matériel
 2015 -> 120’000€ en matériel En 2015 les cartes graphiques progressent et on rentre dans le domaine du possible. avec 64GPU en cluster on arrive à provoquer des collisions et commencer à décoder tout ou parties d'un message. Il faut donc estimer autour de 120k € pour une attaque. autant dire que pour un état ou des criminels bien établi c'est de la petite monnaie.
  67. @gheb_dev @gregoirehebert HASH SHA1
 secure hashing algorithm
 
 2005 ->

    2,7milliard d’€ en matériel
 2015 -> 120’000€ en matériel
 2017 -> SHA1 est dans les cordes
 2019 -> SHA1 est K.O (11k$) En 2017 c’était pas ouf, mais 2019 c'est fini. Une technique particulière met un K.O. a SHA1, il faut se tourner vers SHA2 ou AES. Alors attention, on est en cryptographie, un K.O. ne signifie pas que tout le monde soit capable de le craquer en 1 clic, Par définition, un bon algo de hachage rends l’inversion impossible, on estime que l’algo est K.O. lorsque que techniquement il a été prouvé qu’une collision était réalisable, avec un temps et un budget raisonnable pour être exploité.
  68. @gheb_dev @gregoirehebert HASH Comment ? Pour comprendre la technique il

    faut d'abord comprendre SHA.
  69. @gheb_dev @gregoirehebert HASH Comment ? Any length -> 160 bits


    512 bits en entrée 
 puis compressé C'est un algorithme qui transforme n'importe quelle chaine en une chaine de 160bits.
 Pour fonctionner SHA à besoin en entrée d'une chaine de 512bits et utilise une fonction de compression qui prendra des groupes de bits pour n'en rendre qu'un seul. Si la chaine est supérieure à 512bits on découpera en blocks de 512. et puisqu'une chaine ne fait jamais 512bits, il faut un moyen de la rallonger. on va ajouter un bit positif, puis des 0 et terminer par la longueur du message. s'il fait 7 de long on rajoute 111 à la fin donc 1010111 100000…000111.

  70. @gheb_dev @gregoirehebert HASH Comment ? môman = 6 bytes =

    48bits môman = aca9c866584e891be0e5c736798273c00bb48a00 
 la fonction de compression va effectuer des décalage de bits à partir d'une matrice définie dans l'implémentation. L'algorithme exécutera 80 fois la fonction de compression. pour obtenir une chaine de 160bits. Pour ceux qui ont l’oeil, la chaine produite est un binaire de 20bytes, qui nous est retourné en une chaine hexadécimale de 40bytes.

  71. @gheb_dev @gregoirehebert HASH Comment ? môman = 6 bytes =

    48bits môman = aca9c866584e891be0e5c736798273c00bb48a00
 
 Birthday Paradox ou Birthday-near-collision-attack Dans SHA1 la matrice de correspondance est définie, on obtiendra toujours les mêmes résultats pour la même chaine. Il y a une faible possibilité que différents input puisse produire le même hash.
 La technique utilisée pour l'attaque permet de réduire le nombre de variations à tester pour y arriver.
 
 Cette technique c'est le paradox des bébés ! Ou birthday paradox ou Birthday-near-collision attack. Avec cette approche, on va beaucoup, beaucoup plus vite qu'avec les précédentes techniques. Je vous explique le principe.
  72. @gheb_dev @gregoirehebert HASH Comment ? môman = aca9c866584e891be0e5c736798273c00bb48a00
 môman =

    6 bytes = 48bits
 
 Birthday Paradox ou Birthday-near-collision-attack 23/365 -> 6% Parmi 23 bébés nés dans le monde.
 Quel est la probabilité pour ces bébés d'avoir la même date de naissance?
 23/365 soit 6%.
  73. @gheb_dev @gregoirehebert HASH 50% Comment ? môman = aca9c866584e891be0e5c736798273c00bb48a00
 môman

    = 6 bytes = 48bits
 
 Birthday Paradox ou Birthday-near-collision-attack pas du tout. C'est 50%.
  74. @gheb_dev @gregoirehebert HASH Comment ? môman = aca9c866584e891be0e5c736798273c00bb48a00
 môman =

    6 bytes = 48bits
 
 Birthday Paradox ou Birthday-near-collision-attack 97% Et si on pousse jusqu'a 50 bébés on arrive à 97% de chance. À 75 on touche les 99.97%
 
 C'est un paradox, il semble absurde mais on a les maths pour le prouver. Comment est-ce possible qu'un si petit nombre ai autant de chance d'avoir le même anniversaire ? Comment prouver parmi les 365 possibilités, qu'un sixième suffise ? En fait, on va plutôt prouver le contraire, on va prouver qu'ils n'ont pas, le même anniversaire. C'est plus facile.
  75. @gheb_dev @gregoirehebert HASH Comment ? môman = aca9c866584e891be0e5c736798273c00bb48a00
 môman =

    6 bytes = 48bits
 
 Birthday Paradox ou Birthday-near-collision-attack 365 possibilités sur 365 Le bébé 1 est né. il a donc la totalité des choix possible 365/365.
  76. @gheb_dev @gregoirehebert HASH Comment ? môman = aca9c866584e891be0e5c736798273c00bb48a00
 môman =

    6 bytes = 48bits
 
 Birthday Paradox ou Birthday-near-collision-attack 365 possibilités sur 365 365/365 x 364/365 Le bébé 2 est né. la probabilité qu'il n'ai pas le même anniversaire est 365/365 x 364/365. Un jour de moins que le nombre de bébés déjà nés.
  77. @gheb_dev @gregoirehebert HASH Comment ? môman = aca9c866584e891be0e5c736798273c00bb48a00
 môman =

    6 bytes = 48bits
 
 Birthday Paradox ou Birthday-near-collision-attack 365 possibilités sur 365 365/365 x 364/365 365/365 x 364/365 x 363/365 365/365 x 364/365 x 363/365 x 362/365 Le bébé 3 est né 365/365 x 364/365 x 363/365 Le bébé 4 est né 365/365 x 364/365 x 363/365 x 362/365…
  78. @gheb_dev @gregoirehebert HASH Comment ? môman = aca9c866584e891be0e5c736798273c00bb48a00
 môman =

    6 bytes = 48bits
 
 Birthday Paradox ou Birthday-near-collision-attack 364! ÷ (365 − N)! × 365N−1 Ce calcul a une expression plus simple, on dit que c'est factoriel de 364 divisé par factoriel de 365 -le nombre de bébés * 365 (le nombre de jours dans l'année) à la puissance du nombre de bébé -1
  79. @gheb_dev @gregoirehebert HASH Comment ? môman = aca9c866584e891be0e5c736798273c00bb48a00
 môman =

    6 bytes = 48bits
 
 Birthday Paradox ou Birthday-near-collision-attack 364! ÷ (342! × 36522) Pour 23 bébés, nous attendons donc le résultat de 364!/(342!*365²²)
  80. @gheb_dev @gregoirehebert HASH Comment ? môman = aca9c866584e891be0e5c736798273c00bb48a00
 môman =

    6 bytes = 48bits
 
 Birthday Paradox ou Birthday-near-collision-attack 364! ÷ (342! × 36522) = 0,492703 Ce qui nous donne, 0.492703 soit approximativement 49.3% de chance que ces bébés n'aient pas la même date de naissance. L’astuce ici c'est qu'on évalue la probabilité de chacun des bébés entre-eux. On ne vérifie pas qu'un des bébés de 2 à 23 possède le même anniversaire que bébé 1 parmi les 365 possibilités, mais plutôt que 2 bébés parmi les 23 puisse posséder le même anniversaire au sein des 365 possibilités. C'est surprenant mais les Maths le prouvent. Et très logiquement, plus on ajoute de bébés, plus on augmente ce risque d'interpolation.
  81. @gheb_dev @gregoirehebert HASH Et en vrai ?

  82. @gheb_dev @gregoirehebert HASH Et en vrai ? 99024280cab824efca53a5d1341b9210 Pour casser

    SHA1 les chercheurs essaient de provoquer une collision. En admettant que j'ai un fichier en ma possession produisant le hash : 99024280cab824efca53a5d1341b9210
  83. @gheb_dev @gregoirehebert HASH Et en vrai ? 99024280cab824efca53a5d1341b9210 99024280cab824efca53a5d1341b9210 Je

    vais tenter de produire une autre chaine qui possède le meme hash. Pour le faire je vais créer une multitude de caractères, espaces, virgules, nouvelles lignes, apostrophes etc. En créer un nombre conséquent de variations je vais finir éventuellement par tomber sur le même hash.
  84. @gheb_dev @gregoirehebert HASH Et en vrai ? 99024280cab824efca53a5d1341b9210 99024280cab824efca53a5d1341b9210 MD5

    et SHA1 sont cassés. Je peux faire passer un document pour un autre.
  85. @gheb_dev @gregoirehebert HASH Et en vrai ? SHA1 -> 160

    bits -> collision 1280 MD5 et SHA1 sont cassés. Alors attention remettons un peu de contexte. SHA1 produit un résultat de 160bits, ayant une probabilité de collision de 1²⁸⁰, soit environ 12millions d'années de calcul GPU, tellement long que même la NSA, n'essaiera même pas.
  86. @gheb_dev @gregoirehebert HASH Et en vrai ? SHA1 -> 160

    bits -> Birhday-near-collision -> 260 Avec la méthode ci-dessus, on abaisse cette probabilité à 2⁶⁰ ce qui devient possible, avec un peu d'argent et quelques GTX 970.
  87. @gheb_dev @gregoirehebert HASH Et en vrai ? SHA2 -> 256

    bits -> Birhday-near-collision -> 2128 Il y a toutes les raisons de passer à SHA2 puisqu'on passe de 160 à 256 ou 512 bits. On arrive donc à une probabilité de 2¹²⁸, ce qui est considérablement plus grand. Mais le fait que ce soit possible, reste un risque. Alors on imagine d'autres moyen de hasher nos données et de rendre encore plus "aléatoire" le résultat. Les algorithmes modernes utilisent un SPNetwork.
  88. @gheb_dev @gregoirehebert SP-NETWORK

  89. @gheb_dev @gregoirehebert SP-NETWORK Substitution / Permutation A = E
 E

    = A SP c'est pour Substitution / Permutation Enigma fait de la substitution. Elle a un niveau de substitution de 1 pour 1. A chaque rotation de rouage dans la machine, une lettre = une autre lettre. Ce qui signifie que si je souhaites décoder un caractère, je n'ai qu'à me concentrer sur la paire, c'est à dire à quel caractère est il associé.Une fois décodé, il est éliminé des possibilités pour les caractères suivants.
  90. @gheb_dev @gregoirehebert SP-NETWORK Substitution / Permutation A = E
 E

    = A MD4, MD5, SHA0 et SHA1 MD4, MD5, SHA0 et SHA1 vont utiliser ce processus mais, aussi y ajouter d'autres opérations mathématiques pour complexifier le résultat. On va y retrouver du décalage de bits de modulo 2³², XOR, AND, OR et NOT. Malgré toute, avec cette méthode il reste possible de créer des fichiers différents mais avec la même signature.
  91. @gheb_dev @gregoirehebert SP-NETWORK Substitution / Permutation A = E
 E

    = B Alors on va encore ajouter de la confusion. On va exécuter une permutation. Plutôt que de remplacer les valeurs, on va mélanger les positions. Attention, comme pour l'étape précédente, ce n'est pas aléatoire, ce sont des valeurs prédéfinies. Il faut pouvoir revenir déchiffrer.
  92. @gheb_dev @gregoirehebert SP-NETWORK Substitution / Permutation [0110][1001] A = E


    E = B La manière dont ça fonctionne est la suivante: Dans un premier temps nous allons découper la chaine à encoder en bloc d'une certaine taille. Si le dernier ou seul bloc est plus petit, on va l'étendre.
  93. @gheb_dev @gregoirehebert SP-NETWORK Substitution / Permutation [0110][1001]
 [sbox][sbox]
 [1001][1101]
 


    A = E
 E = B Chaque bloc est passé dans une s-box, ou substitution box. Son but est de d'inter-changer une valeur par une autre à partir d'une matrice pré-définie.
  94. @gheb_dev @gregoirehebert SP-NETWORK Substitution / Permutation [0110][1001]
 [sbox][sbox]
 [1001][1101]
 [

    pbox ]
 [1101][1001] A = E
 E = B On rassemble les blocs de valeurs à nouveau. ça veux déjà dire moins de choses. Puis la valeur va être soumise au sein d'une p-box, ou permutation box. On ne remplace pas les valeurs, on les déplace dans la chaine.
  95. @gheb_dev @gregoirehebert SP-NETWORK Substitution / Permutation 
 
 Clé =

    f8ef4efa9842azgjyu248ger4h984a [0110][1001]
 [sbox][sbox]
 [1001][1101]
 [ pbox ]
 [1101][1001] A = E
 E = B Si on s'arrête là, on fait un peu mieux mais pas beaucoup mieux que Enigma, alors on va utiliser une clé, un hash, que l'on va diviser en 3 blocs, 1 pour chaque étape, puis mixer ce bloc avec le message grâce à un XOR entre chaque étape.
  96. @gheb_dev @gregoirehebert SP-NETWORK Substitution / Permutation 
 
 Clé =

    f8ef4efa9842azgjyu248ger4h984a [0110][1001]
 [sbox][sbox]
 [1001][1101]
 [ pbox ]
 [1101][1001] A = E
 E = B 10x
 80x Puis répéter toutes les étapes un certain nombre de fois, 10x, 80x. Le nombre de tours à faire va dépendre de l'efficacité d'un tour. Donc des substitutions et permutations.
  97. @gheb_dev @gregoirehebert SP-NETWORK Substitution / Permutation 
 
 Clé =

    f8ef4efa9842azgjyu248ger4h984a [0110][1001]
 [sbox][sbox]
 [1001][1101]
 [ pbox ]
 [1101][1001] A = E
 E = B 10x
 14x AES AES par exemple lui fait entre 10 et 14 tours. En deçà on perds en sécurité et au delà on perds en rapidité. Pour encoder un mot de passe on préfèrera la sécurité à la rapidité. Pour encoder des échanges on favorisera la rapidité sans qu'elle soit on dépit de la sécurité.
  98. @gheb_dev @gregoirehebert AES - RIJNDAEL Et quand on parle de

    SP Network impossible de ne pas citer celui qui protège probablement +70% du web. Rijndael.
  99. @gheb_dev @gregoirehebert AES - RIJNDAEL DES - DES3 Advanced Encryption

    Standard Suite à l'insuffisance du prédécesseur DES, et DES3, le NIST (National Institute of Standards and Technology) à ouvert une compétition afin de proposer un algorithme capable de surpasser l'existant et de l'utiliser en tant que Advanced Encryption Standard.
  100. @gheb_dev @gregoirehebert AES - RIJNDAEL A.E.S. Il y a eu

    plusieurs compétiteurs. Certains étaient plus robustes, mais plus lents. D'autres étaient plus rapide, mais moins robuste. Sachant qu'il s'agissait d'établir un moyen de communiquer sur internet, il faut que ça aille vite mais pas au détriment de la sécurité. Parmi les critères on retrouvera également, la consommation de mémoire, l'adaptabilité dans le temps, simplicité etc…
  101. @gheb_dev @gregoirehebert AES - RIJNDAEL A.E.S. Le gagnant est l'algorithme

    Rijndael, créé par 2 belges Vincent Rijmen et Joan Daemen.
 Voyons pourquoi Rijndael a été sélectionné.
  102. @gheb_dev @gregoirehebert AES - RIJNDAEL A.E.S. 128 : 
 2a0a5f2e922599e0192508b03b97799479d26012ae1

    d8b1ad84023a8ac1f4fa740492d9fb91c3f29071c95 9a4914ce55e1dca06209e7fc90e21a45205a51240b0 0a8cc74351b0b9a028667e64d358cfc876c57082529 29183d21120c16684af75020350cd018c8bda552021 3bb4a72090cf000dedfc2f40a4dc99352ad0ed63b Il reçoit un texte d'une longueur de 128 bits, il retournera une chaîne chiffrée de 128bits. Une clé sera utilisée pour le chiffrement, cette clé sera de 128, 192 ou 256 bits. On a donc une clé très longue,
  103. @gheb_dev @gregoirehebert AES - RIJNDAEL A.E.S. 256 : 
 94e5c820930640f96349e7bad731b4e6023d150513c

    28adf86addef93a8f3e760b6c1ff3e406d4583d7e70 d99dbcc66f6b37b1fbd4c3807781a693519f5b998c0 56b123f955f15b671d14c4094452a98f191a064917c 36940a6fd255e4ed4caab3290dee3971aa0b7d01ba6 362af5310fd354d94ef66bbfe7452d72e81fd270a80 64ac5e0a0d3e36f76bacb8bcbb87685bb35a8b2792f 8f00fdb13aa7cb87464db03f7b45cfdc1b85230d9c8 caa4a9dac8dfd8de47c02758eb3559a80994e1d861b 5d2da4abcdbe47e65e55f612e003b1adbb3fea03f4b ebde169715fbe786b0c6a5eb8aecc83833ac8863e54 d4483a2dea67aabea00ad0eeccdc7139cb78feb voir même extrêmement longue…
 Donc, même si vous utilisez une clé de 128bits, c'est déjà bien assez long. (pour ceux qui aiment se représenter dans le temps, il faudrait des milliers d'années pour déchiffrer)
  104. @gheb_dev @gregoirehebert AES - RIJNDAEL A.E.S. Rijndael est conçu comme

    un sp-network. Il va donc réaliser des substitutions pour amener de la confusion et des permutations pour amener de la diffusion.

  105. @gheb_dev @gregoirehebert AES - RIJNDAEL A.E.S. [b01,b05,b09,b13]
 [b02,b06,b10,b14]
 [b03,b07,b11,b15]
 [b04,b08,b12,b16]

    Plutôt que de travailler sur une longue chaîne de caractère, AES manipule les données sous forme d'une matrice. une grille de 4x4. Il va donc découper par blocs de 16bytes.
  106. @gheb_dev @gregoirehebert AES - RIJNDAEL A.E.S. Nous avons en premier

    l'ajout d'une partie de notre clé via une opération binaire, XOR. Ce découpage de notre clé et cet ajout entre chaque opération, est ce qui nous permet de rendre le tout secret. Puisque tout le reste de l'algorithme est publique.
  107. @gheb_dev @gregoirehebert AES - RIJNDAEL A.E.S. Ensuite nous exécutons les

    opérations suivantes substitution de bits, [décalage de bit, mélange de colonne](permutation), et ajout de la clé via XOR. Cette suite d'opérations est un "round", un tour si vous voulez.
  108. @gheb_dev @gregoirehebert AES - RIJNDAEL A.E.S. 128bits: 10 round
 192bits:

    12 rounds
 256bits: 14 rounds Avec une clé de 128bits, il faut effectuer 10 rounds pour tout chiffrer. Avec une clé de 192bits, il faut effectuer 12 rounds. Avec une clé de 256bits, il faut effectuer 14 rounds.
  109. @gheb_dev @gregoirehebert AES - RIJNDAEL A.E.S. RoundKey La clé va

    être divisée en autant de morceaux qu'il est nécessaire. AES utilise un "key schedule". C'est un algorithme qui calcule le morceau de clé nécessaire à utiliser par étape et par tour.
  110. @gheb_dev @gregoirehebert AES - RIJNDAEL A.E.S. Substition -> Champs de

    Galois de 
 çad entre 00000000 et 11111111 28 La première étape, La substitution, est une opération qui résultera en une valeur située dans un champs de Galois de 2⁸, c'est à dire qu'elle sera située entre 00000000 et 11111111.
  111. @gheb_dev @gregoirehebert AES - RIJNDAEL A.E.S. Cette valeur est calculée

    dans une lookup table définie dans l'implémentation de l'algorithme.
  112. @gheb_dev @gregoirehebert AES - RIJNDAEL A.E.S. Cette lookup table est

    un ensemble de fonctions mathématiques s'assurant qu'un élément via le biais du hasard ne retombe jamais sur lui même ,que 2 éléments n'échangent pas leur place entre eux, et qu'il soit possible de revenir à l'état initial. Puisque c'est une lookup Table, c'est rapide.
  113. @gheb_dev @gregoirehebert AES - RIJNDAEL A.E.S. La seconde étape, le

    décalage de bytes. Dans notre matrice chaque ligne est décalée d'un rang vers la gauche (sauf la première ligne). Cette étape permet de garantir que les ensembles de valeurs ne soient pas encodées de manière indépendante, et ne pas former des sous ensemble de chaines courtes, et donc plus facile à décoder.
  114. @gheb_dev @gregoirehebert AES - RIJNDAEL A.E.S. La dernière étape d'un

    round est le mélange des colonnes. Puisqu'on va répéter les 3 opérations, elle permet d'ajouter encore plus de confusion lors des prochaine exécutions. 
 Cette étape n'est pas réalisée au dernier round, puisque de toute manière elle n'ajoute aucune variation des données. Le mélange est une multiplication matricielle qui résultera là aussi dans une valeur située dans un champs de Galois de 2⁸. (pour les matheux qui se demandent comment une multiplication de 2 grandes valeurs pourraient ne pas sortir du champs imposé, c'est parce que la valeur est multipliée modulo un polynomial) Et ici aussi, on utilisera des fonctions qui possèdent leur inverse.
  115. @gheb_dev @gregoirehebert AES - RIJNDAEL A.E.S. Avec cette construction on

    ne sort jamais du champs des possible sur 128bits, et chaque opération est réversible. Alors bien sûr ces étapes son cruciales et si l'implémentation n'est pas rigoureuse, des morceaux de clés pourraient fuiter. Mais, heureusement pour nous, puisque c'est un standard, c'est a présent directement encodé dans les CPU, et de manière précautionneuse. C'est presque impossible a pirater, et extrêmement rapide.
  116. @gheb_dev @gregoirehebert AES - RIJNDAEL A.E.S. WannaCry C'est d'ailleurs pour

    ça qu'on a eu des virus qui verrouillent votre système, grâce a AES, il est capable d'encoder 10Gb/s. Le temps de s'en rendre compte, c'est trop tard.
  117. @gheb_dev @gregoirehebert CONCLUSION Pour sécuriser vos échanges

  118. @gheb_dev @gregoirehebert CONCLUSION RSA + Diffie-Hellmann + AES Pour sécuriser

    vos échanges TLS combine les capacités de RSA, Diffie-Hellmann et AES.
 Oui, c’est sécurisé.
  119. @gheb_dev @gregoirehebert Aller plus loin Triple-Diffie-hellmann
 Triple Ratchet
 Elliptic curves

    Pour sécuriser vos échanges TLS combine les capacités de RSA, Diffie-Hellmann et AES.
  120. @gheb_dev @gregoirehebert Aller plus loin Et si on utilisait ce

    système pour la définition des mots de passes sur nos sites ? https://github.com/jedisct1/spake2-ee
  121. @gheb_dev @gregoirehebert Aller plus loin https://github.com/jedisct1/spake2-ee

  122. @gheb_dev @gregoirehebert Aller plus loin https://blog.usejournal.com/hashing-passwords-on-the-server-side-a-dead-end-82669ee0253a

  123. @gheb_dev @gregoirehebert THANK YOU!

  124. @gheb_dev @gregoirehebert SOURCES https://chiffrer.info/
 https://www.youtube.com/channel/UC9-y-6csu5WGm29I7JiwpnA
 https://en.wikipedia.org/wiki/Transport_Layer_Security
 https://en.wikipedia.org/wiki/Substitution%E2%80%93permutation_network
 https://en.wikipedia.org/wiki/Advanced_Encryption_Standard
 https://en.wikipedia.org/wiki/RSA_(cryptosystem)
 https://en.wikipedia.org/wiki/MD5


    https://en.wikipedia.org/wiki/SHA-1
 https://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange
 https://en.wikipedia.org/wiki/Elliptic-curve_Diffie%E2%80%93Hellman
 https://en.wikipedia.org/wiki/Triple_DES
 https://en.wikipedia.org/wiki/Data_Encryption_Standard
 http://competitions.cr.yp.to/aes.html
 https://en.wikipedia.org/wiki/Public-key_cryptography
 https://sha-mbles.github.io/
 https://en.wikipedia.org/wiki/Password-authenticated_key_agreement