Key Manager (KeyM)

La fonction KeyM_Init sert à initialiser le module Key Management ([SWS_KeyM_00043]). L'appel s'effectue de manière synchrone et est défini comme non réentrant ([SWS_KeyM_00043]). Comme unique paramètre de transmission, ConfigPtr est attendu, lequel représente un pointeur vers le jeu de données de configuration pour VARIANT-POST-BUILD ; la fonction ne possède pas de valeur de retour ([SWS_KeyM_00043]).

En ce qui concerne l'interaction avec d'autres fonctions du module, KeyM_Init constitue une précondition obligatoire : lorsque la détection des erreurs de développement est activée, toutes les autres fonctions du Key Manager vérifient si le module a été préalablement initialisé via KeyM_Init et n'a pas encore été désinitialisé au moyen de KeyM_Deinit ([SWS_KeyM_00144]). Si une fonction de module est appelée à l'état non initialisé, le Key Manager signale l'erreur de développement KEYM_E_UNINIT ([SWS_KeyM_00144]).

Comme KeyM_Init est spécifiée comme non réentrante ([SWS_KeyM_00043]), la fonction ne doit être exécutée qu'une seule fois et à l'exclusion de tout appel concurrent durant la phase d'initialisation du système. Après exécution réussie, le module est disponible via le fichier d'en-tête KeyM.h ([SWS_KeyM_00043]).

La fonction KeyM_Deinit sert à réinitialiser le module Key Manager à l'état non initialisé ([SWS_KeyM_00047]).

Utilisation et contexte d'appel

L'appel de KeyM_Deinit s'effectue de manière synchrone et est spécifié comme non réentrant (Non Reentrant). La fonction possède l'identifiant de service 0x02, n'accepte aucun paramètre et ne renvoie aucune valeur de retour ([SWS_KeyM_00047]).

Concurrence et interaction

En raison de sa non-réentrance, KeyM_Deinit ne doit pas être appelée de manière concurrente avec elle-même ni en contradiction avec des opérations en cours. Après l'exécution de cette désinitialisation, le module se trouve à l'état non initialisé. Si les erreurs de développement sont activées, le Key Manager vérifie lors de chaque appel de fonction ultérieur si le module a été préalablement initialisé via KeyM_Init() et n'a pas encore été désinitialisé au moyen de KeyM_Deinit() ; dans le cas contraire, l'erreur de développement KEYM_E_UNINIT est signalée ([SWS_KeyM_00144]).

La fonction synchrone KeyM_Start sert à autoriser des opérations de mise à jour de clés dans le Key Manager ([SWS_KeyM_00050]). Elle est optionnelle et n'est disponible que si le paramètre de configuration KeyMCryptoKeyStartFinalizeFunctionEnabled est configuré sur true (AUTOSAR_SWS_KeyManager p. 35). La fonction est mise à disposition via KeyM.h et attend, via StartType, le mode de fonctionnement à exécuter ainsi que, via Request Data et Request Data Length, des données de requête supplémentaires telles qu'une signature.

Les données de réponse sont retournées via le tampon de sortie Response Data. Le paramètre Response Data Length fait alors office de paramètre d'entrée et de sortie : avant l'appel, il définit le nombre maximal d'octets disponibles dans le tampon ; après l'exécution, il contient la longueur des données réellement écrites ([SWS_KeyM_00050]).

Gestion des erreurs et valeurs de retour :

• E_OK : opération de démarrage exécutée avec succès ; les mises à jour de clés sont désormais autorisées.
• E_NOT_OK : opération de démarrage non acceptée.
• KEYM_E_PARAMETER_MISMATCH : les paramètres transmis ne correspondent pas aux valeurs attendues.
• KEYM_E_KEY_CERT_SIZE_MISMATCH : une taille de paramètre transmise ne correspond pas à la taille attendue.

La fonction est spécifiée comme non réentrante (Non Reentrant) ([SWS_KeyM_00050]). Aucun mécanisme de verrouillage interne au module n'étant décrit, l'appelant devrait devoir assurer une exécution coordonnée et sérialisée. Question Q-82276b712a8dd170 (ouverte)

La fonction synchrone KeyM_Prepare sert à préparer une mise à jour de clé (Key Update Operation) et transmet les informations requises au serveur de clés ou déclenche la négociation d'un secret partagé en vue de la dérivation de clé [SWS_KeyM_00051]. La fonction possède l'identifiant de service 0x05, est déclarée via l'en-tête KeyM.h et est exclusivement disponible lorsque le paramètre de configuration Key MCrypto Key Prepare Function Enabled est défini sur TRUE [SWS_KeyM_00051].

Lors de l'appel, les tampons et indications de longueur suivants doivent être transmis [SWS_KeyM_00051] :

• Request Data et Request Data Length : données d'entrée et leur longueur pour la requête [SWS_KeyM_00051].
• Response Data : pointeur vers le tampon destiné à recevoir les données de sortie [SWS_KeyM_00051].
• Response Data Length : paramètre d'entrée/sortie indiquant la taille de tampon maximale disponible avant l'appel et contenant, au retour, le nombre d'octets réellement écrits [SWS_KeyM_00051].

Si l'appel est acquitté par E_OK, le service a été accepté et fait l'objet d'un traitement interne ; les résultats finaux sont ensuite mis à disposition via un rappel (callback) [SWS_KeyM_00051]. En cas d'échec de l'acceptation, la fonction renvoie E_NOT_OK en cas d'erreurs internes, KEYM_E_PARAMETER_MISMATCH en cas de valeurs de paramètres divergentes ou KEYM_E_KEY_CERT_SIZE_MISMATCH en cas d'indications de taille inadéquates [SWS_KeyM_00051].

Comme KeyM_Prepare est spécifiée comme non réentrante (Non Reentrant), aucun appel simultané ou imbriqué ne doit avoir lieu [SWS_KeyM_00051].

La fonction KeyM_Finalize finalise les opérations de mise à jour de clés et ramène l'opération de clé à l'état de repos (mode Idle) [SWS_KeyM_00053]. Elle est généralement utilisée conjointement à une opération KeyM_Start précédente. Après l'appel, le module n'accepte plus d'autres opérations de préparation ou de mise à jour (Prepare/Update) jusqu'à ce qu'un nouveau déroulement soit initié via KeyM_Start [SWS_KeyM_00053]. En outre, le matériel de clé mis à jour est persisté et basculé à l'état valide par l'appel de Csm_KeySetValid [SWS_KeyM_00053].

Utilisation et concurrence : KeyM_Finalize est non réentrante (Non Reentrant) et fonctionne de manière asynchrone [SWS_KeyM_00053]. Interprétation : en raison de l'absence de réentrance, l'appel devrait typiquement avoir lieu dans le contexte d'une tâche. Question Q-895ebec2d0d2e635 (ouverte) L'interface n'est disponible que si le paramètre de configuration KeyMCryptoKeyStartFinalizeFunctionEnabled est défini sur TRUE, et est déclarée via KeyM.h [SWS_KeyM_00053].

Paramètres et valeurs de retour : des données spécifiques à la requête sont transmises via RequestDataPtr et RequestDataLength. Les données de réponse sont mises à disposition via ResponseDataPtr ; ResponseMaxDataLength sert de taille de tampon en entrée et fournit le nombre effectif d'octets lors d'un retour synchrone [SWS_KeyM_00053]. Si l'opération est acceptée et traitée en interne, la fonction renvoie E_OK (les résultats suivent de manière asynchrone par rappel) et ResponseMaxDataLength reste inchangé [SWS_KeyM_00053].

