• STATISTIQUES
  • Il y a eu un total de 1 membres et 25340 visiteurs sur le site dans les dernières 24h pour un total de 25 341 personnes!


    Membres: 2 604
    Discussions: 3 579
    Messages: 32 816
    Tutoriels: 78
    Téléchargements: 38
    Sites dans l'annuaire: 58


  • ANNUAIRE
  • [EN] wechall
    Pour les gens n'étant pas familiers avec les sites de challenges, un site de challenges est un site propos...
    Hacking
    [FR] Newbie Contest
    Crackme: 35, Cryptographie: 49, Hacking: 27, Javascript/Java: 17, Logique: 31, Programmation: 23, Stéganographie: 53
    Challenges
    [FR] dcode
    dcode.fr est le site indispensable pour décoder des messages, tricher aux jeux de lettres, résoudre des énigmes...
    Outils / Add-on
    [FR] µContest
    µContest est un site de challenges de programmation, c'est à dire qu'il propose des épreu...
    Hacking
    [EN] Hack this site
    Basic: 11, Realistic: 17, Application: 18, Programming: 12, Extbasic: 14, Javascript: 7, Stego: 17
    Challenges
    [FR] Le site du zero
    Découvrez gratuitement la programmation (C, C++, PHP, MySQL, XHTML, CSS...), Linux, le Mapping, la modé...
    Programmation
    [EN] Big-Daddy
    Big-Daddy est site internet communautaire avec un effectif diversifié, y compris des artistes, des programmeur...
    Hacking

  • DONATION
  • Si vous avez trouvé ce site internet utile, nous vous invitons à nous faire un don du montant de votre choix via Paypal. Ce don servira à financer notre hébergement.

    MERCI!




Note de ce sujet :
  • Moyenne : 0 (0 vote(s))
  • 1
  • 2
  • 3
  • 4
  • 5
Découvrez les attaques par canaux auxiliaires sur cryptoprocesseurs
20-04-2013, 19h58 (Modification du message : 20-04-2013, 20h08 par InstinctHack.)
Message : #1
InstinctHack Hors ligne
Posting Freak
*



Messages : 1,366
Sujets : 184
Points: 299
Inscription : Dec 2011
Découvrez les attaques par canaux auxiliaires sur cryptoprocesseurs
io,
Cet article n'est pas de moi, il provient d'ici
Vu le peu de post sur le blog, j'ai peur qu'il disparaisse et que cet article se perde. L'auteur m'autorise à le recopier et puis je le trouve intéressant Smile
Donc je l'ai remis en forme en bbcode à titre d'archive.
J'espère que le sujet vous plairas autant que ça l'as était pour moi Wink

Présentation

Cet article sera largement détaillé mais ne sera pas spécialement vulgarisé.


J’ai découvert le concept d’attaque par canaux auxiliaires dans un numéro hors-série de MISC (Multi-system and Internet Security Cookbook). Quand j’ai lu l’article en question, j’ai eu une montée d’adrénaline et je me suis dis JE VEUX ESSAYER JE VEUX ESSAYER JE VEUX ESSAYER, PLEAAAAAAAASE !! Alors j’ai ouvert mes bouquins de crypto et j’ai plongé.


Je vous mets dans le contexte. Quand vous allez chez le docteur, il prend votre carte Vitale et la met dans une machine spéciale qui la lit et envoie plein d’info à votre sécu. Heureusement, la communication entre la machine du docteur et votre sécu est super bien protégée, sinon n’importe quel voyou de l’internet pourrait intercepter vos info et vous faire du tort. Le principe est le même pour les terminaux de paiement par carte bancaire dans les magasins où vous faites vos courses.


L’algorithme qui nous protège au quotidien dans ces 2 situations est bien connu, c’est le Rivest Shamir Adleman (RSA) et ses fameux échanges de clefs. Je ne vous l’explique pas ici, il est plutôt simple à comprendre à partir du moment où vous connaissez l’opérateur mathématique modulo (le reste de la division euclidienne entre deux entiers).


Bref, le principe de RSA, c’est de permettre à 2 personnes de discuter à distance sur un réseau sans que personne ne puissent comprendre ce qu’elles se racontent (et donc empêcher un pirate de capter votre numéro de CB quand vous payez vos fringues à Zara). Si ça marche aussi bien, c’est grâce aux maths ! A moins de disposer de tous les ordinateurs de la planète pendant 3000 ans, aucun pirate ne pourrait aujourd’hui déchiffrer vos communications secrètes (ah bon ? un ordinateur quantique, où ça ?).


Ben ça parait COOL NON ? Ho regardez, le ciel s’assombrit… *breudeubooonnn breuudeuboonn* (<= bruit du tonnerre, c’est pour l’ambiance !)


