INCLUDE_DIRECTORIES(
${KEY_MANAGER_PATH}/client
+ ${KEY_MANAGER_PATH}/client-capi
${KEY_MANAGER_PATH}/common
${KEY_MANAGER_PATH}/dpl/core/include
${KEY_MANAGER_PATH}/dpl/log/include
#ifndef __TIZEN_CORE_CKMC_ERROR_H_
#define __TIZEN_CORE_CKMC_ERROR_H_
+#include <tizen.h>
+
#ifdef __cplusplus
extern "C" {
#endif
* @{
*/
-/**
- * @brief Indicates the result of the one specific API is successful
- * @since_tizen 2.3
- */
-#define CKMC_SUCCESS 0
-/**
- * @brief Indicates the socket between client and Central Key Manager failed
- * @since_tizen 2.3
- */
-#define CKMC_ERROR_SOCKET -1
+#define KEY_MANAGER_ERROR_CLASS 0x0FFF0000
-/**
- * @brief Indicates the request from client is malformed
- * @since_tizen 2.3
- */
-#define CKMC_ERROR_BAD_REQUEST -2
/**
- * @brief Indicates the response from Central Key Manager is malformed
+ * @brief Enumeration for Key Manager Errors.
* @since_tizen 2.3
*/
-#define CKMC_ERROR_BAD_RESPONSE -3
+typedef enum{
+ CKMC_SUCCESS = TIZEN_ERROR_NONE, /**< Successful */
+ CKMC_ERROR_INPUT_PARAM = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid function parameter */
+ CKMC_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */
+ CKMC_ERROR_ACCESS_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */
+ CKMC_ERROR_BAD_REQUEST = TIZEN_ERROR_INVALID_OPERATION, /**< Invalid request from client */
-/**
- * @brief Indicates the transmitting request failed.
- * @since_tizen 2.3
- */
-#define CKMC_ERROR_SEND_FAILED -4
-
-/**
- * @brief Indicates the receiving response failed.
- * @since_tizen 2.3
- */
-#define CKMC_ERROR_RECV_FAILED -5
-
-/**
- * @brief Indicates the authentication between client and manager failed.
- * @since_tizen 2.3
- */
-#define CKMC_ERROR_AUTHENTICATION_FAILED -6
-
-/**
- * @brief Indicates the API's input parameter is malformed
- * @since_tizen 2.3
- */
-#define CKMC_ERROR_INPUT_PARAM -7
-
-/**
- * @brief Indicates the output buffer size which is passed as parameter is too small
- * @since_tizen 2.3
- */
-#define CKMC_ERROR_BUFFER_TOO_SMALL -8
-
-/**
- * @brief Indicates system is running out of memory state
- * @since_tizen 2.3
- */
-#define CKMC_ERROR_OUT_OF_MEMORY -9
-
-/**
- * @brief Indicates the access has been denied by Central Key Manager
- * @since_tizen 2.3
- */
-#define CKMC_ERROR_ACCESS_DENIED -10
-
-/**
- * @brief Indicates Central Key Manager has been failed for some reason
- * @since_tizen 2.3
- */
-#define CKMC_ERROR_SERVER_ERROR -11
-
-/**
- * @brief Indicates the database was not unlocked - user did not login
- * @since_tizen 2.3
- */
-#define CKMC_ERROR_DB_LOCKED -12
-
-/**
- * @brief Indicates an internal error inside the database
- * @since_tizen 2.3
- */
-#define CKMC_ERROR_DB_ERROR -13
-
-/**
- * @brief Indicates that provided alias already exists in the database
- * @since_tizen 2.3
- */
-#define CKMC_ERROR_DB_ALIAS_EXISTS -14
-
-/**
- * @brief Indicates that request given to database returned no result
- * @since_tizen 2.3
- */
-#define CKMC_ERROR_DB_ALIAS_UNKNOWN -15
-
-/**
- * @brief Indicates that CA certificate(s) were unknown and chain could not be created
- * @since_tizen 2.3
- */
-#define CKMC_ERROR_VERIFICATION_FAILED -16
-
-/**
- * @brief Indicates that a provided file or binary has not a valid format
- * @since_tizen 2.3
- */
-#define CKMC_ERROR_INVALID_FORMAT -17
-
-/**
- * @brief Indicates that provided file doesn't exists or cannot be accessed in the file system
- * @since_tizen 2.3
- */
-#define CKMC_ERROR_FILE_ACCESS_DENIED -18
-
-/**
- * @brief Indicates the error with unknown reason
- * @since_tizen 2.3
- */
-#define CKMC_ERROR_UNKNOWN -255
+ CKMC_ERROR_SOCKET = KEY_MANAGER_ERROR_CLASS | 0x01, /**< Socket error between client and Central Key Manager */
+ CKMC_ERROR_BAD_RESPONSE = KEY_MANAGER_ERROR_CLASS | 0x02, /**< Invalid response from Central Key Manager */
+ CKMC_ERROR_SEND_FAILED = KEY_MANAGER_ERROR_CLASS | 0x03, /**< Transmitting request failed */
+ CKMC_ERROR_RECV_FAILED = KEY_MANAGER_ERROR_CLASS | 0x04, /**< Receiving response failed */
+ CKMC_ERROR_AUTHENTICATION_FAILED = KEY_MANAGER_ERROR_CLASS | 0x05, /**< Authentication between client and manager failed */
+ CKMC_ERROR_BUFFER_TOO_SMALL = KEY_MANAGER_ERROR_CLASS | 0x06, /**< The output buffer size which is passed as parameter is too small */
+ CKMC_ERROR_SERVER_ERROR = KEY_MANAGER_ERROR_CLASS | 0x07, /**< Central Key Manager has been failed for some reason */
+ CKMC_ERROR_DB_LOCKED = KEY_MANAGER_ERROR_CLASS | 0x08, /**< The database was not unlocked - user did not login */
+ CKMC_ERROR_DB_ERROR = KEY_MANAGER_ERROR_CLASS | 0x09, /**< An internal error inside the database */
+ CKMC_ERROR_DB_ALIAS_EXISTS = KEY_MANAGER_ERROR_CLASS | 0x0A, /**< Provided alias already exists in the database */
+ CKMC_ERROR_DB_ALIAS_UNKNOWN = KEY_MANAGER_ERROR_CLASS | 0x0B, /**< No data for given alias */
+ CKMC_ERROR_VERIFICATION_FAILED = KEY_MANAGER_ERROR_CLASS | 0x0C, /**< CA certificate(s) were unknown and chain could not be created */
+ CKMC_ERROR_INVALID_FORMAT = KEY_MANAGER_ERROR_CLASS | 0x11, /**< A provided file or binary has not a valid format */
+ CKMC_ERROR_FILE_ACCESS_DENIED = KEY_MANAGER_ERROR_CLASS | 0x12, /**< A provided file or binary has not a valid format */
+ CKMC_ERROR_UNKNOWN = KEY_MANAGER_ERROR_CLASS | 0x13, /**< A provided file or binary has not a valid format */
+} key_manager_error_e;
/**
#include <ckm/ckm-control.h>
#include <ckmc/ckmc-control.h>
#include <ckmc/ckmc-error.h>
+#include <ckmc-type-converter.h>
KEY_MANAGER_CAPI
int ckmc_unlock_user_key(uid_t user, const char *password)
{
auto control = CKM::Control::create();
- return control->unlockUserKey(user, std::string(password));
+ int ret = control->unlockUserKey(user, std::string(password));
+ return to_ckmc_error(ret);
}
KEY_MANAGER_CAPI
int ckmc_lock_user_key(uid_t user)
{
auto control = CKM::Control::create();
- return control->lockUserKey(user);
+ int ret = control->lockUserKey(user);
+ return to_ckmc_error(ret);
}
KEY_MANAGER_CAPI
int ckmc_remove_user_data(uid_t user)
{
auto control = CKM::Control::create();
- return control->removeUserData(user);
+ int ret = control->removeUserData(user);
+ return to_ckmc_error(ret);
}
KEY_MANAGER_CAPI
int ckmc_change_user_password(uid_t user, const char *oldPassword, const char *newPassword)
{
auto control = CKM::Control::create();
- return control->changeUserPassword(user, std::string(oldPassword), std::string(newPassword));
+ int ret = control->changeUserPassword(user, std::string(oldPassword), std::string(newPassword));
+ return to_ckmc_error(ret);
}
KEY_MANAGER_CAPI
int ckmc_reset_user_password(uid_t user, const char *newPassword)
{
auto control = CKM::Control::create();
- return control->resetUserPassword(user, std::string(newPassword));
+ int ret = control->resetUserPassword(user, std::string(newPassword));
+ return to_ckmc_error(ret);
}
#include <ckmc/ckmc-type.h>
#include <ckmc/ckmc-manager.h>
#include <ckmc/ckmc-error.h>
+#include <ckmc-type-converter.h>
#include <iostream>
#include <string.h>
CKM::Policy storePolicy(_tostring(policy.password), policy.extractable, policy.restricted);
- return mgr->saveKey(ckmAlias, ckmKey, storePolicy);
+ int ret = mgr->saveKey(ckmAlias, ckmKey, storePolicy);
+ return to_ckmc_error(ret);
}
}
CKM::Alias ckmAlias(alias);
- return mgr->removeKey(ckmAlias);
+ int ret = mgr->removeKey(ckmAlias);
+ return to_ckmc_error(ret);
}
KEY_MANAGER_CAPI
CKM::Alias ckmAlias(alias);
CKM::ManagerShPtr mgr = CKM::Manager::create();
- if( (ret = mgr->getKey(ckmAlias, _tostring(password), ckmKey)) != CKMC_SUCCESS) {
- return ret;
+ if( (ret = mgr->getKey(ckmAlias, _tostring(password), ckmKey)) != CKM_API_SUCCESS) {
+ return to_ckmc_error(ret);
}
unsigned char *rawKey = reinterpret_cast<unsigned char*>(ckmKey->getDER().data());
ret = ckmc_key_new( rawKey, ckmKey->getDER().size(), keyType, NULL, key);
- return ret;
+ return to_ckmc_error(ret);
}
KEY_MANAGER_CAPI
CKM::AliasVector aliasVector;
CKM::ManagerShPtr mgr = CKM::Manager::create();
- if( (ret = mgr->getKeyAliasVector(aliasVector)) != CKMC_SUCCESS) {
- return ret;
+ if( (ret = mgr->getKeyAliasVector(aliasVector)) != CKM_API_SUCCESS) {
+ return to_ckmc_error(ret);
}
ckmc_alias_list_s *plist = NULL;
CKM::Policy storePolicy(_tostring(policy.password), policy.extractable, policy.restricted);
CKM::ManagerShPtr mgr = CKM::Manager::create();
- return mgr->saveCertificate(ckmAlias, ckmCert, storePolicy);
+ int ret = mgr->saveCertificate(ckmAlias, ckmCert, storePolicy);
+
+ return to_ckmc_error(ret);
}
KEY_MANAGER_CAPI
CKM::Alias ckmAlias(alias);
CKM::ManagerShPtr mgr = CKM::Manager::create();
- return mgr->removeCertificate(ckmAlias);
+ int ret = mgr->removeCertificate(ckmAlias);
+
+ return to_ckmc_error(ret);
}
KEY_MANAGER_CAPI
CKM::Alias ckmAlias(alias);
CKM::ManagerShPtr mgr = CKM::Manager::create();
- if( (ret = mgr->getCertificate(ckmAlias, _tostring(password), ckmCert)) != CKMC_SUCCESS) {
- return ret;
+ if( (ret = mgr->getCertificate(ckmAlias, _tostring(password), ckmCert)) != CKM_API_SUCCESS) {
+ return to_ckmc_error(ret);
}
unsigned char *rawCert = reinterpret_cast<unsigned char*>(ckmCert->getDER().data());
CKM::AliasVector aliasVector;
CKM::ManagerShPtr mgr = CKM::Manager::create();
- if( (ret = mgr->getCertificateAliasVector(aliasVector)) != CKMC_SUCCESS) {
- return ret;
+ if( (ret = mgr->getCertificateAliasVector(aliasVector)) != CKM_API_SUCCESS) {
+ return to_ckmc_error(ret);
}
ckmc_alias_list_s *plist = NULL;
CKM::Policy storePolicy(_tostring(policy.password), policy.extractable, policy.restricted);
CKM::ManagerShPtr mgr = CKM::Manager::create();
- return mgr->saveData(ckmAlias, buffer, storePolicy);
+ int ret = mgr->saveData(ckmAlias, buffer, storePolicy);
+
+ return to_ckmc_error(ret);
}
KEY_MANAGER_CAPI
CKM::Alias ckmAlias(alias);
CKM::ManagerShPtr mgr = CKM::Manager::create();
- return mgr->removeData(ckmAlias);
+ int ret = mgr->removeData(ckmAlias);
+ return to_ckmc_error(ret);
}
KEY_MANAGER_CAPI
CKM::Alias ckmAlias(alias);
CKM::ManagerShPtr mgr = CKM::Manager::create();
- if( (ret = mgr->getData(ckmAlias, _tostring(password), ckmBuff)) != CKMC_SUCCESS) {
- return ret;
+ if( (ret = mgr->getData(ckmAlias, _tostring(password), ckmBuff)) != CKM_API_SUCCESS) {
+ return to_ckmc_error(ret);
}
unsigned char *rawBuff = reinterpret_cast<unsigned char*>(ckmBuff.data());
CKM::AliasVector aliasVector;
CKM::ManagerShPtr mgr = CKM::Manager::create();
- if( (ret = mgr->getDataAliasVector(aliasVector)) != CKMC_SUCCESS) {
- return ret;
+ if( (ret = mgr->getDataAliasVector(aliasVector)) != CKM_API_SUCCESS) {
+ return to_ckmc_error(ret);
}
ckmc_alias_list_s *plist = NULL;
CKM::Policy ckmPrivateKeyPolicy(_tostring(policy_private_key.password), policy_private_key.extractable, policy_private_key.restricted);
CKM::Policy ckmPublicKeyPolicy(_tostring(policy_public_key.password), policy_public_key.extractable, policy_public_key.restricted);
- if( (ret = mgr->createKeyPairRSA(size, ckmPrivakeKeyAlias, ckmPublicKeyAlias, ckmPrivateKeyPolicy, ckmPublicKeyPolicy))
- != CKMC_SUCCESS) {
- return ret;
- }
-
- return CKMC_SUCCESS;
+ ret = mgr->createKeyPairRSA(size, ckmPrivakeKeyAlias, ckmPublicKeyAlias, ckmPrivateKeyPolicy, ckmPublicKeyPolicy);
+ return to_ckmc_error(ret);
}
KEY_MANAGER_CAPI
CKM::Policy ckmPrivateKeyPolicy(_tostring(policy_private_key.password), policy_private_key.extractable, policy_private_key.restricted);
CKM::Policy ckmPublicKeyPolicy(_tostring(policy_public_key.password), policy_public_key.extractable, policy_public_key.restricted);
- return mgr->createKeyPairECDSA(ckmType, ckmPrivakeKeyAlias, ckmPublicKeyAlias, ckmPrivateKeyPolicy, ckmPublicKeyPolicy);
+ int ret = mgr->createKeyPairECDSA(ckmType, ckmPrivakeKeyAlias, ckmPublicKeyAlias, ckmPrivateKeyPolicy, ckmPublicKeyPolicy);
+ return to_ckmc_error(ret);
}
KEY_MANAGER_CAPI
ckmMessage,
ckmHashAlgo,
ckmPadding,
- ckmSignature)) != CKMC_SUCCESS) {
- return ret;
+ ckmSignature)) != CKM_API_SUCCESS) {
+ return to_ckmc_error(ret);
}
unsigned char *rawBuff = reinterpret_cast<unsigned char*>(ckmSignature.data());
ckmMessage,
ckmSignature,
ckmHashAlgo,
- ckmPadding)) != CKMC_SUCCESS) {
- return ret;
+ ckmPadding)) != CKM_API_SUCCESS) {
+ return to_ckmc_error(ret);
}
return CKMC_SUCCESS;
}
ret = mgr->getCertificateChain(ckmCert, ckmUntrustedCerts, ckmCertChain);
- if( ret != CKMC_SUCCESS) {
- return ret;
+ if( ret != CKM_API_SUCCESS) {
+ return to_ckmc_error(ret);
}
*cert_chain_list = _toNewCkmCertList(ckmCertChain);
}while(next != NULL);
}
- if( (ret = mgr->getCertificateChain(ckmCert, ckmUntrustedAliases, ckmCertChain)) != CKMC_SUCCESS) {
- return ret;
+ if( (ret = mgr->getCertificateChain(ckmCert, ckmUntrustedAliases, ckmCertChain)) != CKM_API_SUCCESS) {
+ return to_ckmc_error(ret);
}
*cert_chain_list = _toNewCkmCertList(ckmCertChain);
--- /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 ckmc-type-converter.h
+ * @author Dongsun Lee(ds73.lee@samsung.com)
+ * @version 1.0
+ * @brief new and free methods for the struct of CAPI
+ */
+
+#ifndef CKMC_TYPE_CONVERTER_H_
+#define CKMC_TYPE_CONVERTER_H_
+
+#include <ckm/ckm-error.h>
+#include <ckmc/ckmc-error.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int to_ckmc_error(int ckm_error);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CKMC_TYPE_CONVERTER_H_ */
#include <ckm/ckm-type.h>
#include <ckmc/ckmc-type.h>
#include <ckmc/ckmc-error.h>
+#include <ckmc-type-converter.h>
#include <openssl/x509v3.h>
#include <openssl/pkcs12.h>
#include <openssl/evp.h>
return ckmc_cert_new(output.data(), output.size(), CKMC_FORM_DER, cert);
}
+
+int to_ckmc_error(int ckm_error) {
+ switch(ckm_error) {
+ case CKM_API_SUCCESS: return CKMC_SUCCESS;
+ case CKM_API_ERROR_SOCKET: return CKMC_ERROR_SOCKET;
+ case CKM_API_ERROR_BAD_REQUEST: return CKMC_ERROR_BAD_REQUEST;
+ case CKM_API_ERROR_BAD_RESPONSE: return CKMC_ERROR_BAD_RESPONSE;
+ case CKM_API_ERROR_SEND_FAILED: return CKMC_ERROR_SEND_FAILED;
+ case CKM_API_ERROR_RECV_FAILED: return CKMC_ERROR_RECV_FAILED;
+ case CKM_API_ERROR_AUTHENTICATION_FAILED: return CKMC_ERROR_AUTHENTICATION_FAILED;
+ case CKM_API_ERROR_INPUT_PARAM: return CKMC_ERROR_INPUT_PARAM;
+ case CKM_API_ERROR_BUFFER_TOO_SMALL: return CKMC_ERROR_BUFFER_TOO_SMALL;
+ case CKM_API_ERROR_OUT_OF_MEMORY: return CKMC_ERROR_OUT_OF_MEMORY;
+ case CKM_API_ERROR_ACCESS_DENIED: return CKMC_ERROR_ACCESS_DENIED;
+ case CKM_API_ERROR_SERVER_ERROR: return CKMC_ERROR_SERVER_ERROR;
+ case CKM_API_ERROR_DB_LOCKED: return CKMC_ERROR_DB_LOCKED;
+ case CKM_API_ERROR_DB_ERROR: return CKMC_ERROR_DB_ERROR;
+ case CKM_API_ERROR_DB_ALIAS_EXISTS: return CKMC_ERROR_DB_ALIAS_EXISTS;
+ case CKM_API_ERROR_DB_ALIAS_UNKNOWN: return CKMC_ERROR_DB_ALIAS_UNKNOWN;
+ case CKM_API_ERROR_VERIFICATION_FAILED: return CKMC_ERROR_VERIFICATION_FAILED;
+ case CKM_API_ERROR_INVALID_FORMAT: return CKMC_ERROR_INVALID_FORMAT;
+ case CKM_API_ERROR_FILE_ACCESS_DENIED: return CKMC_ERROR_FILE_ACCESS_DENIED;
+ case CKM_API_ERROR_UNKNOWN: return CKMC_ERROR_UNKNOWN;
+ }
+ return CKMC_ERROR_UNKNOWN;
+}
projects / platform / core / security / key-manager.git / commitdiff