Traitement des erreurs : en cas d'erreur, KeyM_Finalize signale l'échec par des valeurs de retour spécifiques [SWS_KeyM_00053] :

• E_NOT_OK : opération non acceptée en raison d'une erreur interne.
• KEYM_E_BUSY : le KeyM est occupé par d'autres requêtes ; la validation ne peut pas encore être effectuée.
• KEYM_E_PARAMETER_MISMATCH : les paramètres ne correspondent pas à la valeur attendue.
• KEYM_E_KEY_CERT_SIZE_MISMATCH : la taille du paramètre ne correspond pas.

Utilisation

La fonction synchrone KeyM_SetCertificate transmet des données de certificat au module de gestion des clés afin de mémoriser temporairement un certificat [SWS_KeyM_00057]. Elle attend comme paramètres d'entrée l'identifiant du certificat CertId (type KeyM_CertificateIdType) ainsi que le pointeur CertificateDataPtr (type const KeyM_CertDataType*), qui référence la structure de certificat à fournir [SWS_KeyM_00057]. L'interface est déclarée via l'en-tête KeyM.h et possède l'identifiant de service 0x0a [SWS_KeyM_00057].

Valeurs de retour et gestion des erreurs

La valeur de retour de type Std_ReturnType renseigne sur l'acceptation des données [SWS_KeyM_00057] :

• E_OK : le certificat a été accepté avec succès [SWS_KeyM_00057].
• E_NOT_OK : le certificat n'a pas pu être défini [SWS_KeyM_00057].
• KEYM_E_PARAMETER_MISMATCH : les paramètres transmis ne correspondent pas aux valeurs attendues [SWS_KeyM_00057].
• KEYM_E_KEY_CERT_SIZE_MISMATCH : la taille des données de certificat transmises diffère de la taille attendue [SWS_KeyM_00057].

Concurrence et restrictions

La fonction est classée comme non réentrante (Non Reentrant) [SWS_KeyM_00057]. Les appels concurrents doivent donc être synchronisés ou exclus du côté de l'appelant. La spécification prévoyant explicitement une mémorisation temporaire, les données de certificat transmises restent vraisemblablement d'abord dans la mémoire volatile du module avant qu'une mémorisation permanente ou une vérification n'ait lieu. Question Q-c35c4b02344d5bc9 (ouverte)

Utilisation

La fonction synchrone KeyM_GetCertificate sert à fournir les données de certificat pour un identifiant de certificat spécifié [SWS_KeyM_00058]. L'appelant transmet via le paramètre CertId l'identifiant du certificat souhaité ainsi que, via le paramètre Inout CertificateDataPtr, un pointeur vers la structure de données de certificat. Il incombe à l'appelant de fournir le tampon vers lequel pointe le pointeur dans la structure [SWS_KeyM_00058]. Avant l'appel, la longueur maximale de ce tampon doit être indiquée dans la structure ; en cas de retour réussi (E_OK), le champ de longueur contient la longueur réelle des données de certificat fournies [SWS_KeyM_00058].

Gestion des erreurs

La fonction signale le succès ou des erreurs spécifiques via la valeur de retour de type Std_ReturnType [SWS_KeyM_00058] :

• E_OK : Les données de certificat sont disponibles et ont été transmises avec succès.
• KEYM_E_PARAMETER_MISMATCH : l'ID de certificat transmis (CertId) n'est pas valide.
• KEYM_E_KEY_CERT_SIZE_MISMATCH : Le tampon fourni est trop petit pour le certificat.
• KEYM_E_KEY_CERT_EMPTY : Aucune donnée de certificat n'est présente car l'emplacement de certificat est vide.
• KEYM_E_KEY_CERT_READ_FAIL : Le certificat ne peut pas être fourni car l'accès a été refusé.
• E_NOT_OK : L'opération n'a pas été acceptée en raison d'une erreur interne.

Concurrence et restrictions

La fonction est spécifiée comme non réentrante (Non Reentrant) et est disponible via le fichier d'en-tête KeyM.h [SWS_KeyM_00058]. Les appelants doivent par conséquent s'assurer que les appels parallèles à la fonction sont synchronisés entre eux.

La fonction KeyM_VerifyCertificates sert à la vérification asynchrone mutuelle de deux certificats analysés et stockés en interne, conformément à [SWS_KeyM_00059]. Il est alors validé si le certificat subordonné référencé via CertId a été signé par le certificat supérieur référencé avec CertUpperId.

Le service étant défini comme non réentrant (Non Reentrant), il ne doit pas être appelé de manière concurrente pour des opérations qui se chevauchent [SWS_KeyM_00059]. L'exécution s'effectue de manière asynchrone en arrière-plan : une valeur de retour de E_OK signale uniquement l'acceptation réussie de la demande de vérification. Le résultat de vérification proprement dit est communiqué à l'appelant via la fonction de rappel KeyMCertificateVerifyCallbackNotificationFunc configurée, sous réserve que celle-ci soit validement configurée [SWS_KeyM_00153].

Si la demande n'est pas acceptée, la fonction fournit des valeurs de retour spécifiques pour le traitement des erreurs [SWS_KeyM_00059] :

• KEYM_E_BUSY : le Key Manager est occupé par d'autres tâches ; la validation ne peut pas encore être démarrée à cet instant.
• KEYM_E_PARAMETER_MISMATCH : au moins un ID de certificat transmis est invalide.
• KEYM_E_KEY_CERT_EMPTY : l'un des emplacements de certificat référencés est vide.
• KEYM_E_CERT_INVALID_CHAIN_OF_TRUST : le certificat supérieur (CertUpperId) n'est pas valide.
• E_NOT_OK : la demande a été rejetée en raison d'une erreur interne.

La fonction KeyM_VerifyCertificate sert à la vérification asynchrone d'un certificat préalablement fourni via KeyM_SetCertificate() [SWS_KeyM_00060]. Le contrôle s'effectue sur la base de l'identifiant de certificat transmis CertId par rapport à des certificats d'autres ID de certificat déjà enregistrés dans le Key Manager [SWS_KeyM_00060]. La déclaration est disponible via le fichier d'en-tête KeyM.h [SWS_KeyM_00060].

Sémantique d'appel et valeurs de retour

Une valeur de retour de E_OK confirme que la demande de vérification a été acceptée avec succès et que l'opération est exécutée en arrière-plan [SWS_KeyM_00060]. Si la requête ne peut pas être acceptée, le retour s'effectue de manière synchrone via des codes d'erreur spécifiques [SWS_KeyM_00060] :

• E_NOT_OK : L'opération a été rejetée en raison d'une erreur interne [SWS_KeyM_00060].
• KEYM_E_BUSY : Le module KeyM est actuellement occupé par d'autres tâches, de sorte que la validation ne peut pas encore être exécutée [SWS_KeyM_00060].
• KEYM_E_PARAMETER_MISMATCH : la CertId transmise n'est pas valide [SWS_KeyM_00060].
• KEYM_E_KEY_CERT_EMPTY : Au moins l'un des emplacements de certificat requis est vide [SWS_KeyM_00060].
• KEYM_E_CERT_INVALID_CHAIN_OF_TRUST : un certificat supérieur dans la chaîne de confiance est invalide [SWS_KeyM_00060].

Concurrence et asynchronisme

