DEENESPTFRRUARHIKOZHNL

Crypto Interface (CryIf)

ModulCryIf (Crypto Interface)
BSW-Modul-ID112
Standard-Header#include "CryIf.h"
SWS-SpezifikationAUTOSAR_SWS_CryptoInterface.pdf
ClusterCrypto Services

Guide du moduleGÉNÉRÉ PAR IA

Transmet les jobs cryptographiques et les appels de clés du CSM aux pilotes cryptographiques compétents via des canaux configurés.
GÉNÉRÉ PAR IA non vérifié Modèle : claude-opus-5-5 · Effort : high · Température : non réglable · Prompt : 6b37c73ee677 Provenance Questions ouvertes (4)
Ancre causale : R20-11 Valable à partir de R20-11 Synthétisé pour cette version de spécification.
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand

Transmet les jobs cryptographiques et les appels de clés du CSM aux pilotes cryptographiques compétents via des canaux configurés.

Au sein de la pile cryptographique Classic, le CryIf assure l'intermédiation entre le CSM et le Crypto Driver et achemine les jobs et les appels de clés vers le Crypto Driver Object compétent via des canaux configurés SWS CSM p. 26. L'interface centrale est CryIf_ProcessJob, qui fonctionne de manière synchrone ou asynchrone selon la configuration [SWS_CryIf_91003]. Le pilote transmet les résultats asynchrones par callback au CryIf, qui les répercute au CSM. Avant le transfert, le CryIf fait correspondre ses propres identifiants de clés à ceux du pilote et vérifie leur plage. Pour R20-11, il convient de noter que les versions ultérieures ont modifié les codes d'erreur et les règles de synchronicité.

Au sein de la pile cryptographique Classic, le CryIf assure l'intermédiation entre le CSM situé dans le Service Layer et le Crypto Driver situé dans le MCAL. Les requêtes des applications transitent via des canaux logiques jusqu'aux moteurs matériels d'un HSM SWS CSM Fig. 7.4 p. 27. Un canal représente le chemin reliant une file d'attente du CSM à un Crypto Driver Object via le CryIf ; chaque file d'attente du CSM est affectée à un seul canal SWS CSM p. 26. Les canaux sont configurés dans le conteneur CryIfChannel avec CryIfChannelId et CryIfDriverObjectRef SWS CryIf p. 51. Avant toute utilisation, CryIf_Init initialise le module avec une configuration spécifique à l'implémentation [SWS_CryIf_91000].

kontext cluster_app Application Layer cluster_srv Service Layer cluster_ecu ECU Abstraction Layer cluster_mcal MCAL cluster_hw Microcontroller (HSM) app1 App1 (AES) rte RTE app1->rte app2 App2 (AES) app2->rte app3 App3 (RSA) app3->rte csm CSM Queue je Kanal rte->csm Krypto-Dienste cryif CryIf CryIfChannel csm->cryif CryIf_ProcessJob, CryIf_CancelJob, CryIf_Key… cryif->csm Csm_CallbackNotification crypto Crypto Driver Crypto Driver Objects cryif->crypto Weiterleitung je Kanal an Crypto Driver Object det DET cryif->det Det_ReportError, Det_ReportRuntimeError crypto->cryif CryIf_CallbackNotification hwaes HW-AES crypto->hwaes Kanal AES hwrsa HW-RSA crypto->hwrsa Kanal RSA

Diagramme de contexte : le CryIf achemine les demandes du CSM par canal vers les Crypto Driver Objects et renvoie les résultats au CSM. Sources : SWS CSM Fig. 7.4 p. 27, [SWS_CryIf_91100]

L'interface centrale est CryIf_ProcessJob. La fonction est réentrante et opère de manière synchrone ou asynchrone selon la configuration [SWS_CryIf_91003]. Les modes de fonctionnement START, UPDATE et FINISH peuvent être combinés, de sorte que la même fonction prend en charge les appels uniques et le streaming SWS CryIf p. 22. Le pilote signale les résultats asynchrones via CryIf_CallbackNotification [SWS_CryIf_91013]. Le CryIf les transmet au CSM via Csm_CallbackNotification [SWS_CryIf_91100]. CryIf_CancelJob interrompt les jobs en cours auprès du pilote [SWS_CryIf_91014].

Traitement de job via CryIf_ProcessJobCSMCryIfCrypto Driver ObjectDETCryIf_ProcessJob(channelId, job)Vérifier les ID de cléet mapper sur les ID du piloteoptID de clé hors plageCRYPTO_E_PARAM_HANDLE meldenE_NOT_OKCrypto_ProcessJob(…, job)altsynchron konfiguriertBerechnungErgebnis (E_OK / CRYPTO_E_…)relayer la valeur de retourasynchron konfiguriertvaleur de retour de la transmissionrelayer la valeur de retourBerechnung,p. ex. depuis la fonction principale (MainFunction)CryIf_CallbackNotification(job, result)Csm_CallbackNotification(job, result)

Diagramme de séquence : le CryIf vérifie les identifiants de clés puis transmet le job. Le résultat est renvoyé de manière synchrone en tant que valeur de retour ou de manière asynchrone via deux niveaux de callback. Sources : [SWS_CryIf_91003], [SWS_CryIf_91013], SWS Crypto p. 27

Avant le transfert, le CryIf fait correspondre ses propres identifiants de clés aux identifiants du pilote. S'ils se situent en dehors de la plage, il signale CRYPTO_E_PARAM_HANDLE à la DET et renvoie E_NOT_OK [SWS_CryIf_00133] [SWS_CryIf_00134]. Par ailleurs, le CryIf propose des fonctions synchrones pour définir, valider et invalider, lire, générer, dériver, échanger et copier des clés. Si, lors d'une copie partielle, la source et la cible résident dans des pilotes différents, le CryIf lit l'élément et l'écrit lui-même dans la cible [SWS_CryIf_00140].

Les erreurs de développement telles que CRYIF_E_UNINIT ou CRYIF_E_PARAM_POINTER sont transmises à la DET [SWS_CryIf_00009]. Les erreurs d'exécution telles que CRYPTO_E_BUSY ou CRYPTO_E_KEY_NOT_VALID sont renvoyées sous forme de valeurs de retour [SWS_CryIf_91020]. Les versions ultérieures diffèrent de R20-11 : elles uniformisent CRYIF_E_PARAM_HANDLE et fixent CryIf_RandomSeed ainsi que CryIf_KeyGenerate en mode synchrone SWS CryIf p. 1.

Rôle du CryIf entre le Crypto Service Manager et le Crypto Driver

Le Crypto Interface (CryIf) se situe dans la pile cryptographique Classic au sein de l'ECU Abstraction Layer. Les applications demandent des services cryptographiques via la RTE et le CSM. Ces requêtes transitent par des canaux logiques à travers le CryIf jusqu'au Crypto Driver dans le MCAL, puis vers ses moteurs matériels, tels que HW-AES et HW-RSA dans un HSM SWS CSM Fig. 7.4 p. 27. Un Crypto Driver Object représente une « entité » cryptographique indépendante, matérielle ou logicielle, par exemple un accélérateur AES ou une implémentation logicielle de RSA SWS CSM p. 26. Le CryIf n'effectue aucun calcul par lui-même. Ses fonctions relaient chaque appel vers le Crypto Driver Object configuré, comme [SWS_CryIf_91005], [SWS_CryIf_91007], [SWS_CryIf_91009] et [SWS_CryIf_91014].

Vers le haut, le CryIf propose trois groupes d'interfaces :

Pour un job à l'état « ACTIVE », le CSM appelle CryIf_ProcessJob et transmet sa valeur de retour sans modification SWS CSM p. 22. Vers le bas, le CryIf reçoit via CryIf_CallbackNotification [SWS_CryIf_91013] les notifications de fin d'exécution du pilote SWS Crypto p. 27. Parmi les autres modules, il requiert Csm_CallbackNotification et Det_ReportRuntimeError [SWS_CryIf_91100], ainsi qu'optionnellement Det_ReportError [SWS_CryIf_91101].

kontext cluster_app Application Layer cluster_srv Service Layer cluster_ecu ECU Abstraction Layer cluster_mcal MCAL cluster_hw Microcontroller (HSM) app1 App1 (AES) rte RTE app1->rte app2 App2 (AES) app2->rte app3 App3 (RSA) app3->rte csm CSM Queue je Kanal rte->csm Krypto-Dienste cryif CryIf CryIfChannel csm->cryif CryIf_ProcessJob, CryIf_CancelJob, CryIf_Key… cryif->csm Csm_CallbackNotification crypto Crypto Driver Crypto Driver Objects cryif->crypto Weiterleitung je Kanal an Crypto Driver Object det DET cryif->det Det_ReportError, Det_ReportRuntimeError crypto->cryif CryIf_CallbackNotification hwaes HW-AES crypto->hwaes Kanal AES hwrsa HW-RSA crypto->hwrsa Kanal RSA

