classe ara::crypto::cryp::PrivateKey

L’interface ara::crypto::cryp::PrivateKey définit l’interface générale pour les clés privées asymétriques dans AUTOSAR Adaptive et est principalement gérée via l’alias de pointeur partagé PrivateKey::Sptr [SWS_CRYPT_22501]. Sa fonction centrale GetPublicKey() permet de récupérer la clé publique associée sous forme de PublicKey::Sptr afin de la mettre à disposition pour des opérations partenaires cryptographiques [SWS_CRYPT_22511]. Cette récupération est spécifiée comme sûre du point de vue des threads ainsi que sûre vis-à-vis des exceptions, sans codes d’erreur standardisés, les erreurs éventuelles devant être signalées de manière spécifique à l’implémentation via le type de retour ara::core::Result (interpretation). Question (ouverte)

plus ›

Contexte

L’interface ara::crypto::cryp::PrivateKey agit dans l’AUTOSAR Adaptive Platform comme une interface généralisée pour les clés privées asymétriques au sein du module crypto. Elle est déclarée dans le fichier d’en-tête ara/crypto/cryp/cryobj/private_key.h et dérive directement de l’interface de base CryptoObject. En tant que composant central du système de cryptographie asymétrique, PrivateKey encapsule le matériel de clé confidentiel requis pour les opérations cryptographiques telles que la génération de signatures numériques ou les procédés de déchiffrement asymétrique.

Parmi les principaux partenaires d’interaction figurent, outre la classe de base CryptoObject, en particulier l’interface de clé publique correspondante PublicKey ainsi que les services cryptographiques consommateurs et les routines applicatives. Alors que la clé privée doit toujours être gardée secrète, l’interface permet la mise à disposition directe de la clé publique associée [SWS_CRYPT_22511] via la fonction membre GetPublicKey(). De cette manière, une relation fixe liée au type est établie entre la clé privée et son homologue mathématique.

Diagramme de contexte : intégration de PrivateKey dans le modèle d’objets cryptographiques et relation avec la PublicKey correspondante. Sources : [SWS_CRYPT_22501], [SWS_CRYPT_22511]

Cycle de vie

La gestion et la transmission d'instances de l'interface PrivateKey s'effectuent via le pointeur intelligent typé PrivateKey::Sptr, qui est défini comme un alias de type pour std::shared_ptr<PrivateKey> [SWS_CRYPT_22501]. Ce pointeur partagé garantit une propriété partagée et une gestion automatique des ressources par comptage de références, de sorte que le matériel de clé protégé soit libéré dès que la dernière référence s'éteint.

Comme PrivateKey représente une interface abstraite avec des méthodes purement virtuelles telles que GetPublicKey() [SWS_CRYPT_22511], les applications ne peuvent pas instancier directement la classe. La création et la mise à disposition d'instances concrètes de PrivateKey::Sptr s'effectuent probablement via des fabriques spécialisées, des composants de gestion des clés ou des fournisseurs cryptographiques du système Adaptive (interprétation). Question Q-f0f9fe2258fac168 (ouverte) L'interface elle-même ne définit aucun état interne discret ni transition d'état.

En matière de concurrence, l'interface spécifie explicitement la sécurité des threads (thread-safe) pour la fonction membre centrale GetPublicKey() [SWS_CRYPT_22511]. Cela permet à plusieurs threads d'exécution d'effectuer un accès en lecture concurrent et sans synchronisation à la même instance de clé pour obtenir la clé publique correspondante.

Parcours d'utilisation

Le chemin d'utilisation typique de PrivateKey comprend la réception de la clé privée, puis l'extraction de la clé publique correspondante à des fins de validation, d'enregistrement ou de communication :

1. Obtention de la clé : le composant logiciel consommateur reçoit une instance valide d'une clé privée asymétrique sous la forme d'un PrivateKey::Sptr [SWS_CRYPT_22501].
2. Récupération de la clé partenaire : si la clé publique correspondante est requise pour un flux de travail en aval, le composant appelle la fonction membre GetPublicKey() sur l'instance [SWS_CRYPT_22511].
3. Traitement du résultat : l'appel renvoie un ara::core::Result<PublicKey::Sptr> [SWS_CRYPT_22511]. L'application vérifie la réussite de l'objet résultat et extrait le pointeur PublicKey::Sptr en cas d'exécution réussie.
4. Réutilisation : la clé publique obtenue peut ensuite être transmise à des partenaires de communication externes ou passée à des routines de vérification locales. La dérivation de la clé publique s'effectue probablement en interne directement à partir des paramètres mathématiques de la clé privée (interprétation). Question Q-464000dc5d638649 (ouverte)

Scénarios d'erreur

Pour une intégration exempte d'erreurs, les caractéristiques d'erreur et les conditions aux limites de GetPublicKey() sont déterminantes :

• Erreurs standardisées : conformément à la spécification, la fonction GetPublicKey() ne définit aucun code d'erreur standardisé [SWS_CRYPT_22511].
• Canal d'erreur : bien qu'aucune erreur standardisée ne soit définie, le type de retour ara::core::Result véhicule les échecs potentiels. Si une erreur survient lors de la dérivation interne de la clé ou de la création de l'objet, l'objet résultat contient probablement des codes d'erreur spécifiques à l'implémentation provenant des pilotes cryptographiques sous-jacents (interprétation). Question Q-4af6390594d9c5e1 (ouverte)
• Sécurité vis-à-vis des exceptions : la fonction est explicitement classée comme sûre vis-à-vis des exceptions (exception safe) et dotée de l'identifiant noexcept [SWS_CRYPT_22511]. Les appelants n'ont donc pas besoin d'intercepter d'exceptions C++.
• Préconditions et postconditions : la précondition pour un appel réussi est une instance valide et non libérée de PrivateKey. En guise de postcondition, l'interface garantit en cas de succès le retour d'un PublicKey::Sptr qui correspond mathématiquement de manière exacte à la clé privée [SWS_CRYPT_22511].