Étant donné que KeyM_VerifyCertificate est spécifiée comme non réentrante (Non Reentrant), l'appelant doit s'assurer qu'aucun appel simultané ou interruptif n'a lieu [SWS_KeyM_00060]. Après l'acceptation réussie de la demande de vérification (retour E_OK), le résultat de l'opération en arrière-plan est transmis à la fonction de rappel configurée KeyMCertificateVerifyCallbackNotificationFunc, pour autant que celle-ci soit dotée d'un nom de fonction valide [SWS_KeyM_00153].

La fonction KeyM_VerifyCertificateChain sert à la vérification asynchrone d'un certificat par rapport à une chaîne de certificats transmis [SWS_KeyM_00061]. Sont transmis comme paramètres l'identifiant du dernier certificat de la chaîne (CertId), un pointeur vers le tableau de certificats trié selon l'ordre PKI (certChainData) ainsi que le nombre de certificats (NumberOfCertificates) [SWS_KeyM_00061]. Avant l'appel, le certificat à vérifier doit avoir été enregistré via KeyM_SetCertificate(), et le certificat racine doit soit figurer dans la liste, soit être déjà affecté à l'un des autres certificats [SWS_KeyM_00061].

La fonction est non réentrante (Non Reentrant) et est mise à disposition via le fichier d'en-tête KeyM.h [SWS_KeyM_00061]. Les valeurs de retour synchrones suivantes indiquent l'état d'acceptation de la demande [SWS_KeyM_00061] :

• E_OK : la demande de vérification a été acceptée et est exécutée en arrière-plan [SWS_KeyM_00061].
• E_NOT_OK : la demande a été rejetée en raison d'une erreur interne [SWS_KeyM_00061].
• KEYM_E_BUSY : le module est occupé par d'autres demandes ; la validation ne peut pas encore être exécutée [SWS_KeyM_00061].
• KEYM_E_PARAMETER_MISMATCH : l'ID de certificat transmis est invalide [SWS_KeyM_00061].
• KEYM_E_KEY_CERT_EMPTY : l'un des emplacements de certificat requis est vide [SWS_KeyM_00061].
• KEYM_E_CERT_INVALID_CHAIN_OF_TRUST : un certificat supérieur dans la chaîne de confiance est invalide [SWS_KeyM_00061].

Si la demande a été acceptée avec E_OK, l'évaluation s'effectue en arrière-plan. Dans la mesure où KeyMCertificateVerifyCallbackNotificationFunc est configurée avec une fonction valide, KeyM renvoie le résultat final de l'opération de vérification à l'application appelante via cette fonction de rappel [SWS_KeyM_00061] [SWS_KeyM_00153].

Utilisation et contexte d'appel

La fonction synchrone KeyM_CertElementGet sert à lire les données d'un élément de certificat spécifique à partir d'un emplacement de certificat dans un tampon fourni par l'appelant [SWS_KeyM_00063]. Elle est utilisée lorsqu'exactement un seul élément est associé à l'identifiant d'objet (OID) configuré dans la configuration de certificat [SWS_KeyM_00063].

L'appelant transmet l'identifiant de certificat CertId, l'identifiant d'élément CertElementId ainsi qu'un pointeur vers le tampon de destination CertElementData [SWS_KeyM_00063]. Le paramètre CertElementDataLength sert de valeur combinée d'entrée et de sortie : avant l'appel, il doit contenir la taille maximale du tampon. En cas de succès (E_OK), il est écrasé par la longueur réelle des données écrites ; en cas d'erreur, la fonction réinitialise à zéro la valeur référencée [SWS_KeyM_00063].

Gestion des erreurs et valeurs de retour

La fonction signale l'état d'exécution via les valeurs de retour suivantes [SWS_KeyM_00063] :

• E_OK : L'élément a été trouvé et copié avec succès dans le tampon [SWS_KeyM_00063].
• E_NOT_OK : Les données de l'élément n'ont pas été trouvées [SWS_KeyM_00063].
• KEYM_E_PARAMETER_MISMATCH : CertId ou CertElementId non valide [SWS_KeyM_00063].
• KEYM_E_KEY_CERT_SIZE_MISMATCH : Le tampon fourni est trop petit pour les données de l'élément [SWS_KeyM_00063].
• KEYM_E_KEY_CERT_EMPTY : Aucune donnée n'existe pour l'emplacement indiqué, l'emplacement est vide [SWS_KeyM_00063].
• KEYM_E_KEY_CERT_INVALID : Le certificat n'est pas valide ou n'a pas encore été vérifié [SWS_KeyM_00063].

concurrence

La fonction est spécifiée comme non réentrante (Non Reentrant) [SWS_KeyM_00063]. En cas d'appels concurrents depuis différentes tâches ou différents contextes, une synchronisation côté appelant devrait donc être nécessaire. Question Q-238a3e53ce0e3a45 (ouverte)

La fonction synchrone KeyM_CertificateElementGetByIndex sert à la lecture ciblée de données d'un élément de certificat sur la base d'un index basé sur zéro (0..N), lorsque plusieurs entrées existent pour un type d'élément [SWS_KeyM_91014]. Elle représente ainsi une alternative d'accès direct à l'itération séquentielle.

Utilisation et paramètres

L'appelant transmet l'identifiant de certificat CertId, l'identifiant d'élément CertElementId ainsi que le Index souhaité [SWS_KeyM_91014]. De plus, l'appelant doit allouer la mémoire pour CertElementDataPtr et transmettre via CertElementDataLengthPtr la taille maximale de tampon disponible. En cas de retour réussi, CertElementDataLengthPtr est écrasé par la longueur réelle des données copiées [SWS_KeyM_91014].

Valeurs de retour et gestion des erreurs

La fonction signale le résultat via des valeurs de retour Std_ReturnType spécifiques [SWS_KeyM_91014] :

• E_OK : L'élément a été trouvé et copié avec succès dans le tampon de destination.
• KEYM_E_PARAMETER_MISMATCH : CertId invalide, CertElementId invalide ou le Index transmis est hors de la plage valide.
• KEYM_E_KEY_CERT_SIZE_MISMATCH : Le tampon fourni est trop petit pour l'élément de certificat.
• KEYM_E_KEY_CERT_EMPTY : Le certificat indiqué ne contient pas de données ou est vide.
• KEYM_E_CERT_INVALID : Le certificat n'est pas valide ou la vérification n'a pas réussi.
• E_NOT_OK : La lecture des données de l'élément a échoué.

concurrence

Selon la spécification, le service est classé comme non réentrant (Non Reentrant) [SWS_KeyM_91014]. Les appels ne doivent donc pas être exécutés de manière concurrente sans protection.

L'interface synchrone KeyM_CertificateElementGetCount détermine le nombre total d'éléments de données enregistrés pour un élément de certificat spécifique et écrit le résultat dans le tampon CountPtr [SWS_KeyM_91015].

Utilisation et paramètres

La fonction est déclarée via l'en-tête KeyM.h et possède l'ID de service 0x1c [SWS_KeyM_91015]. Elle traite les paramètres suivants :

• CertId (IN) : Identifiant unique du certificat à interroger ([SWS_KeyM_91015]).
• CertElementId (IN) : Détermine l'élément concret au sein du certificat ([SWS_KeyM_91015]).
• CountPtr (OUT) : Pointeur vers le tampon de type uint16 dans lequel le nombre d'éléments de données disponibles est copié ([SWS_KeyM_91015]).

Gestion des erreurs et valeurs de retour