Diagramme de contexte : le CryIf relie canal par canal les files d'attente du CSM aux Crypto Driver Objects et renvoie les résultats au CSM. Sources : SWS CSM Fig. 7.4 p. 27, [SWS_CryIf_91100], [SWS_CryIf_91013]

Canaux, configuration et initialisation

Un canal représente le chemin reliant une file d'attente du CSM à un Crypto Driver Object via le CryIf. Chaque file d'attente du CSM est affectée à exactement un canal ; de manière optionnelle, le Crypto Driver dispose également de sa propre file d'attente SWS CSM p. 26. Les canaux sont configurés dans le conteneur CryIfChannel, avec une multiplicité de 0..* et une configuration pre-compile dans toutes les variantes. Le conteneur inclut les paramètres CryIfChannelId et CryIfDriverObjectRef SWS CryIf p. 51. CryIfChannelId détermine à quel canal une file d'attente du CSM est connectée. À l'exécution, le paramètre channelId de [SWS_CryIf_91003] et [SWS_CryIf_91014] désigne également le canal cryptographique. Interprétation : CryIfDriverObjectRef lie vraisemblablement le canal au Crypto Driver Object qui exécute les requêtes de ce canal. Question Q-5f8f778dc8552b7f (ouverte)

Avant toute utilisation, il convient d'appeler CryIf_Init [SWS_CryIf_91000]. Cette fonction est synchrone et non réentrante. Elle reçoit un pointeur vers la configuration sélectionnée de type CryIf_ConfigType, dont le contenu est spécifique à l'implémentation [SWS_CryIf_91118] SWS CryIf p. 20. En cas d'échec d'initialisation, la liste des erreurs prévoit CRYIF_E_INIT_FAILED (0x01) [SWS_CryIf_00009]. CryIf_GetVersionInfo est réentrante et fournit les informations de version du module [SWS_CryIf_91001].

Outre les canaux, le CryIf gère ses propres identifiants de clé (cryIfKeyId). Il les met en correspondance avec les ID de clé du pilote compétent [SWS_CryIf_00133]. Si un job utilise une redirection de traitement (job processing redirection), le CryIf adapte en outre les références entrantes de clé et d'élément de clé à celles du pilote [SWS_CryIf_00136]. Une clé est composée d'un ou de plusieurs éléments de clé, tels que du matériel de clé, un vecteur d'initialisation ou un seed SWS CSM p. 30.

Traitement des jobs, de CryIf_ProcessJob à la notification en retour

L'appel unique et le streaming passent par la même fonction CryIf_ProcessJob. Le champ job->jobPrimitiveInputOutput.mode contient les modes de fonctionnement « START », « UPDATE » et « FINISH », qui peuvent être combinés. Un service complet exécuté en un seul appel correspond à la combinaison des trois modes SWS CryIf p. 22. La fonction est réentrante et fonctionne de manière synchrone ou asynchrone selon la configuration [SWS_CryIf_91003]. Les transitions d'état d'un job sont effectuées par le Crypto Driver, et non par le CSM SWS CSM p. 22.

Dans le cas asynchrone, le pilote ne transmet que les informations nécessaires à la primitive. Le calcul peut ensuite être déclenché depuis la fonction Main. Une fois le traitement terminé, le pilote signale le job et le résultat au CryIf via CryIf_CallbackNotification SWS Crypto p. 27. Cette fonction est synchrone et non réentrante ; le job transmis contient un ID de callback qui l'identifie [SWS_CryIf_91013]. Le CryIf notifie ensuite la fin d'exécution au CSM via Csm_CallbackNotification ; cette fonction est expressément prévue pour la couche sous-jacente CRYIF [SWS_CryIf_91100]. Si le bit FINISH est activé, le CSM appelle le callback configuré SWS CSM p. 82.

Traitement de job via CryIf_ProcessJobCSMCryIfCrypto Driver ObjectDETCryIf_ProcessJob(channelId, job)Vérifier les ID de cléet mapper sur les ID du piloteoptID de clé hors plageCRYPTO_E_PARAM_HANDLE meldenE_NOT_OKCrypto_ProcessJob(…, job)altsynchron konfiguriertBerechnungErgebnis (E_OK / CRYPTO_E_…)relayer la valeur de retourasynchron konfiguriertvaleur de retour de la transmissionrelayer la valeur de retourBerechnung,p. ex. depuis la fonction principale (MainFunction)CryIf_CallbackNotification(job, result)Csm_CallbackNotification(job, result)

Diagramme de séquence : le CryIf vérifie d'abord les ID de clé puis transmet le job. Le résultat est retourné soit de manière synchrone comme valeur de retour, soit de manière asynchrone via deux niveaux de callback. Sources : [SWS_CryIf_91003], [SWS_CryIf_00134], [SWS_CryIf_91013], [SWS_CryIf_91100], SWS Crypto p. 27

Les jobs asynchrones et les jobs de streaming en cours d'exécution peuvent être interrompus. Pour ce faire, le CSM retire le job de sa propre file d'attente ou appelle CryIf_CancelJob SWS CSM p. 80. CryIf_CancelJob est synchrone et réentrante, et relaie l'annulation vers le Crypto Driver Object configuré. E_OK indique que le job a été retiré ; E_NOT_OK signifie que cela n'a pas été possible [SWS_CryIf_91014] SWS CryIf p. 24. Les passages documentaires des versions ultérieures (R24-11/R25-11) mentionnent en outre CRYPTO_E_JOB_CANCELED. Dans ce cas, l'annulation n'intervient qu'à la prochaine étape de traitement appropriée et est signalée par un callback de fin négatif SWS CSM p. 80.

Annulation d'un jobApplicationCSMCryIfCrypto Driver ObjectCsm_CancelJob(job, mode)altJob encore dans la file d'attente CSMRetirer le job de sa propre file d'attenteJob déjà au niveau du piloteCryIf_CancelJob(channelId, job)Abbruch weiterleiten(Crypto_CancelJob)E_OK / E_NOT_OK(plus tard également CRYPTO_E_JOB_CANCELED)Valeur de retourE_OK : le CSM appelle le callback de fin du jobCRYPTO_E_JOB_CANCELED : annulation lors du prochaingeeigneten Schritt, negativer Abschluss-CallbackValeur de retour

Diagramme de séquence : une annulation se termine soit directement dans la file d'attente du CSM, soit est relayée via le CryIf vers le Crypto Driver Object. Sources : [SWS_CryIf_91014], SWS CSM p. 80, SWS CryIf p. 45

Mise en correspondance et vérification des ID de clé dans le job

Certains jobs portent sur un service de gestion des clés : CRYPTO_KEYSETVALID, CRYPTO_KEYSETINVALID, CRYPTO_RANDOMSEED, CRYPTO_KEYGENERATE, CRYPTO_KEYDERIVE, CRYPTO_KEYEXCHANGECALCPUBVAL ou CRYPTO_KEYEXCHANGECALCSECRET. Pour ceux-ci, le CryIf vérifie si job->jobPrimitiveInputOutput->cryIfKeyId et, le cas échéant, targetCryIfKeyId se situent dans la plage valide. Si tel est le cas, il définit job->cryptoKeyId et job->targetCryptoKeyId sur les ID de clé du pilote [SWS_CryIf_00133] [SWS_CryIf_00141]. Si l'ID source est hors de portée, CryIf_ProcessJob signale CRYPTO_E_PARAM_HANDLE à la DET et renvoie E_NOT_OK [SWS_CryIf_00134]. Pour CRYPTO_KEYDERIVE, la même règle s'applique également à l'ID cible [SWS_CryIf_00135].

Les primitives liées à des clés font également l'objet d'un contrôle. Pour CRYPTO_MACGENERATE, CRYPTO_MACVERIFY, CRYPTO_ENCRYPT, CRYPTO_DECRYPT, CRYPTO_AEADENCRYPT, CRYPTO_AEADDECRYPT, CRYPTO_RANDOMGENERATE, CRYPTO_SIGNATUREGENERATE et CRYPTO_SIGNATUREVERIFY, la validité de la plage de job->jobPrimitiveInfo->cryIfKeyId est vérifiée [SWS_CryIf_00143].

