Guide de dépannage de l'authentificateur RADIUS et de l'authentificateur de message non valide

Introduction

Ce document décrit l'en-tête d'authentificateur RADIUS et l'attribut d'authentificateur de message, comment ils sont utilisés et quand s'attendre à un échec de validation.

En-Tête Authenticator

Selon RFC 2865, l'en-tête d'authentificateur a une longueur de 16 octets. Lorsqu'il est utilisé dans une requête d'accès, il est appelé authentificateur de requête. Lorsqu'il est utilisé dans n'importe quel type de réponse, il est appelé authentificateur de réponse. Il est utilisé pour :

• Authentification de la réponse
• Masquage de mot de passe

Authentification de la réponse

Si le serveur répond avec l'authentificateur de réponse correct, le client peut calculer si cette réponse était liée à une demande valide.

Le client envoie la requête avec l'en-tête d'authentificateur aléatoire. Ensuite, le serveur qui envoie la réponse calcule l'authentificateur de réponse avec l'utilisation du paquet de requête avec le secret partagé :

ResponseAuth = MD5(Code + ID + Length + RequestAuth + Attributes + Secret) 

Le client qui reçoit la réponse effectue la même opération. Si le résultat est le même, le paquet est correct.

Remarque : Le pirate qui connaît la valeur secrète ne peut pas usurper la réponse à moins qu'il ne soit en mesure de détecter la demande.

Quand s'attendre à un échec de validation :

L'échec de la validation se produit si le commutateur ne met plus la demande en cache (par exemple, en raison du délai d'attente). Vous pouvez également l'observer lorsque le secret partagé n'est pas valide (yes - Access-Reject inclut également cet en-tête). De cette manière, le périphérique d'accès réseau (NAD) peut détecter la non-concordance du secret partagé. Généralement, il est signalé par les clients/serveurs AAA (Authentication, Authorization, and Accounting) comme une non-concordance de clé partagée, mais il ne révèle pas les détails.

Masquage du mot de passe

L'en-tête Authenticator est également utilisé afin d'éviter l'envoi de l'attribut User-Password en texte clair. Le Message Digest 5 (MD5 - secret, authentificateur) est d'abord calculé. Ensuite, plusieurs opérations XOR avec les blocs du mot de passe sont exécutées. Cette méthode est sensible aux attaques hors ligne (tables arc-en-ciel), car MD5 n'est plus perçu comme un algorithme unidirectionnel fort.

Voici le script Python qui calcule le User-Password :

def Encrypt_Pass(password, authenticator, secret):
        m = md5()
        m.update(secret+authenticator)
        return "".join(chr(ord(x) ^ ord(y)) for x, y in zip(password.ljust
       (16,'\0')[:16], m.digest()[:16]))

Retransmissions

Si l'un des attributs de la demande d'accès RADIUS a changé (comme l'ID RADIUS, le nom d'utilisateur, etc.), le nouveau champ Authenticator doit être généré et tous les autres champs qui en dépendent doivent être recalculés. S'il s'agit d'une retransmission, rien ne change.

Gestion de comptes

La signification de l'en-tête Authenticator est différente pour une demande d'accès et une demande de compte.

Dans le cas d'une demande d'accès, l'authentificateur est généré aléatoirement et il est censé recevoir une réponse avec l'authentificateur ResponseAuthenticator calculé correctement, ce qui prouve que la réponse était liée à cette demande spécifique.

Pour une demande de compte, l'authentificateur n'est pas aléatoire, mais il est calculé (selon RFC 2866) :

RequestAuth = MD5(Code + ID + Length + 16 zero octets + Attributes + Secret) 

De cette manière, le serveur peut vérifier immédiatement le message de gestion des comptes et abandonner le paquet si la valeur recalculée ne correspond pas à la valeur de l'authentificateur. Identity Services Engine (ISE) renvoie :

11038 RADIUS Accounting-Request header contains invalid Authenticator field

La raison typique de cette erreur est la clé secrète partagée incorrecte.

Attribut d'authentificateur de message

L'attribut Message-Authenticator est l'attribut RADIUS défini dans la RFC 3579. Il est utilisé dans un but similaire : pour signer et valider. Mais cette fois, il n'est pas utilisé pour valider une réponse mais une requête.

Le client qui envoie une requête d'accès (il peut également s'agir d'un serveur qui répond par une demande d'accès) calcule le code d'authentification de message à base de hachage (HMAC)-MD5 à partir de son propre paquet, puis ajoute l'attribut Message-Authenticator en tant que signature. Ensuite, le serveur est en mesure de vérifier qu'il effectue la même opération.

La formule ressemble à l'en-tête Authenticator :

Message-Authenticator = HMAC-MD5 (Type, Identifier, Length, Request Authenticator,
Attributes)