La valeur de retour de type Std_ReturnType renseigne sur le résultat de l'exécution [SWS_KeyM_91015] :

• E_OK : La valeur de comptage a été écrite avec succès dans le tampon ([SWS_KeyM_91015]).
• E_NOT_OK : La valeur de comptage n’a pas pu être fournie ([SWS_KeyM_91015]).
• KEYM_E_PARAMETER_MISMATCH : L’ID de certificat (CertId) ou l’ID d’élément (CertElementId) est invalide ou se situe en dehors de la plage autorisée ([SWS_KeyM_91015]).

Concurrence et interaction

L’exécution est synchrone, mais classée comme non réentrante (Non Reentrant), de sorte que les appels simultanés doivent être coordonnés [SWS_KeyM_91015]. Alors qu’un seul élément de données est généralement attribué aux éléments de certificat, plusieurs éléments de données peuvent, dans certains cas, se présenter consécutivement [SWS_KeyM_91015]. Le nombre total déterminé sert de base pour lire ensuite de manière ciblée les différents éléments via KeyM_CertificateElementGetByIndex(), ce qui ressemble sur le plan fonctionnel à l’approche itérative avec KeyM_CertElementGetFirst et KeyM_CertElementGetNext [SWS_KeyM_91015].

La fonction synchrone KeyM_CertElementGetFirst sert, selon [SWS_KeyM_00064], à initier l'extraction itérative de données de certificat. Elle lit l'élément supérieur de l'élément de certificat adressé via CertElementId à partir du certificat CertId et initialise la construction d'itérateur CertElementIterator pour les appels ultérieurs de KeyM_CertElementGetNext().

Lors de l'appel, les exigences suivantes concernant les paramètres et la mémoire selon [SWS_KeyM_00064] doivent être respectées :

• CertElementIterator : Pointeur vers une structure allouée et gérée par l'appelant ; celle-ci ne doit être ni détruite ni modifiée par l'application tant que toutes les données n'ont pas été récupérées via KeyM_CertElementGetNext().
• CertElementData : Pointeur vers un tampon de sortie fourni par l'appelant, dans lequel les données utiles sont copiées si l'élément est trouvé avec succès (E_OK).
• CertElementDataLength : Transmet en entrée la longueur maximale du tampon de données et est écrasé, lors du retour de E_OK, par la longueur de données réellement écrite.

En matière de concurrence, le service est, selon [SWS_KeyM_00064], réentrant, mais rapporté à exactement un itérateur (« Reentrant for one iterator »).

En cas d'erreur, la fonction effectue une distinction via des valeurs de retour spécifiques selon [SWS_KeyM_00064] : E_NOT_OK indique qu'aucune donnée d'élément n'a été trouvée (l'itérateur ne doit plus être utilisé pour d'autres appels par la suite). KEYM_E_PARAMETER_MISMATCH signale un ID de certificat ou d'élément invalide, KEYM_E_KEY_CERT_SIZE_MISMATCH un tampon de données trop petit, KEYM_E_KEY_CERT_EMPTY un certificat vide sans données disponibles et KEYM_E_CERT_INVALID un certificat non valide ou non vérifié avec succès.

La fonction synchrone KeyM_CertElementGetNext (ID de service 0x11, fournie via KeyM.h) sert à la lecture continue d'autres données à partir d'un élément de certificat si plusieurs enregistrements y sont stockés de manière séquentielle [SWS_KeyM_00065]. Comme condition préalable obligatoire, la spécification exige que la fonction KeyM_CertElementGetFirst() ait été appelée au moins une fois auparavant [SWS_KeyM_00065].

Les zones de mémoire pour l'ensemble des paramètres doivent être fournies par l'application appelante [SWS_KeyM_00065] :

• CertElementIterator : Pointeur vers une structure d'itérateur allouée, qui ne doit être ni modifiée ni détruite par l'application pendant le parcours jusqu'à ce que tous les éléments soient entièrement lus [SWS_KeyM_00065].
• CertElementData : Pointeur vers le tampon de sortie dans lequel la fonction copie les données utiles en cas d'exécution réussie [SWS_KeyM_00065].
• CertElementDataLength : Transmet lors de l'appel la capacité maximale du tampon de données et est écrasé, en cas de retour réussi, par la longueur réelle des données copiées [SWS_KeyM_00065].

Si l'appel renvoie E_OK, l'élément suivant a été trouvé, écrit dans le tampon et l'itérateur a été avancé en conséquence [SWS_KeyM_00065]. Avec E_NOT_OK, aucune autre donnée d'élément n'a pu être trouvée ; dans ce cas, l'itérateur ne doit plus être utilisé pour aucun autre appel [SWS_KeyM_00065]. Les situations d'erreur sont signalées par des valeurs de retour spécifiques : KEYM_E_KEY_CERT_SIZE_MISMATCH indique un tampon de données sous-dimensionné, KEYM_E_PARAMETER_MISMATCH un ID de certificat ou d'élément invalide, KEYM_E_KEY_CERT_EMPTY un certificat vide et KEYM_E_CERT_INVALID un certificat non valide ou non vérifié avec succès [SWS_KeyM_00065].

Concernant la concurrence, la fonction synchrone est spécifiée comme réentrante pour un itérateur donné [SWS_KeyM_00065].

La fonction synchrone KeyM_CertGetStatus sert à interroger l'état d'un certificat et à le mettre à disposition via un paramètre de sortie [SWS_KeyM_00066]. La déclaration de la fonction est accessible via le fichier d'en-tête KeyM.h, et l'identifiant de service hexadécimal 0x12 est attribué au service [SWS_KeyM_00066].

Les paramètres suivants sont utilisés pour l'appel [SWS_KeyM_00066] :

• CertId (IN) : Contient l'identifiant du certificat à interroger et est transmis avec le type de données KeyM_CertificateIdType [SWS_KeyM_00066].
• Status (OUT) : Pointeur vers la zone de mémoire de type KeyM_CertificateStatusType dans laquelle la fonction écrit l'état déterminé du certificat [SWS_KeyM_00066].

La valeur de retour de type Std_ReturnType informe sur l'issue de l'interrogation d'état [SWS_KeyM_00066] :

• E_OK : L'état du certificat a été déterminé et mis à disposition avec succès [SWS_KeyM_00066].
• E_NOT_OK : Une mise à disposition de l'état n'est actuellement pas possible [SWS_KeyM_00066]. Cela se produit par exemple lorsqu'un ID de certificat non valide est transmis, documenté avec le code d'erreur KEYM_E_PARAMETER_MISMATCH [SWS_KeyM_00066].

En ce qui concerne l'exécution et la concurrence, l'interface se comporte de manière purement synchrone et est spécifiée comme non réentrante (Non Reentrant) [SWS_KeyM_00066]. Des appels simultanés à travers plusieurs contextes d'exécution ne sont par conséquent pas autorisés. Aucun paramètre d'entrée et de sortie supplémentaire n'est prévu pour cette interface [SWS_KeyM_00066].

La fonction KeyM_MainFunction sert de fonction principale périodique pour le module Classic AUTOSAR KeyM [SWS_KeyM_00074]. Conformément à la spécification, la fonction possède l'identifiant de service 0x19 en notation hexadécimale ainsi que la signature void KeyM_MainFunction (void) [SWS_KeyM_00074]. Les instances appelantes ne transmettent donc aucun paramètre d'entrée et ne reçoivent aucune valeur de retour [SWS_KeyM_00074].

