Crypto Driver (Crypto)

La fonction Crypto_Init sert à initialiser le Crypto Driver conformément à [SWS_Crypto_91000]. L'interface est déclarée dans l'en-tête Crypto.h et possède le Service-ID 0x00 [SWS_Crypto_91000].

Les propriétés suivantes sont spécifiées pour l'appel et les paramètres d'interface :

• Pointeur de configuration : un pointeur vers la structure de configuration sélectionnée est transmis via le paramètre d'entrée configPtr de type const Crypto_ConfigType* [SWS_Crypto_91000].
• Valeur de retour : la fonction ne possède pas de valeur de retour (void) ; il n'existe ni paramètres d'entrée/sortie ni paramètres de sortie séparés [SWS_Crypto_91000].
• Comportement d'exécution : la routine d'initialisation est exécutée de manière synchrone (Synchronous) [SWS_Crypto_91000].
• Réentrance : la fonction est définie comme non réentrante (Non Reentrant) [SWS_Crypto_91000]. Les appels parallèles ou qui se chevauchent ne sont pas autorisés.

En raison de sa classification comme non réentrante et étant donné que la spécification ne renvoie pas de codes d'erreur spécifiques, l'appel devrait typiquement avoir lieu de manière centralisée pendant la phase de démarrage du calculateur avant tout autre accès au pilote (interprétation). Question Q-008bb5a45b823891 (ouverte) L'appelant devrait en outre être responsable de veiller à ce que la structure de configuration référencée reste valide en permanence en mémoire (interprétation). Question Q-6271a86fad440121 (ouverte)

La fonction Crypto_ProcessJob exécute la primitive cryptographique configurée dans le paramètre job sur le Crypto Driver Object référencé par objectId [SWS_Crypto_91003]. L'appel est réentrant et fonctionne de manière synchrone ou asynchrone selon la configuration du job [SWS_Crypto_91003]. Via le pointeur vers Crypto_JobType, des données de configuration pour la primitive ainsi que des tampons pour les données de résultat sont transmis [SWS_Crypto_91003].

Avant l'exécution effective d'un job, le pilote vérifie la validité des identifiants de clé : si job->cryptoKeyId ou le cas échéant job->targetCryptoKeyId se trouvent en dehors de la plage autorisée, la fonction signale l'erreur CRYPTO_E_PARAM_HANDLE au DET et renvoie E_NOT_OK [SWS_Crypto_00217]. Cela s'applique également au service CRYPTO_KEYDERIVE (job->jobPrimitiveInfo->primitiveInfo->service), pour autant que job->targetCryptoKeyId ne soit pas valide [SWS_Crypto_00202].

Outre E_OK et E_NOT_OK, des codes d'erreur spécifiques signalent l'échec de la demande [SWS_Crypto_91003] :

• CRYPTO_E_BUSY, lorsque l'objet pilote est occupé ou que sa file d'attente est pleine [SWS_Crypto_91003],
• des erreurs liées aux clés telles que CRYPTO_E_KEY_NOT_VALID, CRYPTO_E_KEY_SIZE_MISMATCH, CRYPTO_E_KEY_READ_FAIL, CRYPTO_E_KEY_WRITE_FAIL, CRYPTO_E_KEY_NOT_AVAILABLE ou CRYPTO_E_KEY_EMPTY [SWS_Crypto_91003],
• CRYPTO_E_JOB_CANCELED en cas d'interruption d'un job synchrone [SWS_Crypto_91003] ainsi que
• CRYPTO_E_ENTROPY_EXHAUSTED en cas d'entropie insuffisante d'un générateur aléatoire ; dans ce cas, la fonction signale en plus l'erreur d'exécution CRYPTO_E_RE_ENTROPY_EXHAUSTED [SWS_Crypto_00141], [SWS_Crypto_91003].

Utilisation

La fonction synchrone Crypto_CancelJob retire un job transmis de la file d'attente et interrompt son traitement si possible [SWS_Crypto_00122]. Lors de l'appel, l'identifiant du Crypto Driver Object (objectId) ainsi qu'un pointeur vers la configuration du job (job) sont transmis [SWS_Crypto_00122].

Les valeurs de retour signalent le résultat de la tentative d'interruption :

