TLS RSA AES WTF - Speaker Deck

Slide 1

Slide 1 text

@gheb_dev @gregoirehebert TITRE_FINAL_FINAL_2.ai

Slide 2

Slide 2 text

@gheb_dev @gregoirehebert Grégoire Hébert Senior Developper — Trainer — Lecturer @ Les-Tilleuls.coop

Slide 3

Slide 3 text

@gheb_dev @gregoirehebert EndtoEndEncryption

Slide 4

Slide 4 text

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

Slide 5

Slide 5 text

@gheb_dev @gregoirehebert EndtoEndEncryption Oui.

Slide 6

Slide 6 text

@gheb_dev @gregoirehebert THANK YOU!

Slide 7

Slide 7 text

@gheb_dev @gregoirehebert

Slide 8

Slide 8 text

@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échiﬀrer vos messages. Sauf qu'il y a eu des précédents où des réseaux terroristes et organisations criminelles utilisent ces systèmes.

Slide 9

Slide 9 text

@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?

Slide 10

Slide 10 text

@gheb_dev @gregoirehebert EndtoEndEncryption Admettons que oui. Si l’on voulait un moyen de garantir qu’un utilisation a des ﬁn criminelle puisse être détectée et exploitable.

Slide 11

Slide 11 text

@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 chiﬀrer 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.

Slide 12

Slide 12 text

@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, ﬁnalement là on a envie de se protéger sur toute la ligne.

Slide 13

Slide 13 text

@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?

Slide 14

Slide 14 text

@gheb_dev @gregoirehebert TLS Transport Layer Security Secure Sockets Layer,

Slide 15

Slide 15 text

@gheb_dev @gregoirehebert TLS

Slide 16

Slide 16 text

@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.

Slide 17

Slide 17 text

@gheb_dev @gregoirehebert DES DES TLS Le second consiste en chiﬀrer les données échangées. Il y a quelques temps était utilisé le DES (Data encryption standard) qui chiﬀre sur 56bits.

Slide 18

Slide 18 text

@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.

Slide 19

Slide 19 text

@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é.

Slide 20

Slide 20 text

@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.

Slide 21

Slide 21 text

@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.

Slide 22

Slide 22 text

@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 ﬁxe, 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.

Slide 23

Slide 23 text

@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.

Slide 24

Slide 24 text

@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)

Slide 25

Slide 25 text

@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.

Slide 26

Slide 26 text

@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.

Slide 27

Slide 27 text

@gheb_dev @gregoirehebert RSA

Slide 28

Slide 28 text

@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. Suﬃsamment 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.

Slide 29

Slide 29 text

@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 ϕ. 

Slide 30

Slide 30 text

@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.

Slide 31

Slide 31 text

@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ériﬁe 1( mod ϕ(n)).

Slide 32

Slide 32 text

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

Slide 33

Slide 33 text

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

Slide 34

Slide 34 text

@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.

Slide 35

Slide 35 text

@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.

Slide 36

Slide 36 text

@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.

Slide 37

Slide 37 text

@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ériﬁé avec : e⋅d = 1 mod ϕ(n) 7⋅103 = 721 = 1 mod 120.

Slide 38

Slide 38 text

@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

Slide 39

Slide 39 text

@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 ?

Slide 40

Slide 40 text

@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.

Slide 41

Slide 41 text

@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.

Slide 42

Slide 42 text

@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.   

Slide 43

Slide 43 text

@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.

Slide 44

Slide 44 text

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

Slide 45

Slide 45 text

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

Slide 46

Slide 46 text

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

Slide 47

Slide 47 text

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

Slide 48

Slide 48 text

@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

Slide 49

Slide 49 text

@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.

Slide 50

Slide 50 text

@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 chiﬀrage comme AES.

Slide 51

Slide 51 text

@gheb_dev @gregoirehebert KEY EXCHANGE  Diffie-Hellmann Maths Maintenant que le principe est connu, Allons couvrir les maths.

Slide 52

Slide 52 text

@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.

Slide 53

Slide 53 text

@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.

Slide 54

Slide 54 text

@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 ﬁnal 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 diﬃcile 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.

Slide 55

Slide 55 text

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

Slide 56

Slide 56 text

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

Slide 57

Slide 57 text

@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.

Slide 58

Slide 58 text

@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 chiﬀrer leurs échanges.

Slide 59

Slide 59 text

@gheb_dev @gregoirehebert KEY EXCHANGE  Diffie-Hellmann  LIMITS La problématique de l'échange de clé c'est qu'il faut avoir conﬁance dans votre réseau internet.

Slide 60

Slide 60 text

@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.

Slide 61

Slide 61 text

@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.

Slide 62

Slide 62 text

@gheb_dev @gregoirehebert HASH

Slide 63

Slide 63 text

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

Slide 64

Slide 64 text

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

Slide 65

Slide 65 text

@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.

Slide 66

Slide 66 text

@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.

Slide 67

Slide 67 text