Pour le contrôle temporel, il est défini que la fonction doit être appelée périodiquement selon un intervalle de temps défini [SWS_KeyM_00074]. Le fichier d'en-tête SchM_KeyM.h est déclaré comme fichier d'interface [SWS_KeyM_00074]. Il en découle l'interprétation suivante : grâce à la mise à disposition via SchM_KeyM.h, l'appel régulier de la fonction devrait avoir lieu dans le contexte du scheduler du logiciel de base (SchM) [SWS_KeyM_00074]. Question Q-761ff71812bda3c2 (ouverte) De plus, le déclenchement cyclique sert probablement au traitement interne des processus dépendants du temps dans le module KeyM.

Concernant le traitement des erreurs et le comportement face aux erreurs, aucun code de retour, constante d'erreur ou message à destination du DET ou du DEM n'est documenté pour ce service dans l'élément de spécification [SWS_KeyM_00074]. Comme aucun paramètre d'entrée n'existe, une vérification des valeurs transmises lors de l'appel est également superflue [SWS_KeyM_00074].

Utilisation et contexte d'appel

La fonction KeyM_MainBackgroundFunction possède la signature void KeyM_MainBackgroundFunction(void) et est spécifiée sous le Service-ID 0x1a [SWS_KeyM_00075]. Elle ne prend aucun paramètre d'entrée et ne renvoie aucune valeur de retour à l'appelant [SWS_KeyM_00075]. Pour l'intégration, l'interface est déclarée et mise à disposition via le fichier d'en-tête SchM_KeyM.h [SWS_KeyM_00075].

L'appel est effectué en arrière-plan par un système d'exploitation préemptif dès qu'aucune autre opération de tâche n'est en attente d'exécution [SWS_KeyM_00075]. Le but principal de cette fonction est de fournir un contexte d'arrière-plan non critique pour des opérations synchrones consommatrices de temps du module KeyM, comme décrit à titre d'exemple pour l'exécution de KeyM_KH_Update() [SWS_KeyM_00075].

Concurrence et traitement des erreurs

Étant donné que la fonction est exécutée dans le contexte d'arrière-plan d'un système d'exploitation préemptif, elle devrait pouvoir être interrompue à tout moment par n'importe quelle tâche régulière de priorité plus élevée. Pour ce service d'arrière-plan, la norme ne spécifie ni codes d'erreur spécifiques ni notifications au DET ou au DEM [SWS_KeyM_00075]. De plus, aucune propriété particulière de réentrance ni condition d'ordonnancement stricte relative à d'autres fonctions de module ne sont prescrites dans la version des données fournie [SWS_KeyM_00075]. Question Q-a2394a51ba63467f (ouverte)

La fonction synchrone et non réentrante KeyM_KH_Start est déclarée via l'en-tête KeyM_Externals.h [SWS_KeyM_00067]. Si les paramètres de configuration KeyMCryptoKeyStartFinalizeFunctionEnabled et KeyMCryptoKeyHandlerStartFinalizeEnabled sont définis sur TRUE, elle est exécutée immédiatement lors d'un appel de KeyM_Start [SWS_KeyM_00067].

Le paramètre StartType définit le mode d'exécution de l'opération de clé. Au moyen de RequestData et RequestDataLength, la fonction reçoit des données associées spécifiques à la requête, telles que des signatures. L'appelant transmet via le paramètre d'entrée/sortie ResponseDataLength la quantité maximale d'octets disponible dans le tampon ResponseData ; en cas de succès, la fonction renvoie par ce biais le nombre d'octets de réponse réellement écrit [SWS_KeyM_00067].

Comme valeur de retour, la fonction fournit un statut de type Std_ReturnType [SWS_KeyM_00067] :

• E_OK : L'opération de démarrage a réussi. Ce n'est que grâce à cette valeur de retour que le Key Manager passe à l'état actif, de sorte que les mises à jour de clés ultérieures (Key Updates) soient autorisées.
• E_NOT_OK : l'opération de démarrage n'a pas été acceptée.
• KEYM_E_PARAMETER_MISMATCH : un paramètre transmis ne correspond pas à la valeur attendue.
• KEYM_E_KEY_CERT_SIZE_MISMATCH : Une taille de paramètre indiquée ne correspond pas à la taille attendue.

Étant donné que KeyM_KH_Start est définie comme non réentrante, les appels pour des opérations de clé parallèles ne doivent pas avoir lieu de manière concurrente [SWS_KeyM_00067].

Utilisation et contexte d'appel

La fonction KeyM_KH_Prepare est déclarée via le fichier d'en-tête KeyM_Externals.h et sert à la préparation d'une opération de gestion de clés [SWS_KeyM_00068]. Elle est déclenchée immédiatement lors de l'appel de KeyM_Prepare lorsque les deux paramètres de configuration KeyMCryptoKeyPrepareFunctionEnabled et KeyMCryptoKeyHandlerPrepareEnabled sont chacun définis sur TRUE [SWS_KeyM_00068]. L'exécution s'effectue de manière synchrone et est spécifiée comme non réentrante [SWS_KeyM_00068].

La transmission des données s'effectue via quatre paramètres [SWS_KeyM_00068] :

• RequestData : Données d'entrée transmises avec la requête [SWS_KeyM_00068].
• RequestDataLength : Longueur des données dans le tableau RequestData [SWS_KeyM_00068].
• ResponseDataPtr : Pointeur vers le tampon pour les données de réponse renvoyées par la fonction, qui sont transmises sans modification à l'appelant de Key_Prepare [SWS_KeyM_00068].
• ResponseDataLength : Paramètre d'entrée et de sortie ; transmet lors de l'appel le nombre maximal d'octets disponible dans le tampon et renvoie après le retour la quantité d'octets réellement écrite [SWS_KeyM_00068].

Valeurs de retour et comportement en cas d'erreur

La fonction renvoie comme résultat la valeur d'état Std_ReturnType [SWS_KeyM_00068] :

• E_OK : Le service a été accepté et continue d'être traité en interne ; les résultats sont transmis via un callback [SWS_KeyM_00068].
• E_NOT_OK : Le service n'a pas été accepté en raison d'une erreur interne [SWS_KeyM_00068].
• KEYM_E_PARAMETER_MISMATCH : un paramètre ne correspond pas à la valeur attendue [SWS_KeyM_00068].
• KEYM_E_KEY_CERT_SIZE_MISMATCH : La taille d'un paramètre n'est pas adaptée [SWS_KeyM_00068].

Utilisation et délégation

La fonction KeyM_KH_Finalize est déclarée via le fichier d'en-tête KeyM_Externals.h et fait office de gestionnaire de clés spécifique à l'utilisateur [SWS_KeyM_00070]. Si, dans la configuration, KeyMCryptoKeyStartFinalizeFunctionEnabled ainsi que KeyMCryptoKeyHandlerStartFinalizeEnabled sont définis sur TRUE, KeyM_Finalize() n'exécute aucune opération autonome, mais délègue le traitement directement à cette fonction de gestion [SWS_KeyM_00070].

Contexte d'appel et paramètres

L'appel de KeyM_KH_Finalize s'effectue de manière synchrone, mais est classé comme non réentrant (Non Reentrant) et requiert un contexte d'appel protégé [SWS_KeyM_00070]. La transmission des données s'effectue via les paramètres suivants :

