Crypto Service Manager (CSM)

De synchrone functie Csm_Init dient voor de initialisatie van de module Crypto Service Manager (CSM) conform [SWS_Csm_00646]. De interface is gedeclareerd via de header Csm.h [SWS_Csm_00646].

Met betrekking tot de parameters en het aanroepgedrag legt [SWS_Csm_00646] de volgende eigenschappen vast:

• Parameters: als invoerparameter wordt configPtr doorgegeven. Dit is een pointer naar een geselecteerde configuratiestructuur van het type const Csm_ConfigType* [SWS_Csm_00646]. In-/uitvoerparameters of uitvoerparameters zijn niet aanwezig [SWS_Csm_00646].
• Retourwaarde: de functie levert geen retourwaarde (void) [SWS_Csm_00646].
• Synchroniciteit en identificatie: de uitvoering verloopt synchroon; het service-ID luidt 0x00 [SWS_Csm_00646].

Voor gelijktijdigheid en werking over meerdere partities gelden volgens [SWS_Csm_00646] specifieke voorschriften:

• Reentrantie: de functie is niet-reentrant (Non Reentrant) en mag daarom niet gelijktijdig worden aangeroepen [SWS_Csm_00646].
• Partitionering: wanneer de CSM-module aan meer dan één partitie is toegewezen (dat wil zeggen wanneer hoofdfuncties zoals Csm_MainFunction over partities zijn verdeeld), mag de CSM per partitie een eigen initialisatiefunctie beschikbaar stellen [SWS_Csm_00646].

Interpretatie: aangezien de specificatie Csm_Init als initialisatiefunctie definieert, zal de aanroep typisch tijdens de systeemstartfase plaatsvinden, voorafgaand aan de uitvoering van reguliere cryptografische opdrachten. Vraag Q-f462c3f9f4ed24fc (open)

Gebruik

De functie Csm_Hash berekent een cryptografische hashwaarde over de doorgegeven invoergegevens en slaat het resultaat op in het doelgeheugen [SWS_Csm_00980]. De interface wordt gedeclareerd via de header Csm.h en heeft het service-ID 0x5d [SWS_Csm_00980]. Het uitvoeringsgedrag is hetzij synchroon hetzij asynchroon, wat afhangt van de respectievelijke configuratie van de via jobId gespecificeerde job [SWS_Csm_00980].

De parameters zijn als volgt onderverdeeld [SWS_Csm_00980]:

• jobId: unieke identificatie van de CSM-job die gebruikmaakt van de cryptografische service.
• mode: geeft aan welke operationele modus respectievelijk welke operationele modi moeten worden uitgevoerd.
• dataPtr en dataLength: pointer naar de te hashen invoergegevens evenals het aantal te verwerken bytes.
• resultPtr: pointer naar de buffer waarin de berekende hashwaarde wordt opgeslagen.
• resultLengthPtr: voorafgaand aan de aanroep moet deze pointer de ter beschikking gestelde capaciteit van de buffer resultPtr in bytes bevatten. Na voltooiing van de verwerking wordt deze waarde overschreven door de werkelijke bytelengte van de gegenereerde hashwaarde. Indien de ter beschikking gestelde buffer kleiner is dan de totale lengte van het resultaat, wordt de hashwaarde ingekort opgeslagen.

Foutafhandeling en gelijktijdigheid

De retourwaarde van het type Std_ReturnType signaleert met E_OK een succesvol verzoek en met E_NOT_OK een fout bij de opdrachtafhandeling [SWS_Csm_00980]. Wat betreft gelijktijdigheid is Csm_Hash gespecificeerd als reentrant [SWS_Csm_00980].

De reentrante functie Csm_MacGenerate (service-ID 0x60, header Csm.h) berekent een Message Authentication Code (MAC) over de doorgegeven invoergegevens en slaat het resultaat op op het aangegeven doeladres [SWS_Csm_00982]. Of de verwerking synchroon of asynchroon verloopt, hangt af van de configuratie van de via jobId gereferentieerde job [SWS_Csm_00982].

De parameter mode specificeert de uit te voeren operationele modi. Invoergegevens worden via dataPtr en het aantal bytes daarvan via dataLength doorgegeven [SWS_Csm_00982]. De buffer macPtr neemt het resultaat op. Via de in- en uitgangsparameter macLengthPtr moet bij de aanroep de grootte van de ter beschikking gestelde buffer worden doorgegeven; na voltooiing van het verzoek wordt daarin de werkelijke lengte van de berekende MAC opgeslagen. Als de buffer kleiner is dan het totale resultaat, wordt de MAC afgekapt opgeslagen [SWS_Csm_00982].

Mogelijke retourwaarden van het type Std_ReturnType zijn [SWS_Csm_00982]:

• E_OK: verzoek succesvol uitgevoerd.
• E_NOT_OK: Verzoek mislukt.
• CRYPTO_E_BUSY: service is nog bezet.
• CRYPTO_E_KEY_NOT_VALID: Status van de sleutel is ongeldig.
• CRYPTO_E_KEY_SIZE_MISMATCH: een sleutelelement heeft een onjuiste grootte.
• CRYPTO_E_KEY_EMPTY: Het bronsleutelelement is niet geïnitialiseerd.

De functie Csm_MacVerify dient volgens [SWS_Csm_01050] voor de verificatie van een Message Authentication Code (MAC) door te controleren of de overgedragen MAC bij de beschikbaar gestelde gegevens past. Het resultaat van de verificatie wordt opgeslagen op de geheugenlocatie waarnaar verifyPtr verwijst. De dienst is beschikbaar via het headerbestand Csm.h en is gespecificeerd als re-entrant.

Bij de aanroep moeten de volgende parameters en semantiek in acht worden genomen [SWS_Csm_01050]:

• Synchroon of asynchroon gedrag: de uitvoering vindt synchroon of asynchroon plaats, afhankelijk van de configuratie van de via jobId gerefereerde job.
• Bedrijfsmodus: via mode (Crypto_OperationModeType) wordt vastgelegd welke bewerkingsmodi moeten worden uitgevoerd.
• Lengtespecificaties: terwijl dataLength het aantal databytes voor dataPtr aangeeft, vereist macLength dwingend de lengte van de te controleren MAC in bits.

Als retourwaarde levert de functie de status van het verzoek als Std_ReturnType [SWS_Csm_01050]:

• E_OK: het verzoek was succesvol.
• E_NOT_OK: Het verzoek is mislukt.
• CRYPTO_E_BUSY: De dienst is nog bezet.
• CRYPTO_E_KEY_NOT_VALID: De toestand van de sleutel is ongeldig.
• CRYPTO_E_KEY_SIZE_MISMATCH: een sleutelelement heeft een onjuiste grootte.
• CRYPTO_E_KEY_EMPTY: Het bronsleutelelement is niet-geïnitialiseerd.

De functie Csm_Encrypt (service-ID 0x5e, beschikbaar gesteld via Csm.h) versleutelt de doorgegeven invoergegevens en slaat de cijfertekst op in de opgegeven resultaatbuffer [SWS_Csm_00984].

Gebruik en semantiek

Voor de uitvoering van de bewerking worden de volgende parameters doorgegeven [SWS_Csm_00984]:

• jobId: identifier van de CSM-job die de service gebruikt.
• mode: kenmerkt de uit te voeren operationele modus of modi (van het type Crypto_OperationModeType).
• dataPtr en dataLength: pointer naar de te versleutelen uitgangsgegevens evenals het aantal te verwerken bytes.
• resultPtr: pointer naar het geheugengebied waarin de versleutelde gegevens worden opgeslagen.
• resultLengthPtr: pointer naar de lengte-informatie in bytes. Voorafgaand aan de aanroep moet deze parameter de ter beschikking gestelde buffercapaciteit van resultPtr bevatten; na voltooiing van het verzoek wordt daar de werkelijke uitvoerlengte opgeslagen [SWS_Csm_00984].

De uitvoeringssemantiek is niet statisch vastgelegd: deze verloopt afhankelijk van de configuratie van de toegewezen job synchroon of asynchroon [SWS_Csm_00984].

Gelijktijdigheid en beperkingen

De functie is gespecificeerd als reentrant [SWS_Csm_00984]. Oproepers moeten waarborgen dat de buffer resultPtr gedurende de gehele verwerking tot aan de voltooiing van de bewerking geldig blijft en minimaal de initieel via resultLengthPtr opgegeven grootte heeft.

Foutafhandeling en retourwaarden

De retourwaarde van het type Std_ReturnType geeft uitsluitsel over de verzoekstatus [SWS_Csm_00984]:

• E_OK: Verzoek succesvol.
• E_NOT_OK: Verzoek mislukt.
• CRYPTO_E_BUSY: verzoek afgewezen, omdat de service momenteel nog bezet is.
• CRYPTO_E_KEY_NOT_VALID: de opgegeven sleutel bevindt zich in de toestand “invalid”.
• CRYPTO_E_KEY_SIZE_MISMATCH: een sleutelelement heeft een ongeldige grootte.
• CRYPTO_E_KEY_EMPTY: er is een niet-geïnitialiseerd bronsleutelelement doorgegeven.

De functie Csm_Decrypt ([SWS_Csm_00989]) ontsleutelt overgedragen cijfergegevens en slaat de resulterende platte tekst op in het doelgeheugengebied. Deze wordt beschikbaar gesteld via de header Csm.h en voert cryptografische bewerkingen uit op basis van de configuratie van de overgedragen job.

Gebruik en parameters

Via de parameter jobId wordt de te gebruiken CSM-job geadresseerd, terwijl mode (type Crypto_OperationModeType) de uit te voeren bewerkingsfase(n) voorschrijft ([SWS_Csm_00989]). De te ontsleutelen gegevens worden overgedragen als pointer dataPtr met het aantal bytes dataLength. De platte tekst wordt geschreven naar de door resultPtr gerefereerde buffer.

De in-out-parameter resultLengthPtr bestuurt het bufferbeheer: bij de aanroep moet deze de beschikbaar gestelde buffergrootte van resultPtr in bytes bevatten; na voltooiing van de bewerking wordt daar de daadwerkelijk geschreven uitvoerlengte opgeslagen ([SWS_Csm_00989]).

Uitvoering en retourwaarden

Het uitvoeringsgedrag (synchroon of asynchroon) hangt direct af van de onderliggende jobconfiguratie ([SWS_Csm_00989]). De functie is re-entrant ontworpen en retourneert specifieke retourwaarden van het type Std_ReturnType:

• E_OK: Het verzoek was succesvol ([SWS_Csm_00989]).
• E_NOT_OK: Het verzoek is mislukt ([SWS_Csm_00989]).
• CRYPTO_E_BUSY: De aangevraagde dienst is momenteel nog bezet ([SWS_Csm_00989]).
• CRYPTO_E_KEY_NOT_VALID: De status van de gebruikte sleutel is ongeldig ([SWS_Csm_00989]).
• CRYPTO_E_KEY_SIZE_MISMATCH: Een sleutelelement heeft een ongeschikte grootte ([SWS_Csm_00989]).
• CRYPTO_E_KEY_EMPTY: Het bronsleutelelement is niet geïnitialiseerd ([SWS_Csm_00989]).

Gebruik

De functie Csm_AEADEncrypt voert een geauthenticeerde versleuteling met geassocieerde data (AEAD) uit en is beschikbaar via de header Csm.h [SWS_Csm_01023]. Zij verwerkt via plaintextPtr en plaintextLength de te versleutelen platte tekst en via associatedDataPtr en associatedDataLength aanvullende geassocieerde gegevens [SWS_Csm_01023]. De uitvoergegevens worden in de buffers ciphertextPtr (cijfertekst) en tagPtr (authenticatietag resp. MAC) geschreven [SWS_Csm_01023]. Bij de aanroep moeten ciphertextLengthPtr en tagLengthPtr de ter beschikking gestelde buffercapaciteit in bytes bevatten; na voltooiing bevatten zij de werkelijke lengte van de uitvoerwaarden [SWS_Csm_01023] (interpretatie: de in de specificatie genoemde parameter resultPtr heeft redactioneel gezien vermoedelijk betrekking op ciphertextPtr resp. tagPtr). Vraag Q-ea7e69875375c501 (open) Via mode wordt de uit te voeren operationele modus geselecteerd [SWS_Csm_01023]. De uitvoering verloopt synchroon of asynchroon, afhankelijk van de jobconfiguratie van de doorgegeven jobId [SWS_Csm_01023].

Foutafhandeling en retourwaarden

De service levert via het retourtype Std_ReturnType de volgende statuswaarden [SWS_Csm_01023]:

• E_OK: Het verzoek was succesvol [SWS_Csm_01023].
• E_NOT_OK: Het verzoek is mislukt [SWS_Csm_01023].
• CRYPTO_E_BUSY: het verzoek is mislukt, omdat de service bezet is [SWS_Csm_01023].
• CRYPTO_E_KEY_NOT_VALID: het verzoek is mislukt, omdat de status van de sleutel ongeldig is [SWS_Csm_01023].
• CRYPTO_E_KEY_SIZE_MISMATCH: het verzoek is mislukt, omdat een sleutelelement een onjuiste grootte heeft [SWS_Csm_01023].
• CRYPTO_E_KEY_EMPTY: het verzoek is mislukt vanwege een niet-geïnitialiseerd bronsleutelelement [SWS_Csm_01023].

Concurrency

De interface is gespecificeerd als reentrant [SWS_Csm_01023].

De dienst Csm_AEADDecrypt (service-ID 0x63, beschikbaar gesteld via Csm.h) voert volgens [SWS_Csm_01026] een AEAD-ontsleuteling (Authenticated Encryption with Associated Data) uit. Interpretatie: hoewel de beschrijving in de specificatietekst spreekt van een versleuteling, dient de functie op basis van de gedefinieerde invoer- en uitvoerparameters voor de ontsleuteling van cijfertekst en de verificatie van de overgedragen authenticatietag. Vraag Q-00e8fca03eb3b44d (open)

De uitvoering vindt afhankelijk van de configuratie van de via jobId geïdentificeerde job synchroon of asynchroon plaats ([SWS_Csm_01026]). Wat betreft gelijktijdigheid is de functie re-entrant ([SWS_Csm_01026]). Via de parameter mode wordt voorgeschreven welke bewerkingsmodi moeten worden verwerkt.

Voor de aanroep gelden de volgende parameterrelaties ([SWS_Csm_01026]):

• Invoergegevens: pointers en lengtespecificaties voor cijfertekst (ciphertextPtr, ciphertextLength), geassocieerde gegevens (associatedDataPtr, associatedDataLength) en de te controleren tag (tagPtr, tagLength).
• Uitvoergegevens: de buffer plaintextPtr neemt de ontsleutelde platte tekst op. De pointer plaintextLengthPtr moet bij de aanroep de buffercapaciteit bevatten; na voltooiing wordt daar de daadwerkelijke uitvoerlengte opgeslagen.
• Verificatieresultaat: het resultaat van de tagcontrole wordt teruggemeld via verifyPtr.

Als retourwaarden van het type Std_ReturnType zijn volgens [SWS_Csm_01026] gespecificeerd:

• E_OK: Verzoek was succesvol.
• E_NOT_OK: Verzoek is mislukt.
• CRYPTO_E_BUSY: Dienst is bezet.
• CRYPTO_E_KEY_NOT_VALID: Sleutelstatus is ongeldig.
• CRYPTO_E_KEY_SIZE_MISMATCH: Sleutelelement heeft de verkeerde grootte.
• CRYPTO_E_KEY_EMPTY: Bronsleutelelement is niet geïnitialiseerd.

