#include <openssl/pkcs12.h>
#include <openssl/evp.h>
#include <openssl/pem.h>
+#include <fstream>
+#include <crypto-init.h>
+namespace {
-const char * const ckmc_label_name_separator = CKM::LABEL_NAME_SEPARATOR;
+const size_t DEFAULT_IV_LEN = 16;
+const size_t DEFAULT_IV_LEN_BITS = 8*DEFAULT_IV_LEN;
+const size_t DEFAULT_KEY_LEN_BITS = 4096;
+
+int _ckmc_load_cert_from_x509(X509 *xCert, ckmc_cert_s **cert)
+{
+ if(xCert == NULL) {
+ return CKMC_ERROR_INVALID_FORMAT;
+ }
+
+ BIO *bcert = BIO_new(BIO_s_mem());
+
+ i2d_X509_bio(bcert, xCert);
+
+ CKM::RawBuffer output(8196);
+ int size = BIO_read(bcert, output.data(), output.size());
+ BIO_free_all(bcert);
+ if (size <= 0) {
+ return CKMC_ERROR_INVALID_FORMAT;
+ }
+ output.resize(size);
+
+ return ckmc_cert_new(output.data(), output.size(), CKMC_FORM_DER, cert);
+}
+
+} // namespace anonymous
-int _ckmc_load_cert_from_x509(X509 *xCert, ckmc_cert_s **cert);
+const char * const ckmc_label_name_separator = CKM::LABEL_NAME_SEPARATOR;
+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_load_from_pkcs12_file2(const char *file_path, const char *passphrase, ckmc_pkcs12_s **pkcs12_bundle)
+int ckmc_pkcs12_load(const char *file_path, const char *passphrase, ckmc_pkcs12_s **pkcs12_bundle)
{
int ec;
ckmc_key_s *private_key = 0;
}
}
-int _ckmc_load_cert_from_x509(X509 *xCert, ckmc_cert_s **cert)
+KEY_MANAGER_CAPI
+int ckmc_param_list_new(ckmc_param_list_h *pparams)
{
- if(xCert == NULL) {
- return CKMC_ERROR_INVALID_FORMAT;
- }
+ if (!pparams || *pparams)
+ return CKMC_ERROR_INVALID_PARAMETER;
- BIO *bcert = BIO_new(BIO_s_mem());
+ *pparams = reinterpret_cast<ckmc_param_list_h>(new(std::nothrow)(CKM::CryptoAlgorithm));
+ if (!*pparams)
+ return CKMC_ERROR_OUT_OF_MEMORY;
+ return CKMC_ERROR_NONE;
+}
- i2d_X509_bio(bcert, xCert);
+KEY_MANAGER_CAPI
+int ckmc_param_list_set_integer(ckmc_param_list_h params,
+ ckmc_param_name_e name,
+ uint64_t value)
+{
+ if (!params)
+ return CKMC_ERROR_INVALID_PARAMETER;
- CKM::RawBuffer output(8196);
- int size = BIO_read(bcert, output.data(), output.size());
- BIO_free_all(bcert);
- if (size <= 0) {
- return CKMC_ERROR_INVALID_FORMAT;
- }
- output.resize(size);
+ CKM::CryptoAlgorithm* algo = reinterpret_cast<CKM::CryptoAlgorithm*>(params);
+ bool ret = algo->setParam(static_cast<CKM::ParamName>(name), value);
+ return (ret ? CKMC_ERROR_NONE : CKMC_ERROR_INVALID_PARAMETER);
+}
- return ckmc_cert_new(output.data(), output.size(), CKMC_FORM_DER, cert);
+KEY_MANAGER_CAPI
+int ckmc_param_list_set_buffer(ckmc_param_list_h params,
+ ckmc_param_name_e name,
+ const ckmc_raw_buffer_s *buffer)
+{
+ if (!params || !buffer || !buffer->data || buffer->size == 0)
+ return CKMC_ERROR_INVALID_PARAMETER;
+
+ CKM::CryptoAlgorithm* algo = reinterpret_cast<CKM::CryptoAlgorithm*>(params);
+ CKM::RawBuffer b(buffer->data, buffer->data + buffer->size);
+ bool ret = algo->setParam(static_cast<CKM::ParamName>(name), b);
+ return (ret ? CKMC_ERROR_NONE : CKMC_ERROR_INVALID_PARAMETER);
+}
+
+KEY_MANAGER_CAPI
+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_new_params(ckmc_algo_type_e type, ckmc_param_list_h *pparams)
+{
+ if (!pparams || *pparams)
+ return CKMC_ERROR_INVALID_PARAMETER;
+
+ 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_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:
+ case CKMC_ALGO_RSA_OAEP:
+ // no iv by default
+ break;
+ default:
+ ret = CKMC_ERROR_INVALID_PARAMETER;
+ break;
+ }
+
+ 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;
+}