• RequestData et RequestDataLength : Pointeur vers les données d'entrée transmises avec la requête ainsi que la longueur du tableau de données [SWS_KeyM_00070].
• ResponseData : Tampon pour les données de sortie fournies par la fonction [SWS_KeyM_00070].
• ResponseDataLength : Un paramètre d'entrée/sortie qui définit lors de l'appel la quantité maximale d'octets disponible dans le tampon de réponse et contient au retour le nombre d'octets réellement écrit [SWS_KeyM_00070].

Valeurs de retour et gestion des erreurs

Le résultat de l'opération est renvoyé via Std_ReturnType [SWS_KeyM_00070] :

• E_OK : L'opération a été acceptée et continue d'être traitée en interne ; les résultats sont mis à disposition via un callback [SWS_KeyM_00070]. Interprétation : Bien que l'interface de la fonction soit définie comme synchrone, le traitement effectif devrait se poursuivre en arrière-plan. Question Q-02c4aac040570c03 (ouverte)
• E_NOT_OK : L'opération n'a pas été acceptée en raison d'une erreur interne [SWS_KeyM_00070].
• KEYM_E_BUSY : Le Key Manager est occupé par d'autres tâches, raison pour laquelle la validation ne peut actuellement pas être effectuée [SWS_KeyM_00070].
• KEYM_E_PARAMETER_MISMATCH : un paramètre ne correspond pas à la valeur attendue [SWS_KeyM_00070].
• KEYM_E_KEY_CERT_SIZE_MISMATCH : La taille de paramètre transmise ne correspond pas aux spécifications [SWS_KeyM_00070].

La fonction de rappel KeyM_CryptoKeyUpdateCallbackNotification() notifie l'application qu'une mise à jour d'une clé cryptographique a été terminée ([SWS_KeyM_00077]). La fonction est fournie via KeyM_Externals.h, est synchrone et réentrante et ne possède pas de valeur de retour ([SWS_KeyM_00077]).

paramètre

• Result : Transmet des informations sur le résultat de l'opération de mise à jour via le type KeyM_ResultType ([SWS_KeyM_00077], [SWS_KeyM_00156]).
• ResultDataLength : Indique la longueur des données résultantes de cette opération ([SWS_KeyM_00077], [SWS_KeyM_00156]).
• ResultDataPtr : Pointeur vers les données du résultat ([SWS_KeyM_00077]).

Interaction et gestion des tampons

L'appel de KeyM_CryptoKeyUpdateCallbackNotification() est effectué par KeyM_Update() dès que le gestionnaire de clés retourne et fournit le type d'opération KEYM_KH_UPDATE_FINISH ([SWS_KeyM_00093]). Ce faisant, les données de résultat issues de KeyM_KH_Update::ResultDataPtr sont copiées dans le tampon qui a été transmis lors de l'appel de KeyM_Update(), et la valeur de retour du gestionnaire de clés est reprise ([SWS_KeyM_00093]).

Dans la mesure où KeyM_Update() a accepté l'opération avec E_OK, la fonction appelante ne doit en aucun cas modifier le tampon ResultDataPtr jusqu'à ce que la notification de rappel KeyM_CryptoKeyUpdateCallbackNotification() ait eu lieu ([SWS_KeyM_00156]). Le même pointeur de tampon est transmis dans le callback en tant que ResultDataPtr avec les résultats d'opération copiés à l'intérieur ([SWS_KeyM_00156]).

La fonction de rappel KeyM_CryptoKeyFinalizeCallbackNotification notifie l'application de la fin d'une opération de finalisation de clé [SWS_KeyM_00079]. Elle est spécifiée comme synchrone ainsi que réentrante, ne possède pas de valeur de retour et est déclarée via le fichier d'en-tête KeyM_Externals.h [SWS_KeyM_00079].

L'interface transmet les paramètres suivants à l'application lors de l'appel [SWS_KeyM_00079] :

• Result (type KeyM_ResultType) : Transmet le résultat et les informations d'état de l'opération terminée [SWS_KeyM_00079].
• Result Data Length (type uint16) : Indique la longueur des données résultantes de cette opération [SWS_KeyM_00079].
• Result Data Ptr (type const uint8*) : Pointeur vers le tampon contenant les données de résultat, qui a été préalablement fourni à la fonction de service [SWS_KeyM_00079].

Concernant la configuration, la fonction de rappel n'est appelée et requise que si le paramètre de configuration KeyMCryptoKeyStartFinalizeFunctionEnabled est défini sur TRUE [SWS_KeyM_00079]. Des messages d'erreur DET ou DEM spécifiques ne sont pas définis pour cette fonction de rappel. L'application implémente probablement ce callback afin de réceptionner les résultats asynchrones d'une finalisation de clé préalablement initiée. Question Q-6d9e4e062b008832 (ouverte)

Utilisation et paramètres

La fonction de rappel KeyM_CryptoKeyVerifyCallbackNotification informe l'application de l'achèvement d'une opération de vérification pour une clé cryptographique par le module KeyM [SWS_KeyM_00081]. Interprétation : Comme l'élément est disponible, selon la spécification, via l'en-tête KeyM_Externals.h et sert à la notification de l'application, l'implémentation devrait être effectuée par le composant logiciel applicatif, tandis que l'appel est réalisé par le Key Manager [SWS_KeyM_00081]. Question Q-e88e332a7d2cac40 (ouverte)

Quatre paramètres purement d'entrée sont définis pour l'appel [SWS_KeyM_00081] :

• Result (KeyM_ResultType) : Transmet le résultat de la vérification terminée [SWS_KeyM_00081].
• KeyId (uint32) : Désigne l'identifiant de clé pour lequel la vérification a été démarrée [SWS_KeyM_00081].
• ResultDataLength (uint16) : Contient la longueur des données de résultat obtenues, si présentes [SWS_KeyM_00081].
• ResultDataPtr (const uint8*) : Pointe vers les données du résultat de vérification [SWS_KeyM_00081].

Concurrence et restrictions

La fonction ne possède pas de valeur de retour (void) ni de paramètres de sortie ou d'entrée/sortie [SWS_KeyM_00081]. L'appel est exécuté de manière synchrone et réentrante [SWS_KeyM_00081]. Des codes d'erreur spécifiques ainsi que des messages DET ou DEM ne sont pas spécifiés pour ce callback ; les informations d'état et d'erreur sont transmises à l'application exclusivement via le paramètre Result [SWS_KeyM_00081].

Utilisation et sémantique

La fonction de rappel KeyM_ServiceCertificateCallbackNotification est appelée par le sous-module de certificat du KeyM pour notifier l'application de la fin d'une opération de service de certificat [SWS_KeyM_00147]. L'opération de certificat préalable se déroule de manière asynchrone et exécute ce rappel lors de son achèvement afin de transmettre les résultats à l'application [SWS_KeyM_00149].

Tous les résultats pertinents sont transmis par le biais des paramètres de la fonction [SWS_KeyM_00147] :

• CertId : identifiant du certificat pour lequel l'opération a été initiée.
• Result : type KeyM_ResultType comportant l'état ou le résultat de l'opération.
• ResultDataLength : longueur des données de résultat, si elles existent.
• ResultDataPtr : pointeur vers les données de résultat.

La fonction elle-même ne possède aucune valeur de retour (void) et présente une sémantique d'exécution synchrone [SWS_KeyM_00147].

Configuration et restrictions

Le rappel est mis à disposition via l'en-tête KeyM_Externals.h, mais n'est disponible que si le paramètre de configuration KeyMServiceCertificateFunctionEnabled est défini sur TRUE [SWS_KeyM_00147]. Le nom effectif de la fonction de notification peut être adapté via le paramètre de configuration KeyMServiceCertificateCallbackNotificationFunc [SWS_KeyM_00147].