De functie Csm_SignatureGenerate dient voor de cryptografische berekening van handtekeningen over overgedragen payloadgegevens conform [SWS_Csm_00992]. Of de aanroep synchroon of asynchroon wordt verwerkt, hangt af van de desbetreffende configuratie van de overgedragen job (jobId) [SWS_Csm_00992]. De functie is gespecificeerd als re-entrant [SWS_Csm_00992].

Bij de aanroep stuurt de parameter mode van het type Crypto_OperationModeType de uit te voeren bewerkingsmodi [SWS_Csm_00992]. De te ondertekenen gegevens worden via dataPtr samen met hun bytelengte dataLength overgedragen [SWS_Csm_00992]. De berekende handtekening wordt geschreven naar het door signaturePtr gerefereerde geheugengebied [SWS_Csm_00992]. De in-/uitvoerparameter signatureLengthPtr moet vóór de aanroep de beschikbaar gestelde buffergrootte in bytes bevatten; na voltooiing van het verzoek bevat deze de werkelijke bytelengte van de gegenereerde handtekening [SWS_Csm_00992].

De retourwaarde signaleert de status van het functieverzoek [SWS_Csm_00992]:

• E_OK: Verzoek succesvol uitgevoerd respectievelijk gestart [SWS_Csm_00992].
• E_NOT_OK: Algemene fouten bij het verzoek [SWS_Csm_00992].
• CRYPTO_E_BUSY: de aangevraagde dienst is momenteel bezet [SWS_Csm_00992].
• CRYPTO_E_KEY_NOT_VALID: De status van de gebruikte sleutel is ongeldig [SWS_Csm_00992].
• CRYPTO_E_KEY_SIZE_MISMATCH: Een sleutelelement heeft een niet-passende grootte [SWS_Csm_00992].
• CRYPTO_E_KEY_EMPTY: Het bronsleutelelement is niet geïnitialiseerd [SWS_Csm_00992].

De service Csm_SignatureVerify (service-ID 0x64, gedeclareerd in Csm.h) dient voor de verificatie van een cryptografische handtekening aan de hand van meegegeven gegevens [SWS_Csm_00996]. De specificatie beschrijft de functionaliteit vergelijkenderwijs als een controle of de handtekening (in de beschrijving ook als MAC aangeduid) met de meegegeven gegevens is gegenereerd [SWS_Csm_00996].

Gebruik en parameters: Bij het aanroepen identificeert jobId de geconfigureerde CSM-job, terwijl mode (type Crypto_OperationModeType) de uit te voeren operatiemodi voorschrijft [SWS_Csm_00996]. De te controleren payload wordt via de pointer dataPtr met het aantal bytes dataLength meegegeven [SWS_Csm_00996]. De te valideren handtekening wordt via signaturePtr samen met de bytelengte ervan signatureLength beschikbaar gesteld [SWS_Csm_00996]. De functie slaat het verificatieresultaat op op de geheugenlocatie waarnaar door de uitgangsparameter verifyPtr (type Crypto_VerifyResultType*) wordt verwezen [SWS_Csm_00996]. Het uitvoeringsgedrag is synchroon of asynchroon, afhankelijk van de desbetreffende jobconfiguratie [SWS_Csm_00996].

Foutafhandeling en returnwaarden: De functie retourneert een status van het type Std_ReturnType, die het slagen of specifieke fouttoestanden van het verzoek signaleert [SWS_Csm_00996]:

• E_OK: Het serviceverzoek was succesvol [SWS_Csm_00996].
• E_NOT_OK: Het serviceverzoek is mislukt [SWS_Csm_00996].
• CRYPTO_E_BUSY: Het verzoek is mislukt omdat de onderliggende service nog bezet is [SWS_Csm_00996].
• CRYPTO_E_KEY_NOT_VALID: Het verzoek is mislukt omdat de toestand van de sleutel ongeldig is [SWS_Csm_00996].
• CRYPTO_E_KEY_SIZE_MISMATCH: Het verzoek is mislukt omdat een sleutelelement de verkeerde grootte heeft [SWS_Csm_00996].
• CRYPTO_E_KEY_EMPTY: het verzoek is mislukt vanwege een niet-geïnitialiseerd bronsleutelelement [SWS_Csm_00996].

Concurrency: Volgens de specificatie is de functie re-entrant uitgevoerd [SWS_Csm_00996].

De functie Csm_RandomGenerate dient voor het genereren van willekeurige getallen en slaat het resultaat op in het geheugengebied waarnaar resultPtr verwijst [SWS_Csm_01543].

Gebruik en parameters

Via de parameter jobId wordt de identificatie van de geconfigureerde CSM-job overgedragen die de service gebruikt [SWS_Csm_01543]. De aanroeper bestuurt de gewenste hoeveelheid gegevens via de in- en uitgangsparameter resultLengthPtr: bij de aanroep moet deze pointer verwijzen naar het aantal te genereren willekeurige bytes dat in de buffer resultPtr moet worden opgeslagen [SWS_Csm_01543]. Na voltooiing van het verzoek bevat resultLengthPtr de werkelijke bytelengte van de gegenereerde waarde [SWS_Csm_01543]. De verwerking vindt synchroon of asynchroon plaats, afhankelijk van de configuratie van de desbetreffende job [SWS_Csm_01543].

Retourwaarden en foutafhandeling

De functie retourneert een status van het type Std_ReturnType [SWS_Csm_01543]:

• E_OK: het verzoek was succesvol [SWS_Csm_01543].
• E_NOT_OK: het verzoek is mislukt [SWS_Csm_01543].
• CRYPTO_E_BUSY: Het verzoek is mislukt, omdat de service nog bezet is [SWS_Csm_01543].
• CRYPTO_E_ENTROPY_EXHAUSTED: Het verzoek is mislukt, omdat de entropie van de random number generator uitgeput is [SWS_Csm_01543].

Concurrency

De functie is re-entrant ontworpen en beschikbaar via de header Csm.h met de service-ID 0x72 [SWS_Csm_01543].

Gebruik en semantiek

De synchrone functie Csm_KeyElementSet stelt de bytes van een gespecificeerd sleutelelement in voor een via keyId geïdentificeerde sleutel [SWS_Csm_00957]. De functie heeft het service-ID 0x78 en is beschikbaar via de header Csm.h [SWS_Csm_00957]. Voor de aanroep worden de volgende invoerparameters doorgegeven [SWS_Csm_00957]:

• keyId: identificatie van de sleutel waarvoor nieuw sleutelmateriaal moet worden ingesteld [SWS_Csm_00957].
• keyElementId: identificatie van het te beschrijven sleutelelement [SWS_Csm_00957].
• keyElementPtr: pointer naar de te verwerken bytes van het sleutelelement [SWS_Csm_00957].
• keyElementLength: aantal in te stellen bytes van het sleutelelement [SWS_Csm_00957].

Retourwaarden en foutafhandeling

De uitvoering levert een status van het type Std_ReturnType terug, die het welslagen of specifieke foutoorzaken aangeeft [SWS_Csm_00957]:

• E_OK: het verzoek was succesvol [SWS_Csm_00957].
• E_NOT_OK: het verzoek is mislukt [SWS_Csm_00957].
• CRYPTO_E_BUSY: het verantwoordelijke Crypto Driver Object is bezet [SWS_Csm_00957].
• CRYPTO_E_KEY_WRITE_FAIL: de schrijftoegang tot het sleutelelement is geweigerd [SWS_Csm_00957].
• CRYPTO_E_KEY_NOT_AVAILABLE: de geadresseerde sleutel is niet beschikbaar [SWS_Csm_00957].
• CRYPTO_E_KEY_SIZE_MISMATCH: de grootte van het sleutelelement komt niet overeen met de grootte van de verstrekte gegevens [SWS_Csm_00957].

Gelijktijdigheid en beperkingen

De functie Csm_KeyElementSet is gespecificeerd als synchroon en niet-reentrant (Non Reentrant) [SWS_Csm_00957]. Zij heeft geen in-/uitvoer- (inout) of uitvoerparameters (out) [SWS_Csm_00957].

De synchrone functie Csm_KeySetValid dient ertoe de sleuteltoestand van een via de identifier keyId geadresseerde sleutel op geldig (“valid”) te zetten nadat er nieuw sleutelmateriaal beschikbaar is gesteld [SWS_Csm_00958]. De service wordt beschikbaar gesteld via de header Csm.h en heeft de service-ID 0x67 [SWS_Csm_00958].

Voor het gebruik en de retourwaarden gelden de volgende bepalingen conform [SWS_Csm_00958]:

• Invoerparameter: Via keyId wordt de identifier doorgegeven van de sleutel waarvoor het nieuwe materiaal moet worden gevalideerd.
• Retourwaarde E_OK: Het verzoek om de sleuteltoestand te valideren was succesvol.
• Retourwaarde E_NOT_OK: Het verzoek is mislukt.
• Retourwaarde CRYPTO_E_BUSY: Het verzoek is mislukt omdat het onderliggende Crypto Driver Object bezet is.

Met betrekking tot gelijktijdigheid is Csm_KeySetValid gespecificeerd als niet-re-entrant (“Non Reentrant”) [SWS_Csm_00958]. Aanroepers moeten vermoedelijk daarom voor een geschikte synchronisatie zorgen, indien aanroepen potentieel vanuit concurrerende contexten plaatsvinden. Vraag Q-1762a3bca77ab74e (open)

De synchrone functie Csm_KeySetInvalid stelt de status van een sleutel in op ongeldig [SWS_Csm_91075]. Een ongeldig verklaarde sleutel kan net zolang niet meer voor cryptografische operaties worden gebruikt totdat deze opnieuw in een geldige toestand is gebracht [SWS_Csm_91075].

Gebruik en parameters

De aanroep is beschikbaar via de header Csm.h en wordt synchroon uitgevoerd [SWS_Csm_91075]. Via de invoerparameter keyId (type uint32) wordt de identifier overgedragen van de sleutel die moet worden geïnvalideerd [SWS_Csm_91075].

Retourwaarden en foutafhandeling

De functie retourneert een statuswaarde van het type Std_ReturnType [SWS_Csm_91075]:

• E_OK: Het verzoek tot invalidering was succesvol [SWS_Csm_91075].
• E_NOT_OK: het verzoek is mislukt [SWS_Csm_91075].
• CRYPTO_E_BUSY: Het verzoek is mislukt omdat het cryptodriverobject bezet is [SWS_Csm_91075].

Gelijktijdigheid en beperkingen

De functie is als niet-re-entrant (Non Reentrant) gespecificeerd [SWS_Csm_91075]. Aanroepers moeten er daarom voor zorgen dat aanroepen niet onderbrekend of ongecoördineerd parallel plaatsvinden. Als het verantwoordelijke cryptodriverobject op het moment van aanroep bezet is, wordt de operatie afgewezen met CRYPTO_E_BUSY [SWS_Csm_91075].

Gebruik

De synchrone functie Csm_KeyGetStatus dient ertoe de actuele status van een via zijn identificator gespecificeerde sleutel op te vragen [SWS_Csm_91047]. De declaratie is beschikbaar via de header Csm.h [SWS_Csm_91047].

Bij de aanroep worden de volgende parameters doorgegeven [SWS_Csm_91047]:

• keyId (ingang): Identificator van de sleutel waarvan de status moet worden bepaald.
• keyStatusPtr (uitgang): Pointer naar een geheugenlocatie van het type Crypto_KeyStatusType, waar het CSM de bepaalde sleutelstatus opslaat.

Als retourwaarde levert de functie Std_ReturnType [SWS_Csm_91047]:

• E_OK: Het opvragen van de status is geslaagd en het resultaat is beschikbaar via de uitvoerpointer.
• E_NOT_OK: Het verzoek is mislukt.

Gelijktijdigheid en gedrag

De servicefunctie heeft de service-ID 0x83 en is gespecificeerd als re-entrant [SWS_Csm_91047]. Omdat de afloop synchroon plaatsvindt, blokkeert de aanroep de aanroeper totdat het bepalen van de status is voltooid [SWS_Csm_91047]. Een geldig geheugengebied voor keyStatusPtr moet door de aanroeper worden bereitgesteld, aangezien ongeldige pointers vermoedelijk tot de retourwaarde E_NOT_OK leiden. Vraag Q-a920a9a12b1374aa (open)

De synchrone en re-entrante functie Csm_KeyElementGet leest de gegevens van een specifiek sleutelelement uit de via keyId geïdentificeerde sleutel uit en kopieert deze naar het overgedragen geheugengebied [SWS_Csm_00959]. De service wordt gedeclareerd via het headerbestand Csm.h en heeft de service-ID 0x68 [SWS_Csm_00959].

Parameters en bufferbehandeling

Voor de identificatie van het element worden de parameters keyId (identifier van de sleutel) en keyElementId (identifier van het gewenste sleutelelement) doorgegeven [SWS_Csm_00959]. Het uitlezen vereist de beschikbaarstelling van een uitvoerbuffer en het lengtebeheer daarvan:

• keyElementPtr: Pointer naar de geheugenlocatie waarnaar de geëxtraheerde bytes van het sleutelelement worden gekopieerd [SWS_Csm_00959].
• keyElementLengthPtr: Een invoer-/uitvoerparameter (inout) die bij de functieaanroep de maximaal beschikbare buffergrootte van keyElementPtr in bytes moet bevatten. Na voltooiing van de verwerking slaat de functie hier de daadwerkelijk geschreven bytelengte op [SWS_Csm_00959].

Retourwaarden en foutanalyse

De functie levert als Std_ReturnType specifieke statuscodes terug om de uitkomst van de bewerking aan te geven [SWS_Csm_00959]:

• E_OK: Het kopiëren van het sleutelelement was succesvol [SWS_Csm_00959].
• E_NOT_OK: Het verzoek is algemeen mislukt [SWS_Csm_00959].
• CRYPTO_E_BUSY: Het verzoek is mislukt omdat het desbetreffende Crypto Driver Object momenteel bezet is [SWS_Csm_00959].
• CRYPTO_E_KEY_NOT_AVAILABLE: Het via keyElementId opgevraagde sleutelelement is niet beschikbaar [SWS_Csm_00959].
• CRYPTO_E_KEY_READ_FAIL: De leestoegang tot het sleutelelement is geweigerd [SWS_Csm_00959].
• CRYPTO_E_KEY_EMPTY: Het aangevraagde bron-sleutelelement is niet geïnitialiseerd [SWS_Csm_00959].

De synchrone functie Csm_KeyElementCopyManager dient ertoe om een afzonderlijk sleutelelement uit een bronsleutel naar een doelelement van een doelsleutel te kopiëren [SWS_Csm_00969]. De aanroep wordt via het headerbestand Csm.h met de service-ID 0x71 ter beschikking gesteld en vereist vier invoerparameters: keyId en keyElementId ter identificatie van het bronsleutelelement en targetKeyId en targetKeyElementId voor het doel [SWS_Csm_00969].

Wat betreft de gelijktijdigheid is de service re-entrant ontworpen, maar expliciet niet voor dezelfde keyId [SWS_Csm_00969]. Parallelle toegangen tot dezelfde bronsleutel moeten daarom door de aanroeper worden vermeden of gesynchroniseerd.

De functie retourneert een status van het type Std_ReturnType. Bij succesvolle uitvoering levert zij E_OK op [SWS_Csm_00969]. In het geval van een fout zijn specifieke retourwaarden beschikbaar voor oorzaakanalyse [SWS_Csm_00969]:

