Key Manager (KeyM)

La función KeyM_Init sirve para inicializar el módulo de gestión de claves ([SWS_KeyM_00043]). La llamada se realiza de forma síncrona y está definida como no reentrante ([SWS_KeyM_00043]). Como único parámetro de entrada se espera ConfigPtr, que representa un puntero al conjunto de datos de configuración para VARIANT-POST-BUILD; la función no posee valor de retorno ([SWS_KeyM_00043]).

En lo que respecta a la interacción con otras funciones del módulo, KeyM_Init constituye una precondición obligatoria: si la detección de desarrollo está activada, todas las demás funciones del Key Manager comprueban si el módulo se ha inicializado previamente mediante KeyM_Init y aún no se ha desinicializado mediante KeyM_Deinit ([SWS_KeyM_00144]). Si se llama a una función del módulo en estado no inicializado, el Key Manager notifica el error de desarrollo KEYM_E_UNINIT ([SWS_KeyM_00144]).

Dado que KeyM_Init está especificada como no reentrante ([SWS_KeyM_00043]), la función solo debe ejecutarse una vez en la fase de inicialización del sistema y excluyendo llamadas concurrentes. Tras una ejecución correcta, el módulo está disponible a través del archivo de cabecera KeyM.h ([SWS_KeyM_00043]).

La función KeyM_Deinit sirve para restablecer el módulo Key Manager al estado no inicializado ([SWS_KeyM_00047]).

Uso y contexto de llamada

La llamada a KeyM_Deinit se realiza de forma síncrona y está especificada como no reentrante (Non Reentrant). La función posee el Service-ID 0x02, no acepta parámetros y no devuelve ningún valor ([SWS_KeyM_00047]).

Concurrencia e interacción

Debido a la no reentrancia, KeyM_Deinit no debe llamarse de forma concurrente consigo misma ni en conflicto con operaciones en curso. Tras la ejecución de esta desinicialización, el módulo se encuentra en estado no inicializado. Si los errores de desarrollo están habilitados, el Key Manager comprueba en cada llamada de función posterior si el módulo fue inicializado previamente mediante KeyM_Init() y aún no ha sido desinicializado mediante KeyM_Deinit(); de lo contrario, se notifica el error de desarrollo KEYM_E_UNINIT ([SWS_KeyM_00144]).

La función síncrona KeyM_Start sirve para habilitar operaciones para la actualización de claves en el Key Manager ([SWS_KeyM_00050]). Es opcional y solo está disponible si el parámetro de configuración KeyMCryptoKeyStartFinalizeFunctionEnabled está configurado en true (AUTOSAR_SWS_KeyManager p. 35). La función se proporciona a través de KeyM.h y espera a través de StartType el modo de funcionamiento a ejecutar, así como a través de Request Data y Request Data Length datos de solicitud adicionales, tales como una firma.

Los datos de respuesta se devuelven a través del búfer de salida Response Data. El parámetro Response Data Length actúa en este caso como parámetro de entrada y salida: antes de la llamada define el número máximo de bytes disponibles en el búfer, tras la ejecución contiene la longitud de datos realmente escrita ([SWS_KeyM_00050]).

Tratamiento de errores y valores de retorno:

• E_OK: operación de inicio ejecutada correctamente; ahora se permiten actualizaciones de clave.
• E_NOT_OK: operación de inicio no aceptada.
• KEYM_E_PARAMETER_MISMATCH: los parámetros transferidos no coinciden con los valores esperados.
• KEYM_E_KEY_CERT_SIZE_MISMATCH: un tamaño de parámetro transferido no coincide con el tamaño esperado.

La función está especificada como no reentrante (Non Reentrant) ([SWS_KeyM_00050]). Dado que no se describen bloqueos internos del módulo, el llamador presumiblemente deba garantizar una ejecución coordinada y serializada. Pregunta Q-82276b712a8dd170 (abierta)

La función síncrona KeyM_Prepare sirve para preparar una actualización de clave (Key Update Operation) y transmite la información necesaria al servidor de claves o inicia la negociación de un secreto compartido para la derivación de claves [SWS_KeyM_00051]. La función posee el ID de servicio 0x05, está declarada a través de la cabecera KeyM.h y se encuentra disponible exclusivamente si el parámetro de configuración Key MCrypto Key Prepare Function Enabled está establecido en TRUE [SWS_KeyM_00051].

En la llamada se deben transferir los siguientes búferes e indicaciones de longitud [SWS_KeyM_00051]:

• Request Data y Request Data Length: datos de entrada y su longitud para la solicitud [SWS_KeyM_00051].
• Response Data: puntero al búfer para recibir los datos de salida [SWS_KeyM_00051].
• Response Data Length: parámetro de entrada/salida que antes de la llamada indica el tamaño máximo de búfer disponible y al retornar contiene el número de bytes realmente escrito [SWS_KeyM_00051].

Si la llamada se confirma con E_OK, el servicio ha sido aceptado y se procesa internamente; los resultados finales se proporcionan a continuación a través de una retrollamada [SWS_KeyM_00051]. Si la aceptación falla, la función devuelve E_NOT_OK en caso de errores internos, KEYM_E_PARAMETER_MISMATCH en caso de valores de parámetro discrepantes o KEYM_E_KEY_CERT_SIZE_MISMATCH en caso de especificaciones de tamaño inadecuadas [SWS_KeyM_00051].

Dado que KeyM_Prepare está especificada como no reentrante (Non Reentrant), no deben producirse llamadas simultáneas o anidadas [SWS_KeyM_00051].

La función KeyM_Finalize finaliza procesos de actualización de claves y devuelve la operación de clave al estado de reposo (modo inactivo) [SWS_KeyM_00053]. Se utiliza típicamente junto con una operación KeyM_Start previa. Tras la llamada, el módulo no acepta más operaciones de preparación o actualización (Prepare/Update) hasta que se inicie una nueva secuencia mediante KeyM_Start [SWS_KeyM_00053]. Además, el material de clave actualizado se persiste y se pasa al estado válido mediante la llamada de Csm_KeySetValid [SWS_KeyM_00053].

Uso y concurrencia: KeyM_Finalize es no reentrante (Non Reentrant) y opera de forma asíncrona [SWS_KeyM_00053]. Interpretación: ante la falta de reentrancia, la llamada debería realizarse típicamente en contexto de tarea. Pregunta Q-895ebec2d0d2e635 (abierta) La interfaz solo está disponible si el parámetro de configuración KeyMCryptoKeyStartFinalizeFunctionEnabled está establecido en TRUE, y está declarada a través de KeyM.h [SWS_KeyM_00053].

Parámetros y valores de retorno: mediante RequestDataPtr y RequestDataLength se transmiten datos específicos de la solicitud. Los datos de respuesta se proporcionan a través de ResponseDataPtr; ResponseMaxDataLength sirve como tamaño de búfer a la entrada y, en caso de retorno síncrono, proporciona el número real de bytes [SWS_KeyM_00053]. Si la operación se acepta y se procesa internamente, la función devuelve E_OK (los resultados siguen de forma asíncrona mediante retrollamada) y ResponseMaxDataLength permanece inalterado [SWS_KeyM_00053].