La fonction HMAC-MD5 prend en charge deux arguments :

• Charge utile du paquet, qui inclut le champ Message-Authenticator de 16 octets rempli de zéros
• Le secret partagé

Quand utiliser l'authentificateur de message ?

L'authentificateur de message doit être utilisé pour chaque paquet, qui inclut le message EAP (Extensible Authentication Protocol) (RFC 3579). Cela inclut à la fois le client qui envoie la demande d'accès et le serveur qui répond avec la demande d'accès. L'autre côté abandonne silencieusement le paquet si la validation échoue.

Quand s'attendre à un échec de validation :

Un échec de validation se produit lorsque le secret partagé n'est pas valide. Ensuite, le serveur AAA n'est pas en mesure de valider la requête.

L'ISE rapporte :

11036 The Message-Authenticator Radius Attribute is invalid.

Cela se produit généralement à un stade ultérieur lorsque le message EAP est joint. Le premier paquet RADIUS de la session 802.1x n'inclut pas le message EAP ; il n'y a pas de champ Message-Authenticator et il n'est pas possible de vérifier la demande, mais à ce stade, le client peut valider la réponse à l'aide du champ Authenticator.

Valider l'attribut d'authentificateur de message

Voici un exemple pour illustrer comment vous comptez manuellement la valeur afin de vous assurer qu'elle est calculée correctement.

Le paquet numéro 30 (Access-Request) a été choisi. Il se trouve au milieu de la session EAP et le paquet inclut le champ Message-Authenticator. L'objectif est de vérifier que l'authentificateur de message est correct :

1. Cliquez avec le bouton droit sur Protocole Radius et choisissez Exporter les octets de paquets sélectionnés.
   
   
2. Écrivez cette charge utile RADIUS dans un fichier (données binaires).
   
   
3. Afin de calculer le champ Message-Authenticator, vous devez y mettre des zéros et calculer le HMAC-MD5.
   
   Par exemple, lorsque vous utilisez un éditeur hexadécimal/binaire, tel que vim, après avoir tapé « : %!xxd », qui passe en mode hexadécimal et met des zéros sur 16 octets en commençant après « 5012 » (50hex correspond à 80 dans dec, ce qui correspond au type Message-Authenticator, et 12 correspond à la taille qui correspond à 18, y compris l'en-tête des paires de valeurs d'attribut (AVP)) :
   
   Veuillez noter que vim et d'autres éditeurs de texte peuvent ajouter un caractère LineFeed supplémentaire ('0a' en hexadécimal) à la fin du fichier lors de l'enregistrement. Veillez à utiliser le mode binaire de votre éditeur de texte (fichier vim -b) pour empêcher l'affichage du caractère LineFeed. 
   
   

   

   
   Après cette modification, la charge utile est prête. Il est nécessaire de revenir au mode hexadécimal/binaire (type : ":%!xxd -r") et enregistrez le fichier (":wq"). Vous pouvez vérifier qu'un caractère LineFeed supplémentaire n'a pas été ajouté à l'aide de 'hexdump -C file'. 
   
   
4. Utilisez OpenSSL afin de calculer HMAC-MD5 :
   
   

   pluton # cat packet30-clear-msgauth.bin | openssl dgst -md5 -hmac 'cisco'
   (stdin)= 01418d3b1865556918269d3cf73608b0

   
   
   La fonction HMAD-MD5 prend deux arguments : la première entrée standard (stdin) est le message lui-même et la seconde est le secret partagé (Cisco dans cet exemple). Le résultat est exactement la même valeur que l'authentificateur de message attaché au paquet de demande d'accès RADIUS.

La même chose peut être calculée avec l'utilisation du script Python :

 Python 2 :

pluton # cat hmac.py 
#!/usr/bin/env python

import base64
import hmac
import hashlib

f = open('packet30-clear-msgauth.bin', 'rb')
try:
    body = f.read()
finally:
    f.close()

digest = hmac.new('cisco', body, hashlib.md5)
d=digest.hexdigest()
print d

pluton # python hmac.py 
01418d3b1865556918269d3cf73608b0

Python 3 :

import hmac
import hashlib

with open('packet30-clear-msgauth.bin', 'rb') as f:
    body = f.read()

digest = hmac.new(b'cisco', body, hashlib.md5)
print(digest.hexdigest())

L'exemple précédent montre comment calculer le champ Message-Authenticator à partir de la requête d'accès. Pour Access-Challenge, Access-Accept et Access-Reject, la logique est exactement la même, mais il est important de se rappeler que Request Authenticator doit être utilisé, qui est fourni dans le paquet Access-Request précédent.

Informations connexes

• RFC 2865
• RFC 2866
• RFC 3579
• Assistance et documentation techniques - Cisco Systems