• E_OK : la demande a réussi et le job a été retiré [SWS_Crypto_00122]. S'il n'y a aucune erreur dans le pilote et que le job n'est pas en cours de traitement, le service renvoie également E_OK sans action supplémentaire [SWS_Crypto_00214].
• E_NOT_OK : la requête a échoué car le travail n'a pas pu être retiré [SWS_Crypto_00122].
• CRYPTO_E_JOB_CANCELED : le job a été interrompu, mais continue de s'exécuter ; aucun résultat n'est renvoyé à l'application [SWS_Crypto_00122]. Cela s'applique si le pilote fonctionne sans erreur, mais ne peut pas interrompre le job (par exemple en raison de restrictions matérielles) [SWS_Crypto_00183].

Concurrence et restrictions

L'interface est réentrante pour différentes instances, mais ne doit pas être appelée simultanément pour le même Crypto Driver Object [SWS_Crypto_00122].

La fonction synchrone Crypto_KeyElementSet sert à définir les données brutes d'un élément de clé particulier pour une clé identifiée via cryptoKeyId dans le pilote cryptographique [SWS_Crypto_91004].

Paramètres et valeurs de retour

L'élément de clé cible est adressé via keyElementId, tandis que keyPtr référence le tampon de données et keyLength sa taille en octets [SWS_Crypto_91004]. En cas d'affectation réussie, l'interface renvoie E_OK [SWS_Crypto_91004].

Gestion des erreurs

Si une erreur survient lors du traitement, la fonction fournit des valeurs de retour spécifiques [SWS_Crypto_91004] :

• CRYPTO_E_BUSY : le Crypto Driver Object associé est occupé.
• CRYPTO_E_KEY_WRITE_FAIL : l'accès en écriture à l'élément de clé a été refusé.
• CRYPTO_E_KEY_NOT_AVAILABLE : l'élément de clé demandé ou la clé n'est pas disponible.
• CRYPTO_E_KEY_SIZE_MISMATCH : la longueur des données transmises ne correspond pas à la taille de l'élément de clé.
• E_NOT_OK : la demande a échoué pour d'autres raisons.

concurrence

La fonction est spécifiée comme non réentrante (Non Reentrant) [SWS_Crypto_91004]. Interprétation : les appelants devraient être responsables de synchroniser les appels parallèles entre eux afin d'éviter des incohérences de données dans le pilote. Question Q-d7ef7a774052a212 (ouverte)

La fonction synchrone Crypto_KeySetValid sert à définir comme valide l'état d'une clé spécifiée par l'identifiant cryptoKeyId ([SWS_Crypto_91014]). L'interface est disponible via le fichier d'en-tête Crypto.h et possède le Service-ID 0x05 ([SWS_Crypto_91014]).

Lors de l'utilisation, les paramètres et les valeurs de retour suivants sont définis ([SWS_Crypto_91014]) :

• Paramètres d'entrée : l'identifiant de la clé dont l'état doit être défini comme valide est transmis via cryptoKeyId (type uint32) ([SWS_Crypto_91014]). Il n'existe pas de paramètres d'entrée ou de sortie supplémentaires ([SWS_Crypto_91014]).
• Valeur de retour : un code d'état de type Std_ReturnType informe sur le résultat de la demande ([SWS_Crypto_91014]) :
  • E_OK : la demande a réussi ([SWS_Crypto_91014]).
  • E_NOT_OK : La requête a échoué ([SWS_Crypto_91014]).
  • CRYPTO_E_BUSY : l'exécution a échoué car l'objet pilote crypto compétent est occupé ([SWS_Crypto_91014]).

En ce qui concerne la concurrence, la fonction est spécifiée comme non réentrante (« Non Reentrant ») ([SWS_Crypto_91014]). Interprétation : les appelants devraient devoir coordonner de manière externe les appels parallèles entre différentes tâches afin d'éviter les conflits, et devraient prévoir une répétition de l'appel à un moment ultérieur lors de la réception de CRYPTO_E_BUSY. Question Q-32d775a9e61e5731 (ouverte)

Utilisation et sémantique

La fonction synchrone Crypto_KeySetInvalid définit l'état d'une clé identifiée par cryptoKeyId comme non valide [SWS_Crypto_91020]. La fonction est définie dans le fichier d'en-tête Crypto.h et est appelée via le Service-ID 0x15 [SWS_Crypto_91020]. L'unique paramètre transmis est la valeur d'entrée cryptoKeyId (type uint32), qui contient l'identifiant unique de la clé cible ; il n'y a pas de paramètres d'entrée/sortie ni de sortie [SWS_Crypto_91020].