Tratamiento de errores: en caso de error, KeyM_Finalize señala el fallo a través de valores de retorno específicos [SWS_KeyM_00053]:

• E_NOT_OK: operación no aceptada debido a un error interno.
• KEYM_E_BUSY: KeyM está ocupado con otros trabajos; la validación aún no se puede realizar.
• KEYM_E_PARAMETER_MISMATCH: los parámetros no coinciden con el valor esperado.
• KEYM_E_KEY_CERT_SIZE_MISMATCH: el tamaño del parámetro no coincide.

usar

La función síncrona KeyM_SetCertificate transfiere datos de certificado al módulo de gestión de claves para almacenar temporalmente un certificado [SWS_KeyM_00057]. Espera como parámetros de entrada el identificador del certificado CertId (tipo KeyM_CertificateIdType), así como el puntero CertificateDataPtr (tipo const KeyM_CertDataType*) que apunta a la estructura de certificado que se debe proporcionar [SWS_KeyM_00057]. La interfaz se declara a través de la cabecera KeyM.h y posee el ID de servicio 0x0a [SWS_KeyM_00057].

Valores de retorno y tratamiento de errores

El valor de retorno de tipo Std_ReturnType proporciona información sobre la aceptación de los datos [SWS_KeyM_00057]:

• E_OK: El certificado se aceptó con éxito [SWS_KeyM_00057].
• E_NOT_OK: No se pudo establecer el certificado [SWS_KeyM_00057].
• KEYM_E_PARAMETER_MISMATCH: los parámetros transferidos no coinciden con los valores esperados [SWS_KeyM_00057].
• KEYM_E_KEY_CERT_SIZE_MISMATCH: el tamaño de los datos de certificado transferidos difiere del tamaño esperado [SWS_KeyM_00057].

Concurrencia y restricciones

La función está clasificada como no reentrante (Non Reentrant) [SWS_KeyM_00057]. Por lo tanto, las llamadas concurrentes deben sincronizarse o excluirse por parte del llamador. Dado que la especificación prevé explícitamente un almacenamiento temporal, los datos de certificado transferidos probablemente permanezcan al principio en la memoria volátil del módulo antes de que se produzca un almacenamiento permanente o una verificación. Pregunta Q-c35c4b02344d5bc9 (abierta)

usar

La función síncrona KeyM_GetCertificate sirve para proporcionar los datos de certificado para un identificador de certificado especificado [SWS_KeyM_00058]. El llamador pasa mediante el parámetro CertId el identificador del certificado deseado, así como mediante el parámetro inout CertificateDataPtr un puntero a la estructura de datos de certificado. El llamador es responsable de proporcionar el búfer al que apunta el puntero en la estructura [SWS_KeyM_00058]. Antes de la llamada, debe especificarse en la estructura la longitud máxima de este búfer; en caso de retorno correcto (E_OK), el campo de longitud contiene la longitud real de los datos de certificado proporcionados [SWS_KeyM_00058].

Manejo de errores

La función señala el éxito o errores específicos mediante el valor de retorno de tipo Std_ReturnType [SWS_KeyM_00058]:

• E_OK: Los datos de certificado están disponibles y se transfirieron correctamente.
• KEYM_E_PARAMETER_MISMATCH: El ID de certificado pasado (CertId) no es válido.
• KEYM_E_KEY_CERT_SIZE_MISMATCH: El búfer proporcionado es demasiado pequeño para el certificado.
• KEYM_E_KEY_CERT_EMPTY: No hay datos de certificado disponibles porque la ranura de certificado está vacía.
• KEYM_E_KEY_CERT_READ_FAIL: El certificado no se puede proporcionar porque se denegó el acceso.
• E_NOT_OK: La operación no se aceptó debido a un error interno.

Concurrencia y restricciones

La función está especificada como no reentrante (Non Reentrant) y está disponible a través del archivo de cabecera KeyM.h [SWS_KeyM_00058]. Por lo tanto, los llamadores deben asegurarse de sincronizar entre sí las llamadas paralelas a la función.

La función KeyM_VerifyCertificates sirve para la comprobación asíncrona mutua de dos certificados almacenados y analizados sintácticamente de forma interna conforme a [SWS_KeyM_00059]. En este proceso se valida si el certificado subordinado referenciado mediante CertId ha sido firmado por el certificado superior referenciado con CertUpperId.

Dado que el servicio está definido como no reentrante (Non Reentrant), no debe llamarse de forma concurrente para operaciones solapadas [SWS_KeyM_00059]. La ejecución se realiza de forma asíncrona en segundo plano: un valor de retorno de E_OK solo señala la aceptación correcta de la solicitud de verificación. El resultado real de la verificación se comunica al llamante a través de la función de callback configurada KeyMCertificateVerifyCallbackNotificationFunc, siempre que esta esté válidamente configurada [SWS_KeyM_00153].

Si la solicitud no es aceptada, la función proporciona valores de retorno específicos para el tratamiento de errores [SWS_KeyM_00059]:

• KEYM_E_BUSY: El Key Manager está ocupado con otras tareas; la validación aún no puede iniciarse en este momento.
• KEYM_E_PARAMETER_MISMATCH: Al menos un ID de certificado transferido no es válido.
• KEYM_E_KEY_CERT_EMPTY: Una de las ranuras de certificado referenciadas está vacía.
• KEYM_E_CERT_INVALID_CHAIN_OF_TRUST: El certificado superior (CertUpperId) no es válido.
• E_NOT_OK: La solicitud fue rechazada debido a un error interno.

La función KeyM_VerifyCertificate sirve para la verificación asíncrona de un certificado que se proporcionó previamente mediante KeyM_SetCertificate() [SWS_KeyM_00060]. La comprobación se realiza mediante el identificador de certificado transferido CertId frente a certificados de otros ID de certificado ya depositados en el Key Manager [SWS_KeyM_00060]. La declaración está disponible a través del archivo de cabecera KeyM.h [SWS_KeyM_00060].

Semántica de llamada y valores de retorno

Un valor de retorno de E_OK confirma que la solicitud de verificación se aceptó correctamente y que la operación se ejecuta en segundo plano [SWS_KeyM_00060]. Si la solicitud no se puede aceptar, la notificación se realiza de forma síncrona mediante códigos de error específicos [SWS_KeyM_00060]:

• E_NOT_OK: La operación se rechazó debido a un error interno [SWS_KeyM_00060].
• KEYM_E_BUSY: El módulo KeyM está ocupado actualmente con otras tareas, de modo que la validación aún no se puede ejecutar [SWS_KeyM_00060].
• KEYM_E_PARAMETER_MISMATCH: El CertId transferido no es válido [SWS_KeyM_00060].
• KEYM_E_KEY_CERT_EMPTY: Al menos una de las ranuras de certificado requeridas está vacía [SWS_KeyM_00060].
• KEYM_E_CERT_INVALID_CHAIN_OF_TRUST: Un certificado superior en la cadena de confianza no es válido [SWS_KeyM_00060].

Concurrencia y asincronía

