* @version 1.0
*/
-#include <client-manager-async-impl.h>
+#include <stdexcept>
+
#include <ckm/ckm-error.h>
#include <message-buffer.h>
#include <client-common.h>
-#include <stdexcept>
+
+#include <client-manager-async-impl.h>
namespace CKM {
{
}
-void ManagerAsync::Impl::saveKey(const ManagerAsync::ObserverPtr& observer,
- const Alias& alias,
- const KeyShPtr& key,
- const Policy& policy)
+void ManagerAsync::Impl::saveKey(const ObserverPtr& observer,
+ const Alias& alias,
+ const KeyShPtr& key,
+ const Policy& policy)
{
observerCheck(observer);
-
- if (!key) {
+ if (alias.empty() || !key) {
observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
return;
}
- saveBinaryData(observer, alias, toDBDataType(key->getType()), key->getDER(), policy);
+ Try {
+ saveBinaryData(observer, alias, DataType(key->getType()), key->getDER(), policy);
+ } Catch(DataType::Exception::Base) {
+ observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
+ }
}
void ManagerAsync::Impl::saveCertificate(const ObserverPtr& observer,
- const Alias& /*alias*/,
- const CertificateShPtr& /*cert*/,
- const Policy& /*policy*/)
+ const Alias& alias,
+ const CertificateShPtr& cert,
+ const Policy& policy)
{
observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+ if (alias.empty() || !cert) {
+ observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
+ return;
+ }
+ saveBinaryData(observer, alias, DataType::CERTIFICATE, cert->getDER(), policy);
}
+
void ManagerAsync::Impl::saveData(const ObserverPtr& observer,
- const Alias& /*alias*/,
- const RawBuffer& /*data*/,
- const Policy& /*policy*/)
+ const Alias& alias,
+ const RawBuffer& data,
+ const Policy& policy)
{
observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+ if (alias.empty() || data.empty()) {
+ observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
+ return;
+ }
+ saveBinaryData(observer, alias, DataType::BINARY_DATA, data, policy);
}
-void ManagerAsync::Impl::removeKey(const ObserverPtr& observer, const Alias& /*alias*/)
-{
- observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
-}
-void ManagerAsync::Impl::removeCertificate(const ObserverPtr& observer, const Alias& /*alias*/)
-{
- observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
-}
-void ManagerAsync::Impl::removeData(const ObserverPtr& observer, const Alias& /*alias*/)
+void ManagerAsync::Impl::saveBinaryData(const ManagerAsync::ObserverPtr& observer,
+ const Alias& alias,
+ DataType dataType,
+ const RawBuffer& rawData,
+ const Policy& policy)
{
- observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+ try_catch_async([&] {
+ AliasSupport helper(alias);
+ sendToStorage(observer,
+ static_cast<int>(LogicCommand::SAVE),
+ m_counter,
+ static_cast<int>(dataType),
+ helper.getName(),
+ helper.getLabel(),
+ rawData,
+ PolicySerializable(policy));
+ }, [&observer](int error){ observer->ReceivedError(error); } );
}
-void ManagerAsync::Impl::getKey(const ObserverPtr& observer,
- const Alias& /*alias*/,
- const Password& /*password*/)
+void ManagerAsync::Impl::savePKCS12(const ManagerAsync::ObserverPtr& observer,
+ const Alias &alias,
+ const PKCS12ShPtr &pkcs,
+ const Policy &keyPolicy,
+ const Policy &certPolicy)
{
- observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
-}
-void ManagerAsync::Impl::getCertificate(const ObserverPtr& observer,
- const Alias& /*alias*/,
- const Password& /*password*/)
-{
- observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
-}
-void ManagerAsync::Impl::getData(const ObserverPtr& observer,
- const Alias& /*alias*/,
- const Password& /*password*/)
-{
- observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
-}
+ 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));
-void ManagerAsync::Impl::getKeyAliasVector(const ObserverPtr& observer)
-{
- observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
-}
-void ManagerAsync::Impl::getCertificateAliasVector(const ObserverPtr& observer)
-{
- observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
-}
-void ManagerAsync::Impl::getDataAliasVector(const ObserverPtr& observer)
-{
- observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+ }, [&observer](int error){ observer->ReceivedError(error); } );
}
-void ManagerAsync::Impl::createKeyPairRSA(const ObserverPtr& observer,
- int /*size*/,
- const Alias& /*privateKeyAlias*/,
- const Alias& /*publicKeyAlias*/,
- const Policy& /*policyPrivateKey*/,
- const Policy& /*policyPublicKey*/)
-{
- observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
-}
-void ManagerAsync::Impl::createKeyPairDSA(const ObserverPtr& observer,
- int /*size*/,
- const Alias& /*privateKeyAlias*/,
- const Alias& /*publicKeyAlias*/,
- const Policy& /*policyPrivateKey*/,
- const Policy& /*policyPublicKey*/)
-{
- observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
-}
-void ManagerAsync::Impl::createKeyPairECDSA(const ObserverPtr& observer,
- const ElipticCurve /*type*/,
- const Alias& /*privateKeyAlias*/,
- const Alias& /*publicKeyAlias*/,
- const Policy& /*policyPrivateKey*/,
- const Policy& /*policyPublicKey*/)
+void ManagerAsync::Impl::removeAlias(const ManagerAsync::ObserverPtr& observer,
+ const Alias& alias)
{
observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+ if (alias.empty()) {
+ observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
+ return;
+ }
+ try_catch_async([&] {
+ AliasSupport helper(alias);
+ sendToStorage(observer,
+ static_cast<int>(LogicCommand::REMOVE),
+ m_counter,
+ helper.getName(),
+ helper.getLabel());
+ }, [&observer](int error){ observer->ReceivedError(error); } );
}
-void ManagerAsync::Impl::getCertificateChain(const ObserverPtr& observer,
- const CertificateShPtr& /*certificate*/,
- const CertificateShPtrVector& /*untrustedCertificates*/)
+void ManagerAsync::Impl::getBinaryData(const ManagerAsync::ObserverPtr& observer,
+ const Alias &alias,
+ DataType sendDataType,
+ const Password &password)
{
observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+ if (alias.empty()) {
+ observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
+ return;
+ }
+ try_catch_async([&] {
+ AliasSupport helper(alias);
+ sendToStorage(observer,
+ static_cast<int>(LogicCommand::GET),
+ m_counter,
+ static_cast<int>(sendDataType),
+ helper.getName(),
+ helper.getLabel(),
+ password);
+ }, [&observer](int error){ observer->ReceivedError(error); } );
}
-void ManagerAsync::Impl::getCertificateChain(const ObserverPtr& observer,
- const CertificateShPtr& /*certificate*/,
- const AliasVector& /*untrustedCertificates*/)
+void ManagerAsync::Impl::getPKCS12(const ManagerAsync::ObserverPtr& observer,
+ const Alias &alias,
+ const Password &passwordKey,
+ const Password &passwordCert)
{
observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+ 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*/,
- const RawBuffer& /*message*/,
- const HashAlgorithm /*hash*/,
- const RSAPaddingAlgorithm /*padding*/)
+ const Alias& privateKeyAlias,
+ const Password& password,
+ const RawBuffer& message,
+ const HashAlgorithm hash,
+ const RSAPaddingAlgorithm padding)
{
observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+ if (privateKeyAlias.empty() || message.empty()) {
+ observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
+ return;
+ }
+ try_catch_async([&] {
+ AliasSupport helper(privateKeyAlias);
+ sendToStorage(observer,
+ static_cast<int>(LogicCommand::CREATE_SIGNATURE),
+ m_counter,
+ helper.getName(),
+ helper.getLabel(),
+ password,
+ message,
+ static_cast<int>(hash),
+ static_cast<int>(padding));
+ }, [&observer](int error) {observer->ReceivedError(error);});
}
void ManagerAsync::Impl::verifySignature(const ObserverPtr& observer,
- const Alias& /*publicKeyOrCertAlias*/,
- const Password& /*password*/,
- const RawBuffer& /*message*/,
- const RawBuffer& /*signature*/,
- const HashAlgorithm /*hash*/,
- const RSAPaddingAlgorithm /*padding*/)
+ const Alias& publicKeyOrCertAlias,
+ const Password& password,
+ const RawBuffer& message,
+ const RawBuffer& signature,
+ const HashAlgorithm hash,
+ const RSAPaddingAlgorithm padding)
{
observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+ if (publicKeyOrCertAlias.empty() || message.empty() || signature.empty()) {
+ observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
+ return;
+ }
+ try_catch_async([&] {
+ AliasSupport helper(publicKeyOrCertAlias);
+ sendToStorage(observer,
+ static_cast<int>(LogicCommand::VERIFY_SIGNATURE),
+ m_counter,
+ helper.getName(),
+ helper.getLabel(),
+ password,
+ message,
+ signature,
+ static_cast<int>(hash),
+ static_cast<int>(padding));
+ }, [&observer](int error){ observer->ReceivedError(error); } );
}
void ManagerAsync::Impl::ocspCheck(const ObserverPtr& observer,
- const CertificateShPtrVector& /*certificateChainVector*/)
+ const CertificateShPtrVector& certificateChainVector)
{
observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+ if (certificateChainVector.empty()) {
+ observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
+ return;
+ }
+ 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());
+ }
+
+ m_counter++;
+ auto send = MessageBuffer::Serialize(m_counter, rawCertChain);
+
+ thread()->sendMessage(AsyncRequest(observer,
+ SERVICE_SOCKET_OCSP,
+ send.Pop(),
+ m_counter));
+ }, [&observer](int error){ observer->ReceivedError(error); } );
}
-void ManagerAsync::Impl::allowAccess(const ObserverPtr& observer,
- const std::string& /*alias*/,
- const std::string& /*accessor*/,
- AccessRight /*granted*/)
+void ManagerAsync::Impl::setPermission(const ObserverPtr& observer,
+ const Alias& alias,
+ const Label& accessor,
+ PermissionMask permissionMask)
{
observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+ if (alias.empty() || accessor.empty()) {
+ observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
+ return;
+ }
+ try_catch_async([&] {
+ AliasSupport helper(alias);
+ sendToStorage(observer,
+ static_cast<int>(LogicCommand::SET_PERMISSION),
+ m_counter,
+ helper.getName(),
+ helper.getLabel(),
+ accessor,
+ permissionMask);
+ }, [&observer](int error){ observer->ReceivedError(error); } );
}
-void ManagerAsync::Impl::denyAccess(const ObserverPtr& observer,
- const std::string& /*alias*/,
- const std::string& /*accessor*/)
+void ManagerAsync::Impl::getBinaryDataAliasVector(const ManagerAsync::ObserverPtr& observer,
+ DataType dataType)
{
observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+ try_catch_async([&] {
+ sendToStorage(observer,
+ static_cast<int>(LogicCommand::GET_LIST),
+ m_counter,
+ static_cast<int>(dataType));
+ }, [&observer](int error){ observer->ReceivedError(error); } );
}
-void ManagerAsync::Impl::saveBinaryData(const ManagerAsync::ObserverPtr& observer,
- const Alias& alias,
- DBDataType dataType,
- const RawBuffer& rawData,
- const Policy& policy)
+void ManagerAsync::Impl::createKeyPair(const ManagerAsync::ObserverPtr& observer,
+ const KeyType key_type,
+ const int additional_param,
+ const Alias &privateKeyAlias,
+ const Alias &publicKeyAlias,
+ const Policy &policyPrivateKey,
+ const Policy &policyPublicKey)
{
- if (alias.empty() || rawData.empty()) {
+ observerCheck(observer);
+ if (privateKeyAlias.empty() || publicKeyAlias.empty()) {
observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
return;
}
+ // input type check
+ CryptoAlgorithm keyGenAlgorithm;
+ switch(key_type)
+ {
+ case KeyType::KEY_RSA_PUBLIC:
+ case KeyType::KEY_RSA_PRIVATE:
+ keyGenAlgorithm.setParam(ParamName::ALGO_TYPE, AlgoType::RSA_GEN);
+ keyGenAlgorithm.setParam(ParamName::GEN_KEY_LEN, additional_param);
+ break;
- try_catch_async([&] {
- m_counter++;
+ case KeyType::KEY_DSA_PUBLIC:
+ case KeyType::KEY_DSA_PRIVATE:
+ keyGenAlgorithm.setParam(ParamName::ALGO_TYPE, AlgoType::DSA_GEN);
+ keyGenAlgorithm.setParam(ParamName::GEN_KEY_LEN, additional_param);
+ break;
- MessageBuffer send;
- Serialization::Serialize(send, static_cast<int>(LogicCommand::SAVE));
- Serialization::Serialize(send, m_counter);
- Serialization::Serialize(send, static_cast<int>(dataType));
- Serialization::Serialize(send, alias);
- Serialization::Serialize(send, rawData);
- Serialization::Serialize(send, PolicySerializable(policy));
+ case KeyType::KEY_ECDSA_PUBLIC:
+ case KeyType::KEY_ECDSA_PRIVATE:
+ keyGenAlgorithm.setParam(ParamName::ALGO_TYPE, AlgoType::ECDSA_GEN);
+ keyGenAlgorithm.setParam(ParamName::GEN_EC, additional_param);
+ break;
- thread()->sendMessage(AsyncRequest(observer,
- SERVICE_SOCKET_CKM_STORAGE,
- send.Pop(),
- m_counter));
+ default:
+ observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
+ return;
+ }
+
+ try_catch_async([&] {
+ AliasSupport prvHelper(privateKeyAlias);
+ AliasSupport pubHelper(publicKeyAlias);
+ sendToStorage(observer,
+ static_cast<int>(LogicCommand::CREATE_KEY_PAIR),
+ m_counter,
+ CryptoAlgorithmSerializable(keyGenAlgorithm),
+ PolicySerializable(policyPrivateKey),
+ PolicySerializable(policyPublicKey),
+ prvHelper.getName(),
+ prvHelper.getLabel(),
+ pubHelper.getName(),
+ pubHelper.getLabel());
+ }, [&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); } );
}
projects / platform / core / security / key-manager.git / blobdiff