3.2. Processing an Incoming SNMP Message (Traitement d'un message SNMP entrant)

Cette section décrit la procédure suivie par un moteur SNMP chaque fois qu'il reçoit un message contenant une opération de gestion au nom d'un utilisateur, avec un securityLevel particulier.

General Notes (Notes générales)

Pour simplifier les éléments de procédure, la libération des informations d'état n'est pas toujours explicitement spécifiée. En règle générale, si des informations d'état sont disponibles lorsqu'un message est rejeté, les informations d'état doivent également être libérées.

De plus, une indication d'erreur peut renvoyer:

Un OID et une valeur pour un compteur incrémenté
Éventuellement une valeur pour securityLevel
Des valeurs pour contextEngineID ou contextName pour le compteur
Les données securityStateReference si de telles informations sont disponibles au point où l'erreur est détectée

Étape 1: Analyser securityParameters (Parse securityParameters)

Si les securityParameters reçus ne sont pas la sérialisation (selon les conventions de RFC 3417) d'un OCTET STRING formaté selon les UsmSecurityParameters définis dans la section 2.4, alors:

Le compteur snmpInASNParseErrs (RFC 3418) est incrémenté
Une indication d'erreur (parseError) est renvoyée au module appelant

Note: Nous revenons sans l'OID et la valeur du compteur incrémenté, car dans ce cas il n'y a pas suffisamment d'informations pour générer un Report PDU.

Étape 2: Extraire les paramètres de sécurité (Extract Security Parameters)

Les valeurs des champs de paramètres de sécurité sont extraites des securityParameters.

Le securityEngineID à renvoyer à l'appelant est la valeur du champ msgAuthoritativeEngineID
Les cachedSecurityData sont préparés et une securityStateReference est préparée pour référencer ces données

Valeurs à mettre en cache (Values to be cached):

msgUserName
msgAuthoritativeEngineID
msgAuthoritativeEngineBoots
msgAuthoritativeEngineTime
msgAuthenticationParameters
msgPrivacyParameters

Étape 3: Vérifier msgAuthoritativeEngineID (Check msgAuthoritativeEngineID)

Si la valeur du champ msgAuthoritativeEngineID dans les securityParameters est inconnue, alors:

Option a) Mode découverte (moteur non autorisé) (Discovery Mode)

Un moteur SNMP non autorisé qui effectue la découverte peut éventuellement créer une nouvelle entrée dans son magasin de données de configuration local (LCD) et continuer le traitement.

Option b) Renvoyer une erreur (Return Error)

Le compteur usmStatsUnknownEngineIDs est incrémenté, et une indication d'erreur (unknownEngineID) avec l'OID et la valeur du compteur incrémenté est renvoyée au module appelant.

Note: Dans le cas où un msgAuthoritativeEngineID de longueur nulle ou de taille illégale est reçu, l'option b) devrait être choisie pour faciliter la découverte d'engineID. Sinon, le choix entre a) et b) est une question d'implémentation.

Étape 4: Rechercher les informations utilisateur (Lookup User Information)

Les informations sur les valeurs des champs msgUserName et msgAuthoritativeEngineID sont extraites du magasin de données de configuration local (LCD, usmUserTable).

Si aucune information n'est disponible pour l'utilisateur, alors:

Le compteur usmStatsUnknownUserNames est incrémenté
Une indication d'erreur (unknownSecurityName) avec l'OID et la valeur du compteur incrémenté est renvoyée au module appelant

Étape 5: Vérifier le support du niveau de sécurité (Check Security Level Support)

Si les informations sur l'utilisateur indiquent qu'il ne prend pas en charge le securityLevel demandé par l'appelant, alors:

Le compteur usmStatsUnsupportedSecLevels est incrémenté
Une indication d'erreur (unsupportedSecurityLevel) avec l'OID et la valeur du compteur incrémenté est renvoyée au module appelant

Étape 6: Authentifier le message (si nécessaire) (Authenticate Message)

Si le securityLevel spécifie que le message doit être authentifié, alors le message est authentifié selon le protocole d'authentification de l'utilisateur.

Pour ce faire, un appel est effectué au module d'authentification qui implémente le protocole d'authentification de l'utilisateur selon la primitive de service abstraite:

statusInformation =          -- succès ou échec
  authenticateIncomingMsg(
  IN   authKey               -- authKey localisée de l'utilisateur
  IN   authParameters        -- tel que reçu sur le fil
  IN   wholeMsg              -- tel que reçu sur le fil
  OUT  authenticatedWholeMsg -- vérifié pour l'authentification
       )

Paramètres (Parameters):

