* result codes begin with the start error code and extend into negative direction.
* @{
*/
-#define KEY_MANAGER_API_SUCCESS 0
+#define CKM_API_SUCCESS 0
/*! \brief indicating the result of the one specific API is successful */
-#define KEY_MANAGER_API_ERROR_SOCKET -1
+#define CKM_API_ERROR_SOCKET -1
/*! \brief indicating the socket between client and Central Key Manager failed */
-#define KEY_MANAGER_API_ERROR_BAD_REQUEST -2
+#define CKM_API_ERROR_BAD_REQUEST -2
/*! \brief indicating the response from Central Key Manager is malformed */
-#define KEY_MANAGER_API_ERROR_BAD_RESPONSE -3
+#define CKM_API_ERROR_BAD_RESPONSE -3
/*! \brief indicating the transmitting request failed */
/* deprecated unused */
-#define KEY_MANAGER_API_ERROR_SEND_FAILED -4
+#define CKM_API_ERROR_SEND_FAILED -4
/*! \brief indicating the receiving response failed */
/* deprecated unused */
-#define KEY_MANAGER_API_ERROR_RECV_FAILED -5
+#define CKM_API_ERROR_RECV_FAILED -5
/*! \brief indicating the authentication between client and manager failed */
-#define KEY_MANAGER_API_ERROR_AUTHENTICATION_FAILED -6
+#define CKM_API_ERROR_AUTHENTICATION_FAILED -6
/*! \brief indicating the API's input parameter is malformed */
-#define KEY_MANAGER_API_ERROR_INPUT_PARAM -7
+#define CKM_API_ERROR_INPUT_PARAM -7
/*! \brief indicating the output buffer size which is passed as parameter is too small */
-#define KEY_MANAGER_API_ERROR_BUFFER_TOO_SMALL -8
+#define CKM_API_ERROR_BUFFER_TOO_SMALL -8
/*! \brief indicating system is running out of memory state */
-#define KEY_MANAGER_API_ERROR_OUT_OF_MEMORY -9
+#define CKM_API_ERROR_OUT_OF_MEMORY -9
/*! \brief indicating the access has been denied by Central Key Manager */
-#define KEY_MANAGER_API_ERROR_ACCESS_DENIED -10
+#define CKM_API_ERROR_ACCESS_DENIED -10
/*! \brief indicating Central Key Manager has been failed for some reason */
-#define KEY_MANAGER_API_ERROR_SERVER_ERROR -11
+#define CKM_API_ERROR_SERVER_ERROR -11
/*! \brief indicating the database was not unlocked - user did not login */
-#define KEY_MANAGER_API_ERROR_DB_LOCKED -12
+#define CKM_API_ERROR_DB_LOCKED -12
/*! \brief indicating an internal error inside the database */
-#define KEY_MANAGER_API_ERROR_DB_ERROR -13
+#define CKM_API_ERROR_DB_ERROR -13
/*! \brief indicating that provided alias already exists in the database */
-#define KEY_MANAGER_API_ERROR_DB_ALIAS_EXISTS -14
+#define CKM_API_ERROR_DB_ALIAS_EXISTS -14
/*! \brief indicating that request give to database returned no result */
-#define KEY_MANAGER_API_ERROR_DB_ALIAS_UNKNOWN -15
+#define CKM_API_ERROR_DB_ALIAS_UNKNOWN -15
/*! \brief indicating the error with unknown reason */
-#define KEY_MANAGER_API_ERROR_UNKNOWN -255
+#define CKM_API_ERROR_UNKNOWN -255
/** @}*/
namespace CKM {
* \param[in] Message for service
* \param[out] Response from service
*
- * \return KEY_MANAGER_API_ERROR_INPUT_PARAM when trying to pass NULL message
- * \return KEY_MANAGER_API_SUCCESS on success
+ * \return CKM_API_ERROR_INPUT_PARAM when trying to pass NULL message
+ * \return CKM_API_SUCCESS on success
*/
int key_manager_echo(const char* echo, char** oche);
if (m_sock < 0) {
int err = errno;
LogError("Error creating socket: " << strerror(err));
- return KEY_MANAGER_API_ERROR_SOCKET;
+ return CKM_API_ERROR_SOCKET;
}
if ((flags = fcntl(m_sock, F_GETFL, 0)) < 0 ||
{
int err = errno;
LogError("Error in fcntl: " << strerror(err));
- return KEY_MANAGER_API_ERROR_SOCKET;
+ return CKM_API_ERROR_SOCKET;
}
memset(&clientAddr, 0, sizeof(clientAddr));
if (strlen(interface) >= sizeof(clientAddr.sun_path)) {
LogError("Error: interface name " << interface << "is too long. Max len is:" << sizeof(clientAddr.sun_path));
- return KEY_MANAGER_API_ERROR_SOCKET;
+ return CKM_API_ERROR_SOCKET;
}
strcpy(clientAddr.sun_path, interface);
if ((retval == -1) && (errno == EINPROGRESS)) {
if (0 >= waitForSocket(m_sock, POLLIN, POLL_TIMEOUT)) {
LogError("Error in waitForSocket.");
- return KEY_MANAGER_API_ERROR_SOCKET;
+ return CKM_API_ERROR_SOCKET;
}
int error = 0;
size_t len = sizeof(error);
if (-1 == retval) {
int err = errno;
LogError("Error in getsockopt: " << strerror(err));
- return KEY_MANAGER_API_ERROR_SOCKET;
+ return CKM_API_ERROR_SOCKET;
}
if (error == EACCES) {
LogError("Access denied");
- return KEY_MANAGER_API_ERROR_ACCESS_DENIED;
+ return CKM_API_ERROR_ACCESS_DENIED;
}
if (error != 0) {
LogError("Error in connect: " << strerror(error));
- return KEY_MANAGER_API_ERROR_SOCKET;
+ return CKM_API_ERROR_SOCKET;
}
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
if (-1 == retval) {
int err = errno;
LogError("Error connecting socket: " << strerror(err));
if (err == EACCES)
- return KEY_MANAGER_API_ERROR_ACCESS_DENIED;
- return KEY_MANAGER_API_ERROR_SOCKET;
+ return CKM_API_ERROR_ACCESS_DENIED;
+ return CKM_API_ERROR_SOCKET;
}
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
int Get() {
ssize_t done = 0;
char buffer[2048];
- if (KEY_MANAGER_API_SUCCESS != (ret = sock.Connect(interface))) {
+ if (CKM_API_SUCCESS != (ret = sock.Connect(interface))) {
LogError("Error in SockRAII");
return ret;
}
while ((send.size() - done) > 0) {
if (0 >= waitForSocket(sock.Get(), POLLOUT, POLL_TIMEOUT)) {
LogError("Error in poll(POLLOUT)");
- return KEY_MANAGER_API_ERROR_SOCKET;
+ return CKM_API_ERROR_SOCKET;
}
ssize_t temp = TEMP_FAILURE_RETRY(write(sock.Get(), &send[done], send.size() - done));
if (-1 == temp) {
int err = errno;
LogError("Error in write: " << strerror(err));
- return KEY_MANAGER_API_ERROR_SOCKET;
+ return CKM_API_ERROR_SOCKET;
}
done += temp;
}
do {
if (0 >= waitForSocket(sock.Get(), POLLIN, POLL_TIMEOUT)) {
LogError("Error in poll(POLLIN)");
- return KEY_MANAGER_API_ERROR_SOCKET;
+ return CKM_API_ERROR_SOCKET;
}
ssize_t temp = TEMP_FAILURE_RETRY(read(sock.Get(), buffer, 2048));
if (-1 == temp) {
int err = errno;
LogError("Error in read: " << strerror(err));
- return KEY_MANAGER_API_ERROR_SOCKET;
+ return CKM_API_ERROR_SOCKET;
}
if (0 == temp) {
LogError("Read return 0/Connection closed by server(?)");
- return KEY_MANAGER_API_ERROR_SOCKET;
+ return CKM_API_ERROR_SOCKET;
}
RawBuffer raw(buffer, buffer+temp);
recv.Push(raw);
} while(!recv.Ready());
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
int try_catch(const std::function<int()>& func)
} catch (...) {
LogError("Unknown exception occured");
}
- return KEY_MANAGER_API_ERROR_UNKNOWN;
+ return CKM_API_ERROR_UNKNOWN;
}
} // namespace CKM
send.Pop(),
recv);
- if (KEY_MANAGER_API_SUCCESS != retCode) {
+ if (CKM_API_SUCCESS != retCode) {
return retCode;
}
send.Pop(),
recv);
- if (KEY_MANAGER_API_SUCCESS != retCode) {
+ if (CKM_API_SUCCESS != retCode) {
return retCode;
}
send.Pop(),
recv);
- if (KEY_MANAGER_API_SUCCESS != retCode) {
+ if (CKM_API_SUCCESS != retCode) {
return retCode;
}
send.Pop(),
recv);
- if (KEY_MANAGER_API_SUCCESS != retCode) {
+ if (CKM_API_SUCCESS != retCode) {
return retCode;
}
send.Pop(),
recv);
- if (KEY_MANAGER_API_SUCCESS != retCode) {
+ if (CKM_API_SUCCESS != retCode) {
return retCode;
}
if(echo == NULL){
LogDebug("Echo message is null");
- return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+ return CKM_API_ERROR_INPUT_PARAM;
}
MessageBuffer send, recv;
int retCode = sendToServer(SERVICE_SOCKET_ECHO, send.Pop(), recv);
- if(retCode != KEY_MANAGER_API_SUCCESS)
+ if(retCode != CKM_API_SUCCESS)
return retCode;
std::string response;
*oche = strdup(response.c_str());
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
__attribute__ ((visibility ("default")))
const char * ErrorToString(int error) {
switch(error) {
- ERRORDESCRIBE(KEY_MANAGER_API_SUCCESS);
- ERRORDESCRIBE(KEY_MANAGER_API_ERROR_SOCKET);
- ERRORDESCRIBE(KEY_MANAGER_API_ERROR_BAD_REQUEST);
- ERRORDESCRIBE(KEY_MANAGER_API_ERROR_BAD_RESPONSE);
- ERRORDESCRIBE(KEY_MANAGER_API_ERROR_SEND_FAILED);
- ERRORDESCRIBE(KEY_MANAGER_API_ERROR_RECV_FAILED);
- ERRORDESCRIBE(KEY_MANAGER_API_ERROR_AUTHENTICATION_FAILED);
- ERRORDESCRIBE(KEY_MANAGER_API_ERROR_INPUT_PARAM);
- ERRORDESCRIBE(KEY_MANAGER_API_ERROR_BUFFER_TOO_SMALL);
- ERRORDESCRIBE(KEY_MANAGER_API_ERROR_OUT_OF_MEMORY);
- ERRORDESCRIBE(KEY_MANAGER_API_ERROR_ACCESS_DENIED);
- ERRORDESCRIBE(KEY_MANAGER_API_ERROR_SERVER_ERROR);
- ERRORDESCRIBE(KEY_MANAGER_API_ERROR_DB_LOCKED);
- ERRORDESCRIBE(KEY_MANAGER_API_ERROR_DB_ERROR);
- ERRORDESCRIBE(KEY_MANAGER_API_ERROR_DB_ALIAS_EXISTS);
- ERRORDESCRIBE(KEY_MANAGER_API_ERROR_DB_ALIAS_UNKNOWN);
- ERRORDESCRIBE(KEY_MANAGER_API_ERROR_UNKNOWN);
+ ERRORDESCRIBE(CKM_API_SUCCESS);
+ ERRORDESCRIBE(CKM_API_ERROR_SOCKET);
+ ERRORDESCRIBE(CKM_API_ERROR_BAD_REQUEST);
+ ERRORDESCRIBE(CKM_API_ERROR_BAD_RESPONSE);
+ ERRORDESCRIBE(CKM_API_ERROR_SEND_FAILED);
+ ERRORDESCRIBE(CKM_API_ERROR_RECV_FAILED);
+ ERRORDESCRIBE(CKM_API_ERROR_AUTHENTICATION_FAILED);
+ ERRORDESCRIBE(CKM_API_ERROR_INPUT_PARAM);
+ ERRORDESCRIBE(CKM_API_ERROR_BUFFER_TOO_SMALL);
+ ERRORDESCRIBE(CKM_API_ERROR_OUT_OF_MEMORY);
+ ERRORDESCRIBE(CKM_API_ERROR_ACCESS_DENIED);
+ ERRORDESCRIBE(CKM_API_ERROR_SERVER_ERROR);
+ ERRORDESCRIBE(CKM_API_ERROR_DB_LOCKED);
+ ERRORDESCRIBE(CKM_API_ERROR_DB_ERROR);
+ ERRORDESCRIBE(CKM_API_ERROR_DB_ALIAS_EXISTS);
+ ERRORDESCRIBE(CKM_API_ERROR_DB_ALIAS_UNKNOWN);
+ ERRORDESCRIBE(CKM_API_ERROR_UNKNOWN);
default:
return "Error not defined";
}
return try_catch([&] {
if (alias.empty() || rawData.empty())
- return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+ return CKM_API_ERROR_INPUT_PARAM;
MessageBuffer send, recv;
Serialization::Serialize(send, static_cast<int>(LogicCommand::SAVE));
send.Pop(),
recv);
- if (KEY_MANAGER_API_SUCCESS != retCode) {
+ if (CKM_API_SUCCESS != retCode) {
return retCode;
}
Deserialization::Deserialize(recv, opType);
if (counter != m_counter) {
- return KEY_MANAGER_API_ERROR_UNKNOWN;
+ return CKM_API_ERROR_UNKNOWN;
}
return retCode;
int Manager::ManagerImpl::saveKey(const Alias &alias, const Key &key, const Policy &policy) {
if (key.empty())
- return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+ return CKM_API_ERROR_INPUT_PARAM;
return saveBinaryData(alias, toDBDataType(key.getType()), key.getDER(), policy);
}
int Manager::ManagerImpl::saveData(const Alias &alias, const RawBuffer &rawData, const Policy &policy) {
if (!policy.extractable)
- return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+ return CKM_API_ERROR_INPUT_PARAM;
return saveBinaryData(alias, DBDataType::BINARY_DATA, rawData, policy);
}
{
return try_catch([&] {
if (alias.empty())
- return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+ return CKM_API_ERROR_INPUT_PARAM;
MessageBuffer send, recv;
Serialization::Serialize(send, static_cast<int>(LogicCommand::REMOVE));
send.Pop(),
recv);
- if (KEY_MANAGER_API_SUCCESS != retCode) {
+ if (CKM_API_SUCCESS != retCode) {
return retCode;
}
Deserialization::Deserialize(recv, opType);
if (counter != m_counter) {
- return KEY_MANAGER_API_ERROR_UNKNOWN;
+ return CKM_API_ERROR_UNKNOWN;
}
return retCode;
{
return try_catch([&] {
if (alias.empty())
- return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+ return CKM_API_ERROR_INPUT_PARAM;
MessageBuffer send, recv;
Serialization::Serialize(send, static_cast<int>(LogicCommand::GET));
send.Pop(),
recv);
- if (KEY_MANAGER_API_SUCCESS != retCode) {
+ if (CKM_API_SUCCESS != retCode) {
return retCode;
}
recvDataType = static_cast<DBDataType>(tmpDataType);
if (counter != m_counter) {
- return KEY_MANAGER_API_ERROR_UNKNOWN;
+ return CKM_API_ERROR_UNKNOWN;
}
return retCode;
recvDataType,
rawData);
- if (retCode != KEY_MANAGER_API_SUCCESS)
+ if (retCode != CKM_API_SUCCESS)
return retCode;
Key keyParsed(rawData);
if (keyParsed.empty()) {
LogDebug("Key empty - failed to parse!");
- return KEY_MANAGER_API_ERROR_BAD_RESPONSE;
+ return CKM_API_ERROR_BAD_RESPONSE;
}
key = keyParsed;
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
int Manager::ManagerImpl::getCertificate(const Alias &alias, const std::string &password, Certificate &cert)
recvDataType,
rawData);
- if (retCode != KEY_MANAGER_API_SUCCESS)
+ if (retCode != CKM_API_SUCCESS)
return retCode;
if (recvDataType != DBDataType::CERTIFICATE)
- return KEY_MANAGER_API_ERROR_BAD_RESPONSE;
+ return CKM_API_ERROR_BAD_RESPONSE;
Certificate certParsed(rawData, DataFormat::FORM_DER);
if (certParsed.empty())
- return KEY_MANAGER_API_ERROR_BAD_RESPONSE;
+ return CKM_API_ERROR_BAD_RESPONSE;
cert = certParsed;
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
int Manager::ManagerImpl::getData(const Alias &alias, const std::string &password, RawBuffer &rawData)
recvDataType,
rawData);
- if (retCode != KEY_MANAGER_API_SUCCESS)
+ if (retCode != CKM_API_SUCCESS)
return retCode;
if (recvDataType != DBDataType::BINARY_DATA)
- return KEY_MANAGER_API_ERROR_BAD_RESPONSE;
+ return CKM_API_ERROR_BAD_RESPONSE;
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
int Manager::ManagerImpl::getBinaryDataAliasVector(DBDataType dataType, AliasVector &aliasVector)
send.Pop(),
recv);
- if (KEY_MANAGER_API_SUCCESS != retCode) {
+ if (CKM_API_SUCCESS != retCode) {
return retCode;
}
Deserialization::Deserialize(recv, aliasVector);
if (counter != m_counter) {
- return KEY_MANAGER_API_ERROR_UNKNOWN;
+ return CKM_API_ERROR_UNKNOWN;
}
return retCode;
send.Pop(),
recv);
- if (KEY_MANAGER_API_SUCCESS != retCode) {
+ if (CKM_API_SUCCESS != retCode) {
return retCode;
}
Deserialization::Deserialize(recv, retCode);
if (counter != my_counter) {
- return KEY_MANAGER_API_ERROR_UNKNOWN;
+ return CKM_API_ERROR_UNKNOWN;
}
return retCode;
send.Pop(),
recv);
- if (KEY_MANAGER_API_SUCCESS != retCode) {
+ if (CKM_API_SUCCESS != retCode) {
return retCode;
}
Deserialization::Deserialize(recv, retCode);
if (counter != my_counter) {
- return KEY_MANAGER_API_ERROR_UNKNOWN;
+ return CKM_API_ERROR_UNKNOWN;
}
return retCode;
<< "label already exists.");
}
m_keyMap[smackLabel] = applicationKey;
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
std::size_t DBCryptoModule::insertDigest(RawBuffer &data, const int dataSize)
crow.algorithmType = DBCMAlgType::AES_CBC_256;
row = crow;
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
int DBCryptoModule::decryptRow(const std::string &password, DBRow &row)
}
row = crow;
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
RawBuffer DBCryptoModule::generateRandIV(void)
RawBuffer CKMLogic::unlockUserKey(uid_t user, const std::string &password) {
// TODO try catch for all errors that should be supported by error code
- int retCode = KEY_MANAGER_API_SUCCESS;
+ int retCode = CKM_API_SUCCESS;
try {
if (0 == m_userDataMap.count(user) || !(m_userDataMap[user].keyProvider.isInitialized())) {
}
} catch (const KeyProvider::Exception::Base &e) {
LogError("Error in KeyProvider " << e.GetMessage());
- retCode = KEY_MANAGER_API_ERROR_SERVER_ERROR;
+ retCode = CKM_API_ERROR_SERVER_ERROR;
}
MessageBuffer response;
}
RawBuffer CKMLogic::lockUserKey(uid_t user) {
- int retCode = KEY_MANAGER_API_SUCCESS;
+ int retCode = CKM_API_SUCCESS;
// TODO try catch for all errors that should be supported by error code
m_userDataMap.erase(user);
}
RawBuffer CKMLogic::removeUserData(uid_t user) {
- int retCode = KEY_MANAGER_API_SUCCESS;
+ int retCode = CKM_API_SUCCESS;
// TODO try catch for all errors that should be supported by error code
m_userDataMap.erase(user);
const std::string &oldPassword,
const std::string &newPassword)
{
- int retCode = KEY_MANAGER_API_SUCCESS;
+ int retCode = CKM_API_SUCCESS;
// TODO try-catch
FileSystem fs(user);
auto wrappedDomainKEK = fs.getDomainKEK();
if (wrappedDomainKEK.empty()) {
- retCode = KEY_MANAGER_API_ERROR_BAD_REQUEST;
+ retCode = CKM_API_ERROR_BAD_REQUEST;
} else {
wrappedDomainKEK = KeyProvider::reencrypt(wrappedDomainKEK, oldPassword, newPassword);
fs.saveDomainKEK(wrappedDomainKEK);
uid_t user,
const std::string &newPassword)
{
- int retCode = KEY_MANAGER_API_SUCCESS;
+ int retCode = CKM_API_SUCCESS;
// TODO try-catch
if (0 == m_userDataMap.count(user)) {
- retCode = KEY_MANAGER_API_ERROR_BAD_REQUEST;
+ retCode = CKM_API_ERROR_BAD_REQUEST;
} else {
auto &handler = m_userDataMap[user];
FileSystem fs(user);
const PolicySerializable &policy)
{
if (0 == m_userDataMap.count(cred.uid))
- return KEY_MANAGER_API_ERROR_DB_LOCKED;
+ return CKM_API_ERROR_DB_LOCKED;
DBRow row = { alias, cred.smackLabel, policy.restricted,
policy.extractable, dataType, DBCMAlgType::NONE,
handler.crypto.encryptRow(policy.password, row);
handler.database.saveDBRow(row);
transaction.commit();
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
RawBuffer CKMLogic::saveData(
const RawBuffer &key,
const PolicySerializable &policy)
{
- int retCode = KEY_MANAGER_API_SUCCESS;
+ int retCode = CKM_API_SUCCESS;
try {
retCode = saveDataHelper(cred, dataType, alias, key, policy);
LogDebug("SaveDataHelper returned: " << retCode);
} catch (const KeyProvider::Exception::Base &e) {
LogError("KeyProvider failed with message: " << e.GetMessage());
- retCode = KEY_MANAGER_API_ERROR_SERVER_ERROR;
+ retCode = CKM_API_ERROR_SERVER_ERROR;
} catch (const DBCryptoModule::Exception::Base &e) {
LogError("DBCryptoModule failed with message: " << e.GetMessage());
- retCode = KEY_MANAGER_API_ERROR_SERVER_ERROR;
+ retCode = CKM_API_ERROR_SERVER_ERROR;
} catch (const DBCrypto::Exception::InternalError &e) {
LogError("DBCrypto failed with message: " << e.GetMessage());
- retCode = KEY_MANAGER_API_ERROR_DB_ERROR;
+ retCode = CKM_API_ERROR_DB_ERROR;
} catch (const DBCrypto::Exception::AliasExists &e) {
LogError("DBCrypto couldn't save duplicate alias");
- retCode = KEY_MANAGER_API_ERROR_DB_ALIAS_EXISTS;
+ retCode = CKM_API_ERROR_DB_ALIAS_EXISTS;
} catch (const DBCrypto::Exception::TransactionError &e) {
LogError("DBCrypto transaction failed with message " << e.GetMessage());
- retCode = KEY_MANAGER_API_ERROR_DB_ERROR;
+ retCode = CKM_API_ERROR_DB_ERROR;
}
MessageBuffer response;
DBDataType dataType,
const Alias &alias)
{
- int retCode = KEY_MANAGER_API_SUCCESS;
+ int retCode = CKM_API_SUCCESS;
if (0 < m_userDataMap.count(cred.uid)) {
Try {
m_userDataMap[cred.uid].database.deleteDBRow(alias, cred.smackLabel);
} Catch (CKM::Exception) {
LogError("Error in deleting row!");
- retCode = KEY_MANAGER_API_ERROR_DB_ERROR;
+ retCode = CKM_API_ERROR_DB_ERROR;
}
} else {
- retCode = KEY_MANAGER_API_ERROR_DB_LOCKED;
+ retCode = CKM_API_ERROR_DB_LOCKED;
}
MessageBuffer response;
{
if (0 == m_userDataMap.count(cred.uid))
- return KEY_MANAGER_API_ERROR_DB_LOCKED;
+ return CKM_API_ERROR_DB_LOCKED;
auto &handler = m_userDataMap[cred.uid];
row_optional = handler.database.getKeyDBRow(alias, cred.smackLabel);
} else {
LogError("Unknown type of requested data" << (int)dataType);
- return KEY_MANAGER_API_ERROR_BAD_REQUEST;
+ return CKM_API_ERROR_BAD_REQUEST;
}
if(!row_optional) {
LogError("No row for given alias, label and type");
- return KEY_MANAGER_API_ERROR_DB_ALIAS_UNKNOWN;
+ return CKM_API_ERROR_DB_ALIAS_UNKNOWN;
} else {
row = *row_optional;
}
auto key_optional = handler.database.getKey(row.smackLabel);
if(!key_optional) {
LogError("No key for given label in database");
- return KEY_MANAGER_API_ERROR_DB_ERROR;
+ return CKM_API_ERROR_DB_ERROR;
}
key = *key_optional;
key = handler.keyProvider.getPureDEK(key);
LogError("Datatype: " << (int) row.dataType);
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
RawBuffer CKMLogic::getData(
const Alias &alias,
const std::string &password)
{
- int retCode = KEY_MANAGER_API_SUCCESS;
+ int retCode = CKM_API_SUCCESS;
DBRow row;
try {
retCode = getDataHelper(cred, dataType, alias, password, row);
} catch (const KeyProvider::Exception::Base &e) {
LogError("KeyProvider failed with error: " << e.GetMessage());
- retCode = KEY_MANAGER_API_ERROR_SERVER_ERROR;
+ retCode = CKM_API_ERROR_SERVER_ERROR;
} catch (const DBCryptoModule::Exception::Base &e) {
LogError("DBCryptoModule failed with message: " << e.GetMessage());
- retCode = KEY_MANAGER_API_ERROR_SERVER_ERROR;
+ retCode = CKM_API_ERROR_SERVER_ERROR;
} catch (const DBCrypto::Exception::Base &e) {
LogError("DBCrypto failed with message: " << e.GetMessage());
- retCode = KEY_MANAGER_API_ERROR_DB_ERROR;
+ retCode = CKM_API_ERROR_DB_ERROR;
}
- if (KEY_MANAGER_API_SUCCESS != retCode) {
+ if (CKM_API_SUCCESS != retCode) {
row.data.clear();
row.dataType = dataType;
}
int commandId,
DBDataType dataType)
{
- int retCode = KEY_MANAGER_API_SUCCESS;
+ int retCode = CKM_API_SUCCESS;
AliasVector aliasVector;
if (0 < m_userDataMap.count(cred.uid)) {
}
} Catch (CKM::Exception) {
LogError("Failed to get aliases");
- retCode = KEY_MANAGER_API_ERROR_DB_ERROR;
+ retCode = CKM_API_ERROR_DB_ERROR;
}
} else {
- retCode = KEY_MANAGER_API_ERROR_DB_LOCKED;
+ retCode = CKM_API_ERROR_DB_LOCKED;
}
MessageBuffer response;
const PolicySerializable &policyPublic)
{
if (0 >= m_userDataMap.count(cred.uid))
- return KEY_MANAGER_API_ERROR_DB_LOCKED;
+ return CKM_API_ERROR_DB_LOCKED;
auto &handler = m_userDataMap[cred.uid];
GenericKey prv, pub;
(retCode = CryptoService::createKeyPairRSA(size, prv, pub)))
{
LogDebug("CryptoService error with code: " << retCode);
- return KEY_MANAGER_API_ERROR_SERVER_ERROR; // TODO error code
+ return CKM_API_ERROR_SERVER_ERROR; // TODO error code
}
DBCrypto::Transaction transaction(&handler.database);
prv.getDER(),
policyPrivate);
- if (KEY_MANAGER_API_SUCCESS != retCode)
+ if (CKM_API_SUCCESS != retCode)
return retCode;
retCode = saveDataHelper(cred,
pub.getDER(),
policyPublic);
- if (KEY_MANAGER_API_SUCCESS != retCode)
+ if (CKM_API_SUCCESS != retCode)
return retCode;
transaction.commit();
const PolicySerializable &policyPrivate,
const PolicySerializable &policyPublic)
{
- int retCode = KEY_MANAGER_API_SUCCESS;
+ int retCode = CKM_API_SUCCESS;
try {
retCode = createKeyPairRSAHelper(
retCode = CKM_API_ERROR_DB_ERROR;
} catch (DBCrypto::Exception::InternalError &e) {
LogDebug("DBCrypto internal error: " << e.GetMessage());
- retCode = KEY_MANAGER_API_ERROR_DB_ERROR;
+ retCode = CKM_API_ERROR_DB_ERROR;
}
MessageBuffer response;
const PolicySerializable &policyPublic)
{
if (0 >= m_userDataMap.count(cred.uid))
- return KEY_MANAGER_API_ERROR_DB_LOCKED;
+ return CKM_API_ERROR_DB_LOCKED;
auto &handler = m_userDataMap[cred.uid];
GenericKey prv, pub;
(retCode = CryptoService::createKeyPairECDSA(static_cast<ElipticCurve>(type), prv, pub)))
{
LogError("CryptoService failed with code: " << retCode);
- return KEY_MANAGER_API_ERROR_SERVER_ERROR; // TODO error code
+ return CKM_API_ERROR_SERVER_ERROR; // TODO error code
}
DBCrypto::Transaction transaction(&handler.database);
prv.getDER(),
policyPrivate);
- if (KEY_MANAGER_API_SUCCESS != retCode)
+ if (CKM_API_SUCCESS != retCode)
return retCode;
retCode = saveDataHelper(cred,
pub.getDER(),
policyPublic);
- if (KEY_MANAGER_API_SUCCESS != retCode)
+ if (CKM_API_SUCCESS != retCode)
return retCode;
transaction.commit();
const PolicySerializable &policyPrivate,
const PolicySerializable &policyPublic)
{
- int retCode = KEY_MANAGER_API_SUCCESS;
+ int retCode = CKM_API_SUCCESS;
try {
retCode = createKeyPairECDSAHelper(
retCode = CKM_API_ERROR_DB_ERROR;
} catch (const DBCrypto::Exception::InternalError &e) {
LogDebug("DBCrypto internal error: " << e.GetMessage());
- retCode = KEY_MANAGER_API_ERROR_DB_ERROR;
+ retCode = CKM_API_ERROR_DB_ERROR;
}
MessageBuffer response;