• CRYPTO_E_BUSY: Het onderliggende crypto-driverobject is bezet [SWS_Csm_00969].
• CRYPTO_E_KEY_NOT_AVAILABLE: Het opgevraagde sleutelelement is niet beschikbaar [SWS_Csm_00969].
• CRYPTO_E_KEY_READ_FAIL: Het uitlezen van het bronelement is niet toegestaan [SWS_Csm_00969].
• CRYPTO_E_KEY_WRITE_FAIL: Het schrijven naar het doelelement is niet toegestaan [SWS_Csm_00969].
• CRYPTO_E_KEY_SIZE_MISMATCH: De groottes van de beide sleutelelementen zijn onderling incompatibel [SWS_Csm_00969].
• CRYPTO_E_KEY_EMPTY: Het bronsleutelelement is nog niet geïnitialiseerd [SWS_Csm_00969].
• E_NOT_OK: Algemene fouten bij de uitvoering van het verzoek [SWS_Csm_00969].

Gebruik

De synchrone servicefunctie Csm_KeyCopy met het service-ID 0x73 dient voor het volledig kopiëren van alle sleutelelementen van een bronsleutel naar een doelsleutel [SWS_Csm_01034]. De declaratie wordt via het headerbestand Csm.h ter beschikking gesteld [SWS_Csm_01034]. Als onveranderlijke ingangsparameters worden keyId voor de identifier van de bronsleutel en targetKeyId voor de identifier van de doelsleutel meegegeven [SWS_Csm_01034]. Aanvullende in-/uitgangs- of uitgangsparameters zijn in de signatuur niet gedefinieerd [SWS_Csm_01034].

Foutafhandeling en retourwaarden

De returnwaarde van het type Std_ReturnType informeert de aanroeper over het resultaat van de uitvoering [SWS_Csm_01034]. Terwijl E_OK een succesvolle uitvoering signaleert, duidt E_NOT_OK op een algemeen mislukken van het verzoek [SWS_Csm_01034]. Specifieke foutoorzaken worden aangegeven door afzonderlijke krypto-returnwaarden [SWS_Csm_01034]:

• CRYPTO_E_BUSY: De operatie is mislukt omdat het Crypto Driver Object bezet is.
• CRYPTO_E_KEY_NOT_AVAILABLE: Het opgevraagde sleutelelement is niet beschikbaar.
• CRYPTO_E_KEY_READ_FAIL: Het uitlezen van het sleutelelement uit de bron is niet toegestaan.
• CRYPTO_E_KEY_WRITE_FAIL: Het schrijven van het sleutelelement naar het doel is niet toegestaan.
• CRYPTO_E_KEY_SIZE_MISMATCH: De groottes van de betrokken sleutelelementen zijn niet onderling compatibel.
• CRYPTO_E_KEY_EMPTY: Het sleutelelement van de bronsleutel is niet geïnitialiseerd.

Gelijktijdigheid en beperkingen

Wat het aanroepgedrag betreft, is Csm_KeyCopy re-entrant ontworpen, zij het met de bindende beperking dat dit niet geldt voor dezelfde keyId [SWS_Csm_01034].

De synchrone functie Csm_KeyElementCopyPartial kopieert een gedefinieerd deelbereik van een sleutelelement naar een ander sleutelelement binnen dezelfde cryptodriver [SWS_Csm_91025]. Via de parameters keyElementSourceOffset en keyElementCopyLength wordt bepaald vanaf welke byte en met welke lengte het bronelement (geïdentificeerd door keyId en keyElementId) wordt gekopieerd. De startpositie in het doelelement (targetKeyId, targetKeyElementId) wordt via keyElementTargetOffset aangegeven [SWS_Csm_91025].

De returnwaarde levert de uitvoeringsstatus en specifieke foutoorzaken [SWS_Csm_91025]:

• E_OK: De kopieerbewerking is met succes uitgevoerd.
• CRYPTO_E_BUSY: Het Crypto Driver Object is bezet.
• CRYPTO_E_KEY_NOT_AVAILABLE: Het opgevraagde sleutelelement is niet beschikbaar.
• CRYPTO_E_KEY_READ_FAIL: Het uitlezen van het bron-sleutelelement is niet toegestaan.
• CRYPTO_E_KEY_WRITE_FAIL: Het beschrijven van het doel-sleutelelement is niet toegestaan.
• CRYPTO_E_KEY_SIZE_MISMATCH: De groottes van de betrokken sleutelelementen zijn incompatibel.
• CRYPTO_E_KEY_EMPTY: Het bronsleutelelement is niet-geïnitialiseerd.
• E_NOT_OK: Het verzoek is om algemene redenen mislukt.

De functie is re-entrant geïmplementeerd, maar mag niet gelijktijdig voor dezelfde keyId worden aangeroepen [SWS_Csm_91025]. Bovendien vereist de interface dat bron en doel in dezelfde cryptodriver worden beheerd [SWS_Csm_91025]. De declaratie is beschikbaar via de header Csm.h [SWS_Csm_91025].

Gebruik en aanroepcontext

De synchrone functie Csm_RandomSeed dient ertoe het sleutelelement CRYPTO_KE_RANDOM_SEED van een sleutel te vullen met een overgedragen toevalswaarde (seed) [SWS_Csm_01051]. Bij de aanroep worden via keyId de identifier van de doelsleutel, via seedPtr de pointer naar de geheugenlocatie met de seed-gegevens en via seedLength de lengte van de seed in bytes overgedragen [SWS_Csm_01051].

Samenspel

Als de CSM bij de uitvoering geen fouten detecteert, stuurt de functie Csm_RandomSeed de dienstaanroep direct door naar CryIf_RandomSeed van de Crypto Interface [SWS_Csm_01052].

Foutafhandeling en retourwaarden

De functie retourneert een statuswaarde van het type Std_ReturnType [SWS_Csm_01051]:

• E_OK: het verzoek was succesvol [SWS_Csm_01051].
• E_NOT_OK: het verzoek is mislukt [SWS_Csm_01051].
• CRYPTO_E_BUSY: De uitvoering is mislukt, omdat het desbetreffende Crypto Driver Object momenteel bezet is [SWS_Csm_01051].
• CRYPTO_E_KEY_NOT_VALID: Het verzoek is geweigerd, omdat de toestand van de sleutel ongeldig is [SWS_Csm_01051].

Gelijktijdigheid en beperkingen

Wat betreft het gedrag bij gelijktijdigheid is Csm_RandomSeed re-entrant geïmplementeerd, maar mag deze niet gelijktijdig voor dezelfde keyId worden aangeroepen [SWS_Csm_01051].

De synchrone functie Csm_KeyGenerate dient voor het genereren van nieuw cryptografisch sleutelmateriaal en slaat dit direct op in de via parameter keyId vastgelegde sleutel [SWS_Csm_00955]. De interface wordt beschikbaar gesteld via het headerbestand Csm.h en heeft de service-ID 0x6a [SWS_Csm_00955].

Bij de aanroep geeft de applicatie de identifier keyId (type uint32) door van de sleutel waarvoor het materiaal moet worden gegenereerd; invoer-/uitvoerparameters of zuivere uitvoerparameters bestaan niet [SWS_Csm_00955]. De status van de bewerking wordt synchroon gemeld via de retourwaarde van het type Std_ReturnType [SWS_Csm_00955]:

• E_OK: Het genereren en opslaan van het sleutelmateriaal was succesvol [SWS_Csm_00955].
• E_NOT_OK: het verzoek is mislukt [SWS_Csm_00955].
• CRYPTO_E_BUSY: De uitvoering is mislukt omdat het verantwoordelijke crypto-driver-object momenteel bezet is [SWS_Csm_00955].
• CRYPTO_E_KEY_NOT_VALID: Het verzoek is geweigerd omdat de doelsleutel zich in de toestand “invalid” bevindt [SWS_Csm_00955].
• CRYPTO_E_KEY_EMPTY: Het genereren is mislukt vanwege een niet-geïnitialiseerd bronsleutelelement [SWS_Csm_00955].

Met betrekking tot gelijktijdigheid is Csm_KeyGenerate ontworpen als re-entrant, maar mag niet gelijktijdig voor dezelfde keyId worden aangeroepen [SWS_Csm_00955].

De synchrone functie Csm_KeyDerive dient voor het afleiden van een nieuwe cryptografische sleutel uit een opgegeven uitgangssleutel [SWS_Csm_00956]. De functie is gedeclareerd in het headerbestand Csm.h en heeft de service-ID 0x6b [SWS_Csm_00956].

Gebruik en parameters

De synchrone aanroep verwerkt twee invoerparameters [SWS_Csm_00956]:

• keyId: Identifier van de uitgangssleutel die de sleutelelementen voor wachtwoord en salt bevat [SWS_Csm_00956].
• targetKeyId: Identifier van de doelsleutel; het afgeleide sleutelmateriaal wordt opgeslagen in het sleutelelement met ID 1 [SWS_Csm_00956].

Retourwaarden en foutafhandeling

Als retourwaarde levert de functie de status Std_ReturnType [SWS_Csm_00956]. Naast E_OK bij een succesvolle uitvoering en E_NOT_OK bij algemene fouten zijn er specifieke crypto-fouten gedefinieerd [SWS_Csm_00956]:

• CRYPTO_E_BUSY: Het crypto-driver-object is bezet [SWS_Csm_00956].
• CRYPTO_E_KEY_READ_FAIL: Het uitlezen van het sleutelelement is niet toegestaan [SWS_Csm_00956].
• CRYPTO_E_KEY_WRITE_FAIL: Schrijven naar het doelsleutelelement is niet toegestaan [SWS_Csm_00956].
• CRYPTO_E_KEY_NOT_VALID: De toestand van de sleutel is ongeldig [SWS_Csm_00956].
• CRYPTO_E_KEY_SIZE_MISMATCH: De groottes van de sleutelelementen zijn incompatibel [SWS_Csm_00956].
• CRYPTO_E_KEY_EMPTY: Het sleutelelement van de bron is niet-geïnitialiseerd [SWS_Csm_00956].

Gelijktijdigheid en wisselwerking

De functie is re-entrant, echter uitdrukkelijk niet voor dezelfde keyId [SWS_Csm_00956]. Als er in de CSM geen fouten worden vastgesteld, stuurt de service de uitvoering direct door naar CryIf_KeyDerive [SWS_Csm_01018].

De synchrone interface Csm_KeyExchangeCalcPubVal (service-ID 0x6c, beschikbaar via Csm.h) berekent de openbare waarde van de huidige gebruiker voor het sleuteluitwisselingsprotocol en slaat de openbare sleutel op op het door de pointer publicValuePtr gereferentieerde geheugenadres [SWS_Csm_00966].

Parameters en bufferbeheer

De functie verwerkt drie overdrachtparameters [SWS_Csm_00966]:

• keyId (invoer): Bevat de identifier van de sleutel die voor het sleuteluitwisselingsprotocol moet worden gebruikt [SWS_Csm_00966].
• publicValuePtr (uitvoer): Pointer naar het geheugengebied waarin de resulterende openbare sleutelwaarde wordt opgeslagen [SWS_Csm_00966].
• publicValueLengthPtr (invoer/uitvoer): Pointer naar de lengte-informatie. Bij de aanroep moet deze parameter de beschikbaar gestelde grootte van de buffer publicValuePtr bevatten; na voltooiing van de uitvoering wordt daar de daadwerkelijke lengte van de berekende waarde opgeslagen [SWS_Csm_00966].

Foutafhandeling en retourwaarden

De uitvoeringsstatus wordt via Std_ReturnType teruggemeld [SWS_Csm_00966]:

• E_OK: Het verzoek was succesvol [SWS_Csm_00966].
• E_NOT_OK: Het verzoek is mislukt [SWS_Csm_00966].
• CRYPTO_E_BUSY: Het verzoek is mislukt omdat het crypto-driver-object bezet is [SWS_Csm_00966].
• CRYPTO_E_KEY_NOT_VALID: Het verzoek mislukt omdat de status van de sleutel ongeldig is [SWS_Csm_00966].
• CRYPTO_E_KEY_EMPTY: Het verzoek mislukt vanwege een niet-geïnitialiseerd bronsleutelelement [SWS_Csm_00966].

Concurrency

De functie is ontworpen als re-entrant, maar mag niet gelijktijdig voor dezelfde keyId worden aangeroepen [SWS_Csm_00966].

De synchrone functie Csm_KeyExchangeCalcSecret dient in de Crypto Service Manager voor de berekening van een gedeeld geheim (Shared Secret Key) in het kader van een sleuteluitwisselingsprotocol [SWS_Csm_00967]. Hierbij wordt het sleutelmateriaal van de via keyId gereferentieerde sleutel gecombineerd met de openbare waarde van de communicatiepartner. De berekende geheime sleutel wordt vervolgens direct als sleutelelement binnen dezelfde sleutel vastgelegd [SWS_Csm_00967].

De interface wordt beschikbaar gesteld via de header Csm.h en verwacht drie invoerparameters [SWS_Csm_00967]:

• keyId: Identifier van de sleutel waarvan het sleutelmateriaal voor het protocol wordt gebruikt.
• partnerPublicValuePtr: Pointer naar het geheugengebied dat de openbare waarde van de partner bevat.
• partnerPublicValueLength: Lengte van de overgedragen partnerwaarde in bytes.

De aanroep levert als retourwaarde van het type Std_ReturnType ofwel E_OK bij een succesvolle uitvoering ofwel E_NOT_OK bij een algemene fout [SWS_Csm_00967]. Specifieke foutsituaties signaleren gedetailleerde statuscodes: CRYPTO_E_BUSY geeft aan dat het onderliggende Crypto-Driver-object bezet is. Als de toestand van de sleutel ongeldig is, wordt CRYPTO_E_KEY_NOT_VALID geretourneerd, terwijl CRYPTO_E_KEY_EMPTY wijst op een niet-geïnitialiseerd bron-sleutelelement [SWS_Csm_00967].

Met betrekking tot gelijktijdigheid is de functie ontworpen als re-entrant, maar mag niet gelijktijdig voor dezelfde keyId worden aangeroepen [SWS_Csm_00967].

Gebruik

De functie Csm_JobKeySetValid slaat de sleutel zo nodig op en stelt de sleutelstatus van de via keyId geïdentificeerde sleutel in op geldig [SWS_Csm_91027]. De interface is gedeclareerd via het headerbestand Csm.h en heeft de service-ID 0x7a met de signatuur Std_ReturnType Csm_JobKeySetValid (uint32 jobId, uint32 keyId) [SWS_Csm_91027].

Bij de aanroep worden twee invoerparameters van het type uint32 doorgegeven [SWS_Csm_91027]:

• jobId: Bevat de identificator van de job die de CSM-dienst gebruikt [SWS_Csm_91027].
• keyId: Bevat de identificator van de sleutel waarvoor nieuw sleutelmateriaal moet worden gevalideerd [SWS_Csm_91027].

Aanvullende invoer-/uitvoerparameters of zuivere uitvoerparameters zijn voor deze functie niet gedefinieerd [SWS_Csm_91027].

Synchroon en asynchroon gedrag en gelijktijdigheid

De uitvoeringssemantiek is afhankelijk van de desbetreffende jobconfiguratie: de aanroep vindt ofwel synchroon ofwel asynchroon plaats [SWS_Csm_91027]. De functie is gespecificeerd als re-entrant [SWS_Csm_91027].

Retourwaarden en foutafhandeling

De retourwaarde van het type Std_ReturnType weerspiegelt het resultaat van het functieverzoek [SWS_Csm_91027]:

• E_OK: Het verzoek was succesvol [SWS_Csm_91027].
• E_NOT_OK: Het verzoek is mislukt [SWS_Csm_91027].
• CRYPTO_E_BUSY: Het verzoek is mislukt omdat het verantwoordelijke Crypto Driver Object bezet is [SWS_Csm_91027].

