Comment fonctionnent les clés RSA SecurID ®?
J'utilise les clés RSA SecureID ® depuis un certain temps maintenant (peut-être 10 ans), pour des choses telles que la sécurité de mon compte bancaire à domicile en ligne ou l'accès au réseau d'ordinateurs de mon entreprise à domicile. Ces clés génèrent un jeton numérique à 6 chiffres qui est configuré pour expirer. Cependant, je me suis toujours demandé comment cela fonctionne.
Sur le côté droit, il y a un point (non montré sur l'image) qui clignote une fois par seconde, et sur la gauche il y a une pile de six barres horizontales empilées verticalement, chacune disparaissant toutes les dix secondes. Chaque fois que soixante secondes se sont écoulées, le jeton se réinitialise et le jeton précédent devient invalide.
AFAIK ces appareils n'utilisent pas le réseau, et les numéros qu'ils génèrent doivent être vérifiés par le serveur (qu'il s'agisse d'un serveur de banque ou d'une entreprise). Par conséquent, à l'intérieur de cet appareil, il doit être stocké un algorithme qui génère des nombres aléatoires avec un mécanisme qui comprend une minuterie très précise alimentée par une petite batterie. Le temporisateur doit être très précis, car le serveur doit vérifier la validité des chiffres générés dans le même intervalle de temps. Pour chaque utilisateur/employé, le serveur doit, pour autant que je sache, stocker le même algorithme de génération de nombres aléatoires, avec un tel algorithme par client/employé. La puce doit bien sûr être construite de telle manière que si elle est volée, l'attaquant ne peut pas accéder à l'algorithme de génération de nombres aléatoires qui y est stocké, même si l'appareil est cassé.
Est-ce ainsi que cela fonctionne?
Merci!
Oui, cela fonctionne comme vous le dites. La puce est "inviolable" et effacera la "graine" (clé secrète) en cas de tentative d'attaque. Ceci est souvent accompli en ayant une batterie non remplaçable par l'utilisateur et un "piège" qui coupe l'alimentation du périphérique une fois que le périphérique est ouvert ou que la surface de la puce est retirée. La clé est ensuite stockée dans une mémoire SRAM, nécessitant une alimentation pour conserver la clé.
La clé est une graine, qui, combinée à l'heure actuelle en 60 secondes (en fait, l'horodatage UNIX actuel/60), actualise le code.
Non, l'appareil n'a PAS besoin d'être précis. Au lieu de cela, le serveur stockera l'heure du dernier code accepté. Ensuite, le serveur acceptera un code une minute plus tôt, une minute avant et à l'heure actuelle, donc si l'heure actuelle sur le serveur est 23h20, il acceptera un code de 23h19, 23h20 et 23: 21.
Après cela, il stockera l'heure du dernier code accepté, par exemple si un code 23:21 a été accepté, il stockera 23:21 dans une base de données et refusera d'accepter tout code généré à 23:21 ou plus tôt.
Passons maintenant à la partie intéressante: pour empêcher un jeton imprécis de se désynchroniser du serveur, le serveur stockera dans sa base de données, s'il devait accepter un code 23:19 ou 23:21 à 23:20. Cela garantira qu'à la prochaine connexion, le serveur corrigera le code avec le nombre d'étapes.
Disons que vous vous connectez à l'horloge 23:20 avec un code 23:19. Le serveur stocke "-1" dans sa base de données (et s'il s'agit d'un code 23:21, il stockera "+1" dans la base de données). La prochaine fois que vous vous connectez, l'horloge est 23h40. Ensuite, le serveur acceptera un code 23:38, 23:39 ou 23:40. Si un code 23:38 est accepté, il stockera "-2" dans la base de données, à 23:39 il gardera "-1" dans la base de données et à 23:40 il stockera "0" dans la base de données.
Cela garantit efficacement la synchronisation du serveur avec votre jeton. En plus de cela, le système, si un jeton "s'est trop éloigné" du serveur (car il est inutilisé pendant une longue période), permet la resyncronisation. Ceci est accompli soit par un administrateur système, soit un service de resynchronisation en libre service est présenté où l'utilisateur du jeton est invité à fournir 2 codes suivants à partir du jeton, comme 23:20 et 23:21, ou 19:10 et 19:11. Notez que le serveur n'acceptera JAMAIS un code de jeton généré au moment ou avant le moment où le "dernier code de jeton utilisé" était (car cela permettrait la réutilisation des codes OTP). Lorsqu'une resyncronisation est effectuée, le jeton stockera la différence par rapport aux 2 codes de jeton fournis, et l'heure actuelle du serveur et dans une resynchronisation, la fenêtre de recherche pourrait être comme plus/moins 50 étapes (ce qui permettrait environ 0,75 heures de désynchronisation dans les deux sens).
Le serveur peut détecter un jeton désynchronisé en générant les 50 codes antérieurs et 50 codes futurs, et si le code spécifié correspond à cela, il lancera automatiquement le processus de resynchronisation. Plusieurs fois, pour empêcher un attaquant d'utiliser le processus de resynchronisation pour trouver des codes valides, une fois qu'un compte est en mode de resynchronisation, la connexion ne sera pas acceptée sans resynchronisation, ce qui obligerait l'attaquant à trouver le code exact après ou avant le code juste a trouvé.
Le jeton SecurID a une valeur de "graine" qui lui est affectée et est programmé avec un algorithme spécifique qui génère des nombres basés sur la graine et son horloge système. La valeur de départ est également stockée dans un fichier livré avec le jeton. Lors de la réception du jeton, les administrateurs système importent le fichier d'origine sur le serveur d'authentification. Étant donné que le périphérique de jeton SecurID et le serveur ont tous deux la valeur de départ et utilisent tous deux l'algorithme, le serveur peut déterminer à tout moment le code de jeton correct.
Parfois, l'horloge du jeton peut ne pas être synchronisée avec le serveur d'authentification. Dans ce cas, les administrateurs système ou tout autre personnel de support autorisé peuvent aider l'utilisateur en effectuant un processus de resynchronisation sur le serveur. Cela configurera le serveur pour reconnaître le décalage horaire pour ce jeton afin que les futures tentatives d'authentification soient traitées avec précision.
Remarque: Étant donné que ces nombres doivent être prévisibles par le serveur, sur la base uniquement des données stockées dans le fichier d'origine, l'heure actuelle et un algorithme standard, ils peuvent également être prédits par un attaquant avec des outils spéciaux et l'accès au jeton. (Ou pire, l'accès aux fichiers de départ eux-mêmes - tel quel soupçonné d'avoir eu lieu en 2011 .) Étant donné suffisamment de codes de jetons consécutifs, il existe des outils qui peuvent déterminer la valeur de départ, puis générer de futurs codes sur leur posséder.
La réponse de Sebastian était formidable. Je vais répéter cela en termes simples. Le jeton SecureID est simplement une horloge contenant une valeur de départ. Au lieu d'afficher l'heure, il affiche un nombre. Le point que nous pouvons voir sur l'image est en secondes (je pense), la barre est lorsque le nombre va changer afin que vous puissiez le chronométrer. S'il atteint le fond, il est sur le point de changer et si vous le saisissez, vous voudrez attendre.
La "graine" se trouve également sur le serveur qui authentifie l'appareil. Lorsque les gars de la sécurité installent le serveur RSA, ils doivent charger les mêmes graines dans le serveur qui recevra votre code PIN.
Donc ... Fondamentalement, c'est un cryptoclock. Tout comme les anciennes LCD montres que mes enfants ont avec des dora ou des princesses dessus. La différence est la graine qui fournit le calcul du nombre.