keyid start CryIf_ProcessJob(channelId, job) d1 Service de gestion des clés ? KEYSETVALID, KEYSETINVALID, RANDOMSEED, KEYGENERATE, KEYDERIVE, KEYEXCHANGECALCPUBVAL, KEYEXCHANGECALCSECRET start->d1 c1 jobPrimitiveInputOutput->cryIfKeyId dans la plage valide ? d1->c1 Oui d3 Primitive avec clé ? MACGENERATE/-VERIFY, (AEAD)ENCRYPT/DECRYPT, RANDOMGENERATE, SIGNATUREGENERATE/-VERIFY d1->d3 Non d2 Dienst = CRYPTO_KEYDERIVE? c1->d2 Oui err CRYPTO_E_PARAM_HANDLE au DET retour de E_NOT_OK c1->err Non c2 targetCryIfKeyId dans la plage valide ? d2->c2 Oui map Définir job->cryptoKeyId (le cas échéant job->targetCryptoKeyId) sur les identifiants de clé du pilote d2->map Non c2->map Oui c2->err Non fwd Transférer au Crypto Driver Object du canal map->fwd c3 jobPrimitiveInfo->cryIfKeyId dans la plage valide ? d3->c3 Oui d3->fwd Non c3->err Non c3->fwd Oui

Diagramme d'activité : le CryIf vérifie les ID de clé en fonction du type de service et les fait correspondre aux ID du pilote avant de relayer le job. Sources : [SWS_CryIf_00133], [SWS_CryIf_00134], [SWS_CryIf_00135], [SWS_CryIf_00143]

Ce domaine a évolué entre les versions. La R20-11 mentionne CRYPTO_E_PARAM_HANDLE dans les vérifications, tandis que la liste des erreurs du module définit CRYIF_E_PARAM_HANDLE (0x03) [SWS_CryIf_00009]. Selon l'historique des modifications, cela n'a été unifié sur CRYIF_E_PARAM_HANDLE qu'en R22-11 SWS CryIf p. 1. Cette même modification a supprimé les valeurs de retour consécutives aux notifications DET. En outre, le service CRYPTO_CUSTOM a été ajouté, figurant déjà dans la liste du passage documentaire ultérieur SWS CryIf p. 23. Pour la R20-11, les exigences s'appliquent sous la forme citée ici.

Gestion des clés : matériel, état, génération et échange

Les API directes de gestion des clés sont synchrones. Les fonctions non réentrantes sont CryIf_KeyElementSet [SWS_CryIf_91004], CryIf_KeySetValid [SWS_CryIf_91005], CryIf_KeySetInvalid [SWS_CryIf_91021] et CryIf_KeyGetStatus [SWS_CryIf_91012]. Selon l'historique des modifications, la fonctionnalité liée à l'état de la clé a été ajoutée avec la R20-11 SWS CryIf p. 1. En cas d'échec de la définition d'un élément, son état est considéré comme inconnu selon la spécification du CSM SWS CSM p. 62. Il peut être vérifié avec Csm_KeyGetStatus, qui appelle à son tour CryIf_KeyGetStatus SWS CSM p. 63.

CryIf_KeyElementGet est réentrante [SWS_CryIf_91006]. Le paramètre resultLengthPtr sert d'entrée et de sortie. Lors de l'appel, il contient la taille du tampon ; pour les éléments à accès partiel, il contient à la place la quantité devant être lue. À l'issue de l'opération, il contient la quantité de données réellement écrite SWS CryIf p. 30.

schluesselstatus start commencer gesetzt Éléments définis (pas encore déclarés valides, interprétation) start->gesetzt CryIf_KeyElementSet valid valide (valid) gesetzt->valid CryIf_KeySetValid valid->valid Nutzung in Jobs, CryIf_KeyGetStatus invalid invalide (invalid) valid->invalid CryIf_KeySetInvalid invalid->valid CryIf_KeySetValid invalid->invalid Nutzung scheitert: CRYPTO_E_KEY_NOT_VALID

Diagramme d'états : une clé est déclarée valide après la définition de ses éléments et peut de nouveau être rendue invalide. Si la clé est invalide, les opérations échouent avec CRYPTO_E_KEY_NOT_VALID. L'état initial précédant CryIf_KeySetValid constitue une interprétation. Sources : [SWS_CryIf_91004], [SWS_CryIf_91005], [SWS_CryIf_91021], [SWS_CryIf_91012], SWS CSM p. 70.

Pour la génération de clés, CryIf_RandomSeed [SWS_CryIf_91007] fournit les valeurs initiales, et CryIf_KeyGenerate [SWS_CryIf_91008] génère la clé. Selon la spécification du CSM, la clé est créée dans l'élément CRYPTO_KE_KEYGENERATE_KEY. Les bases reposent sur le seed dans CRYPTO_KE_KEYGENERATE_SEED et sur l'algorithme dans CRYPTO_KE_KEYGENERATE_ALGORITHM SWS CSM p. 67. Dans la R20-11, ces deux fonctions s'exécutent de façon synchrone ou asynchrone selon la configuration [SWS_CryIf_91007] [SWS_CryIf_91008]. Ce n'est qu'à partir de la R21-11 qu'elles sont définies comme synchrones SWS CryIf p. 1. CryIf_KeyDerive est synchrone et réentrante, et dérive à partir d'une clé source une clé qui est stockée dans la clé cible [SWS_CryIf_91009] SWS CryIf p. 42.

Deux fonctions sont prévues pour l'échange de clés Diffie-Hellman. CryIf_KeyExchangeCalcPubVal [SWS_CryIf_91010] calcule la valeur publique propre. CryIf_KeyExchangeCalcSecret [SWS_CryIf_91011] calcule le secret partagé à partir de la valeur du partenaire. Le matériel de clé se trouve dans les éléments CRYPTO_KE_KEYEXCHANGE_BASE, CRYPTO_KE_KEYEXCHANGE_PRIVKEY et CRYPTO_KE_KEYEXCHANGE_OWNPUBKEY SWS CSM p. 70. Le pilote stocke le secret en tant qu'élément au sein de la même clé SWS Crypto p. 84. Interprétation : pour les API directes de gestion des clés également, le CryIf fait vraisemblablement correspondre la cryIfKeyId à l'ID de clé du pilote, tout comme dans le cheminement des jobs [SWS_CryIf_00133]. Question Q-f146ad33e972fa97 (ouverte)

Échange de clés via CryIfAnwendung / CSMCryIfCrypto Driver ObjectKommunikationspartnerUse Case: Calculer la propre valeur publiqueCryIf_KeyExchangeCalcPubVal(cryIfKeyId,publicValuePtr, publicValueLengthPtr)an konfiguriertes Crypto Driver Object weiterleitenvaleur publique, valeur de retourvaleur publique, valeur de retourUse Case: Échange en dehors de CryIfenvoyer sa propre valeur publiqueenvoyer la valeur publique du partenaireUse Case: Gemeinsames Geheimnis berechnenCryIf_KeyExchangeCalcSecret(cryIfKeyId,partnerPublicValuePtr, partnerPublicValueLength)Crypto_KeyExchangeCalcSecret(…)Secret en tant qu'élément de clédéposer dans la même cléValeur de retourValeur de retour

Diagramme de séquence : l'échange de clés se déroule en deux appels CryIf. Entre les deux, l'application échange les valeurs publiques avec le partenaire en dehors du CryIf. Sources : [SWS_CryIf_91010], [SWS_CryIf_91011], SWS CSM p. 70, SWS Crypto p. 84

Copie de clés au sein d'un même Crypto Driver et entre plusieurs Crypto Drivers

Pour les copies, il existe CryIf_KeyElementCopy [SWS_CryIf_91015], CryIf_KeyCopy [SWS_CryIf_91016] et CryIf_KeyElementCopyPartial [SWS_CryIf_91018]. Toutes trois sont synchrones et réentrantes, mais pas pour la même cryIfKeyId. En plus de E_OK et E_NOT_OK, elles peuvent notamment retourner CRYPTO_E_KEY_READ_FAIL, CRYPTO_E_KEY_WRITE_FAIL, CRYPTO_E_KEY_SIZE_MISMATCH et CRYPTO_E_KEY_EMPTY SWS CryIf p. 35.

Pour la copie partielle, la spécification distingue deux cas :

  • les clés source et cible se trouvent dans le même Crypto Driver : le CryIf appelle Crypto_<vi>_<ai>_KeyElementCopyPartial() du pilote assigné et transmet sa valeur de retour [SWS_CryIf_00139] ;
  • les clés se trouvent dans des pilotes différents : le CryIf lit l'élément au moyen de Crypto_<vi>_<ai>_KeyElementGet(), copie les données partielles vers leur destination et écrit l'élément cible via Crypto_<vi>_<ai>_KeyElementSet() [SWS_CryIf_00140].

Les fonctions de copie des pilotes sont des interfaces optionnelles. Si un élément réside directement en mémoire Flash, un appel peut durer nettement plus longtemps SWS CryIf p. 45.