Dado que KeyM_VerifyCertificate está especificada como no reentrante (Non Reentrant), el llamador debe asegurarse de que no se produzcan llamadas simultáneas ni que causen interrupciones [SWS_KeyM_00060]. Tras la aceptación correcta de la solicitud de comprobación (retorno E_OK), el resultado de la operación en segundo plano se transmite a la función de callback configurada KeyMCertificateVerifyCallbackNotificationFunc, siempre que esta cuente con un nombre de función válido [SWS_KeyM_00153].

La función KeyM_VerifyCertificateChain sirve para la verificación asíncrona de un certificado frente a una cadena de certificados transferidos [SWS_KeyM_00061]. Como parámetros se transfieren el identificador del último certificado de la cadena (CertId), un puntero a la matriz de certificados ordenada según el orden de la PKI (certChainData) y la cantidad de certificados (NumberOfCertificates) [SWS_KeyM_00061]. Antes de la llamada, el certificado que se va a comprobar debe haberse registrado a través de KeyM_SetCertificate(), y el certificado raíz debe estar incluido en la lista o ya asignado a uno de los otros certificados [SWS_KeyM_00061].

La función no es reentrante (Non Reentrant) y se pone a disposición a través del archivo de cabecera KeyM.h [SWS_KeyM_00061]. Los siguientes valores de retorno síncronos indican el estado de aceptación de la solicitud [SWS_KeyM_00061]:

• E_OK: La solicitud de verificación ha sido aceptada y se ejecutará en segundo plano [SWS_KeyM_00061].
• E_NOT_OK: La solicitud fue rechazada debido a un error interno [SWS_KeyM_00061].
• KEYM_E_BUSY: El módulo está ocupado con otras solicitudes; la validación aún no puede ejecutarse [SWS_KeyM_00061].
• KEYM_E_PARAMETER_MISMATCH: El ID de certificado transferido no es válido [SWS_KeyM_00061].
• KEYM_E_KEY_CERT_EMPTY: Una de las ranuras de certificado requeridas está vacía [SWS_KeyM_00061].
• KEYM_E_CERT_INVALID_CHAIN_OF_TRUST: Un certificado superior en la cadena de confianza no es válido [SWS_KeyM_00061].

Si la solicitud se aceptó con E_OK, la evaluación tiene lugar en segundo plano. Siempre que KeyMCertificateVerifyCallbackNotificationFunc esté configurada con una función válida, KeyM devuelve el resultado final de la operación de verificación a la aplicación llamante a través de esta función de callback [SWS_KeyM_00061] [SWS_KeyM_00153].

Uso y contexto de llamada

La función síncrona KeyM_CertElementGet sirve para leer los datos de un elemento de certificado específico desde una ranura de certificado en un búfer proporcionado por el llamador [SWS_KeyM_00063]. Se utiliza cuando al identificador de objeto (OID) depositado en la configuración del certificado le corresponde exactamente un único elemento [SWS_KeyM_00063].

El llamador transfiere el identificador de certificado CertId, el identificador de elemento CertElementId, así como un puntero al búfer de destino CertElementData [SWS_KeyM_00063]. El parámetro CertElementDataLength sirve como valor combinado de entrada y salida: antes de la llamada, debe contener el tamaño máximo del búfer. En caso de éxito (E_OK), se sobrescribe con la longitud real de los datos escritos; en caso de error, la función restablece a cero el valor referenciado [SWS_KeyM_00063].

Tratamiento de errores y valores de retorno

La función notifica el estado de ejecución mediante los siguientes valores de retorno [SWS_KeyM_00063]:

• E_OK: El elemento se encontró y se copió correctamente en el búfer [SWS_KeyM_00063].
• E_NOT_OK: No se encontraron los datos del elemento [SWS_KeyM_00063].
• KEYM_E_PARAMETER_MISMATCH: CertId o CertElementId no válidos [SWS_KeyM_00063].
• KEYM_E_KEY_CERT_SIZE_MISMATCH: El búfer proporcionado es demasiado pequeño para los datos del elemento [SWS_KeyM_00063].
• KEYM_E_KEY_CERT_EMPTY: No existen datos para la ranura especificada; la ranura está vacía [SWS_KeyM_00063].
• KEYM_E_KEY_CERT_INVALID: El certificado no es válido o aún no se ha verificado [SWS_KeyM_00063].

concurrencia

La función está especificada como no reentrante (Non Reentrant) [SWS_KeyM_00063]. Por tanto, en caso de llamadas concurrentes desde diferentes tareas o contextos, es probable que se requiera una sincronización por parte del llamador. Pregunta Q-238a3e53ce0e3a45 (abierta)

La función síncrona KeyM_CertificateElementGetByIndex sirve para la lectura selectiva de datos de un elemento de certificado mediante un índice basado en cero (0..N), cuando existen varias entradas para un tipo de elemento [SWS_KeyM_91014]. Representa, por tanto, una alternativa de acceso directo a la iteración secuencial.

Uso y parámetros

El llamador transfiere el identificador de certificado CertId, el identificador de elemento CertElementId así como el Index deseado [SWS_KeyM_91014]. Además, el llamador debe asignar la memoria para CertElementDataPtr y transferir a través de CertElementDataLengthPtr el tamaño máximo de búfer disponible. En caso de retorno correcto, CertElementDataLengthPtr se sobrescribe con la longitud real de los datos copiados [SWS_KeyM_91014].

Valores de retorno y tratamiento de errores

La función señala el resultado mediante valores de retorno Std_ReturnType específicos [SWS_KeyM_91014]:

• E_OK: el elemento se encontró y se copió correctamente en el búfer de destino.
• KEYM_E_PARAMETER_MISMATCH: CertId no válido, CertElementId no válido o el Index pasado está fuera del rango válido.
• KEYM_E_KEY_CERT_SIZE_MISMATCH: el búfer provisto es demasiado pequeño para el elemento de certificado.
• KEYM_E_KEY_CERT_EMPTY: el certificado indicado no contiene datos o está vacío.
• KEYM_E_CERT_INVALID: el certificado no es válido o la verificación no fue correcta.
• E_NOT_OK: la lectura de los datos del elemento ha fallado.

concurrencia

Según la especificación, el servicio está clasificado como no reentrante (Non Reentrant) [SWS_KeyM_91014]. Por lo tanto, las llamadas no deben ejecutarse de forma concurrente sin protección.

La interfaz síncrona KeyM_CertificateElementGetCount determina la cantidad total de elementos de datos almacenados para un elemento de certificado específico y escribe el resultado en el búfer CountPtr [SWS_KeyM_91015].

Uso y parámetros

La función se declara a través de la cabecera KeyM.h y posee el Service-ID 0x1c [SWS_KeyM_91015]. Procesa los siguientes parámetros:

• CertId (IN): identificador unívoco del certificado a consultar ([SWS_KeyM_91015]).
• CertElementId (IN): determina el elemento concreto dentro del certificado ([SWS_KeyM_91015]).
• CountPtr (OUT): puntero al búfer de tipo uint16, en el cual se copia la cantidad de elementos de datos disponibles ([SWS_KeyM_91015]).

Tratamiento de errores y valores de retorno

El valor de retorno de tipo Std_ReturnType informa sobre el resultado de la ejecución [SWS_KeyM_91015]:

• E_OK: el valor de recuento se escribió correctamente en el búfer ([SWS_KeyM_91015]).
• E_NOT_OK: no se pudo proporcionar el valor de recuento ([SWS_KeyM_91015]).
• KEYM_E_PARAMETER_MISMATCH: el ID de certificado (CertId) o el ID de elemento (CertElementId) no es válido o está fuera del rango permitido ([SWS_KeyM_91015]).

Concurrencia e interacción

La ejecución es síncrona, pero está clasificada como no reentrante (Non Reentrant), por lo que las llamadas simultáneas deben coordinarse [SWS_KeyM_91015]. Mientras que a los elementos de certificado se les asigna típicamente solo un único elemento de datos, en determinados casos pueden existir varios elementos de datos consecutivos [SWS_KeyM_91015]. El total determinado sirve de base para leer a continuación los elementos individuales de manera selectiva a través de KeyM_CertificateElementGetByIndex(), lo que se asemeja funcionalmente al enfoque iterativo con KeyM_CertElementGetFirst y KeyM_CertElementGetNext [SWS_KeyM_91015].

La función síncrona KeyM_CertElementGetFirst sirve, según [SWS_KeyM_00064], para iniciar la extracción iterativa de datos de certificado. Lee el elemento superior del elemento de certificado direccionado mediante CertElementId a partir del certificado CertId e inicializa la estructura de iterador CertElementIterator para llamadas posteriores de KeyM_CertElementGetNext().

Al realizar la llamada, deben tenerse en cuenta los siguientes requisitos de parámetros y memoria según [SWS_KeyM_00064]:

• CertElementIterator: Puntero a una estructura asignada y gestionada por el llamador; la aplicación no debe destruirla ni modificarla mientras no se hayan recuperado todos los datos mediante KeyM_CertElementGetNext().
• CertElementData: Puntero a un búfer de salida proporcionado por el llamador en el que se copian los datos útiles si se localizan con éxito (E_OK).
• CertElementDataLength: Transfiere como entrada la longitud máxima del búfer de datos y se sobrescribe con la longitud de datos realmente escrita al retornar E_OK.

En lo relativo a la concurrencia, según [SWS_KeyM_00064] el servicio es reentrante, pero referido exactamente a un iterador («Reentrant for one iterator»).

En caso de error, la función diferencia mediante valores de retorno específicos según [SWS_KeyM_00064]: E_NOT_OK indica que no se encontraron datos del elemento (tras lo cual el iterador no debe utilizarse para más llamadas). KEYM_E_PARAMETER_MISMATCH señala un ID de certificado o de elemento no válido, KEYM_E_KEY_CERT_SIZE_MISMATCH un búfer de datos demasiado pequeño, KEYM_E_KEY_CERT_EMPTY un certificado vacío sin datos disponibles y KEYM_E_CERT_INVALID un certificado no válido o no verificado con éxito.

La función síncrona KeyM_CertElementGetNext (Service-ID 0x11, proporcionada a través de KeyM.h) sirve para la lectura continua de datos adicionales de un elemento de certificado si en él se han almacenado varios registros de forma secuencial [SWS_KeyM_00065]. Como condición obligatoria de llamada, la especificación exige que previamente se haya llamado al menos una vez a la función KeyM_CertElementGetFirst() [SWS_KeyM_00065].

Las áreas de memoria para todos los parámetros deben ser proporcionadas por la aplicación llamadora [SWS_KeyM_00065]:

• CertElementIterator: Puntero a una estructura de iterador asignada que la aplicación no debe modificar ni destruir durante el recorrido hasta que todos los elementos se hayan leído por completo [SWS_KeyM_00065].
• CertElementData: Puntero al búfer de salida en el que la función copia los datos útiles en caso de ejecución correcta [SWS_KeyM_00065].
• CertElementDataLength: Transfiere al llamar la capacidad máxima del búfer de datos y se sobrescribe con la longitud real de los datos copiados en caso de retorno correcto [SWS_KeyM_00065].

Si la llamada devuelve E_OK, se encontró el siguiente elemento, se escribió en el búfer y el iterador avanzó en consecuencia [SWS_KeyM_00065]. Con E_NOT_OK no se pudieron encontrar más datos del elemento; en este caso, el iterador ya no debe utilizarse para ninguna llamada posterior [SWS_KeyM_00065]. Las situaciones de error se notifican mediante valores de retorno específicos: KEYM_E_KEY_CERT_SIZE_MISMATCH indica un búfer de datos dimensionado demasiado pequeño, KEYM_E_PARAMETER_MISMATCH un ID de certificado o de elemento no válido, KEYM_E_KEY_CERT_EMPTY un certificado vacío y KEYM_E_CERT_INVALID un certificado no válido o no verificado con éxito [SWS_KeyM_00065].

En cuanto a la concurrencia, la función síncrona está especificada como reentrante para un iterador en cada caso [SWS_KeyM_00065].

La función síncrona KeyM_CertGetStatus sirve para consultar el estado de un certificado y proporcionarlo a través de un parámetro de salida [SWS_KeyM_00066]. La declaración de la función es accesible a través del archivo de cabecera KeyM.h, y al servicio se le asigna el Service-ID hexadecimal 0x12 [SWS_KeyM_00066].

Para la llamada se utilizan los siguientes parámetros [SWS_KeyM_00066]:

• CertId (IN): Contiene el identificador del certificado que se va a consultar y se transfiere con el tipo de datos KeyM_CertificateIdType [SWS_KeyM_00066].
• Status (OUT): Puntero al área de memoria de tipo KeyM_CertificateStatusType en la que la función escribe el estado determinado del certificado [SWS_KeyM_00066].

El valor de retorno de tipo Std_ReturnType informa sobre el resultado de la consulta de estado [SWS_KeyM_00066]:

• E_OK: El estado del certificado se determinó y proporcionó correctamente [SWS_KeyM_00066].
• E_NOT_OK: Actualmente no es posible proporcionar el estado [SWS_KeyM_00066]. Esto ocurre, por ejemplo, si se transfiere un ID de certificado no válido, documentado con el código de error KEYM_E_PARAMETER_MISMATCH [SWS_KeyM_00066].

En lo que respecta a la ejecución y la concurrencia, la interfaz se comporta de forma puramente síncrona y está especificada como no reentrante (Non Reentrant) [SWS_KeyM_00066]. Por tanto, no se permiten llamadas simultáneas a través de múltiples contextos de ejecución. No se prevén parámetros de entrada y salida adicionales para esta interfaz [SWS_KeyM_00066].

La función KeyM_MainFunction sirve como función principal periódica para el módulo AUTOSAR Classic KeyM [SWS_KeyM_00074]. Según la especificación, la función dispone del Service-ID 0x19 en representación hexadecimal, así como de la signatura void KeyM_MainFunction (void) [SWS_KeyM_00074]. De este modo, las entidades llamantes no transfieren parámetros de entrada ni reciben ningún valor de retorno [SWS_KeyM_00074].

