Fix parameter validation in ocsp

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

diff --git a/src/manager/client-async/client-manager-async-impl.cpp b/src/manager/client-async/client-manager-async-impl.cpp
index 30aa462..2a37c24 100644 (file)
--- a/src/manager/client-async/client-manager-async-impl.cpp
+++ b/src/manager/client-async/client-manager-async-impl.cpp
@@ -50,8 +50,8 @@ void ManagerAsync::Impl::saveKey(const ObserverPtr& observer,
         return;
     }
     Try {
-        saveBinaryData(observer, alias, DBDataType(key->getType()), key->getDER(), policy);
-    } Catch(DBDataType::Exception::Base) {
+        saveBinaryData(observer, alias, DataType(key->getType()), key->getDER(), policy);
+    } Catch(DataType::Exception::Base) {
         observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
     }
 }
@@ -66,7 +66,7 @@ void ManagerAsync::Impl::saveCertificate(const ObserverPtr& observer,
         observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
         return;
     }
-    saveBinaryData(observer, alias, DBDataType::CERTIFICATE, cert->getDER(), policy);
+    saveBinaryData(observer, alias, DataType::CERTIFICATE, cert->getDER(), policy);
 }
 
 void ManagerAsync::Impl::saveData(const ObserverPtr& observer,
@@ -79,12 +79,12 @@ void ManagerAsync::Impl::saveData(const ObserverPtr& observer,
         observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
         return;
     }
-    saveBinaryData(observer, alias, DBDataType::BINARY_DATA, data, policy);
+    saveBinaryData(observer, alias, DataType::BINARY_DATA, data, policy);
 }
 
 void ManagerAsync::Impl::saveBinaryData(const ManagerAsync::ObserverPtr& observer,
                                         const Alias& alias,
-                                        DBDataType dataType,
+                                        DataType dataType,
                                         const RawBuffer& rawData,
                                         const Policy& policy)
 {
@@ -101,6 +101,26 @@ void ManagerAsync::Impl::saveBinaryData(const ManagerAsync::ObserverPtr& observe
     }, [&observer](int error){ observer->ReceivedError(error); } );
 }
 