Concurrence et traitement des erreurs

Conformément à la spécification, la fonction est classée comme réentrante [SWS_KeyM_00147]. Les erreurs ou les états de succès de l'opération asynchrone précédente sont signalés par le paramètre transmis Result ; aucun message DET ou DEM spécifique n'est défini dans la charge utile pour cette interface de rappel [SWS_KeyM_00147].

Utilisation

La fonction de rappel KeyM_CertificateVerifyCallbackNotification sert à notifier l'application de la fin d'une vérification de certificat [SWS_KeyM_00073]. La déclaration est disponible via l'en-tête KeyM_Externals.h, le nom de la fonction pouvant être configuré via le paramètre de configuration KeyMCertificateVerifyCallbackNotificationFunc [SWS_KeyM_00073].

Lors de l'appel, deux paramètres d'entrée sont transmis [SWS_KeyM_00073] :

• CertId (type KeyM_CertificateIdType) : Identifiant du certificat vérifié [SWS_KeyM_00073].
• Result (type KeyM_CertificateStatusType) : Contient des informations sur le résultat de l'opération de vérification [SWS_KeyM_00073].

La fonction renvoie la valeur E_OK comme valeur d'état de type Std_ReturnType [SWS_KeyM_00073].

Exécution et traitement des erreurs

L'exécution de la notification est définie comme synchrone et réentrante [SWS_KeyM_00073]. Des codes d'erreur spécifiques, des valeurs de retour divergentes ou des signalements au DET ou au DEM ne sont pas prévus pour ce callback [SWS_KeyM_00073]. Interprétation : L'implémentation côté application devrait devoir être conçue de manière thread-safe afin de traiter des appels simultanés pour différents certificats sans effets secondaires. Question Q-6bf5313c425fe1a8 (ouverte)

Utilisation

Le type de données KeyM_CertElementIteratorType est défini comme une structure (Structure) conformément à [SWS_KeyM_00042] et est mis à disposition via le fichier d'en-tête KeyM.h. Selon la spécification, ce type sert à itérer sur une série d'éléments d'un certificat ([SWS_KeyM_00042]). Comme le contenu concret de la structure de données est expressément spécifié comme dépendant de l'implémentation ([SWS_KeyM_00042]), les utilisateurs devraient considérer ce type comme un état d'itération opaque et ne pas accéder directement aux champs internes de la structure. Question Q-81b5deb7dcdf2812 (ouverte)

Manipulation et restrictions

De la spécification découlent les conditions pratiques d'utilisation suivantes :

• Structure dépendante de l'implémentation : les champs de KeyM_CertElementIteratorType étant implémentés de manière spécifique au constructeur ([SWS_KeyM_00042]), l'agencement interne de la mémoire dépend de la réalisation BSW respective.
• Gestion de l'état : interprétation : une instance de la structure devrait être allouée par l'appelant comme contexte d'itérateur et transmise aux fonctions correspondantes de traversée des éléments de certificat afin de suivre la progression lors de la vérification ou de l'extraction des champs de certificat. Question Q-5ddb438001abe656 (ouverte)
• Concurrence : une instance d'itérateur ne peut vraisemblablement pas être utilisée de manière concurrente sans synchronisation externe à travers plusieurs tâches lors d'accès parallèles au même certificat. Question Q-6b4b8b1cdc35f021 (ouverte)

Le type d'énumération KeyM_ServiceCertificateType est fourni par l'en-tête Rte_KeyM_Type.h et spécifie l'opération de service de certificat demandée par le serveur de clés ainsi que la nature des informations transmises avec la fonction [SWS_KeyM_00039]. La déclaration dans le fichier d'en-tête RTE devrait indiquer que ce type est avant tout utilisé pour l'échange de données entre les composants logiciels et le module Key Manager. Question Q-37ed693ea3eda646 (ouverte)

Les codes d'opération standardisés suivants sont définis pour la gestion des certificats [SWS_KeyM_00039] :

• KEYM_SERVICE_CERT_REQUEST_CSR (0x01) : le serveur de clés invite le client de clés (Key-Client) à générer un certificat ou une demande de signature de certificat (CSR) [SWS_KeyM_00039].
• KEYM_SERVICE_CERT_UPDATE_SIGNED_CSR (0x02) : le serveur renvoie un certificat préalablement reçu, désormais signé par l'autorité de certification (CA) [SWS_KeyM_00039].
• KEYM_SERVICE_CERT_SET_ROOT (0x03) et KEYM_SERVICE_CERT_UPDATE_ROOT (0x04) : création d'un nouveau certificat racine ou mise à jour d'un certificat racine existant [SWS_KeyM_00039].
• KEYM_SERVICE_CERT_SET_INTERMEDIATE (0x05) et KEYM_SERVICE_CERT_UPDATE_INTERMEDIATE (0x06) : ajout ou mise à jour d'un certificat intermédiaire (certificat CA) [SWS_KeyM_00039].
• KEYM_SERVICE_CERT_UPDATE_CRL (0x07) : mise à disposition ou mise à jour d'une liste de révocation de certificats (CRL) [SWS_KeyM_00039].

Comme précondition essentielle, KEYM_SERVICE_CERT_SET_INTERMEDIATE exige que le certificat racine correspondant soit déjà enregistré avant la définition d'un certificat intermédiaire, afin de garantir une vérification réussie [SWS_KeyM_00039]. Pour les extensions spécifiques au projet, la spécification prévoit la plage de valeurs réservée de 0x80 à 0x9F [SWS_KeyM_00039].

Le type énuméré KeyM_CertificateStatusType représente le résultat des vérifications de certificat et reproduit l'état actuel de vérification et de traitement d'un certificat dans le Key Manager [SWS_KeyM_91003]. Le type est fourni via l'en-tête Rte_KeyM_Type.h et permet aux appelants d'évaluer de manière différenciée l'état ou les causes d'erreur spécifiques d'une vérification de certificat [SWS_KeyM_91003].

Les valeurs d'énumération couvrent aussi bien des états réguliers intermédiaires et de succès que des profils d'erreur précis [SWS_KeyM_91003] :

• KEYM_CERTIFICATE_VALID (0x00) : le certificat a été analysé syntaxiquement et vérifié avec succès [SWS_KeyM_91003].
• KEYM_CERTIFICATE_INVALID (0x01) : le certificat est invalide en raison d'une erreur non spécifiée de manière détaillée [SWS_KeyM_91003].
• KEYM_CERTIFICATE_NOT_PARSED (0x02) : le certificat n'a pas encore été analysé syntaxiquement jusqu'à présent [SWS_KeyM_91003].
• KEYM_CERTIFICATE_PARSED_NOT_VALIDATED (0x03) : le certificat a été analysé syntaxiquement, mais pas encore validé [SWS_KeyM_91003].
• KEYM_CERTIFICATE_NOT_AVAILABLE (0x04) : aucun certificat n'est défini [SWS_KeyM_91003].
• Résultats de vérification spécifiques à des erreurs : période de validité échouée (KEYM_E_CERTIFICATE_VALIDITY_PERIOD_FAIL, 0x05), signature erronée (KEYM_E_CERTIFICATE_SIGNATURE_FAIL, 0x06), chaîne de confiance invalide (KEYM_E_CERTIFICATE_INVALID_CHAIN_OF_TRUST, 0x07), type invalide (KEYM_E_CERTIFICATE_INVALID_TYPE, 0x08), format erroné (KEYM_E_CERTIFICATE_INVALID_FORMAT, 0x09), contenu invalide (KEYM_E_CERTIFICATE_INVALID_CONTENT, 0x0A) ainsi que révocation ou domaine de validité invalide (KEYM_E_CERTIFICATE_REVOKED, 0x0B) [SWS_KeyM_91003].