Gestion des erreurs et valeurs de retour

Le résultat de l'exécution de la fonction est signalé via la valeur de retour de type Std_ReturnType [SWS_Crypto_91020] :

• E_OK : la demande a réussi et l'état de la clé a été défini comme non valide [SWS_Crypto_91020].
• E_NOT_OK : l'exécution de la demande a échoué [SWS_Crypto_91020].
• CRYPTO_E_BUSY : la demande a échoué car l'objet pilote crypto (Crypto Driver Object) compétent est actuellement occupé [SWS_Crypto_91020].

Concurrence et restrictions

L'interface est spécifiée comme non réentrante (Non Reentrant) [SWS_Crypto_91020]. Un appel concurrent ou provoquant une interruption est donc inadmissible. Étant donné que la fonction est exécutée de manière synchrone, elle ne retourne à l'appelant qu'après l'achèvement du changement d'état ou après la constatation de l'erreur [SWS_Crypto_91020].

La fonction synchrone et réentrante Crypto_KeyElementGet sert à lire un élément de clé identifié par keyElementId à partir de la clé cryptoKeyId et à le stocker dans la zone mémoire resultPtr [SWS_Crypto_91006]. L'interface est fournie via l'en-tête Crypto.h et possède le Service-ID 0x06 [SWS_Crypto_91006]. Lors de l'appel, l'appelant transmet via le paramètre d'entrée-sortie resultLengthPtr la taille du tampon ou, en cas d'accès partiel configuré, la taille de lecture souhaitée ; une fois l'exécution terminée, le pilote y enregistre la quantité de données réellement copiée [SWS_Crypto_91006].

En cas de succès, la fonction renvoie E_OK [SWS_Crypto_91006]. Si l'opération échoue, elle le signale via des codes d'erreur spécifiques : CRYPTO_E_BUSY si l'objet pilote cryptographique est occupé, CRYPTO_E_KEY_NOT_AVAILABLE si l'élément de clé n'est pas disponible, CRYPTO_E_KEY_READ_FAIL en cas de refus d'accès en lecture, CRYPTO_E_KEY_EMPTY en présence d'un élément source non initialisé ainsi que de manière générique E_NOT_OK [SWS_Crypto_91006].

Bien que l'interface soit spécifiée comme réentrante, la spécification indique qu'en cas de mappage direct de l'élément de clé en mémoire flash, des latences perceptibles peuvent survenir pendant l'exécution synchrone [SWS_Crypto_91006]. Interprétation : en raison de ces retards potentiels, l'appel devrait être approprié principalement dans un contexte de tâche et non au sein de routines de service d'interruption à contraintes temporelles critiques. Question Q-ff4e2843b9aad46d (ouverte)

La fonction synchrone Crypto_KeyGetStatus sert à interroger l'état actuel d'une clé spécifique au sein du pilote cryptographique [SWS_Crypto_91019]. Elle est fournie via l'en-tête Crypto.h et porte le Service-ID 0x14 [SWS_Crypto_91019].

Utilisation et paramètres

L'appel s'effectue de manière synchrone et attend deux paramètres [SWS_Crypto_91019] :

• cryptoKeyId : l'identifiant de la clé dont l'état doit être déterminé.
• keyStatusPtr : pointeur vers la zone mémoire de type Crypto_KeyStatusType à laquelle l'état est renvoyé.

Comme valeur de retour, l'interface renvoie Std_ReturnType. En cas d'exécution réussie, E_OK est signalé, tandis qu'en cas d'erreur E_NOT_OK est renvoyé [SWS_Crypto_91019].

Concurrence et restrictions

La fonction est déclarée comme non réentrante (Non Reentrant) [SWS_Crypto_91019]. Les appelants doivent donc veiller à éviter les appels concurrents au moyen de mécanismes de synchronisation de niveau supérieur. Aucun message d'erreur DET spécifique n'est mentionné ; vraisemblablement, un appel erroné tel qu'un pointeur non valide ou un ID non valide entraîne directement le retour de E_NOT_OK [SWS_Crypto_91019]. Question Q-5703fab02905e91a (ouverte)

La fonction synchrone Crypto_KeyElementCopy sert à copier un élément de clé vers un autre élément de clé au sein du même pilote cryptographique [SWS_Crypto_00148]. Sont transmis les identifiants de la clé source (cryptoKeyId) et de l'élément de clé source (keyElementId) ainsi que de la clé cible (targetCryptoKeyId) et de l'élément de clé cible (targetKeyElementId) [SWS_Crypto_00148].

