/*! \brief indicating that CA certificate(s) were unknown and chain could not be created */
#define CKM_API_ERROR_VERIFICATION_FAILED -16
+/*! \brief indicating that a provided file or binary has not a valid format */
+#define CKM_API_ERROR_INVALID_FORMAT -17
+
+/*! \brief indicating that provided file doesn't exists or cannot be accessed in the file system */
+#define CKM_API_ERROR_FILE_ACCESS_DENIED -18
+
/*! \brief indicating the error with unknown reason */
#define CKM_API_ERROR_UNKNOWN -255
/** @}*/
* limitations under the License
*
* @file ckmc-error.h
- * @author Bartlomiej Grzelewski (b.grzelewski@samsung.com)
+ * @author Yuseok Jeon(yuseok.jeon@samsung.com)
* @version 1.0
* @brief This file is implementation of client-common functions.
*/
#ifndef CKMC_ERROR_H
#define CKMC_ERROR_H
-#include <sys/types.h>
-
-/**
- * \name Return Codes
- * exported by the foundation API.
- * result codes begin with the start error code and extend into negative direction.
- * @{
-*/
-#define KEY_MANAGER_API_SUCCESS 0
-/*! \brief indicating the result of the one specific API is successful */
-#define KEY_MANAGER_API_ERROR_SOCKET -1
-
-/*! \brief indicating the socket between client and Central Key Manager failed */
-#define KEY_MANAGER_API_ERROR_BAD_REQUEST -2
-
-/*! \brief indicating the response from Central Key Manager is malformed */
-#define KEY_MANAGER_API_ERROR_BAD_RESPONSE -3
-
-/*! \brief indicating the transmitting request failed */
-/* deprecated unused */
-#define KEY_MANAGER_API_ERROR_SEND_FAILED -4
-
-/*! \brief indicating the receiving response failed */
-/* deprecated unused */
-#define KEY_MANAGER_API_ERROR_RECV_FAILED -5
-
-/*! \brief indicating the authentication between client and manager failed */
-#define KEY_MANAGER_API_ERROR_AUTHENTICATION_FAILED -6
-
-/*! \brief indicating the API's input parameter is malformed */
-#define KEY_MANAGER_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
-
-/*! \brief indicating system is running out of memory state */
-#define KEY_MANAGER_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
-
-/*! \brief indicating Central Key Manager has been failed for some reason */
-#define KEY_MANAGER_API_ERROR_SERVER_ERROR -11
-
-/*! \brief indicating the database was not unlocked - user did not login */
-#define KEY_MANAGER_API_ERROR_DB_LOCKED -12
-
-/*! \brief indicating that request give to database returned no result */
-#define KEY_MANAGER_API_ERROR_DB_BAD_REQUEST -13
-
-/*! \brief indicating an internal error inside the database */
-#define KEY_MANAGER_API_ERROR_DB_ERROR -14
-
-/*! \brief indicating that provided alias already exists in the database */
-#define KEY_MANAGER_API_ERROR_DB_ALIAS_EXISTS -15
-
-/*! \brief indicating that provided file doesn't exists or cannot be accessed in the file system */
-#define KEY_MANAGER_API_ERROR_FILE_ACCESS_DENIED -16
-
-/*! \brief indicating that a provided file or binary has not a valid format */
-#define KEY_MANAGER_API_ERROR_INVALID_FORMAT -17
-
-
-/*! \brief indicating the error with unknown reason */
-#define KEY_MANAGER_API_ERROR_UNKNOWN -255
-/** @}*/
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-const char * ckm_error_to_string(int error);
-
-
-#ifdef __cplusplus
-}
-#endif
-
-/**
- * @}
-*/
-
-/**
- * @}
-*/
+#include <ckm/ckm-error.h>
#endif /* CKMC_ERROR_H */
*/
#include <ckmc/ckmc-error.h>
-#include <ckm/ckm-error.h>
+#include <ckm/ckm-type.h>
const char * ckm_error_to_string(int error) {
return CKM::ErrorToString(error);
CKM::Manager mgr;
if(alias == NULL) {
- return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+ return CKM_API_ERROR_INPUT_PARAM;
}
CKM::Alias ckmAlias(alias);
if(key.raw_key == NULL || key.key_size <= 0) {
- return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+ return CKM_API_ERROR_INPUT_PARAM;
}
CKM::RawBuffer buffer(key.raw_key, key.raw_key + key.key_size);
std::string password(key.password);
CKM::Manager mgr;
if(alias == NULL) {
- return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+ return CKM_API_ERROR_INPUT_PARAM;
}
CKM::Alias ckmAlias(alias);
CKM::Key ckmKey;
if(alias == NULL) {
- return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+ return CKM_API_ERROR_INPUT_PARAM;
}
CKM::Alias ckmAlias(alias);
CKM::Manager mgr;
- if( (ret = mgr.getKey(ckmAlias, std::string(password), ckmKey)) != KEY_MANAGER_API_SUCCESS) {
+ if( (ret = mgr.getKey(ckmAlias, std::string(password), ckmKey)) != CKM_API_SUCCESS) {
return ret;
}
ckm_key_type keyType = static_cast<ckm_key_type>(static_cast<int>(ckmKey.getType()));
*key = ckm_key_new( rawKey, ckmKey.getDER().size(), keyType, NULL);
if(*key == NULL) {
- return KEY_MANAGER_API_ERROR_OUT_OF_MEMORY;
+ return CKM_API_ERROR_OUT_OF_MEMORY;
}else {
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
}
CKM::AliasVector aliasVector;
CKM::Manager mgr;
- if( (ret = mgr.getKeyAliasVector(aliasVector)) != KEY_MANAGER_API_SUCCESS) {
+ if( (ret = mgr.getKeyAliasVector(aliasVector)) != CKM_API_SUCCESS) {
return ret;
}
}
}
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
KEY_MANAGER_CAPI
int ckm_save_cert(const char *alias, const ckm_cert cert, const ckm_policy policy)
{
if(alias == NULL) {
- return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+ return CKM_API_ERROR_INPUT_PARAM;
}
CKM::Alias ckmAlias(alias);
if(cert.raw_cert == NULL || cert.cert_size <= 0) {
- return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+ return CKM_API_ERROR_INPUT_PARAM;
}
CKM::Certificate ckmCert = _toCkmCertificate(&cert);
int ckm_remove_cert(const char *alias)
{
if(alias == NULL) {
- return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+ return CKM_API_ERROR_INPUT_PARAM;
}
CKM::Alias ckmAlias(alias);
int ret;
if(alias == NULL) {
- return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+ return CKM_API_ERROR_INPUT_PARAM;
}
CKM::Alias ckmAlias(alias);
CKM::Manager mgr;
- if( (ret = mgr.getCertificate(ckmAlias, std::string(password), ckmCert)) != KEY_MANAGER_API_SUCCESS) {
+ if( (ret = mgr.getCertificate(ckmAlias, std::string(password), ckmCert)) != CKM_API_SUCCESS) {
return ret;
}
unsigned char *rawCert = reinterpret_cast<unsigned char*>(ckmCert.getDER().data());
*cert = ckm_cert_new( rawCert, ckmCert.getDER().size(), CKM_CERT_FORM_DER);
if(*cert == NULL) {
- return KEY_MANAGER_API_ERROR_OUT_OF_MEMORY;
+ return CKM_API_ERROR_OUT_OF_MEMORY;
}else {
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
}
CKM::AliasVector aliasVector;
CKM::Manager mgr;
- if( (ret = mgr.getCertificateAliasVector(aliasVector)) != KEY_MANAGER_API_SUCCESS) {
+ if( (ret = mgr.getCertificateAliasVector(aliasVector)) != CKM_API_SUCCESS) {
return ret;
}
}
}
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
KEY_MANAGER_CAPI
int ckm_save_data(const char *alias, ckm_raw_buffer data, const ckm_policy policy)
{
if(alias == NULL) {
- return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+ return CKM_API_ERROR_INPUT_PARAM;
}
CKM::Alias ckmAlias(alias);
if(data.data == NULL || data.size <= 0) {
- return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+ return CKM_API_ERROR_INPUT_PARAM;
}
CKM::RawBuffer buffer(data.data, data.data + data.size);
int ckm_remove_data(const char *alias)
{
if(alias == NULL) {
- return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+ return CKM_API_ERROR_INPUT_PARAM;
}
CKM::Alias ckmAlias(alias);
int ret;
if(alias == NULL) {
- return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+ return CKM_API_ERROR_INPUT_PARAM;
}
CKM::Alias ckmAlias(alias);
CKM::Manager mgr;
- if( (ret = mgr.getData(ckmAlias, std::string(password), ckmBuff)) != KEY_MANAGER_API_SUCCESS) {
+ if( (ret = mgr.getData(ckmAlias, std::string(password), ckmBuff)) != CKM_API_SUCCESS) {
return ret;
}
unsigned char *rawBuff = reinterpret_cast<unsigned char*>(ckmBuff.data());
*data = ckm_buffer_new( rawBuff, ckmBuff.size());
if(*data == NULL) {
- return KEY_MANAGER_API_ERROR_OUT_OF_MEMORY;
+ return CKM_API_ERROR_OUT_OF_MEMORY;
}else {
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
}
CKM::AliasVector aliasVector;
CKM::Manager mgr;
- if( (ret = mgr.getDataAliasVector(aliasVector)) != KEY_MANAGER_API_SUCCESS) {
+ if( (ret = mgr.getDataAliasVector(aliasVector)) != CKM_API_SUCCESS) {
return ret;
}
}
}
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
KEY_MANAGER_CAPI
CKM::Policy ckmPublicKeyPolicy(policy_public_key.password, _toBool(policy_public_key.extractable), _toBool(policy_public_key.restricted));
if( (mgr.createKeyPairRSA(size, ckmPrivakeKeyAlias, ckmPublicKeyAlias, ckmPrivateKeyPolicy, ckmPublicKeyPolicy))
- != KEY_MANAGER_API_SUCCESS) {
+ != CKM_API_SUCCESS) {
return ret;
}
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
KEY_MANAGER_CAPI
CKM::Policy ckmPublicKeyPolicy(policy_public_key.password, _toBool(policy_public_key.extractable), _toBool(policy_public_key.restricted));
if( (mgr.createKeyPairECDSA(ckmType, ckmPrivakeKeyAlias, ckmPublicKeyAlias, ckmPrivateKeyPolicy, ckmPublicKeyPolicy))
- != KEY_MANAGER_API_SUCCESS) {
+ != CKM_API_SUCCESS) {
return ret;
}
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
KEY_MANAGER_CAPI
ckmMessage,
ckmHashAlgo,
ckmPadding,
- ckmSignature)) != KEY_MANAGER_API_SUCCESS) {
+ ckmSignature)) != CKM_API_SUCCESS) {
return ret;
}
unsigned char *rawBuff = reinterpret_cast<unsigned char*>(ckmSignature.data());
*signature = ckm_buffer_new( rawBuff, ckmSignature.size());
if(*signature == NULL) {
- return KEY_MANAGER_API_ERROR_OUT_OF_MEMORY;
+ return CKM_API_ERROR_OUT_OF_MEMORY;
}else {
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
KEY_MANAGER_CAPI
ckmMessage,
ckmSignature,
ckmHashAlgo,
- ckmPadding)) != KEY_MANAGER_API_SUCCESS) {
+ ckmPadding)) != CKM_API_SUCCESS) {
return ret;
}
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
KEY_MANAGER_CAPI
if(cert->raw_cert == NULL || cert->cert_size <= 0) {
- return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+ return CKM_API_ERROR_INPUT_PARAM;
}
CKM::RawBuffer buffer(cert->raw_cert, cert->raw_cert + cert->cert_size);
CKM::DataFormat dataFormat = static_cast<CKM::DataFormat>(static_cast<int>(cert->data_format));
next = current->next;
if(current->cert == NULL){
- return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+ return CKM_API_ERROR_INPUT_PARAM;
}
CKM::Certificate ckmCert = _toCkmCertificate(current->cert);
ckmUntrustedCerts.push_back(ckmCert);
}while(next != NULL);
}
- if( (ret = mgr.getCertificateChain(ckmCert, ckmUntrustedCerts, ckmCertChain)) != KEY_MANAGER_API_SUCCESS) {
+ if( (ret = mgr.getCertificateChain(ckmCert, ckmUntrustedCerts, ckmCertChain)) != CKM_API_SUCCESS) {
return ret;
}
*cert_chain_list = _toNewCkmCertList(ckmCertChain);
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
KEY_MANAGER_CAPI
if(cert->raw_cert == NULL || cert->cert_size <= 0) {
- return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+ return CKM_API_ERROR_INPUT_PARAM;
}
CKM::RawBuffer buffer(cert->raw_cert, cert->raw_cert + cert->cert_size);
CKM::DataFormat dataFormat = static_cast<CKM::DataFormat>(static_cast<int>(cert->data_format));
next = current->next;
if(current->alias == NULL){
- return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+ return CKM_API_ERROR_INPUT_PARAM;
}
CKM::Alias ckmAlias(current->alias);
ckmUntrustedAliases.push_back(ckmAlias);
}while(next != NULL);
}
- if( (ret = mgr.getCertificateChain(ckmCert, ckmUntrustedAliases, ckmCertChain)) != KEY_MANAGER_API_SUCCESS) {
+ if( (ret = mgr.getCertificateChain(ckmCert, ckmUntrustedAliases, ckmCertChain)) != CKM_API_SUCCESS) {
return ret;
}
*cert_chain_list = _toNewCkmCertList(ckmCertChain);
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
FILE *fp = fopen(file_path, "r");
if(fp == NULL)
- return KEY_MANAGER_API_ERROR_FILE_ACCESS_DENIED;
+ return CKM_API_ERROR_FILE_ACCESS_DENIED;
X509 *pcert = NULL;
if(!(pcert = d2i_X509_fp(fp, NULL))) {
fseek(fp, 0, SEEK_SET);
}
fclose(fp);
if(pcert == NULL) {
- return KEY_MANAGER_API_ERROR_INVALID_FORMAT;
+ return CKM_API_ERROR_INVALID_FORMAT;
}
int ret = _ckm_load_cert_from_x509(pcert, cert);
- if(ret != KEY_MANAGER_API_SUCCESS) {
+ if(ret != CKM_API_SUCCESS) {
X509_free(pcert);
}
return ret;
pkey = NULL;
x509Cert = NULL;
ca = NULL;
- ret = KEY_MANAGER_API_SUCCESS;
+ ret = CKM_API_SUCCESS;
retPrivateKey = NULL;
retCkmCert = NULL;
retCaCertList = NULL;
sk_X509_pop_free(ca, X509_free);
EVP_cleanup();
- if(ret != KEY_MANAGER_API_SUCCESS) {
+ if(ret != CKM_API_SUCCESS) {
if(retPrivateKey != NULL)
ckm_key_free(retPrivateKey);
if(retCkmCert != NULL)
int parsePkcs12(const char *filePath, const char *pass) {
fp_in = NULL;
if(!(fp_in = fopen(filePath, "rb"))) {
- return KEY_MANAGER_API_ERROR_FILE_ACCESS_DENIED;
+ return CKM_API_ERROR_FILE_ACCESS_DENIED;
}
if(!(p12 = d2i_PKCS12_fp(fp_in, NULL))) {
- return KEY_MANAGER_API_ERROR_INVALID_FORMAT;
+ return CKM_API_ERROR_INVALID_FORMAT;
}
/* parse PKCS#12 certificate */
if((ret = PKCS12_parse(p12, pass, &pkey, &x509Cert, &ca)) != 1) {
- return KEY_MANAGER_API_ERROR_INVALID_FORMAT;
+ return CKM_API_ERROR_INVALID_FORMAT;
}
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
int toCkmCert() {
- if( (ret =_ckm_load_cert_from_x509(x509Cert,&retCkmCert)) != KEY_MANAGER_API_SUCCESS) {
+ if( (ret =_ckm_load_cert_from_x509(x509Cert,&retCkmCert)) != CKM_API_SUCCESS) {
return ret;
}
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
int toCkmKey() {
int prikeyLen = 0;
if((prikeyLen = i2d_PrivateKey(pkey, NULL)) < 0) {
- return KEY_MANAGER_API_ERROR_OUT_OF_MEMORY;
+ return CKM_API_ERROR_OUT_OF_MEMORY;
}
unsigned char arrayPrikey[sizeof(unsigned char) * prikeyLen];
unsigned char *pPrikey = arrayPrikey;
if((prikeyLen = i2d_PrivateKey(pkey, &pPrikey)) < 0) {
- return KEY_MANAGER_API_ERROR_OUT_OF_MEMORY;
+ return CKM_API_ERROR_OUT_OF_MEMORY;
}
int type = EVP_PKEY_type(pkey->type);
break;
}
if(key_type == CKM_KEY_NONE) {
- return KEY_MANAGER_API_ERROR_INVALID_FORMAT;
+ return CKM_API_ERROR_INVALID_FORMAT;
}
char *nullPassword = NULL;
retPrivateKey = ckm_key_new(pPrikey, sizeof(unsigned char) * prikeyLen, key_type, nullPassword);
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
int toCaCkmCertList() {
ckm_cert_list *tmpCertList = NULL;
retCaCertList = tmpCertList;
while((popedCert = sk_X509_pop(ca)) != NULL) {
- if( (ret =_ckm_load_cert_from_x509(popedCert, &popedCkmCert)) != KEY_MANAGER_API_SUCCESS) {
- return KEY_MANAGER_API_ERROR_OUT_OF_MEMORY;
+ if( (ret =_ckm_load_cert_from_x509(popedCert, &popedCkmCert)) != CKM_API_SUCCESS) {
+ return CKM_API_ERROR_OUT_OF_MEMORY;
}
tmpCertList = ckm_cert_list_add(tmpCertList, popedCkmCert);
}
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
};
- int ret = KEY_MANAGER_API_SUCCESS;
+ int ret = CKM_API_SUCCESS;
Pkcs12Converter converter;
- if((ret = converter.parsePkcs12(file_path, passphrase)) != KEY_MANAGER_API_SUCCESS) {
+ if((ret = converter.parsePkcs12(file_path, passphrase)) != CKM_API_SUCCESS) {
return ret;
}
- if((ret = converter.toCkmCert()) != KEY_MANAGER_API_SUCCESS) {
+ if((ret = converter.toCkmCert()) != CKM_API_SUCCESS) {
return ret;
}
- if((ret = converter.toCkmKey()) != KEY_MANAGER_API_SUCCESS) {
+ if((ret = converter.toCkmKey()) != CKM_API_SUCCESS) {
return ret;
}
- if((ret = converter.toCaCkmCertList()) != KEY_MANAGER_API_SUCCESS) {
+ if((ret = converter.toCaCkmCertList()) != CKM_API_SUCCESS) {
return ret;
}
*private_key = converter.retPrivateKey;
*ckmcert = converter.retCkmCert;
*ca_cert_list = converter.retCaCertList;
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
KEY_MANAGER_CAPI
unsigned char* bufCert = NULL;
if(xCert == NULL) {
- return KEY_MANAGER_API_ERROR_INVALID_FORMAT;
+ return CKM_API_ERROR_INVALID_FORMAT;
}
/* load certificate into buffer */
if((certLen = i2d_X509(xCert, NULL)) < 0) {
- return KEY_MANAGER_API_ERROR_INVALID_FORMAT;
+ return CKM_API_ERROR_INVALID_FORMAT;
}
unsigned char arrayCert[sizeof(unsigned char) * certLen];
bufCert = arrayCert;
*cert = ckm_cert_new(bufCert, certLen, CKM_CERT_FORM_DER);
- return KEY_MANAGER_API_SUCCESS;
+ return CKM_API_SUCCESS;
}
ERRORDESCRIBE(CKM_API_ERROR_DB_ALIAS_EXISTS);
ERRORDESCRIBE(CKM_API_ERROR_DB_ALIAS_UNKNOWN);
ERRORDESCRIBE(CKM_API_ERROR_VERIFICATION_FAILED);
+ ERRORDESCRIBE(CKM_API_ERROR_INVALID_FORMAT);
+ ERRORDESCRIBE(CKM_API_ERROR_FILE_ACCESS_DENIED);
ERRORDESCRIBE(CKM_API_ERROR_UNKNOWN);
default:
return "Error not defined";
projects / platform / core / security / key-manager.git / commitdiff