Para el control temporal, se establece que la función debe llamarse periódicamente según un intervalo de tiempo definido [SWS_KeyM_00074]. Como archivo de interfaz está declarado el archivo de cabecera SchM_KeyM.h [SWS_KeyM_00074]. De ello se deriva la interpretación: al proporcionarse a través de SchM_KeyM.h, es probable que la llamada regular a la función tenga lugar en el contexto del planificador de Basic Software (SchM) [SWS_KeyM_00074]. Pregunta Q-761ff71812bda3c2 (abierta) Además, la activación cíclica sirve presumiblemente para el procesamiento interno de secuencias dependientes del tiempo en el módulo KeyM.

En cuanto al tratamiento y comportamiento ante errores, en el elemento de especificación no se documentan códigos de retorno, constantes de error ni notificaciones a DET o DEM para este servicio [SWS_KeyM_00074]. Como no existen parámetros de entrada, tampoco se requiere una verificación de los valores de transferencia en el momento de la llamada [SWS_KeyM_00074].

Uso y contexto de llamada

La función KeyM_MainBackgroundFunction posee la signatura void KeyM_MainBackgroundFunction(void) y está especificada bajo el Service-ID 0x1a [SWS_KeyM_00075]. No acepta parámetros de transferencia y no devuelve ningún valor de retorno al llamante [SWS_KeyM_00075]. Para su integración, la interfaz se declara y se proporciona a través del archivo de cabecera SchM_KeyM.h [SWS_KeyM_00075].

La llamada la realiza un sistema operativo apropiativo en segundo plano en cuanto no haya pendiente ninguna otra operación de tarea para su procesamiento [SWS_KeyM_00075]. El propósito principal de esta función es la provisión de un contexto de fondo no crítico para operaciones síncronas de larga duración del módulo KeyM, tal como se describe a modo de ejemplo para la ejecución de KeyM_KH_Update() [SWS_KeyM_00075].

Concurrencia y tratamiento de errores

Dado que la función se ejecuta en el contexto de fondo de un sistema operativo apropiativo, debería poder ser interrumpida en cualquier momento por cualquier tarea regular de mayor prioridad. Pregunta Q-a2394a51ba63467f (abierta) Para este servicio de segundo plano, el estándar no especifica códigos de error específicos ni notificaciones al DET o DEM [SWS_KeyM_00075]. Además, en el estado de datos dado no se prescriben propiedades de reentrancia particulares ni condiciones fijas de orden respecto a otras funciones del módulo [SWS_KeyM_00075].

La función síncrona y no reentrante KeyM_KH_Start se declara a través de la cabecera KeyM_Externals.h [SWS_KeyM_00067]. Si los parámetros de configuración KeyMCryptoKeyStartFinalizeFunctionEnabled y KeyMCryptoKeyHandlerStartFinalizeEnabled están establecidos en TRUE, se ejecuta inmediatamente ante una llamada de KeyM_Start [SWS_KeyM_00067].

Mediante el parámetro StartType se define el modo de ejecución de la operación de clave. Mediante RequestData y RequestDataLength, la función recibe datos adjuntos específicos de la solicitud, como por ejemplo firmas. El llamador transfiere mediante el parámetro de entrada/salida ResponseDataLength la cantidad máxima de bytes disponible en el búfer ResponseData; en caso de éxito, la función notifica a través de él el número real de bytes de respuesta escritos [SWS_KeyM_00067].

Como valor de retorno, la función proporciona un estado de tipo Std_ReturnType [SWS_KeyM_00067]:

• E_OK: La operación de inicio fue correcta. Solo a través de este valor de retorno el Key Manager cambia al estado activo, de modo que las actualizaciones de clave (Key Updates) posteriores quedan permitidas.
• E_NOT_OK: La operación de inicio no fue aceptada.
• KEYM_E_PARAMETER_MISMATCH: Un parámetro pasado no coincide con el valor esperado.
• KEYM_E_KEY_CERT_SIZE_MISMATCH: Un tamaño de parámetro especificado no se ajusta al tamaño esperado.

Dado que KeyM_KH_Start se define como no reentrante, las llamadas para operaciones de clave paralelas no deben tener lugar de forma concurrente [SWS_KeyM_00067].

Uso y contexto de llamada

La función KeyM_KH_Prepare se declara a través del archivo de cabecera KeyM_Externals.h y sirve para preparar una operación de gestión de claves [SWS_KeyM_00068]. Se inicia inmediatamente al llamar a KeyM_Prepare si los dos parámetros de configuración KeyMCryptoKeyPrepareFunctionEnabled y KeyMCryptoKeyHandlerPrepareEnabled están establecidos respectivamente en TRUE [SWS_KeyM_00068]. La ejecución es síncrona y está especificada como no reentrante [SWS_KeyM_00068].

La transferencia de datos se realiza a través de cuatro parámetros [SWS_KeyM_00068]:

• RequestData: Datos de entrada transferidos junto con la solicitud [SWS_KeyM_00068].
• RequestDataLength: Longitud de los datos en el array RequestData [SWS_KeyM_00068].
• ResponseDataPtr: Puntero al búfer para los datos de respuesta devueltos por la función, los cuales se transmiten sin cambios al llamador de Key_Prepare [SWS_KeyM_00068].
• ResponseDataLength: Parámetro de entrada y salida; al llamar transfiere el número máximo de bytes disponible en el búfer y, tras el retorno, devuelve la cantidad de bytes realmente escrita [SWS_KeyM_00068].

Valores de retorno y comportamiento ante errores

La función devuelve como resultado el valor de estado Std_ReturnType [SWS_KeyM_00068]:

• E_OK: El servicio se aceptó y se sigue procesando internamente; los resultados se transmiten a través de un callback [SWS_KeyM_00068].
• E_NOT_OK: El servicio no se aceptó debido a un error interno [SWS_KeyM_00068].
• KEYM_E_PARAMETER_MISMATCH: un parámetro no coincide con el valor esperado [SWS_KeyM_00068].
• KEYM_E_KEY_CERT_SIZE_MISMATCH: El tamaño de un parámetro no es adecuado [SWS_KeyM_00068].

Uso y delegación

La función KeyM_KH_Finalize se declara a través del archivo de cabecera KeyM_Externals.h y actúa como key handler específico de la aplicación [SWS_KeyM_00070]. Si en la configuración tanto KeyMCryptoKeyStartFinalizeFunctionEnabled como KeyMCryptoKeyHandlerStartFinalizeEnabled están establecidos en TRUE, KeyM_Finalize() no ejecuta ninguna operación por sí misma, sino que delega el procesamiento inmediatamente a esta función handler [SWS_KeyM_00070].

Contexto de llamada y parámetros

La llamada a KeyM_KH_Finalize se produce de forma síncrona, pero está clasificada como no reentrante (Non Reentrant) y requiere un contexto de llamada protegido [SWS_KeyM_00070]. La transferencia de datos se efectúa a través de los siguientes parámetros:

• RequestData y RequestDataLength: Puntero a los datos de entrada transferidos con la solicitud, así como la longitud del array de datos [SWS_KeyM_00070].
• ResponseData: Búfer para los datos de salida proporcionados por la función [SWS_KeyM_00070].
• ResponseDataLength: Parámetro in/out que en la llamada especifica la cantidad máxima de bytes disponible en el búfer de respuesta y, al retornar, contiene el número de bytes realmente escrito [SWS_KeyM_00070].