Si les maths ne peuvent pas venir à bout de RSA et de la sécurité des terminaux de paiement, les attaques par canaux auxiliaires le peuvent. En fait, un algo aura beau être sûr à 99,999%, son implémentation matérielle pourra lui faire défaut. C’est le principe des canaux auxiliaires.


Vous avez déjà vu un mauvais joueur de poker ? Il suinte de rictus et autres TOC pendant ses parties. On peut dire qu’une attaque par canal auxiliaire sur sa tronche ferait plutôt mal. Un canal auxiliaire, c’est une fuite d’informations provenant d’un système, à l’insu de son administrateur (et encore pire, de son fabriquant !).


Dans la vie réelle, les attaques par canaux auxiliaires se font sur des cryptoprocesseurs. Des cryptoprocesseurs, il y en a dans la machine du docteur pour la carte Vitale, dans les terminaux de paiement à Zara ou H&M mais aussi dans le bazar militaire (radar, brouilleur de signal et j’en passe).

Quelle différence entre un cryptoprocesseur et un bon vieux processeur Intel des familles me direz-vous ?

A priori, aucune. Un processeur, ça reste un processeur, pas de souci là dessus. Par contre, les cryptoprocesseurs embarquent certaines instructions que nos processeurs à nous n’embarquent pas, comme l’exponentiation modulaire, très utilisée dans les opérations cryptographiques. Certains cryptoprocesseurs sont conçus pour résister aux radiations, d’autres pour économiser de l’énergie. Mais il y a une autre différence cool ! Ces processeurs sont généralement protégés contre les attaques par canaux auxiliaires.

4 types d’attaques par canaux auxiliaires

Si je veux powned la machine de mon docteur pour piquer les info de ses patients, je vais m’attaquer à son processeur parce que c’est là dedans qu’il y a des informations intéressantes et des calculs cryptographiques qui me permettront de déchiffrer la discussion entre la machine elle-même et la sécu. Partons du principe que mon médecin a acheté sa machine sur Ebay en solde et que du coup, elle ne possède pas un cryptoprocesseur, mais un bête processeur.

Voila comment je pourrais l’attaquer :
  • Grâce à une étude temporelle (timing attack)
  • Grâce à une étude électromagnétique locale (electromagnetic analysis)
  • Grâce aux fuites photoniques
  • Grâce à une attaque par consommation (power analysis)
Timing Attack, whatzat ?

La timing attack ne date pas d’hier, elle a été expliquée en 1996 par môssieur Kocher dans son article « Timing attacks on implementations of Diffie-Hellman, RSA, DSS and other systems» . Rien que ça. Il a montré comment une implémentation de l’exponentiation modulaire pouvait fuir par canaux auxiliaires.


Je vous fais grâce du code mais en gros, imaginez une boucle qui permet de faire grimper un entier N à la puissance b, le tout modulo c. En fonction de la valeur de b, l’algorithme ne prendra pas le même temps à s’exécuter, ça parait assez évident (plus b est grand, plus l’algo mettra du temps). Et ben, la voila notre fuite ! Notez que cette fuite seule ne sert à rien mais elle pourrait être une étape d’une attaque qui viserait à obtenir la clef de chiffrement d’un cryptoprocesseur.


Grâce à cette différence de temps (et donc de consommation d’énergie), il est possible d’attaquer le processeur et de connaître les valeurs de N, b et c. Comment ? C’est un axe de recherche très pointu, je ne vais pas pouvoir vous l’expliquer mais le concept est super intéressant. Mais les autres types d’attaque sont encore plus hallucinants !

Analyse électromagnétique et Maxwell

Vous avez sûrement déjà entendu parler de Maxwell, le physicien (fameux pour les équations qui portent son doux nom).
Maxwell a écrit :La circulation d’un courant dans un conducteur génère des champs électriques et magnétiques au voisinage de ce conducteur.
Il a démontré que les champs électromagnétiques étaient fonction du courant traversé par le conducteur, comme l’exprime clairement cette équation (Big Grin) :

[Image: c8515bd6c173d514d83785140924ce3c.png]

En résumé, il est possible de connaître la consommation en courant d’un composant en étudiant ses émanations électromagnétiques. Comment on peut appeler ça… ah ben, une fuite ?

La fuite photonique

La fuite photonique suit le même concept. Les circuits électroniques fuient en émettant de la lumière ! Évidemment, ne comptez pas sur des circuits électroniques pour vous servir de lampe torche mais sachez tout de même qu’ils dégagent des photons. C’est le cas des transistors NMOS qui dégagent des photons lorsqu’ils commutent de 0 à 1. Pour capturer ces photons, il faut du matos de bourrin vous en conviendrez.

Power analysis

