Feature #2451
Updated by Alex Afanasyev about 9 years ago
Refactoring code from the SecPubInfo interface, and more precisely the sec-pub-info-sqlite3 concrete implementation into a series of abstractions. The general design is as follows: - SecIdentityManager - a mechanism class that is used to interact with the TPM, Pib, and Identities - SecIdentityInfo - a value-semantic class used to manage information relating to a particular identity, including accessing any keys associated with the Identity - SecKeyInfo - a value-semantic type used to manage information relating to a particular key including the type of key and associated certificates - DbUtil - a utility class to encapsulate common functionality used to access sqlite database More complete public interfaces are included below. A current topic relevant to the design that needs to be settled are the circumstances in which we should throw an exception. class SecIdentityManager { // A mechanism class to manage access to identities, TPM, and Pib. public: class Error : public SecPublicInfo::Error { public: explicit SecIdentityManager(const std::string& dir = ""); // ACCESSORS /** * @brief Get TPM Locator * * @throws SecPublicInfo::Error if the TPM info does not exist */ std::string getTpmLocator() const; /** * @brief Get PIB Locator */ std::string getPibLocator() const; /** * @brief Check if the specified identity already exists * * @param identityName The identity name * @return true if the identity exists, otherwise false */ bool doesIdentityExist(const Name& identityName) const; /** * @brief Get name of the default identity * * @throws SecPublicInfo::Error if there is no default. */ SecIdentityInfo& getDefaultIdentity() const; /** * @brief Get all the identities from public info, return a vector * with the results. */ std::vector<SecIdentityInfo>&& getAllIdentities() const; /** * @brief return the scheme of the PibLocator */ std::string getScheme() const; // MANIPULATORS /** * @brief Set the corresponding TPM information to @p tpmLocator * * If the provided @p tpmLocator is different from the existing one, the PIB will be reset, * otherwise nothing will be changed. * * For legacy issue, the TPM info may not exist (some old PIB content may not have this info), * this method will simply set the TPM info as provided without changing anything else. Thus an * ideal process of handling old PIB is to check if TPM info exists. If it does not exist, * then set it to the default value according to configuration. */ void setTpmLocator(const std::string& tpmLocator); /** * @brief Add a new identity * * if identity already exist, do not add it again * * @param identityName The identity name to be added */ void addIdentity(const Name& identityName); /** * @brief Set the default identity * * @param identityName The default identity name */ void setDefaultIdentity(const Name& identity); /** * @brief Delete an identity and related public keys and certificates * * @param identity The identity name */ void deleteIdentityInfo(const Name& identityName); }; class SecIdentityInfo { public: //CREATORS /** * @brief Create an a new 'SecIdentityInfo' for the identity with the specified 'identityName'. * * @param identityName The identity name */ SecIdentityInfo(Name& identityName); //ACCESSORS bool doesPublicKeyExist(const Name& keyName) const; /** * @brief Generate a key name for this identity * * @param useKsk If true, generate a KSK name, otherwise a DSK name * @return The a "SecKeyInfo" for the new key */ SecKeyInfo& getNewKeyInfo(bool useKsk) const; /** * @brief Get all the keys associated with this identity * @return A vector of all keys */ std::vector<SecKeyInfo>&& getAllKeys() const; /** * @brief Get name of the default key name for this identity * * @throws SecPublicInfo::Error if there is no default * * @return The keyInfo for the requested key */ SecKeyInfo& getDefaultKey() const; /** * @brief Get the KeyInfo for the key with the specified 'keyName'. * * @param keyName The name of the desired key * * @return The keyInfo for the requested key */ SecKeyInfo& getKey(const Name& keyName) const; //MANIPULATORS /** * @brief Delete a public key and related certificates related to the key * of the specifed 'name' associated with this identity. * * @param keyName The key name */ void deletePublicKeyInfo(const Name& keyName); /** * @brief Add a public key to the identity storage. * * @param keyName The name of the public key to be added * @param publicKey Reference to the PublicKey object */ void addKey(const Name& keyName, const PublicKey& publicKey); /** * @brief Set the default key name for the corresponding identity * * @param keyName The key name * @throws SecPublicInfo::Error if the key does not exist */ void setDefaultKeyName(const Name& keyName) const; }; class SecKeyInfo { public: SecKeyInfo(const Name& keyName); // ACCESSORS /** * @brief Check if the specified certificate already exists * * @param certificateName The name of the certificate */ bool doesCertificateExist(const Name& certificateName) const; /** * @brief Get a shared pointer to identity certificate object from the identity storage corresponding to this Key. * * @param certificateName The name of the requested certificate * @throws SecPublicInfo::Error if the certificate does not exist */ shared_ptr<IdentityCertificate> getCertificate(const Name& certificateName) const; /** * @brief Get all the certificate name in public info * * @return A vector will all certificates for this key. */ std::vector<IdentityCertificate>&& getAllCertificates(); /** * @brief Get the type of the queried public key * * @note KeyType is also available from PublicKey instance. * This method is more efficient if only KeyType is needed. * * @param keyName The name of the requested public key * @return the type of the key. If the queried key does not exist, KEY_TYPE_NULL will be returned */ virtual KeyType getPublicKeyType(const Name& keyName) // MANIPULATOR /** * @brief Add a certificate to the identity storage. * * It will add the corresponding public key and identity if they do not exist * * @param certificate The certificate to be added */ void addCertificate(const IdentityCertificate& certificate) /** * @brief Delete a certificate * * @param certificateName The certificate name */ void deleteCertificateInfo(const Name& certificateName) /** * @brief Add a certificate into the public key identity storage and set the certificate as the * default one of the default identity * * @param certificate The certificate to be added * @throws SecPublicInfo::Error if the certificate cannot be added (though it is really rare) */ void addCertificateAsSystemDefault(const IdentityCertificate& certificate); };