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,
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,
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)
{
}, [&observer](int error){ observer->ReceivedError(error); } );
}
-void ManagerAsync::Impl::removeBinaryData(const ManagerAsync::ObserverPtr& observer,
- const Alias& alias,
- DBDataType dataType)
+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)
{
observerCheck(observer);
if (alias.empty()) {
sendToStorage(observer,
static_cast<int>(LogicCommand::REMOVE),
m_counter,
- static_cast<int>(dataType),
helper.getName(),
helper.getLabel());
}, [&observer](int error){ observer->ReceivedError(error); } );
void ManagerAsync::Impl::getBinaryData(const ManagerAsync::ObserverPtr& observer,
const Alias &alias,
- DBDataType sendDataType,
+ DataType sendDataType,
const Password &password)
{
observerCheck(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,
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());
}
}
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()) {
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([&] {
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:
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(),
}, [&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)