Valores de retorno y tratamiento de errores

El resultado de la operación se devuelve mediante Std_ReturnType [SWS_KeyM_00070]:

• E_OK: La operación fue aceptada y se sigue procesando internamente; los resultados se proporcionan a través de un callback [SWS_KeyM_00070]. Interpretación: Aunque la interfaz de la función está definida como síncrona, es probable que la ejecución real continúe en segundo plano. Pregunta Q-02c4aac040570c03 (abierta)
• E_NOT_OK: La operación no se aceptó debido a un error interno [SWS_KeyM_00070].
• KEYM_E_BUSY: El Key Manager está ocupado con otras tareas, motivo por el cual actualmente no se puede llevar a cabo la validación [SWS_KeyM_00070].
• KEYM_E_PARAMETER_MISMATCH: un parámetro no coincide con el valor esperado [SWS_KeyM_00070].
• KEYM_E_KEY_CERT_SIZE_MISMATCH: El tamaño de parámetro transferido no se corresponde con las especificaciones [SWS_KeyM_00070].

La función de callback KeyM_CryptoKeyUpdateCallbackNotification() notifica a la aplicación que se ha completado una actualización de una clave criptográfica ([SWS_KeyM_00077]). La función se proporciona a través de KeyM_Externals.h, es síncrona y reentrante, y no posee ningún valor de retorno ([SWS_KeyM_00077]).

parámetro

• Result: Transmite información sobre el resultado de la operación de actualización a través del tipo KeyM_ResultType ([SWS_KeyM_00077], [SWS_KeyM_00156]).
• ResultDataLength: Indica la longitud de los datos resultantes de esta operación ([SWS_KeyM_00077], [SWS_KeyM_00156]).
• ResultDataPtr: Puntero a los datos del resultado ([SWS_KeyM_00077]).

Interacción y gestión de búferes

La llamada a KeyM_CryptoKeyUpdateCallbackNotification() se realiza mediante KeyM_Update() en cuanto el key handler retorna y entrega el tipo de operación KEYM_KH_UPDATE_FINISH ([SWS_KeyM_00093]). En este proceso, los datos de resultado de KeyM_KH_Update::ResultDataPtr se copian en el búfer transferido al llamar a KeyM_Update(), y se asume el valor de retorno del key handler ([SWS_KeyM_00093]).

Siempre que KeyM_Update() haya aceptado el proceso con E_OK, la función llamadora no debe modificar en ningún caso el búfer ResultDataPtr hasta que se haya producido la notificación de callback KeyM_CryptoKeyUpdateCallbackNotification() ([SWS_KeyM_00156]). El mismo puntero de búfer se transfiere en el callback como ResultDataPtr con los resultados de la operación copiados en él ([SWS_KeyM_00156]).

La función de callback KeyM_CryptoKeyFinalizeCallbackNotification notifica a la aplicación sobre la finalización de una operación de finalización de clave [SWS_KeyM_00079]. Está especificada como síncrona y reentrante, no tiene valor de retorno y se declara a través del archivo de cabecera KeyM_Externals.h [SWS_KeyM_00079].

Al realizar la llamada, la interfaz transfiere los siguientes parámetros a la aplicación [SWS_KeyM_00079]:

• Result (tipo KeyM_ResultType): Transmite el resultado e información de estado de la operación completada [SWS_KeyM_00079].
• Result Data Length (tipo uint16): Indica la longitud de los datos resultantes de esta operación [SWS_KeyM_00079].
• Result Data Ptr (tipo const uint8*): Puntero al búfer con los datos de resultado proporcionado previamente a la función de servicio [SWS_KeyM_00079].

En cuanto a la configuración, la función de callback solo se llama y se requiere si el parámetro de configuración KeyMCryptoKeyStartFinalizeFunctionEnabled está establecido en TRUE [SWS_KeyM_00079]. No hay definidos mensajes de error específicos de DET o DEM para esta función de callback. Presumiblemente, la aplicación implementa este callback para recibir los resultados asíncronos de una finalización de clave iniciada previamente. Pregunta Q-6d9e4e062b008832 (abierta)

Uso y parámetros

La función de callback KeyM_CryptoKeyVerifyCallbackNotification informa a la aplicación sobre la finalización de una operación de verificación para una clave criptográfica por parte del módulo KeyM [SWS_KeyM_00081]. Interpretación: dado que, según la especificación, el elemento está disponible a través de la cabecera KeyM_Externals.h y sirve para la notificación a la aplicación, es probable que la implementación la realice el componente de software usuario, mientras que la invocación la efectúa el administrador de claves [SWS_KeyM_00081]. Pregunta Q-e88e332a7d2cac40 (abierta)

Para la invocación se definen cuatro parámetros exclusivamente de entrada [SWS_KeyM_00081]:

• Result (KeyM_ResultType): transfiere el resultado de la verificación finalizada [SWS_KeyM_00081].
• KeyId (uint32): identifica el identificador de clave para el cual se inició la verificación [SWS_KeyM_00081].
• ResultDataLength (uint16): contiene la longitud de los datos de resultado resultantes, si existen [SWS_KeyM_00081].
• ResultDataPtr (const uint8*): apunta a los datos del resultado de verificación [SWS_KeyM_00081].

Concurrencia y restricciones

La función no posee valor de retorno (void) ni parámetros de salida o de entrada/salida [SWS_KeyM_00081]. La invocación se ejecuta de forma síncrona y reentrante [SWS_KeyM_00081]. Para este callback no se especifican códigos de error específicos ni mensajes DET o DEM; la información de estado y de error se transmite exclusivamente a la aplicación a través del parámetro Result [SWS_KeyM_00081].

Uso y semántica

La función de callback KeyM_ServiceCertificateCallbackNotification es llamada por el submódulo de certificados de KeyM para notificar a la aplicación la finalización de una operación de servicio de certificados [SWS_KeyM_00147]. La operación de certificados previa se ejecuta de forma asíncrona y, al finalizar, ejecuta este callback para transmitir los resultados a la aplicación [SWS_KeyM_00149].

A través de los parámetros de la función se transmiten todos los datos de resultado relevantes [SWS_KeyM_00147]:

• CertId: Identificador del certificado para el que se inició la operación.
• Result: Tipo KeyM_ResultType con el estado o resultado de la operación.
• ResultDataLength: Longitud de los datos de resultado, si existen.
• ResultDataPtr: Puntero a los datos de resultado.

La función en sí no posee valor de retorno (void) y presenta una semántica de ejecución síncrona [SWS_KeyM_00147].

Configuración y restricciones

El callback se proporciona a través de la cabecera KeyM_Externals.h, pero solo está disponible si el parámetro de configuración KeyMServiceCertificateFunctionEnabled está ajustado a TRUE [SWS_KeyM_00147]. El nombre real de la función de notificación se puede adaptar mediante el parámetro de configuración KeyMServiceCertificateCallbackNotificationFunc [SWS_KeyM_00147].

Concurrencia y tratamiento de errores

