classe ara::crypto::CryptoException

La classe ara::crypto::CryptoException agit dans l'AUTOSAR Adaptive Platform comme une exception spécialisée pour signaler les erreurs cryptographiques aux applications appelantes. Elle dérive de ara::core::Exception et est explicitement instanciée avec un ara::core::ErrorCode lors d'opérations ayant échoué [SWS_CRYPT_19906]. Grâce à sa spécification comme noexcept et sûre pour les threads, une génération fiable d'exceptions est garantie sans erreurs consécutives, y compris dans des environnements concurrents [SWS_CRYPT_19906]. Les applications doivent protéger les appels cryptographiques en conséquence afin d'éviter les exceptions non gérées et les interruptions de programme.

plus ›

Contexte

La classe ara::crypto::CryptoException définit le type d'exception central pour les états d'erreur au sein du module crypto de l'AUTOSAR Adaptive Platform. En tant que spécialisation de la classe d'exception standard ara::core::Exception, elle établit une passerelle entre le retour par code d'erreur principalement utilisé dans la plateforme et les mécanismes classiques de gestion des exceptions en C++. Elle est employée dans des architectures système où des opérations cryptographiques échouent et où cet état d'erreur doit être propagé à travers la pile d'appels sous forme d'exception. Parmi les partenaires d'interaction principaux figurent les modules fonctionnels et services cryptographiques, qui lèvent des exceptions lors d'erreurs imprévues ou de vérifications explicites, ainsi que les composants applicatifs de niveau supérieur, qui déclenchent des opérations cryptographiques telles que le chiffrement, la vérification de signature ou la gestion des clés et interceptent les erreurs éventuelles. Par son ancrage dans le concept commun de domaine d'erreur de la plateforme, ara::crypto::CryptoException garantit que les erreurs cryptographiques sont signalées de manière cohérente et typée à la logique applicative.

Cycle de vie

La création d'un objet de ara::crypto::CryptoException s'effectue de manière déterministe en transmettant un code d'erreur de type ara::core::ErrorCode au constructeur [SWS_CRYPT_19906]. Ce constructeur est déclaré comme explicit afin d'empêcher les conversions implicites de type à partir de codes d'erreur, et possède la spécification noexcept [SWS_CRYPT_19906]. Cette dernière garantit qu'aucune autre exception ne peut être levée lors de la construction de l'exception elle-même, ce qui augmente considérablement la sécurité vis-à-vis des exceptions et la sécurité de fonctionnement du sous-système crypto. Conformément à la spécification, l'implémentation est classée comme thread-safe [SWS_CRYPT_19906], de sorte que les instances peuvent être instanciées et traitées de manière fiable même dans des environnements d'exécution concurrents. Concernant la propriété, l'exception est généralement levée par valeur et liée comme référence constante dans le bloc d'interception. Comme la classe ne gère aucune ressource dynamique au-delà du code d'erreur, son cycle de vie se termine normalement en quittant le bloc catch traitant (interprétation). Question (ouverte)

Parcours d'utilisation

Le chemin d'utilisation normal commence au sein d'une opération cryptographique lorsqu'une condition d'erreur survient et ne peut pas être résolue localement. Le module identifie la cause de l'erreur à l'aide du domaine d'erreur cryptographique issu du fichier d'en-tête ara/crypto/common/crypto_error_domain.h et génère un ara::core::ErrorCode correspondant [SWS_CRYPT_19906]. Ensuite, une instance de ara::crypto::CryptoException est instanciée avec ce code d'erreur [SWS_CRYPT_19906] et signalée au moyen d'une instruction throw. Côté application, le composant appelant intercepte l'exception de manière ciblée via catch (const ara::crypto::CryptoException& e). Alternativement, la hiérarchie d'héritage permet également une interception polymorphe sous forme de ara::core::Exception générique. En interrogeant le ara::core::ErrorCode contenu, l'application peut ensuite analyser la cause spécifique de l'erreur cryptographique et prendre les contre-mesures appropriées.

Diagramme de séquence : déroulement typique de la gestion des erreurs et de la levée d'exceptions lors d'opérations cryptographiques. Sources : [SWS_CRYPT_19906]

Scénarios d'erreur

Comme ara::crypto::CryptoException constitue lui-même le vecteur de signalement des erreurs, l'attention principale lors des scénarios d'erreur porte sur la robustesse de la génération de l'exception. La garantie de sécurité vis-à-vis des exceptions et des threads ainsi que la garantie noexcept du constructeur évitent l'apparition d'exceptions secondaires lors d'un traitement d'erreur déjà actif [SWS_CRYPT_19906]. Un scénario d'erreur potentiel dans la logique applicative consiste en ce qu'un ara::core::ErrorCode transmis encapsule des domaines d'erreur inattendus ou non cryptographiques ; l'exception traite vraisemblablement le code d'erreur de manière neutre malgré tout et le transmet sans modification au gestionnaire (interprétation). Question Q-0bb3376f547ce024 (ouverte) Un autre risque au niveau du système réside dans l'omission de l'interception de l'exception, ce qui conduirait à l'appel de std::terminate dans l'environnement d'exécution C++. Par conséquent, les composants appelants qui utilisent des API sans retour basé sur des codes d'erreur doivent impérativement protéger les appels cryptographiques avec des blocs catch appropriés.