statusInformation: Indique si l'authentification a réussi ou non
authKey: L'authKey privée localisée de l'utilisateur est la clé secrète qui peut être utilisée par l'algorithme d'authentification
authParameters: Les msgAuthenticationParameters tels que reçus dans le message
wholeMsg: Le message sérialisé complet à authentifier
authenticatedWholeMsg: Identique à l'entrée donnée au service authenticateIncomingMsg, mais après vérification de l'authentification

Gestion des erreurs (Error Handling):

Si le module d'authentification renvoie un échec, alors le message ne peut pas être fiable, donc:

Le compteur usmStatsWrongDigests est incrémenté
Une indication d'erreur (authenticationFailure) avec l'OID et la valeur du compteur incrémenté est renvoyée au module appelant

Si le module d'authentification renvoie un succès, alors le message est authentique et peut être fiable, donc le traitement continue.

Étape 7: Vérifier la fenêtre temporelle (pour les messages authentifiés) (Check Time Window)

Si le securityLevel indique un message authentifié, alors les valeurs locales de snmpEngineBoots, snmpEngineTime et latestReceivedEngineTime correspondant à la valeur du champ msgAuthoritativeEngineID sont extraites du magasin de données de configuration local.

7a) Moteur autorisé (msgAuthoritativeEngineID == snmpEngineID local)

Si la valeur extraite de msgAuthoritativeEngineID est identique à la valeur de snmpEngineID du moteur SNMP de traitement (ce qui signifie que c'est le moteur SNMP autorisé), alors si l'une des conditions suivantes est vraie, le message est considéré comme étant en dehors de la fenêtre temporelle:

La valeur locale de snmpEngineBoots est 2147483647 (valeur maximale atteinte)
La valeur du champ msgAuthoritativeEngineBoots diffère de la valeur locale de snmpEngineBoots
La valeur du champ msgAuthoritativeEngineTime diffère de la notion locale de snmpEngineTime de plus de +/- 150 secondes

Si en dehors de la fenêtre temporelle:

Le compteur usmStatsNotInTimeWindows est incrémenté
Une indication d'erreur (notInTimeWindow) avec l'OID, la valeur du compteur incrémenté, et une indication que l'erreur doit être rapportée avec un securityLevel de authNoPriv, est renvoyée au module appelant

7b) Moteur non autorisé (msgAuthoritativeEngineID != snmpEngineID local)

Si la valeur extraite de msgAuthoritativeEngineID n'est pas identique à la valeur snmpEngineID du moteur SNMP de traitement (ce qui signifie que ce n'est pas le moteur SNMP autorisé), alors:

7b.1) Mettre à jour les informations temporelles (si plus récentes) (Update Time Information)

Si au moins une des conditions suivantes est vraie:

La valeur extraite du champ msgAuthoritativeEngineBoots est supérieure à la notion locale de la valeur de snmpEngineBoots; OU
La valeur extraite du champ msgAuthoritativeEngineBoots est égale à la notion locale de la valeur de snmpEngineBoots, ET la valeur extraite du champ msgAuthoritativeEngineTime est supérieure à la valeur de latestReceivedEngineTime

Alors l'entrée LCD correspondant à la valeur extraite du champ msgAuthoritativeEngineID est mise à jour, en définissant:

La notion locale de la valeur de snmpEngineBoots à la valeur du champ msgAuthoritativeEngineBoots
La notion locale de la valeur de snmpEngineTime à la valeur du champ msgAuthoritativeEngineTime
Le latestReceivedEngineTime à la valeur du champ msgAuthoritativeEngineTime

7b.2) Vérifier la fenêtre temporelle (Check Time Window)

Si l'une des conditions suivantes est vraie, alors le message est considéré comme étant en dehors de la fenêtre temporelle:

La notion locale de la valeur de snmpEngineBoots est 2147483647
La valeur du champ msgAuthoritativeEngineBoots est inférieure à la notion locale de la valeur de snmpEngineBoots
La valeur du champ msgAuthoritativeEngineBoots est égale à la notion locale de la valeur de snmpEngineBoots ET la valeur du champ msgAuthoritativeEngineTime est de plus de 150 secondes inférieure à la notion locale de la valeur de snmpEngineTime

Si en dehors de la fenêtre temporelle:

Le compteur usmStatsNotInTimeWindows est incrémenté
Une indication d'erreur (notInTimeWindow) avec l'OID et la valeur du compteur incrémenté est renvoyée au module appelant

Étape 8: Déchiffrer le message (si nécessaire) (Decrypt Message)