En ce qui concerne le comportement temporel, il convient de noter qu'en cas d'éléments de clé mappés directement en mémoire flash, des retards plus importants peuvent survenir lors de l'appel de fonction en raison de l'exécution synchrone [SWS_Crypto_00148]. Le comportement temporel d'exécution doit donc être pris en compte, en particulier dans les contextes à contraintes temporelles critiques.

La fonction est conçue pour être réentrante, mais explicitement pas pour la même cryptoKeyId [SWS_Crypto_00148]. Les appels simultanés avec une clé source identique doivent par conséquent être synchronisés ou exclus par l'appelant.

En cas de succès, la fonction renvoie E_OK [SWS_Crypto_00148]. En cas d'erreur, la valeur de retour signale la cause spécifique [SWS_Crypto_00148] :

• CRYPTO_E_BUSY : l'objet pilote cryptographique est occupé [SWS_Crypto_00148].
• CRYPTO_E_KEY_NOT_AVAILABLE : l'élément de clé demandé d'au moins une clé n'est pas disponible [SWS_Crypto_00148].
• CRYPTO_E_KEY_READ_FAIL ou CRYPTO_E_KEY_WRITE_FAIL : la lecture de l'élément source ou l'écriture de l'élément cible n'est pas autorisée [SWS_Crypto_00148].
• CRYPTO_E_KEY_SIZE_MISMATCH : les tailles des éléments de clé ne sont pas compatibles entre elles [SWS_Crypto_00148].
• CRYPTO_E_KEY_EMPTY : l'élément de clé source n'est pas initialisé [SWS_Crypto_00148].
• E_NOT_OK : la requête a échoué de manière générale [SWS_Crypto_00148].

La fonction synchrone Crypto_KeyElementCopyPartial sert à la copie partielle de données depuis un élément de clé source vers un élément de clé cible au sein du même pilote crypto [SWS_Crypto_91015]. La section à copier de l'élément source (cryptoKeyId, keyElementId) est définie via les paramètres keyElementSourceOffset et keyElementCopyLength, tandis que keyElementTargetOffset détermine la position de départ dans l'élément cible (targetCryptoKeyId, targetKeyElementId). En cas de vérification sans erreur, le pilote effectue l'opération de copie de manière synchrone et renvoie E_OK [SWS_Crypto_00209].

Avant l'exécution, le pilote valide les états des tampons et du pilote :

• Si le pilote crypto n'est pas initialisé et que le contrôle de développement est activé, la fonction signale CRYPTO_E_UNINIT au DET et renvoie E_NOT_OK [SWS_Crypto_00205].
• Si la longueur totale de l'élément de clé source est inférieure à keyElementSourceOffset + keyElementCopyLength, l'appel échoue avec CRYPTO_E_KEY_SIZE_MISMATCH [SWS_Crypto_00207].
• Si le tampon maximal de l'élément de clé cible offre moins d'espace que keyElementTargetOffset + keyElementCopyLength, CRYPTO_E_KEY_SIZE_MISMATCH est également signalé [SWS_Crypto_00208].
• D'autres valeurs d'erreur spécifiées sont entre autres CRYPTO_E_BUSY (objet pilote occupé), CRYPTO_E_KEY_EMPTY (élément source non initialisé), CRYPTO_E_KEY_NOT_AVAILABLE ainsi que des erreurs d'accès en lecture ou en écriture (CRYPTO_E_KEY_READ_FAIL, CRYPTO_E_KEY_WRITE_FAIL) [SWS_Crypto_91015].

La fonction est réentrante, mais ne doit pas être appelée simultanément pour le même ID de clé cryptoKeyId [SWS_Crypto_91015]. Si un élément de clé est directement stocké dans la mémoire flash, l'exécution synchrone peut entraîner des retards perceptibles [SWS_Crypto_91015].

Utilisation

La fonction synchrone Crypto_KeyCopy copie une clé ainsi que tous ses éléments de clé vers une clé cible au sein du même pilote crypto [SWS_Crypto_00155]. L'association s'effectue via les paramètres d'entrée cryptoKeyId pour la clé source ainsi que targetCryptoKeyId pour la clé cible [SWS_Crypto_00155]. Une opération de copie réussie est confirmée par E_OK [SWS_Crypto_00155].

