Key generation uses CryptoAlgorithm object provided by the client.

Protocol changed: single command to generate all types of asymetric keys.

Change-Id: Iafe2b593c3945ff0e3fcc31241faea3a542aca65

diff --git a/src/include/ckm/ckm-manager-async.h b/src/include/ckm/ckm-manager-async.h
index 20faac2..21f8b64 100644 (file)
--- a/src/include/ckm/ckm-manager-async.h
+++ b/src/include/ckm/ckm-manager-async.h
@@ -64,9 +64,7 @@ public:
         virtual void ReceivedCertificateAliasVector(AliasVector &&) {}
         virtual void ReceivedDataAliasVector(AliasVector &&) {}
 
-        virtual void ReceivedCreateKeyPairRSA() {}
-        virtual void ReceivedCreateKeyPairDSA() {}
-        virtual void ReceivedCreateKeyPairECDSA() {}
+        virtual void ReceivedCreateKeyPair() {}
 
         virtual void ReceivedGetCertificateChain(CertificateShPtrVector &&) {}
 

diff --git a/src/manager/client-async/client-manager-async-impl.cpp b/src/manager/client-async/client-manager-async-impl.cpp
index 13db701..3056ab7 100644 (file)
--- a/src/manager/client-async/client-manager-async-impl.cpp
+++ b/src/manager/client-async/client-manager-async-impl.cpp
@@ -309,22 +309,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.addParam(ParamName::ALGO_TYPE, AlgoType::RSA_GEN);
+            keyGenAlgorithm.addParam(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.addParam(ParamName::ALGO_TYPE, AlgoType::DSA_GEN);
+            keyGenAlgorithm.addParam(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.addParam(ParamName::ALGO_TYPE, AlgoType::ECDSA_GEN);
+            keyGenAlgorithm.addParam(ParamName::GEN_EC, additional_param);
             break;
 
         default:
@@ -336,9 +339,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(),

diff --git a/src/manager/client-async/storage-receiver.cpp b/src/manager/client-async/storage-receiver.cpp
index 646f24a..a04dcba 100644 (file)
--- a/src/manager/client-async/storage-receiver.cpp
+++ b/src/manager/client-async/storage-receiver.cpp
@@ -71,11 +71,8 @@ void StorageReceiver::parseResponse()
     case LogicCommand::REMOVE:
         parseRemoveCommand();
         break;
-    case LogicCommand::CREATE_KEY_PAIR_RSA:
-        parseRetCode(&ManagerAsync::Observer::ReceivedCreateKeyPairRSA);
-        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:
@@ -87,9 +84,6 @@ 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::SET_PERMISSION:
         parseRetCode(&ManagerAsync::Observer::ReceivedSetPermission);
         break;

diff --git a/src/manager/client/client-manager-impl.cpp b/src/manager/client/client-manager-impl.cpp
index 9316cd8..91bb263 100644 (file)
--- a/src/manager/client/client-manager-impl.cpp
+++ b/src/manager/client/client-manager-impl.cpp
@@ -465,22 +465,25 @@ int ManagerImpl::createKeyPair(
     const Policy &policyPublicKey)
 {
     // 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.addParam(ParamName::ALGO_TYPE, AlgoType::RSA_GEN);
+            keyGenAlgorithm.addParam(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.addParam(ParamName::ALGO_TYPE, AlgoType::DSA_GEN);
+            keyGenAlgorithm.addParam(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.addParam(ParamName::ALGO_TYPE, AlgoType::ECDSA_GEN);
+            keyGenAlgorithm.addParam(ParamName::GEN_EC, additional_param);
             break;
 
         default:
@@ -495,9 +498,9 @@ int ManagerImpl::createKeyPair(
         MessageBuffer recv;
         AliasSupport privateHelper(privateKeyAlias);
         AliasSupport publicHelper(publicKeyAlias);
-        auto send = MessageBuffer::Serialize(static_cast<int>(cmd_type),
+        auto send = MessageBuffer::Serialize(static_cast<int>(LogicCommand::CREATE_KEY_PAIR),
                                              my_counter,
-                                             static_cast<int>(additional_param),
+                                             CryptoAlgorithmSerializable(keyGenAlgorithm),
                                              PolicySerializable(policyPrivateKey),
                                              PolicySerializable(policyPublicKey),
                                              privateHelper.getName(),

diff --git a/src/manager/common/data-type.cpp b/src/manager/common/data-type.cpp
index d724001..54efcd1 100644 (file)
--- a/src/manager/common/data-type.cpp
+++ b/src/manager/common/data-type.cpp
@@ -49,6 +49,20 @@ DataType::DataType(KeyType key) {
     }
 }
 
+DataType::DataType(AlgoType algorithmType) {
+    switch(algorithmType) {
+    case AlgoType::AES_CTR:
+    case AlgoType::AES_CBC:
+    case AlgoType::AES_GCM:
+    case AlgoType::AES_CFB:         m_dataType = DataType::KEY_AES;             break;
+    case AlgoType::RSA_GEN:         m_dataType = DataType::KEY_RSA_PUBLIC;      break;
+    case AlgoType::DSA_GEN:         m_dataType = DataType::KEY_DSA_PUBLIC;      break;
+    case AlgoType::ECDSA_GEN:       m_dataType = DataType::KEY_ECDSA_PUBLIC;    break;
+    default:
+        ThrowMsg(Exception::OutOfRange, "Invalid conversion from AlgoType to DBDataType");
+    }
+}
+
 DataType::DataType(int data)
   : m_dataType(static_cast<Type>(data))
 {

diff --git a/src/manager/common/data-type.h b/src/manager/common/data-type.h
index 2f5f008..b331d51 100644 (file)
--- a/src/manager/common/data-type.h
+++ b/src/manager/common/data-type.h
@@ -76,6 +76,7 @@ public:
     DataType(Type data);
     explicit DataType(int data);
     explicit DataType(KeyType key);
+    explicit DataType(AlgoType algorithmType);
     DataType(const DataType &) = default;
     DataType& operator=(const DataType &) = default;
 

diff --git a/src/manager/common/protocols.h b/src/manager/common/protocols.h
index 8d7d817..b136064 100644 (file)
--- a/src/manager/common/protocols.h
+++ b/src/manager/common/protocols.h
@@ -50,7 +50,6 @@ enum class ControlCommand : int {
     REMOVE_APP_DATA,
     UPDATE_CC_MODE,
     SET_PERMISSION
-    // for backward compatibility append new at the end
 };
 
 enum class LogicCommand : int {
@@ -58,17 +57,14 @@ enum class LogicCommand : int {
     GET_LIST,
     SAVE,
     REMOVE,
-    CREATE_KEY_PAIR_RSA,
-    CREATE_KEY_PAIR_ECDSA,
+    CREATE_KEY_PAIR,
     GET_CHAIN_CERT,
     GET_CHAIN_ALIAS,
     CREATE_SIGNATURE,
     VERIFY_SIGNATURE,
-    CREATE_KEY_PAIR_DSA,
     SET_PERMISSION,
     SAVE_PKCS12,
     GET_PKCS12
-    // for backward compatibility append new at the end
 };
 
 enum class EncryptionCommand : int {

diff --git a/src/manager/service/ckm-logic.cpp b/src/manager/service/ckm-logic.cpp
index 7b1ef96..8b0e433 100644 (file)
--- a/src/manager/service/ckm-logic.cpp
+++ b/src/manager/service/ckm-logic.cpp
@@ -1164,8 +1164,7 @@ int CKMLogic::saveDataHelper(
 
 int CKMLogic::createKeyPairHelper(
     const Credentials &cred,
-    const KeyType key_type,
-    const int additional_param,
+    const CryptoAlgorithmSerializable & keyGenParams,
     const Name &namePrivate,
     const Label &labelPrivate,
     const Name &namePublic,
@@ -1173,37 +1172,18 @@ int CKMLogic::createKeyPairHelper(
     const PolicySerializable &policyPrivate,
     const PolicySerializable &policyPublic)
 {
-    CryptoAlgorithm keyGenAlgorithm;
-    switch(key_type)
-    {
-        case KeyType::KEY_RSA_PUBLIC:
-        case KeyType::KEY_RSA_PRIVATE:
-            keyGenAlgorithm.addParam(ParamName::ALGO_TYPE, AlgoType::RSA_GEN);
-            keyGenAlgorithm.addParam(ParamName::GEN_KEY_LEN, additional_param);
-            break;
-
-        case KeyType::KEY_DSA_PUBLIC:
-        case KeyType::KEY_DSA_PRIVATE:
-            keyGenAlgorithm.addParam(ParamName::ALGO_TYPE, AlgoType::DSA_GEN);
-            keyGenAlgorithm.addParam(ParamName::GEN_KEY_LEN, additional_param);
-            break;
-
-        case KeyType::KEY_ECDSA_PUBLIC:
-        case KeyType::KEY_ECDSA_PRIVATE:
-            keyGenAlgorithm.addParam(ParamName::ALGO_TYPE, AlgoType::ECDSA_GEN);
-            keyGenAlgorithm.addParam(ParamName::GEN_EC, additional_param);
-            break;
-
-        default:
-            LogError("Invalid key_type for asymetric key generation: " << (int)key_type);
-            return CKM_API_ERROR_INPUT_PARAM;
-    }
-
     auto &handlerPriv = selectDatabase(cred, labelPrivate);
     auto &handlerPub = selectDatabase(cred, labelPublic);
 
+    AlgoType keyType = AlgoType::RSA_GEN;
+    if(!keyGenParams.getParam(ParamName::ALGO_TYPE, keyType))
+        ThrowMsg(Crypto::Exception::InputParam, "Error, parameter ALGO_TYPE not found.");
+    DataType dt(keyType);
+    if(!dt.isKey())
+        ThrowMsg(Crypto::Exception::InputParam, "Error, parameter ALGO_TYPE with wrong value.");
+
     bool exportable = policyPrivate.extractable || policyPublic.extractable;
-    TokenPair keys = m_decider.getStore(DataType(key_type), exportable).generateAKey(keyGenAlgorithm);
+    TokenPair keys = m_decider.getStore(dt, exportable).generateAKey(keyGenParams);
 
     DB::Crypto::Transaction transactionPriv(&handlerPriv.database);
     // in case the same database is used for private and public - the second
@@ -1235,9 +1215,8 @@ int CKMLogic::createKeyPairHelper(
 
 RawBuffer CKMLogic::createKeyPair(
     const Credentials &cred,
-    LogicCommand protocol_cmd,
     int commandId,
-    const int additional_param,
+    const CryptoAlgorithmSerializable & keyGenParams,
     const Name &namePrivate,
     const Label &labelPrivate,
     const Name &namePublic,
@@ -1247,27 +1226,10 @@ RawBuffer CKMLogic::createKeyPair(
 {
     int retCode = CKM_API_SUCCESS;
 
-    KeyType key_type = KeyType::KEY_NONE;
-    switch(protocol_cmd)
-    {
-        case LogicCommand::CREATE_KEY_PAIR_RSA:
-            key_type = KeyType::KEY_RSA_PUBLIC;
-            break;
-        case LogicCommand::CREATE_KEY_PAIR_DSA:
-            key_type = KeyType::KEY_DSA_PUBLIC;
-            break;
-        case LogicCommand::CREATE_KEY_PAIR_ECDSA:
-            key_type = KeyType::KEY_ECDSA_PUBLIC;
-            break;
-        default:
-            break;
-    }
-
     try {
         retCode = createKeyPairHelper(
                         cred,
-                        key_type,
-                        additional_param,
+                        keyGenParams,
                         namePrivate,
                         labelPrivate,
                         namePublic,
@@ -1300,7 +1262,8 @@ RawBuffer CKMLogic::createKeyPair(
         retCode = CKM_API_ERROR_SERVER_ERROR;
     }
 
-    return MessageBuffer::Serialize(static_cast<int>(protocol_cmd), commandId, retCode).Pop();
+    return MessageBuffer::Serialize(static_cast<int>(LogicCommand::CREATE_KEY_PAIR),
+                                    commandId, retCode).Pop();
 }
 
 int CKMLogic::readCertificateHelper(

diff --git a/src/manager/service/ckm-logic.h b/src/manager/service/ckm-logic.h
index 341d23d..3c889c2 100644 (file)
--- a/src/manager/service/ckm-logic.h
+++ b/src/manager/service/ckm-logic.h
@@ -127,9 +127,8 @@ public:
 
     RawBuffer createKeyPair(
         const Credentials &cred,
-        LogicCommand protocol_cmd,
         int commandId,
-        const int additional_param,
+        const CryptoAlgorithmSerializable & keyGenParams,
         const Name &namePrivate,
         const Label &labelPrivate,
         const Name &namePublic,
@@ -324,8 +323,7 @@ private:
 
     int createKeyPairHelper(
         const Credentials &cred,
-        const KeyType key_type,
-        const int additional_param,
+        const CryptoAlgorithmSerializable & keyGenParams,
         const Name &namePrivate,
         const Label &labelPrivate,
         const Name &namePublic,

diff --git a/src/manager/service/ckm-service.cpp b/src/manager/service/ckm-service.cpp
index de4e624..febbf7f 100644 (file)
--- a/src/manager/service/ckm-service.cpp
+++ b/src/manager/service/ckm-service.cpp
@@ -235,18 +235,16 @@ RawBuffer CKMService::ProcessStorage(Credentials &cred, MessageBuffer &buffer)
                 msgID,
                 DataType(tmpDataType));
         }
-        case LogicCommand::CREATE_KEY_PAIR_RSA:
-        case LogicCommand::CREATE_KEY_PAIR_DSA:
-        case LogicCommand::CREATE_KEY_PAIR_ECDSA:
+        case LogicCommand::CREATE_KEY_PAIR:
         {
-            int additional_param = 0;
+            CryptoAlgorithmSerializable keyGenAlgorithm;
             Name privateKeyName;
             Label privateKeyLabel;
             Name publicKeyName;
             Label publicKeyLabel;
             PolicySerializable policyPrivateKey;
             PolicySerializable policyPublicKey;
-            buffer.Deserialize(additional_param,
+            buffer.Deserialize(keyGenAlgorithm,
                                policyPrivateKey,
                                policyPublicKey,
                                privateKeyName,
@@ -255,9 +253,8 @@ RawBuffer CKMService::ProcessStorage(Credentials &cred, MessageBuffer &buffer)
                                publicKeyLabel);
             return m_logic->createKeyPair(
                 cred,
-                static_cast<LogicCommand>(command),
                 msgID,
-                additional_param,
+                keyGenAlgorithm,
                 privateKeyName,
                 privateKeyLabel,
                 publicKeyName,