Enfin, l’attaque par consommation est celle que je me suis amusée à mettre en œuvre cet après-midi sur mon micro-contrôleur Arduino, fièrement équipé d’un processeur ATmega 328. Le principe est simple : en mesurant les tensions d’un circuit, on tente de découvrir les données manipulées par le circuit.

Et alors, comment protéger nos cryptoprocesseurs ?
  • Contre l’attaque temporelle, les processeurs génèrent un nombre aléatoire qu’ils insèrent dans leurs calculs pour brouiller le temps d’exécution et effectuer des opérations inutiles
  • Contre les fuites électromagnétiques, un blindage des composants ou la génération d’un bruit magnétique rendant l’écoute impossible
  • Contre l’étude photonique, rien ! Parce que c’est un domaine en pleine recherche et que personne ne maîtrise la technique pour le moment
Topologie de mon attaque rudimentaire type « Power Analysis »

Je me suis tenté à une petite attaque par analyse de tensions sortantes grâce à un Arduino. Un Arduino est un micro-contrôleur, soit très vulgairement un mini-ordinateur. Il possède un processeur, de la mémoire, des entrées/sorties. Il est utilisé en électronique et en robotique.


En premier lieu, mon Arduino (à gauche) est relié à un écran LCD. L’Arduino était chargé de générer un mot aléatoire (EIFJE, XIRH ou NBOR enfin vous voyez le genre) et de l’afficher sur l’écran. Imaginez que l’Arduino est la borne « carte Vitale » de votre docteur et l’écran est le serveur qui reçoit les info dans les locaux de votre sécu. Le but était d’écouter ce qui se passait sur le circuit et de reconstituer le mot aléatoire qu’envoyait l’Arduino en boucle.

[Image: bazarsmall1.jpg]

Le montage était relié à mon laptop (fraichement Ubuntisé, adieu Fedora </3). J’ai conçu un programme très simple qui fait office d’oscilloscope numérique : le PC reçoit la mesure d’une tension via le câble USB et l’affiche sur la sortie standard. Grâce à la commande tee, j’enregistre les valeurs mesurées dans un fichier que je peux ensuite transformer en graphique avec gnuplot (je suis entrain de me mettre à Qt pour générer des graphiques en « temps-réel » et avoir un vrai oscilloscope numérique).

[Image: bazarall.jpg]
Voila la gueule de mon oscillo numérique (4.99V représente évidemment 5V, soit un 1 logique) :
[Image: bazar.jpg]

Rudimentaire, mais efficace. Sur l’avant-dernière photo, le fil blanc qui pendouille est le fil que j’utilise comme outils de mesure : la tension que reçoit ce fil est envoyée à mon programme qui l’affiche à l’écran, la masse étant branchée sur 0V.

L’attaque se passe en 3 temps :
  1. L’Arduino génère un mot aléatoire et l’envoie en boucle, lettre par lettre, au petit écran LCD, qui l’affiche (dans l’explication, le mot est « hello » pour simplifier les choses)
  2. Je me branche sur le circuit avec mon outil de mesure et je choppe 8 tensions type 0 ou 5V (donc 8 bits) pendant une période définie
  3. Je récupère les tensions sur mon PC, et je trace des sortes de chronogrammes pour reconstituer le message de l’Arduino
[Image: chrono.jpg]

On ne se moque pas de l’écriture de sagouin, merci. A noter que la photo des chronogrammes n’a rien à voir avec l’explication courante, ce sont des brouillons photographiés au hasard, n’essayez pas de chercher des correspondances.

En mesurant les tensions émises par l’Arduino, je déduis 5 octets qu’il a transmis à l’écran LCD :
  • 0110 1000 (première lettre de mon mot aléatoire)
  • 0110 0101 (seconde lettre de mon mot aléatoire)
  • 0110 1100 (ainsi de suite…)
  • 0110 1100
  • 0110 1111

J’ai mis un petit délai entre l’envoi de chaque lettre (quelques millisecondes) pour faciliter la réception parce que mes appareils de mesure sont assez… artisanaux.


A partir de là, je me jette soit sur le datasheet du processeur si c’est lui que j’écoutais, soit sur le datasheet de l’écran LCD si c’est lui que j’écoutais. En l’occurrence, j’espionnais les tensions de mon écran, plus facile. Le processeur est beaucoup moins abordable. Le datasheet va me donner les informations qu’il me manque :

[Image: datasheet.png]

Je fais la correspondance entre mes octets trouvés et les caractères du tableau… « h », « e », « l », « l », « o ». Yes, c’est bien ce qu’il y a sur l’écran ! Les tensions de cet écran LCD sont très faciles à décoder, ça n’aurait pas été le cas avec tous les autres composants. En cela, ce n’est pas une vraie attaque par canaux auxiliaires parce la fuite n’en est pas une.


