${KEY_MANAGER_CLIENT_ASYNC_SRC_PATH}/connection-thread.cpp
${KEY_MANAGER_CLIENT_ASYNC_SRC_PATH}/async-request.cpp
${KEY_MANAGER_CLIENT_ASYNC_SRC_PATH}/service.cpp
- ${KEY_MANAGER_CLIENT_ASYNC_SRC_PATH}/receiver.cpp
+ ${KEY_MANAGER_CLIENT_ASYNC_SRC_PATH}/storage-receiver.cpp
+ ${KEY_MANAGER_CLIENT_ASYNC_SRC_PATH}/ocsp-receiver.cpp
${KEY_MANAGER_CLIENT_CAPI_SRC_PATH}/ckmc-type.cpp
${KEY_MANAGER_CLIENT_CAPI_SRC_PATH}/ckmc-error.cpp
${KEY_MANAGER_CLIENT_CAPI_SRC_PATH}/ckmc-manager.cpp
* @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;
}
}
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, DBDataType::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, DBDataType::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,
+ DBDataType dataType,
+ const RawBuffer& rawData,
+ const Policy& policy)
{
- observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+ try_catch_async([&] {
+ sendToStorage(observer,
+ static_cast<int>(LogicCommand::SAVE),
+ m_counter,
+ static_cast<int>(dataType),
+ alias,
+ rawData,
+ PolicySerializable(policy));
+ }, [&observer](int error){ observer->ReceivedError(error); } );
}
-void ManagerAsync::Impl::getKey(const ObserverPtr& observer,
- const Alias& /*alias*/,
- const Password& /*password*/)
-{
- 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*/)
+void ManagerAsync::Impl::removeBinaryData(const ManagerAsync::ObserverPtr& observer,
+ const Alias& alias,
+ DBDataType dataType)
{
observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+ if (alias.empty()) {
+ observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
+ return;
+ }
+ try_catch_async([&] {
+ sendToStorage(observer,
+ static_cast<int>(LogicCommand::REMOVE),
+ m_counter,
+ static_cast<int>(dataType),
+ alias);
+ }, [&observer](int error){ observer->ReceivedError(error); } );
}
-void ManagerAsync::Impl::getKeyAliasVector(const ObserverPtr& observer)
+void ManagerAsync::Impl::getBinaryData(const ManagerAsync::ObserverPtr& observer,
+ const Alias &alias,
+ DBDataType sendDataType,
+ const Password &password)
{
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);
+ if (alias.empty()) {
+ observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
+ return;
+ }
+ try_catch_async([&] {
+ sendToStorage(observer,
+ static_cast<int>(LogicCommand::GET),
+ m_counter,
+ static_cast<int>(sendDataType),
+ alias,
+ password);
+ }, [&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::createSignature(const ObserverPtr& observer,
+ 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([&] {
+ sendToStorage(observer,
+ static_cast<int>(LogicCommand::CREATE_SIGNATURE),
+ m_counter,
+ privateKeyAlias,
+ password,
+ message,
+ static_cast<int>(hash),
+ static_cast<int>(padding));
+ }, [&observer](int error) {observer->ReceivedError(error);});
}
-void ManagerAsync::Impl::getCertificateChain(const ObserverPtr& observer,
- const CertificateShPtr& /*certificate*/,
- const CertificateShPtrVector& /*untrustedCertificates*/)
+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)
{
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([&] {
+ sendToStorage(observer,
+ static_cast<int>(LogicCommand::VERIFY_SIGNATURE),
+ m_counter,
+ publicKeyOrCertAlias,
+ password,
+ message,
+ signature,
+ static_cast<int>(hash),
+ static_cast<int>(padding));
+ }, [&observer](int error){ observer->ReceivedError(error); } );
}
-void ManagerAsync::Impl::getCertificateChain(const ObserverPtr& observer,
- const CertificateShPtr& /*certificate*/,
- const AliasVector& /*untrustedCertificates*/)
+void ManagerAsync::Impl::ocspCheck(const ObserverPtr& observer,
+ 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) {
+ rawCertChain.push_back(e->getDER());
+ }
-void ManagerAsync::Impl::createSignature(const ObserverPtr& observer,
- const Alias& /*privateKeyAlias*/,
- const Password& /*password*/,
- const RawBuffer& /*message*/,
- const HashAlgorithm /*hash*/,
- const RSAPaddingAlgorithm /*padding*/)
-{
- observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
-}
+ m_counter++;
+ auto send = MessageBuffer::Serialize(m_counter, rawCertChain);
-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*/)
-{
- observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+ thread()->sendMessage(AsyncRequest(observer,
+ SERVICE_SOCKET_OCSP,
+ send.Pop(),
+ m_counter));
+ }, [&observer](int error){ observer->ReceivedError(error); } );
}
-void ManagerAsync::Impl::ocspCheck(const ObserverPtr& observer,
- const CertificateShPtrVector& /*certificateChainVector*/)
+void ManagerAsync::Impl::allowAccess(const ObserverPtr& observer,
+ const std::string& alias,
+ const std::string& accessor,
+ AccessRight granted)
{
observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+ if (alias.empty() || accessor.empty()) {
+ observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
+ return;
+ }
+ try_catch_async([&] {
+ sendToStorage(observer,
+ static_cast<int>(LogicCommand::ALLOW_ACCESS),
+ m_counter,
+ alias,
+ accessor,
+ static_cast<int>(granted));
+ }, [&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::denyAccess(const ObserverPtr& observer,
+ const std::string& alias,
+ const std::string& accessor)
{
observerCheck(observer);
- observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+ if (alias.empty() || accessor.empty()) {
+ observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
+ return;
+ }
+ try_catch_async([&] {
+ sendToStorage(observer,
+ static_cast<int>(LogicCommand::DENY_ACCESS),
+ m_counter,
+ alias,
+ accessor);
+ }, [&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,
+ DBDataType 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
+ LogicCommand cmd_type;
+ switch(key_type)
+ {
+ case KeyType::KEY_RSA_PUBLIC:
+ case KeyType::KEY_RSA_PRIVATE:
+ cmd_type = LogicCommand::CREATE_KEY_PAIR_RSA;
+ break;
- try_catch_async([&] {
- m_counter++;
+ case KeyType::KEY_DSA_PUBLIC:
+ case KeyType::KEY_DSA_PRIVATE:
+ cmd_type = LogicCommand::CREATE_KEY_PAIR_DSA;
+ break;
- auto send = MessageBuffer::Serialize(static_cast<int>(LogicCommand::SAVE),
- m_counter,
- static_cast<int>(dataType),
- alias,
- rawData,
- PolicySerializable(policy));
+ case KeyType::KEY_ECDSA_PUBLIC:
+ case KeyType::KEY_ECDSA_PRIVATE:
+ cmd_type = LogicCommand::CREATE_KEY_PAIR_ECDSA;
+ 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([&] {
+ sendToStorage(observer,
+ static_cast<int>(cmd_type),
+ m_counter,
+ static_cast<int>(additional_param),
+ PolicySerializable(policyPrivateKey),
+ PolicySerializable(policyPublicKey),
+ privateKeyAlias,
+ publicKeyAlias);
}, [&observer](int error){ observer->ReceivedError(error); } );
}
const RawBuffer& data,
const Policy& policy);
- void removeKey(const ObserverPtr& observer, const Alias& alias);
- void removeCertificate(const ObserverPtr& observer, const Alias& alias);
- void removeData(const ObserverPtr& observer, const Alias& alias);
-
- void getKey(const ObserverPtr& observer, const Alias& alias, const Password& password);
- void getCertificate(const ObserverPtr& observer, const Alias& alias, const Password& password);
- void getData(const ObserverPtr& observer, const Alias& alias, const Password& password);
-
- void getKeyAliasVector(const ObserverPtr& observer);
- void getCertificateAliasVector(const ObserverPtr& observer);
- void getDataAliasVector(const ObserverPtr& observer);
-
- void createKeyPairRSA(
- const ObserverPtr& observer,
- int size,
- const Alias& privateKeyAlias,
- const Alias& publicKeyAlias,
- const Policy& policyPrivateKey,
- const Policy& policyPublicKey);
- void createKeyPairDSA(
- const ObserverPtr& observer,
- int size,
- const Alias& privateKeyAlias,
- const Alias& publicKeyAlias,
- const Policy& policyPrivateKey,
- const Policy& policyPublicKey);
- void createKeyPairECDSA(
- const ObserverPtr& observer,
- const ElipticCurve type,
- const Alias& privateKeyAlias,
- const Alias& publicKeyAlias,
- const Policy& policyPrivateKey,
- const Policy& policyPublicKey);
-
- void getCertificateChain(
- const ObserverPtr& observer,
- const CertificateShPtr& certificate,
- const CertificateShPtrVector& untrustedCertificates);
- void getCertificateChain(
- const ObserverPtr& observer,
- const CertificateShPtr& certificate,
- const AliasVector& untrustedCertificates);
-
void createSignature(
const ObserverPtr& observer,
const Alias& privateKeyAlias,
const std::string& alias,
const std::string& accessor);
+ // generic methods
+ void saveBinaryData(
+ const ManagerAsync::ObserverPtr& observer,
+ const Alias& alias,
+ DBDataType dataType,
+ const RawBuffer& rawData,
+ const Policy& policy);
+
+ void removeBinaryData(
+ const ManagerAsync::ObserverPtr& observer,
+ const Alias &alias,
+ DBDataType dataType);
+
+ void getBinaryData(
+ const ManagerAsync::ObserverPtr& observer,
+ const Alias &alias,
+ DBDataType sendDataType,
+ const Password &password);
+
+ void getBinaryDataAliasVector(
+ const ManagerAsync::ObserverPtr& observer,
+ DBDataType dataType);
+
+ void 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);
+
+ template <typename T>
+ void getCertChain(
+ const ManagerAsync::ObserverPtr& observer,
+ LogicCommand command,
+ const CertificateShPtr &certificate,
+ const T &sendData)
+ {
+ observerCheck(observer);
+ if (!certificate || sendData.empty()) {
+ observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
+ return;
+ }
+ try_catch_async([&] {
+ sendToStorage(observer,
+ static_cast<int>(command),
+ m_counter,
+ certificate->getDER(),
+ sendData);
+ }, [&observer](int error){ observer->ReceivedError(error); } );
+ }
+
private:
- void saveBinaryData(const ManagerAsync::ObserverPtr& observer,
- const Alias& alias,
- DBDataType dataType,
- const RawBuffer& rawData,
- const Policy& policy);
+
+ template <typename... Args>
+ void sendToStorage(const ManagerAsync::ObserverPtr& observer, const Args&... args)
+ {
+ m_counter++; // yes, it changes m_counter argument passed in args
+
+ auto send = MessageBuffer::Serialize(args...);
+ thread()->sendMessage(AsyncRequest(observer,
+ SERVICE_SOCKET_CKM_STORAGE,
+ send.Pop(),
+ m_counter));
+ }
void observerCheck(const ManagerAsync::ObserverPtr& observer);
void ManagerAsync::removeKey(const ObserverPtr& observer, const Alias& alias)
{
- m_impl->removeKey(observer, alias);
+ m_impl->removeBinaryData(observer, alias, DBDataType::DB_KEY_FIRST);
}
void ManagerAsync::removeCertificate(const ObserverPtr& observer, const Alias& alias)
{
- m_impl->removeCertificate(observer, alias);
+ m_impl->removeBinaryData(observer, alias, DBDataType::CERTIFICATE);
}
void ManagerAsync::removeData(const ObserverPtr& observer, const Alias& alias)
{
- m_impl->removeData(observer, alias);
+ m_impl->removeBinaryData(observer, alias, DBDataType::BINARY_DATA);
}
void ManagerAsync::getKey(const ObserverPtr& observer, const Alias& alias, const Password& password)
{
- m_impl->getKey(observer, alias, password);
+ m_impl->getBinaryData(observer, alias, DBDataType::DB_KEY_FIRST, password);
}
void ManagerAsync::getCertificate(const ObserverPtr& observer,
const Alias& alias,
const Password& password)
{
- m_impl->getCertificate(observer, alias, password);
+ m_impl->getBinaryData(observer, alias, DBDataType::CERTIFICATE, password);
}
void ManagerAsync::getData(const ObserverPtr& observer,
const Alias& alias,
const Password& password)
{
- m_impl->getData(observer, alias, password);
+ m_impl->getBinaryData(observer, alias, DBDataType::BINARY_DATA, password);
}
void ManagerAsync::getKeyAliasVector(const ObserverPtr& observer)
{
- m_impl->getKeyAliasVector(observer);
+ m_impl->getBinaryDataAliasVector(observer, DBDataType::DB_KEY_FIRST);
}
void ManagerAsync::getCertificateAliasVector(const ObserverPtr& observer)
{
- m_impl->getCertificateAliasVector(observer);
+ m_impl->getBinaryDataAliasVector(observer, DBDataType::CERTIFICATE);
}
void ManagerAsync::getDataAliasVector(const ObserverPtr& observer)
{
- m_impl->getDataAliasVector(observer);
+ m_impl->getBinaryDataAliasVector(observer, DBDataType::BINARY_DATA);
}
void ManagerAsync::createKeyPairRSA(const ObserverPtr& observer,
const Policy& policyPrivateKey,
const Policy& policyPublicKey)
{
- m_impl->createKeyPairRSA(observer,
- size,
- privateKeyAlias,
- publicKeyAlias,
- policyPrivateKey,
- policyPublicKey);
+ m_impl->createKeyPair(observer,
+ KeyType::KEY_RSA_PUBLIC,
+ size,
+ privateKeyAlias,
+ publicKeyAlias,
+ policyPrivateKey,
+ policyPublicKey);
}
void ManagerAsync::createKeyPairDSA(const ObserverPtr& observer,
const Policy& policyPrivateKey,
const Policy& policyPublicKey)
{
- m_impl->createKeyPairDSA(observer,
- size,
- privateKeyAlias,
- publicKeyAlias,
- policyPrivateKey,
- policyPublicKey);
+ m_impl->createKeyPair(observer,
+ KeyType::KEY_DSA_PUBLIC,
+ size,
+ privateKeyAlias,
+ publicKeyAlias,
+ policyPrivateKey,
+ policyPublicKey);
}
void ManagerAsync::createKeyPairECDSA(const ObserverPtr& observer,
const Policy& policyPrivateKey,
const Policy& policyPublicKey)
{
- m_impl->createKeyPairECDSA(observer,
- type,
- privateKeyAlias,
- publicKeyAlias,
- policyPrivateKey,
- policyPublicKey);
+ m_impl->createKeyPair(observer,
+ KeyType::KEY_ECDSA_PUBLIC,
+ static_cast<int>(type),
+ privateKeyAlias,
+ publicKeyAlias,
+ policyPrivateKey,
+ policyPublicKey);
}
void ManagerAsync::getCertificateChain(const ObserverPtr& observer,
const CertificateShPtr& certificate,
const CertificateShPtrVector& untrustedCertificates)
{
- m_impl->getCertificateChain(observer, certificate, untrustedCertificates);
+ RawBufferVector rawBufferVector;
+
+ for (auto &e: untrustedCertificates) {
+ rawBufferVector.push_back(e->getDER());
+ }
+
+ m_impl->getCertChain(observer,
+ LogicCommand::GET_CHAIN_CERT,
+ certificate,
+ rawBufferVector);
}
void ManagerAsync::getCertificateChain(const ObserverPtr& observer,
const CertificateShPtr& certificate,
const AliasVector& untrustedCertificates)
{
- m_impl->getCertificateChain(observer, certificate, untrustedCertificates);
+ m_impl->getCertChain(observer,
+ LogicCommand::GET_CHAIN_ALIAS,
+ certificate,
+ untrustedCertificates);
}
void ManagerAsync::createSignature(const ObserverPtr& observer,
m_waitingReqs.push(std::move(req));
lock.unlock();
- // notifty via pipe
+ // notify via pipe
m_pipe.notify();
}
* limitations under the License
*/
/*
- * @file receiver.cpp
+ * @file ocsp-receiver.cpp
* @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
* @version 1.0
*/
-#include <receiver.h>
+#include <ocsp-receiver.h>
#include <protocols.h>
#include <dpl/log/log.h>
namespace CKM {
-Receiver::Receiver(MessageBuffer& buffer, AsyncRequest::Map& requests) :
+OcspReceiver::OcspReceiver(MessageBuffer& buffer, AsyncRequest::Map& requests) :
m_buffer(buffer),
- m_requests(requests),
- m_observer(NULL)
+ m_requests(requests)
{
}
-void Receiver::parseResponse()
+void OcspReceiver::parseResponse()
{
- int command;
- int id;
- m_buffer.Deserialize(command, id);
+ int id, retCode, ocspStatus;
+ m_buffer.Deserialize(id, retCode, ocspStatus);
auto it = m_requests.find(id);
if (it == m_requests.end()) {
AsyncRequest req = std::move(m_requests.at(id));
m_requests.erase(id);
- m_observer = req.observer;
-
- switch (static_cast<LogicCommand>(command)) {
- case LogicCommand::SAVE:
- parseSaveCommand();
- break;
- // TODO other cases
- default:
- LogError("Unknown command id: " << command);
- ThrowMsg(BadResponse, "Unknown command id: " << command);
- break;
- }
-}
-
-void Receiver::parseSaveCommand()
-{
- int retCode;
- int dataType;
-
- m_buffer.Deserialize(retCode, dataType);
-
- DBDataType dt = static_cast<DBDataType>(dataType);
- if (dt >= DBDataType::DB_KEY_FIRST && dt <= DBDataType::DB_KEY_LAST) {
- if (retCode == CKM_API_SUCCESS)
- m_observer->ReceivedSaveKey();
- else
- m_observer->ReceivedError(retCode);
- } else {
- // TODO
- }
+ if (retCode == CKM_API_SUCCESS)
+ req.observer->ReceivedOCSPCheck(ocspStatus);
+ else
+ req.observer->ReceivedError(retCode);
}
} /* namespace CKM */
--- /dev/null
+/*
+ * Copyright (c) 2000 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+/*
+ * @file ocsp-receiver.h
+ * @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+ * @version 1.0
+ */
+
+#pragma once
+
+#include <message-buffer.h>
+#include <noncopyable.h>
+#include <async-request.h>
+#include <receiver.h>
+
+namespace CKM {
+
+class OcspReceiver : public IReceiver
+{
+public:
+ OcspReceiver(MessageBuffer& buffer, AsyncRequest::Map& reqMap);
+ virtual ~OcspReceiver() {}
+
+ NONCOPYABLE(OcspReceiver);
+
+ void parseResponse();
+
+private:
+ MessageBuffer& m_buffer;
+ AsyncRequest::Map& m_requests;
+};
+
+} /* namespace CKM */
#pragma once
-#include <message-buffer.h>
-#include <noncopyable.h>
-#include <ckm/ckm-manager.h>
-#include <async-request.h>
-
namespace CKM {
-class Receiver
-{
+class IReceiver {
public:
DECLARE_EXCEPTION_TYPE(CKM::Exception, BadResponse);
- Receiver(MessageBuffer& buffer, AsyncRequest::Map& reqMap);
- virtual ~Receiver() {}
-
- NONCOPYABLE(Receiver);
-
- void parseResponse();
-
-private:
- void parseSaveCommand();
-
- MessageBuffer& m_buffer;
- AsyncRequest::Map& m_requests;
- ManagerAsync::ObserverPtr m_observer;
+ virtual void parseResponse() = 0;
+ virtual ~IReceiver() {};
};
-} /* namespace CKM */
+}
#include <service.h>
#include <dpl/log/log.h>
-#include <receiver.h>
+#include <storage-receiver.h>
+#include <ocsp-receiver.h>
+#include <protocols.h>
namespace CKM {
LogError("Unexpected event: " << revents << "!=" << POLLOUT);
serviceError(CKM_API_ERROR_SOCKET);
}
- } catch (const Receiver::BadResponse&) {
+ } catch (const IReceiver::BadResponse&) {
serviceError(CKM_API_ERROR_BAD_RESPONSE);
} catch (std::exception &e) {
LogError("STD exception " << e.what());
// parse while you can
while(m_responseBuffer->Ready())
{
- Receiver recv(*m_responseBuffer, m_responseMap);
- recv.parseResponse();
+ std::unique_ptr<IReceiver> receiver;
+ if (m_interface == SERVICE_SOCKET_CKM_STORAGE)
+ receiver.reset(new StorageReceiver(*m_responseBuffer, m_responseMap));
+ else if (m_interface == SERVICE_SOCKET_OCSP)
+ receiver.reset(new OcspReceiver(*m_responseBuffer, m_responseMap));
+ else {
+ LogError("Unknown service " << m_interface);
+ serviceError(CKM_API_ERROR_RECV_FAILED);
+ return;
+ }
+ receiver->parseResponse();
if (m_responseMap.empty())
watch(m_sendQueue.empty()?0:POLLOUT);
--- /dev/null
+/*
+ * Copyright (c) 2000 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+/*
+ * @file receiver.cpp
+ * @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+ * @version 1.0
+ */
+
+#include <storage-receiver.h>
+#include <protocols.h>
+#include <dpl/log/log.h>
+#include <key-impl.h>
+#include <certificate-impl.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),
+ m_observer(NULL)
+{
+}
+
+void StorageReceiver::parseResponse()
+{
+ int command, id;
+ m_buffer.Deserialize(command, id);
+
+ auto it = m_requests.find(id);
+ if (it == m_requests.end()) {
+ LogError("Request with id " << id << " not found!");
+ ThrowMsg(BadResponse, "Request with id " << id << " not found!");
+ }
+
+ // let it throw
+ AsyncRequest req = std::move(m_requests.at(id));
+ m_requests.erase(id);
+
+ m_observer = req.observer;
+
+ switch (static_cast<LogicCommand>(command)) {
+ case LogicCommand::GET:
+ parseGetCommand();
+ break ;
+ case LogicCommand::GET_LIST:
+ parseGetListCommand();
+ break;
+ case LogicCommand::SAVE:
+ parseSaveCommand();
+ break;
+ 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);
+ break;
+ case LogicCommand::GET_CHAIN_CERT:
+ case LogicCommand::GET_CHAIN_ALIAS:
+ parseGetChainCertCommand();
+ break;
+ case LogicCommand::CREATE_SIGNATURE:
+ parseCreateSignatureCommand();
+ break;
+ 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);
+ break;
+
+ default:
+ LogError("Unknown command id: " << command);
+ ThrowMsg(BadResponse, "Unknown command id: " << command);
+ break;
+ }
+}
+
+void StorageReceiver::parseGetCommand()
+{
+ RawBuffer rawData;
+ int dataType, retCode;
+ m_buffer.Deserialize(retCode, dataType, rawData);
+
+ // check error code
+ if (retCode != CKM_API_SUCCESS) {
+ m_observer->ReceivedError(retCode);
+ return;
+ }
+
+ switch(type(dataType))
+ {
+ case DataType::KEY:
+ m_observer->ReceivedKey(KeyImpl(rawData));
+ break;
+ case DataType::CERT:
+ m_observer->ReceivedCertificate(CertificateImpl(rawData, DataFormat::FORM_DER));
+ break;
+ case DataType::DATA:
+ m_observer->ReceivedData(std::move(rawData));
+ break;
+ }
+}
+
+void StorageReceiver::parseGetListCommand()
+{
+ int dataType, retCode;
+ AliasVector aliasVector;
+ m_buffer.Deserialize(retCode, dataType, aliasVector);
+
+ // check error code
+ if (retCode != CKM_API_SUCCESS) {
+ m_observer->ReceivedError(retCode);
+ return;
+ }
+
+ switch(type(dataType))
+ {
+ case DataType::KEY:
+ m_observer->ReceivedKeyAliasVector(std::move(aliasVector));
+ break;
+ case DataType::CERT:
+ m_observer->ReceivedCertificateAliasVector(std::move(aliasVector));
+ break;
+ case DataType::DATA:
+ m_observer->ReceivedDataAliasVector(std::move(aliasVector));
+ break;
+ }
+}
+
+void StorageReceiver::parseSaveCommand()
+{
+ int dataType, retCode;
+ m_buffer.Deserialize(retCode, dataType);
+
+ // check error code
+ if (retCode != CKM_API_SUCCESS) {
+ m_observer->ReceivedError(retCode);
+ 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;
+ }
+}
+
+void StorageReceiver::parseRemoveCommand()
+{
+ int dataType, retCode;
+ m_buffer.Deserialize(retCode, dataType);
+
+ // check error code
+ if (retCode != CKM_API_SUCCESS) {
+ m_observer->ReceivedError(retCode);
+ 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;
+ }
+}
+
+void StorageReceiver::parseGetChainCertCommand()
+{
+ CertificateShPtrVector certificateChainVector;
+ RawBufferVector rawBufferVector;
+ int retCode;
+ m_buffer.Deserialize(retCode, rawBufferVector);
+
+ // check error code
+ if (retCode != CKM_API_SUCCESS) {
+ m_observer->ReceivedError(retCode);
+ return;
+ }
+
+ for (auto &e: rawBufferVector) {
+ CertificateShPtr cert(new CertificateImpl(e, DataFormat::FORM_DER));
+ if (cert->empty()) {
+ m_observer->ReceivedError(CKM_API_ERROR_BAD_RESPONSE);
+ return;
+ }
+ certificateChainVector.push_back(cert);
+ }
+ m_observer->ReceivedGetCertificateChain(std::move(certificateChainVector));
+}
+
+void StorageReceiver::parseCreateSignatureCommand()
+{
+ int retCode;
+ RawBuffer signature;
+ m_buffer.Deserialize(retCode, signature);
+
+ // check error code
+ if (retCode != CKM_API_SUCCESS) {
+ m_observer->ReceivedError(retCode);
+ return;
+ }
+
+ 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()
+{
+ int retCode;
+ m_buffer.Deserialize(retCode);
+
+ // check error code
+ if (retCode != CKM_API_SUCCESS) {
+ m_observer->ReceivedError(retCode);
+ return;
+ }
+
+ m_observer->ReceivedDenyAccess();
+}
+
+void StorageReceiver::parseRetCode(ObserverCb callback)
+{
+ int retCode;
+ m_buffer.Deserialize(retCode);
+
+ // check error code
+ if (retCode != CKM_API_SUCCESS) {
+ m_observer->ReceivedError(retCode);
+ return;
+ }
+
+ (m_observer.get()->*callback)();
+}
+
+} /* namespace CKM */
--- /dev/null
+/*
+ * Copyright (c) 2000 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+/*
+ * @file storage-receiver.h
+ * @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+ * @version 1.0
+ */
+
+#pragma once
+
+#include <message-buffer.h>
+#include <noncopyable.h>
+#include <ckm/ckm-manager.h>
+#include <async-request.h>
+#include <receiver.h>
+
+namespace CKM {
+
+class StorageReceiver : public IReceiver
+{
+public:
+ StorageReceiver(MessageBuffer& buffer, AsyncRequest::Map& reqMap);
+ virtual ~StorageReceiver() {}
+
+ NONCOPYABLE(StorageReceiver);
+
+ void parseResponse();
+
+private:
+ void parseGetCommand();
+ void parseGetListCommand();
+ void parseSaveCommand();
+ void parseRemoveCommand();
+ void parseGetChainCertCommand();
+ void parseCreateSignatureCommand();
+ void parseAllowAccessCommand();
+ void parseDenyAccessCommand();
+
+ typedef void (ManagerAsync::Observer::*ObserverCb)();
+
+ void parseRetCode(ObserverCb callback);
+
+ MessageBuffer& m_buffer;
+ AsyncRequest::Map& m_requests;
+ ManagerAsync::ObserverPtr m_observer;
+};
+
+} /* namespace CKM */
projects / platform / core / security / key-manager.git / commitdiff