copypartial start CryIf_KeyElementCopyPartial(…) fehler Fehler durch CryIf erkannt? start->fehler abbruch aucun transfert (voir comportement en cas d'erreur) fehler->abbruch Oui gleich cryIfKeyId et targetCryIfKeyId dans le même Crypto Driver ? fehler->gleich Non ende Ende abbruch->ende partial Appeler Crypto_<vi>_<ai>_KeyElementCopyPartial() , transmettre la valeur de retour gleich->partial Oui lesen Lire l'élément source avec Crypto_<vi>_<ai>_KeyElementGet() gleich->lesen Non partial->ende kopieren Teildaten an Zielposition kopieren lesen->kopieren schreiben Écrire l'élément cible avec Crypto_<vi>_<ai>_KeyElementSet() kopieren->schreiben schreiben->ende

Diagramme d'activité : le fait que le CryIf délègue directement au pilote ou procède lui-même à la copie par lecture et écriture dépend de l'appartenance des clés au même pilote ou non. Sources : [SWS_CryIf_00139], [SWS_CryIf_00140]

Comportement en cas d'erreur

Le CryIf signale les erreurs de développement à la DET. La liste des erreurs du module comprend [SWS_CryIf_00009] :

Code d'erreurValeurMotif
CRYIF_E_UNINIT0x00appel d'API avant l'initialisation
CRYIF_E_INIT_FAILED0x01échec de l'initialisation
CRYIF_E_PARAM_POINTER0x02pointeur nul comme paramètre
CRYIF_E_PARAM_HANDLE0x03paramètre hors plage
CRYIF_E_PARAM_VALUE0x04valeur de paramètre invalide
CRYIF_E_KEY_SIZE_MISMATCH0x05discordance de taille entre l'élément source et l'élément cible

La notification de CRYIF_E_UNINIT avant l'initialisation est attestée pour plusieurs fonctions : CryIf_KeyDerive SWS CryIf p. 42, CryIf_RandomSeed SWS CryIf p. 37, CryIf_CancelJob SWS CryIf p. 24, CryIf_KeyGetStatus SWS CryIf p. 29 et CryIf_CallbackNotification SWS CryIf p. 44. La même règle s'applique vraisemblablement aux autres services. D'autres vérifications sont également documentées. CryIf_CancelJob signale CRYIF_E_PARAM_HANDLE en cas de channelId non autorisée, et CryIf_KeyGetStatus en cas de cryIfKeyId non autorisée. CryIf_CallbackNotification vérifie son pointeur et signale le cas échéant CRYIF_E_PARAM_POINTER SWS CryIf p. 44. Question (ouverte)

Les erreurs d'exécution proviennent du pilote sous forme de valeurs de retour. Le CryIf les transmet, comme le stipule par exemple [SWS_CryIf_00139] pour la copie partielle. Le CSM relaie à son tour la valeur de retour de CryIf_ProcessJob SWS CSM p. 22. La plage de valeurs comprend notamment [SWS_CryIf_91020] :

  • CRYPTO_E_BUSY (0x02) : service toujours occupé
  • CRYPTO_E_ENTROPY_EXHAUSTED (0x04)
  • CRYPTO_E_KEY_READ_FAIL (0x06)
  • CRYPTO_E_KEY_WRITE_FAIL (0x07)
  • CRYPTO_E_KEY_NOT_AVAILABLE (0x08)
  • CRYPTO_E_KEY_NOT_VALID (0x09)

Si une file d'attente du CSM est pleine, le CSM rejette la requête dès le départ avec CRYPTO_E_BUSY SWS CSM p. 22.

Concernant les valeurs de retour, un examen de l'historique des versions est instructif. CRYPTO_E_QUEUE_FULL n'a été retiré de [SWS_CryIf_91003] qu'à partir de la R23-11. CRYPTO_E_KEY_EMPTY n'a été ajouté pour CryIf_RandomSeed qu'en R24-11 SWS CryIf p. 1. Pour la R20-11, ce sont donc les exigences d'API de cette version qui font foi, et non les passages documentaires datés ultérieurement.

Preuves détaillées supplémentaires

Guide généré par IA sur la base des exigences de la R20-11 et des passages documentaires associés, dont certains sont issus de versions ultérieures. La spécification AUTOSAR fait foi.

Crypto Interface (CryIf)

Abstracts cryptographic hardware and software acceleration engines.

Funktionen — Übersicht

Typen — Übersicht

Funktionen & Typen — Detailansicht

fonction CryIf_Init [SWS_CryIf_91000] 📄 PDF

void CryIf_Init (const CryIf_ConfigType* configPtr);

Initializes the CRYIF module. AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_CryptoInterface

GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 2b39ab06c8cb Provenance Questions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand

Utilisation

La fonction synchrone CryIf_Init sert à l'initialisation complète du module Crypto Interface (CryIf) conformément à l'AUTOSAR Classic Platform [SWS_CryIf_91000]. La fonction est déclarée dans le fichier d'en-tête CryIf.h et possède le Service ID 0x00 [SWS_CryIf_91000]. Comme unique paramètre d'entrée, l'interface attend configPtr, un pointeur vers une structure de configuration sélectionnée de type CryIf_ConfigType [SWS_CryIf_91000]. La fonction ne renvoie aucune valeur de retour (void) et ne possède aucun paramètre inout ou out [SWS_CryIf_91000].

Sémantique et concurrence

L'appel de CryIf_Init est exécuté de manière synchrone [SWS_CryIf_91000]. Le module achève ainsi tous les travaux d'initialisation requis avant que l'exécution ne soit rendue à l'appelant. Concernant la concurrence, la fonction est classée comme non réentrante (Non Reentrant) [SWS_CryIf_91000]. Par conséquent, la routine ne doit à aucun moment être appelée de manière parallèle ou imbriquée.

Restrictions et intégration

Interprétation : l'appel de CryIf_Init devrait typiquement s'effectuer de manière centralisée lors du démarrage du système dans le cadre de la phase d'initialisation du logiciel de base, avant que les services de l'interface cryptographique situés en aval ne puissent être appelés. Comme la charge utile ne mentionne aucune gestion d'erreur spécifique, message DET ou événement DEM, l'appelant doit s'assurer au préalable de la validité du pointeur vers la configuration. Les exigences associées ne sont pas définies dans la charge utile. Question Q-31b82ca9b144c843 (ouverte)

Cette note d'utilisation a été générée de manière automatisée et repose exclusivement sur les données de spécification relatives à SWS_CryIf_91000.

Guide de l'implémenteur à venir (complexité I1)

fonction CryIf_ProcessJob [SWS_CryIf_91003] 📄 PDF

Std_ReturnType CryIf_ProcessJob (uint32 channelId, Crypto_JobType* job);

Service CryIf_ProcessJob.

GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 7b2b73dd3704 Provenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand

La fonction CryIf_ProcessJob (ID de service 0x03), mise à disposition via l'en-tête CryIf.h, transmet les ordres de traitement cryptographique à l'objet Crypto Driver respectivement configuré [SWS_CryIf_91003]. Elle accepte comme paramètres l'identifiant du canal cryptographique (channelId) ainsi qu'un pointeur vers la configuration de l'ordre (job) [SWS_CryIf_91003]. La structure job contient alors toutes les informations pertinentes pour l'utilisateur ainsi que pour la primitive cryptographique spécifique [SWS_CryIf_91003]. Le traitement de l'ordre s'effectue de manière synchrone ou asynchrone selon la configuration ; de plus, l'interface est implémentée de manière réentrante [SWS_CryIf_91003].

En cas de prise en charge sans erreur, la fonction retourne E_OK [SWS_CryIf_91003]. Si la requête échoue, la valeur de retour signale soit E_NOT_OK, soit un état d'erreur spécifique du pilote : CRYPTO_E_BUSY (objet pilote occupé), CRYPTO_E_QUEUE_FULL (file d'attente pleine), des erreurs relatives aux états des clés telles que CRYPTO_E_KEY_NOT_VALID, CRYPTO_E_KEY_SIZE_MISMATCH, CRYPTO_E_KEY_NOT_AVAILABLE, CRYPTO_E_KEY_EMPTY, CRYPTO_E_KEY_READ_FAIL ou CRYPTO_E_KEY_WRITE_FAIL ainsi que CRYPTO_E_JOB_CANCELED en cas d'annulation d'un ordre synchrone et CRYPTO_E_ENTROPY_EXHAUSTED [SWS_CryIf_91003].

De plus, l'interface procède à des vérifications préalables des identifiants de clés :

  • Si job->jobPrimitiveInfo->primitiveInfo->service est défini sur CRYPTO_KEYSETVALID, CRYPTO_KEYSETINVALID, CRYPTO_RANDOMSEED, CRYPTO_KEYGENERATE, CRYPTO_KEYDERIVE, CRYPTO_KEYEXCHANGECALCPUBVAL ou CRYPTO_KEYEXCHANGECALCSECRET, job->cryIfKeyId doit se trouver dans la plage de valeurs valide [SWS_CryIf_00134]. Dans le cas contraire, la fonction signale l'erreur CRYPTO_E_PARAM_HANDLE au DET et s'interrompt avec E_NOT_OK [SWS_CryIf_00134].
  • Si le service CRYPTO_KEYDERIVE est demandé, l'identifiant de clé cible job->cryIfTargetKeyId doit en outre se trouver dans la plage valide ; sinon, CRYPTO_E_PARAM_HANDLE est également signalé au DET et E_NOT_OK est retourné [SWS_CryIf_00135].