Concurrence et comportement à l'exécution

L'interface est conçue pour être réentrante, mais ne doit pas être exécutée simultanément pour la même cryptoKeyId [SWS_Crypto_00155]. Étant donné que l'exécution s'effectue de manière synchrone, des retards perceptibles peuvent survenir pendant l'appel pour les éléments de clé stockés directement dans la mémoire flash [SWS_Crypto_00155].

Gestion des erreurs

En cas d'erreur, la fonction fournit des valeurs de retour spécifiques de type Std_ReturnType [SWS_Crypto_00155] :

• CRYPTO_E_BUSY : le Crypto Driver Object associé est occupé [SWS_Crypto_00155].
• CRYPTO_E_KEY_NOT_AVAILABLE : au moins l'une des clés demandées n'est pas disponible [SWS_Crypto_00155].
• CRYPTO_E_KEY_READ_FAIL : la lecture de l'élément de clé source n'est pas autorisée [SWS_Crypto_00155].
• CRYPTO_E_KEY_WRITE_FAIL : l'écriture dans l'élément de clé cible n'est pas autorisée [SWS_Crypto_00155].
• CRYPTO_E_KEY_SIZE_MISMATCH : les tailles des éléments de clé ne sont pas compatibles entre elles [SWS_Crypto_00155].
• CRYPTO_E_KEY_EMPTY : l'élément de clé de la clé source n'est pas initialisé [SWS_Crypto_00155].
• E_NOT_OK : l'exécution de la demande a échoué [SWS_Crypto_00155].

La fonction synchrone Crypto_KeyElementIdsGet sert à demander des informations indiquant quels éléments de clé sont disponibles dans une clé donnée [SWS_Crypto_00160]. L'identifiant de la clé dont les ID d'éléments disponibles doivent être exportés est transmis via le paramètre d'entrée cryptoKeyId [SWS_Crypto_00160]. Les identifiants déterminés sont stockés dans le tableau référencé par le pointeur keyElementIdsPtr [SWS_Crypto_00160].

La gestion de la taille du tampon s'effectue via le paramètre d'entrée et de sortie keyElementIdsLengthPtr : lors de l'appel, ce paramètre doit contenir la taille fournie du tampon keyElementIdsPtr [SWS_Crypto_00160]. Une fois l'opération terminée, le nombre réel d'éléments de clé présents y est consigné [SWS_Crypto_00160].

Comme valeur de retour, le service fournit E_OK en cas d'interrogation réussie ou E_NOT_OK si la requête a échoué [SWS_Crypto_00160]. Si l'objet pilote cryptographique concerné est occupé au moment de l'appel, le code d'erreur CRYPTO_E_BUSY est renvoyé [SWS_Crypto_00160].

En ce qui concerne la concurrence, la fonction est réentrante, mais ne doit pas être appelée simultanément pour la même cryptoKeyId [SWS_Crypto_00160]. La déclaration est disponible via l'en-tête Crypto.h [SWS_Crypto_00160].

La fonction synchrone Crypto_RandomSeed (Service-ID 0x0d) sert, selon [SWS_Crypto_91013], à la génération ainsi qu'à la mise à jour de l'état de graine interne d'une clé en utilisant une source d'entropie fournie. La déclaration de la fonction figure dans le fichier d'en-tête Crypto.h.

Utilisation et paramètres d'appel

Outre la génération initiale, la fonction peut également être utilisée selon [SWS_Crypto_91013] pour mettre à jour l'état de graine avec une nouvelle entropie. L'appel synchrone nécessite pour cela trois paramètres d'entrée :

• cryptoKeyId : transmet l'identifiant de la clé pour laquelle une nouvelle graine doit être générée.
• seedPtr : contient un pointeur vers la zone mémoire avec les données pour alimenter la graine.
• seedLength : définit la longueur en octets des données de graine transmises.

Valeurs de retour et gestion des erreurs

Comme valeur de retour, Crypto_RandomSeed signale un état de type Std_ReturnType selon [SWS_Crypto_91013] :

• E_OK : la requête a été exécutée avec succès.
• E_NOT_OK : la requête a échoué.
• CRYPTO_E_KEY_NOT_VALID : l'exécution échoue, car l'état de la clé identifiée par cryptoKeyId se trouve au statut « invalid ».

Concurrence et restrictions