@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é.

Slide 68

Slide 68 text

@gheb_dev @gregoirehebert HASH Comment ? Pour comprendre la technique il faut d'abord comprendre SHA.

Slide 69

Slide 69 text

@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 ﬁn donc 1010111 100000…000111. 

Slide 70

Slide 70 text

@gheb_dev @gregoirehebert HASH Comment ? môman = 6 bytes = 48bits môman = aca9c866584e891be0e5c736798273c00bb48a00   la fonction de compression va eﬀectuer des décalage de bits à partir d'une matrice déﬁnie 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. 

Slide 71

Slide 71 text

@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éﬁnie, on obtiendra toujours les mêmes résultats pour la même chaine. Il y a une faible possibilité que diﬀé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.

Slide 72

Slide 72 text

@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%.

Slide 73

Slide 73 text

@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%.

Slide 74

Slide 74 text

@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 suﬃse ? 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.

Slide 75

Slide 75 text

Slide 76

Slide 76 text

@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.

Slide 77

Slide 77 text

@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…

Slide 78

Slide 78 text

@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

Slide 79

Slide 79 text

Slide 80

Slide 80 text

@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ériﬁe 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.

Slide 81

Slide 81 text

@gheb_dev @gregoirehebert HASH Et en vrai ?

Slide 82

Slide 82 text

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

Slide 83

Slide 83 text

@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 ﬁnir éventuellement par tomber sur le même hash.

Slide 84

Slide 84 text

@gheb_dev @gregoirehebert HASH Et en vrai ? 99024280cab824efca53a5d1341b9210 99024280cab824efca53a5d1341b9210 MD5 et SHA1 sont cassés. Je peux faire passer un document pour un autre.

Slide 85

Slide 85 text

@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.

Slide 86

Slide 86 text

@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.

Slide 87

Slide 87 text

@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.

Slide 88

Slide 88 text

@gheb_dev @gregoirehebert SP-NETWORK

Slide 89

Slide 89 text

@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 signiﬁe 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.

Slide 90

Slide 90 text

@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.

Slide 91

Slide 91 text

@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éﬁnies. Il faut pouvoir revenir déchiﬀrer.

Slide 92

Slide 92 text

@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.

Slide 93

Slide 93 text

@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éﬁnie.

Slide 94

Slide 94 text

@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.

Slide 95

Slide 95 text

@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.

Slide 96

Slide 96 text

@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'eﬃcacité d'un tour. Donc des substitutions et permutations.

Slide 97

Slide 97 text

@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é.

Slide 98

Slide 98 text

@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.

Slide 99

Slide 99 text

@gheb_dev @gregoirehebert AES - RIJNDAEL DES - DES3 Advanced Encryption Standard Suite à l'insuﬃsance du prédécesseur DES, et DES3, le NIST (National Institute of Standards and Technology) à ouvert une compétition aﬁn de proposer un algorithme capable de surpasser l'existant et de l'utiliser en tant que Advanced Encryption Standard.

Slide 100

Slide 100 text

@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…

Slide 101

Slide 101 text

@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é.

Slide 102

Slide 102 text

@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 chiﬀrée de 128bits. Une clé sera utilisée pour le chiﬀrement, cette clé sera de 128, 192 ou 256 bits. On a donc une clé très longue,

Slide 103

Slide 103 text

@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échiﬀrer)

Slide 104

Slide 104 text

@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 diﬀusion. 

Slide 105

Slide 105 text

@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.

Slide 106

Slide 106 text

@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.

Slide 107

Slide 107 text

@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.

Slide 108

Slide 108 text

@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.

Slide 109

Slide 109 text

@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.

Slide 110

Slide 110 text

@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.

Slide 111

Slide 111 text

@gheb_dev @gregoirehebert AES - RIJNDAEL A.E.S. Cette valeur est calculée dans une lookup table déﬁnie dans l'implémentation de l'algorithme.

Slide 112

Slide 112 text

@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.

Slide 113

Slide 113 text

@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.

Slide 114

Slide 114 text

@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.

Slide 115

Slide 115 text

@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.

Slide 116

Slide 116 text

@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.

Slide 117

Slide 117 text

@gheb_dev @gregoirehebert CONCLUSION Pour sécuriser vos échanges

Slide 118

Slide 118 text

@gheb_dev @gregoirehebert CONCLUSION RSA + Diffie-Hellmann + AES Pour sécuriser vos échanges TLS combine les capacités de RSA, Diﬃe-Hellmann et AES.  Oui, c’est sécurisé.

Slide 119

Slide 119 text

@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, Diﬃe-Hellmann et AES.

Slide 120

Slide 120 text

@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

Slide 121

Slide 121 text

@gheb_dev @gregoirehebert Aller plus loin https://github.com/jedisct1/spake2-ee

Slide 122

Slide 122 text

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

Slide 123

Slide 123 text

@gheb_dev @gregoirehebert THANK YOU!

Slide 124

Slide 124 text

@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