Ce texte a été généré par une IA et repose sur la spécification AUTOSAR CP R20-11.

fonction CryIf_CancelJob [SWS_CryIf_91014] 📄 PDF

Std_ReturnType CryIf_CancelJob (uint32 channelId, Crypto_JobType* job);

This interface dispatches the job cancellation function to the configured crypto driver object.

GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : feb9ccdcc6c2 Provenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand

La fonction CryIf_CancelJob sert à transmettre une requête d'annulation d'un travail cryptographique à l'objet pilote de chiffrement configuré [SWS_CryIf_91014]. Elle fournit l'interface standardisée du Crypto Interface, est déclarée via l'en-tête CryIf.h et possède l'ID de service 0x0e [SWS_CryIf_91014].

Pour l'appel, l'identifiant du canal cible ainsi que la configuration du travail doivent être transmis [SWS_CryIf_91014] :

  • channelId (entrée, uint32) : contient l'identifiant du canal cryptographique respectif [SWS_CryIf_91014].
  • job (entrée/sortie, Crypto_JobType*) : pointeur vers la configuration du travail, qui comprend des structures contenant des informations pertinentes pour l'utilisateur et la primitive [SWS_CryIf_91014].

L'exécution s'effectue de manière synchrone et renvoie un état de type Std_ReturnType à l'appelant [SWS_CryIf_91014] :

  • E_OK : la requête a réussi et le travail a été retiré du pilote [SWS_CryIf_91014].
  • E_NOT_OK : la requête a échoué car le travail n'a pas pu être retiré [SWS_CryIf_91014].
  • CRYPTO_E_JOB_CANCELED : valeur de retour cryptographique spécifiée pour confirmer l'annulation du travail [SWS_CryIf_91014].

En ce qui concerne le comportement face à la concurrence, CryIf_CancelJob est spécifié comme réentrant [SWS_CryIf_91014]. Cela autorise des appels parallèles pour l'annulation d'ordres, le traitement étant délégué de manière bloquante à l'objet pilote sous-jacent [SWS_CryIf_91014].

Ce texte a été généré par une IA sur la base de la spécification AUTOSAR R20-11.

fonction CryIf_KeyElementSet [SWS_CryIf_91004] 📄 PDF

Std_ReturnType CryIf_KeyElementSet (uint32 cryIfKeyId, uint32 keyElementId, const uint8* keyPtr, uint32 keyLength);

This function shall dispatch the set key element function to the configured crypto driver object.

GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : b1d8a6a46a48 Provenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand

La fonction synchrone CryIf_KeyElementSet (Service ID 0x04) transmet la demande de définition d'un élément de clé à l'objet pilote cryptographique configuré [SWS_CryIf_91004]. La déclaration de la fonction est fournie via le fichier d'en-tête CryIf.h [SWS_CryIf_91004].

L'appel s'effectue via quatre paramètres d'entrée [SWS_CryIf_91004] :

  • cryIfKeyId : désigne l'identifiant de la clé dont l'élément de clé doit être mis à jour.
  • keyElementId : désigne l'identifiant de l'élément de clé concret à définir.
  • keyPtr : pointeur vers le tampon contenant les données de clé à reprendre en tant qu'élément.
  • keyLength : indique la longueur en octets de l'élément de clé à définir.

La fonction est spécifiée comme non réentrante (Non Reentrant) [SWS_CryIf_91004]. Les appelants doivent donc veiller à ce que les appels ne soient pas effectués de manière concurrente non coordonnée.

La valeur de retour de type Std_ReturnType signale le résultat de la transmission ou de l'exécution [SWS_CryIf_91004] :

  • E_OK : La requête a réussi.
  • E_NOT_OK : la demande a échoué.
  • CRYPTO_E_BUSY : l'objet pilote cryptographique associé est actuellement occupé.
  • CRYPTO_E_KEY_WRITE_FAIL : l'accès en écriture à l'élément de clé a été refusé.
  • CRYPTO_E_KEY_NOT_AVAILABLE : la clé demandée n'est pas disponible.
  • CRYPTO_E_KEY_SIZE_MISMATCH : la taille de l'élément de clé ne correspond pas à la longueur des données fournies.

Cette note d'utilisation a été générée par une IA sur la base de la spécification AUTOSAR R20-11.

Guide de l'implémenteur à venir (complexité I1)

fonction CryIf_KeySetValid [SWS_CryIf_91005] 📄 PDF

Std_ReturnType CryIf_KeySetValid (uint32 cryIfKeyId);

This function shall dispatch the set key valid function to the configured crypto driver object.

GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : f4147bfa82e2 Provenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand

Utilisation

L'interface synchrone CryIf_KeySetValid (Service ID 0x05) est mise à disposition via le fichier d'en-tête CryIf.h et transmet la demande de validation d'une clé à l'objet pilote cryptographique configuré respectif [SWS_CryIf_91005]. L'identifiant cryIfKeyId est transmis comme unique paramètre, déterminant la clé cible dont les éléments de clé doivent être marqués comme valides [SWS_CryIf_91005]. Il n'existe aucun paramètre d'entrée/sortie ou de sortie supplémentaire pour cette fonction [SWS_CryIf_91005].

Valeurs de retour et gestion des erreurs

La valeur de retour de type Std_ReturnType informe l'appelant du résultat de la transmission et du traitement dans le pilote [SWS_CryIf_91005] :

  • E_OK : l'opération a été transmise avec succès à l'objet pilote cryptographique et s'est achevée avec succès [SWS_CryIf_91005].
  • E_NOT_OK : la transmission ou l'exécution de la demande a échoué [SWS_CryIf_91005].
  • CRYPTO_E_BUSY : la demande n'a pas pu être exécutée car l'objet pilote cryptographique compétent est actuellement occupé [SWS_CryIf_91005].

Concurrence et restrictions

La fonction est expressément désignée comme non réentrante (Non Reentrant) dans la spécification [SWS_CryIf_91005]. Les instances appelantes doivent donc veiller à ce que les appels de CryIf_KeySetValid ne soient jamais exécutés de manière concurrente ou avec interruption, afin d'éviter de manière fiable tout conflit lors de la transmission à l'objet pilote.

Cette note d'utilisation a été générée automatiquement sur la base de la spécification.

fonction CryIf_KeySetInvalid [SWS_CryIf_91021] 📄 PDF

Std_ReturnType CryIf_KeySetInvalid (uint32 cryIfKeyId);

Sets invalid for the status of the key identifi ed by cry If Key Id.

GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : de4f767c5cce Provenance Questions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand

L'interface synchrone CryIf_KeySetInvalid (Service-ID 0x14) définit l'état de la clé identifiée par le paramètre cryIfKeyId sur non valide [SWS_CryIf_91021]. La déclaration de la fonction est fournie via le fichier d'en-tête CryIf.h [SWS_CryIf_91021].

Les paramètres ainsi que les valeurs de retour suivants s'appliquent à l'utilisation de la fonction [SWS_CryIf_91021] :

  • Paramètre transmis : l'identifiant de la clé dont la validité doit être révoquée est transmis via le paramètre d'entrée cryIfKeyId de type uint32. Il n'existe pas de paramètres d'entrée/sortie.
  • Valeur de retour (Std_ReturnType) :
    • E_OK : la demande de modification d'état a réussi.
    • E_NOT_OK : la demande a échoué.
    • CRYPTO_E_BUSY : l'exécution a échoué, car le Crypto Driver Object concerné est occupé.

Concernant la concurrence et le contexte d'exécution, CryIf_KeySetInvalid est spécifié comme non réentrant (Non Reentrant) [SWS_CryIf_91021]. Les instances appelantes doivent donc s'assurer que les appels se déroulent de manière séquentielle et ne se chevauchent pas mutuellement. Si la valeur de retour CRYPTO_E_BUSY se produit, le Crypto Driver Object est temporairement bloqué [SWS_CryIf_91021] ; l'appelant devrait dans ce cas être responsable d'une répétition ultérieure de l'invalidation d'état. Question Q-4377065d4d4eecab (ouverte)

Ce texte a été généré par une IA et se base exclusivement sur les données de spécification d'AUTOSAR R20-11.

Guide de l'implémenteur à venir (complexité I1)

fonction CryIf_KeyGetStatus [SWS_CryIf_91012] 📄 PDF

Std_ReturnType CryIf_KeyGetStatus (uint32 cryIfKeyId, Crypto_KeyStatusType* keyStatusPtr);

Returns the key state of the key identified by cry If Key Id.

GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 5bef488620f3 Provenance Questions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand

Utilisation et contexte d'appel

