}
m_counter++;
- auto send = MessageBuffer::Serialize(m_counter, rawCertChain);
+ auto send = SerializeMessage(m_counter, rawCertChain);
- thread()->sendMessage(AsyncRequest(observer, SERVICE_SOCKET_OCSP, send.Pop(),
+ thread()->sendMessage(AsyncRequest(observer, SERVICE_SOCKET_OCSP, std::move(send),
m_counter, 0));
}, [&observer](int error) {
observer->ReceivedError(error);
auto command = static_cast<int>(encryption ?
EncryptionCommand::ENCRYPT : EncryptionCommand::DECRYPT);
- auto send = MessageBuffer::Serialize(command, m_counter, cas,
- helper.getName(), helper.getOwner(), password, input);
+ auto send = SerializeMessage(command, m_counter, cas, helper.getName(), helper.getOwner(),
+ password, input);
thread()->sendMessage(AsyncRequest(observer, SERVICE_SOCKET_ENCRYPTION,
- send.Pop(), m_counter, command));
+ std::move(send), m_counter, command));
}, [&observer](int error) {
observer->ReceivedError(error);
});
{
m_counter++; // yes, it changes m_counter argument passed in args
- auto send = MessageBuffer::Serialize(command, args...);
+ auto send = SerializeMessage(command, args...);
thread()->sendMessage(AsyncRequest(observer,
SERVICE_SOCKET_CKM_STORAGE,
- send.Pop(),
+ std::move(send),
m_counter,
command));
}
return CKM_API_ERROR_INPUT_PARAM;
MessageBuffer recv;
- auto send = MessageBuffer::Serialize(static_cast<int>
- (ControlCommand::UNLOCK_USER_KEY),
- user,
- password);
+ auto send = SerializeMessage(static_cast<int>(ControlCommand::UNLOCK_USER_KEY),
+ user,
+ password);
- int retCode = m_controlConnection.processRequest(send.Pop(), recv);
+ int retCode = m_controlConnection.processRequest(send, recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
return CKM_API_ERROR_INPUT_PARAM;
MessageBuffer recv;
- auto send = MessageBuffer::Serialize(static_cast<int>
- (ControlCommand::LOCK_USER_KEY), user);
+ auto send = SerializeMessage(static_cast<int>(ControlCommand::LOCK_USER_KEY), user);
- int retCode = m_controlConnection.processRequest(send.Pop(), recv);
+ int retCode = m_controlConnection.processRequest(send, recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
return CKM_API_ERROR_INPUT_PARAM;
MessageBuffer recv;
- auto send = MessageBuffer::Serialize(static_cast<int>
- (ControlCommand::REMOVE_USER_DATA), user);
+ auto send = SerializeMessage(static_cast<int>(ControlCommand::REMOVE_USER_DATA), user);
- int retCode = m_controlConnection.processRequest(send.Pop(), recv);
+ int retCode = m_controlConnection.processRequest(send, recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
return CKM_API_ERROR_INPUT_PARAM;
MessageBuffer recv;
- auto send = MessageBuffer::Serialize(
- static_cast<int>(ControlCommand::CHANGE_USER_PASSWORD),
- user,
- oldPassword,
- newPassword);
+ auto send = SerializeMessage(static_cast<int>(ControlCommand::CHANGE_USER_PASSWORD),
+ user,
+ oldPassword,
+ newPassword);
- int retCode = m_controlConnection.processRequest(send.Pop(), recv);
+ int retCode = m_controlConnection.processRequest(send, recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
return CKM_API_ERROR_INPUT_PARAM;
MessageBuffer recv;
- auto send = MessageBuffer::Serialize(
- static_cast<int>(ControlCommand::RESET_USER_PASSWORD),
- user,
- newPassword);
+ auto send = SerializeMessage(static_cast<int>(ControlCommand::RESET_USER_PASSWORD),
+ user,
+ newPassword);
- int retCode = m_controlConnection.processRequest(send.Pop(), recv);
+ int retCode = m_controlConnection.processRequest(send, recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
return CKM_API_ERROR_INPUT_PARAM;
MessageBuffer recv;
- auto send = MessageBuffer::Serialize(static_cast<int>
- (ControlCommand::REMOVE_APP_DATA), owner);
+ auto send = SerializeMessage(static_cast<int>(ControlCommand::REMOVE_APP_DATA), owner);
- int retCode = m_controlConnection.processRequest(send.Pop(), recv);
+ int retCode = m_controlConnection.processRequest(send, recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
EXCEPTION_GUARD_START_CPPAPI
MessageBuffer recv;
- auto send = MessageBuffer::Serialize(static_cast<int>
- (ControlCommand::UPDATE_CC_MODE));
+ auto send = SerializeMessage(static_cast<int>(ControlCommand::UPDATE_CC_MODE));
- int retCode = m_controlConnection.processRequest(send.Pop(), recv);
+ int retCode = m_controlConnection.processRequest(send, recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
MessageBuffer recv;
AliasSupport helper(alias);
- auto send = MessageBuffer::Serialize(static_cast<int>
- (ControlCommand::SET_PERMISSION),
- static_cast<int>(user),
- helper.getName(),
- helper.getOwner(),
- accessor,
- permissionMask);
-
- int retCode = m_controlConnection.processRequest(send.Pop(), recv);
+ auto send = SerializeMessage(static_cast<int>(ControlCommand::SET_PERMISSION),
+ static_cast<int>(user),
+ helper.getName(),
+ helper.getOwner(),
+ accessor,
+ permissionMask);
+
+ int retCode = m_controlConnection.processRequest(send, recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
EXCEPTION_GUARD_START_CPPAPI
MessageBuffer recv;
- auto send = MessageBuffer::Serialize(static_cast<int>(command),
- msgId,
- certificate->getDER(),
- untrustedVector,
- trustedVector,
- useTrustedSystemCertificates);
+ auto send = SerializeMessage(static_cast<int>(command),
+ msgId,
+ certificate->getDER(),
+ untrustedVector,
+ trustedVector,
+ useTrustedSystemCertificates);
- int retCode = serviceConnection.processRequest(send.Pop(), recv);
+ int retCode = serviceConnection.processRequest(send, recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
MessageBuffer recv;
AliasSupport helper(alias);
- auto send = MessageBuffer::Serialize(static_cast<int>(LogicCommand::SAVE),
- msgId,
- dataType,
- helper.getName(),
- helper.getOwner(),
- rawData,
- PolicySerializable(policy));
+ auto send = SerializeMessage(static_cast<int>(LogicCommand::SAVE),
+ msgId,
+ dataType,
+ helper.getName(),
+ helper.getOwner(),
+ rawData,
+ PolicySerializable(policy));
- int retCode = m_storageConnection.processRequest(send.Pop(), recv);
+ int retCode = m_storageConnection.processRequest(send, recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
MessageBuffer recv;
AliasSupport helper(alias);
- auto send = MessageBuffer::Serialize(static_cast<int>
- (LogicCommand::SAVE_PKCS12),
- msgId,
- helper.getName(),
- helper.getOwner(),
- PKCS12Serializable(*pkcs.get()),
- PolicySerializable(keyPolicy),
- PolicySerializable(certPolicy));
+ auto send = SerializeMessage(static_cast<int>(LogicCommand::SAVE_PKCS12),
+ msgId,
+ helper.getName(),
+ helper.getOwner(),
+ PKCS12Serializable(*pkcs.get()),
+ PolicySerializable(keyPolicy),
+ PolicySerializable(certPolicy));
- int retCode = m_storageConnection.processRequest(send.Pop(), recv);
+ int retCode = m_storageConnection.processRequest(send, recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
MessageBuffer recv;
AliasSupport helper(alias);
- auto send = MessageBuffer::Serialize(static_cast<int>(LogicCommand::GET_PKCS12),
- msgId,
- helper.getName(),
- helper.getOwner(),
- keyPass,
- certPass);
+ auto send = SerializeMessage(static_cast<int>(LogicCommand::GET_PKCS12),
+ msgId,
+ helper.getName(),
+ helper.getOwner(),
+ keyPass,
+ certPass);
- int retCode = m_storageConnection.processRequest(send.Pop(), recv);
+ int retCode = m_storageConnection.processRequest(send, recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
MessageBuffer recv;
AliasSupport helper(alias);
- auto send = MessageBuffer::Serialize(static_cast<int>(LogicCommand::REMOVE),
- msgId,
- helper.getName(),
- helper.getOwner());
+ auto send = SerializeMessage(static_cast<int>(LogicCommand::REMOVE),
+ msgId,
+ helper.getName(),
+ helper.getOwner());
- int retCode = m_storageConnection.processRequest(send.Pop(), recv);
+ int retCode = m_storageConnection.processRequest(send, recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
MessageBuffer recv;
AliasSupport helper(alias);
- auto send = MessageBuffer::Serialize(static_cast<int>(LogicCommand::GET),
- msgId,
- sendDataType,
- helper.getName(),
- helper.getOwner(),
- password);
+ auto send = SerializeMessage(static_cast<int>(LogicCommand::GET),
+ msgId,
+ sendDataType,
+ helper.getName(),
+ helper.getOwner(),
+ password);
- int retCode = m_storageConnection.processRequest(send.Pop(), recv);
+ int retCode = m_storageConnection.processRequest(send, recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
MessageBuffer recv;
AliasSupport helper(alias);
- auto send = MessageBuffer::Serialize(static_cast<int>(LogicCommand::GET_PROTECTION_STATUS),
- msgId,
- sendDataType,
- helper.getName(),
- helper.getOwner());
+ auto send = SerializeMessage(static_cast<int>(LogicCommand::GET_PROTECTION_STATUS),
+ msgId,
+ sendDataType,
+ helper.getName(),
+ helper.getOwner());
- int retCode = m_storageConnection.processRequest(send.Pop(), recv);
+ int retCode = m_storageConnection.processRequest(send, recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
int msgId = ++m_counter;
MessageBuffer recv;
- auto send = MessageBuffer::Serialize(static_cast<int>(LogicCommand::GET_LIST),
- msgId,
- dataType);
+ auto send = SerializeMessage(static_cast<int>(LogicCommand::GET_LIST), msgId, dataType);
- int retCode = m_storageConnection.processRequest(send.Pop(), recv);
+ int retCode = m_storageConnection.processRequest(send, recv);
if (retCode != CKM_API_SUCCESS)
return retCode;
MessageBuffer recv;
AliasSupport aliasHelper(keyAlias);
- auto send = MessageBuffer::Serialize(static_cast<int>
- (LogicCommand::CREATE_KEY_AES),
- msgId,
- static_cast<int>(size),
- PolicySerializable(policyKey),
- aliasHelper.getName(),
- aliasHelper.getOwner());
+ auto send = SerializeMessage(static_cast<int>(LogicCommand::CREATE_KEY_AES),
+ msgId,
+ static_cast<int>(size),
+ PolicySerializable(policyKey),
+ aliasHelper.getName(),
+ aliasHelper.getOwner());
- int retCode = m_storageConnection.processRequest(send.Pop(), recv);
+ int retCode = m_storageConnection.processRequest(send, recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
MessageBuffer recv;
AliasSupport privateHelper(privateKeyAlias);
AliasSupport publicHelper(publicKeyAlias);
- auto send = MessageBuffer::Serialize(static_cast<int>
- (LogicCommand::CREATE_KEY_PAIR),
- msgId,
- CryptoAlgorithmSerializable(keyGenAlgorithm),
- PolicySerializable(policyPrivateKey),
- PolicySerializable(policyPublicKey),
- privateHelper.getName(),
- privateHelper.getOwner(),
- publicHelper.getName(),
- publicHelper.getOwner());
-
- int retCode = m_storageConnection.processRequest(send.Pop(), recv);
+ auto send = SerializeMessage(static_cast<int>(LogicCommand::CREATE_KEY_PAIR),
+ msgId,
+ CryptoAlgorithmSerializable(keyGenAlgorithm),
+ PolicySerializable(policyPrivateKey),
+ PolicySerializable(policyPublicKey),
+ privateHelper.getName(),
+ privateHelper.getOwner(),
+ publicHelper.getName(),
+ publicHelper.getOwner());
+
+ int retCode = m_storageConnection.processRequest(send, recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
MessageBuffer recv;
AliasSupport helper(privateKeyAlias);
- auto send = MessageBuffer::Serialize(static_cast<int>
- (LogicCommand::CREATE_SIGNATURE),
- msgId,
- helper.getName(),
- helper.getOwner(),
- password,
- message,
- CryptoAlgorithmSerializable(cAlgorithm));
+ auto send = SerializeMessage(static_cast<int>(LogicCommand::CREATE_SIGNATURE),
+ msgId,
+ helper.getName(),
+ helper.getOwner(),
+ password,
+ message,
+ CryptoAlgorithmSerializable(cAlgorithm));
- int retCode = m_storageConnection.processRequest(send.Pop(), recv);
+ int retCode = m_storageConnection.processRequest(send, recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
MessageBuffer recv;
AliasSupport helper(publicKeyOrCertAlias);
- auto send = MessageBuffer::Serialize(static_cast<int>
- (LogicCommand::VERIFY_SIGNATURE),
- msgId,
- helper.getName(),
- helper.getOwner(),
- password,
- message,
- signature,
- CryptoAlgorithmSerializable(cAlg));
-
- int retCode = m_storageConnection.processRequest(send.Pop(), recv);
+ auto send = SerializeMessage(static_cast<int>(LogicCommand::VERIFY_SIGNATURE),
+ msgId,
+ helper.getName(),
+ helper.getOwner(),
+ password,
+ message,
+ signature,
+ CryptoAlgorithmSerializable(cAlg));
+
+ int retCode = m_storageConnection.processRequest(send, recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
rawCertChain.push_back(e->getDER());
}
- auto send = MessageBuffer::Serialize(msgId, rawCertChain);
+ auto send = SerializeMessage(msgId, rawCertChain);
- int retCode = m_ocspConnection.processRequest(send.Pop(), recv);
+ int retCode = m_ocspConnection.processRequest(send, recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
MessageBuffer recv;
AliasSupport helper(alias);
- auto send = MessageBuffer::Serialize(static_cast<int>
- (LogicCommand::SET_PERMISSION),
- msgId,
- helper.getName(),
- helper.getOwner(),
- accessor,
- permissionMask);
+ auto send = SerializeMessage(static_cast<int>(LogicCommand::SET_PERMISSION),
+ msgId,
+ helper.getName(),
+ helper.getOwner(),
+ accessor,
+ permissionMask);
- int retCode = m_storageConnection.processRequest(send.Pop(), recv);
+ int retCode = m_storageConnection.processRequest(send, recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
MessageBuffer recv;
AliasSupport helper(keyAlias);
CryptoAlgorithmSerializable cas(algo);
- auto send = MessageBuffer::Serialize(static_cast<int>(command),
- msgId,
- cas,
- helper.getName(),
- helper.getOwner(),
- password,
- input);
-
- int retCode = m_encryptionConnection.processRequest(send.Pop(), recv);
+ auto send = SerializeMessage(static_cast<int>(command),
+ msgId,
+ cas,
+ helper.getName(),
+ helper.getOwner(),
+ password,
+ input);
+
+ int retCode = m_encryptionConnection.processRequest(send, recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
/*
- * Copyright (c) 2000-2019 Samsung Electronics Co., Ltd. All rights reserved
+ * Copyright (c) 2000-2020 Samsung Electronics Co., Ltd. All rights reserved
*
* Contact: Dongsun Lee <ds73.lee@samsung.com>
*
#include <message-buffer.h>
+#include <exception.h>
#include <dpl/log/log.h>
namespace CKM {
m_buffer.AppendCopy(&data[0], data.size());
}
-RawBuffer MessageBuffer::Pop()
-{
- size_t size = m_buffer.Size();
- RawBuffer buffer;
- buffer.resize(size + sizeof(size_t));
- memcpy(&buffer[0], &size, sizeof(size_t));
- m_buffer.FlattenConsume(&buffer[sizeof(size_t)], size);
- return buffer;
-}
-
bool MessageBuffer::Ready()
{
CountBytesLeft();
m_bytesLeft -= num;
}
-void MessageBuffer::Write(size_t num, const void *bytes)
+void MessageBuffer::Write(size_t, const void *)
+{
+ ThrowErr(Exc::InternalError, "unexpected IStream::Write call in MessageBuffer");
+}
+
+void MessageSerializer::Sizer::Read(size_t, void*)
+{
+ ThrowErr(Exc::InternalError, "unexpected IStream::Read call in SerializeMessage");
+}
+
+void MessageSerializer::Sizer::Write(size_t num, const void*)
+{
+ m_bytes += num;
+}
+
+MessageSerializer::Writer::Writer(size_t size)
+{
+ m_buffer.reserve(sizeof(size_t) + size);
+ Serializer<size_t>::Serialize(*this, size);
+}
+
+void MessageSerializer::Writer::Read(size_t, void*)
+{
+ ThrowErr(Exc::InternalError, "unexpected IStream::Read call in SerializeMessage");
+}
+
+void MessageSerializer::Writer::Write(size_t num, const void* bytes)
{
- m_buffer.AppendCopy(bytes, num);
+ assert(m_buffer.size() + num <= m_buffer.capacity());
+ m_buffer.resize(m_buffer.size() + num);
+ memcpy(&m_buffer[m_buffer.size() - num], bytes, num);
}
} // namespace CKM
/*
- * Copyright (c) 2000-2019 Samsung Electronics Co., Ltd. All rights reserved
+ * Copyright (c) 2000-2020 Samsung Electronics Co., Ltd. All rights reserved
*
* Contact: Dongsun Lee <ds73.lee@samsung.com>
*
void Push(const RawBuffer &data);
- RawBuffer Pop();
-
bool Ready();
virtual void Read(size_t num, void *bytes);
virtual void Write(size_t num, const void *bytes);
- // generic serialization
- template <typename... Args>
- static MessageBuffer Serialize(const Args &... args)
- {
- MessageBuffer buffer;
- Serializer<Args...>::Serialize(buffer, args...);
- return buffer;
- }
-
// generic deserialization
template <typename... Args>
void Deserialize(Args &... args)
CKM::BinaryQueue m_buffer;
};
+class MessageSerializer final {
+ struct COMMON_API Sizer : IStream {
+ void Read(size_t num, void* bytes) override;
+ void Write(size_t num, const void* bytes) override;
+
+ size_t m_bytes = 0;
+ };
+
+ struct COMMON_API Writer : IStream {
+ Writer(size_t size);
+
+ void Read(size_t num, void* bytes) override;
+ void Write(size_t num, const void* bytes) override;
+
+ RawBuffer m_buffer;
+ };
+
+ MessageSerializer() = delete;
+
+public:
+ template <typename... T>
+ static RawBuffer Run(const T&... args)
+ {
+ Sizer sizer;
+ Serializer<T...>::Serialize(sizer, args...);
+ Writer writer(sizer.m_bytes);
+ Serializer<T...>::Serialize(writer, args...);
+ return std::move(writer.m_buffer);
+ }
+};
+
+template <typename... T>
+RawBuffer SerializeMessage(const T&... args)
+{
+ return MessageSerializer::Run(args...);
+}
+
} // namespace CKM
#endif // _CENT_KEY_MNG_SOCKET_BUFFER_
// serialization exceptions will be catched as CKM::Exception and will cause
// CKM_API_ERROR_SERVER_ERROR
- packed = MessageBuffer::Serialize(ret.first, iv, ret.second).Pop();
+ packed = SerializeMessage(ret.first, iv, ret.second);
}
// encryption scheme + internal buffer
- return MessageBuffer::Serialize(scheme, packed).Pop();
+ return SerializeMessage(scheme, packed);
}
} // namespace anonymous
/*
- * Copyright (c) 2015 - 2019 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2015 - 2020 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.
int scheme = pwd.empty() ? EncryptionScheme::NONE : EncryptionScheme::PASSWORD;
if (scheme == EncryptionScheme::PASSWORD) {
- return MessageBuffer::Serialize(scheme, keyId, iv, tag).Pop();
+ return SerializeMessage(scheme, keyId, iv, tag);
} else {
- return MessageBuffer::Serialize(scheme, keyId).Pop();
+ return SerializeMessage(scheme, keyId);
}
}
else // do not allow lock/unlock operations for system users
retCode = CKM_API_ERROR_INPUT_PARAM;
- return MessageBuffer::Serialize(retCode).Pop();
+ return SerializeMessage(retCode);
}
RawBuffer CKMLogic::updateCCMode()
{
m_accessControl.updateCCMode();
- return MessageBuffer::Serialize(CKM_API_SUCCESS).Pop();
+ return SerializeMessage(CKM_API_SUCCESS);
}
RawBuffer CKMLogic::lockUserKey(uid_t user)
else // do not allow lock/unlock operations for system users
retCode = CKM_API_ERROR_INPUT_PARAM;
- return MessageBuffer::Serialize(retCode).Pop();
+ return SerializeMessage(retCode);
}
RawBuffer CKMLogic::removeUserData(uid_t user)
? CKM_API_ERROR_FILE_SYSTEM
: CKM_API_SUCCESS;
- return MessageBuffer::Serialize(retCode).Pop();
+ return SerializeMessage(retCode);
}
int CKMLogic::changeUserPasswordHelper(uid_t user,
retCode = CKM_API_ERROR_SERVER_ERROR;
}
- return MessageBuffer::Serialize(retCode).Pop();
+ return SerializeMessage(retCode);
}
int CKMLogic::resetUserPasswordHelper(
retCode = CKM_API_ERROR_SERVER_ERROR;
}
- return MessageBuffer::Serialize(retCode).Pop();
+ return SerializeMessage(retCode);
}
RawBuffer CKMLogic::removeApplicationData(const ClientId &owner)
retCode = CKM_API_ERROR_SERVER_ERROR;
}
- return MessageBuffer::Serialize(retCode).Pop();
+ return SerializeMessage(retCode);
}
int CKMLogic::checkSaveConditions(
const PolicySerializable &policy)
{
int retCode = verifyAndSaveDataHelper(cred, name, explicitOwner, data, policy);
- auto response = MessageBuffer::Serialize(msgId, retCode, data.type);
- return response.Pop();
+ return SerializeMessage(msgId, retCode, data.type);
}
int CKMLogic::extractPKCS12Data(
retCode = CKM_API_ERROR_SERVER_ERROR;
}
- auto response = MessageBuffer::Serialize(msgId, retCode);
- return response.Pop();
+ return SerializeMessage(msgId, retCode);
}
retCode = CKM_API_ERROR_DB_ERROR;
}
- auto response = MessageBuffer::Serialize(msgId, retCode);
- return response.Pop();
+ return SerializeMessage(msgId, retCode);
}
int CKMLogic::readSingleRow(const Name &name,
if (CKM_API_SUCCESS != retCode)
rowData.clear();
- auto response = MessageBuffer::Serialize(msgId,
- retCode,
- objDataType,
- rowData);
- return response.Pop();
+ return SerializeMessage(msgId, retCode, objDataType, rowData);
}
RawBuffer CKMLogic::getDataProtectionStatus(
retCode = CKM_API_SUCCESS;
}
- auto response = MessageBuffer::Serialize(msgId,
- retCode,
- objDataType,
- status);
- return response.Pop();
+ return SerializeMessage(msgId, retCode, objDataType, status);
}
int CKMLogic::getPKCS12Helper(
retCode = CKM_API_ERROR_SERVER_ERROR;
}
- auto response = MessageBuffer::Serialize(msgId, retCode, output);
- return response.Pop();
+ return SerializeMessage(msgId, retCode, output);
}
int CKMLogic::getDataListHelper(const Credentials &cred,
userVector.end());
}
- auto response = MessageBuffer::Serialize(msgId,
- retCode,
- dataType,
- ownerNameVector);
- return response.Pop();
+ return SerializeMessage(msgId, retCode, dataType, ownerNameVector);
}
int CKMLogic::importInitialData(
retCode = CKM_API_ERROR_SERVER_ERROR;
}
- return MessageBuffer::Serialize(msgId, retCode).Pop();
+ return SerializeMessage(msgId, retCode);
}
RawBuffer CKMLogic::createKeyAES(
retCode = CKM_API_ERROR_SERVER_ERROR;
}
- return MessageBuffer::Serialize(msgId, retCode).Pop();
+ return SerializeMessage(msgId, retCode);
}
int CKMLogic::readCertificateHelper(
LogError("Unknown error.");
}
- auto response = MessageBuffer::Serialize(msgId, retCode, chainRawVector);
- return response.Pop();
+ return SerializeMessage(msgId, retCode, chainRawVector);
}
RawBuffer CKMLogic::getCertificateChain(
LogError("Unknown error.");
}
- auto response = MessageBuffer::Serialize(msgId, retCode, chainRawVector);
- return response.Pop();
+ return SerializeMessage(msgId, retCode, chainRawVector);
}
RawBuffer CKMLogic::createSignature(
retCode = CKM_API_ERROR_SERVER_ERROR;
}
- auto response = MessageBuffer::Serialize(msgId, retCode, signature);
- return response.Pop();
+ return SerializeMessage(msgId, retCode, signature);
}
RawBuffer CKMLogic::verifySignature(
retCode = CKM_API_ERROR_SERVER_ERROR;
}
- auto response = MessageBuffer::Serialize(msgId, retCode);
- return response.Pop();
+ return SerializeMessage(msgId, retCode);
}
int CKMLogic::setPermissionHelper(
retCode = CKM_API_ERROR_DB_ERROR;
}
- return MessageBuffer::Serialize(msgID, retCode).Pop();
+ return SerializeMessage(msgID, retCode);
}
int CKMLogic::loadAppKey(UserData &handle, const ClientId &owner)
if (!allowed) {
LogError("Access denied!");
- return MessageBuffer::Serialize(CKM_API_ERROR_ACCESS_DENIED).Pop();
+ return SerializeMessage(CKM_API_ERROR_ACCESS_DENIED);
}
return logicFunc();
const RawBuffer &data)
{
try {
- RawBuffer response = MessageBuffer::Serialize(request.msgId, retCode, data).Pop();
+ RawBuffer response = SerializeMessage(request.msgId, retCode, data);
m_serviceManager->Write(request.conn, response);
} catch (...) {
LogError("Failed to send response to the client");
if (retCode == CKM_API_SUCCESS)
ocspStatus = ocsp.verify(certChain);
- return MessageBuffer::Serialize(msgId, retCode, ocspStatus).Pop();
+ return SerializeMessage(msgId, retCode, ocspStatus);
}
} // namespace CKM
NEGATIVE_TEST_CASE(SERIALIZATION)
{
MessageBuffer msg;
- msg.Push(MessageBuffer::Serialize(static_cast<int>(DataType::DB_FIRST - 1)).Pop());
+ msg.Push(SerializeMessage(static_cast<int>(DataType::DB_FIRST - 1)));
BOOST_REQUIRE_THROW(DataType{msg}, Exc::InputParam);
- msg.Push(MessageBuffer::Serialize(static_cast<int>(DataType::DB_LAST + 1)).Pop());
+ msg.Push(SerializeMessage(static_cast<int>(DataType::DB_LAST + 1)));
BOOST_REQUIRE_THROW(DataType{msg}, Exc::InputParam);
}
MessageBuffer msg;
DataType dt;
- BOOST_REQUIRE_NO_THROW(DataType(typeToCheck).Serialize(msg));
- msg.Push(msg.Pop());
+ BOOST_REQUIRE_NO_THROW(msg.Push(SerializeMessage(DataType(typeToCheck))));
BOOST_REQUIRE_NO_THROW(dt = DataType{msg});
BOOST_REQUIRE(dt == typeToCheck);
};
auto checkPkcs = [&](const PKCS12Serializable& ps) {
MessageBuffer msg;
- msg.Push(MessageBuffer::Serialize(ps).Pop());
+ msg.Push(SerializeMessage(ps));
PKCS12Serializable deserialized(msg);
BOOST_REQUIRE(!deserialized.empty());
{
auto checkEmptiness = [](const PKCS12Serializable& ps) {
MessageBuffer msg;
- msg.Push(MessageBuffer::Serialize(ps).Pop());
+ msg.Push(SerializeMessage(ps));
PKCS12Serializable deserialized(msg);
BOOST_REQUIRE(deserialized.empty());
};
CryptoAlgorithmSerializable input(ca);
CryptoAlgorithmSerializable output;
- auto msg = MessageBuffer::Serialize(input);
- RawBuffer buffer = msg.Pop();
+ RawBuffer buffer = SerializeMessage(input);
MessageBuffer resp;
resp.Push(buffer);
resp.Deserialize(output);
CryptoAlgorithmSerializable input(ca);
CryptoAlgorithmSerializable output;
- auto msg = MessageBuffer::Serialize(input);
- RawBuffer buffer = msg.Pop();
+ RawBuffer buffer = SerializeMessage(input);
MessageBuffer resp;
resp.Push(buffer);
resp.Deserialize(output);
CryptoAlgorithmSerializable input(ca);
CryptoAlgorithmSerializable output;
- auto msg = MessageBuffer::Serialize(input);
- RawBuffer buffer = msg.Pop();
+ RawBuffer buffer = SerializeMessage(input);
MessageBuffer resp;
resp.Push(buffer);
BOOST_REQUIRE_THROW(resp.Deserialize(output),
projects / platform / core / security / key-manager.git / commitdiff