Gebruik

De functie Csm_JobKeySetInvalid stelt de status van een cryptografische sleutel in op ongeldig [SWS_Csm_91002]. Na het aanroepen van deze interface kan de desbetreffende sleutel niet meer voor cryptografische operaties worden gebruikt totdat deze opnieuw in een geldige toestand is gebracht [SWS_Csm_91002]. De service heeft het service-ID 0x84, is beschikbaar via het headerbestand Csm.h en werkt afhankelijk van de jobconfiguratie synchroon of asynchroon [SWS_Csm_91002].

Voor de aanroep worden de volgende parameters meegegeven [SWS_Csm_91002]:

• jobId: Identificatie van de CSM-job die deze service gebruikt [SWS_Csm_91002].
• keyId: Identificatie van de sleutel die ongeldig moet worden gemaakt [SWS_Csm_91002].

Foutafhandeling en retourwaarden

De returnwaarde van het type Std_ReturnType meldt het resultaat van het verzoek [SWS_Csm_91002]:

• E_OK: het verzoek was succesvol [SWS_Csm_91002].
• E_NOT_OK: het verzoek is mislukt [SWS_Csm_91002].
• CRYPTO_E_BUSY: Het verzoek is mislukt omdat het verantwoordelijke Crypto Driver Object bezet is [SWS_Csm_91002].

Concurrency

De interface is gespecificeerd als re-entrant [SWS_Csm_91002]. Aanvullende in- of uitgangsparameters bestaan niet [SWS_Csm_91002].

Gebruik en aanroepcontext

De functie Csm_JobRandomSeed dient ertoe een nieuwe seed voor een vastgelegde sleutel beschikbaar te stellen, die voor een toegewezen toevalsgenerator wordt gebruikt [SWS_Csm_91028]. De declaratie is beschikbaar in de header Csm.h [SWS_Csm_91028]. De functie heeft de service-ID 0x7b en verwerkt vier ingangsparameters: via jobId wordt de gebruikende CSM-job geïdentificeerd, terwijl keyId de doelsleutel bepaalt waarvoor de seed moet worden gegenereerd [SWS_Csm_91028]. Via de pointer seedPtr worden de initialisatiegegevens overgedragen en met seedLength wordt de lengte ervan in bytes vastgelegd [SWS_Csm_91028]. Het uitvoeringsgedrag richt zich naar de configuratie van de desbetreffende job en verloopt synchroon of asynchroon [SWS_Csm_91028].

Foutafhandeling en retourwaarden

De functie retourneert een status van het type Std_ReturnType, die het resultaat van het verzoek aangeeft [SWS_Csm_91028]:

• E_OK: het verzoek was succesvol [SWS_Csm_91028].
• E_NOT_OK: Het verzoek is in het algemeen mislukt [SWS_Csm_91028].
• CRYPTO_E_BUSY: Het verzoek is mislukt omdat de dienst momenteel nog bezet is [SWS_Csm_91028].
• CRYPTO_E_KEY_NOT_VALID: Het verzoek is afgewezen omdat de gespecificeerde sleutel zich in de toestand invalid bevindt [SWS_Csm_91028].

Gelijktijdigheid en beperkingen

De interface is als re-entrant gespecificeerd [SWS_Csm_91028]. Als een applicatie de dienst aanroept terwijl een andere operatie nog actief is, signaleert de retourwaarde CRYPTO_E_BUSY deze toestand [SWS_Csm_91028]. Bovendien moet vóór de uitvoering gewaarborgd zijn dat de via keyId geadresseerde sleutel geldig is, om de fout CRYPTO_E_KEY_NOT_VALID te voorkomen [SWS_Csm_91028].

Gebruik

De functie Csm_JobKeyGenerate genereert nieuw sleutelmateriaal en slaat dit op in de via keyId geïdentificeerde sleutel [SWS_Csm_91029]. Via de parameter jobId wordt de identificatie meegegeven van de job die de CSM-service gebruikt [SWS_Csm_91029]. De uitvoering vindt afhankelijk van de configuratie van de desbetreffende job synchroon of asynchroon plaats [SWS_Csm_91029]. De service is gedeclareerd via het headerbestand Csm.h met het service-ID 0x7c [SWS_Csm_91029].

Retourwaarden en foutafhandeling

De returnwaarde van het type Std_ReturnType geeft uitsluitsel over het resultaat van het verzoek [SWS_Csm_91029]:

• E_OK: het verzoek was succesvol [SWS_Csm_91029].
• E_NOT_OK: het verzoek is mislukt [SWS_Csm_91029].
• CRYPTO_E_BUSY: De service is op dit moment nog bezet [SWS_Csm_91029].
• CRYPTO_E_KEY_NOT_VALID: De toestand van de sleutel is ongeldig (invalid) [SWS_Csm_91029].
• CRYPTO_E_KEY_EMPTY: Het verzoek is mislukt vanwege een niet-geïnitialiseerd bronsleutelelement [SWS_Csm_91029].

Gelijktijdigheid en beperkingen

De functie is gespecificeerd als re-entrant [SWS_Csm_91029]. Interpretatie: Aangezien de specificatie geen specifieke uitvoeringscontext voorschrijft, zal de aanroep typisch plaatsvinden in de task-context. Vraag Q-236d699ed655e285 (open)

Gebruik en semantiek

De functie Csm_JobKeyDerive leidt een nieuwe cryptografische sleutel af door de sleutelelementen voor wachtwoord en salt uit de door keyId geïdentificeerde sleutel te gebruiken [SWS_Csm_91030]. Het resultaat wordt opgeslagen in het sleutelelement met ID 1 van de door targetKeyId vastgelegde doelsleutel [SWS_Csm_91030]. De aanroep vindt plaats via het headerbestand Csm.h met het service-ID 0x7d onder doorgifte van de desbetreffende job via jobId [SWS_Csm_91030].

De verwerking vindt afhankelijk van de configuratie van de meegegeven job synchroon of asynchroon plaats [SWS_Csm_91030]. De functie is gespecificeerd als re-entrant [SWS_Csm_91030].

Foutafhandeling en retourwaarden

Als returnwaarde levert de functie het type Std_ReturnType. Een succesvolle uitvoering van het verzoek wordt bevestigd door E_OK [SWS_Csm_91030]. In geval van een fout of bij niet-passende randvoorwaarden worden specifieke returnwaarden gemeld [SWS_Csm_91030]:

• E_NOT_OK: Het verzoek is mislukt [SWS_Csm_91030].
• CRYPTO_E_BUSY: Het verzoek mislukt omdat de service momenteel nog bezet is [SWS_Csm_91030].
• CRYPTO_E_KEY_READ_FAIL: Het uitlezen van het sleutelelement is niet toegestaan [SWS_Csm_91030].
• CRYPTO_E_KEY_WRITE_FAIL: Het schrijven naar het doel-sleutelelement is niet toegestaan [SWS_Csm_91030].
• CRYPTO_E_KEY_NOT_VALID: De toestand van de sleutel is ongeldig [SWS_Csm_91030].
• CRYPTO_E_KEY_SIZE_MISMATCH: De groottes van de betrokken sleutelelementen zijn onderling niet compatibel [SWS_Csm_91030].
• CRYPTO_E_KEY_EMPTY: Het bronsleutelelement is niet-geïnitialiseerd [SWS_Csm_91030].

Gebruik

De functie Csm_JobKeyExchangeCalcPubVal berekent de publieke waarde van de actuele deelnemer voor het sleuteluitwisselingsprotocol en slaat deze op in het opgegeven doelgeheugen [SWS_Csm_91031]. Afhankelijk van de configuratie van de toegewezen job verloopt de verwerking synchroon of asynchroon [SWS_Csm_91031].

De overdracht van de parameters vindt plaats via de volgende interfacegegevens [SWS_Csm_91031]:

• jobId: Identifier van de CSM-job die gebruikmaakt van de cryptografische dienst.
• keyId: Identifier van de sleutel die voor het sleuteluitwisselingsprotocol wordt gebruikt.
• publicValuePtr: Pointer naar het buffergebied waarin de berekende publieke sleutel wordt opgeslagen.
• publicValueLengthPtr: Pointer naar de lengteopgave. Bij de functieaanroep moet deze parameter de capaciteit van de buffer publicValuePtr bevatten; na voltooiing van de uitvoering wordt de werkelijke lengte van de berekende waarde ingevuld.

Foutafhandeling

De retourwaarde van het type Std_ReturnType geeft uitsluitsel over de uitvoeringsstatus van het verzoek [SWS_Csm_91031]:

• E_OK: Verzoek is succesvol uitgevoerd.
• E_NOT_OK: Verzoek is mislukt.
• CRYPTO_E_BUSY: De aangevraagde dienst is momenteel nog bezet.
• CRYPTO_E_KEY_NOT_VALID: De sleuteltoestand is ongeldig.
• CRYPTO_E_KEY_EMPTY: Het bronsleutelelement is niet geïnitialiseerd.

Gelijktijdigheid en integratie

De interface is als re-entrant gedeclareerd, heeft de service-ID 0x7e en wordt via het headerbestand Csm.h beschikbaar gesteld [SWS_Csm_91031].

Gebruik en semantiek

De functie Csm_JobKeyExchangeCalcSecret berekent de gedeelde geheime sleutel (Shared Secret Key) voor een sleuteluitwisseling met gebruikmaking van het sleutelmateriaal uit de via keyId geïdentificeerde sleutel en de publieke sleutel van de communicatiepartner [SWS_Csm_91032]. Het geheugenadres van de partnersleutel wordt via partnerPublicValuePtr overgedragen en de lengte ervan in bytes wordt via partnerPublicValueLength gedefinieerd [SWS_Csm_91032]. Het berekende gedeelde geheim wordt direct als sleutelelement binnen dezelfde sleutel opgeslagen [SWS_Csm_91032].

Via de ingangsparameter jobId wordt de gebruikende CSM-job geïdentificeerd. Het uitvoeringsgedrag is synchroon of asynchroon, afhankelijk van de desbetreffende jobconfiguratie [SWS_Csm_91032].

Foutafhandeling en retourwaarden

De retourwaarde van het type Std_ReturnType meldt de status van het serviceverzoek [SWS_Csm_91032]:

• E_OK: Het serviceverzoek was succesvol [SWS_Csm_91032].
• E_NOT_OK: Het serviceverzoek is mislukt [SWS_Csm_91032].
• CRYPTO_E_BUSY: Het verzoek mislukt omdat de onderliggende dienst nog bezet is [SWS_Csm_91032].
• CRYPTO_E_KEY_NOT_VALID: Het verzoek mislukt omdat de gerefereerde sleutel zich in de toestand “invalid” bevindt [SWS_Csm_91032].
• CRYPTO_E_KEY_EMPTY: De berekening mislukt omdat een vereist bronsleutelelement niet is geïnitialiseerd [SWS_Csm_91032].

Gelijktijdigheid en integratie

De functie is als re-entrant ontworpen, heeft de service-ID 0x7f en wordt via het headerbestand Csm.h gedeclareerd [SWS_Csm_91032].

De functie Csm_SaveContextJob instrueert de Crypto Driver om de interne context van de desbetreffende crypto-operatie op te slaan in een buffer aan de applicatiezijde [SWS_Csm_91063]. De service is gedeclareerd in het headerbestand Csm.h en heeft de service-ID 0x86 [SWS_Csm_91063].

De interface verwacht de volgende parameters [SWS_Csm_91063]:

• jobId (invoer): Duidt de unieke identificatie aan van de job die de CSM-service gebruikt.
• contextBufferLengthPtr (in-/uitvoer): Pointer naar de lengtewaarde. Bij aanroep geeft deze de maximaal in de doelbuffer beschikbare capaciteit aan; na uitvoering bevat deze de werkelijk geschreven gegevenslengte of in het geval van een fout de waarde 0.
• contextBufferPtr (uitvoer): Pointer naar het geheugengebied van de applicatie waarin de contextgegevens moeten worden geschreven.

De uitvoering vindt afhankelijk van de jobconfiguratie hetzij synchroon hetzij asynchroon plaats [SWS_Csm_91063]. Bovendien is de functie als re-entrant gespecificeerd [SWS_Csm_91063].

Voor de terugmelding van de operatiestatus worden de volgende retourwaarden gedefinieerd [SWS_Csm_91063]:

• E_OK: De contextgegevens zijn succesvol in de buffer opgeslagen en de lengteopgave is bijgewerkt.
• E_NOT_OK: De contextgegevens konden niet ter beschikking worden gesteld, omdat de waarden ongeldig zijn; de teruggemelde lengte wordt op 0 gezet.
• CRYPTO_E_BUSY: Het verzoek is mislukt, omdat de onderliggende crypto-service nog bezig is.

Gebruik en semantiek

De functie Csm_RestoreContextJob dient ertoe de interne toestand van een cryptografische taak vanuit een externe buffer te herstellen, zodat opeenvolgende operaties op de exacte locatie van de eerdere opslag worden voortgezet [SWS_Csm_91064]. Via de parameter jobId wordt de doel-job geadresseerd, terwijl contextBufferPtr verwijst naar de payload en contextBufferLength naar de bytegrootte daarvan [SWS_Csm_91064]. De uitvoering vindt afhankelijk van de configuratie van de desbetreffende taak synchroon of asynchroon plaats [SWS_Csm_91064].

Retourwaarden en foutafhandeling

De functie meldt het resultaat van de operatie via haar retourwaarde van het type Std_ReturnType terug [SWS_Csm_91064]:

• E_OK: De contextgegevens zijn succesvol ingelezen en de interne drivertoestand is hersteld [SWS_Csm_91064].
• E_NOT_OK: Het herstel van de context is mislukt [SWS_Csm_91064].
• CRYPTO_E_BUSY: De onderliggende cryptodienst is momenteel bezet, waardoor het verzoek is afgewezen [SWS_Csm_91064].

Gelijktijdigheid en beperkingen

De interface is als re-entrant gespecificeerd en beschikbaar via Csm.h (Service-ID 0x87) [SWS_Csm_91064]. Interpretatie: Bij een asynchrone configuratie van de job dient de aanroeper er vermoedelijk voor te zorgen dat de buffer onder contextBufferPtr tot aan de daadwerkelijke voltooiing van het herstel ongewijzigd en geldig blijft. Vraag Q-8ab0cb179f807bd4 (open)

Gebruik en aanroepcontext

De functie Csm_CancelJob (service-ID 0x6f) dient voor het synchroon afbreken van de verwerking van asynchrone of streaming-jobs binnen de module Csm [SWS_Csm_00968]. De interface wordt beschikbaar gesteld via de header Csm.h [SWS_Csm_00968]. Als parameter accepteert de functie de identifier van de af te breken job via job (van het type uint32) evenals de parameter mode (van het type Crypto_OperationModeType), die niet wordt gebruikt en uitsluitend dient voor interfacecompatibiliteit [SWS_Csm_00968].

Retourwaarden en annuleringsgedrag

Het resultaat van de afbreekoproep wordt synchroon gesignaleerd via de retourwaarde van het type Std_ReturnType [SWS_Csm_00968]:

• E_OK: het afbreken was direct succesvol; de job is uit alle wachtrijen en potentieel direct uit de hardware van de crypto-driver verwijderd [SWS_Csm_00968].
• E_NOT_OK: het afbreekverzoek is mislukt [SWS_Csm_00968].
• CRYPTO_E_JOB_CANCELED: een onmiddellijke annulering was niet mogelijk; het afbreken wordt in de eerstvolgende geschikte verwerkingsstap voltooid en aansluitend meegedeeld via de negatieve afrondings-callback van de job [SWS_Csm_00968].

Gelijktijdigheid en beperkingen