La fonction CryIf_KeyGetStatus sert à interroger de manière synchrone l'état d'une clé cryptographique au sein du Crypto Interface [SWS_CryIf_91012]. Elle est disponible via l'en-tête CryIf.h avec l'ID de service 0x13 [SWS_CryIf_91012]. Les paramètres suivants sont transmis lors de l'appel :

  • cryIfKeyId (entrée) : identificateur unique de la clé dont l'état doit être déterminé [SWS_CryIf_91012].
  • keyStatusPtr (sortie) : pointeur vers une variable de type Crypto_KeyStatusType dans laquelle l'état de la clé est écrit [SWS_CryIf_91012].

Gestion des erreurs et valeurs de retour

La valeur de retour de type Std_ReturnType signale le résultat de l'exécution [SWS_CryIf_91012] :

Aucun code d'erreur spécifique, message DET ou événement DEM n'est indiqué dans la spécification de l'élément ; le traitement des erreurs côté appelant repose principalement sur l'évaluation de la valeur de retour.

Concurrence et restrictions

La fonction est spécifiée comme non réentrante (Non Reentrant) [SWS_CryIf_91012]. Les appelants doivent par conséquent s'assurer qu'aucun appel simultané ou interruptif n'ait lieu pour la même instance de clé ou pour des instances différentes. De plus, l'appelant doit vraisemblablement fournir une zone mémoire valide pour le pointeur de sortie keyStatusPtr, étant donné que la fonction écrit directement dans celui-ci. Question Q-da3a034d4f2e9442 (ouverte)

Ce texte a été généré par une IA sur la base de la spécification AUTOSAR R20-11.

Guide de l'implémenteur à venir (complexité I1)

fonction CryIf_KeyElementGet [SWS_CryIf_91006] 📄 PDF

Std_ReturnType CryIf_KeyElementGet (uint32 cryIfKeyId, uint32 keyElementId, uint8* resultPtr, uint32* resultLengthPtr);

This function shall dispatch the get key ele ment function to the configured crypto driver object.

GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : ab8ed66ea380 Provenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand

La fonction synchrone CryIf_KeyElementGet transmet l'interrogation d'un élément de clé au Crypto Driver Object configuré [SWS_CryIf_91006]. Elle est déclarée via le fichier d'en-tête CryIf.h et est spécifiée comme réentrante [SWS_CryIf_91006].

Utilisation et paramètres

Lors de l'appel, cryIfKeyId identifie la clé concernée et keyElementId l'élément de clé à récupérer [SWS_CryIf_91006]. Les données utiles sont déposées dans le tampon resultPtr [SWS_CryIf_91006]. Le pointeur resultLengthPtr sert de paramètre combiné d'entrée et de sortie pour la gestion de la longueur [SWS_CryIf_91006] :

  • Avant l'exécution, l'appelant y transmet la taille de tampon disponible de resultPtr [SWS_CryIf_91006].
  • Si l'élément de clé autorise un accès partiel, la valeur définit à la place la quantité de données à récupérer, qui ne correspond pas nécessairement à la taille du tampon [SWS_CryIf_91006].
  • À la fin de l'opération, la fonction enregistre la quantité de données effectivement écrites à cet emplacement mémoire [SWS_CryIf_91006].

Gestion des erreurs et valeurs de retour

La valeur de retour de type Std_ReturnType signale le statut de succès ou d'erreur [SWS_CryIf_91006] :

Cette note d'utilisation a été générée de manière automatisée sur la base de la spécification d'AUTOSAR R20-11.

Guide de l'implémenteur à venir (complexité I1)

fonction CryIf_KeyElementCopy [SWS_CryIf_91015] 📄 PDF

Std_ReturnType CryIf_KeyElementCopy (uint32 cryIfKeyId, uint32 keyElementId, uint32 targetCryIfKeyId, uint32 targetKeyElementId);

Service CryIf_KeyElementCopy.

GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 98ca892724e4 Provenance Questions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand

La fonction synchrone CryIf_KeyElementCopy sert à copier un élément de clé d'une clé source vers une clé cible conformément à [SWS_CryIf_91015]. Le service est disponible via le fichier d'en-tête CryIf.h.

Pour l'appel, la clé source (cryIfKeyId), l'élément source à copier (keyElementId) ainsi que la clé cible (targetCryIfKeyId) et l'élément cible (targetKeyElementId) sont transmis via les paramètres d'entrée [SWS_CryIf_91015]. La fonction est conçue pour être réentrante, mais explicitement pas pour la même cryIfKeyId [SWS_CryIf_91015]. Il paraît plausible d'interpréter que, pour éviter les conflits de données, les accès concurrents en écriture sur la même clé cible (targetCryIfKeyId) devraient également être synchronisés par l'appelant. Question Q-cba3554c537dd498 (ouverte)

La valeur de retour de type Std_ReturnType signale le résultat de l'opération [SWS_CryIf_91015] :

  • E_OK : l'opération de copie a réussi.
  • E_NOT_OK : la requête a échoué.
  • CRYPTO_E_BUSY : le Crypto Driver Object associé est occupé.
  • CRYPTO_E_KEY_NOT_AVAILABLE : l'élément de clé demandé n'est pas disponible.
  • CRYPTO_E_KEY_READ_FAIL : la lecture de l'élément de clé source n'est pas autorisée.
  • CRYPTO_E_KEY_WRITE_FAIL : l'écriture de l'élément de clé cible n'est pas autorisée.
  • CRYPTO_E_KEY_SIZE_MISMATCH : les tailles des éléments de clé impliqués ne sont pas compatibles.
  • CRYPTO_E_KEY_EMPTY : l'élément de clé source n'est pas initialisé.

Cette note d'utilisation a été générée automatiquement sur la base d'AUTOSAR R20-11.

Guide de l'implémenteur à venir (complexité I1)

fonction CryIf_KeyElementCopyPartial [SWS_CryIf_91018] 📄 PDF

Std_ReturnType CryIf_KeyElementCopyPartial (uint32 cryIfKeyId, uint32 keyElementId, uint32 keyElementSourceOffset, uint32 keyElementTargetOffset, uint32 keyElementCopyLength, uint32 targetCryIfKeyId, uint32 targetKeyElementId);

Service CryIf_KeyElementCopyPartial.

GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 1703918a24fa Provenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand

La fonction synchrone CryIf_KeyElementCopyPartial fournie via l'en-tête CryIf.h copie des sous-parties d'un élément de clé dans un autre élément de clé [SWS_CryIf_91018]. Les clés source et cible ainsi que les éléments respectifs sont spécifiés via les paramètres cryIfKeyId, keyElementId, targetCryIfKeyId et targetKeyElementId [SWS_CryIf_91018]. Les positions de départ au sein des deux éléments sont définies par keyElementSourceOffset et keyElementTargetOffset, tandis que keyElementCopyLength détermine le nombre exact d'octets à transférer [SWS_CryIf_91018].

En ce qui concerne la concurrence, la routine est conçue pour être réentrante, mais expressément pas pour la même clé source (cryIfKeyId) [SWS_CryIf_91018]. Les appels parallèles avec un identifiant de clé source identique doivent donc être synchronisés ou évités par l'appelant.

La valeur de retour signale l'état d'exécution détaillé de la requête synchrone [SWS_CryIf_91018] :

  • E_OK : l'opération de copie s'est déroulée avec succès.
  • E_NOT_OK : la requête a échoué.
  • CRYPTO_E_BUSY : le Crypto Driver Object concerné est occupé.
  • CRYPTO_E_KEY_NOT_AVAILABLE : l'élément de clé source ou cible demandé n'est pas disponible.
  • CRYPTO_E_KEY_READ_FAIL : la lecture de l'élément de clé source n'est pas autorisée.
  • CRYPTO_E_KEY_WRITE_FAIL : l'écriture dans l'élément de clé cible n'est pas autorisée.
  • CRYPTO_E_KEY_SIZE_MISMATCH : les tailles des éléments ou les indications d'offset et de longueur sont incompatibles.
  • CRYPTO_E_KEY_EMPTY : l'élément de clé source n'est pas initialisé.

Cette note d'utilisation a été générée automatiquement sur la base de la spécification d'AUTOSAR R20-11.

Guide de l'implémenteur à venir (complexité I1)

fonction CryIf_KeyCopy [SWS_CryIf_91016] 📄 PDF

Std_ReturnType CryIf_KeyCopy (uint32 cryIfKeyId, uint32 targetCryIfKeyId);

This function shall co py all key elements from the source key to a target key.

GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : e2c4b04b20c3 Provenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand

Utilisation

La fonction synchrone CryIf_KeyCopy copie tous les éléments de clé d'une clé source vers une clé cible indiquée ([SWS_CryIf_91016]). Elle est mise à disposition via le fichier d'en-tête CryIf.h et possède le Service ID 0x10 ([SWS_CryIf_91016]).

