#include <openssl/evp.h>
#include <openssl/pem.h>
#include <fstream>
+#include <crypto-init.h>
namespace {
const size_t DEFAULT_IV_LEN_BITS = 8*DEFAULT_IV_LEN;
const size_t DEFAULT_KEY_LEN_BITS = 4096;
-int _ckmc_random_buffer(ckmc_raw_buffer_s **buffer, size_t len)
-{
- if(!buffer)
- return CKMC_ERROR_INVALID_PARAMETER;
-
- char* data = static_cast<char*>(malloc(len*sizeof(char)));
- if(!data)
- return CKMC_ERROR_OUT_OF_MEMORY;
-
- std::ifstream is("/dev/urandom", std::ifstream::binary);
- if(!is) {
- free(data);
- return CKMC_ERROR_FILE_SYSTEM;
- }
-
- is.read(data, len);
- if (static_cast<std::streamsize>(len) != is.gcount()) {
- free(data);
- return CKMC_ERROR_FILE_SYSTEM;
- }
-
- return ckmc_buffer_new(reinterpret_cast<unsigned char*>(data), len, buffer);
-}
-
int _ckmc_load_cert_from_x509(X509 *xCert, ckmc_cert_s **cert)
{
if(xCert == NULL) {
const char * const ckmc_label_name_separator = CKM::LABEL_NAME_SEPARATOR;
-const char * const ckmc_label_shared_owner = CKM::LABEL_SYSTEM_DB;
+const char * const ckmc_label_shared_owner = CKM::OWNER_ID_SYSTEM;
+const char * const ckmc_owner_id_separator = CKM::LABEL_NAME_SEPARATOR;
+const char * const ckmc_owner_id_system = CKM::OWNER_ID_SYSTEM;
KEY_MANAGER_CAPI
int ckmc_key_new(unsigned char *raw_key, size_t key_size, ckmc_key_type_e key_type, char *password, ckmc_key_s **ppkey)
KEY_MANAGER_CAPI
int ckmc_load_cert_from_file(const char *file_path, ckmc_cert_s **cert)
{
- OpenSSL_add_all_algorithms();
+ CKM::initOpenSslOnce();
FILE *fp = fopen(file_path, "r");
if(fp == NULL)
};
- OpenSSL_add_all_algorithms();
+ CKM::initOpenSslOnce();
int ret = CKMC_ERROR_NONE;
}
KEY_MANAGER_CAPI
-int ckmc_param_list_new(ckmc_param_list_s **ppparams)
+int ckmc_param_list_new(ckmc_param_list_h *pparams)
{
- if (!ppparams)
+ if (!pparams || *pparams)
return CKMC_ERROR_INVALID_PARAMETER;
- *ppparams = reinterpret_cast<ckmc_param_list_s*>(new(std::nothrow)(CKM::CryptoAlgorithm));
- if (!*ppparams)
+ *pparams = reinterpret_cast<ckmc_param_list_h>(new(std::nothrow)(CKM::CryptoAlgorithm));
+ if (!*pparams)
return CKMC_ERROR_OUT_OF_MEMORY;
return CKMC_ERROR_NONE;
}
KEY_MANAGER_CAPI
-int ckmc_param_list_add_integer(ckmc_param_list_s *params,
+int ckmc_param_list_set_integer(ckmc_param_list_h params,
ckmc_param_name_e name,
uint64_t value)
{
return CKMC_ERROR_INVALID_PARAMETER;
CKM::CryptoAlgorithm* algo = reinterpret_cast<CKM::CryptoAlgorithm*>(params);
- bool ret = algo->addParam(static_cast<CKM::ParamName>(name), value);
+ bool ret = algo->setParam(static_cast<CKM::ParamName>(name), value);
return (ret ? CKMC_ERROR_NONE : CKMC_ERROR_INVALID_PARAMETER);
}
KEY_MANAGER_CAPI
-int ckmc_param_list_add_buffer(ckmc_param_list_s *params,
+int ckmc_param_list_set_buffer(ckmc_param_list_h params,
ckmc_param_name_e name,
const ckmc_raw_buffer_s *buffer)
{
CKM::CryptoAlgorithm* algo = reinterpret_cast<CKM::CryptoAlgorithm*>(params);
CKM::RawBuffer b(buffer->data, buffer->data + buffer->size);
- bool ret = algo->addParam(static_cast<CKM::ParamName>(name), b);
+ bool ret = algo->setParam(static_cast<CKM::ParamName>(name), b);
return (ret ? CKMC_ERROR_NONE : CKMC_ERROR_INVALID_PARAMETER);
}
KEY_MANAGER_CAPI
-void ckmc_param_list_free(ckmc_param_list_s *params)
+int ckmc_param_list_get_integer(ckmc_param_list_h params,
+ ckmc_param_name_e name,
+ uint64_t *pvalue)
+{
+ if (!params || !pvalue)
+ return CKMC_ERROR_INVALID_PARAMETER;
+
+ const CKM::CryptoAlgorithm* algo = reinterpret_cast<const CKM::CryptoAlgorithm*>(params);
+ if (!algo->getParam(static_cast<CKM::ParamName>(name), *pvalue))
+ return CKMC_ERROR_INVALID_PARAMETER;
+
+ return CKMC_ERROR_NONE;
+}
+
+KEY_MANAGER_CAPI
+int ckmc_param_list_get_buffer(ckmc_param_list_h params,
+ ckmc_param_name_e name,
+ ckmc_raw_buffer_s **ppbuffer)
+{
+ if (!params || !ppbuffer || *ppbuffer)
+ return CKMC_ERROR_INVALID_PARAMETER;
+
+ const CKM::CryptoAlgorithm* algo = reinterpret_cast<const CKM::CryptoAlgorithm*>(params);
+ CKM::RawBuffer value;
+ if (!algo->getParam(static_cast<CKM::ParamName>(name),value))
+ return CKMC_ERROR_INVALID_PARAMETER;
+
+ return ckmc_buffer_new(value.data(), value.size(), ppbuffer);
+}
+
+KEY_MANAGER_CAPI
+void ckmc_param_list_free(ckmc_param_list_h params)
{
CKM::CryptoAlgorithm* algo = reinterpret_cast<CKM::CryptoAlgorithm*>(params);
delete algo;
}
KEY_MANAGER_CAPI
-int ckmc_generate_params(ckmc_algo_type_e type, ckmc_param_list_s *params)
+int ckmc_generate_new_params(ckmc_algo_type_e type, ckmc_param_list_h *pparams)
{
- // return error if params are NULL
- if(params == NULL)
+ if (!pparams || *pparams)
return CKMC_ERROR_INVALID_PARAMETER;
- ckmc_raw_buffer_s* buffer = NULL;
- int ret = CKMC_ERROR_NONE;
- switch(type)
- {
+ ckmc_param_list_h params = NULL;
+ int ret = ckmc_param_list_new(¶ms);
+ if (ret != CKMC_ERROR_NONE)
+ return ret;
+
+ switch (type) {
case CKMC_ALGO_AES_CTR:
- ret = ckmc_param_list_add_integer(params, CKMC_PARAM_ED_CTR_LEN, DEFAULT_IV_LEN_BITS);
- // no break on purpose
+ ret = ckmc_param_list_set_integer(params, CKMC_PARAM_ED_CTR_LEN, DEFAULT_IV_LEN_BITS);
+ break;
case CKMC_ALGO_AES_CBC:
case CKMC_ALGO_AES_GCM:
case CKMC_ALGO_AES_CFB:
- if (ret == CKMC_ERROR_NONE)
- ret = _ckmc_random_buffer(&buffer, DEFAULT_IV_LEN);
- if (ret == CKMC_ERROR_NONE)
- ret = ckmc_param_list_add_buffer(params, CKMC_PARAM_ED_IV, buffer);
- else
- ckmc_buffer_free(buffer);
- break;
case CKMC_ALGO_RSA_OAEP:
- break;
- case CKMC_ALGO_RSA_SV:
- case CKMC_ALGO_DSA_SV:
- case CKMC_ALGO_ECDSA_SV:
- // no hash, no padding by default
- break;
- case CKMC_ALGO_RSA_GEN:
- case CKMC_ALGO_DSA_GEN:
- ret = ckmc_param_list_add_integer(params, CKMC_PARAM_GEN_KEY_LEN, DEFAULT_KEY_LEN_BITS);
- break;
- case CKMC_ALGO_ECDSA_GEN:
- ret = ckmc_param_list_add_integer(params, CKMC_PARAM_GEN_EC, CKMC_EC_PRIME192V1);
+ // no iv by default
break;
default:
- return CKMC_ERROR_INVALID_PARAMETER;
+ ret = CKMC_ERROR_INVALID_PARAMETER;
+ break;
}
- if (ret == CKMC_ERROR_NONE)
- return ckmc_param_list_add_integer(params, CKMC_PARAM_ALGO_TYPE, type);
- return ret;
+
+ if (ret != CKMC_ERROR_NONE) {
+ ckmc_param_list_free(params);
+ return ret;
+ }
+
+ ret = ckmc_param_list_set_integer(params, CKMC_PARAM_ALGO_TYPE, type);
+ if (ret != CKMC_ERROR_NONE) {
+ ckmc_param_list_free(params);
+ return ret;
+ }
+
+ *pparams = params;
+
+ return CKMC_ERROR_NONE;
}
projects / platform / core / security / key-manager.git / blobdiff