Conformément à [SWS_Crypto_91013], la fonction est spécifiée comme réentrante, mais expressément pas pour la même cryptoKeyId. Les appels parallèles pour la même clé doivent donc être empêchés côté appelant.

Utilisation

La fonction Crypto_KeyGenerate fournie via le fichier d'en-tête Crypto.h génère du nouveau matériel de clé et met à jour la clé adressée via l'identifiant cryptoKeyId [SWS_Crypto_91007]. La fonction fonctionne de manière entièrement synchrone et est définie sous le Service-ID 0x07 [SWS_Crypto_91007]. Il n'existe pas d'autres paramètres en dehors de l'identifiant de la clé [SWS_Crypto_91007].

Concurrence et restrictions

En matière de concurrence, Crypto_KeyGenerate est spécifiée comme réentrante, mais expressément avec la restriction selon laquelle cela ne s'applique pas à la même cryptoKeyId [SWS_Crypto_91007]. Si plusieurs demandes sont émises pour la même clé, celles-ci doivent être synchronisées côté appelant afin d'éviter les conflits de pilote.

Valeurs de retour et gestion des erreurs

Via la valeur de retour du type de base Std_ReturnType, l'appelant reçoit un retour détaillé sur le succès ou les causes d'erreur spécifiques de l'opération [SWS_Crypto_91007] :

• E_OK : la génération de clé a été exécutée avec succès [SWS_Crypto_91007].
• CRYPTO_E_BUSY : la demande a échoué, car le Crypto Driver Object concerné est actuellement occupé [SWS_Crypto_91007].
• CRYPTO_E_KEY_EMPTY : la génération a échoué parce qu'un élément de clé source requis n'est pas initialisé [SWS_Crypto_91007].
• CRYPTO_E_KEY_NOT_VALID : l'opération a échoué, car l'état de la clé référencée par cryptoKeyId est marqué comme non valide [SWS_Crypto_91007].
• E_NOT_OK : la demande de génération de clé a échoué pour d'autres raisons [SWS_Crypto_91007].

La fonction synchrone Crypto_KeyDerive dérive une nouvelle clé cryptographique à partir des éléments de clé d'une clé source (cryptoKeyId) et l'enregistre dans l'élément de clé d'ID 1 de la clé cible (targetCryptoKeyId) [SWS_Crypto_91008]. La clé source doit contenir les éléments de clé requis pour le mot de passe et le sel ; le nombre d'itérations est spécifié via l'élément de clé CRYPTO_KE_KEYDERIVATION_ITERATIONS [SWS_Crypto_91008].

Appel et concurrence

L'interface est réentrante, mais ne doit pas être appelée simultanément pour la même cryptoKeyId [SWS_Crypto_91008]. Les appelants doivent donc s'assurer que les opérations de dérivation parallèles s'exécutent sur des clés sources différentes.

Valeurs de retour et gestion des erreurs

La fonction signale le résultat via des valeurs de retour définies de type Std_ReturnType [SWS_Crypto_91008] :

• E_OK : dérivation de clé effectuée avec succès.
• E_NOT_OK : dérivation échouée. Si le paramètre targetCryptoKeyId est en dehors de la plage valide, la fonction signale en outre CRYPTO_E_PARAM_HANDLE au DET lorsque la détection du développement est activée [SWS_Crypto_00180].
• CRYPTO_E_BUSY : Le Crypto Driver Object concerné est occupé [SWS_Crypto_91008].
• CRYPTO_E_KEY_EMPTY : un élément de clé source requis n'est pas initialisé [SWS_Crypto_91008].
• CRYPTO_E_KEY_NOT_VALID : l'état de la clé référencée par cryptoKeyId n'est pas valide [SWS_Crypto_91008].

Utilisation

La fonction synchrone Crypto_KeyExchangeCalcPubVal calcule la valeur publique pour un protocole d'échange de clés et l'enregistre à l'emplacement mémoire de publicValuePtr ([SWS_Crypto_91009]). L'appelant transmet via cryptoKeyId l'identifiant de la clé devant être utilisée pour le protocole. Via le paramètre d'entrée et de sortie publicValueLengthPtr, la taille de tampon de la mémoire fournie doit être transmise lors de l'appel ; une fois l'exécution terminée, la longueur réelle de la valeur publique calculée y est consignée ([SWS_Crypto_91009]).

Gestion des erreurs et valeurs de retour