La fonction attend deux paramètres d'entrée ([SWS_CryIf_91016]) :

  • cryIfKeyId : identifiant de la clé dont les éléments de clé servent de source.
  • targetCryIfKeyId : identifiant de la clé qui reçoit les éléments de clé en tant que cible.

Concurrence et restrictions

L'interface est spécifiée comme réentrante, mais ne doit pas être appelée simultanément pour le même identifiant de clé source (cryIfKeyId) ([SWS_CryIf_91016]).

Gestion des erreurs

La valeur de retour du type Std_ReturnType signale le résultat de l'opération ([SWS_CryIf_91016]) :

  • E_OK : opération de copie achevée avec succès.
  • E_NOT_OK : La demande a échoué.
  • CRYPTO_E_BUSY : échec car l'objet Crypto Driver sous-jacent est occupé.
  • CRYPTO_E_KEY_NOT_AVAILABLE : l'élément de clé demandé n'est pas disponible.
  • CRYPTO_E_KEY_READ_FAIL : la lecture de l'élément de clé n'est pas autorisée.
  • CRYPTO_E_KEY_WRITE_FAIL : l'écriture de l'élément de clé cible n'est pas autorisée.
  • CRYPTO_E_KEY_SIZE_MISMATCH : Les tailles des éléments de clé ne sont pas compatibles entre elles.
  • CRYPTO_E_KEY_EMPTY : l'élément de clé source n'est pas initialisé.

Cette note d'utilisation a été générée automatiquement sur la base de la spécification.

fonction CryIf_RandomSeed [SWS_CryIf_91007] 📄 PDF

Std_ReturnType CryIf_RandomSeed (uint32 cryIfKeyId, const uint8* seedPtr, uint32 seedLength);

This function shall dispatch the random seed function to the configured crypto driver object.

GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : cb0539e3124c Provenance Questions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand

La fonction CryIf_RandomSeed sert à transmettre la génération ou l'injection d'une graine aléatoire (Random Seed) à l'objet pilote crypto configuré [SWS_CryIf_91007]. Elle est disponible via le fichier d'en-tête CryIf.h et possède le Service-ID 0x07 [SWS_CryIf_91007].

L'interface attend trois paramètres d'entrée [SWS_CryIf_91007] :

  • cryIfKeyId : identifiant de la clé pour laquelle une nouvelle graine doit être générée.
  • seedPtr : pointeur vers la zone mémoire contenant les données pour l'injection de la graine.
  • seedLength : longueur de la graine en octets.

Le comportement d'exécution (synchrone ou asynchrone) n'est pas prédéfini de manière fixe, mais dépend de la configuration respective [SWS_CryIf_91007]. Concernant la concurrence, la fonction est spécifiée comme réentrante [SWS_CryIf_91007].

Comme valeur de retour, la fonction fournit un Std_ReturnType avec les valeurs d'état suivantes [SWS_CryIf_91007] :

  • E_OK : la requête a réussi.
  • E_NOT_OK : la requête a échoué.
  • CRYPTO_E_KEY_NOT_VALID : la demande a échoué car l'état de clé de la clé est « invalid ».

Interprétation : lors du retour de CRYPTO_E_KEY_NOT_VALID, la vérification devrait se référer à la clé cryIfKeyId transmise, bien que le texte de spécification mentionne cryptoKeyId de manière divergente [SWS_CryIf_91007]. Question Q-22b20256f21f131b (ouverte)

Ce texte a été généré par une IA et est basé sur la spécification AUTOSAR CP R20-11.

fonction CryIf_KeyGenerate [SWS_CryIf_91008] 📄 PDF

Std_ReturnType CryIf_KeyGenerate (uint32 cryIfKeyId);

This function shall dispatch the key generate function to the configured crypto driver object.

GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : d582a843edfa Provenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand

Utilisation

La fonction CryIf_KeyGenerate transmet l'appel de fonction pour la génération de clé à l'objet Crypto Driver configuré [SWS_CryIf_91008]. Le paramètre d'entrée cryIfKeyId transmet l'identifiant unique de la clé qui doit être mise à jour avec la valeur de clé nouvellement générée [SWS_CryIf_91008]. La déclaration de cette interface est mise à disposition via l'en-tête CryIf.h [SWS_CryIf_91008].

Comportement de synchronisation et concurrence

L'exécution s'effectue de manière synchrone ou asynchrone selon la configuration sous-jacente [SWS_CryIf_91008]. Concernant le contexte d'appel et la concurrence, la fonction est spécifiée comme réentrante [SWS_CryIf_91008].

Valeurs de retour et gestion des erreurs

L'appel renvoie une valeur d'état de type Std_ReturnType [SWS_CryIf_91008] :

  • E_OK : la demande de génération de clé a été exécutée avec succès [SWS_CryIf_91008].
  • E_NOT_OK : la requête a échoué [SWS_CryIf_91008].
  • CRYPTO_E_BUSY : la demande a échoué car l'objet Crypto Driver sollicité est actuellement occupé [SWS_CryIf_91008].
  • CRYPTO_E_KEY_EMPTY : la demande a échoué car un élément de clé source requis n'est pas initialisé [SWS_CryIf_91008].
  • CRYPTO_E_KEY_NOT_VALID : la demande a échoué car l'état de la clé référencée par l'identifiant de clé est invalide [SWS_CryIf_91008].

Cette note d'utilisation a été générée automatiquement sur la base de la spécification de la version AUTOSAR R20-11.

fonction CryIf_KeyDerive [SWS_CryIf_91009] 📄 PDF

Std_ReturnType CryIf_KeyDerive (uint32 cryIfKeyId, uint32 targetCryIfKeyId);

This function shall dispatch th e key derive function to the configured crypto driver object.

GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : e0c725352dab Provenance Questions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand

Utilisation

La fonction CryIf_KeyDerive sert à transmettre de manière synchrone une requête de dérivation de clé au Crypto Driver Object respectivement configuré [SWS_CryIf_91009]. L'interface est déclarée via le fichier d'en-tête CryIf.h avec l'ID de service 0x09 [SWS_CryIf_91009].

Deux identifiants de clé sont transmis lors de l'appel [SWS_CryIf_91009] :

  • cryIfKeyId : identifiant de la clé utilisée comme base pour la dérivation.
  • targetCryIfKeyId : identifiant de la clé dans laquelle la clé dérivée est enregistrée.

Gestion des erreurs et valeurs de retour

Le résultat de l'opération est transmis via le type de retour Std_ReturnType [SWS_CryIf_91009] :

Concurrence et contraintes

L'interface est spécifiée comme réentrante [SWS_CryIf_91009]. Le déroulement étant synchrone, les appelants devraient devoir prendre en compte le temps d'exécution du pilote dans le contexte d'appel respectif. Question Q-2b2fd50249878177 (ouverte)

Cette note d'utilisation a été générée automatiquement à partir de la spécification AUTOSAR R20-11.

fonction CryIf_KeyExchangeCalcPubVal [SWS_CryIf_91010] 📄 PDF

Std_ReturnType CryIf_KeyExchangeCalcPubVal (uint32 cryIfKeyId, uint8* publicValuePtr, uint32* publicValueLengthPtr);

This function shall dispatch the key exchange public value calculation function to the configured crypto driver object. Available

GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 5f03ab0336af Provenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand

La fonction synchrone et réentrante CryIf_KeyExchangeCalcPubVal transmet le calcul de la valeur publique d'échange de clés à l'objet Crypto Driver configuré [SWS_CryIf_91010]. Le service est disponible via l'en-tête CryIf.h [SWS_CryIf_91010].

Lors de l'appel de la fonction, les paramètres suivants sont traités [SWS_CryIf_91010] :

  • cryIfKeyId : identifiant de la clé à utiliser pour le protocole d'échange de clés.
  • publicValuePtr : pointeur vers la zone mémoire dans laquelle la valeur publique calculée est déposée.
  • publicValueLengthPtr : pointeur vers l'information de longueur. Lors de l'appel, ce paramètre doit contenir la taille de tampon fournie ; une fois l'opération terminée, il enregistre la longueur réelle de la valeur calculée.

La fonction renvoie un statut de type Std_ReturnType [SWS_CryIf_91010] :

  • E_OK : La requête a réussi.
  • E_NOT_OK : la demande a échoué.
  • CRYPTO_E_BUSY : erreur car l'objet Crypto Driver compétent est occupé.
  • CRYPTO_E_KEY_EMPTY : erreur due à un élément de clé source non initialisé.
  • CRYPTO_E_KEY_NOT_VALID : erreur car la clé adressée se trouve dans un état invalide.

Ce texte a été généré par un système assisté par IA et repose exclusivement sur les données de spécification issues d'AUTOSAR R20-11.

fonction CryIf_KeyExchangeCalcSecret [SWS_CryIf_91011] 📄 PDF

Std_ReturnType CryIf_KeyExchangeCalcSecret (uint32 cryIfKeyId, const uint8* partnerPublicValuePtr, uint32 partnerPublicValueLength);