Les appelants devraient vérifier l'état avant d'utiliser des clés cryptographiques ; les opérations ne doivent généralement s'appuyer sur un certificat que si l'état signale explicitement KEYM_CERTIFICATE_VALID. Comme le type est déclaré via Rte_KeyM_Type.h, il devrait être principalement utilisé dans des interfaces de service et des ports standardisés pour l'interaction entre KeyM et les SWC d'application. Question Q-f3ca10ee673798df (ouverte)

Utilisation et structure

Le type de données KeyM_CertificateElementType est spécifié sous la forme d'un tableau d'octets avec le type d'élément uint8 et sert, selon la spécification, de zone de mémoire suffisamment grande pour stocker les données d'un élément de certificat [SWS_KeyM_91004]. La mise à disposition et la déclaration du type de données s'effectuent pour le module KeyM via le fichier d'en-tête Rte_KeyM_Type.h [SWS_KeyM_91004].

Configuration et gestion des variantes

La forme du type de données est soumise à une variation de nom et de taille dépendante de la configuration, qui est dérivée des paramètres configurés du module [SWS_KeyM_91004] :

• Modèle de nom : le nom de type concret est généré de manière spécifique à l'élément selon le schéma KeyM_CertificateElementType_{KeyMCertificate}_{KeyMCertificateElement}, où les espaces réservés correspondent aux noms courts configurés SHORT-NAME des instances respectives de certificat et d'élément de certificat [SWS_KeyM_91004].
• Taille du tableau : le nombre d'éléments uint8 est déterminé par le paramètre de configuration KeyMCertificateElementMaxLength afin que le tableau offre un espace mémoire suffisant pour les données brutes de l'élément concerné [SWS_KeyM_91004].

Restrictions et hypothèses

Étant donné que la définition est fournie dans Rte_KeyM_Type.h, le type devrait être principalement utilisé en tant que tampon standardisé au niveau des interfaces avec les composants logiciels pour l'échange de contenus de certificat [SWS_KeyM_91004]. Question Q-994f8ac6772de3c1 (ouverte) La longueur maximale des données pouvant être traitées reste alors liée statiquement à la longueur maximale définie au moment de la configuration [SWS_KeyM_91004].

Utilisation et définition de type

Le type de données KeyM_CryptoKeyDataType est défini comme un type pointeur vers uint8* et sert de pointeur d'octet pour les données d'entrée ou de sortie au sein du module KeyM [SWS_KeyM_91012]. La définition du type est fournie via le fichier d'en-tête Rte_KeyM_Type.h [SWS_KeyM_91012].

Restrictions et gestion de la mémoire

Lors de l'utilisation de KeyM_CryptoKeyDataType en tant que pointeur vers des tampons d'octets, des conditions cadres spécifiques doivent être prises en compte :

• Interprétation : étant donné que le type est spécifié comme un simple pointeur d'octet (uint8*) [SWS_KeyM_91012], l'allocation, le dimensionnement ainsi que la validité de la mémoire référencée incombent vraisemblablement à l'appelant respectif. Question Q-07c167f400cbfb9c (ouverte)
• Interprétation : lors de la transmission en tant que tampon de sortie, il conviendrait de s'assurer que la zone de mémoire référencée est suffisamment grande pour les données de clé ou de cryptographie à accueillir, afin d'éviter tout dépassement de tampon. Question (ouverte)
• Interprétation : pour l'accès concurrent au tampon référencé, des mesures de synchronisation supplémentaires par le logiciel appelant devraient être nécessaires, étant donné que le type lui-même n'offre aucun mécanisme de synchronisation. Question (ouverte)

Intégration

Les appelants qui transmettent des données de clés cryptographiques ou de certificats aux interfaces KeyM ou qui en reçoivent de celles-ci incluent Rte_KeyM_Type.h afin d'obtenir l'accès à la définition de pointeur typée de KeyM_CryptoKeyDataType [SWS_KeyM_91012].

Le type énumération KeyM_ResultType spécifie le résultat de fonctions asynchrones du module KeyM pour la gestion des clés et des certificats [SWS_KeyM_91008]. Le type est fourni via le fichier d'en-tête Rte_KeyM_Type.h et sert au retour d'information sur l'issue d'un ordre de travail asynchrone demandé [SWS_KeyM_91008].

La plage de valeurs comprend des codes d'état et d'erreur standardisés pour une évaluation différenciée par les appelants [SWS_KeyM_91008] :

• KEYM_RT_OK (0x00) : L'opération de gestion de clés s'est terminée avec succès [SWS_KeyM_91008].
• KEYM_RT_NOT_OK (0x01) : Une erreur générale est survenue pendant l'opération de gestion de clés [SWS_KeyM_91008].
• KEYM_RT_KEY_CERT_INVALID (0x02) : La clé ou le certificat référencé n'est pas valide et ne peut pas être utilisé pour l'opération [SWS_KeyM_91008].
• KEYM_RT_KEY_CERT_WRITE_FAIL (0x03) : L'écriture de la clé ou du certificat dans la mémoire de destination prévue a échoué [SWS_KeyM_91008].
• KEYM_RT_KEY_CERT_UPDATE_FAIL (0x04) : Erreur générale lors de la mise à jour d'une clé ou d'un certificat, qui n'a pas pu être précisée par un code plus spécifique [SWS_KeyM_91008].
• KEYM_RT_CERT_INVALID_CHAIN_OF_TRUST (0x05) : La vérification du certificat a échoué en raison d'une chaîne de confiance non valide [SWS_KeyM_91008].

Les appelants de fonctions KeyM asynchrones doivent évaluer ce type de retour afin de pouvoir réagir de manière ciblée, en cas d'erreur, à des chaînes de confiance non valides, des erreurs d'accès à la mémoire ou un matériel de clé incorrect [SWS_KeyM_91008].

La structure KeyM_CertDataType est utilisée dans le module KeyM pour la transmission et l'échange de données de certificat via des fonctions d'interface [SWS_KeyM_00041]. La définition du type est disponible via le fichier d'en-tête KeyM.h [SWS_KeyM_00041].

La structure regroupe deux éléments essentiels [SWS_KeyM_00041] :

• certDataLength : élément de type uint32 indiquant la longueur des données de certificat [SWS_KeyM_00041].
• certData : élément de type VoidPtr qui référence directement, en tant que pointeur, les données de certificat dans une zone de données locale de l'appelant [SWS_KeyM_00041].

Étant donné que certData pointe vers des zones mémoire situées dans le contexte local de l'appelant [SWS_KeyM_00041], la gestion du tampon incombe à l'instance appelante. Interprétation : l'appelant devrait devoir garantir que la mémoire référencée reste valide pendant toute la durée d'exécution de la fonction d'interface respective et qu'elle comprend au moins le nombre d'octets indiqué dans certDataLength. Question Q-7da9d5ed0975ddbd (ouverte) De plus, on peut supposer qu'en cas de longueur supérieure à zéro, un pointeur valide différent de NULL doit être transmis afin d'éviter tout accès mémoire erroné au sein de la fonction d'interface.