La fonction renvoie E_OK en cas d'exécution réussie. Si une erreur survient, E_NOT_OK ou un code d'erreur spécifique est renvoyé ([SWS_Crypto_91009]) :

• CRYPTO_E_BUSY : la requête échoue, car le Crypto Driver Object est occupé.
• CRYPTO_E_KEY_EMPTY : la requête échoue, car l'élément de clé source n'est pas initialisé.
• CRYPTO_E_KEY_NOT_VALID : la requête échoue, car l'état de la clé référencée via cryptoKeyId n'est pas valide.

Concurrence et intégration système

Conformément à [SWS_Crypto_91009], la fonction est réentrante, mais pas pour la même cryptoKeyId. Si le pilote cryptographique requiert pour des besoins internes tels que Crypto_KeyExchangeCalcPubVal les services d'un générateur de nombres aléatoires (RNG), le premier Crypto Driver Object (numéro d'objet 0) doit être configuré à cet effet ([SWS_Crypto_00224]).

La fonction synchrone Crypto_KeyExchangeCalcSecret sert au calcul d'un secret partagé (Shared Secret Key) pour un protocole d'échange de clés [SWS_Crypto_91010]. Elle traite le matériel de clé de la clé spécifiée via cryptoKeyId conjointement avec la valeur publique du partenaire transmise via partnerPublicValuePtr, dont le nombre d'octets est indiqué via partnerPublicValueLength [SWS_Crypto_91010]. Le secret partagé calculé est directement enregistré en tant qu'élément de clé au sein de la même clé [SWS_Crypto_91010].

Comme valeur de retour, la fonction fournit l'état via Std_ReturnType [SWS_Crypto_91010] :

• E_OK : le calcul et l'enregistrement du secret se sont terminés avec succès [SWS_Crypto_91010].
• E_NOT_OK : la demande a échoué [SWS_Crypto_91010].
• CRYPTO_E_BUSY : l'exécution a échoué, car le Crypto Driver Object concerné est occupé [SWS_Crypto_91010].
• CRYPTO_E_KEY_EMPTY : l'élément de clé source n'est pas initialisé [SWS_Crypto_91010].
• CRYPTO_E_KEY_NOT_VALID : l'état de la clé référencée par cryptoKeyId n'est pas valide [SWS_Crypto_91010].

L'interface est implémentée pour être réentrante, mais ne doit pas être appelée de manière concurrente pour la même cryptoKeyId [SWS_Crypto_91010]. Les appelants doivent donc veiller à éviter les appels simultanés avec un identifiant de clé identique et s'assurer que le matériel de clé référencé est initialisé au préalable et se trouve dans un état valide afin d'empêcher les états d'erreur [SWS_Crypto_91010].

La fonction Crypto_MainFunction sert au traitement cyclique d'ordres cryptographiques mis en file d'attente dans les files d'attente de jobs du pilote cryptographique [SWS_Crypto_91012]. Son utilisation requiert que le traitement asynchrone des ordres ait été configuré dans le module et que les files d'attente d'ordres correspondantes soient présentes [SWS_Crypto_91012].

Appel et sémantique

La fonction possède la signature void Crypto_MainFunction(void) et est spécifiée avec le Service-ID 0x0c [SWS_Crypto_91012]. Elle n'accepte aucun paramètre d'entrée et ne renvoie aucune valeur de retour. L'interface est fournie via l'en-tête SchM_Crypto.h [SWS_Crypto_91012]. Cela autorise l'interprétation selon laquelle l'appel cyclique est déclenché de manière planifiée par l'ordonnanceur BSW (Schedule Manager) dans le contexte d'une tâche périodique du système d'exploitation.

Concurrence et restrictions

L'appel est strictement lié à la configuration de files d'attente de jobs asynchrones [SWS_Crypto_91012]. La spécification n'indiquant aucune réentrance pour Crypto_MainFunction, la fonction devrait être traitée comme non réentrante ; les appels parallèles à partir de plusieurs threads ou tâches devraient donc être évités. Question Q-038d384305c8c5c3 (ouverte)

Gestion des erreurs

Dans la spécification, aucun code d'erreur spécifique ni entrée DET ne sont consignés pour cette fonction [SWS_Crypto_91012]. La fonction ne fournissant pas de valeurs de retour, d'éventuelles erreurs survenues pendant le traitement asynchrone sont probablement transmises aux couches supérieures via des interrogations d'état ou via les canaux de retour des jobs respectifs. Question (ouverte)