Ce qui m’intéressait, c’était de me rapprocher du concept : en ayant les yeux bandés, est-ce qu’il est possible de dire ce qui se passe dans un circuit et si oui, est-ce automatisable ? A priori oui, il faut juste de la patience. Prochaine étape : m’amuser à faire pareil directement sur les pins du processeur Atmega 328.


Les canaux auxiliaires ont encore de beaux jours devant eux : c’est un axe de recherche qui ne cesse pas depuis bientôt 20 ans. Est-ce que RSA va craquer, un jour, à cause de ça ? Non, l’algorithme reste « sûr ». Ce sont ses implémentations matérielles qui doivent être perfectionnées. Une attaque par canaux auxiliaires demande au pirate un accès direct au matériel, ne l’oublions pas.

Pour approfondir
[FIN DE L'ARTICLE]

et voilà son code :
Code CPP :

    /**
    @Author : Stéphane Paton
    @Website : http://www.mangetamain.fr
    @Ref : http://www.mangetamain.fr/decouvrez-les-...seurs.html
     
    Code d'exemple de la libserial en C++ pour récupérer la valeur analogique d'un
    port de sortie sur mon Arduino
    */

     
    #include <iostream>
    #include <sstream>
    #include <string>
    #include <stdexcept>
    #include <SerialStream.h>
     
    void getVoltage();
    inline double convertToDouble(std:tring const& s);
     
    int main(int argc,char** argv)
    {
            getVoltage();
            return 0;
    }
     
    void getVoltage()
    {
        // Open the serial port.
        float voltage;
        using namespace LibSerial ;
        SerialStream serial_port ;
        serial_port.Open("/dev/ttyACM3");
        if ( ! serial_port.good() )
        {
            std::cerr << "[" << __FILE__ << ":" << __LINE__ << "] "
                      << "Error: Could not open serial port."
                      << std::endl ;
            exit(1) ;
        }
        // Set the baud rate of the serial port.
        serial_port.SetBaudRate( SerialStreamBuf::BAUD_9600 ) ;
        if ( ! serial_port.good() )
        {
            std::cerr << "Error: Could not set the baud rate." << std::endl ;
            exit(1) ;
        }
        // Set the number of data bits.
        serial_port.SetCharSize( SerialStreamBuf::CHAR_SIZE_8 ) ;
        if ( ! serial_port.good() )
        {
            std::cerr << "Error: Could not set the character size." << std::endl ;
            exit(1) ;
        }
        // Disable parity.
        serial_port.SetParity( SerialStreamBuf:ARITY_NONE ) ;
        if ( ! serial_port.good() )
        {
            std::cerr << "Error: Could not disable the parity." << std::endl ;
            exit(1) ;
        }
        // Set the number of stop bits.
        serial_port.SetNumOfStopBits( 1 ) ;
        if ( ! serial_port.good() )
        {
            std::cerr << "Error: Could not set the number of stop bits."
                      << std::endl ;
            exit(1) ;
        }
        // Turn on hardware flow control.
        serial_port.SetFlowControl( SerialStreamBuf::FLOW_CONTROL_HARD ) ;
        if ( ! serial_port.good() )
        {
            std::cerr << "Error: Could not use hardware flow control."
                      << std::endl ;
            exit(1) ;
        }
     
        // Lecture
        std:tring buffer;
        char next_byte;
        while ( true )
        {
            // Tant qu'on ne reçoit pas un "\n" sur le port série,
            // on concatène le buffer
            serial_port.get(next_byte);
            if(next_byte != '\n') buffer = buffer+next_byte;
            else
            {
                    // Quand on a reçu le \n de fin de ligne, on affiche le buffer
                    // transformé en float (la tension) et on le vide
                    voltage = convertToDouble(buffer);
                    std::cout<<voltage<<std::endl;
                    buffer.clear();
            }
        }
    }
     
     
     class BadConversion : public std::runtime_error {
     public:
       BadConversion(std:tring const& s)
         : std::runtime_error(s)
         { }
     };
     
     inline double convertToDouble(std:tring const& s)
     {
       std::istringstream i(s);
       double x;
       if (!(i >> x))
         throw BadConversion("convertToDouble(\"" + s + "\")");
       return x;
     }

 
Citation :un jour en cours de java j'ai attrapé les seins d'une fille mais elle m'a frappé en disant "c'est privé !!"
j'ai pas compris pourquoi, je croyais qu'on était dans la même classe
+1 (3) -1 (0) Répondre


Atteindre :


Utilisateur(s) parcourant ce sujet : 1 visiteur(s)
N-PN
Accueil | Challenges | Tutoriels | Téléchargements | Forum | Retourner en haut