This function shall dispatch the key exchange common shared secret calculation function to the configured crypto driver object.

GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : ecfeb27c89f0 Provenance Questions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand

La fonction synchrone CryIf_KeyExchangeCalcSecret transmet le calcul du secret partagé lors de l'échange de clés à l'objet Crypto Driver configuré [SWS_CryIf_91011]. L'identifiant de la clé (cryIfKeyId), un pointeur vers la valeur de clé publique du partenaire de communication (partnerPublicValuePtr) ainsi que sa longueur en octets (partnerPublicValueLength) sont transmis au service [SWS_CryIf_91011].

Gestion des erreurs : la fonction renvoie le résultat via Std_ReturnType [SWS_CryIf_91011] :

Concurrence : l'interface est spécifiée comme réentrante [SWS_CryIf_91011]. Le déroulement étant exécuté de manière synchrone, l'appel devrait typiquement avoir lieu dans le contexte de tâche. Question Q-b3bca3645b0ef468 (ouverte) Le service est mis à disposition via le fichier d'en-tête CryIf.h [SWS_CryIf_91011].

Cette note d'utilisation a été générée automatiquement sur la base de la spécification d'AUTOSAR R20-11.

fonction CryIf_CallbackNotification [SWS_CryIf_91013] 📄 PDF

void CryIf_CallbackNotification (Crypto_JobType* job, Crypto_ResultType result);

Notifies the CRYIF about the completion of the request with the result of the cryptographic operation.

GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 781636a3f50e Provenance Questions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand

La fonction CryIf_CallbackNotification sert, conformément à [SWS_CryIf_91013], à informer le Crypto Interface (CryIf) de l'achèvement d'une opération cryptographique ainsi que de son résultat. La déclaration est disponible via l'en-tête CryIf.h et possède l'ID de service 0x0d [SWS_CryIf_91013].

L'appel s'effectue de manière synchrone et traite deux paramètres d'entrée obligatoires [SWS_CryIf_91013] :

  • job (entrée, Crypto_JobType*) : pointe vers la structure d'informations de l'ordre terminé et contient un ID de callback pour l'attribution du travail achevé [SWS_CryIf_91013].
  • result (entrée, Crypto_ResultType) : transmet le résultat de l'opération cryptographique exécutée [SWS_CryIf_91013].

Aucun code d'erreur ni message d'erreur spécifique (DET/DEM) n'est défini pour ce service ; le contrôle fonctionnel des erreurs s'effectue via le paramètre result, qui reflète le succès ou l'état d'erreur de l'opération [SWS_CryIf_91013].

Concernant la concurrence, la fonction est spécifiée selon [SWS_CryIf_91013] comme non réentrante (Non Reentrant) et ne possède pas de valeur de retour (void). Les appelants doivent donc s'assurer que les appels se déroulent de manière séquentielle et qu'aucune exécution imbriquée ou parallèle ne survienne. Interprétation : la notification devrait typiquement être appelée par les pilotes cryptographiques sous-jacents pour renvoyer au Crypto Interface le résultat d'ordres cryptographiques traités de manière asynchrone. Question Q-ae17af188a970e00 (ouverte)

Cette note d'utilisation a été générée de manière automatisée sur la base de la spécification d'AUTOSAR R20-11.

Request a governed re-review of this record. The record is not changed immediately.

Record
AUTOSAR/AP/record/CP_MOD_CryIf
Status
unspecified
Version
AUTOSAR/AP/record/CP_MOD_CryIf@rel:R20-11#a060c261
Content hash
a060c261
Source
https://www.autosar.org/fileadmin/standards/R20-11/CP/AUTOSAR_SWS_CryptoInterface.pdf#nameddest=SWS_CryIf_91000

Carte des thèmes

Initialisation et état

2
CryIf_GetVersionInfoCryIf_Init

Services · KeyElement…

4
CryIf_KeyElementCopyCryIf_KeyElementCopyPartialCryIf_KeyElementGetCryIf_KeyElementSet

Services · Key…

8
CryIf_KeyCopyCryIf_KeyDeriveCryIf_KeyExchangeCalcPubValCryIf_KeyExchangeCalcSecretCryIf_KeyGenerateCryIf_KeyGetStatusCryIf_KeySetInvalidCryIf_KeySetValid

Services · Autres

4
CryIf_CallbackNotificationCryIf_CancelJobCryIf_ProcessJobCryIf_RandomSeed

Types

1
CryIf_ConfigType

Vue détaillée

Sélectionnez une entrée dans le plan.

Initialisation et état

CryIf_GetVersionInfo fonction

Returns the version information of this module.

void CryIf_GetVersionInfo (Std_VersionInfoType* versioninfo);
CryIf_Init fonction

Initializes the CRYIF module. AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_CryptoInterface

void CryIf_Init (const CryIf_ConfigType* configPtr);

Services · KeyElement…

CryIf_KeyElementCopy fonction

Service CryIf_KeyElementCopy.

Std_ReturnType CryIf_KeyElementCopy (uint32 cryIfKeyId, uint32 keyElementId, uint32 targetCryIfKeyId, uint32 targetKeyElementId);
CryIf_KeyElementCopyPartial fonction

Service CryIf_KeyElementCopyPartial.

Std_ReturnType CryIf_KeyElementCopyPartial (uint32 cryIfKeyId, uint32 keyElementId, uint32 keyElementSourceOffset, uint32 keyElementTargetOffset, uint32 keyElementCopyLength, uint32 targetCryIfKeyId, uint32 targetKeyElementId);
CryIf_KeyElementGet fonction

This function shall dispatch the get key ele ment function to the configured crypto driver object.

Std_ReturnType CryIf_KeyElementGet (uint32 cryIfKeyId, uint32 keyElementId, uint8* resultPtr, uint32* resultLengthPtr);
CryIf_KeyElementSet fonction

This function shall dispatch the set key element function to the configured crypto driver object.

Std_ReturnType CryIf_KeyElementSet (uint32 cryIfKeyId, uint32 keyElementId, const uint8* keyPtr, uint32 keyLength);

Services · Key…

CryIf_KeyCopy fonction

This function shall co py all key elements from the source key to a target key.

Std_ReturnType CryIf_KeyCopy (uint32 cryIfKeyId, uint32 targetCryIfKeyId);
CryIf_KeyDerive fonction

This function shall dispatch th e key derive function to the configured crypto driver object.

Std_ReturnType CryIf_KeyDerive (uint32 cryIfKeyId, uint32 targetCryIfKeyId);
CryIf_KeyExchangeCalcPubVal fonction

This function shall dispatch the key exchange public value calculation function to the configured crypto driver object. Available

Std_ReturnType CryIf_KeyExchangeCalcPubVal (uint32 cryIfKeyId, uint8* publicValuePtr, uint32* publicValueLengthPtr);
CryIf_KeyExchangeCalcSecret fonction

This function shall dispatch the key exchange common shared secret calculation function to the configured crypto driver object.

Std_ReturnType CryIf_KeyExchangeCalcSecret (uint32 cryIfKeyId, const uint8* partnerPublicValuePtr, uint32 partnerPublicValueLength);
CryIf_KeyGenerate fonction

This function shall dispatch the key generate function to the configured crypto driver object.

Std_ReturnType CryIf_KeyGenerate (uint32 cryIfKeyId);
CryIf_KeyGetStatus fonction

Returns the key state of the key identified by cry If Key Id.

Std_ReturnType CryIf_KeyGetStatus (uint32 cryIfKeyId, Crypto_KeyStatusType* keyStatusPtr);
CryIf_KeySetInvalid fonction

Sets invalid for the status of the key identifi ed by cry If Key Id.

Std_ReturnType CryIf_KeySetInvalid (uint32 cryIfKeyId);
CryIf_KeySetValid fonction

This function shall dispatch the set key valid function to the configured crypto driver object.

Std_ReturnType CryIf_KeySetValid (uint32 cryIfKeyId);

Services · Autres

CryIf_CallbackNotification fonction

Notifies the CRYIF about the completion of the request with the result of the cryptographic operation.

void CryIf_CallbackNotification (Crypto_JobType* job, Crypto_ResultType result);
CryIf_CancelJob fonction

This interface dispatches the job cancellation function to the configured crypto driver object.

Std_ReturnType CryIf_CancelJob (uint32 channelId, Crypto_JobType* job);
CryIf_ProcessJob fonction

Service CryIf_ProcessJob.

Std_ReturnType CryIf_ProcessJob (uint32 channelId, Crypto_JobType* job);
CryIf_RandomSeed fonction

This function shall dispatch the random seed function to the configured crypto driver object.

Std_ReturnType CryIf_RandomSeed (uint32 cryIfKeyId, const uint8* seedPtr, uint32 seedLength);

Types

CryIf_ConfigType type

Configuration data structure of Cry If module