+void ManagerAsync::Impl::savePKCS12(const ManagerAsync::ObserverPtr& observer,
+                                    const Alias &alias,
+                                    const PKCS12ShPtr &pkcs,
+                                    const Policy &keyPolicy,
+                                    const Policy &certPolicy)
+{
+    try_catch_async([&] {
+        AliasSupport helper(alias);
+        sendToStorage(observer,
+                      static_cast<int>(LogicCommand::SAVE_PKCS12),
+                      m_counter,
+                      helper.getName(),
+                      helper.getLabel(),
+                      PKCS12Serializable(*pkcs.get()),
+                      PolicySerializable(keyPolicy),
+                      PolicySerializable(certPolicy));
+
+    }, [&observer](int error){ observer->ReceivedError(error); } );
+}
+
 void ManagerAsync::Impl::removeAlias(const ManagerAsync::ObserverPtr& observer,
                                      const Alias& alias)
 {
@@ -121,7 +141,7 @@ void ManagerAsync::Impl::removeAlias(const ManagerAsync::ObserverPtr& observer,
 
 void ManagerAsync::Impl::getBinaryData(const ManagerAsync::ObserverPtr& observer,
                                        const Alias &alias,
-                                       DBDataType sendDataType,
+                                       DataType sendDataType,
                                        const Password &password)
 {
     observerCheck(observer);
@@ -141,6 +161,28 @@ void ManagerAsync::Impl::getBinaryData(const ManagerAsync::ObserverPtr& observer
     }, [&observer](int error){ observer->ReceivedError(error); } );
 }
 
+void ManagerAsync::Impl::getPKCS12(const ManagerAsync::ObserverPtr& observer,
+                                   const Alias &alias,
+                                   const Password &passwordKey,
+                                   const Password &passwordCert)
+{
+    observerCheck(observer);
+    if (alias.empty()) {
+        observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
+        return;
+    }
+    try_catch_async([&] {
+        AliasSupport helper(alias);
+        sendToStorage(observer,
+                      static_cast<int>(LogicCommand::GET_PKCS12),
+                      m_counter,
+                      helper.getName(),
+                      helper.getLabel(),
+                      passwordKey,
+                      passwordCert);
+    }, [&observer](int error){ observer->ReceivedError(error); } );
+}
+
 void ManagerAsync::Impl::createSignature(const ObserverPtr& observer,
                                          const Alias& privateKeyAlias,
                                          const Password& password,
@@ -206,6 +248,8 @@ void ManagerAsync::Impl::ocspCheck(const ObserverPtr& observer,
     try_catch_async([&] {
         RawBufferVector rawCertChain;
         for (auto &e: certificateChainVector) {
+            if(!e || e->empty())
+                return observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
             rawCertChain.push_back(e->getDER());
         }
 
@@ -220,9 +264,9 @@ void ManagerAsync::Impl::ocspCheck(const ObserverPtr& observer,
 }
 
 void ManagerAsync::Impl::setPermission(const ObserverPtr& observer,
-                                         const Alias& alias,
-                                         const Label& accessor,
-                                         Permission newPermission)
+                                       const Alias& alias,
+                                       const Label& accessor,
+                                       PermissionMask permissionMask)
 {
     observerCheck(observer);
     if (alias.empty() || accessor.empty()) {
@@ -237,12 +281,12 @@ void ManagerAsync::Impl::setPermission(const ObserverPtr& observer,
                       helper.getName(),
                       helper.getLabel(),
                       accessor,
-                      static_cast<int>(newPermission));
+                      permissionMask);
     }, [&observer](int error){ observer->ReceivedError(error); } );
 }
 
 void ManagerAsync::Impl::getBinaryDataAliasVector(const ManagerAsync::ObserverPtr& observer,
-                                                  DBDataType dataType)
+                                                  DataType dataType)
 {
     observerCheck(observer);
     try_catch_async([&] {
@@ -267,22 +311,25 @@ void ManagerAsync::Impl::createKeyPair(const ManagerAsync::ObserverPtr& observer
         return;
     }
     // input type check
-    LogicCommand cmd_type;
+    CryptoAlgorithm keyGenAlgorithm;
     switch(key_type)
     {
         case KeyType::KEY_RSA_PUBLIC:
         case KeyType::KEY_RSA_PRIVATE:
-            cmd_type = LogicCommand::CREATE_KEY_PAIR_RSA;
+            keyGenAlgorithm.setParam(ParamName::ALGO_TYPE, AlgoType::RSA_GEN);
+            keyGenAlgorithm.setParam(ParamName::GEN_KEY_LEN, additional_param);
             break;
 
         case KeyType::KEY_DSA_PUBLIC:
         case KeyType::KEY_DSA_PRIVATE:
-            cmd_type = LogicCommand::CREATE_KEY_PAIR_DSA;
+            keyGenAlgorithm.setParam(ParamName::ALGO_TYPE, AlgoType::DSA_GEN);
+            keyGenAlgorithm.setParam(ParamName::GEN_KEY_LEN, additional_param);
             break;
 
         case KeyType::KEY_ECDSA_PUBLIC:
         case KeyType::KEY_ECDSA_PRIVATE:
-            cmd_type = LogicCommand::CREATE_KEY_PAIR_ECDSA;
+            keyGenAlgorithm.setParam(ParamName::ALGO_TYPE, AlgoType::ECDSA_GEN);
+            keyGenAlgorithm.setParam(ParamName::GEN_EC, additional_param);
             break;
 
         default:
@@ -294,9 +341,9 @@ void ManagerAsync::Impl::createKeyPair(const ManagerAsync::ObserverPtr& observer
         AliasSupport prvHelper(privateKeyAlias);
         AliasSupport pubHelper(publicKeyAlias);
         sendToStorage(observer,
-                      static_cast<int>(cmd_type),
+                      static_cast<int>(LogicCommand::CREATE_KEY_PAIR),
                       m_counter,
-                      static_cast<int>(additional_param),
+                      CryptoAlgorithmSerializable(keyGenAlgorithm),
                       PolicySerializable(policyPrivateKey),
                       PolicySerializable(policyPublicKey),
                       prvHelper.getName(),
@@ -306,6 +353,29 @@ void ManagerAsync::Impl::createKeyPair(const ManagerAsync::ObserverPtr& observer
     }, [&observer](int error){ observer->ReceivedError(error); } );
 }
 
+void ManagerAsync::Impl::createKeyAES(const ManagerAsync::ObserverPtr& observer,
+                                      const size_t  size,
+                                      const Alias  &keyAlias,
+                                      const Policy &policyKey)
+{
+    observerCheck(observer);
+    if (keyAlias.empty()) {
+        observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
+        return;
+    }
+
+    try_catch_async([&] {
+        AliasSupport aliasHelper(keyAlias);
+        sendToStorage(observer,
+                      static_cast<int>(LogicCommand::CREATE_KEY_AES),
+                      m_counter,
+                      static_cast<int>(size),
+                      PolicySerializable(policyKey),
+                      aliasHelper.getName(),
+                      aliasHelper.getLabel());
+    }, [&observer](int error){ observer->ReceivedError(error); } );
+}
+
 void ManagerAsync::Impl::observerCheck(const ManagerAsync::ObserverPtr& observer)
 {
     if(!observer)