/*
- * Copyright (c) 2000 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2014 - 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.
AsyncRequest::AsyncRequest(const ManagerAsync::ObserverPtr &o,
std::string &&i,
RawBuffer &&b,
- int id) :
+ int id,
+ int command) :
observer(o),
interface(std::move(i)),
buffer(std::move(b)),
written(0),
- id(id)
+ id(id),
+ command(command)
{
}
/*
- * Copyright (c) 2000 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2014 - 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.
AsyncRequest(const ManagerAsync::ObserverPtr &observer,
std::string &&interface,
RawBuffer &&buffer,
- int id);
+ int id,
+ int command);
ManagerAsync::ObserverPtr observer;
std::string interface;
RawBuffer buffer;
size_t written;
int id;
+ int command;
};
} /* namespace CKM */
/*
- * Copyright (c) 2000 - 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2014 - 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.
auto send = MessageBuffer::Serialize(m_counter, rawCertChain);
thread()->sendMessage(AsyncRequest(observer, SERVICE_SOCKET_OCSP, send.Pop(),
- m_counter));
+ m_counter, 0));
}, [&observer](int error) {
observer->ReceivedError(error);
});
CryptoAlgorithmSerializable cas(algo);
m_counter++;
- auto send = MessageBuffer::Serialize(static_cast<int>(encryption ?
- EncryptionCommand::ENCRYPT : EncryptionCommand::DECRYPT), m_counter, cas,
+ auto command = static_cast<int>(encryption ?
+ EncryptionCommand::ENCRYPT : EncryptionCommand::DECRYPT);
+ auto send = MessageBuffer::Serialize(command, m_counter, cas,
helper.getName(), helper.getOwner(), password, input);
thread()->sendMessage(AsyncRequest(observer, SERVICE_SOCKET_ENCRYPTION,
- send.Pop(), m_counter));
+ send.Pop(), m_counter, command));
}, [&observer](int error) {
observer->ReceivedError(error);
});
/*
- * Copyright (c) 2000 - 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2014 - 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.
private:
template <typename... Args>
void sendToStorage(const ManagerAsync::ObserverPtr &observer,
+ int command,
const Args &... args)
{
m_counter++; // yes, it changes m_counter argument passed in args
- auto send = MessageBuffer::Serialize(args...);
+ auto send = MessageBuffer::Serialize(command, args...);
thread()->sendMessage(AsyncRequest(observer,
SERVICE_SOCKET_CKM_STORAGE,
send.Pop(),
- m_counter));
+ m_counter,
+ command));
}
typedef std::unique_ptr<ConnectionThread> ConnectionThreadPtr;
/*
- * Copyright (c) 2000 - 2015 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 id = 0;
int retCode;
RawBuffer output;
- m_buffer.Deserialize(command, id, retCode, output);
+ m_buffer.Deserialize(id, retCode, output);
auto it = m_requests.find(id);
AsyncRequest req = std::move(m_requests.at(id));
m_requests.erase(id);
- switch (static_cast<EncryptionCommand>(command)) {
+ switch (static_cast<EncryptionCommand>(req.command)) {
case EncryptionCommand::ENCRYPT:
if (retCode == CKM_API_SUCCESS)
req.observer->ReceivedEncrypted(std::move(output));
/*
- * Copyright (c) 2000 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2014 - 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.
void StorageReceiver::processResponse()
{
- int command = 0, id = 0;
- m_buffer.Deserialize(command, id);
+ int id = 0;
+ m_buffer.Deserialize(id);
auto it = m_requests.find(id);
m_observer = req.observer;
- switch (static_cast<LogicCommand>(command)) {
+ switch (static_cast<LogicCommand>(req.command)) {
case LogicCommand::GET:
parseGetCommand();
break;
break;
default:
- LogError("Unknown command id: " << command);
- ThrowMsg(BadResponse, "Unknown command id: " << command);
+ LogError("Unknown command id: " << req.command);
+ ThrowMsg(BadResponse, "Unknown command id: " << req.command);
break;
}
}
/*
- * Copyright (c) 2000-2019 Samsung Electronics Co., Ltd. All rights reserved
+ * Copyright (c) 2014 - 2020 Samsung Electronics Co., Ltd. All rights reserved
*
* Contact: Dongsun Lee <ds73.lee@samsung.com>
*
if (CKM_API_SUCCESS != retCode)
return retCode;
- int command;
int counter;
- recv.Deserialize(command, counter, retCode);
+ recv.Deserialize(counter, retCode);
return retCode;
-/* Copyright (c) 2000 - 2019 Samsung Electronics Co., Ltd All Rights Reserved
+/* Copyright (c) 2014 - 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 getCertChain(
ServiceConnection &serviceConnection,
LogicCommand command,
- int counter,
+ int msgId,
const CertificateShPtr &certificate,
const T &untrustedVector,
const T &trustedVector,
MessageBuffer recv;
auto send = MessageBuffer::Serialize(static_cast<int>(command),
- counter,
+ msgId,
certificate->getDER(),
untrustedVector,
trustedVector,
if (CKM_API_SUCCESS != retCode)
return retCode;
- int retCommand;
- int retCounter;
+ int retMsgId;
RawBufferVector rawBufferVector;
- recv.Deserialize(retCommand, retCounter, retCode, rawBufferVector);
+ recv.Deserialize(retMsgId, retCode, rawBufferVector);
- if ((counter != retCounter) || (static_cast<int>(command) != retCommand))
+ if (msgId != retMsgId)
return CKM_API_ERROR_UNKNOWN;
if (retCode != CKM_API_SUCCESS)
const RawBuffer &rawData,
const Policy &policy)
{
- int my_counter = ++m_counter;
+ int msgId = ++m_counter;
EXCEPTION_GUARD_START_CPPAPI
MessageBuffer recv;
AliasSupport helper(alias);
auto send = MessageBuffer::Serialize(static_cast<int>(LogicCommand::SAVE),
- my_counter,
+ msgId,
static_cast<int>(dataType),
helper.getName(),
helper.getOwner(),
if (CKM_API_SUCCESS != retCode)
return retCode;
- int command;
- int counter;
+ int retMsgId;
int opType;
- recv.Deserialize(command, counter, retCode, opType);
+ recv.Deserialize(retMsgId, retCode, opType);
- if (counter != my_counter)
+ if (retMsgId != msgId)
return CKM_API_ERROR_UNKNOWN;
return retCode;
if (alias.empty() || pkcs.get() == NULL)
return CKM_API_ERROR_INPUT_PARAM;
- int my_counter = ++m_counter;
+ int msgId = ++m_counter;
EXCEPTION_GUARD_START_CPPAPI
AliasSupport helper(alias);
auto send = MessageBuffer::Serialize(static_cast<int>
(LogicCommand::SAVE_PKCS12),
- my_counter,
+ msgId,
helper.getName(),
helper.getOwner(),
PKCS12Serializable(*pkcs.get()),
if (CKM_API_SUCCESS != retCode)
return retCode;
- int command;
- int counter;
- recv.Deserialize(command, counter, retCode);
+ int retMsgId;
+ recv.Deserialize(retMsgId, retCode);
- if (counter != my_counter)
+ if (retMsgId != msgId)
return CKM_API_ERROR_UNKNOWN;
return retCode;
if (alias.empty())
return CKM_API_ERROR_INPUT_PARAM;
- int my_counter = ++m_counter;
+ int msgId = ++m_counter;
EXCEPTION_GUARD_START_CPPAPI
MessageBuffer recv;
AliasSupport helper(alias);
auto send = MessageBuffer::Serialize(static_cast<int>(LogicCommand::GET_PKCS12),
- my_counter,
+ msgId,
helper.getName(),
helper.getOwner(),
keyPass,
if (CKM_API_SUCCESS != retCode)
return retCode;
- int command;
- int counter;
+ int retMsgId;
PKCS12Serializable gotPkcs;
- recv.Deserialize(command, counter, retCode, gotPkcs);
+ recv.Deserialize(retMsgId, retCode, gotPkcs);
- if (counter != my_counter)
+ if (retMsgId != msgId)
return CKM_API_ERROR_UNKNOWN;
pkcs = std::make_shared<PKCS12Impl>(std::move(gotPkcs));
if (alias.empty())
return CKM_API_ERROR_INPUT_PARAM;
- int my_counter = ++m_counter;
+ int msgId = ++m_counter;
EXCEPTION_GUARD_START_CPPAPI
MessageBuffer recv;
AliasSupport helper(alias);
auto send = MessageBuffer::Serialize(static_cast<int>(LogicCommand::REMOVE),
- my_counter,
+ msgId,
helper.getName(),
helper.getOwner());
if (CKM_API_SUCCESS != retCode)
return retCode;
- int command;
- int counter;
- recv.Deserialize(command, counter, retCode);
+ int retMsgId;
+ recv.Deserialize(retMsgId, retCode);
- if (counter != my_counter)
+ if (retMsgId != msgId)
return CKM_API_ERROR_UNKNOWN;
return retCode;
if (alias.empty())
return CKM_API_ERROR_INPUT_PARAM;
- int my_counter = ++m_counter;
+ int msgId = ++m_counter;
EXCEPTION_GUARD_START_CPPAPI
MessageBuffer recv;
AliasSupport helper(alias);
auto send = MessageBuffer::Serialize(static_cast<int>(LogicCommand::GET),
- my_counter,
+ msgId,
static_cast<int>(sendDataType),
helper.getName(),
helper.getOwner(),
if (CKM_API_SUCCESS != retCode)
return retCode;
- int command;
- int counter;
+ int retMsgId;
int tmpDataType;
- recv.Deserialize(command, counter, retCode, tmpDataType, rawData);
+ recv.Deserialize(retMsgId, retCode, tmpDataType, rawData);
recvDataType = DataType(tmpDataType);
- if (counter != my_counter)
+ if (retMsgId != msgId)
return CKM_API_ERROR_UNKNOWN;
return retCode;
if (alias.empty())
return CKM_API_ERROR_INPUT_PARAM;
- int my_counter = ++m_counter;
+ int msgId = ++m_counter;
EXCEPTION_GUARD_START_CPPAPI
MessageBuffer recv;
AliasSupport helper(alias);
auto send = MessageBuffer::Serialize(static_cast<int>(LogicCommand::GET_PROTECTION_STATUS),
- my_counter,
+ msgId,
static_cast<int>(sendDataType),
helper.getName(),
helper.getOwner());
if (CKM_API_SUCCESS != retCode)
return retCode;
- int command;
- int counter;
+ int retMsgId;
int tmpDataType;
bool passwordProtectionStatus;
- recv.Deserialize(command, counter, retCode, tmpDataType, passwordProtectionStatus);
+ recv.Deserialize(retMsgId, retCode, tmpDataType, passwordProtectionStatus);
- if (counter != my_counter)
+ if (retMsgId != msgId)
return CKM_API_ERROR_UNKNOWN;
if (retCode != CKM_API_SUCCESS) {
int Manager::Impl::getBinaryDataAliasVectorHelper(DataType dataType,
OwnerNameVector &ownerNameVector)
{
- int my_counter = ++m_counter;
+ int msgId = ++m_counter;
MessageBuffer recv;
auto send = MessageBuffer::Serialize(static_cast<int>(LogicCommand::GET_LIST),
- my_counter,
+ msgId,
static_cast<int>(dataType));
int retCode = m_storageConnection.processRequest(send.Pop(), recv);
if (retCode != CKM_API_SUCCESS)
return retCode;
- int command;
- int counter;
+ int retMsgId;
int tmpDataType;
+ recv.Deserialize(retMsgId, retCode, tmpDataType, ownerNameVector);
- recv.Deserialize(command, counter, retCode, tmpDataType, ownerNameVector);
-
- if ((command != static_cast<int>(LogicCommand::GET_LIST)) ||
- (counter != my_counter))
+ if (retMsgId != msgId)
return CKM_API_ERROR_UNKNOWN;
return CKM_API_SUCCESS;
const Policy &policyKey)
{
// proceed with sending request
- int my_counter = ++m_counter;
+ int msgId = ++m_counter;
EXCEPTION_GUARD_START_CPPAPI
AliasSupport aliasHelper(keyAlias);
auto send = MessageBuffer::Serialize(static_cast<int>
(LogicCommand::CREATE_KEY_AES),
- my_counter,
+ msgId,
static_cast<int>(size),
PolicySerializable(policyKey),
aliasHelper.getName(),
if (CKM_API_SUCCESS != retCode)
return retCode;
- int command;
- int counter;
- recv.Deserialize(command, counter, retCode);
+ int retMsgId;
+ recv.Deserialize(retMsgId, retCode);
- if (counter != my_counter)
+ if (retMsgId != msgId)
return CKM_API_ERROR_UNKNOWN;
return retCode;
}
// proceed with sending request
- int my_counter = ++m_counter;
+ int msgId = ++m_counter;
EXCEPTION_GUARD_START_CPPAPI
AliasSupport publicHelper(publicKeyAlias);
auto send = MessageBuffer::Serialize(static_cast<int>
(LogicCommand::CREATE_KEY_PAIR),
- my_counter,
+ msgId,
CryptoAlgorithmSerializable(keyGenAlgorithm),
PolicySerializable(policyPrivateKey),
PolicySerializable(policyPublicKey),
if (CKM_API_SUCCESS != retCode)
return retCode;
- int command;
- int counter;
- recv.Deserialize(command, counter, retCode);
+ int retMsgId;
+ recv.Deserialize(retMsgId, retCode);
- if (counter != my_counter)
+ if (retMsgId != msgId)
return CKM_API_ERROR_UNKNOWN;
return retCode;
const CryptoAlgorithm &cAlgorithm,
RawBuffer &signature)
{
- int my_counter = ++m_counter;
+ int msgId = ++m_counter;
EXCEPTION_GUARD_START_CPPAPI
AliasSupport helper(privateKeyAlias);
auto send = MessageBuffer::Serialize(static_cast<int>
(LogicCommand::CREATE_SIGNATURE),
- my_counter,
+ msgId,
helper.getName(),
helper.getOwner(),
password,
if (CKM_API_SUCCESS != retCode)
return retCode;
- int command;
- int counter;
- recv.Deserialize(command, counter, retCode, signature);
+ int retMsgId;
+ recv.Deserialize(retMsgId, retCode, signature);
- if ((command != static_cast<int>(LogicCommand::CREATE_SIGNATURE))
- || (counter != my_counter))
+ if (retMsgId != msgId)
return CKM_API_ERROR_UNKNOWN;
return retCode;
const RawBuffer &signature,
const CryptoAlgorithm &cAlg)
{
- int my_counter = ++m_counter;
+ int msgId = ++m_counter;
EXCEPTION_GUARD_START_CPPAPI
AliasSupport helper(publicKeyOrCertAlias);
auto send = MessageBuffer::Serialize(static_cast<int>
(LogicCommand::VERIFY_SIGNATURE),
- my_counter,
+ msgId,
helper.getName(),
helper.getOwner(),
password,
if (CKM_API_SUCCESS != retCode)
return retCode;
- int command;
- int counter;
- recv.Deserialize(command, counter, retCode);
+ int retMsgId;
+ recv.Deserialize(retMsgId, retCode);
- if ((command != static_cast<int>(LogicCommand::VERIFY_SIGNATURE))
- || (counter != my_counter))
+ if (retMsgId != msgId)
return CKM_API_ERROR_UNKNOWN;
return retCode;
{
EXCEPTION_GUARD_START_CPPAPI
- int my_counter = ++m_counter;
+ int msgId = ++m_counter;
MessageBuffer recv;
RawBufferVector rawCertChain;
rawCertChain.push_back(e->getDER());
}
- auto send = MessageBuffer::Serialize(my_counter, rawCertChain);
+ auto send = MessageBuffer::Serialize(msgId, rawCertChain);
int retCode = m_ocspConnection.processRequest(send.Pop(), recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
- int counter;
- recv.Deserialize(counter, retCode, ocspStatus);
+ int retMsgId;
+ recv.Deserialize(retMsgId, retCode, ocspStatus);
- if (my_counter != counter)
+ if (msgId != retMsgId)
return CKM_API_ERROR_UNKNOWN;
return retCode;
const ClientId &accessor,
PermissionMask permissionMask)
{
- int my_counter = ++m_counter;
+ int msgId = ++m_counter;
EXCEPTION_GUARD_START_CPPAPI
AliasSupport helper(alias);
auto send = MessageBuffer::Serialize(static_cast<int>
(LogicCommand::SET_PERMISSION),
- my_counter,
+ msgId,
helper.getName(),
helper.getOwner(),
accessor,
if (CKM_API_SUCCESS != retCode)
return retCode;
- int command;
- int counter;
- recv.Deserialize(command, counter, retCode);
+ int retMsgId;
+ recv.Deserialize(retMsgId, retCode);
- if (my_counter != counter)
+ if (msgId != retMsgId)
return CKM_API_ERROR_UNKNOWN;
return retCode;
const RawBuffer &input,
RawBuffer &output)
{
- int my_counter = ++m_counter;
+ int msgId = ++m_counter;
EXCEPTION_GUARD_START_CPPAPI
AliasSupport helper(keyAlias);
CryptoAlgorithmSerializable cas(algo);
auto send = MessageBuffer::Serialize(static_cast<int>(command),
- my_counter,
+ msgId,
cas,
helper.getName(),
helper.getOwner(),
if (CKM_API_SUCCESS != retCode)
return retCode;
- int retCommand;
- int counter;
- recv.Deserialize(retCommand, counter, retCode, output);
+ int retMsgId;
+ recv.Deserialize(retMsgId, retCode, output);
- if (my_counter != counter || retCommand != static_cast<int>(command))
+ if (msgId != retMsgId)
return CKM_API_ERROR_UNKNOWN;
return retCode;
RawBuffer CKMLogic::saveData(
const Credentials &cred,
- int commandId,
+ int msgId,
const Name &name,
const ClientId &explicitOwner,
const Crypto::Data &data,
const PolicySerializable &policy)
{
int retCode = verifyAndSaveDataHelper(cred, name, explicitOwner, data, policy);
- auto response = MessageBuffer::Serialize(static_cast<int>(LogicCommand::SAVE),
- commandId,
- retCode,
- static_cast<int>(data.type));
+ auto response = MessageBuffer::Serialize(msgId, retCode, static_cast<int>(data.type));
return response.Pop();
}
RawBuffer CKMLogic::savePKCS12(
const Credentials &cred,
- int commandId,
+ int msgId,
const Name &name,
const ClientId &explicitOwner,
const PKCS12Serializable &pkcs,
retCode = CKM_API_ERROR_SERVER_ERROR;
}
- auto response = MessageBuffer::Serialize(static_cast<int>
- (LogicCommand::SAVE_PKCS12),
- commandId,
- retCode);
+ auto response = MessageBuffer::Serialize(msgId, retCode);
return response.Pop();
}
RawBuffer CKMLogic::removeData(
const Credentials &cred,
- int commandId,
+ int msgId,
const Name &name,
const ClientId &explicitOwner)
{
retCode = CKM_API_ERROR_DB_ERROR;
}
- auto response = MessageBuffer::Serialize(static_cast<int>(LogicCommand::REMOVE),
- commandId,
- retCode);
+ auto response = MessageBuffer::Serialize(msgId, retCode);
return response.Pop();
}
RawBuffer CKMLogic::getData(
const Credentials &cred,
- int commandId,
+ int msgId,
DataType dataType,
const Name &name,
const ClientId &explicitOwner,
if (CKM_API_SUCCESS != retCode)
rowData.clear();
- auto response = MessageBuffer::Serialize(static_cast<int>(LogicCommand::GET),
- commandId,
- retCode,
- static_cast<int>(objDataType),
- rowData);
+ auto response = MessageBuffer::Serialize(msgId,
+ retCode,
+ static_cast<int>(objDataType),
+ rowData);
return response.Pop();
}
RawBuffer CKMLogic::getDataProtectionStatus(
const Credentials &cred,
- int commandId,
+ int msgId,
DataType dataType,
const Name &name,
const ClientId &explicitOwner)
retCode = CKM_API_SUCCESS;
}
- auto response = MessageBuffer::Serialize(static_cast<int>(LogicCommand::GET_PROTECTION_STATUS),
- commandId,
- retCode,
- static_cast<int>(objDataType),
- status);
+ auto response = MessageBuffer::Serialize(msgId,
+ retCode,
+ static_cast<int>(objDataType),
+ status);
return response.Pop();
}
RawBuffer CKMLogic::getPKCS12(
const Credentials &cred,
- int commandId,
+ int msgId,
const Name &name,
const ClientId &explicitOwner,
const Password &keyPassword,
retCode = CKM_API_ERROR_SERVER_ERROR;
}
- auto response = MessageBuffer::Serialize(static_cast<int>
- (LogicCommand::GET_PKCS12),
- commandId,
- retCode,
- output);
+ auto response = MessageBuffer::Serialize(msgId, retCode, output);
return response.Pop();
}
RawBuffer CKMLogic::getDataList(
const Credentials &cred,
- int commandId,
+ int msgId,
DataType dataType)
{
OwnerNameVector systemVector;
userVector.end());
}
- auto response = MessageBuffer::Serialize(static_cast<int>
- (LogicCommand::GET_LIST),
- commandId,
- retCode,
- static_cast<int>(dataType),
- ownerNameVector);
+ auto response = MessageBuffer::Serialize(msgId,
+ retCode,
+ static_cast<int>(dataType),
+ ownerNameVector);
return response.Pop();
}
RawBuffer CKMLogic::createKeyPair(
const Credentials &cred,
- int commandId,
+ int msgId,
const CryptoAlgorithmSerializable &keyGenParams,
const Name &namePrivate,
const ClientId &explicitOwnerPrivate,
retCode = CKM_API_ERROR_SERVER_ERROR;
}
- return MessageBuffer::Serialize(static_cast<int>(LogicCommand::CREATE_KEY_PAIR),
- commandId, retCode).Pop();
+ return MessageBuffer::Serialize(msgId, retCode).Pop();
}
RawBuffer CKMLogic::createKeyAES(
const Credentials &cred,
- int commandId,
+ int msgId,
const int size,
const Name &name,
const ClientId &explicitOwner,
retCode = CKM_API_ERROR_SERVER_ERROR;
}
- return MessageBuffer::Serialize(static_cast<int>(LogicCommand::CREATE_KEY_AES),
- commandId, retCode).Pop();
+ return MessageBuffer::Serialize(msgId, retCode).Pop();
}
int CKMLogic::readCertificateHelper(
RawBuffer CKMLogic::getCertificateChain(
const Credentials & /*cred*/,
- int commandId,
+ int msgId,
const RawBuffer &certificate,
const RawBufferVector &untrustedCertificates,
const RawBufferVector &trustedCertificates,
LogError("Unknown error.");
}
- auto response = MessageBuffer::Serialize(static_cast<int>
- (LogicCommand::GET_CHAIN_CERT),
- commandId,
- retCode,
- chainRawVector);
+ auto response = MessageBuffer::Serialize(msgId, retCode, chainRawVector);
return response.Pop();
}
RawBuffer CKMLogic::getCertificateChain(
const Credentials &cred,
- int commandId,
+ int msgId,
const RawBuffer &certificate,
const OwnerNameVector &untrustedCertificates,
const OwnerNameVector &trustedCertificates,
LogError("Unknown error.");
}
- auto response = MessageBuffer::Serialize(static_cast<int>
- (LogicCommand::GET_CHAIN_ALIAS),
- commandId,
- retCode,
- chainRawVector);
+ auto response = MessageBuffer::Serialize(msgId, retCode, chainRawVector);
return response.Pop();
}
RawBuffer CKMLogic::createSignature(
const Credentials &cred,
- int commandId,
+ int msgId,
const Name &privateKeyName,
const ClientId &explicitOwner,
const Password &password, // password for private_key
retCode = CKM_API_ERROR_SERVER_ERROR;
}
- auto response = MessageBuffer::Serialize(static_cast<int>
- (LogicCommand::CREATE_SIGNATURE),
- commandId,
- retCode,
- signature);
+ auto response = MessageBuffer::Serialize(msgId, retCode, signature);
return response.Pop();
}
RawBuffer CKMLogic::verifySignature(
const Credentials &cred,
- int commandId,
+ int msgId,
const Name &publicKeyOrCertName,
const ClientId &explicitOwner,
const Password &password, // password for public_key (optional)
retCode = CKM_API_ERROR_SERVER_ERROR;
}
- auto response = MessageBuffer::Serialize(static_cast<int>
- (LogicCommand::VERIFY_SIGNATURE),
- commandId,
- retCode);
+ auto response = MessageBuffer::Serialize(msgId, retCode);
return response.Pop();
}
RawBuffer CKMLogic::setPermission(
const Credentials &cred,
- const int command,
const int msgID,
const Name &name,
const ClientId &explicitOwner,
retCode = CKM_API_ERROR_DB_ERROR;
}
- return MessageBuffer::Serialize(command, msgID, retCode).Pop();
+ return MessageBuffer::Serialize(msgID, retCode).Pop();
}
int CKMLogic::loadAppKey(UserData &handle, const ClientId &owner)
/*
- * Copyright (c) 2014 - 2019 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2014 - 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.
RawBuffer saveData(
const Credentials &cred,
- int commandId,
+ int msgId,
const Name &name,
const ClientId &explicitOwner,
const Crypto::Data &data,
RawBuffer savePKCS12(
const Credentials &cred,
- int commandId,
+ int msgId,
const Name &name,
const ClientId &explicitOwner,
const PKCS12Serializable &pkcs,
RawBuffer removeData(
const Credentials &cred,
- int commandId,
+ int msgId,
const Name &name,
const ClientId &explicitOwner);
RawBuffer getData(
const Credentials &cred,
- int commandId,
+ int msgId,
DataType dataType,
const Name &name,
const ClientId &explicitOwner,
RawBuffer getDataProtectionStatus(
const Credentials &cred,
- int commandId,
+ int msgId,
DataType dataType,
const Name &name,
const ClientId &explicitOwner);
RawBuffer getPKCS12(
const Credentials &cred,
- int commandId,
+ int msgId,
const Name &name,
const ClientId &explicitOwner,
const Password &keyPassword,
RawBuffer getDataList(
const Credentials &cred,
- int commandId,
+ int msgId,
DataType dataType);
RawBuffer createKeyPair(
const Credentials &cred,
- int commandId,
+ int msgId,
const CryptoAlgorithmSerializable &keyGenParams,
const Name &namePrivate,
const ClientId &explicitOwnerPrivate,
RawBuffer createKeyAES(
const Credentials &cred,
- int commandId,
+ int msgId,
const int size,
const Name &name,
const ClientId &explicitOwner,
RawBuffer getCertificateChain(
const Credentials &cred,
- int commandId,
+ int msgId,
const RawBuffer &certificate,
const RawBufferVector &untrustedCertificates,
const RawBufferVector &trustedCertificates,
RawBuffer getCertificateChain(
const Credentials &cred,
- int commandId,
+ int msgId,
const RawBuffer &certificate,
const OwnerNameVector &untrustedCertificates,
const OwnerNameVector &trustedCertificates,
RawBuffer createSignature(
const Credentials &cred,
- int commandId,
+ int msgId,
const Name &privateKeyName,
const ClientId &explicitOwner,
const Password &password, // password for private_key
RawBuffer verifySignature(
const Credentials &cred,
- int commandId,
+ int msgId,
const Name &publicKeyOrCertName,
const ClientId &explicitOwner,
const Password &password, // password for public_key (optional)
RawBuffer setPermission(
const Credentials &cred,
- const int command,
const int msgID,
const Name &name,
const ClientId &explicitOwner,
/*
- * Copyright (c) 2000 - 2019 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2014 - 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.
logicFunc = [&, name, explicitOwner, accessor, permissionMask, cred]() {
return m_logic->setPermission(
cred,
- command,
0, // dummy
name,
explicitOwner,
RawBuffer CKMService::ProcessStorage(Credentials &cred, MessageBuffer &buffer)
{
int command = 0;
- int msgID = 0;
+ int msgId = 0;
int tmpDataType = 0;
Name name;
ClientId explicitOwner, accessor;
buffer.Deserialize(command);
- buffer.Deserialize(msgID);
+ buffer.Deserialize(msgId);
// This is a workaround solution for locktype=None in Tizen 2.2.1
// When locktype is None, lockscreen app doesn't interfere with unlocking process.
buffer.Deserialize(tmpDataType, name, explicitOwner, rawData, policy);
return m_logic->saveData(
cred,
- msgID,
+ msgId,
name,
explicitOwner,
Crypto::Data(DataType(tmpDataType), std::move(rawData)),
buffer.Deserialize(name, explicitOwner, pkcs, keyPolicy, certPolicy);
return m_logic->savePKCS12(
cred,
- msgID,
+ msgId,
name,
explicitOwner,
pkcs,
buffer.Deserialize(name, explicitOwner);
return m_logic->removeData(
cred,
- msgID,
+ msgId,
name,
explicitOwner);
}
buffer.Deserialize(tmpDataType, name, explicitOwner, password);
return m_logic->getData(
cred,
- msgID,
+ msgId,
DataType(tmpDataType),
name,
explicitOwner,
case LogicCommand::GET_PKCS12: {
Password passKey;
Password passCert;
- buffer.Deserialize(
- name,
- explicitOwner,
- passKey,
- passCert);
+ buffer.Deserialize(name, explicitOwner, passKey, passCert);
return m_logic->getPKCS12(
cred,
- msgID,
+ msgId,
name,
explicitOwner,
passKey,
buffer.Deserialize(tmpDataType, name, explicitOwner);
return m_logic->getDataProtectionStatus(
cred,
- msgID,
+ msgId,
DataType(tmpDataType),
name,
explicitOwner);
buffer.Deserialize(tmpDataType);
return m_logic->getDataList(
cred,
- msgID,
+ msgId,
DataType(tmpDataType));
}
Name keyName;
ClientId keyExplicitOwner;
PolicySerializable policyKey;
- buffer.Deserialize(
- size,
- policyKey,
- keyName,
- keyExplicitOwner);
+ buffer.Deserialize(size, policyKey, keyName, keyExplicitOwner);
return m_logic->createKeyAES(
cred,
- msgID,
+ msgId,
size,
keyName,
keyExplicitOwner,
explicitOwnerPublic);
return m_logic->createKeyPair(
cred,
- msgID,
+ msgId,
keyGenAlgorithm,
privateKeyName,
explicitOwnerPrivate,
buffer.Deserialize(certificate, untrustedVector, trustedVector, systemCerts);
return m_logic->getCertificateChain(
cred,
- msgID,
+ msgId,
certificate,
untrustedVector,
trustedVector,
buffer.Deserialize(certificate, untrustedVector, trustedVector, systemCerts);
return m_logic->getCertificateChain(
cred,
- msgID,
+ msgId,
certificate,
untrustedVector,
trustedVector,
return m_logic->createSignature(
cred,
- msgID,
+ msgId,
name,
explicitOwner,
password, // password for private_key
RawBuffer signature;
CryptoAlgorithmSerializable cAlg;
- buffer.Deserialize(name,
- explicitOwner,
- password,
- message,
- signature,
- cAlg);
+ buffer.Deserialize(name, explicitOwner, password, message, signature, cAlg);
return m_logic->verifySignature(
cred,
- msgID,
+ msgId,
name,
explicitOwner,
password, // password for public_key (optional)
buffer.Deserialize(name, explicitOwner, accessor, permissionMask);
return m_logic->setPermission(
cred,
- command,
- msgID,
+ msgId,
name,
explicitOwner,
accessor,
/*
- * Copyright (c) 2000 - 2015 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.
const RawBuffer &data)
{
try {
- RawBuffer response = MessageBuffer::Serialize(
- static_cast<int>(request.command), request.msgId, retCode, data).Pop();
+ RawBuffer response = MessageBuffer::Serialize(request.msgId, retCode, data).Pop();
m_serviceManager->Write(request.conn, response);
} catch (...) {
LogError("Failed to send response to the client");
/*
- * Copyright (c) 2014 - 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2014 - 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.
m_isNetAvailable = false;
}
-RawBuffer OCSPLogic::ocspCheck(int commandId, const RawBufferVector &rawChain,
+RawBuffer OCSPLogic::ocspCheck(int msgId, const RawBufferVector &rawChain,
bool allowed)
{
CertificateImplVector certChain;
if (retCode == CKM_API_SUCCESS)
ocspStatus = ocsp.verify(certChain);
- return MessageBuffer::Serialize(commandId, retCode, ocspStatus).Pop();
+ return MessageBuffer::Serialize(msgId, retCode, ocspStatus).Pop();
}
} // namespace CKM
/*
- * Copyright (c) 2014 - 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2014 - 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.
OCSPLogic &operator=(const OCSPLogic &) = delete;
OCSPLogic &operator=(OCSPLogic &&) = delete;
- RawBuffer ocspCheck(int commandId, const RawBufferVector &rawChain,
- bool allowed);
+ RawBuffer ocspCheck(int msgId, const RawBufferVector &rawChain, bool allowed);
virtual ~OCSPLogic() {}
private:
/*
- * Copyright (c) 2014 - 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2014 - 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.
auto &buffer = info.buffer;
- int commandId = 0;
+ int msgId = 0;
RawBufferVector chainVector;
- buffer.Deserialize(commandId, chainVector);
+ buffer.Deserialize(msgId, chainVector);
- RawBuffer response = m_logic->ocspCheck(commandId, chainVector, allowed);
+ RawBuffer response = m_logic->ocspCheck(msgId, chainVector, allowed);
m_serviceManager->Write(conn, response);
return true;