De specificatie definieert Csm_CancelJob als synchroon en niet-reentrant (Non Reentrant) [SWS_Csm_00968]. Aanroepende componenten moeten er daarom voor zorgen dat er geen concurrerende aanroepen van de functie plaatsvinden.

De synchrone interface Csm_CallbackNotification wordt gedeclareerd via het headerbestand Csm.h en dient voor de onderliggende laag (CRYIF) als terugmeldfunctie om de Crypto Service Manager (CSM) te informeren over de voltooiing van een cryptografische opdracht [SWS_Csm_00970]. De functie heeft geen retourwaarde en accepteert twee ingangsparameters: de pointer job naar de beëindigde opdracht van het type Crypto_JobType* en result van het type Crypto_ResultType, die het uitvoeringsresultaat van de onderliggende cryptografische bewerking overdraagt [SWS_Csm_00970].

Met betrekking tot de gelijktijdigheid is de uitvoering van Csm_CallbackNotification als re-entrant gespecificeerd [SWS_Csm_00970]. Specifieke retourcodes of afzonderlijke DET- respectievelijk DEM-foutmeldingen zijn in het element niet gedefinieerd; foutstatussen en uitvoeringsresultaten van de cryptografische verwerking worden in plaats daarvan direct via het overgedragen argument result ter beschikking gesteld [SWS_Csm_00970].

In het kader van de interactie controleert de functie de verwerkingsmodus van de opdracht: als in het veld job->jobPrimitiveInputOutput.mode de bit CRYPTO_OPERATIONMODE_FINISH is ingesteld, verplicht de specificatie Csm_CallbackNotification ertoe de geconfigureerde callback-functie aan te roepen [SWS_Csm_01044]. Interpretatie: bij deze aanroep betreft het vermoedelijk de notificatie van de bovenliggende applicatielaag, aangezien de FINISH-vlag de uiteindelijke afronding van een cryptografische bewerkingssequentie signaleert. Vraag Q-32da2433b15ba3a9 (open)

Gebruik

De functie Csm_MainFunction wordt cyclisch aangeroepen om aangevraagde cryptografische jobs te verwerken [SWS_Csm_00479]. Deze heeft geen overdrachtsparameters (void) en levert geen retourwaarde op [SWS_Csm_00479]. De declaratie is beschikbaar via de header SchM_Csm.h [SWS_Csm_00479].

Taken en interactie

In het kader van haar periodieke uitvoering controleert de functie de interne wachtrijen op openstaande jobs en draagt deze over aan de onderliggende laag CRYIF [SWS_Csm_00479].

Instantiëring en aanroepcontext

Per geconfigureerde instantie wordt een specifieke functie van de vorm Csm_MainFunction_<shortName> geïmplementeerd, waarbij <shortName> overeenkomt met de korte naam van de configuratiecontainer in de ECU-configuratie [SWS_Csm_00479]. De cyclische aanroep vindt vermoedelijk volgens plan plaats door de BSW-scheduler (SchM) in een periodieke taak, aangezien de interface via SchM_Csm.h ter beschikking wordt gesteld. Vraag Q-ffb62942b1f517b3 (open)

Foutafhandeling en randvoorwaarden

Specifieke foutcodes, DET- of DEM-meldingen en expliciete re-entrantievoorschriften worden in het onderhavige specificatie-uittreksel niet beschreven [SWS_Csm_00479].

De configureerbare callback-functie <Csm_ Application Callback Notification> dient ertoe een applicatie via de Crypto Service Manager (CSM) synchroon te informeren over het einde van een verwerkingsopdracht [SWS_Csm_00971]. De identifier van de functie is niet vast voorgeschreven, maar wordt via de configuratieparameter {Csm Job/ Csm Job Primitive Callback Ref}/Csm Callback Func projectspecifiek vastgelegd [SWS_Csm_00971]. De interface heeft het service-ID 0x82 en wordt via het headerbestand Csm.h beschikbaar gesteld [SWS_Csm_00971].

De signatuur heeft geen returnwaarde (void) en geeft twee ingangsparameters ter evaluatie door aan de applicatie [SWS_Csm_00971]:

• jobId (uint32): Duidt het unieke ID aan van de cryptografische opdracht waarvan de voltooiing de callback heeft getriggerd [SWS_Csm_00971].
• result (Crypto_ResultType): Geeft het resultaat respectievelijk de status van de uitgevoerde cryptografische operatie door [SWS_Csm_00971].

Met betrekking tot concurrency is de notificatiefunctie gespecificeerd als re-entrant [SWS_Csm_00971]. Specifieke DET- of DEM-foutcodes worden voor de callback zelf niet gedefinieerd; opgetreden fouten van de voorafgaande operatie moeten direct via result worden geëvalueerd [SWS_Csm_00971]. Aangezien de interface re-entrant is verklaard, zou de implementatie aan applicatiezijde vermoedelijk zo moeten zijn ontworpen dat deze gelijktijdige notificaties voor verschillende opdrachten thread-safe kan verwerken. Vraag Q-79504ea3461f8d61 (open)

Het enumeratietype Crypto_AlgorithmModeType specificeert volgens [SWS_Csm_01048] de bedrijfsmodus van een cryptografisch algoritme. Het is beschikbaar via het headerbestand Crypto_GeneralTypes.h en dient voor de gestandaardiseerde configuratie en runtime-selectie van cryptografische methoden in de Crypto Service Manager.

Gebruik en waardebereik:

• Klassieke blokcijfermodi: ondersteund worden onder andere CRYPTO_ALGOMODE_ECB, CRYPTO_ALGOMODE_CBC, CRYPTO_ALGOMODE_CFB, CRYPTO_ALGOMODE_OFB, CRYPTO_ALGOMODE_CTR, CRYPTO_ALGOMODE_GCM en CRYPTO_ALGOMODE_XTS [SWS_Csm_01048].
• Asymmetrische methoden en padding: inbegrepen zijn modi voor versleuteling en handtekeningen zoals CRYPTO_ALGOMODE_RSAES_OAEP, CRYPTO_ALGOMODE_RSAES_PKCS1_v1_5, CRYPTO_ALGOMODE_RSASSA_PSS en CRYPTO_ALGOMODE_RSASSA_PKCS1_v1_5 [SWS_Csm_01048].
• Overige bedrijfsmodi: het waardebereik omvat aantallen ronden (CRYPTO_ALGOMODE_8ROUNDS, CRYPTO_ALGOMODE_12ROUNDS, CRYPTO_ALGOMODE_20ROUNDS), MAC-methoden (CRYPTO_ALGOMODE_HMAC, CRYPTO_ALGOMODE_CMAC, CRYPTO_ALGOMODE_GMAC), toevalsbitgeneratoren (CRYPTO_ALGOMODE_CTRDRBG), SipHash-varianten en curvedefinities zoals CRYPTO_ALGOMODE_PXXXR1 [SWS_Csm_01048].
• Speciale statussen: met CRYPTO_ALGOMODE_NOT_SET (0x00) wordt een niet-ingestelde algoritmesleutel gesignaleerd, terwijl CRYPTO_ALGOMODE_CUSTOM (0xff) fabrikantspecifieke bedrijfsmodi toestaat [SWS_Csm_01048].

Interpretatie: aangezien het bij Crypto_AlgorithmModeType om een zuivere enumeratie gaat, heeft het type geen eigen foutafhandeling via DET of DEM en is het niet onderworpen aan re-entrancy-voorschriften. Vraag Q-3d2e905dda6531ac (open) Foutcontroles en beperkingen met betrekking tot de aanroepcontext vloeien pas voort uit de CSM-functies waaraan waarden van dit type als parameter worden overgedragen.

Gebruik en opbouw van Crypto_JobType

De structuur Crypto_JobType bundelt alle relevante sturings-, toestands- en buffergegevens voor de uitvoering van een cryptografische opdracht in de Crypto Service Manager en is beschikbaar via Crypto_GeneralTypes.h [SWS_Csm_01013].

Tot de centrale elementen van de structuur behoren [SWS_Csm_01013]:

• jobId: unieke identificatie van de job.
• jobState: representeert de actuele uitvoeringsstatus van de job.
• jobPrimitiveInputOutput: verwijst naar de specifieke in- en uitvoergegevens van het primitief.
• jobPrimitiveInfo: pointer naar constante aanvullende informatie over het gekozen crypto-primitief.
• jobPriority: bepaalt de uitvoeringsprioriteit, waarbij een hogere waarde een hogere urgentie aangeeft.
• jobRedirectionInfoRef: pointer naar optionele gegevens voor het omleiden van sleutels als in- en uitvoerwaarden.

Samenspel en interfacerelaties

De structuurvelden cryptoKeyId en targetCryptoKeyId refereren aan de te gebruiken sleutels in de crypto-driver; conform de specificatie worden deze identifiers door het Crypto Interface beschreven [SWS_Csm_01013]. Interpretatie: via jobPriority zal vermoedelijk de volgorde bij het inplannen en afhandelen van gelijktijdige opdrachten in wachtrijen worden geregeld. Vraag Q-439432c5631948fb (open)

Het enumeratietype Crypto_JobStateType definieert de actuele verwerkingsstatus van een cryptografische job in de CSM [SWS_Csm_01028]. Het wordt via het headerbestand Crypto_GeneralTypes.h beschikbaar gesteld en maakt onderscheid tussen twee hoofdtoestanden van de levenscyclus van de job [SWS_Csm_01028]:

• CRYPTO_JOBSTATE_IDLE (0x00): Markeert de rusttoestand van de job. Deze toestand wordt initieel na de aanroep van Csm_Init() aangenomen of zodra een Finish-operatie (toestand „Finish”) is voltooid [SWS_Csm_01028].
• CRYPTO_JOBSTATE_ACTIVE (0x01): Geeft aan dat de job actief wordt verwerkt en dat er al invoergegevens zijn verwerkt of dat er tussenresultaten beschikbaar zijn. Deze toestand wordt bereikt zodra een Start- of Update-operatie succesvol is afgerond [SWS_Csm_01028].

Met betrekking tot het gebruik en de wisselwerking weerspiegelt het type de voortgang van streaming- of meertraps krypto-operaties [SWS_Csm_01028]. Een overgang naar CRYPTO_JOBSTATE_ACTIVE signaleert dat de cryptografische context is geïnitialiseerd of doorlopend tussenresultaten vasthoudt, terwijl de overgang naar CRYPTO_JOBSTATE_IDLE de beëindiging markeert en aangeeft dat de job gereed is voor nieuwe afhandelingen [SWS_Csm_01028].

De datastructuur Crypto_JobPrimitiveInfoType bundelt aanvullende informatie over een crypto-job en de onderliggende primitieven daarvan [SWS_Csm_01012]. Deze is in de Classic-AUTOSAR-stack beschikbaar via het headerbestand Crypto_GeneralTypes.h [SWS_Csm_01012].

Onderdelen en gebruik

Volgens specificatie [SWS_Csm_01012] is de structuur samengesteld uit de volgende velden:

• callbackId (uint32): Interne identifier van de callback-functie die door de module CSM wordt aangeroepen zodra de uitvoering van de geconfigureerde service is beëindigd [SWS_Csm_01012].
• primitiveInfo (const Crypto_PrimitiveInfoType*): Pointer naar een datastructuur met de verdere configuratie van de crypto-primitieven [SWS_Csm_01012].
• cryIfKeyId (uint32): Identificatie van de sleutel voor de crypto-interface (CryIf) [SWS_Csm_01012].
• processingType (Crypto_ProcessingType): Definieert het uitvoeringsgedrag en bepaalt of de opdracht synchroon dan wel asynchroon wordt verwerkt [SWS_Csm_01012].

Uitvoeringscontext en semantiek

Het veld processingType bestuurt de synchrone of asynchrone semantiek van de opdrachtverwerking [SWS_Csm_01012]. De via callbackId vastgelegde callback-functie is daarbij vermoedelijk vooral relevant in de asynchrone modus om de aanroeper te informeren over het einde van de service, terwijl de pointer primitiveInfo naar een geldige primitief-configuratie moet verwijzen [SWS_Csm_01012]. Vraag Q-791dae4fb6a83f99 (open)

Gebruik

De datastructuur Crypto_AlgorithmInfoType bepaalt de exacte configuratie van een cryptografisch algoritme en wordt via het headerbestand Crypto_GeneralTypes.h beschikbaar gesteld [SWS_Csm_01008]. Deze is opgebouwd uit de volgende elementen:

• family (Crypto_AlgorithmFamilyType): De primaire familie van het algoritme.
• secondaryFamily (Crypto_AlgorithmFamilyType): De secundaire familie van het algoritme.
• keyLength (uint32): De te gebruiken sleutellengte in bits.
• mode (Crypto_AlgorithmModeType): De beoogde bedrijfsmodus van het algoritme.

Niet elk algoritme vereist de volledige toekenning van alle structuurelementen [SWS_Csm_01008]. Afhankelijk van de aard van de cryptografische operatie kunnen afzonderlijke velden zoals de bedrijfsmodus of een secundaire familie ongebruikt blijven.

Beperkingen en foutafhandeling

Volgens [SWS_Csm_01008] mogen in AUTOSAR uitsluitend geldige combinaties van de structuurelementen voorkomen. Niet-toegestane combinaties – bijvoorbeeld niet-overeenkomende bedrijfsmodi of ontoelaatbare sleutellengtes voor een specifieke algoritmenfamilie – zijn niet toegestaan. De controle op geldigheid van de parametercombinatie vindt vermoedelijk plaats door de configuratietools of bij service-aanroepen door de CSM. Vraag Q-da4984170bba173c (open)

De structuur Crypto_PrimitiveInfoType dient in de Crypto Service Manager (CSM) voor het beschikbaar stellen van basismetatadata over een cryptografische primitieve ([SWS_Csm_01011]). Deze wordt via het headerbestand Crypto_GeneralTypes.h gedeclareerd en bundelt de statische karakteristieken van de desbetreffende operatie ([SWS_Csm_01011]).

De structuur is opgebouwd uit twee elementen ([SWS_Csm_01011]):

• service (type: const Crypto_ServiceInfoType): Bepaalt de gebruikte cryptografische service via een enumeratie, bijvoorbeeld een versleuteling (Encrypt) ([SWS_Csm_01011]).
• algorithm (type: const Crypto_AlgorithmInfoType): Bevat de detailinformatie over het gebruikte algoritme ([SWS_Csm_01011]).

Aangezien beide elementen als const zijn getypeerd, betreft het vermoedelijk alleen-lezen configuratie- of metadata die tijdens de configuratietijd worden vastgelegd en tijdens runtime door drivers of de CSM zuiver lezend worden geëvalueerd ([SWS_Csm_01011]). Vraag Q-6d53291f7fb8cfe6 (open) Specifieke foutcodes, foutafhandelingsroutines of concurrencybeperkingen zijn voor dit datastructuurtype niet gedefinieerd.

Het enumeratietype Crypto_OperationModeType definieert conform [SWS_Csm_01029] de uit te voeren verwerkingsfase bij cryptografische bewerkingen. Het type is opgebouwd als een bitmasker waarvan de eerste drie bits de kernstappen Start (bit 1 / 0x01), Update (bit 2 / 0x02) en Finish (bit 3 / 0x04) weerspiegelen.

Via de enumeratiewaarden worden de verschillende uitvoerings- en levenscyclusfasen van een crypto-job bestuurd [SWS_Csm_01029]:

• CRYPTO_OPERATIONMODE_START (0x01): Initialiseert de job; de toestand wordt gereset, waardoor eerdere invoergegevens en tussenresultaten worden gewist.
• CRYPTO_OPERATIONMODE_UPDATE (0x02): Verwerkt invoergegevens voor de berekening van tussenresultaten.
• CRYPTO_OPERATIONMODE_FINISH (0x04): Rondt de berekeningen van de cryptografische bewerking definitief af.
• CRYPTO_OPERATIONMODE_STREAMSTART (0x03): Combineert Start en Update voor streamingscenario's.
• CRYPTO_OPERATIONMODE_SINGLECALL (0x07): Verenigd Start, Update en Finish voor volledige verwerking in één enkele aanroep.

Daarnaast ondersteunt het type workspace-management bij onderbreekbare processen: met CRYPTO_OPERATIONMODE_SAVE_CONTEXT (0x08) stelt de crypto-driver de actuele workspace-context van de applicatie beschikbaar, terwijl CRYPTO_OPERATIONMODE_RESTORE_CONTEXT (0x10) een eerder opgeslagen toestand in de interne workspace van de driver herstelt [SWS_Csm_01029]. Het type wordt via de header Rte_Csm_Type.h ter beschikking gesteld.

Het opsommingstype Crypto_VerifyResultType definieert het functionele resultaat van verificatieoperaties in de module CSM [SWS_Csm_01024]. Het wordt via het headerbestand Rte_Csm_Type.h beschikbaar gesteld en dient om vast te stellen of een cryptografische vergelijking succesvol is afgerond [SWS_Csm_01024].

Waardebereik en semantiek

De enumeratie omvat volgens [SWS_Csm_01024] twee discrete waarden voor het weergeven van de vergelijkingsstatus:

• CRYPTO_E_VER_OK (waarde 0x00 resp. 0): Het resultaat van de verificatie is „true”; de twee vergeleken elementen zijn dus identiek [SWS_Csm_01024].
• CRYPTO_E_VER_NOT_OK (waarde 0x01 resp. 1): Het resultaat van de verificatie is „false”; de vergeleken elementen zijn niet identiek [SWS_Csm_01024].

Het type scheidt de functionele uitspraak over de gegevensovereenstemming van de algemene uitvoeringsstatus van een operatie. Als interpretatie betekent dit dat ook een foutloos uitgevoerde controleroutine de returnwaarde CRYPTO_E_VER_NOT_OK kan opleveren wanneer gegevens van elkaar afwijken [SWS_Csm_01024].

Gebruik en beperkingen

Aangezien het datatype via Rte_Csm_Type.h is gedeclareerd, zal het vermoedelijk vooral als uitgangsparameter voor verificatieservices van de CSM worden gebruikt [SWS_Csm_01024]. Vraag Q-067a1d2b36ffe56b (open) Specifieke foutafhandelingen zoals DET- of DEM-meldingen en voorschriften met betrekking tot re-entrantie of concurrency zijn niet vastgelegd voor het type zelf [SWS_Csm_01024].

Het enumeratietype Crypto_ResultType dient als specifiek returntype voor functies van de AUTOSAR-cryptostack en is beschikbaar via de header Rte_Csm_Type.h [SWS_Csm_91044]. Het breidt het klassieke retourschema uit met gedifferentieerde fout- en statusmeldingen voor cryptografische operaties [SWS_Csm_91044].

Naast de reguliere successtatus E_OK (0x00) en de algemene fout E_NOT_OK (0x01) definieert het type de volgende specifieke fouttoestanden [SWS_Csm_91044]:

• Verloop- en servicetoestanden: CRYPTO_E_BUSY (0x02) markeert een nog bezette service, CRYPTO_E_JOB_CANCELED (0x0C) het afbreken van een opdracht en CRYPTO_E_ENTROPY_EXHAUSTED (0x04) een uitgeputte entropiebron van de toevalsgenerator [SWS_Csm_91044].
• Sleutel- en toegangsproblemen: Gespecificeerd zijn toegangsweigeringen bij lezen (CRYPTO_E_KEY_READ_FAIL, 0x06) of schrijven (CRYPTO_E_KEY_WRITE_FAIL, 0x07), ontbrekende sleutels (CRYPTO_E_KEY_NOT_AVAILABLE, 0x08), ongeldige sleutels (CRYPTO_E_KEY_NOT_VALID, 0x09), onjuiste sleutelgroottes (CRYPTO_E_KEY_SIZE_MISMATCH, 0x0A) en niet-geïnitialiseerde bronsleutelelementen (CRYPTO_E_KEY_EMPTY, 0x0D) [SWS_Csm_91044].

Interpretatie: Aanroepende componenten zullen deze retourcodes vermoedelijk evalueren om situatieafhankelijk onderscheid te maken tussen tijdelijke wachttoestanden en permanente configuratiefouten. Vraag Q-68cfedad7880908c (open)

Gebruik en structuur van Csm_HashDataType

Het datatype Csm_HashDataType is volgens [SWS_Csm_01920] gedefinieerd als array met elementen van het basistype uint8. Het dient als databuffer voor de opslag van de ingangsgegevens die moeten worden onderworpen aan een hashwaardeberekening in de Crypto Service Manager. De lengte van het veld is zodanig ontworpen dat deze toereikend is voor de volledige opname van de te hashen gegevens [SWS_Csm_01920].

Configuratie en variantvorming

De daadwerkelijke dimensionering van de array wordt gestuurd via de configuratieparameter CsmHashDataMaxLength, die gedefinieerd is onder het pad Csm/CsmPrimitives/CsmHash/CsmHashConfig [SWS_Csm_01920]. Hierdoor wordt gewaarborgd dat het geheugengebied passend is ontworpen voor de maximaal verwachte hoeveelheid gegevens van de desbetreffende hashconfiguratie.

Daarnaast bestaat er een cryptografische variantvorming volgens het patroon Csm_HashDataType_{Crypto}, waarbij de tijdelijke aanduiding {Crypto} via de SHORT-NAME van de desbetreffende primitive-configuratie onder Csm/CsmPrimitives wordt opgelost [SWS_Csm_01920]. Dit maakt primitivespecifieke bufferstructuren in het systeem mogelijk.

Integratie en randvoorwaarden

Het type wordt beschikbaar gesteld via de header Rte_Csm_Type.h [SWS_Csm_01920]. Dit duidt er vermoedelijk op dat het type bedoeld is voor de gestandaardiseerde gegevensoverdracht via RTE-interfaces tussen softwarecomponenten en de CSM. Vraag Q-4240a8394cdd746d (open) Gebruikers moeten er bij de bufferbezetting op letten dat gegevens de geconfigureerde bovengrens CsmHashDataMaxLength niet mogen overschrijden, om overflows bij de hashberekening te voorkomen.

Gebruik en structuur van Csm_HashResultType

Het datatype Csm_HashResultType representeert een array van uint8-elementen en dient als voldoende gedimensioneerd geheugengebied voor het opslaan van de gegevens van een hash-resultaat [SWS_Csm_00912].

De concrete bufferlengte van de array is configureerbaar en wordt vastgelegd via de configuratieparameter CsmHashResultLength onder Csm/CsmPrimitives/CsmHash/CsmHashConfig/CsmHashResultLength [SWS_Csm_00912]. Daarmee richt de grootte van het datatype zich direct naar de uitvoerlengte van het betreffende cryptografische hash-algoritme.

De typedefinitie is onderhevig aan een naamvariatie volgens het patroon Csm_HashResultType_{Crypto}, waarbij de identifier {Crypto} wordt gesubstitueerd door de korte naam van het geconfigureerde primitief (ecuc/Csm/CsmPrimitives.SHORT-NAME) [SWS_Csm_00912].

Het datatype wordt beschikbaar gemaakt via de header Rte_Csm_Type.h [SWS_Csm_00912]. Interpretatie: Op grond van de beschikbaarstelling via Rte_Csm_Type.h is het type vermoedelijk vooral bedoeld om in softwarecomponenten of aan RTE-interfaces als getypte resultaatbuffer voor hash-retourwaarden te worden gebruikt. Vraag Q-4ff10e08b6a5c8c0 (open)

Het datatype Csm_MacGenerateDataType dient als byte-array voor de opslag van de invoergegevens waaruit een Message Authentication Code (MAC) moet worden berekend [SWS_Csm_00935].

Gebruik en typestructuur

Het element is volgens [SWS_Csm_00935] gespecificeerd als een array met elementen van het basistype uint8. De typenaam is onderhevig aan een cryptografische naamvariatie volgens het schema Csm_MacGenerateDataType_{Crypto}, waarbij het achtervoegsel overeenkomt met de geconfigureerde korte naam van de desbetreffende primitive [SWS_Csm_00935]. De dimensionering van het veld wordt statisch bepaald via de configuratieparameter CsmMacGenerateDataMaxLength, waardoor wordt gewaarborgd dat de array voldoende geheugenruimte biedt voor de te verwerken gegevens [SWS_Csm_00935].

Integratie en interfaces

