AUTOSAR Classic Crypto Services
ClustergidsAI-GEGENEREERD
Stelt gestandaardiseerde cryptografische reken- en sleutelbeheerdiensten beschikbaar via hardware- en softwarestuurprogramma's.
Stelt gestandaardiseerde cryptografische reken- en sleutelbeheerdiensten beschikbaar via hardware- en softwarestuurprogramma's.
Het cluster bundelt de modules CSM, CryIf en Crypto Driver voor de hardware-onafhankelijke levering van cryptografische diensten en sleutelbeheerfuncties in het AUTOSAR Classic Platform EXP_UtilizationOfCryptoServices p. 8. Cryptografische jobs worden geprioriteerd via de CSM, in de CryIf gerouteerd naar logische kanalen en in de Crypto Driver synchroon of asynchroon uitgevoerd [SWS_CryIf_91003]. Sleutelpersistenties in het NVM vinden om consistentieredenen strikt pas plaats na succesvolle validatie door middel van KeySetValid SWS_CryptoDriver p. 37.
Het modulecluster “Crypto Services & Hardware Abstraction” omvat de AUTOSAR Classic-modules Crypto Service Manager (csm), Crypto Interface (cryif) en Crypto Driver (crypto) EXP_UtilizationOfCryptoServices p. 8. Het biedt een hardware-onafhankelijke abstractielaag voor cryptografische bewerkingen (o.a. versleuteling, handtekeningen, MAC-berekening en het genereren van willekeurige getallen) en voor veilig sleutelbeheer [SWS_Csm_00982], [SWS_Csm_00984], SWS_CryptoDriver p. 15.
Cryptografische verzoeken worden ingekapseld als Crypto_JobType, die prioriteiten, in- en uitvoerbuffers en bedrijfsmodi (Start, Update, Finish voor streaming of SingleCall) definieert [SWS_Csm_01013], [SWS_Csm_01039]. De CSM neemt opdrachten aan, wijst ze toe aan softwarematige wachtrijen en leidt ze via CryIf_ProcessJob() door [SWS_Csm_00017], [SWS_CryIf_91003]. De CryIf verzorgt de kanaalroutering naar de stuurprogramma's en vertaalt CSM-sleutelidentificaties naar modulespecifieke driver-sleutel-ID's [SWS_CryIf_00133].
Contextdiagram: lagenarchitectuur en interfacecascade van de AUTOSAR-cryptostack. Bronnen: SWS_CryptoDriver p. 15, SWS_CryptoServiceManager p. 29
Voor de synchronisatie van asynchrone crypto-opdrachten dient de periodieke Csm_MainFunction(), die de wachtrijen leegt en openstaande berekeningen initieert [SWS_Csm_00479]. Na afronding van een asynchrone hardwareberekening stelt de Crypto Driver de CryIf via CryIf_CallbackNotification() op de hoogte, die de melding doorgeeft aan Csm_CallbackNotification() en uiteindelijk aan de aanroepende applicatie [SWS_CryIf_91013], [SWS_Csm_00970].
Sequentiediagram: asynchroon verloop van een crypto-opdracht met wachtrijvorming en callback-cascade. Bronnen: [SWS_Csm_00970], [SWS_CryIf_91013], AUTOSAR_CP_SWS_CryptoServiceManager p. 146
Het sleutelbeheer vindt plaats via gestandaardiseerde interfaces zoals Csm_KeyElementSet() en CryIf_KeyElementCopy() onder strikte inachtneming van geconfigureerde toegangsrechten [SWS_Csm_00957], [SWS_CryIf_91015], [SWS_Crypto_00219]. Persisteren in het NVM wordt pas in gang gezet bij expliciete validatie via Crypto_KeySetValid(), waardoor onvolledige sleutelopslag wordt voorkomen [SWS_Crypto_91014], SWS_CryptoDriver p. 37. Fouten zoals overbelasting of ongeldige sleuteltoestanden worden via CRYPTO_E_BUSY resp. CRYPTO_E_KEY_NOT_VALID robuust afgevangen [SWS_Csm_00018], [SWS_CryIf_91003].
1. Systeemarchitectuur & rol van het modulecluster
Het modulecluster “Crypto Services & Hardware Abstraction” vormt het functionele fundament voor cryptografische bewerkingen, software- en hardwarematige sleutelbeheer en veilige on-board-communicatie in het AUTOSAR Classic Platform EXP_UtilizationOfCryptoServices p. 8. De architectuur is strikt volgens het AUTOSAR-lagenmodel ingedeeld in drie gestandaardiseerde BSW-modules: de Crypto Service Manager (csm) in de servicelaag, de Crypto Interface (cryif) in de ECU Abstraction Layer en minstens één Crypto Driver (crypto) in de Microcontroller Abstraction Layer (MCAL) SWS_CryptoDriver p. 15. Deze lagenstructuur abstraheert beveiligingsapplicaties (zoals SecOC, opbouw van TLS-verbindingen en UDS-diagnoseauthenticatie) volledig van bedrijfseigen crypto-coprocessors zoals Hardware Security Modules (HSM) of Secure Hardware Extensions (SHE) SWS_SecureOnboardCommunication p. 78.
De Crypto Service Manager (CSM) fungeert als primaire dienstverlener voor applicatiecomponenten (SW-C's) en hoger gelegen BSW-modules. Hij stelt gestandaardiseerde programmeerinterfaces beschikbaar voor symmetrische en asymmetrische algoritmen (bijv. AES, RSA), hashing, Message Authentication Codes (MAC), het genereren van willekeurige getallen (RNG) en AEAD-procedures [SWS_Csm_00980], [SWS_Csm_00982], [SWS_Csm_00984], [SWS_Csm_01023]. Daarnaast realiseert de CSM softwarematige jobwachtrijen en bestuurt hij de prioritisering van parallelle crypto-opdrachten [SWS_Csm_00022], SWS_CryptoServiceManager p. 29.
De Crypto Interface (CryIf) biedt als abstractielaag een uniforme 1:n-interface tussen de CSM en een willekeurig aantal crypto-drivers. Zijn centrale taak is dispatching: hij stuurt opdrachten op basis van geconfigureerde logische kanalen (channelId) door naar de corresponderende Crypto Driver-instantie en transformeert logische sleutelreferenties (cryIfKeyId) in driverspecifieke identificatoren (cryptoKeyId) [SWS_CryIf_00133], [SWS_CryIf_91003]. De Crypto Driver omhult de fysieke uitvoeringseenheid (Crypto Driver Object) en bedient ofwel zuivere software-cryptoprimitieven of speciale hardware-beveiligingsmodules [SWS_Crypto_00224], SWS_CryptoDriver p. 15.
Contextdiagram: lagenarchitectuur en interfacecascade van de AUTOSAR-cryptostack. Bronnen: SWS_CryptoDriver p. 15, SWS_CryptoServiceManager p. 29
2. Samenspel & interactiepaden tussen de modules
De opdrachtverwerking binnen het cluster vindt primair plaats via het job-gebaseerde model met behulp van de structuur Crypto_JobType [SWS_Csm_01013], AUTOSAR_CP_SWS_CryptoServiceManager p. 21. Een crypto-job bundelt het job-ID, prioriteitsinformatie, sleutelreferenties, primitieve metadata en de structuur Crypto_JobPrimitiveInputOutputType voor het pointerbeheer van invoer-, uitvoer- en lengteparameters [SWS_Csm_01012]. Via het bitmaskerveld Crypto_OperationModeType (met de vlaggen START, UPDATE, FINISH) wordt bestuurd of een opdracht als samenhangende enkelvoudige aanroep (SINGLECALL) dan wel incrementeel in streamingmodus wordt berekend [SWS_Csm_01039], [SWS_Csm_01029].
Als een CSM-dienstfunctie synchroon wordt aangeroepen, controleert de CSM de jobstatus. Is de driver vrij of de opdracht als synchroon geconfigureerd, dan roept de CSM direct CryIf_ProcessJob() aan [SWS_Csm_00017], [SWS_CryIf_91003]. De CryIf mapt de sleutel-ID's en dispatcht de job naar de toegewezen driverinstantie via Crypto_ProcessJob() [SWS_CryIf_00133]. Bij asynchrone verzoeken wordt de job bij een bezet driverobject in de CSM-wachtrij geplaatst [SWS_Csm_00018], AUTOSAR_CP_SWS_CryptoServiceManager p. 30. Na voltooiing van de asynchrone driverberekening triggert de driver CryIf_CallbackNotification() [SWS_CryIf_91013], leidt de CryIf de melding door naar Csm_CallbackNotification() [SWS_Csm_00970], en stelt de CSM ten slotte de aanvragende applicatie via haar geconfigureerde callback op de hoogte [SWS_Csm_01044], [SWS_Csm_00928].
Sequentiediagram: asynchroon verloop van een crypto-opdracht met wachtrijvorming en callback-cascade. Bronnen: [SWS_Csm_00970], [SWS_CryIf_91013], AUTOSAR_CP_SWS_CryptoServiceManager p. 146
Naast de primaire crypto-uitvoering vormt het sleutelbeheer een integraal interactiepad van het cluster SWS_CryptoDriver p. 24. Een sleutel bestaat uit meerdere logische sleutelelementen (zoals sleutelmateriaal, initialisatievectoren of iteratiewaarden) [SWS_Csm_00954], [SWS_Csm_01022]. Bewerkingen zoals het instellen van sleutelmateriaal via Csm_KeyElementSet(), het kopiëren door middel van Csm_KeyElementCopy() of de sleutelafleiding via Csm_KeyDerive() worden synchroon via de CryIf (CryIf_KeyElementCopy(), CryIf_KeyDerive()) doorgestuurd naar de driverfuncties [SWS_Csm_00957], [SWS_Csm_00969], [SWS_CryIf_91015], [SWS_CryIf_91009]. De toegang tot sleutelelementen wordt daarbij strikt bewaakt op basis van geconfigureerde toegangsrechten (CRYPTO_RA_ALLOWED, CRYPTO_RA_ENCRYPTED, CRYPTO_RA_INTERNAL_COPY) [SWS_Crypto_00219].
3. Synchronisatie, re-entrantie en taakcontexten
Cryptografische bewerkingen variëren drastisch in uitvoeringsduur. Terwijl snelle blokcijfers of hashberekeningen synchroon in de taskcontext van de aanroeper kunnen worden uitgevoerd, vereisen asymmetrische berekeningen (bijv. het genereren van RSA-handtekeningen) of tijdrovende hardwareprocessen een asynchrone verwerking [SWS_Csm_00984], [SWS_Csm_00992]. Voor de ontkoppeling biedt de CSM de cyclisch aangeroepen hoofdfunctie Csm_MainFunction() [SWS_Csm_00479]. Deze bewaakt wachtrijen, dispatcht klaarstaande jobs naar de CryIf en stuurt interne toestandsmachines van asynchrone primitieven aan [SWS_Csm_00019].
In moderne multicore- en multisectorarchitecturen ondersteunt de CSM meerdere instanties Csm_MainFunction_<shortName>(), die aan speciale OS-partities worden toegewezen [SWS_Csm_00479], AUTOSAR_SWS_CryptoServiceManager p. 170. Bij asynchrone driveruitvoering worden de berekeningen ofwel beëindigd door polling in de driver-MainFunction, ofwel door Interrupt Service Routines (ISR) van hardwaregebaseerde crypto-engines [SWS_Crypto_00027], [SWS_Crypto_00028]. Eén enkel Crypto Driver Object kan per definitie telkens precies één crypto-job tegelijkertijd verwerken; een driver met n objecten verwerkt n opdrachten werkelijk parallel [SWS_Crypto_00014], [SWS_Crypto_00117].
Wat betreft re-entrantie zijn service-interfaces zoals Csm_MacGenerate() of CryIf_ProcessJob() ontworpen als re-entrant voor verschillende jobs, maar zij verbieden het gelijktijdig meervoudig toewijzen van dezelfde jobinstantie [SWS_Csm_00016], [SWS_CryIf_91003]. Sleutelbeheerfuncties zoals Csm_KeyElementCopy(), CryIf_KeyElementCopy() of Crypto_KeyCopy() zijn als re-entrant geïmplementeerd, maar mogen niet gelijktijdig op dezelfde bronsleutelidentificatie (keyId resp. cryptoKeyId) worden toegepast, om data-inconsistenties en race conditions te voorkomen [SWS_Csm_00969], [SWS_CryIf_91015], [SWS_Crypto_00155]. Hardwaredrivers kunnen voor de modificatie van interne werkgebieden en sleutelregisters interne exclusieve gebieden (Exclusive Areas) gebruiken om race conditions tussen ISR- en taskniveau af te vangen SWS_CryptoDriver p. 27. Vraag Q-b1e9578255723a0e (open)
Activiteitendiagram: beslissingslogica en queuing-ontkoppeling bij acceptatie van opdrachten in de CSM. Bronnen: AUTOSAR_CP_SWS_CryptoServiceManager p. 30, [SWS_Csm_00017], [SWS_Csm_00018]
4. Typische levenscycli en bedrijfsmodi
De initialisatie van het crypto-cluster vindt plaats tijdens het opstarten van de BSW in hiërarchische volgorde. Eerst initialiseert de EcuM of BswM de driverlaag via Crypto_Init() onder overdracht van de configuratie Crypto_ConfigType [SWS_Crypto_91016], gevolgd door de interfacelaag via CryIf_Init() met CryIf_ConfigType [SWS_CryIf_91118]. Ten slotte wordt de CSM gestart via Csm_Init(), waarbij de configuratiepointer daarvan volgens de specificatie altijd op NULL_PTR moet worden ingesteld [SWS_Csm_00646]. Pas na volledige initialisatie van alle lagen mogen cryptografische opdrachten of sleuteltoegang worden geaccepteerd [SWS_CryIf_00076], [SWS_Crypto_00196].
Een centraal aspect van de levenscyclus van sleutels is de validatie en persistente opslag in niet-vluchtig geheugen (NVM). Na het laden van nieuwe sleutelwaarden via Csm_KeyElementSet() blijft de sleutel in de status „onvolledig resp. onbekend” [SWS_Csm_00957]. Pas de expliciete aanroep van Csm_JobKeySetValid() resp. Crypto_KeySetValid() controleert de consistentie en zet de sleutelstatus om naar geldig [SWS_Csm_91027], [SWS_Crypto_91014]. Bij gepersisteerde sleutels activeert uitsluitend deze validatie de opslag in het NVM [SWS_Crypto_91026], SWS_CryptoDriver p. 37. Dit voorkomt meervoudige gefragmenteerde NVM-schrijfcycli en beschermt tegen onvolledige sleutelsets SWS_CryptoDriver p. 37. Voor synchronisatie met de NVRAM Manager maakt de Crypto Driver gebruik van de callbacks Crypto_<vi>_<ai>_NvBlock_ReadFrom_<NvBlock>() en Crypto_<vi>_<ai>_NvBlock_WriteTo_<NvBlock>() alsook NvM_WriteBlock() [SWS_Crypto_91024], [SWS_Crypto_91025], [SWS_Crypto_91017].
Lopende streamingopdrachten kunnen desgewenst via Csm_SaveContextJob() worden onderbroken, in een applicatie-eigen buffer worden opgeslagen en later via contextherstel worden hervat [SWS_Csm_91063], [SWS_Csm_01029]. Voorafgaand aan het uitschakelen van de ECU of een overgang naar low-powermodi kunnen asynchrone opdrachten gecontroleerd via Csm_CancelJob() worden afgebroken, waardoor de CryIf via CryIf_CancelJob() de jobs verwijdert uit driverwachtrijen en hardwarekanalen [SWS_Csm_00968], [SWS_CryIf_91014].
5. Foutafhandeling, DET-tracing en degradatie
Het cluster implementeert een meertraps strategie voor foutdetectie en -afweer. Ontwikkelfouten worden bij geactiveerde tracing rechtstreeks gemeld aan de Default Error Tracer (DET)-module [SWS_Csm_91101], [SWS_Crypto_91017]. Typische DET-gebeurtenissen zijn onder meer module-aanroepen vóór voltooide initialisatie (CRYIF_E_UNINIT, CRYPTO_E_UNINIT), ongeldige handle- of sleutelparameters (CRYIF_E_PARAM_HANDLE, CRYPTO_E_PARAM_HANDLE) en het doorgeven van null-pointers [SWS_CryIf_00076], [SWS_CryIf_00134], [SWS_Crypto_00196], [SWS_Crypto_00217].
Runtime-overbelastingen en knelpunten in resources worden deterministisch afgevangen via gedefinieerde retourwaarden. Als de CSM-wachtrij voor een asynchrone job vol is, wijst de CSM de opdracht af met de statuscode CRYPTO_E_BUSY en genereert hij de runtimefout CSM_E_QUEUE_FULL [SWS_Csm_00018], [SWS_Csm_01089]. Is een ter beschikking gestelde resultaatbuffer ontoereikend gedimensioneerd, dan breekt de driver de bewerking af met CRYPTO_E_SMALL_BUFFER [SWS_Crypto_00195]. Als een cryptografische dienst verwijst naar een niet-geïnitialiseerde of expliciet geïnvalideerde sleutel (bijvoorbeeld na aanroep van Csm_JobKeySetInvalid() of Crypto_KeySetInvalid()), falen serviceverzoeken gecontroleerd met CRYPTO_E_KEY_NOT_VALID of CRYPTO_E_KEY_EMPTY [SWS_Csm_91002], [SWS_CryIf_91003], [SWS_Crypto_91020].
Degradatie- en fallback-mechanismen worden op systeemniveau mogelijk gemaakt: applicaties kunnen via Csm_KeyGetStatus() de integriteitsstatus van sleutels controleren voordat een opdracht wordt verzonden [SWS_Csm_91047], [SWS_CryIf_91012]. Mocht een hardware-cryptoversneller permanent bezet zijn of uitvallen, dan maakt de CryIf-kanaalconfiguratie een softwarematige uitwijkroute mogelijk, mits een redundante software-driver is geïntegreerd SWS_CryptoDriver p. 15.
Deze gids is uitsluitend gebaseerd op de AUTOSAR Classic-specificatie R20-11 en werd gegenereerd door de autodocs-curatie-assistent.
Die Crypto Services bieten hardware- und softwaregestützte Kryptographie-Primitive (CSM, CryIf, Crypto-Treiber) für symmetrische/asymmetrische Verschlüsselung, Signaturen und Hashing.
Module im Cluster
Crypto Abstraction Library (Cal)
AUTOSAR Classic Crypto Services-Modul Crypto Abstraction Library (Cal, Spezifikation: AUTOSAR_SWS_CryptoAbstractionLibrary.pdf).
Crypto Interface (CryIf)
Abstracts cryptographic hardware and software acceleration engines.
Crypto Driver (Crypto)
Low-level driver executing cryptographic primitives on hardware security modules (HSM) or software libraries.
Crypto Service Manager (CSM)
Provides standardized cryptographic services (encryption, hashing, digital signatures, key management) to applications and BSW.
Themakaart
CryIf
19Crypto
20CSM
82Geen elementgegevens voor deze release
CryIf
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);This interface dispatches the job cancellation function to the configured crypto driver object.
Std_ReturnType CryIf_CancelJob (uint32 channelId, Crypto_JobType* job);Returns the version information of this module.
void CryIf_GetVersionInfo (Std_VersionInfoType* versioninfo);Initializes the CRYIF module. AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_CryptoInterface
void CryIf_Init (const CryIf_ConfigType* configPtr);This function shall co py all key elements from the source key to a target key.
Std_ReturnType CryIf_KeyCopy (uint32 cryIfKeyId, uint32 targetCryIfKeyId);This function shall dispatch th e key derive function to the configured crypto driver object.
Std_ReturnType CryIf_KeyDerive (uint32 cryIfKeyId, uint32 targetCryIfKeyId);Service CryIf_KeyElementCopy.
Std_ReturnType CryIf_KeyElementCopy (uint32 cryIfKeyId, uint32 keyElementId, uint32 targetCryIfKeyId, uint32 targetKeyElementId);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);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);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);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);This function shall dispatch the key generate function to the configured crypto driver object.
Std_ReturnType CryIf_KeyGenerate (uint32 cryIfKeyId);Returns the key state of the key identified by cry If Key Id.
Std_ReturnType CryIf_KeyGetStatus (uint32 cryIfKeyId, Crypto_KeyStatusType* keyStatusPtr);Sets invalid for the status of the key identifi ed by cry If Key Id.
Std_ReturnType CryIf_KeySetInvalid (uint32 cryIfKeyId);This function shall dispatch the set key valid function to the configured crypto driver object.
Std_ReturnType CryIf_KeySetValid (uint32 cryIfKeyId);Service CryIf_ProcessJob.
Std_ReturnType CryIf_ProcessJob (uint32 channelId, Crypto_JobType* job);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);Configuration data structure of Cry If module
Crypto
This interface removes the provided job from the queue and cancels the processing of the job if possible.
Std_ReturnType Crypto_CancelJob (uint32 objectId, Crypto_JobType* job);Returns the version information of this module.
void Crypto_GetVersionInfo (Std_VersionInfoType* versioninfo);Initializes the Crypto Driver.
void Crypto_Init (const Crypto_ConfigType* configPtr);Copies a key with all its elements to another key in the same crypto driver. Note: If the actual key element is directly mapped to flash memory, there could be a bigger delay when calling this function (synchronous operation)
Std_ReturnType Crypto_KeyCopy (uint32 cryptoKeyId, uint32 targetCryptoKeyId);Derives a new key by using the key elements in the given key identified by the crypto Key Id. The given key contains the key elements for the password, salt. The derived key is stored in the key element with the id 1 of the key identified by target Crypto Key Id. The number of iterations is given in the key element CRYPTO_ KE_ KEYDERIVATION_ ITERATIONS.
Std_ReturnType Crypto_KeyDerive (uint32 cryptoKeyId, uint32 targetCryptoKeyId);Service Crypto_KeyElementCopy.
Std_ReturnType Crypto_KeyElementCopy (uint32 cryptoKeyId, uint32 keyElementId, uint32 targetCryptoKeyId, uint32 targetKeyElementId);This interface shall be used to get a key element of the key identified by the crypto
Std_ReturnType Crypto_KeyElementGet (uint32 cryptoKeyId, uint32 keyElementId, uint8* resultPtr, uint32* resultLengthPtr);Used to retrieve information which key elements are available in a given key.
Std_ReturnType Crypto_KeyElementIdsGet (uint32 cryptoKeyId, uint32* keyElementIdsPtr, uint32* keyElementIdsLengthPtr);Sets the given key element bytes to the key identified by crypto Key Id.
Std_ReturnType Crypto_KeyElementSet (uint32 cryptoKeyId, uint32 keyElementId, const uint8* keyPtr, uint32 keyLength);Calculates the public value for the key exchange a nd stores the public key in the memory location pointed by the public value pointer.
Std_ReturnType Crypto_KeyExchangeCalcPubVal (uint32 cryptoKeyId, uint8* publicValuePtr, uint32* publicValueLengthPtr);Calculates the shared secret key for the key exchange with the key material of the key identified by the crypto Key Id and the partner public key. The shared secret key is stored as a key element in the same key.
Std_ReturnType Crypto_KeyExchangeCalcSecret (uint32 cryptoKeyId, const uint8* partnerPublicValuePtr, uint32 partnerPublicValueLength);Generates new key material store it in the key identified by crypto Key Id.
Std_ReturnType Crypto_KeyGenerate (uint32 cryptoKeyId);Returns the key state of the key identified by crypto Key Id.
Std_ReturnType Crypto_KeyGetStatus (uint32 cryptoKeyId, Crypto_KeyStatusType* keyStatusPtr);Sets invalid for the status of the key identifi ed by crypto Key Id.
Std_ReturnType Crypto_KeySetInvalid (uint32 cryptoKeyId);Sets the key state of the key identified by crypto Key Id to valid.
Std_ReturnType Crypto_KeySetValid (uint32 cryptoKeyId);If asynchronous job processing is configured and there are job queues, the function is called cyclically to process queued jobs. AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_CryptoDriver
void Crypto_MainFunction (void);Service Crypto_ProcessJob.
Std_ReturnType Crypto_ProcessJob (uint32 objectId, Crypto_JobType* job);This function generates the internal seed state using the pro vided entropy source. Furthermore, this function can be used to update the seed state with new entropy
Std_ReturnType Crypto_RandomSeed (uint32 cryptoKeyId, const uint8* seedPtr, uint32 seedLength);Configuration data structure of Cry If module
CSM
CSM notifies the application that a job has finished. The function name is configurable. The function name itself is derived from "{CSM Job/ CSM Job Primitive Callback Ref}/CSM Callback Func".
void <Csm_ApplicationCallbackNotification> (uint32 jobId, Crypto_ResultType result);Service Csm_AEADDecryptManager.
Std_ReturnType Csm_AEADDecrypt (uint32 jobId, Crypto_OperationModeType mode, const uint8* ciphertextPtr, uint32 ciphertextLength, const uint8* associatedDataPtr, uint32 associatedDataLength, const uint8* tagPtr, uint32 tagLength, uint8* plaintextPtr, uint32* plaintextLengthPtr, Crypto_VerifyResultType* verifyPtr);Service Csm_AEADEncrypt.
Notifies the CSM that a job has finished. This function is used by the underlying layer (CRYIF).
void Csm_CallbackNotification (Crypto_JobType* job, Crypto_ResultType result);Cancels the job processing from asynchronous or streaming jobs .
Std_ReturnType Csm_CancelJob (uint32 job, Crypto_OperationModeType mode);Service Csm_Decrypt.
Std_ReturnType Csm_Decrypt (uint32 jobId, Crypto_OperationModeType mode, const uint8* dataPtr, uint32 DataLength, uint8* resultPtr, uint32* resultLengthPtr);Service Csm_Encrypt.
Std_ReturnType Csm_Encrypt (uint32 jobId, Crypto_OperationModeType mode, const uint8* dataPtr, uint32 DataLength, uint8* resultPtr, uint32* resultLengthPtr);Returns the version information of this module.
void Csm_GetVersionInfo (Std_VersionInfoType* versioninfo);Uses the given data to perform the hash calculation and stores the hash.
Std_ReturnType Csm_Hash (uint32 jobId, Crypto_OperationModeType mode, const uint8* dataPtr, uint32 DataLength, uint8* resultPtr, uint32* resultLengthPtr);Initializes the CSM module. In configurations, in which CSM is assigned to more than one partition (i.e. Csm_ Main Functions are mapped to partitions), CSM may provide one init function per partition.
void Csm_Init (const Csm_ConfigType* configPtr);Derives a new key by using the key elements in the given key identified by the key Id. The given key contains the key elements for the password and salt. The derived key is stored in the key element with the id 1 of the key identified by target Crypto
Std_ReturnType Csm_JobKeyDerive (uint32 jobId, uint32 keyId, uint32 targetKeyId);Calculates the public value of the current user for the key exchange and stores the
Std_ReturnType Csm_JobKeyExchangeCalcPubVal (uint32 jobId, uint32 keyId, uint8* publicValuePtr, uint32* publicValueLengthPtr);Calculates the shared secret key for the key exchange with the key material of the key identified by the key Id and the partner public key. The shared secret key is stored as a key element in the same key.
Std_ReturnType Csm_JobKeyExchangeCalcSecret (uint32 jobId, uint32 keyId, const uint8* partnerPublicValuePtr, uint32 partnerPublicValueLength);Generates new key material and stores it in the key identified by key Id.
Std_ReturnType Csm_JobKeyGenerate (uint32 jobId, uint32 keyId);Sets the key status to invalid. The key cannot be used any longer for cryptographic operations until it has been set to valid state again.
Std_ReturnType Csm_JobKeySetInvalid (uint32 jobId, uint32 keyId);Stores the key if necessary and sets the key state of the key identified by key Id to valid.
Std_ReturnType Csm_JobKeySetValid (uint32 jobId, uint32 keyId);Provides a new seed for the specified key that is used for an associated random number generator.
Std_ReturnType Csm_JobRandomSeed (uint32 jobId, uint32 keyId, const uint8* seedPtr, Manager uint32 seedLength);This function shall copy all key elements from the source key to a target key. Ava ilable via Csm.h
Std_ReturnType Csm_KeyCopy (const uint32 keyId, const uint32 targetKeyId);Derives a new key by using the key elements in the given key identified by the key Id. The given key contains the key elements for the password and salt. The derived key is stored in the k ey element with the id 1 of the key identified by target Crypto Key Id.
Std_ReturnType Csm_KeyDerive (uint32 keyId, uint32 targetKeyId);Service Csm_KeyElementCopyManager.
Std_ReturnType Csm_KeyElementCopy (const uint32 keyId, const uint32 keyElementId, const uint32 targetKeyId, const uint32 targetKeyElementId);Service Csm_KeyElementGet.
Std_ReturnType Csm_KeyElementGet (uint32 keyId, uint32 keyElementId, uint8* keyElementPtr, Manager uint32* keyElementLengthPtr);Sets the given key element bytes to the key identified by key Id.
Std_ReturnType Csm_KeyElementSet (uint32 keyId, uint32 keyElementId, const uint8* keyElementPtr, uint32 keyElementLength);Calculates the public value of the current user for the key exchange and stores the pub lic key in the memory location pointed by the public value pointer.
Std_ReturnType Csm_KeyExchangeCalcPubVal (uint32 keyId, uint8* publicValuePtr, uint32* publicValueLengthPtr);Calculates the shared secret key for the key exchange with the key material of the key identified by the key Id and the partner public key. The shared secret key is stored as a key element in the same key.
Std_ReturnType Csm_KeyExchangeCalcSecret (uint32 keyId, const uint8* partnerPublicValuePtr, uint32 partnerPublicValueLength);Generates new key material and store it in the key identified by key Id.
Std_ReturnType Csm_KeyGenerate (uint32 keyId);Returns the key state of the key identified by key Id.
Std_ReturnType Csm_KeyGetStatus (uint32 keyId, Crypto_KeyStatusType* keyStatusPtr);Sets the key status to invalid. The key cannot be used any longer for cryptographic operations until it has been set to valid state again.
Std_ReturnType Csm_KeySetInvalid (uint32 keyId);Sets the key state of the key identified by key Id to valid.
Std_ReturnType Csm_KeySetValid (uint32 keyId);Service Csm_MacGenerate.
Std_ReturnType Csm_MacGenerate (uint32 jobId, Crypto_OperationModeType mode, const uint8* dataPtr, uint32 DataLength, uint8* macPtr, uint32* macLengthPtr);Service Csm_MacVerify.
Std_ReturnType Csm_MacVerify (uint32 jobId, Crypto_OperationModeType mode, const uint8* dataPtr, uint32 DataLength, const uint8* macPtr, const uint32 macLength, Crypto_VerifyResultType* verifyPtr);API to be called cyclically to process the requested jobs. The Csm_ Main Function shall check the queues for jobs to pass to the underlying CRYIF. Per configured CSM Main Function ins tance one Csm_ Main Function_ shall be implemented. Hereby is the short name of the CSM Main Function configuration container in the ECU configuration.
void Csm_MainFunction (void);Generate a random number and stores it in the memory location pointed by th e result pointer.
Std_ReturnType Csm_RandomGenerate (uint32 jobId, uint8* resultPtr, uint32* resultLengthPtr);Feeds the key element CRYPTO_ KE_ RANDOM_ SEED with a random seed. Manager AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_CryptoServiceManager
Std_ReturnType Csm_RandomSeed (uint32 keyId, const uint8* seedPtr, uint32 seedLength);The Crypto Driver extracts the context data from the context Buffer and restores the internal state so that further crypto operation of this crypto service will continue at the exact point when the context was taken.
Std_ReturnType Csm_RestoreContextJob (uint32 jobId, uint8* contextBufferPtr, uint32 contextBufferLength);The Crypto Driver stores the internal context of the respective crypto operation to the context Buffer.
Std_ReturnType Csm_SaveContextJob (uint32 jobId, uint8* contextBufferPtr, uint32* contextBufferLengthPtr);Service Csm_SignatureGenerate.
Std_ReturnType Csm_SignatureGenerate (uint32 jobId, Crypto_OperationModeType mode, const uint8* dataPtr, uint32 DataLength, uint8* signaturePtr, uint32* signatureLengthPtr);Service Csm_SignatureVerify.
Std_ReturnType Csm_SignatureVerify (uint32 jobId, Crypto_OperationModeType mode, const uint8* dataPtr, uint32 DataLength, const uint8* signaturePtr, uint32 signatureLength, Crypto_VerifyResultType* verifyPtr);Type Crypto_AlgorithmFamilyType.
Structure which determines the exact algorithm. Note, not every algorithm needs to specify all fields. AUTOSAR shall only allow valid combinations.
Type Crypto_AlgorithmModeType.
Defines which of the input/ output parameters are re - directed to a key element. The values can be combined to define a bit field.
Structure which contains further information, which depends on the job and the crypto primitive.
Type Crypto_JobPrimitiveInputOutputType.
Type Crypto_JobRedirectionInfoType.
Enumeration of the current job state.
Structure which contains further information, which depends on the job and the crypto primitive.
Enumeration for key status.
Enume ration which operation shall be performed. This enumeration is constructed from a bit mask, where the first bit indicates "Start", the second "Update" and the third "Finish".
Structure which contains basic information about the crypto primitive. Manager AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_CryptoServiceManager
Enumeration of the processing type.
Return for Std_ Return Type for Cryptostack.
Enumeration of the kind of the service.
Enumeration of the result type of verification operations.
Array long enough to store the data of the header.
Array long enough to store the ciphertext to be decrypted with AEAD.
Array long enough to store the data of the plaintext.
Array long enough to store the data of the Tag.
Array long enough to store the data of the header.
Array long enough to store the data of the cipher.
Array long enough to store the plaintext to be encrypted with AEAD.
Array long enough to store the data of the Tag.
Identification of a CSM service configuration via a numeric identifier, that is unique within a service. The name of a CSM service configuration, i.e. the name of the container Csm_Config, shall serve as a symbolic name for this parameter Avail able via Csm.h
Configuration data structure of CSM module
Array long enough to store the data to be decrypted.
Array long enough to store the data of the decrypted plaintext.
Array long enough to store the data to be encrypted.
Array long enough to store the data of the cipher.
Array long enough to store the data which shall be hashed.
Array long enough to store the data of the hash.
Array long enough to store any key element of the considered key
Implementation Data Type of category DATA_ REFERENCE with the pointer target uint32 to be able to return asynchronously the length.
Array long enough to store the data from which a MAC shall be generated.
Array long enough to store the data of the MAC.
Array long enough to store a MAC to be verified.
Array long enough to store the data for whichs MAC shall be verified.
Array long enough to store the data of the random number.
Array long enough to store the data from which the signature shall be generated.
Array long enough to store the signature and its length.
Array long enough to store a signature to be verified.
Array long enough to store the data for whichs signature shall be verified.
Implementation Data Type of category DATA_ REFERENCE with the pointer target Csm_ Verify Result Type to be able to return asynchronously the verify result.
gemini-3.8-flash-low· 2026-10-13 · Duits origineel