
Lors d’un test d’intrusion sur une application web, nous avons identifié une vulnérabilité permettant de prendre le contrôle de n’importe quel compte utilisateur en exploitant le mécanisme de réinitialisation de mot de passe. L’attaque reposait sur une technique dite sandwich attack (attaque sandwich) et sur l’utilisation de System.Random, un générateur de nombres pseudo-aléatoires non cryptographique de C#.
Utiliser un générateur aléatoire inadapté pour produire des secrets est une mauvaise pratique connue. Ce cas concret montre toutefois que ses conséquences ne sont pas seulement théoriques : un mot de passe temporaire apparemment aléatoire peut devenir prévisible et conduire à une compromission de compte.
Dans cet article, nous détaillons l’origine de la vulnérabilité, la manière dont nous l’avons exploitée et les conditions qui ont rendu cette attaque possible.
Dans l’application auditée, le parcours de réinitialisation était le suivant :
Le problème ne venait pas de l’envoi du mot de passe par e-mail, mais de la manière dont ce mot de passe temporaire était généré.
System.RandomLe fonctionnement de la fonction de génération pouvait être représenté par le code C# suivant :
public string genPass()
{
var charset = new List<string> {
"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m",
"n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",
"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"
};
var random = new Random();
var password = string.Empty;
int ind;
for (var i = 0; i < 8; i++)
{
ind = random.Next(0, charset.length);
password += charset[ind];
}
return password;
}
La fonction utilise un ensemble de 36 caractères (les lettres minuscules de l’alphabet et les chiffres de 0 à 9). Pour chacun des huit caractères du mot de passe, System.Random produit un indice qui permet de sélectionner un caractère dans cet ensemble.
À première vue, les mots de passe obtenus semblent aléatoires. Pourtant, leur sécurité dépend entièrement de la prévisibilité du générateur utilisé.
System.Random rend-il ces mots de passe prévisibles ?La classe System.Random produit des suites de valeurs pseudo-aléatoires. Elle peut être initialisée à partir d’une valeur explicite, appelée graine ou seed, ou sans argument au moyen du constructeur Random().
Une même graine produit une même suite de valeurs. Si un attaquant parvient à retrouver la graine utilisée, il peut donc reproduire la séquence générée et, dans notre cas, le mot de passe temporaire associé.
La documentation Microsoft précise d’ailleurs que System.Random ne doit pas être employé pour générer des valeurs nécessitant une sécurité cryptographique, comme des mots de passe, et recommande d’utiliser System.Security.Cryptography.RandomNumberGenerator.
Environment.TickCount sous .NET Framework 4.8.1Restait à comprendre comment Random() était initialisé en l’absence de graine explicite.
La documentation du constructeur indique que la valeur par défaut dépend de l’horloge système, sans détailler complètement son calcul. Plusieurs sources consacrées aux anciennes versions de .NET Framework mentionnaient l’utilisation de Environment.TickCount.
Pour vérifier ce comportement dans .NET Framework 4.8.1, nous avons décompilé mscorlib.dll avec dnSpy et retrouvé l’implémentation suivante :
public Random() : this(Environment.TickCount) { }
public Random(int Seed)
{
int num = (Seed == int.MinValue)
? int.MaxValue
: Math.Abs(Seed);
// ...
}
La propriété Environment.TickCount correspond au nombre de millisecondes écoulées depuis le démarrage du système, exprimé sous la forme d’un entier signé sur 32 bits (Int32).
Deux caractéristiques sont essentielles pour comprendre l’attaque : la graine évolue de façon prévisible avec le temps et le nombre de valeurs possibles est limité.
Un entier signé sur 32 bits possède théoriquement 2³² représentations. Mais l’implémentation observée utilise la valeur absolue des graines négatives, avec un traitement particulier de int.MinValue. La plage effective des valeurs internes se limite donc à 2³¹ possibilités au maximum, soit environ 2,15 milliards de graines.
Cette taille est suffisamment réduite pour envisager une recherche exhaustive locale. Surtout, la relation avec Environment.TickCount permet d’aller plus loin : il n’est pas nécessaire de tester toutes ces possibilités pour prédire le mot de passe d’une victime.
Une attaque sandwich consiste ici à provoquer trois réinitialisations successives, dans un intervalle de temps aussi court que possible :
Le mot de passe inconnu de la victime se retrouve ainsi « pris en sandwich » entre deux mots de passe que nous pouvons observer.
Après ces trois requêtes, l’exploitation se poursuit localement.
Nous recherchons par force brute la graine permettant de reproduire le premier mot de passe temporaire, puis celle correspondant au second. Appelons-les seed1 et seed2.
Puisque les trois mots de passe ont été générés successivement, leurs graines sont liées à l’évolution de Environment.TickCount. Tant que les générations se situent dans une même plage où la graine évolue sans discontinuité, la graine de la victime est comprise entre les deux graines retrouvées.
Dans une plage où les valeurs progressent, cela se traduit par :
seed1 < seed_victime < seed2
Lorsque la valeur absolue appliquée à une période négative de TickCount inverse le sens d’évolution, l’encadrement reste possible, mais l’ordre des deux bornes est inversé. Les changements de signe et le retour cyclique du compteur doivent donc être pris en compte.
Il suffit ensuite de parcourir les graines comprises entre les deux bornes et de générer, pour chacune, le mot de passe correspondant à l’aide du même algorithme pseudo-aléatoire et du même ordre de caractères.
Cette opération aboutit à une liste réduite de mots de passe candidats pouvant être testés sur le compte cible, sans jamais avoir consulté l’e-mail reçu par la victime.
Pour nos essais, nous avons réimplémenté en Python l’algorithme de génération pseudo-aléatoire de System.Random utilisé par l’application.
Dans nos conditions de test, la recherche des deux graines et la génération des mots de passe candidats ont pris environ quatre à cinq minutes.
La liste finale contenait environ 3 000 mots de passe possibles, contre un espace de recherche bien plus vaste si l’on ne connaissait que la longueur du mot de passe et les caractères autorisés.
Un tel nombre de candidats peut rester exploitable malgré certains mécanismes de limitation des tentatives. L’efficacité réelle de l’attaque dépend néanmoins des protections mises en place : limitation du débit, verrouillage de compte et détection des tentatives répétées, notamment.
Gestion du compteur système
Environment.TickCount est un entier signé sur 32 bits. Au bout d’environ 24,9 jours de fonctionnement, il passe de Int32.MaxValue à Int32.MinValue, puis continue à évoluer jusqu’à zéro au cours des 24,9 jours suivants. Cette particularité n’empêche pas l’exploitation, mais elle impose de tenir compte du passage entre plages de valeurs et de l’utilisation de Math.Abs. Les deux bornes doivent être interprétées dans une portion cohérente de cette évolution.
Version de .NET
Nos vérifications concernent une application utilisant .NET Framework 4.8.1. Le comportement d’initialisation de System.Random a évolué dans .NET Core et les versions modernes de .NET. Nos essais n’y ont pas reproduit cette attaque dans les mêmes conditions : les résultats présentés ici ne doivent donc pas être généralisés à toutes les versions de .NET.
Apport d’un assistant IA
L’outil Claude a également contribué à repérer la vulnérabilité dans le code source et à accompagner son exploitation.
Dans l’audit présenté, nous disposions du code source. Nous connaissions donc non seulement les caractères utilisés pour générer les mots de passe, mais aussi leur ordre exact dans l’ensemble charset. Cette information facilite la reproduction des mots de passe à partir des graines retrouvées.
Nous nous sommes demandé si l’attaque resterait envisageable lorsque cet ensemble de caractères n’est pas accessible, par exemple parce qu’il est défini dans un autre dépôt de code.
Nos expérimentations ont montré qu’il était possible de reconstituer l’ensemble de caractères et son ordre à partir de plusieurs mots de passe temporaires générés par l’application. Nous désignons ces mots de passe observés comme des échantillons.
charset à partir d’échantillons de mots de passeL’idée consiste à confronter, pour chaque graine candidate, la séquence d’indices produite par le générateur avec les caractères présents dans les échantillons.
La méthode expérimentée suit les étapes suivantes :
Pour retrouver l’ensemble complet, il faut que chaque caractère de charset apparaisse au moins une fois parmi les échantillons collectés.
Nous avons testé cette approche sur 30 à 40 échantillons de huit caractères, produits localement. Les échantillons retenus présentaient un grand nombre de répétitions (environ cinq caractères répétés sur huit) ce qui facilitait l’élimination précoce des graines incohérentes et limitait la consommation mémoire.
Ces résultats confirment la faisabilité de la reconstruction dans les conditions de notre expérimentation. En revanche, obtenir autant d’échantillons présentant ces caractéristiques depuis une application distante demanderait davantage de temps. Nous n’avons pas poussé les optimisations ni réalisé d’expérimentations supplémentaires sur ce point.
Nous avons également examiné brièvement les implémentations de fonctions random() dans plusieurs langages de programmation.
Certaines reposent sur un espace de graines de 32 bits. Toutefois, parmi les implémentations testées, aucune ne réunissait à elle seule les deux caractéristiques indispensables au scénario étudié : un espace de graines limité et une initialisation temporelle dont l’évolution permet d’encadrer la valeur inconnue.
L’existence d’un générateur pseudo-aléatoire non cryptographique ne suffit donc pas, à elle seule, à reproduire cette attaque sandwich. Les détails de son initialisation et du contexte applicatif sont déterminants.
La correction principale consiste à ne jamais utiliser un générateur pseudo-aléatoire généraliste pour produire une valeur sensible : mot de passe temporaire, jeton de réinitialisation, jeton de session, nonce, secret ou clé cryptographique.
Dans l’écosystème .NET, Microsoft recommande la classe System.Security.Cryptography.RandomNumberGenerator, conçue pour générer des valeurs aléatoires adaptées aux usages cryptographiques.
Le point essentiel est de s’assurer que l’imprévisibilité du secret repose sur un générateur cryptographiquement sûr, et non sur un état interne ou une graine qu’un attaquant pourrait reconstituer à partir du temps écoulé.
Cette vulnérabilité illustre comment un choix d’implémentation apparemment anodin peut compromettre une fonctionnalité critique. Dans l’application auditée, l’utilisation de System.Random pour générer les mots de passe temporaires, combinée à une initialisation prévisible sous .NET Framework, a rendu possible une attaque sandwich aboutissant à la prédiction du mot de passe d’un autre utilisateur.
Au-delà de ce cas particulier, l’enseignement est simple : la sécurité d’un mot de passe ou d’un jeton ne dépend pas seulement de sa longueur ou de son apparence aléatoire, mais aussi de la qualité du mécanisme qui le génère.
Auteur : Souad SEBAA – Pentester @Vaadata