class ara::crypto::cryp::PrivateKey

The interface ara::crypto::cryp::PrivateKey defines the general interface for asymmetric private keys in AUTOSAR Adaptive and is primarily managed via the shared-pointer alias PrivateKey::Sptr [SWS_CRYPT_22501]. Its central function GetPublicKey() allows retrieving the associated public key as PublicKey::Sptr in order to provide it for cryptographic partner operations [SWS_CRYPT_22511]. This retrieval is specified as thread-safe and exception-safe without standardized error codes, where any errors would likely be signaled in an implementation-specific manner via the return type ara::core::Result (interpretation). Question (open)

more ›

Context

In the AUTOSAR Adaptive Platform, the interface ara::crypto::cryp::PrivateKey acts as a generalized interface for asymmetric private keys within the module crypto. It is declared in the header file ara/crypto/cryp/cryobj/private_key.h and derives directly from the base interface CryptoObject. As a core component of the asymmetric cryptography system, PrivateKey encapsulates the confidential key material required for cryptographic operations such as generating digital signatures or asymmetric decryption procedures.

In addition to the base class CryptoObject, the primary interaction partners include in particular the corresponding public key interface PublicKey as well as consuming crypto services and application routines. While the private key must always be kept secret, the interface enables the direct provisioning of the associated public key [SWS_CRYPT_22511] via the member function GetPublicKey(). In this way, a fixed type-related relationship between the private key and its mathematical counterpart is realized.

Context diagram: Embedding of PrivateKey in the cryptographic object model and relationship to the corresponding PublicKey. Sources: [SWS_CRYPT_22501], [SWS_CRYPT_22511]

Lifecycle

Instances of the interface PrivateKey are managed and passed via the typed smart pointer PrivateKey::Sptr, which is defined as a type alias for std::shared_ptr<PrivateKey> [SWS_CRYPT_22501]. This shared pointer ensures shared ownership and automatic resource management via reference counting, so that the protected key material is released as soon as the last reference expires.

Since PrivateKey represents an abstract interface with pure virtual methods such as GetPublicKey() [SWS_CRYPT_22511], applications cannot instantiate the class directly. The creation and provisioning of concrete instances of PrivateKey::Sptr is likely to take place via specialized factories, key management components, or crypto providers of the Adaptive system (interpretation). Question Q-f0f9fe2258fac168 (open) The interface itself defines no discrete internal states or state transitions.

Regarding concurrency, the interface explicitly specifies thread safety (thread-safe) for the central member function GetPublicKey() [SWS_CRYPT_22511]. This allows multiple threads of execution concurrent, synchronization-free read access to the same key instance to obtain the corresponding public key.

Usage Path

The typical usage path of PrivateKey includes receiving the private key and subsequently extracting the corresponding public key for validation, registration, or communication purposes:

1. Key acquisition: The consuming software component receives a valid instance of an asymmetric private key in the form of a PrivateKey::Sptr [SWS_CRYPT_22501].
2. Retrieving the partner key: If the corresponding public key is required for a downstream workflow, the component invokes the member function GetPublicKey() on the instance [SWS_CRYPT_22511].
3. Result processing: The call returns a ara::core::Result<PublicKey::Sptr> [SWS_CRYPT_22511]. The application checks the result object for success and, upon successful execution, unwraps the pointer PublicKey::Sptr.
4. Further usage: The obtained public key can subsequently be transmitted to external communication partners or passed to local verification routines. Internally, the derivation of the public key is presumably performed directly from the mathematical key parameters of the private key (interpretation). Question Q-464000dc5d638649 (open)

Error Scenarios

For error-free integration, the error properties and preconditions/postconditions of GetPublicKey() are decisive:

• Standardized errors: According to the specification, the function GetPublicKey() defines no standardized error codes [SWS_CRYPT_22511].
• Error channel: Although no standardized errors are defined, the return type ara::core::Result transports potential failures. If an error occurs during internal key derivation or object creation, the result object would likely contain implementation-specific error codes of the underlying crypto drivers (interpretation). Question Q-4af6390594d9c5e1 (open)
• Exception safety: The function is explicitly classified as exception-safe (exception safe) and designated with the identifier noexcept [SWS_CRYPT_22511]. Callers therefore do not need to catch C++ exceptions.
• Pre- and postconditions: The precondition for a successful call is a valid, unreleased PrivateKey instance. As a postcondition, the interface guarantees the return of a PublicKey::Sptr upon success that corresponds mathematically exactly to the private key [SWS_CRYPT_22511].