AES: add generation, save, get support.

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

diff --git a/src/manager/client-async/storage-receiver.cpp b/src/manager/client-async/storage-receiver.cpp
index 60d0da6..17f8624 100644 (file)
--- a/src/manager/client-async/storage-receiver.cpp
+++ b/src/manager/client-async/storage-receiver.cpp
@@ -24,44 +24,10 @@
 #include <dpl/log/log.h>
 #include <key-impl.h>
 #include <certificate-impl.h>
+#include <client-common.h>
 
 namespace CKM {
 
-namespace {
-
-enum class DataType {
-    KEY,
-    CERT,
-    DATA
-};
-
-DataType type(int dbDataType)
-{
-    switch(static_cast<DBDataType>(dbDataType))
-    {
-    case DBDataType::KEY_RSA_PUBLIC:
-    case DBDataType::KEY_RSA_PRIVATE:
-    case DBDataType::KEY_ECDSA_PUBLIC:
-    case DBDataType::KEY_ECDSA_PRIVATE:
-    case DBDataType::KEY_DSA_PUBLIC:
-    case DBDataType::KEY_DSA_PRIVATE:
-    case DBDataType::KEY_AES:
-        return DataType::KEY;
-
-    case DBDataType::CERTIFICATE:
-        return DataType::CERT;
-
-    case DBDataType::BINARY_DATA:
-        return DataType::DATA;
-
-    default:
-        LogError("Unsupported data type: " <<dbDataType);
-        ThrowMsg(IReceiver::BadResponse, "Unsupported data type: " << dbDataType);
-    }
-}
-
-} // namespace anonymous
-
 StorageReceiver::StorageReceiver(MessageBuffer& buffer, AsyncRequest::Map& requests) :
     m_buffer(buffer),
     m_requests(requests),
@@ -71,7 +37,7 @@ StorageReceiver::StorageReceiver(MessageBuffer& buffer, AsyncRequest::Map& reque
 
 void StorageReceiver::parseResponse()
 {
-    int command, id;
+    int command = 0, id = 0;
     m_buffer.Deserialize(command, id);
 
     auto it = m_requests.find(id);
@@ -89,21 +55,27 @@ void StorageReceiver::parseResponse()
     switch (static_cast<LogicCommand>(command)) {
     case LogicCommand::GET:
         parseGetCommand();
-        break ;
+        break;
+    case LogicCommand::GET_PKCS12:
+        parseGetPKCS12Command();
+        break;
     case LogicCommand::GET_LIST:
         parseGetListCommand();
         break;
     case LogicCommand::SAVE:
         parseSaveCommand();
         break;
+    case LogicCommand::SAVE_PKCS12:
+        parseSavePKCS12Command();
+        break;
     case LogicCommand::REMOVE:
         parseRemoveCommand();
         break;
-    case LogicCommand::CREATE_KEY_PAIR_RSA:
-        parseRetCode(&ManagerAsync::Observer::ReceivedCreateKeyPairRSA);
+    case LogicCommand::CREATE_KEY_AES:
+        parseRetCode(&ManagerAsync::Observer::ReceivedCreateKeyAES);
         break;
-    case LogicCommand::CREATE_KEY_PAIR_ECDSA:
-        parseRetCode(&ManagerAsync::Observer::ReceivedCreateKeyPairECDSA);
+    case LogicCommand::CREATE_KEY_PAIR:
+        parseRetCode(&ManagerAsync::Observer::ReceivedCreateKeyPair);
         break;
     case LogicCommand::GET_CHAIN_CERT:
     case LogicCommand::GET_CHAIN_ALIAS:
@@ -115,14 +87,8 @@ void StorageReceiver::parseResponse()
     case LogicCommand::VERIFY_SIGNATURE:
         parseRetCode(&ManagerAsync::Observer::ReceivedVerifySignature);
         break;
-    case LogicCommand::CREATE_KEY_PAIR_DSA:
-        parseRetCode(&ManagerAsync::Observer::ReceivedCreateKeyPairDSA);
-        break;
-    case LogicCommand::ALLOW_ACCESS:
-        parseRetCode(&ManagerAsync::Observer::ReceivedAllowAccess);
-        break;
-    case LogicCommand::DENY_ACCESS:
-        parseRetCode(&ManagerAsync::Observer::ReceivedDenyAccess);
+    case LogicCommand::SET_PERMISSION:
+        parseRetCode(&ManagerAsync::Observer::ReceivedSetPermission);
         break;
 
     default:
@@ -135,7 +101,7 @@ void StorageReceiver::parseResponse()
 void StorageReceiver::parseGetCommand()
 {
     RawBuffer rawData;
-    int dataType, retCode;
+    int dataType = 0, retCode = 0;
     m_buffer.Deserialize(retCode, dataType, rawData);
 
     // check error code
@@ -144,25 +110,37 @@ void StorageReceiver::parseGetCommand()
          return;
     }
 
-    switch(type(dataType))
-    {
-    case DataType::KEY:
+    DataType type(dataType);
+    if (type.isKey())
         m_observer->ReceivedKey(KeyImpl(rawData));
-        break;
-    case DataType::CERT:
+    else if (type.isCertificate())
         m_observer->ReceivedCertificate(CertificateImpl(rawData, DataFormat::FORM_DER));
-        break;
-    case DataType::DATA:
+    else if (type.isBinaryData())
         m_observer->ReceivedData(std::move(rawData));
-        break;
+    else
+        m_observer->ReceivedError(CKM_API_ERROR_BAD_RESPONSE);
+}
+
+void StorageReceiver::parseGetPKCS12Command()
+{
+    int retCode;
+    PKCS12Serializable gotPkcs;
+    m_buffer.Deserialize(retCode, gotPkcs);
+
+    // check error code
+    if (retCode != CKM_API_SUCCESS) {
+         m_observer->ReceivedError(retCode);
+         return;
     }
+
+    m_observer->ReceivedPKCS12(std::make_shared<PKCS12Impl>(std::move(gotPkcs)));
 }
 
 void StorageReceiver::parseGetListCommand()
 {
-    int dataType, retCode;
-    AliasVector aliasVector;
-    m_buffer.Deserialize(retCode, dataType, aliasVector);
+    int dataType = 0, retCode = 0;
+    LabelNameVector labelNameVector;
+    m_buffer.Deserialize(retCode, dataType, labelNameVector);
 
     // check error code
     if (retCode != CKM_API_SUCCESS) {
@@ -170,23 +148,25 @@ void StorageReceiver::parseGetListCommand()
          return;
     }
 
-    switch(type(dataType))
-    {
-    case DataType::KEY:
+    AliasVector aliasVector;
+    for(const auto &it : labelNameVector)
+        aliasVector.push_back( AliasSupport::merge(it.first, it.second) );
+
+    DataType type(dataType);
+
+    if (type.isKey())
         m_observer->ReceivedKeyAliasVector(std::move(aliasVector));
-        break;
-    case DataType::CERT:
+    else if (type.isCertificate())
         m_observer->ReceivedCertificateAliasVector(std::move(aliasVector));
-        break;
-    case DataType::DATA:
+    else if (type.isBinaryData())
         m_observer->ReceivedDataAliasVector(std::move(aliasVector));
-        break;
-    }
+    else
+        m_observer->ReceivedError(CKM_API_ERROR_BAD_RESPONSE);
 }
 
 void StorageReceiver::parseSaveCommand()
 {
-    int dataType, retCode;
+    int dataType = 0, retCode = 0;
     m_buffer.Deserialize(retCode, dataType);
 
     // check error code
@@ -195,24 +175,35 @@ void StorageReceiver::parseSaveCommand()
          return;
     }
 
-    switch(type(dataType))
-    {
-    case DataType::KEY:
+    DataType type(dataType);
+    if (type.isKey())
         m_observer->ReceivedSaveKey();
-        break;
-    case DataType::CERT:
+    else if (type.isCertificate())
         m_observer->ReceivedSaveCertificate();
-        break;
-    case DataType::DATA:
+    else if (type.isBinaryData())
         m_observer->ReceivedSaveData();
-        break;
+    else
+        m_observer->ReceivedError(CKM_API_ERROR_BAD_RESPONSE);
+}
+
+void StorageReceiver::parseSavePKCS12Command()
+{
+    int retCode = 0;
+    m_buffer.Deserialize(retCode);
+
+    // check error code
+    if (retCode != CKM_API_SUCCESS) {
+         m_observer->ReceivedError(retCode);
+         return;
     }
+
+    m_observer->ReceivedSavePKCS12();
 }
 
 void StorageReceiver::parseRemoveCommand()
 {
-    int dataType, retCode;
-    m_buffer.Deserialize(retCode, dataType);
+    int retCode = 0;
+    m_buffer.Deserialize(retCode);
 
     // check error code
     if (retCode != CKM_API_SUCCESS) {
@@ -220,25 +211,14 @@ void StorageReceiver::parseRemoveCommand()
          return;
     }
 
-    switch(type(dataType))
-    {
-    case DataType::KEY:
-        m_observer->ReceivedSaveKey();
-        break;
-    case DataType::CERT:
-        m_observer->ReceivedSaveCertificate();
-        break;
-    case DataType::DATA:
-        m_observer->ReceivedSaveData();
-        break;
-    }
+    m_observer->ReceivedRemovedAlias();
 }
 
 void StorageReceiver::parseGetChainCertCommand()
 {
     CertificateShPtrVector certificateChainVector;
     RawBufferVector rawBufferVector;
-    int retCode;
+    int retCode = 0;
     m_buffer.Deserialize(retCode, rawBufferVector);
 
     // check error code
@@ -260,7 +240,7 @@ void StorageReceiver::parseGetChainCertCommand()
 
 void StorageReceiver::parseCreateSignatureCommand()
 {
-    int retCode;
+    int retCode = 0;
     RawBuffer signature;
     m_buffer.Deserialize(retCode, signature);
 
@@ -273,21 +253,7 @@ void StorageReceiver::parseCreateSignatureCommand()
     m_observer->ReceivedCreateSignature(std::move(signature));
 }
 
-void StorageReceiver::parseAllowAccessCommand()
-{
-    int retCode;
-    m_buffer.Deserialize(retCode);
-
-    // check error code
-    if (retCode != CKM_API_SUCCESS) {
-         m_observer->ReceivedError(retCode);
-         return;
-    }
-
-    m_observer->ReceivedAllowAccess();
-}
-
-void StorageReceiver::parseDenyAccessCommand()
+void StorageReceiver::parseSetPermission()
 {
     int retCode;
     m_buffer.Deserialize(retCode);
@@ -298,12 +264,12 @@ void StorageReceiver::parseDenyAccessCommand()
          return;
     }
 
-    m_observer->ReceivedDenyAccess();
+    m_observer->ReceivedSetPermission();
 }
 
 void StorageReceiver::parseRetCode(ObserverCb callback)
 {
-    int retCode;
+    int retCode = 0;
     m_buffer.Deserialize(retCode);
 
     // check error code