AES: add generation, save, get support.

[platform/core/security/key-manager.git] / src / manager / client-async / client-manager-async.cpp

diff --git a/src/manager/client-async/client-manager-async.cpp b/src/manager/client-async/client-manager-async.cpp
index 7c747bf..d97cfd9 100644 (file)
--- a/src/manager/client-async/client-manager-async.cpp
+++ b/src/manager/client-async/client-manager-async.cpp
@@ -24,6 +24,28 @@
 
 namespace CKM {
 
+namespace {
+RawBufferVector toRawBufferVector(const CertificateShPtrVector& certificates)
+{
+    RawBufferVector rawBufferVector;
+    for (auto &e: certificates) {
+        rawBufferVector.push_back(e->getDER());
+    }
+    return rawBufferVector;
+}
+
+LabelNameVector toLabelNameVector(const AliasVector& aliases)
+{
+    LabelNameVector labelNames;
+    for (auto &e: aliases) {
+        AliasSupport helper(e);
+        labelNames.push_back(std::make_pair(helper.getLabel(), helper.getName()));
+    }
+    return labelNames;
+}
+
+} // namespace anonymous
+
 ManagerAsync::ManagerAsync()
 {
     m_impl.reset(new Impl());
@@ -58,53 +80,60 @@ void ManagerAsync::saveData(const ObserverPtr& observer,
     m_impl->saveData(observer, alias, data, policy);
 }
 
-void ManagerAsync::removeKey(const ObserverPtr& observer, const Alias& alias)
-{
-    m_impl->removeKey(observer, alias);
-}
-
-void ManagerAsync::removeCertificate(const ObserverPtr& observer, const Alias& alias)
+void ManagerAsync::savePKCS12(const ObserverPtr& observer,
+                              const Alias &alias,
+                              const PKCS12ShPtr &pkcs,
+                              const Policy &keyPolicy,
+                              const Policy &certPolicy)
 {
-    m_impl->removeCertificate(observer, alias);
+    m_impl->savePKCS12(observer, alias, pkcs, keyPolicy, certPolicy);
 }
 
-void ManagerAsync::removeData(const ObserverPtr& observer, const Alias& alias)
+void ManagerAsync::removeAlias(const ObserverPtr& observer, const Alias& alias)
 {
-    m_impl->removeData(observer, alias);
+    m_impl->removeAlias(observer, alias);
 }
 
 void ManagerAsync::getKey(const ObserverPtr& observer, const Alias& alias, const Password& password)
 {
-    m_impl->getKey(observer, alias, password);
+    m_impl->getBinaryData(observer, alias, DataType::DB_KEY_FIRST, password);
 }
 
 void ManagerAsync::getCertificate(const ObserverPtr& observer,
                                   const Alias& alias,
                                   const Password& password)
 {
-    m_impl->getCertificate(observer, alias, password);
+    m_impl->getBinaryData(observer, alias, DataType::CERTIFICATE, password);
 }
 
 void ManagerAsync::getData(const ObserverPtr& observer,
                            const Alias& alias,
                            const Password& password)
 {
-    m_impl->getData(observer, alias, password);
+    m_impl->getBinaryData(observer, alias, DataType::BINARY_DATA, password);
+}
+
+void ManagerAsync::getPKCS12(const ObserverPtr& observer,
+                             const Alias &alias,
+                             const Password &keyPassword,
+                             const Password &certPassword)
+{
+    m_impl->getPKCS12(observer, alias, keyPassword, certPassword);
 }
 
 void ManagerAsync::getKeyAliasVector(const ObserverPtr& observer)
 {
-    m_impl->getKeyAliasVector(observer);
+    m_impl->getBinaryDataAliasVector(observer, DataType::DB_KEY_FIRST);
 }
 
 void ManagerAsync::getCertificateAliasVector(const ObserverPtr& observer)
 {
-    m_impl->getCertificateAliasVector(observer);
+    m_impl->getBinaryDataAliasVector(observer, DataType::CERTIFICATE);
 }
 
 void ManagerAsync::getDataAliasVector(const ObserverPtr& observer)
 {
-    m_impl->getDataAliasVector(observer);
+    m_impl->getBinaryDataAliasVector(observer, DataType::BINARY_DATA);
 }
 
 void ManagerAsync::createKeyPairRSA(const ObserverPtr& observer,
@@ -114,12 +143,13 @@ void ManagerAsync::createKeyPairRSA(const ObserverPtr& observer,
                                     const Policy& policyPrivateKey,
                                     const Policy& policyPublicKey)
 {
-    m_impl->createKeyPairRSA(observer,
-                             size,
-                             privateKeyAlias,
-                             publicKeyAlias,
-                             policyPrivateKey,
-                             policyPublicKey);
+    m_impl->createKeyPair(observer,
+                          KeyType::KEY_RSA_PUBLIC,
+                          size,
+                          privateKeyAlias,
+                          publicKeyAlias,
+                          policyPrivateKey,
+                          policyPublicKey);
 }
 
 void ManagerAsync::createKeyPairDSA(const ObserverPtr& observer,
@@ -129,12 +159,13 @@ void ManagerAsync::createKeyPairDSA(const ObserverPtr& observer,
                                     const Policy& policyPrivateKey,
                                     const Policy& policyPublicKey)
 {
-    m_impl->createKeyPairDSA(observer,
-                             size,
-                             privateKeyAlias,
-                             publicKeyAlias,
-                             policyPrivateKey,
-                             policyPublicKey);
+    m_impl->createKeyPair(observer,
+                          KeyType::KEY_DSA_PUBLIC,
+                          size,
+                          privateKeyAlias,
+                          publicKeyAlias,
+                          policyPrivateKey,
+                          policyPublicKey);
 }
 
 void ManagerAsync::createKeyPairECDSA(const ObserverPtr& observer,
@@ -144,26 +175,52 @@ void ManagerAsync::createKeyPairECDSA(const ObserverPtr& observer,
                                       const Policy& policyPrivateKey,
                                       const Policy& policyPublicKey)
 {
-    m_impl->createKeyPairECDSA(observer,
-                               type,
-                               privateKeyAlias,
-                               publicKeyAlias,
-                               policyPrivateKey,
-                               policyPublicKey);
+    m_impl->createKeyPair(observer,
+                          KeyType::KEY_ECDSA_PUBLIC,
+                          static_cast<int>(type),
+                          privateKeyAlias,
+                          publicKeyAlias,
+                          policyPrivateKey,
+                          policyPublicKey);
+}
+
+void ManagerAsync::createKeyAES(const ObserverPtr& observer,
+                                int size,
+                                const Alias &keyAlias,
+                                const Policy &policyKey)
+{
+    m_impl->createKeyAES(observer,
+                         size,
+                         keyAlias,
+                         policyKey);
 }
 
 void ManagerAsync::getCertificateChain(const ObserverPtr& observer,
                                        const CertificateShPtr& certificate,
-                                       const CertificateShPtrVector& untrustedCertificates)
+                                       const CertificateShPtrVector& untrustedCertificates,
+                                       const CertificateShPtrVector& trustedCertificates,
+                                       bool useSystemTrustedCertificates)
 {
-    m_impl->getCertificateChain(observer, certificate, untrustedCertificates);
+    m_impl->getCertChain(observer,
+                         LogicCommand::GET_CHAIN_CERT,
+                         certificate,
+                         toRawBufferVector(untrustedCertificates),
+                         toRawBufferVector(trustedCertificates),
+                         useSystemTrustedCertificates);
 }
 
 void ManagerAsync::getCertificateChain(const ObserverPtr& observer,
                                        const CertificateShPtr& certificate,
-                                       const AliasVector& untrustedCertificates)
+                                       const AliasVector& untrustedCertificates,
+                                       const AliasVector& trustedCertificates,
+                                       bool useSystemTrustedCertificates)
 {
-    m_impl->getCertificateChain(observer, certificate, untrustedCertificates);
+    m_impl->getCertChain(observer,
+                         LogicCommand::GET_CHAIN_ALIAS,
+                         certificate,
+                         toLabelNameVector(untrustedCertificates),
+                         toLabelNameVector(trustedCertificates),
+                         useSystemTrustedCertificates);
 }
 
 void ManagerAsync::createSignature(const ObserverPtr& observer,
@@ -193,19 +250,12 @@ void ManagerAsync::ocspCheck(const ObserverPtr& observer,
     m_impl->ocspCheck(observer, certificateChainVector);
 }
 
-void ManagerAsync::allowAccess(const ObserverPtr& observer,
-                               const std::string& alias,
-                               const std::string& accessor,
-                               AccessRight granted)
-{
-    m_impl->allowAccess(observer, alias, accessor, granted);
-}
-
-void ManagerAsync::denyAccess(const ObserverPtr& observer,
-                              const std::string& alias,
-                              const std::string& accessor)
+void ManagerAsync::setPermission(const ObserverPtr& observer,
+                                 const Alias& alias,
+                                 const Label& accessor,
+                                 PermissionMask permissionMask)
 {
-    m_impl->denyAccess(observer, alias, accessor);
+    m_impl->setPermission(observer, alias, accessor, permissionMask);
 }
 
 } // namespace CKM