Si le securityLevel indique que le message est protégé contre la divulgation (confidentialité), alors l'OCTET STRING représentant l'encryptedPDU est déchiffré selon le protocole de confidentialité de l'utilisateur.

Pour ce faire, un appel est effectué au module de confidentialité qui implémente le protocole de confidentialité de l'utilisateur selon la primitive de service abstraite:

statusInformation =         -- succès ou échec
  decryptData(
  IN    decryptKey          -- privKey localisée de l'utilisateur
  IN    privParameters      -- tel que reçu sur le fil
  IN    encryptedData       -- encryptedPDU tel que reçu
  OUT   decryptedData       -- scopedPDU déchiffré
        )

Paramètres (Parameters):

statusInformation: Indique si le processus de déchiffrement a réussi ou non
decryptKey: La privKey privée localisée de l'utilisateur est la clé secrète utilisée par l'algorithme de déchiffrement
privParameters: Les msgPrivacyParameters tels que reçus dans le message
encryptedData: L'encryptedPDU du message
decryptedData: Le scopedPDU déchiffré

Gestion des erreurs (Error Handling):

Si le module de confidentialité renvoie un échec, alors le message ne peut pas être traité, donc:

Le compteur usmStatsDecryptionErrors est incrémenté
Une indication d'erreur (decryptionError) avec l'OID et la valeur du compteur incrémenté est renvoyée au module appelant

Si le module de confidentialité renvoie un succès, alors le scopedPDU déchiffré est utilisé pour un traitement ultérieur.

Étape 9: Renvoyer les résultats (Return Results)

Les valeurs suivantes sont renvoyées au module de traitement de messages appelant:

securityEngineID: Le msgAuthoritativeEngineID
securityName: Le msgUserName
scopedPDU: Soit le scopedPDU déchiffré (si confidentialité) soit le scopedPDU en texte clair
maxSizeResponseScopedPDU: Calculé en fonction des contraintes de taille de message
securityStateReference: Référence aux données de sécurité mises en cache

Processing Flow Summary (Résumé du flux de traitement)

1. Analyser securityParameters
2. Extraire les champs de paramètres de sécurité
3. Vérifier msgAuthoritativeEngineID (inconnu -> erreur ou créer entrée)
4. Rechercher utilisateur dans LCD (utilisateur inconnu -> erreur)
5. Vérifier support niveau de sécurité (non supporté -> erreur)
6. Authentifier message (si authNoPriv ou authPriv)
   └─> Vérifier MAC/résumé (erroné -> erreur)
7. Vérifier fenêtre temporelle (si authentifié)
   └─> Pour autorisé: valider boots et time
   └─> Pour non autorisé: mettre à jour infos temporelles si plus récentes, puis valider
   └─> Hors fenêtre -> erreur
8. Déchiffrer message (si authPriv)
   └─> Déchiffrer encryptedPDU (échec -> erreur)
9. Renvoyer securityEngineID, securityName, scopedPDU, etc.

Error Conditions Summary (Résumé des conditions d'erreur)

Erreur (Error)	Compteur (Counter)	Condition
parseError	snmpInASNParseErrs	Format securityParameters invalide
unknownEngineID	usmStatsUnknownEngineIDs	msgAuthoritativeEngineID inconnu
unknownSecurityName	usmStatsUnknownUserNames	Utilisateur non trouvé dans LCD
unsupportedSecurityLevel	usmStatsUnsupportedSecLevels	Utilisateur ne supporte pas le niveau demandé
authenticationFailure	usmStatsWrongDigests	Vérification authentification échouée
notInTimeWindow	usmStatsNotInTimeWindows	Message hors fenêtre de 150 secondes
decryptionError	usmStatsDecryptionErrors	Déchiffrement échoué

Implementation Notes (Notes d'implémentation)

Gestion d'état (State Management): Les implémentations doivent gérer et libérer correctement les données securityStateReference
Génération de rapports (Report Generation): De nombreuses erreurs entraînent l'envoi de Report PDU avec les compteurs d'erreur appropriés à l'expéditeur
Synchronisation temporelle (Time Synchronization): Les moteurs non autorisés mettent automatiquement à jour leurs informations temporelles lors de la réception de messages avec des valeurs temporelles plus récentes des moteurs autorisés
Découverte (Discovery): Les moteurs non autorisés peuvent éventuellement apprendre de nouveaux moteurs en créant des entrées LCD pendant la découverte
Niveau de sécurité dans les rapports (Security Level in Reports): L'erreur notInTimeWindow doit être rapportée avec securityLevel authNoPriv (pas authPriv) pour permettre à l'expéditeur de recevoir et traiter le rapport