Het type wordt beschikbaar gesteld via het headerbestand Rte_Csm_Type.h en verbindt de datastructuren met de AUTOSAR-RTE [SWS_Csm_00935]. Aanroepende softwarecomponenten (SWC's) of basissoftwaremodules kunnen dit type gebruiken om getypeerde databuffers voor MAC-generatiediensten van de CSM te declareren.

Beperkingen

Aangezien de veldgrootte vast via de maximale lengte is geconfigureerd, dient op gebruikersniveau vermoedelijk te worden gewaarborgd dat de payload deze grens niet overschrijdt, omdat het statische type niet voorziet in een dynamische lengteaanpassing [SWS_Csm_00935]. Vraag Q-2010ffc7191f874a (open)

Het datatype Csm_MacGenerateResultType representeert volgens [SWS_Csm_00927] een byte-array (elementtype uint8) die dient voor de opname van de resultaatgegevens van een gegenereerde Message Authentication Code (MAC).

Gebruik en dimensionering

De specificatie definieert de array als voldoende lang om de gegevens van de MAC op te slaan ([SWS_Csm_00927]). De werkelijke buffergrootte wordt vastgelegd via de configuratieparameter CsmMacGenerateResultLength, die wordt geconfigureerd onder het pad Csm/CsmPrimitives/CsmMacGenerate/CsmMacGenerateConfig ([SWS_Csm_00927]). Bovendien is het type onderhevig aan een cryptografische variatie via de korte naam van het primitief ({Crypto} resp. ecuc/Csm/CsmPrimitives.SHORT-NAME) volgens [SWS_Csm_00927].

Beschikbaarheid en interface

Het type wordt ter beschikking gesteld via de header Rte_Csm_Type.h ([SWS_Csm_00927]). Dit toont aan dat het primair is ontworpen voor de getypeerde gegevensoverdracht via de RTE-interface voor het beschikbaar stellen van de berekende MAC-waarde.

Beperkingen

Aangezien het om een statische typedefinitie gaat, hangt de concrete instantiëring af van de vooraf geconfigureerde MAC-lengte; verdere parameters, foutcodes of concurrency-eisen zijn voor dit datatype zelf niet gespecificeerd ([SWS_Csm_00927]).

Het datatype Csm_MacVerifyDataType is gespecificeerd als een array van uint8-elementen en dient als buffer voor de opslag van de gegevens waarvoor een Message Authentication Code (MAC) moet worden geverifieerd [SWS_Csm_00802].

Voor het gebruik en de configuratie van dit type gelden de volgende bepalingen:

• Buffergrootte: De arraygrootte richt zich naar de configuratieparameter CsmMacVerifyDataMaxLength in de container Csm/CsmPrimitives/CsmMacVerify/CsmMacVerifyConfig. Hierdoor wordt gewaarborgd dat de array voldoende gedimensioneerd is om de te verifiëren invoergegevens volledig op te nemen [SWS_Csm_00802].
• Variantie en naamgeving: De definitie bevat het variantiecriterium Crypto={ecuc/Csm/CsmPrimitives.SHORT-NAME}, waardoor de concrete C-type-identifier modulespecifiek in de vorm Csm_MacVerifyDataType_{Crypto} wordt gegenereerd [SWS_Csm_00802].
• Interface-integratie: Het type wordt geëxporteerd via het headerbestand Rte_Csm_Type.h [SWS_Csm_00802]. Interpretatie: De beschikbaarstelling in deze header wijst erop dat het type vermoedelijk primair bestemd is voor de door de RTE ondersteunde interfacecommunicatie tussen softwarecomponenten en de CSM. Vraag Q-c49670b3de0ba19c (open)

Applicatieontwikkelaars moeten er rekening mee houden dat de maximale lengte van de verifieerbare payload beperkt is door de statische configuratie van de primitieven en dat invoergegevens deze buffercapaciteit niet mogen overschrijden [SWS_Csm_00802].

Gebruik en structuur

Het type Csm_MacVerifyCompareType is conform [SWS_Csm_00803] gedefinieerd als een array van uint8-elementen. Het dient ertoe de te verifiëren Message Authentication Code (MAC) op te nemen, die vergeleken moet worden met de in het kader van een cryptografische bewerking berekende MAC.

De beschikbaarstelling van het type vindt plaats via de header Rte_Csm_Type.h voor de RTE-interface [SWS_Csm_00803]. De concrete typeaanduiding is onderhevig aan een naamvariatie via de primitiefnaam volgens het patroon Csm_MacVerifyCompareType_{Crypto}, waarbij {Crypto} wordt vervangen door de korte naam van het primitief (ecuc/Csm/CsmPrimitives.SHORT-NAME).

Configuratie en dimensionering

De grootte van de array wordt conform [SWS_Csm_00803] bepaald volgens de expressie CsmMacVerifyCompareLength/8 uit de configuratie (ecuc(Csm/CsmPrimitives/CsmMacVerify/CsmMacVerifyConfig/CsmMacVerifyCompareLength)). Dit weerspiegelt de lengte van de MAC-vergelijkingswaarde in bytes.

Foutafhandeling en randvoorwaarden

Als zuivere typedefinitie voor een data-array heeft Csm_MacVerifyCompareType geen eigen retourwaarden en genereert het geen directe foutcodes of DET-/DEM-gebeurtenissen. Er gelden echter de volgende toepassingsgerelateerde randvoorwaarden:

• Bufferbeschikbaarstelling: Aanroepers zijn er vermoedelijk voor verantwoordelijk om de array vóór de overdracht aan een verificatiefunctie volledig te initialiseren met de ontvangen referentie-MAC. Vraag Q-94b98958fd778057 (open)
• Gelijktijdigheid: Aangezien het om een datastructuur gaat, is het type zelf re-entrant. Concurrerende lees- en schrijftoegang van meerdere taken tot dezelfde array-instantie leidt zonder synchronisatie vermoedelijk echter tot corruptie. Vraag Q-148c0a523da7b402 (open)

Het type Csm_EncryptDataType definieert een byte-array van uint8-elementen, die dient voor de opname van de te versleutelen gegevens [SWS_Csm_01921]. Het wordt beschikbaar gesteld via het headerbestand Rte_Csm_Type.h en maakt voor softwarecomponenten de getypeerde gegevensoverdracht naar de cryptografische diensten van de module mogelijk [SWS_Csm_01921].

Structuur en configuratie

• Array-elementen: de elementen zijn van het basistype uint8 [SWS_Csm_01921].
• Grootte: de arraylengte richt zich naar de configuratieparameter CsmEncryptDataMaxLength onder de desbetreffende primitive-configuratie CsmEncryptConfig [SWS_Csm_01921].
• Naamvariatie: de typenaam varieert afhankelijk van de primitive volgens het schema Csm_EncryptDataType_{Crypto}, waarbij {Crypto} overeenkomt met de korte naam (SHORT-NAME) van de geconfigureerde CSM-primitive [SWS_Csm_01921].

Gebruik en beperkingen

Als zuivere typedefinitie bezit het element geen eigen re-entrancy of foutafhandeling. Aangezien de arraygrootte vast gekoppeld is aan de maximale buffergrootte van de configuratie, dient de aanroeper bij het vullen er als interpretatie vermoedelijk voor zorg te dragen dat de beschikbaar gestelde gegevens de buffergrens CsmEncryptDataMaxLength niet overschrijden [SWS_Csm_01921]. Vraag Q-4bf70d603b5679d3 (open)

Gebruik en doel

Het datatype Csm_EncryptResultType is gespecificeerd als byte-array met het elementtype uint8 en dient voor de opname van de cijfergegevens (cijferresultaat) van een versleutelingsproces ([SWS_Csm_01922]). De array moet volgens de specificatie zodanig worden ontworpen dat deze lang genoeg is om alle gegevens van het cijfer op te nemen ([SWS_Csm_01922]).

Configuratie en varianten

De definitie van het datatype is onderhevig aan een variantvorming aan de hand van de geconfigureerde cryptoprimitives. Voor elke primitive wordt een typespecifieke identifier volgens het schema Csm_EncryptResultType_{Crypto} gevormd, waarbij {Crypto} overeenkomt met de korte naam van de desbetreffende primitive ([SWS_Csm_01922]). De statische veldgrootte van de array wordt bepaald via de configuratieparameter CsmEncryptResultMaxLength onder Csm/CsmPrimitives/CsmEncrypt/CsmEncryptConfig/ ([SWS_Csm_01922]).

Integratie en randvoorwaarden

Het datatype wordt geëxporteerd via het headerbestand Rte_Csm_Type.h ([SWS_Csm_01922]). Interpretatie: vanwege de beschikbaarstelling via Rte_Csm_Type.h is het type vermoedelijk ontworpen voor de gestandaardiseerde gegevensoverdracht tussen applicatiesoftwarecomponenten en de Crypto Service Manager via RTE-poorten. Vraag Q-6dc06520e3fd9dc6 (open) Gebruikers moeten bij de bufferterbeschikkingstelling waarborgen dat de cijferresultaten de geconfigureerde maximale lengte CsmEncryptResultMaxLength niet overschrijden ([SWS_Csm_01922]).

Gebruik en datastructuur

Het type Csm_DecryptDataType is in de specificatie van de Crypto Service Manager gedefinieerd als array met elementen van het basistype uint8 [SWS_Csm_01923]. Het dient als specifieke geheugenbuffer voor de te ontsleutelen invoergegevens [SWS_Csm_01923]. Het ontwerp van de array is bindend zodanig voorgeschreven dat de capaciteit ervan altijd lang genoeg moet zijn om de desbetreffende gegevens volledig op te nemen [SWS_Csm_01923].

Configuratie en variantvorming

De dimensionering van de array vindt statisch plaats via de configuratieparameter ecuc(Csm/CsmPrimitives/CsmDecrypt/CsmDecryptConfig/CsmDecryptDataMaxLength) [SWS_Csm_01923]. Daarnaast is het datatype onderhevig aan een cryptografische variantie volgens Crypto={ecuc/Csm/CsmPrimitives.SHORT-NAME} [SWS_Csm_01923]. Hierdoor wordt de type-identifier voor de concrete primitive-configuratie met de bijbehorende korte naam geïnstantieerd tot Csm_DecryptDataType_{Crypto} [SWS_Csm_01923].

Integratie en randvoorwaarden

De definitie wordt via het headerbestand Rte_Csm_Type.h beschikbaar gesteld voor het totale systeem [SWS_Csm_01923]. Interpretatie: de opname in Rte_Csm_Type.h doet vermoeden dat het type vooral bestemd is voor getypeerde poorten en de gegevensuitwisseling tussen softwarecomponenten en de module CSM via de RTE. Vraag Q-6dcc31d5d7258088 (open) Aangezien het om een datastructuur en niet om een functie gaat, zijn in de omvang van de specificatie noch synchrone of asynchrone aanroepsemantiek, noch re-entrancy-voorschriften of specifieke DET-foutmeldingen gedefinieerd [SWS_Csm_01923].

Het datatype Csm_DecryptResultType is volgens [SWS_Csm_01924] in de module Csm gedefinieerd als array met elementen van het type uint8. Het dient als databuffer voor de opslag van de resultaatgegevens van een ontsleutelde platte tekst en moet voldoende gedimensioneerd zijn om de volledige platte tekst op te nemen.

Voor de configuratie, beschikbaarstelling en structurering van het type gelden volgens [SWS_Csm_01924] de volgende bepalingen:

• Headerbeschikbaarheid: de definitie van het datatype wordt ter beschikking gesteld via het headerbestand Rte_Csm_Type.h.
• Dimensionering van de buffer: de grootte van de array wordt voorgeschreven via de configuratieparameter CsmDecryptResultMaxLength (pad Csm/CsmPrimitives/CsmDecrypt/CsmDecryptConfig/CsmDecryptResultMaxLength), waardoor de maximale geheugenruimte voor het ontsleutelingsresultaat statisch wordt vastgelegd.
• Cryptografische variantvorming: de typenaam is onderhevig aan een primitive-variantvorming volgens het schema Csm_DecryptResultType_{Crypto}, waarbij de specifieke vorm wordt gestuurd via het configuratie-element Crypto={ecuc/Csm/CsmPrimitives.SHORT-NAME}.

Wat betreft aanroepcontext, gelijktijdigheid en foutafhandeling bevat [SWS_Csm_01924] uitsluitend de typedefinitie zonder eigen functielogica. Interpretatie: het type dient vermoedelijk vooral in gebruikende softwarecomponenten als geheugenstructuur om uitvoergegevens van cryptografische ontsleutelingsbewerkingen van de CSM op te nemen. Vraag Q-54c836ed946ee1f2 (open) Specifieke DET- of DEM-foutcodes zijn voor dit datatype niet gedefinieerd; configuratieverantwoordelijken moeten echter waarborgen dat de geconfigureerde maximale lengte toereikend is voor alle te verwerken platte teksten.

Gebruik en typedefinitie

Het datatype Csm_AEADEncryptPlaintextType dient volgens [SWS_Csm_01925] als databuffer voor de platte tekst die in het kader van een AEAD-versleutelingsbewerking (Authenticated Encryption with Associated Data) moet worden verwerkt. Het type is gedefinieerd als byte-array met het elementtype uint8 en biedt voldoende geheugenruimte om de te versleutelen platte tekst volledig op te nemen.

Dimensionering en variantvorming

De concrete buffergrootte is niet star voorgeschreven, maar richt zich naar de configuratieparameter CsmAEADEncryptPlaintextMaxLength uit de configuratie van de desbetreffende primitive ([SWS_Csm_01925]). Bovendien is het type onderhevig aan een naam- en structuurvariatie: afhankelijk van de geconfigureerde cryptoprimitive wordt de identifier uitgebreid met de korte naam van de primitive (Csm_AEADEncryptPlaintextType_{Crypto}).

Integratie en interface

Volgens [SWS_Csm_01925] wordt het type via de header Rte_Csm_Type.h beschikbaar gesteld. Dit wijst op de interpretatie dat het type vooral in de context van de AUTOSAR-RTE voor applicatiesoftwarecomponenten ter beschikking wordt gesteld om getypeerde platte-tekstgegevens aan cryptografische services van de CSM over te dragen. Aangezien het om een zuivere typedeclaratie gaat, definieert de specificatie geen eigen foutcodes of re-entrancy-voorschriften op gegevenstypeniveau.

Het gegevenstype Csm_AEADEncryptAssociatedDataType definieert een byte-array van elementen van het basistype uint8, die als buffer dient voor het opnemen van de header- respectievelijk geassocieerde aanvullende gegevens bij AEAD-versleutelingsoperaties [SWS_Csm_01928]. Het type wordt via het headerbestand Rte_Csm_Type.h beschikbaar gesteld en maakt de getypeerde gegevensuitwisseling via de AUTOSAR-RTE-interface van de Crypto Service Manager mogelijk [SWS_Csm_01928].

De dimensionering en verschijningsvorm van het type zijn afhankelijk van de configuratie van de cryptografische primitive [SWS_Csm_01928]:

• Arraygrootte: De buffergrootte wordt bepaald door de configuratieparameter CsmAEADEncryptAssociatedDataMaxLength binnen de configuratie Csm/CsmPrimitives/CsmAEADEncrypt/CsmAEADEncryptConfig, waardoor gewaarborgd wordt dat de array voldoende lang is voor de headergegevens [SWS_Csm_01928].
• Naamvariatie: Het element is onderhevig aan een cryptografiespecifieke naamvariatie Csm_AEADEncryptAssociatedDataType_{Crypto}, waarbij de tijdelijke aanduiding {Crypto} overeenkomt met de korte naam van de desbetreffende primitive uit CsmPrimitives.SHORT-NAME [SWS_Csm_01928].

Aanroepers moeten er bij het vullen van de array voor zorgen dat de werkelijke lengte van de over te dragen headergegevens de geconfigureerde maximale grootte niet overschrijdt [SWS_Csm_01928]. Interpretatie: Aangezien geassocieerde gegevens bij AEAD-procedures onversleuteld blijven, maar wel geauthenticeerd worden, dient het gegevenstype er vermoedelijk vooral voor protocolspecifieke metadata consistent tussen applicatie en CSM over te dragen. Vraag Q-26b724044c51253f (open)

Het gegevenstype Csm_AEADEncryptCiphertextType dient volgens [SWS_Csm_01927] als byte-array voor de opslag van de cijfertekstgegevens bij cryptografische AEAD-versleutelingsoperaties in de Classic-AUTOSAR-module Csm.

De specificatie definieert het gegevenselement als een array van elementen van het basistype uint8 [SWS_Csm_01927]. De vaste buffergrootte wordt via de configuratieparameter CsmAEADEncryptCiphertextMaxLength binnen het configuratiepad Csm/CsmPrimitives/CsmAEADEncrypt/CsmAEADEncryptConfig bepaald [SWS_Csm_01927]. Conform de eis moet de array lang genoeg bemeten zijn om de volledige gegevens van de cijfertekst op te nemen [SWS_Csm_01927].

De type-identifier vertoont een van de primitive afhankelijke naamvariatie: via het configuratie-attribuut Crypto={ecuc/Csm/CsmPrimitives.SHORT-NAME} wordt de concrete typenaam geëxpandeerd naar Csm_AEADEncryptCiphertextType_{Crypto} [SWS_Csm_01927]. Deze definitie wordt voor applicatiesoftwarecomponenten en de CSM beschikbaar gesteld via het headerbestand Rte_Csm_Type.h [SWS_Csm_01927].

In het praktische gebruik declareren aanroepende componenten vermoedelijk overeenkomstige buffers om de versleutelingsresultaten van een AEAD-operatie te ontvangen. Vraag Q-af095525ea319451 (open) Specifieke aanroepcontexten, foutafhandelingen (zoals DET of DEM), retourwaarden of re-entrancy-voorschriften zijn voor deze gegevensstructuur in de bronnen niet gedefinieerd.

Het gegevenstype Csm_AEADEncryptTagType definieert volgens [SWS_Csm_01926] een byte-array (elementtype uint8) die als buffer voor de gegevens van de authenticatietag bij AEAD-versleutelingsoperaties dient. De array is conform de specificatie lang genoeg gedimensioneerd om de gegevens van de tag volledig op te nemen [SWS_Csm_01926].

Met betrekking tot structuur en configuratie gelden de volgende bepalingen uit [SWS_Csm_01926]:

• Buffergrootte: De dimensionering van de array wordt via de configuratieparameter CsmAEADEncryptTagLength onder Csm/CsmPrimitives/CsmAEADEncrypt/CsmAEADEncryptConfig vastgelegd [SWS_Csm_01926].
• Naamvariant: De typenaam heeft een cryptografische variantie en wordt volgens het schema Csm_AEADEncryptTagType_{Crypto} gevormd, waarbij {Crypto} overeenkomt met de korte naam van de desbetreffende primitive (SHORT-NAME) [SWS_Csm_01926].
• Header-opname: Het type wordt via de header Rte_Csm_Type.h beschikbaar gesteld [SWS_Csm_01926].

Door de beschikbaarheid in Rte_Csm_Type.h is het gegevenstype vermoedelijk bestemd voor gestandaardiseerde software-interfaces (interpretatie: gebruik voor bufferoverdracht in softwarecomponent-ports) [SWS_Csm_01926]. Vraag Q-3cd2f6ae1229483e (open)

Gebruik en structuur

Het datatype Csm_AEADDecryptCiphertextType definieert volgens [SWS_Csm_00922] een byte-array op basis van het elementtype uint8. Het dient als voldoende gedimensioneerde buffer voor de opname van de cijfertekst die in het kader van een AEAD-operatie (Authenticated Encryption with Associated Data) moet worden ontsleuteld [SWS_Csm_00922]. De beschikbaarstelling van de typedefinitie vindt plaats via het headerbestand Rte_Csm_Type.h [SWS_Csm_00922].

Dimensionering en variantie

De dimensionering van het veld vindt statisch plaats aan de hand van de configuratieparameter CsmAEADDecryptCiphertextMaxLength binnen de configuratietak Csm/CsmAEADDecrypt/CsmAEADDecryptConfig [SWS_Csm_00922]. De array is zo ontworpen dat deze de volledige te verwerken cijfertekst kan bevatten. Bovendien is de typenaam onderhevig aan een cryptografische variantie volgens het patroon Csm_AEADDecryptCiphertextType_{Crypto}, waarbij het identifierdeel {Crypto} wordt gevormd door de korte naam van het betreffende primitief (CsmPrimitives.SHORT-NAME) [SWS_Csm_00922].

Samenspel en randvoorwaarden

Op grond van de definitie in Rte_Csm_Type.h is het type vermoedelijk primair bedoeld voor de getypeerde koppeling van softwarecomponenten (SW-C's) via RTE-poorten aan de Crypto Service Gateway resp. CSM [SWS_Csm_00922]. Vraag Q-35738ff5fc96c699 (open) Aangezien de array-grootte tijdens de configuratietijd vast wordt opgegeven, moeten aanroepers ervoor zorgen dat de cijfertekstgegevens de maximumlengte niet overschrijden om buffer overflows tijdens runtime uit te sluiten.

Het datatype Csm_AEADDecryptAssociatedDataType is gedefinieerd als een array van elementen van het type uint8 en volgt het formatie-afhankelijke naampatroon Csm_AEADDecryptAssociatedDataType_{Crypto} [SWS_Csm_00923]. Het doel van dit datatype is het ter beschikking stellen van een geheugengebied dat voldoende gedimensioneerd is om de header-gegevens resp. geassocieerde aanvullende gegevens (Associated Data) van een geauthenticeerde ontsleuteling (AEAD Decrypt) op te nemen [SWS_Csm_00923].

De grootte van de array richt zich naar de configuratieparameter CsmAEADDecryptAssociatedDataMaxLength in het configuratiepad Csm/CsmAEADDecrypt/CsmAEADDecryptConfig [SWS_Csm_00923]. Via de variantie Crypto={ecuc/Csm/CsmPrimitives.SHORT-NAME} wordt de type-identifier voor het respectievelijke in de Crypto Service Manager geconfigureerde primitief gespecialiseerd via de korte naam ervan [SWS_Csm_00923]. Daardoor kan voor elk cryptografisch primitief een specifieke buffer met een passende maximumlengte worden gedeclareerd.

Het datatype wordt geëxporteerd via het headerbestand Rte_Csm_Type.h [SWS_Csm_00923]. Aangezien het om een zuivere typedefinitie gaat, specificeert de invoer geen foutcodes, DET-meldingen of re-entrantievoorwaarden. Als interpretatie dient de array vermoedelijk als getypeerde databuffer voor de overdracht van niet-versleutelde, maar cryptografisch te verifiëren begeleidende gegevens tussen softwarecomponenten en de CSM via de RTE. Vraag Q-2f32bbe9a4489b27 (open)

Gebruik en doel

Het datatype Csm_AEADDecryptTagType is gedefinieerd als byte-array met het elementtype uint8 en dient als specifiek geheugengebied voor de opname van de taggegevens bij AEAD-ontsleutelingsbewerkingen [SWS_Csm_01074]. De beschikbaarstelling vindt plaats via het headerbestand Rte_Csm_Type.h [SWS_Csm_01074].

Dimensionering en configuratieafhankelijkheid

De dimensionering van de array is configureerbaar en richt zich naar de geconfigureerde taglengte CsmAEADDecryptTagLength [SWS_Csm_01074]. Het aantal elementen wordt bepaald via de expressie (({ecuc(Csm/CsmPrimitives/CsmAEADDecrypt/CsmAEADDecryptConfig/CsmAEADDecryptTagLength)}+7)/8) [SWS_Csm_01074]. Door deze berekening wordt de in bits aangegeven taglengte omgerekend naar volledige bytes, waarbij bitlengtes die niet deelbaar zijn door acht worden afgerond naar de eerstvolgende bytegrens.

Het type is onderhevig aan een naamvariatie volgens het schema Csm_AEADDecryptTagType_{Crypto}, waarbij {Crypto} wordt vervangen door de korte naam (SHORT-NAME) van de desbetreffende primitive-configuratie [SWS_Csm_01074]. Hierdoor bestaat voor elke geconfigureerde AEAD-ontsleutelingsprimitive-instantie een passend getypeerde structuur.

Integratie- en randvoorwaarden

De beschikbaarstelling via Rte_Csm_Type.h duidt er vermoedelijk op dat dit type vooral bedoeld is voor softwarecomponenten aan poorten van de AUTOSAR-RTE, om de authenticatietag over te dragen aan de Crypto Service Manager [SWS_Csm_01074]. Vraag Q-2a0bebbb8e1d6b76 (open) Aangezien het type geen eigen control flows of synchronisatiemechanismen bevat, wordt de consistentie van de gegevens in de buffer vermoedelijk volledig gewaarborgd door de aanroepende context tijdens de ontsleutelingscyclus.

Gebruik en structuur

Het datatype Csm_AEADDecryptPlaintextType respectievelijk de primitivespecifieke variant daarvan Csm_AEADDecryptPlaintextType_{Crypto} is gedefinieerd als byte-array met elementen van het type uint8 [SWS_Csm_01075]. Het dient ertoe een voldoende gedimensioneerde buffer beschikbaar te stellen voor de opslag van de platte-tekstgegevens bij een AEAD-ontsleuteling (Authenticated Encryption with Associated Data) [SWS_Csm_01075]. De vaste veldgrootte wordt bepaald via de configuratieparameter CsmAEADDecryptPlaintextMaxLength binnen de configuratie van de desbetreffende AEAD-ontsleutelingsprimitive [SWS_Csm_01075]. Via de header Rte_Csm_Type.h wordt het datatype beschikbaar gesteld voor softwarecomponenten, waarbij de typenaam via de variatie Crypto gekoppeld is aan de korte naam van de geconfigureerde CSM-primitives [SWS_Csm_01075].

Foutafhandeling en gelijktijdigheid

Aangezien het om een zuivere typedefinitie gaat, definieert het element geen eigen retourwaarden, foutcodes of DET-meldingen [SWS_Csm_01075]. De belangrijkste functionele randvoorwaarde ligt in de statisch vastgelegde maximale lengte: platte-tekstgegevens die de geconfigureerde grens overschrijden, kunnen niet in deze buffer worden ondergebracht [SWS_Csm_01075]. Interpretatie: het type dient vermoedelijk primair voor de getypeerde gegevensoverdracht via RTE-poorten, wanneer SWC's asynchroon of synchroon resultaten van ontsleutelingsdiensten ontvangen. Vraag Q-2de04243d7f996c8 (open) Aanroepers moeten vermoedelijk zelfstandig waarborgen dat buffergrenzen in acht worden genomen en gelijktijdige schrijf- of leestoegangen over meerdere taken heen thread-safe zijn gesynchroniseerd.

Het type Csm_SignatureGenerateDataType definieert volgens [SWS_Csm_01083] een array van uint8-elementen, die dient als buffer voor de opname van de gegevens waaruit een cryptografische handtekening moet worden gegenereerd. De concrete naamgeving in de broncode is primitivespecifiek en volgt het patroon Csm_SignatureGenerateDataType_{Crypto}, waarbij de identifier wordt gevarieerd via de korte naam van de geconfigureerde cryptoprimitive [SWS_Csm_01083].

De statische dimensionering van het dataveld wordt bepaald via de configuratieparameter CsmSignatureGenerateDataMaxLength [SWS_Csm_01083]. Het datatype wordt beschikbaar gesteld via het headerbestand Rte_Csm_Type.h [SWS_Csm_01083]. Interpretatie: vanwege de beschikbaarstelling via Rte_Csm_Type.h is het arraytype vermoedelijk primair bedoeld voor de getypeerde gegevensoverdracht aan RTE-poorten tussen softwarecomponenten en de module CSM. Vraag Q-dcc731a5b8961aef (open)

Bij de configuratie en het gebruik moet er rekening mee worden gehouden dat CsmSignatureGenerateDataMaxLength de vaste bovengrens van de array vastlegt [SWS_Csm_01083]. Gebruikers moeten configuratief waarborgen dat de buffergrootte toereikend is voor alle tijdens het bedrijf optredende invoergegevens voor de handtekeninggeneratie, aangezien de array statisch wordt gealloceerd.

Het datatype Csm_SignatureGenerateResultType definieert volgens [SWS_Csm_01077] een byte-array op basis van uint8, die dient voor de opname van een gegenereerde cryptografische handtekening en de bijbehorende lengtespecificatie. Het type wordt gedeclareerd via de header Rte_Csm_Type.h en stelt de gestandaardiseerde uitvoerbuffer voor handtekeningbewerkingen in de Crypto Service Manager beschikbaar.

De structuur en dimensionering van het type zijn configureerbaar:

• Buffergrootte: het aantal uint8-elementen wordt voorgeschreven via de configuratieparameter CsmSignatureGenerateResultLength van de desbetreffende configuratie voor handtekeninggeneratie ([SWS_Csm_01077]).
• Naamvariant: de identifier bevat het achtervoegsel _{Crypto}, dat overeenkomt met de korte naam van de geconfigureerde primitive ([SWS_Csm_01077]).

Aangezien het om een zuivere typedefinitie gaat, bevat [SWS_Csm_01077] geen specificatie van foutcodes, DET-meldingen of re-entrancy-eigenschappen. De runtimesemantiek en bufferoverdracht richten zich vermoedelijk naar de synchrone of asynchrone aanroepconventies van de CSM-dienstinterfaces. Vraag Q-3304c06a29f069a2 (open) Aanroepers moeten waarborgen dat de geconfigureerde arraygrootte altijd toereikend is voor de op te nemen handtekening inclusief lengtewaarde.

Het datatype Csm_SignatureVerifyDataType is volgens [SWS_Csm_01078] gedefinieerd als byte-array met het elementtype uint8 en dient voor het bufferen van gegevens waarvan de handtekening moet worden geverifieerd.

Voor de configuratie en het gebruik van het type gelden volgens [SWS_Csm_01078] de volgende bepalingen:

• Arraydimensionering: de grootte van het veld komt overeen met de configuratiewaarde CsmSignatureVerifyDataMaxLength uit het configuratiepad Csm/CsmPrimitives/CsmSignatureVerify/CsmSignatureVerifyConfig, zodat de array voldoende gedimensioneerd is om alle te controleren gegevens op te nemen.
• Naamvariatie: de typenaam varieert afhankelijk van de desbetreffende cryptoprimitive volgens het schema Csm_SignatureVerifyDataType_{Crypto}, waarbij {Crypto} overeenkomt met de korte naam CsmPrimitives.SHORT-NAME.
• Headerbeschikbaarstelling: de typedefinitie is beschikbaar via het headerbestand Rte_Csm_Type.h.

Interpretatie: door de beschikbaarstelling in Rte_Csm_Type.h is het type vermoedelijk vooral bestemd voor softwarecomponenten aan de RTE-interface, om payload tot aan de geconfigureerde maximale lengte voor de handtekeningcontrole over te dragen aan de Crypto Service Manager [SWS_Csm_01078]. Vraag Q-c1541703c2bcd199 (open)

Het type Csm_SignatureVerifyCompareType definieert een byte-array op basis van uint8, die voldoende geheugenruimte biedt voor een te verifiëren cryptografische handtekening ([SWS_Csm_01079]). Het wordt ter beschikking gesteld via de header Rte_Csm_Type.h en maakt voor softwarecomponenten getypeerde toegang tot handtekeningvergelijkingsgegevens mogelijk ([SWS_Csm_01079]).

Configuratie en variantie

De concrete grootte van de array is niet vast voorgeschreven, maar richt zich naar de configuratiewaarde CsmSignatureVerifyCompareLength uit de handtekeningverificatieconfiguratie van de desbetreffende primitives ([SWS_Csm_01079]). Bovendien is het type onderhevig aan een naamvariatie via de korte naam van de cryptografische primitive (Crypto = {ecuc/Csm/CsmPrimitives.SHORT-NAME}), zodat de getypeerde identifier wordt gevormd als Csm_SignatureVerifyCompareType_{Crypto} ([SWS_Csm_01079]).

Gebruiksaspecten en randvoorwaarden

• Aanroepcontext en semantiek: als zuivere datastructuur heeft het element geen zelfstandige synchrone of asynchrone semantiek. De instantiëring vindt doorgaans plaats door de aanroeper van verificatiediensten van de module ([SWS_Csm_01079]).
• Foutafhandeling: de typedefinitie definieert geen eigen foutcodes of DET-/DEM-meldingen ([SWS_Csm_01079]). Interpretatie: een validatie van de bufferlengte of pointerintegriteit vindt vermoedelijk plaats in de gebruikende CSM-functies. Vraag Q-60454c8a7d8035cf (open)
• Gelijktijdigheid: voor zuivere typedefinities bestaan geen beperkingen ten aanzien van re-entrancy; gelijktijdige toegang tot bufferinstanties moet door de gebruikende modules worden gecoördineerd ([SWS_Csm_01079]).

Gebruik en doel

Het datatype Csm_RandomGenerateResultType is gedefinieerd als array en dient als gestructureerd geheugengebied voor de opslag van de resultaatgegevens van een gegenereerd willekeurig getal [SWS_Csm_00930]. De afzonderlijke elementen van de array hebben het basistype uint8, waardoor het resulterende willekeurige getal als aaneengesloten bytereeks wordt gerepresenteerd [SWS_Csm_00930].

Configuratie en variantvorming

De buffergrootte wordt niet dynamisch doorgegeven, maar statisch vastgelegd via de moduleconfiguratie: Het aantal array-elementen richt zich naar de configuratieparameter CsmRandomGenerateResultLength onder het pad Csm/CsmPrimitives/CsmRandomGenerate/CsmRandomGenerateConfig [SWS_Csm_00930]. Bovendien is de identifier onderhevig aan een cryptografiespecifieke naamvariatie volgens het schema Csm_RandomGenerateResultType_{Crypto}, waarbij het achtervoegsel overeenkomt met de korte naam van het desbetreffende primitief [SWS_Csm_00930]. Op deze wijze krijgt elke geconfigureerde instantie van de random-generatie een typeconforme buffer van passende lengte.

Integratie en randvoorwaarden

De declaratie van het type wordt ter beschikking gesteld via het headerbestand Rte_Csm_Type.h [SWS_Csm_00930]. Interpretatie: Aangezien de beschikbaarstelling via de RTE-header plaatsvindt, is dit datatype vermoedelijk primair bedoeld voor Application Software Components om toevalswaarden via poorten typesafe te ontvangen. Vraag Q-ea993612037bec12 (open) Concrete API-aanroepcontexten, foutcodes of concurrency-aspecten zijn niet verankerd in het type zelf, maar in de bijbehorende CSM-services, terwijl dit type de statische geheugeneis waarborgt [SWS_Csm_00930].

Gebruik en semantiek

Het type Csm_VerifyResultPtr is een AUTOSAR-Implementation-Data-Type van de categorie DATA_REFERENCE, waarvan het pointerdoel Csm_VerifyResultType is (formeel Csm_VerifyResultType*) [SWS_Csm_91046]. De typedefinitie wordt via de header Rte_Csm_Type.h beschikbaar gesteld en is daarmee beschikbaar voor applicatiecomponenten via de RTE en voor basissoftwaremodules [SWS_Csm_91046].

De functionele taak van Csm_VerifyResultPtr bestaat erin het verificatieresultaat bij asynchrone cryptografische operaties te retourneren [SWS_Csm_91046]. Bij asynchrone uitvoering verwijst de pointer naar een door de aanroeper gereserveerde buffer, waarin de module Csm na voltooiing van de controle het resultaat invoert [SWS_Csm_91046].

Gelijktijdigheid en beperkingen

Aangezien Csm_VerifyResultPtr expliciet bedoeld is voor asynchrone terugkoppeling [SWS_Csm_91046], moeten gebruikers ervoor zorgen dat de geldigheid van het gereferentieerde doelobject gedurende de gehele mutatieduur behouden blijft. Hierbij dient rekening te worden gehouden met de volgende aspecten:

• Het gerefereerde geheugengebied van het type Csm_VerifyResultType zou gedurende de gehele asynchrone uitvoeringstijd tot aan de ontvangst van de terugmelding geldig en beschermd moeten blijven (interpretatie: vermijden van schrijftoegang tot ongeldige geheugenadressen). Vraag (open)
• Aanroepers dienen de pointer vermoedelijk niet te richten op vluchtige stackvariabelen wanneer de aanroepende functie al vóór voltooiing van de asynchrone opdracht kan worden verlaten. Vraag (open)

Het enumeratietype Crypto_KeyStatusType definieert de geldigheidsstatus van cryptografische sleutels en wordt beschikbaar gesteld via het headerbestand Rte_Csm_Type.h [SWS_Csm_91102].

Waardebereik en semantiek

Het type omvat twee waarden [SWS_Csm_91102]:

• CRYPTO_KEYSTATUS_INVALID (0x00): De status van de sleutel is ongeldig. Dit treedt bijvoorbeeld op wanneer na het instellen van een sleutelelement met behulp van Csm_KeyElementSet de functie Csm_KeySetValid nog niet is uitgevoerd.
• CRYPTO_KEYSTATUS_VALID (0x01): De sleutel is geldig nadat de status bijvoorbeeld is ingesteld door de succesvolle aanroep van Csm_KeySetValid.

Volgordevoorwaarden en interactie

De toestandslogica koppelt de geldigheid direct aan de updateprocessen van het sleutelbeheer: elke wijziging van sleutelelementen brengt de sleutel in een ongeldige tussentoestand, die pas wordt beëindigd door de expliciete validatie via Csm_KeySetValid [SWS_Csm_91102]. Interpretatie: Aanroepers en cryptografische diensten dienen daarom vóór de uitvoering van cryptografische operaties vermoedelijk de status CRYPTO_KEYSTATUS_VALID te vereisen om storingen door onvolledige sleutelgegevens uit te sluiten. Vraag Q-7ad50e0568814efa (open)