Según la especificación, la función está clasificada como reentrante [SWS_KeyM_00147]. Los estados de error o de éxito de la operación asíncrona previa se señalan mediante el parámetro de transferencia Result; en el payload no se definen mensajes de DET o DEM específicos para esta interfaz de callback [SWS_KeyM_00147].

usar

La función de callback KeyM_CertificateVerifyCallbackNotification sirve para notificar a la aplicación la finalización de una verificación de certificado [SWS_KeyM_00073]. La declaración está disponible a través de la cabecera KeyM_Externals.h, pudiéndose configurar el nombre de la función mediante el parámetro de configuración KeyMCertificateVerifyCallbackNotificationFunc [SWS_KeyM_00073].

En la llamada se transfieren dos parámetros de entrada [SWS_KeyM_00073]:

• CertId (tipo KeyM_CertificateIdType): Identificador del certificado verificado [SWS_KeyM_00073].
• Result (tipo KeyM_CertificateStatusType): Contiene información sobre el resultado de la operación de verificación [SWS_KeyM_00073].

La función devuelve como valor de estado de tipo Std_ReturnType el valor E_OK [SWS_KeyM_00073].

Ejecución y tratamiento de errores

La ejecución de la notificación está definida como síncrona y reentrante [SWS_KeyM_00073]. Para este callback no se prevén códigos de error específicos, valores de retorno divergentes ni notificaciones a DET o DEM [SWS_KeyM_00073]. Interpretación: Es probable que la implementación por parte de la aplicación deba diseñarse de forma segura para hilos para procesar llamadas simultáneas para diferentes certificados sin efectos secundarios. Pregunta Q-6bf5313c425fe1a8 (abierta)

usar

El tipo de datos KeyM_CertElementIteratorType está definido conforme a [SWS_KeyM_00042] como una estructura (Structure) y se pone a disposición a través del archivo de cabecera KeyM.h. Conforme a la especificación, este tipo sirve para iterar sobre una serie de elementos de un certificado ([SWS_KeyM_00042]). Dado que el contenido concreto de la estructura de datos se ha establecido expresamente como específico de la implementación ([SWS_KeyM_00042]), es de suponer que los usuarios consideren el tipo como un estado de iteración opaco y no accedan directamente a campos internos de la estructura. Pregunta Q-81b5deb7dcdf2812 (abierta)

Manejo y restricciones

De la especificación se derivan las siguientes condiciones marco prácticas para el uso:

• Estructura específica de la implementación: dado que los campos de KeyM_CertElementIteratorType se implementan de forma específica del fabricante ([SWS_KeyM_00042]), la disposición interna de la memoria depende de la respectiva realización del BSW.
• Gestión del estado: Interpretación: el llamador probablemente deba asignar una instancia de la estructura como contexto de iterador y pasarla a las funciones correspondientes para el recorrido de elementos de certificado, con el fin de realizar el seguimiento del progreso en la verificación o extracción de campos de certificado. Pregunta Q-5ddb438001abe656 (abierta)
• Concurrencia: presumiblemente, una instancia de iterador no se puede utilizar de forma concurrente sin sincronización externa a través de múltiples tareas si se producen accesos paralelos al mismo certificado. Pregunta Q-6b4b8b1cdc35f021 (abierta)

El tipo de enumeración KeyM_ServiceCertificateType se proporciona a través de la cabecera Rte_KeyM_Type.h y especifica la operación de servicio de certificado solicitada por el Key-Server, así como el tipo de información pasada con la función [SWS_KeyM_00039]. La declaración en el archivo de cabecera RTE debería indicar que el tipo se aplica ante todo en el intercambio de datos entre componentes de software y el módulo Key-Manager. Pregunta Q-37ed693ea3eda646 (abierta)

Para la gestión de certificados se han definido los siguientes códigos de operación estandarizados [SWS_KeyM_00039]:

• KEYM_SERVICE_CERT_REQUEST_CSR (0x01): El Key-Server solicita al Key-Client que genere un certificado o una solicitud de certificado (CSR) [SWS_KeyM_00039].
• KEYM_SERVICE_CERT_UPDATE_SIGNED_CSR (0x02): El servidor devuelve un certificado recibido previamente y firmado entretanto por la autoridad de certificación (CA) [SWS_KeyM_00039].
• KEYM_SERVICE_CERT_SET_ROOT (0x03) y KEYM_SERVICE_CERT_UPDATE_ROOT (0x04): Creación de un certificado raíz nuevo o actualización de uno existente [SWS_KeyM_00039].
• KEYM_SERVICE_CERT_SET_INTERMEDIATE (0x05) y KEYM_SERVICE_CERT_UPDATE_INTERMEDIATE (0x06): Adición o actualización de un certificado intermedio (certificado CA) [SWS_KeyM_00039].
• KEYM_SERVICE_CERT_UPDATE_CRL (0x07): Suministro o actualización de una lista de revocación de certificados (CRL) [SWS_KeyM_00039].

Como condición previa esencial, KEYM_SERVICE_CERT_SET_INTERMEDIATE exige que antes de establecer un certificado intermedio ya deba estar depositado el certificado raíz correspondiente para garantizar una verificación correcta [SWS_KeyM_00039]. Para extensiones específicas de proyecto, la especificación contempla el rango de valores reservado de 0x80 a 0x9F [SWS_KeyM_00039].

El tipo de enumeración KeyM_CertificateStatusType representa el resultado de las comprobaciones de certificados y refleja el estado actual de verificación y procesamiento de un certificado en el Key Manager [SWS_KeyM_91003]. El tipo se proporciona a través del encabezado Rte_KeyM_Type.h y sirve a los llamantes para evaluar de forma diferenciada el estado o causas de error específicas de una verificación de certificados [SWS_KeyM_91003].

Los valores de enumeración cubren tanto estados intermedios y de éxito regulares como patrones de error precisos [SWS_KeyM_91003]:

• KEYM_CERTIFICATE_VALID (0x00): El certificado se analizó sintácticamente y se verificó con éxito [SWS_KeyM_91003].
• KEYM_CERTIFICATE_INVALID (0x01): El certificado no es válido debido a un error no especificado [SWS_KeyM_91003].
• KEYM_CERTIFICATE_NOT_PARSED (0x02): El certificado todavía no se ha analizado sintácticamente [SWS_KeyM_91003].
• KEYM_CERTIFICATE_PARSED_NOT_VALIDATED (0x03): El certificado se ha analizado sintácticamente, pero todavía no se ha validado [SWS_KeyM_91003].
• KEYM_CERTIFICATE_NOT_AVAILABLE (0x04): No hay ningún certificado establecido [SWS_KeyM_91003].
• Resultados de comprobación específicos de error: periodo de validez fallido (KEYM_E_CERTIFICATE_VALIDITY_PERIOD_FAIL, 0x05), firma errónea (KEYM_E_CERTIFICATE_SIGNATURE_FAIL, 0x06), cadena de confianza no válida (KEYM_E_CERTIFICATE_INVALID_CHAIN_OF_TRUST, 0x07), tipo no válido (KEYM_E_CERTIFICATE_INVALID_TYPE, 0x08), formato erróneo (KEYM_E_CERTIFICATE_INVALID_FORMAT, 0x09), contenido no válido (KEYM_E_CERTIFICATE_INVALID_CONTENT, 0x0A), así como revocación o ámbito de validez no válido (KEYM_E_CERTIFICATE_REVOKED, 0x0B) [SWS_KeyM_91003].

Los llamadores deberían comprobar el estado antes de utilizar claves criptográficas; las operaciones normalmente solo deben basarse en un certificado si el estado señala explícitamente KEYM_CERTIFICATE_VALID. Dado que el tipo se declara mediante Rte_KeyM_Type.h, es probable que se utilice principalmente en interfaces de servicio y puertos estandarizados para la interacción entre KeyM y SWC de aplicación. Pregunta Q-f3ca10ee673798df (abierta)

Uso y estructura

El tipo de datos KeyM_CertificateElementType está especificado como array de bytes con el tipo de elemento uint8 y, según la especificación, sirve como área de memoria suficientemente grande para almacenar datos de un elemento de certificado [SWS_KeyM_91004]. La provisión y declaración del tipo de datos se realiza para el módulo KeyM a través del archivo de cabecera Rte_KeyM_Type.h [SWS_KeyM_91004].

Configuración y formación de variantes

La variante del tipo de datos está sujeta a una variación de nombre y tamaño dependiente de la configuración, que se deriva de los parámetros configurados del módulo [SWS_KeyM_91004]:

• Patrón de nombres: El nombre de tipo concreto se genera de forma específica para cada elemento según el esquema KeyM_CertificateElementType_{KeyMCertificate}_{KeyMCertificateElement}, donde los marcadores de posición corresponden a los nombres cortos configurados SHORT-NAME de las respectivas instancias de certificado y elemento de certificado [SWS_KeyM_91004].
• Tamaño del array: La cantidad de elementos uint8 se determina mediante el parámetro de configuración KeyMCertificateElementMaxLength, para que el array ofrezca suficiente espacio de almacenamiento para los datos brutos del elemento respectivo [SWS_KeyM_91004].

Restricciones y suposiciones

Dado que la definición se proporciona en Rte_KeyM_Type.h, es de suponer que el tipo se utilice principalmente como búfer estandarizado en las interfaces hacia componentes de software para el intercambio de contenidos de certificados [SWS_KeyM_91004]. Pregunta Q-994f8ac6772de3c1 (abierta) La longitud máxima de datos procesable permanece fijada estáticamente a la longitud máxima definida en el momento de la configuración [SWS_KeyM_91004].

Uso y definición de tipo

El tipo de datos KeyM_CryptoKeyDataType está definido como tipo puntero a uint8* y sirve como puntero a bytes para datos de entrada o salida dentro del módulo KeyM [SWS_KeyM_91012]. La definición del tipo se proporciona a través del archivo de cabecera Rte_KeyM_Type.h [SWS_KeyM_91012].

Restricciones y gestión de memoria

Al utilizar KeyM_CryptoKeyDataType como puntero a búferes de bytes deben tenerse en cuenta condiciones de contorno específicas:

• Interpretación: Dado que el tipo está especificado como un puntero a bytes simple (uint8*) [SWS_KeyM_91012], la asignación, el dimensionamiento y la validez de la memoria referenciada corresponden presumiblemente al invocador respectivo. Pregunta Q-07c167f400cbfb9c (abierta)
• Interpretación: Al transferirse como búfer de salida, es probable que deba garantizarse que el área de memoria referenciada sea lo suficientemente grande para los datos de clave o criptográficos que se van a recibir, con el fin de evitar desbordamientos de búfer. Pregunta (abierta)
• Interpretación: Para el acceso concurrente al búfer referenciado, es de prever que el software invocador requiera medidas de sincronización adicionales, ya que el tipo en sí no ofrece ningún mecanismo de sincronización. Pregunta (abierta)

Integración

Los invocadores que transfieren datos de claves criptográficas o certificados a interfaces de KeyM o los reciben de estas incluyen Rte_KeyM_Type.h para obtener acceso a la definición de puntero tipificada de KeyM_CryptoKeyDataType [SWS_KeyM_91012].

El tipo de enumeración KeyM_ResultType especifica el resultado de funciones asíncronas del módulo KeyM para la gestión de claves y certificados [SWS_KeyM_91008]. El tipo se proporciona a través del archivo de cabecera Rte_KeyM_Type.h y sirve para notificar el desenlace de una orden de trabajo asíncrona solicitada [SWS_KeyM_91008].

El rango de valores comprende códigos de estado y de error estandarizados para una evaluación diferenciada por parte de los llamadores [SWS_KeyM_91008]:

• KEYM_RT_OK (0x00): la operación de gestión de claves finalizó correctamente [SWS_KeyM_91008].
• KEYM_RT_NOT_OK (0x01): se produjo un error general durante la operación de gestión de claves [SWS_KeyM_91008].
• KEYM_RT_KEY_CERT_INVALID (0x02): la clave referenciada o el certificado no es válido y no se puede utilizar para la operación [SWS_KeyM_91008].
• KEYM_RT_KEY_CERT_WRITE_FAIL (0x03): falló la escritura de la clave o del certificado en la memoria de destino prevista [SWS_KeyM_91008].
• KEYM_RT_KEY_CERT_UPDATE_FAIL (0x04): error general durante la actualización de una clave o un certificado que no pudo precisarse mediante un código más específico [SWS_KeyM_91008].
• KEYM_RT_CERT_INVALID_CHAIN_OF_TRUST (0x05): la verificación del certificado falló debido a una cadena de confianza no válida [SWS_KeyM_91008].

Los llamadores de funciones asíncronas de KeyM deben evaluar este tipo de retorno para poder reaccionar de manera específica en caso de error ante cadenas de confianza no válidas, errores de acceso a memoria o material de clave incorrecto [SWS_KeyM_91008].

La estructura KeyM_CertDataType se utiliza en el módulo KeyM para el paso y el intercambio de datos de certificado a través de funciones de interfaz [SWS_KeyM_00041]. La definición del tipo está disponible a través del archivo de cabecera KeyM.h [SWS_KeyM_00041].

La estructura agrupa dos elementos esenciales [SWS_KeyM_00041]:

• certDataLength: Elemento de tipo uint32 que indica la longitud de los datos de certificado [SWS_KeyM_00041].
• certData: Elemento de tipo VoidPtr que referencia como puntero directamente a los datos de certificado en un área de datos local de la entidad que realiza la llamada [SWS_KeyM_00041].

Dado que certData apunta a áreas de memoria en el contexto local de la entidad que realiza la llamada [SWS_KeyM_00041], la gestión del búfer incumbe a dicha instancia que realiza la llamada. Interpretación: es de suponer que la entidad que realiza la llamada deba garantizar que la memoria referenciada permanezca válida durante todo el tiempo de ejecución de la función de interfaz respectiva y abarque al menos el número de bytes indicado en certDataLength. Pregunta Q-7da9d5ed0975ddbd (abierta) Además, es de suponer que con una longitud superior a cero deba pasarse un puntero válido distinto de NULL para evitar accesos erróneos a memoria dentro de la función de interfaz.