diff --git a/0026-uadk-tools-modify-NO-SVA-test-scenario.patch b/0026-uadk-tools-modify-NO-SVA-test-scenario.patch new file mode 100644 index 0000000..43237b7 --- /dev/null +++ b/0026-uadk-tools-modify-NO-SVA-test-scenario.patch @@ -0,0 +1,421 @@ +From 0ec02e23cfc86ea664905a11b28635cab12ee29a Mon Sep 17 00:00:00 2001 +From: Liulongfang +Date: Wed, 5 Jan 2022 14:46:54 +0800 +Subject: [PATCH 29/53] uadk/tools: modify NO-SVA test scenario + +In the No-SVA scenario, the user's business data needs to be copied +from the user memory to the block memory allocated by the user mode +through the copy method. +After the business execution is completed, it needs to be copied back. +The test tool should truly reflect the copy operation process. + +Signed-off-by: Liulongfang +--- + uadk_tool/Makefile.am | 2 +- + uadk_tool/sec_wd_benchmark.c | 122 +++++++++++++++++++++++++++++------ + uadk_tool/uadk_benchmark.c | 2 +- + 3 files changed, 103 insertions(+), 23 deletions(-) + +diff --git a/uadk_tool/Makefile.am b/uadk_tool/Makefile.am +index 36536a2..f79a6e3 100644 +--- a/uadk_tool/Makefile.am ++++ b/uadk_tool/Makefile.am +@@ -16,7 +16,7 @@ uadk_tool_LDADD=$(libwd_la_OBJECTS) \ + ../.libs/libhisi_sec.a \ + ../.libs/libhisi_hpre.a \ + ../.libs/libhisi_zip.a \ +- include/libcrypto.a -ldl -lnuma ++ $(top_srcdir)/uadk_tool/include/libcrypto.a -ldl -lnuma + else + uadk_tool_LDADD=-L../.libs -l:libwd.so.2 -l:libwd_crypto.so.2 \ + -L$(top_srcdir)/uadk_tool/include -l:libcrypto.so.1.1 -lnuma +diff --git a/uadk_tool/sec_wd_benchmark.c b/uadk_tool/sec_wd_benchmark.c +index c650e9a..dffd3a7 100644 +--- a/uadk_tool/sec_wd_benchmark.c ++++ b/uadk_tool/sec_wd_benchmark.c +@@ -36,6 +36,7 @@ struct thread_queue_res { + + struct wcrypto_async_tag { + void *ctx; ++ char *out_buf; + int thread_id; + int cnt; + }; +@@ -54,17 +55,34 @@ static unsigned int g_pktlen; + + static void *cipher_async_cb(void *message, void *cipher_tag) + { ++ struct wcrypto_async_tag *async_tag = (struct wcrypto_async_tag *)cipher_tag; ++ struct wcrypto_cipher_msg *req = (struct wcrypto_cipher_msg *)message; ++ ++ // no-sva data copy from uadk to user ++ memcpy(async_tag->out_buf, req->out, g_pktlen); ++ + return NULL; + } + +-static void *aead_async_cb(void *message, void *cipher_tag) ++static void *aead_async_cb(void *message, void *aead_tag) + { ++ struct wcrypto_async_tag *async_tag = (struct wcrypto_async_tag *)aead_tag; ++ struct wcrypto_aead_msg *req = (struct wcrypto_aead_msg *)message; ++ ++ // no-sva data copy from uadk to user ++ memcpy(async_tag->out_buf, req->out, g_pktlen); ++ + return NULL; + } + + static void *digest_async_cb(void *message, void *digest_tag) + { +- // struct WCRYPTO_req *req = (struct WCRYPTO_req *)data; ++ struct wcrypto_async_tag *async_tag = (struct wcrypto_async_tag *)digest_tag; ++ struct wcrypto_digest_msg *req = (struct wcrypto_digest_msg *)message; ++ ++ // no-sva data copy from uadk to user ++ memcpy(async_tag->out_buf, req->out, 16); ++ + return NULL; + } + +@@ -563,6 +581,8 @@ static void *sec_wd_async_run(void *arg) + struct wcrypto_async_tag *tag = NULL; + char priv_key[MAX_IVK_LENTH]; + struct thread_bd_res *bd_res; ++ char *src_data_buf = NULL; ++ char *out_data_buf = NULL; + struct wd_queue *queue; + void *ctx = NULL; + void **res_in; +@@ -584,13 +604,27 @@ static void *sec_wd_async_run(void *arg) + res_out = bd_res->out; + res_iv = bd_res->iv; + ++ /* create user data buffer */ ++ src_data_buf = malloc(g_pktlen * sizeof(char)); ++ if (!src_data_buf) ++ return NULL; ++ ++ get_rand_data(src_data_buf, g_pktlen); ++ out_data_buf = malloc(g_pktlen * sizeof(char)); ++ if (!out_data_buf) { ++ free(src_data_buf); ++ return NULL; ++ } ++ + memset(priv_key, DEF_IVK_DATA, MAX_IVK_LENTH); + tag = malloc(sizeof(struct wcrypto_async_tag)); // set the user tag + if (!tag) { + SEC_TST_PRT("wcrypto async alloc tag fail!\n"); ++ free(src_data_buf); ++ free(out_data_buf); + return NULL; + } +- tag->thread_id = pdata->td_id; ++ tag->out_buf = out_data_buf; + + switch(pdata->subtype) { + case CIPHER_TYPE: +@@ -607,7 +641,7 @@ static void *sec_wd_async_run(void *arg) + ctx = wcrypto_create_cipher_ctx(queue, &cipher_setup); + if (!ctx) { + SEC_TST_PRT("wd create cipher ctx fail!\n"); +- return NULL; ++ goto async_err; + } + tag->ctx = ctx; + +@@ -615,7 +649,7 @@ static void *sec_wd_async_run(void *arg) + if (ret) { + SEC_TST_PRT("wd cipher set key fail!\n"); + wcrypto_del_cipher_ctx(ctx); +- return NULL; ++ goto async_err; + } + + if (queue->capa.priv.direction == 0) +@@ -637,6 +671,9 @@ static void *sec_wd_async_run(void *arg) + if (get_run_state() == 0) + break; + ++ // no-sva data copy to uadk ++ memcpy(copdata.in, src_data_buf, g_pktlen); ++ + ret = wcrypto_do_cipher(ctx, &copdata, (void *)tag); + if (ret == -WD_EBUSY) { + usleep(SEND_USLEEP * try_cnt); +@@ -672,7 +709,7 @@ static void *sec_wd_async_run(void *arg) + ctx = wcrypto_create_aead_ctx(queue, &aead_setup); + if (!ctx) { + SEC_TST_PRT("wd create aead ctx fail!\n"); +- return NULL; ++ goto async_err; + } + tag->ctx = ctx; + +@@ -680,7 +717,7 @@ static void *sec_wd_async_run(void *arg) + if (ret) { + SEC_TST_PRT("wd aead set key fail!\n"); + wcrypto_del_aead_ctx(ctx); +- return NULL; ++ goto async_err; + } + + authsize = 16; //set defaut size +@@ -688,7 +725,7 @@ static void *sec_wd_async_run(void *arg) + if (ret) { + SEC_TST_PRT("set authsize fail!\n"); + wcrypto_del_aead_ctx(ctx); +- return NULL; ++ goto async_err; + } + + if (queue->capa.priv.direction == 0) { +@@ -715,6 +752,9 @@ static void *sec_wd_async_run(void *arg) + if (get_run_state() == 0) + break; + ++ // no-sva data copy to uadk ++ memcpy(aopdata.in, src_data_buf, g_pktlen); ++ + ret = wcrypto_do_aead(ctx, &aopdata, (void *)tag); + if (ret == -WD_EBUSY) { + usleep(SEND_USLEEP * try_cnt); +@@ -750,7 +790,7 @@ static void *sec_wd_async_run(void *arg) + ctx = wcrypto_create_digest_ctx(queue, &digest_setup); + if (!ctx) { + SEC_TST_PRT("wd create digest ctx fail!\n"); +- return NULL; ++ goto async_err; + } + tag->ctx = ctx; + +@@ -760,7 +800,7 @@ static void *sec_wd_async_run(void *arg) + if (ret) { + SEC_TST_PRT("wd digest set key fail!\n"); + wcrypto_del_digest_ctx(ctx); +- return NULL; ++ goto async_err; + } + } + +@@ -777,6 +817,9 @@ static void *sec_wd_async_run(void *arg) + if (get_run_state() == 0) + break; + ++ // no-sva data copy to uadk ++ memcpy(dopdata.in, src_data_buf, g_pktlen); ++ + ret = wcrypto_do_digest(ctx, &dopdata, (void *)tag); + if (ret == -WD_EBUSY) { + usleep(SEND_USLEEP * try_cnt); +@@ -802,7 +845,7 @@ static void *sec_wd_async_run(void *arg) + add_send_complete(); + + while (1) { +- if (get_recv_time() > 0) // wait Async mode finish recv ++ if (get_recv_time() == g_thread_num) // wait Async mode finish recv + break; + usleep(SEND_USLEEP); + } +@@ -819,6 +862,10 @@ static void *sec_wd_async_run(void *arg) + break; + } + ++async_err: ++ free(tag); ++ free(src_data_buf); ++ free(out_data_buf); + return NULL; + } + +@@ -834,6 +881,8 @@ static void *sec_wd_sync_run(void *arg) + char priv_key[MAX_IVK_LENTH]; + struct thread_bd_res *bd_res; + struct wd_queue *queue; ++ char *src_data_buf = NULL; ++ char *out_data_buf = NULL; + void *ctx = NULL; + void *tag = NULL; + void **res_in; +@@ -855,6 +904,18 @@ static void *sec_wd_sync_run(void *arg) + res_out = bd_res->out; + res_iv = bd_res->iv; + ++ /* create user data buffer */ ++ src_data_buf = malloc(g_pktlen * sizeof(char)); ++ if (!src_data_buf) ++ return NULL; ++ ++ get_rand_data(src_data_buf, g_pktlen); ++ out_data_buf = malloc(g_pktlen * sizeof(char)); ++ if (!out_data_buf) { ++ free(src_data_buf); ++ return NULL; ++ } ++ + memset(priv_key, DEF_IVK_DATA, MAX_IVK_LENTH); + + switch(pdata->subtype) { +@@ -871,14 +932,14 @@ static void *sec_wd_sync_run(void *arg) + ctx = wcrypto_create_cipher_ctx(queue, &cipher_setup); + if (!ctx) { + SEC_TST_PRT("wd create cipher ctx fail!\n"); +- return NULL; ++ goto sync_err; + } + + ret = wcrypto_set_cipher_key(ctx, (__u8*)priv_key, (__u16)pdata->keysize); + if (ret) { + SEC_TST_PRT("wd cipher set key fail!\n"); + wcrypto_del_cipher_ctx(ctx); +- return NULL; ++ goto sync_err; + } + + if (queue->capa.priv.direction == 0) +@@ -899,6 +960,9 @@ static void *sec_wd_sync_run(void *arg) + if (get_run_state() == 0) + break; + ++ // no-sva data copy to uadk ++ memcpy(copdata.in, src_data_buf, g_pktlen); ++ + ret = wcrypto_do_cipher(ctx, &copdata, tag); + if (ret == -WD_EBUSY) { + usleep(SEND_USLEEP * try_cnt); +@@ -916,6 +980,9 @@ static void *sec_wd_sync_run(void *arg) + copdata.in = res_in[i]; + copdata.out = res_out[i]; + copdata.iv = res_iv[i]; ++ ++ // no-sva data copy from uadk to user ++ memcpy(out_data_buf, copdata.out, g_pktlen); + } + wcrypto_del_cipher_ctx(ctx); + +@@ -933,14 +1000,14 @@ static void *sec_wd_sync_run(void *arg) + ctx = wcrypto_create_aead_ctx(queue, &aead_setup); + if (!ctx) { + SEC_TST_PRT("wd create aead ctx fail!\n"); +- return NULL; ++ goto sync_err; + } + + ret = wcrypto_set_aead_ckey(ctx, (__u8*)priv_key, (__u16)pdata->keysize); + if (ret) { + SEC_TST_PRT("wd aead set key fail!\n"); + wcrypto_del_aead_ctx(ctx); +- return NULL; ++ goto sync_err; + } + + authsize = 16; //set defaut size +@@ -948,7 +1015,7 @@ static void *sec_wd_sync_run(void *arg) + if (ret) { + SEC_TST_PRT("set authsize fail!\n"); + wcrypto_del_aead_ctx(ctx); +- return NULL; ++ goto sync_err; + } + + if (queue->capa.priv.direction == 0) { +@@ -974,6 +1041,9 @@ static void *sec_wd_sync_run(void *arg) + if (get_run_state() == 0) + break; + ++ // no-sva data copy to uadk ++ memcpy(aopdata.in, src_data_buf, g_pktlen); ++ + ret = wcrypto_do_aead(ctx, &aopdata, tag); + if (ret == -WD_EBUSY) { + usleep(SEND_USLEEP * try_cnt); +@@ -991,6 +1061,9 @@ static void *sec_wd_sync_run(void *arg) + aopdata.in = res_in[i]; + aopdata.out = res_out[i]; + aopdata.iv = res_iv[i]; ++ ++ // no-sva data copy from uadk to user ++ memcpy(out_data_buf, aopdata.out, g_pktlen); + } + wcrypto_del_aead_ctx(ctx); + +@@ -1008,7 +1081,7 @@ static void *sec_wd_sync_run(void *arg) + ctx = wcrypto_create_digest_ctx(queue, &digest_setup); + if (!ctx) { + SEC_TST_PRT("wd create digest ctx fail!\n"); +- return NULL; ++ goto sync_err; + } + + if (digest_setup.mode == WCRYPTO_DIGEST_HMAC) { +@@ -1017,7 +1090,7 @@ static void *sec_wd_sync_run(void *arg) + if (ret) { + SEC_TST_PRT("wd digest set key fail!\n"); + wcrypto_del_digest_ctx(ctx); +- return NULL; ++ goto sync_err; + } + } + +@@ -1033,6 +1106,9 @@ static void *sec_wd_sync_run(void *arg) + if (get_run_state() == 0) + break; + ++ // no-sva data copy to uadk ++ memcpy(dopdata.in, src_data_buf, g_pktlen); ++ + ret = wcrypto_do_digest(ctx, &dopdata, (void *)tag); + if (ret == -WD_EBUSY) { + usleep(SEND_USLEEP * try_cnt); +@@ -1048,7 +1124,10 @@ static void *sec_wd_sync_run(void *arg) + try_cnt = 0; + i = count % MAX_BLOCK_NM; + dopdata.in = res_in[i]; +- dopdata.out = res_out[i]; ++ dopdata.out = res_out[i]; ++ ++ // no-sva data copy from uadk to user ++ memcpy(out_data_buf, dopdata.out, 16); + } + wcrypto_del_digest_ctx(ctx); + break; +@@ -1056,6 +1135,9 @@ static void *sec_wd_sync_run(void *arg) + + add_recv_data(count); + ++sync_err: ++ free(src_data_buf); ++ free(out_data_buf); + return NULL; + } + +@@ -1097,7 +1179,6 @@ int sec_wd_sync_threads(struct acc_option *options) + + sync_error: + return ret; +- + } + + int sec_wd_async_threads(struct acc_option *options) +@@ -1185,4 +1266,3 @@ int sec_wd_benchmark(struct acc_option *options) + + return 0; + } +- +diff --git a/uadk_tool/uadk_benchmark.c b/uadk_tool/uadk_benchmark.c +index 5773b2c..8067ed7 100644 +--- a/uadk_tool/uadk_benchmark.c ++++ b/uadk_tool/uadk_benchmark.c +@@ -551,7 +551,7 @@ static void print_help(void) + ACC_TST_PRT(" [--seconds]:\n"); + ACC_TST_PRT(" set the test times\n"); + ACC_TST_PRT(" [--multi]:\n"); +- ACC_TST_PRT(" set the number of threads\n"); ++ ACC_TST_PRT(" set the number of process\n"); + ACC_TST_PRT(" [--thread]:\n"); + ACC_TST_PRT(" set the number of threads\n"); + ACC_TST_PRT(" [--ctxnum]:\n"); +-- +2.25.1 + diff --git a/0027-wd-fix-wd_parse_async_poll_num.patch b/0027-wd-fix-wd_parse_async_poll_num.patch new file mode 100644 index 0000000..41c924a --- /dev/null +++ b/0027-wd-fix-wd_parse_async_poll_num.patch @@ -0,0 +1,31 @@ +From 4478ede7a98cc9f84b30bb5766007b2acbec1a2f Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Tue, 4 Jan 2022 12:20:32 +0800 +Subject: [PATCH 30/53] wd: fix wd_parse_async_poll_num + +skip parse poll number if inner poll is not enabled. + +Signed-off-by: Wenkai Lin +--- + wd_util.c | 5 +++++ + 1 file changed, 5 insertions(+) + +diff --git a/wd_util.c b/wd_util.c +index e04747b..58463e9 100644 +--- a/wd_util.c ++++ b/wd_util.c +@@ -759,6 +759,11 @@ int wd_parse_async_poll_num(struct wd_env_config *config, const char *s) + char *left, *section, *start; + int node, poll_num, ret; + ++ if (!config->enable_internal_poll) { ++ WD_ERR("internal poll not enabled, skip parse poll number!\n"); ++ return 0; ++ } ++ + start = strdup(s); + if (!start) + return -ENOMEM; +-- +2.25.1 + diff --git a/0028-uadk-optimize-wd_init_async_polling_thread_per_numa.patch b/0028-uadk-optimize-wd_init_async_polling_thread_per_numa.patch new file mode 100644 index 0000000..5afbf56 --- /dev/null +++ b/0028-uadk-optimize-wd_init_async_polling_thread_per_numa.patch @@ -0,0 +1,81 @@ +From 8094e7a2344cf558eb056e7afc153299a3642f39 Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Tue, 4 Jan 2022 12:20:28 +0800 +Subject: [PATCH 31/53] uadk: optimize wd_init_async_polling_thread_per_numa + +use fmin to get poll thread num. + +Signed-off-by: Wenkai Lin +--- + wd_util.c | 23 +++++++++-------------- + 1 file changed, 9 insertions(+), 14 deletions(-) + +diff --git a/wd_util.c b/wd_util.c +index 58463e9..fd132aa 100644 +--- a/wd_util.c ++++ b/wd_util.c +@@ -10,6 +10,7 @@ + #include + #include + #include ++#include + #include "wd_alg_common.h" + #include "wd_util.h" + #include "wd_sched.h" +@@ -1295,7 +1296,8 @@ static int wd_init_async_polling_thread_per_numa(struct wd_env_config *config, + struct wd_env_config_per_numa *config_numa) + { + struct async_task_queue *task_queue, *queue_head; +- int i, j, poll_thread_num, ret; ++ int i, j, ret; ++ double num; + + if (!config_numa->async_ctx_num) + return 0; +@@ -1307,13 +1309,7 @@ static int wd_init_async_polling_thread_per_numa(struct wd_env_config *config, + config_numa->async_poll_num = WD_ASYNC_DEF_POLL_NUM; + } + +- poll_thread_num = config_numa->async_poll_num; +- if (poll_thread_num > config_numa->async_ctx_num) { +- poll_thread_num = config_numa->async_ctx_num; +- WD_ERR("downgrade poll thread num from %lu to %lu.\n", +- config_numa->async_poll_num, +- config_numa->async_ctx_num); +- } ++ num = fmin(config_numa->async_poll_num, config_numa->async_ctx_num); + + /* make max task queues as the number of async ctxs */ + queue_head = calloc(config_numa->async_ctx_num, sizeof(*queue_head)); +@@ -1321,7 +1317,7 @@ static int wd_init_async_polling_thread_per_numa(struct wd_env_config *config, + return -WD_ENOMEM; + + task_queue = queue_head; +- for (i = 0; i < poll_thread_num; task_queue++, i++) { ++ for (i = 0; i < num; task_queue++, i++) { + ret = wd_init_one_task_queue(task_queue, config->alg_poll_ctx); + if (ret) { + for (j = 0; j < i; task_queue++, j++) +@@ -1340,15 +1336,14 @@ static void wd_uninit_async_polling_thread_per_numa(struct wd_env_config *cfg, + struct wd_env_config_per_numa *config_numa) + { + struct async_task_queue *task_queue, *head; +- int i, n; ++ double num; ++ int i; + + head = config_numa->async_task_queue_array; + task_queue = head; +- n = config_numa->async_poll_num; +- if (config_numa->async_poll_num > config_numa->async_ctx_num) +- n = config_numa->async_ctx_num; ++ num = fmin(config_numa->async_poll_num, config_numa->async_ctx_num); + +- for (i = 0; i < n; task_queue++, i++) ++ for (i = 0; i < num; task_queue++, i++) + wd_uninit_one_task_queue(task_queue); + free(head); + config_numa->async_task_queue_array = NULL; +-- +2.25.1 + diff --git a/0029-uadk-env-fix-wd_add_task_to_async_queue.patch b/0029-uadk-env-fix-wd_add_task_to_async_queue.patch new file mode 100644 index 0000000..494e97a --- /dev/null +++ b/0029-uadk-env-fix-wd_add_task_to_async_queue.patch @@ -0,0 +1,113 @@ +From a3b74902cadf6dd671a093c6747a5bd624d09cc4 Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Tue, 4 Jan 2022 12:20:29 +0800 +Subject: [PATCH 32/53] uadk: env: fix wd_add_task_to_async_queue + +clear global information if an add task error occurred. + +Signed-off-by: Wenkai Lin +--- + wd_util.c | 38 ++++++++++++++++++++++++-------------- + 1 file changed, 24 insertions(+), 14 deletions(-) + +diff --git a/wd_util.c b/wd_util.c +index fd132aa..676f475 100644 +--- a/wd_util.c ++++ b/wd_util.c +@@ -45,7 +45,9 @@ struct async_task { + struct async_task_queue { + struct async_task *head; + int depth; ++ /* the producer offset of task queue */ + int prod; ++ /* the consumer offset of task queue */ + int cons; + int cur_task; + int left_task; +@@ -1113,8 +1115,8 @@ static struct async_task_queue *find_async_queue(struct wd_env_config *config, + int wd_add_task_to_async_queue(struct wd_env_config *config, __u32 idx) + { + struct async_task_queue *task_queue; +- struct async_task *head, *task; +- int prod, ret; ++ struct async_task *task; ++ int curr_prod, ret; + + if (!config->enable_internal_poll) + return 0; +@@ -1131,14 +1133,13 @@ int wd_add_task_to_async_queue(struct wd_env_config *config, __u32 idx) + + pthread_mutex_lock(&task_queue->lock); + +- prod = task_queue->prod; +- head = task_queue->head; +- task = head + prod; +- /* fix me */ ++ /* get an available async task and fill ctx idx */ ++ curr_prod = task_queue->prod; ++ task = task_queue->head + curr_prod; + task->idx = idx; + +- prod = (prod + 1) % task_queue->depth; +- task_queue->prod = prod; ++ /* update global information of task queue */ ++ task_queue->prod = (curr_prod + 1) % task_queue->depth; + task_queue->cur_task++; + task_queue->left_task--; + +@@ -1147,10 +1148,19 @@ int wd_add_task_to_async_queue(struct wd_env_config *config, __u32 idx) + ret = sem_post(&task_queue->full_sem); + if (ret) { + WD_ERR("failed to post full_sem!\n"); +- return ret; ++ goto err_out; + } + + return 0; ++ ++err_out: ++ pthread_mutex_lock(&task_queue->lock); ++ task_queue->left_task++; ++ task_queue->cur_task--; ++ task_queue->prod = curr_prod; ++ pthread_mutex_unlock(&task_queue->lock); ++ ++ return ret; + } + + static void *async_poll_process_func(void *args) +@@ -1216,18 +1226,18 @@ static int wd_init_one_task_queue(struct async_task_queue *task_queue, + void *alg_poll_ctx) + + { +- struct async_task *task_head; ++ struct async_task *head; + pthread_t thread_id; + pthread_attr_t attr; + int depth, ret; + + task_queue->depth = depth = WD_ASYNC_DEF_QUEUE_DEPTH; + +- task_head = calloc(task_queue->depth, sizeof(struct async_task)); +- if (!task_head) ++ head = calloc(task_queue->depth, sizeof(*head)); ++ if (!head) + return -WD_ENOMEM; + +- task_queue->head = task_head; ++ task_queue->head = head; + task_queue->left_task = depth; + task_queue->alg_poll_ctx = alg_poll_ctx; + +@@ -1268,7 +1278,7 @@ err_uninit_full_sem: + err_uninit_empty_sem: + sem_destroy(&task_queue->empty_sem); + err_free_head: +- free(task_head); ++ free(head); + ret = -errno; + return ret; + } +-- +2.25.1 + diff --git a/0030-uadk-optimize-find_async_queue.patch b/0030-uadk-optimize-find_async_queue.patch new file mode 100644 index 0000000..4e3ffe2 --- /dev/null +++ b/0030-uadk-optimize-find_async_queue.patch @@ -0,0 +1,41 @@ +From 72f58fe17adc3396a5c6826c5acf9a235b02b635 Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Tue, 4 Jan 2022 12:20:30 +0800 +Subject: [PATCH 33/53] uadk: optimize find_async_queue + +No need to determine offset size before modulo. + +Signed-off-by: Wenkai Lin +--- + wd_util.c | 8 +++----- + 1 file changed, 3 insertions(+), 5 deletions(-) + +diff --git a/wd_util.c b/wd_util.c +index 676f475..9e96114 100644 +--- a/wd_util.c ++++ b/wd_util.c +@@ -1069,7 +1069,7 @@ static struct async_task_queue *find_async_queue(struct wd_env_config *config, + struct wd_env_config_per_numa *config_numa; + struct wd_ctx_range **ctx_table; + struct async_task_queue *head; +- unsigned long offset; ++ unsigned long offset = 0; + int num = 0; + int i; + +@@ -1093,10 +1093,8 @@ static struct async_task_queue *find_async_queue(struct wd_env_config *config, + for (i = 0; i < config_numa->op_type_num; i++) { + if (idx <= ctx_table[CTX_MODE_ASYNC][i].end && + idx >= ctx_table[CTX_MODE_ASYNC][i].begin) { +- offset = idx - ctx_table[CTX_MODE_ASYNC][i].begin; +- if (offset >= config_numa->async_poll_num) +- offset = offset % config_numa->async_poll_num; +- ++ offset = (idx - ctx_table[CTX_MODE_ASYNC][i].begin) % ++ config_numa->async_poll_num; + break; + } + } +-- +2.25.1 + diff --git a/0031-uadk-fix-check_after_sink.patch b/0031-uadk-fix-check_after_sink.patch new file mode 100644 index 0000000..f89b863 --- /dev/null +++ b/0031-uadk-fix-check_after_sink.patch @@ -0,0 +1,41 @@ +From e2b9b8fbf8ee1f8e9775b473de7ee464f32aed50 Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Tue, 4 Jan 2022 12:20:27 +0800 +Subject: [PATCH 34/53] uadk: fix check_after_sink + +No need to check last ret, it cause check_after_sink. + +Signed-off-by: Wenkai Lin +--- + wd.c | 8 ++------ + 1 file changed, 2 insertions(+), 6 deletions(-) + +diff --git a/wd.c b/wd.c +index 25386d7..238ce8a 100644 +--- a/wd.c ++++ b/wd.c +@@ -171,11 +171,7 @@ static int get_dev_info(struct uacce_dev *dev) + if (ret < 0) + return ret; + +- ret = get_str_attr(dev, "algorithms", dev->algs, MAX_ATTR_STR_SIZE); +- if (ret < 0) +- return ret; +- +- return 0; ++ return get_str_attr(dev, "algorithms", dev->algs, MAX_ATTR_STR_SIZE); + } + + static struct uacce_dev *read_uacce_sysfs(const char *dev_name) +@@ -215,7 +211,7 @@ static struct uacce_dev *read_uacce_sysfs(const char *dev_name) + goto out_dir; + + ret = get_dev_info(dev); +- if (ret) { ++ if (ret < 0) { + WD_ERR("failed to get dev info: ret = %d!\n", ret); + goto out_dir; + } +-- +2.25.1 + diff --git a/0032-uadk-fix-wd_request_ctx.patch b/0032-uadk-fix-wd_request_ctx.patch new file mode 100644 index 0000000..7394a12 --- /dev/null +++ b/0032-uadk-fix-wd_request_ctx.patch @@ -0,0 +1,42 @@ +From 6ede569a63ce4f4ead3865b96c5dfff4e9b2fcaf Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Tue, 4 Jan 2022 16:48:01 +0800 +Subject: [PATCH 35/53] uadk: fix wd_request_ctx + +wd_get_accel_name and strncpy should use relative path. + +Signed-off-by: Wenkai Lin +--- + wd.c | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +diff --git a/wd.c b/wd.c +index 238ce8a..746fa02 100644 +--- a/wd.c ++++ b/wd.c +@@ -328,11 +328,11 @@ handle_t wd_request_ctx(struct uacce_dev *dev) + if (!ctx) + return 0; + +- ctx->dev_name = wd_get_accel_name(char_dev_path, 0); ++ ctx->dev_name = wd_get_accel_name(dev->char_dev_path, 0); + if (!ctx->dev_name) + goto free_ctx; + +- ctx->drv_name = wd_get_accel_name(char_dev_path, 1); ++ ctx->drv_name = wd_get_accel_name(dev->char_dev_path, 1); + if (!ctx->drv_name) + goto free_dev_name; + +@@ -342,7 +342,7 @@ handle_t wd_request_ctx(struct uacce_dev *dev) + + wd_ctx_init_qfrs_offs(ctx); + +- strncpy(ctx->dev_path, char_dev_path, MAX_DEV_NAME_LEN); ++ strncpy(ctx->dev_path, dev->char_dev_path, MAX_DEV_NAME_LEN); + ctx->dev_path[MAX_DEV_NAME_LEN - 1] = '\0'; + + ctx->fd = open(char_dev_path, O_RDWR | O_CLOEXEC); +-- +2.25.1 + diff --git a/0033-uadk-fix-sched-params-begin-issue.patch b/0033-uadk-fix-sched-params-begin-issue.patch new file mode 100644 index 0000000..d38a679 --- /dev/null +++ b/0033-uadk-fix-sched-params-begin-issue.patch @@ -0,0 +1,77 @@ +From cca176ed2ab3a34e5eb73cc70247c0f2dd02bdac Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Tue, 4 Jan 2022 21:26:09 +0800 +Subject: [PATCH 36/53] uadk: fix sched params begin issue + +begin field of sched params need to be smaller than end, +otherwise begin ctx is used all the time. So add a check +to prevent invalid user input. + +Signed-off-by: Wenkai Lin +--- + wd_sched.c | 17 +++++++++++------ + 1 file changed, 11 insertions(+), 6 deletions(-) + +diff --git a/wd_sched.c b/wd_sched.c +index a85fd95..aeaf11b 100644 +--- a/wd_sched.c ++++ b/wd_sched.c +@@ -93,7 +93,7 @@ static __u32 sched_get_next_pos_rr(struct sched_ctx_region *region, + + if (pos < region->end) + region->last++; +- else if (pos >= region->end) ++ else + region->last = region->begin; + + pthread_mutex_unlock(®ion->lock); +@@ -209,12 +209,12 @@ static int session_sched_poll_policy(handle_t sched_ctx, + + if (!sched_ctx || !count || !ctx) { + WD_ERR("ERROR: %s the para is NULL!\n", __FUNCTION__); +- return -EINVAL; ++ return -WD_EINVAL; + } + + if (ctx->numa_num > NUMA_NUM_NODES) { + WD_ERR("ERROR: %s ctx numa num is invalid!\n", __FUNCTION__); +- return -EINVAL; ++ return -WD_EINVAL; + } + + sched_info = ctx->sched_info; +@@ -359,7 +359,12 @@ int wd_sched_rr_instance(const struct wd_sched *sched, + if (!sched || !sched->h_sched_ctx || !param) { + WD_ERR("ERROR: %s para err: sched of h_sched_ctx is NULL!\n", + __FUNCTION__); +- return -EINVAL; ++ return -WD_EINVAL; ++ } ++ ++ if (param->begin > param->end) { ++ WD_ERR("ERROR: sched_params's begin is larger than end!\n"); ++ return -WD_EINVAL; + } + + numa_id = param->numa_id; +@@ -372,7 +377,7 @@ int wd_sched_rr_instance(const struct wd_sched *sched, + (type >= sched_ctx->type_num)) { + WD_ERR("ERROR: %s para err: numa_id=%d, mode=%u, type=%u!\n", + __FUNCTION__, numa_id, mode, type); +- return -EINVAL; ++ return -WD_EINVAL; + } + + sched_info = sched_ctx->sched_info; +@@ -380,7 +385,7 @@ int wd_sched_rr_instance(const struct wd_sched *sched, + if (!sched_info[numa_id].ctx_region[mode]) { + WD_ERR("ERROR: %s para err: ctx_region:numa_id=%d, mode=%u is NULL!\n", + __FUNCTION__, numa_id, mode); +- return -EINVAL; ++ return -WD_EINVAL; + } + + sched_info[numa_id].ctx_region[mode][type].begin = param->begin; +-- +2.25.1 + diff --git a/0034-uadk-optimize-wd_request_ctx.patch b/0034-uadk-optimize-wd_request_ctx.patch new file mode 100644 index 0000000..31d19cd --- /dev/null +++ b/0034-uadk-optimize-wd_request_ctx.patch @@ -0,0 +1,88 @@ +From d25bfc4577d47cbf5254b565876b4ca943580881 Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Thu, 6 Jan 2022 21:25:48 +0800 +Subject: [PATCH 37/53] uadk: optimize wd_request_ctx + +open fd first is more reasonable since it often goes wrong. + +Signed-off-by: Wenkai Lin +--- + wd.c | 26 ++++++++++++-------------- + 1 file changed, 12 insertions(+), 14 deletions(-) + +diff --git a/wd.c b/wd.c +index 746fa02..787d74b 100644 +--- a/wd.c ++++ b/wd.c +@@ -300,11 +300,6 @@ static struct uacce_dev *clone_uacce_dev(struct uacce_dev *dev) + return new; + } + +-static void free_uacce_dev(struct uacce_dev *dev) +-{ +- free(dev); +-} +- + static void wd_ctx_init_qfrs_offs(struct wd_ctx_h *ctx) + { + memcpy(&ctx->qfrs_offs, &ctx->dev->qfrs_offs, +@@ -316,6 +311,7 @@ handle_t wd_request_ctx(struct uacce_dev *dev) + struct wd_ctx_h *ctx; + char char_dev_path[PATH_MAX]; + char *ptrRet = NULL; ++ int fd; + + if (!dev || !strlen(dev->dev_root)) + return 0; +@@ -324,9 +320,15 @@ handle_t wd_request_ctx(struct uacce_dev *dev) + if (ptrRet == NULL) + return 0; + ++ fd = open(char_dev_path, O_RDWR | O_CLOEXEC); ++ if (fd < 0) { ++ WD_ERR("failed to open %s!(err = %d)\n", char_dev_path, -errno); ++ return 0; ++ } ++ + ctx = calloc(1, sizeof(struct wd_ctx_h)); + if (!ctx) +- return 0; ++ goto close_fd; + + ctx->dev_name = wd_get_accel_name(dev->char_dev_path, 0); + if (!ctx->dev_name) +@@ -340,27 +342,23 @@ handle_t wd_request_ctx(struct uacce_dev *dev) + if (!ctx->dev) + goto free_drv_name; + ++ ctx->fd = fd; ++ + wd_ctx_init_qfrs_offs(ctx); + + strncpy(ctx->dev_path, dev->char_dev_path, MAX_DEV_NAME_LEN); + ctx->dev_path[MAX_DEV_NAME_LEN - 1] = '\0'; + +- ctx->fd = open(char_dev_path, O_RDWR | O_CLOEXEC); +- if (ctx->fd < 0) { +- WD_ERR("failed to open %s (%d).\n", char_dev_path, -errno); +- goto free_dev; +- } +- + return (handle_t)ctx; + +-free_dev: +- free_uacce_dev(ctx->dev); + free_drv_name: + free(ctx->drv_name); + free_dev_name: + free(ctx->dev_name); + free_ctx: + free(ctx); ++close_fd: ++ close(fd); + return 0; + } + +-- +2.25.1 + diff --git a/0035-uadk-env-bugfix-for-wd_init_resource.patch b/0035-uadk-env-bugfix-for-wd_init_resource.patch new file mode 100644 index 0000000..4903345 --- /dev/null +++ b/0035-uadk-env-bugfix-for-wd_init_resource.patch @@ -0,0 +1,32 @@ +From 556bf83c694c85c124b90428cb7622cc7babd411 Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Mon, 10 Jan 2022 18:52:02 +0800 +Subject: [PATCH 38/53] uadk: env: bugfix for wd_init_resource + +If sched is internal alloc, free it and set to NULL. +Otherwise do not free sched resource from user input. + +Signed-off-by: Wenkai Lin +--- + wd_util.c | 5 ++++- + 1 file changed, 4 insertions(+), 1 deletion(-) + +diff --git a/wd_util.c b/wd_util.c +index 9e96114..2e0e062 100644 +--- a/wd_util.c ++++ b/wd_util.c +@@ -1412,7 +1412,10 @@ static int wd_init_resource(struct wd_env_config *config, + err_uninit_alg: + ops->alg_uninit(); + err_uninit_sched: +- wd_uninit_sched_config(config->sched); ++ if (config->internal_sched) { ++ wd_uninit_sched_config(config->sched); ++ config->sched = NULL; ++ } + err_uninit_ctx: + wd_free_ctx(config->ctx_config); + return ret; +-- +2.25.1 + diff --git a/0036-uadk-env-fix-wd-ctx-num-init.patch b/0036-uadk-env-fix-wd-ctx-num-init.patch new file mode 100644 index 0000000..1e93010 --- /dev/null +++ b/0036-uadk-env-fix-wd-ctx-num-init.patch @@ -0,0 +1,256 @@ +From 388f0f7959acc5130c43b7a7d4a43603724a20a5 Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Mon, 10 Jan 2022 18:52:03 +0800 +Subject: [PATCH 39/53] uadk: env: fix wd ctx num init + +No need to set environment variables for ctx num init, +because environment variables need to parse after set, +add wd_parse_ctx_attr to set environment config directly. + +Signed-off-by: Wenkai Lin +--- + include/wd_util.h | 1 - + wd_util.c | 152 +++++++++++++--------------------------------- + 2 files changed, 43 insertions(+), 110 deletions(-) + +diff --git a/include/wd_util.h b/include/wd_util.h +index 81f4ba8..de2cd44 100644 +--- a/include/wd_util.h ++++ b/include/wd_util.h +@@ -72,7 +72,6 @@ struct wd_env_config { + const struct wd_config_variable *table; + __u32 table_size; + __u16 numa_num; +- __u8 disable_env; + __u8 op_type_num; + }; + +diff --git a/wd_util.c b/wd_util.c +index 2e0e062..ad108bf 100644 +--- a/wd_util.c ++++ b/wd_util.c +@@ -474,8 +474,10 @@ static int wd_alloc_numa(struct wd_env_config *config, + + /* alloc and init config_per_numa and all uacce dev */ + ret = wd_set_config_numa(config, numa_dev_num, max_node); +- if (ret) ++ if (ret) { ++ WD_ERR("failed to set numa config, ret = %d!\n", ret); + goto free_list; ++ } + + /* set device and device num for config numa from uacce_dev list */ + wd_set_numa_dev(head, config); +@@ -801,11 +803,8 @@ static int wd_parse_env(struct wd_env_config *config) + + for (i = 0; i < config->table_size; i++) { + var = config->table + i; +- if (config->disable_env) +- var_s = var->def_val; +- else +- var_s = secure_getenv(var->name); + ++ var_s = secure_getenv(var->name); + if (!var_s || !strlen(var_s)) { + var_s = var->def_val; + WD_ERR("no %s environment variable! Use default: %s\n", +@@ -839,6 +838,40 @@ static void wd_free_env(struct wd_env_config *config) + } + } + ++static int wd_parse_ctx_attr(struct wd_env_config *env_config, ++ struct wd_ctx_attr *attr) ++{ ++ struct wd_env_config_per_numa *config_numa; ++ int ret; ++ ++ config_numa = wd_get_config_numa(env_config, attr->node); ++ if (!config_numa) { ++ WD_ERR("%s got wrong numa node!\n", __func__); ++ return -WD_EINVAL; ++ } ++ ++ config_numa->op_type_num = env_config->op_type_num; ++ ret = wd_alloc_ctx_table(config_numa); ++ if (ret) ++ return ret; ++ ++ config_numa->ctx_table[attr->mode][attr->type].size = attr->num; ++ wd_fill_ctx_table(env_config); ++ ++ /* Use default sched and disable internal poll */ ++ env_config->sched = NULL; ++ env_config->enable_internal_poll = 0; ++ config_numa->async_poll_num = 0; ++ ++ return 0; ++} ++ ++static int wd_init_env_config(struct wd_env_config *config, ++ struct wd_ctx_attr *attr) ++{ ++ return attr ? wd_parse_ctx_attr(config, attr) : wd_parse_env(config); ++} ++ + static __u8 get_ctx_mode(struct wd_env_config_per_numa *config, int idx) + { + struct wd_ctx_range **ctx_table = config->ctx_table; +@@ -869,6 +902,7 @@ static int get_op_type(struct wd_env_config_per_numa *config, + return i; + } + ++ WD_ERR("failed to get op type!\n"); + return -WD_EINVAL; + } + +@@ -1030,6 +1064,7 @@ static int wd_init_sched_config(struct wd_env_config *config) + config->internal_sched = false; + type_num = config->op_type_num; + if (!config->sched) { ++ WD_ERR("no sched is specified, alloc a default sched!\n"); + config->sched = wd_sched_rr_alloc(SCHED_POLICY_RR, type_num, + max_node, func); + if (!config->sched) +@@ -1430,100 +1465,6 @@ static void wd_uninit_resource(struct wd_env_config *config) + wd_free_ctx(config->ctx_config); + } + +-static void *wd_alloc_table(const struct wd_config_variable *table, +- __u32 table_size) +-{ +- struct wd_config_variable *alg_table; +- int i, j; +- +- alg_table = malloc(table_size * sizeof(struct wd_config_variable)); +- if (!alg_table) +- return NULL; +- +- memcpy(alg_table, table, +- table_size * sizeof(struct wd_config_variable)); +- for (i = 0; i < table_size - 1; i++) { +- alg_table[i].def_val = malloc(MAX_STR_LEN); +- if (!alg_table[i].def_val) { +- WD_ERR("%s malloc fail\n", __func__); +- goto free_mem; +- } +- } +- +- return alg_table; +- +-free_mem: +- for (j = 0; j < i; j++) +- free(alg_table[j].def_val); +- +- free(alg_table); +- return NULL; +-} +- +-static int wd_alg_table_init(const struct wd_config_variable *table, +- __u32 table_size, +- struct wd_ctx_attr *attr, +- struct wd_env_config *env_config) +-{ +- struct wd_config_variable *var_tbl; +- const char *type_tbl; +- int ret; +- +- if (!attr) { +- env_config->disable_env = 0; +- env_config->table = table; +- return 0; +- } +- +- env_config->disable_env = 1; +- +- var_tbl = wd_alloc_table(table, table_size); +- if (!var_tbl) +- return -WD_ENOMEM; +- +- env_config->table = var_tbl; +- +- /** +- * Below def_val's memory is allocated from wd_alloc_table, +- * the length of memory allocated to def_val is MAX_STR_LEN. +- * +- * We use mode and type as index of a string two-dimensional +- * array to init def_val. +- */ +- if (env_config->op_type_num == 1) +- type_tbl = ctx_type[attr->mode][attr->type]; +- else +- type_tbl = comp_ctx_type[attr->mode][attr->type]; +- +- ret = snprintf(var_tbl[0].def_val, MAX_STR_LEN, "%s%u%c%u", +- type_tbl, attr->num, '@', attr->node); +- if (ret < 0) +- return -errno; +- +- return 0; +-} +- +-static void wd_alg_table_uninit(struct wd_env_config *config) +-{ +- struct wd_config_variable *table; +- int i; +- +- if (!config->disable_env) +- return; +- +- table = (struct wd_config_variable *)config->table; +- if (!table) +- return; +- +- for (i = 0; i < config->table_size - 1; i++) { +- free(table[i].def_val); +- table[i].def_val = NULL; +- } +- +- free(table); +- table = NULL; +-} +- + int wd_alg_env_init(struct wd_env_config *env_config, + const struct wd_config_variable *table, + const struct wd_alg_ops *ops, +@@ -1534,18 +1475,14 @@ int wd_alg_env_init(struct wd_env_config *env_config, + + env_config->op_type_num = ops->op_type_num; + env_config->alg_poll_ctx = ops->alg_poll_ctx; ++ env_config->table = table; + env_config->table_size = table_size; + +- ret = wd_alg_table_init(table, table_size, +- ctx_attr, env_config); +- if (ret) +- return ret; +- + ret = wd_alloc_numa(env_config, ops); + if (ret) +- goto table_uninit; ++ return ret; + +- ret = wd_parse_env(env_config); ++ ret = wd_init_env_config(env_config, ctx_attr); + if (ret) + goto free_numa; + +@@ -1562,8 +1499,6 @@ free_env: + wd_free_env(env_config); + free_numa: + wd_free_numa(env_config); +-table_uninit: +- wd_alg_table_uninit(env_config); + return ret; + } + +@@ -1576,7 +1511,6 @@ void wd_alg_env_uninit(struct wd_env_config *env_config) + wd_uninit_resource(env_config); + wd_free_env(env_config); + wd_free_numa(env_config); +- wd_alg_table_uninit(env_config); + } + + int wd_alg_get_env_param(struct wd_env_config *env_config, +-- +2.25.1 + diff --git a/0037-uadk-modify-for-free-and-return.patch b/0037-uadk-modify-for-free-and-return.patch new file mode 100644 index 0000000..5ef0735 --- /dev/null +++ b/0037-uadk-modify-for-free-and-return.patch @@ -0,0 +1,39 @@ +From f4cd396150be285aa614f4272a51cd3dacf99096 Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Mon, 10 Jan 2022 20:01:41 +0800 +Subject: [PATCH 40/53] uadk: modify for free and return + +After free local variable, no need to set NULL. +If return value is not associated with other +functions, no need to set value, return directly. + +Signed-off-by: JunchongPan +--- + wd_util.c | 4 +--- + 1 file changed, 1 insertion(+), 3 deletions(-) + +diff --git a/wd_util.c b/wd_util.c +index ad108bf..c2c109c 100644 +--- a/wd_util.c ++++ b/wd_util.c +@@ -599,7 +599,6 @@ free_mem: + } + + free(ctx_table); +- ctx_table = NULL; + return ret; + } + +@@ -652,8 +651,7 @@ static int wd_parse_section(struct wd_env_config *config, char *section) + config_numa = wd_get_config_numa(config, node); + if (!config_numa) { + WD_ERR("%s got wrong numa node: %s!\n", __func__, section); +- ret = -WD_EINVAL; +- return ret; ++ return -WD_EINVAL; + } + + config_numa->op_type_num = config->op_type_num; +-- +2.25.1 + diff --git a/0038-uadk-include-fix-uadk-compatibility.patch b/0038-uadk-include-fix-uadk-compatibility.patch new file mode 100644 index 0000000..20f046d --- /dev/null +++ b/0038-uadk-include-fix-uadk-compatibility.patch @@ -0,0 +1,516 @@ +From b8c3d3c5f1b3db3b89ed975bb51c7546676f2bd1 Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Mon, 10 Jan 2022 18:52:04 +0800 +Subject: [PATCH 41/53] uadk: include: fix uadk compatibility + +Fix that C++ program can't call the uadk interface. + +Signed-off-by: Wenkai Lin +--- + include/drv/wd_aead_drv.h | 9 +++++++++ + include/drv/wd_cipher_drv.h | 9 +++++++++ + include/drv/wd_comp_drv.h | 8 ++++++++ + include/drv/wd_dh_drv.h | 8 ++++++++ + include/drv/wd_digest_drv.h | 9 +++++++++ + include/drv/wd_ecc_drv.h | 8 ++++++++ + include/drv/wd_rsa_drv.h | 8 ++++++++ + include/hisi_qm_udrv.h | 8 ++++++++ + include/uacce.h | 9 +++++++++ + include/wd.h | 8 ++++++++ + include/wd_aead.h | 8 ++++++++ + include/wd_alg_common.h | 8 ++++++++ + include/wd_cipher.h | 8 ++++++++ + include/wd_common.h | 8 ++++++++ + include/wd_comp.h | 8 ++++++++ + include/wd_dh.h | 8 ++++++++ + include/wd_digest.h | 8 ++++++++ + include/wd_rsa.h | 8 ++++++++ + include/wd_sched.h | 8 ++++++++ + include/wd_util.h | 8 ++++++++ + 20 files changed, 164 insertions(+) + +diff --git a/include/drv/wd_aead_drv.h b/include/drv/wd_aead_drv.h +index d2016f0..78a5673 100644 +--- a/include/drv/wd_aead_drv.h ++++ b/include/drv/wd_aead_drv.h +@@ -7,6 +7,10 @@ + #include "include/wd_alg_common.h" + #include "include/wd_aead.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + struct wd_aead_msg { + struct wd_aead_req req; + /* Request identifier */ +@@ -87,4 +91,9 @@ static void __attribute__((constructor)) set_aead_driver(void) \ + wd_aead_set_driver(&drv); \ + } + #endif ++ ++#ifdef __cplusplus ++} ++#endif ++ + #endif /* __WD_AEAD_DRV_H */ +diff --git a/include/drv/wd_cipher_drv.h b/include/drv/wd_cipher_drv.h +index d6798c0..e649869 100644 +--- a/include/drv/wd_cipher_drv.h ++++ b/include/drv/wd_cipher_drv.h +@@ -7,6 +7,10 @@ + #include "../wd_cipher.h" + #include "../wd_alg_common.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + /* fixme wd_cipher_msg */ + struct wd_cipher_msg { + struct wd_cipher_req req; +@@ -72,4 +76,9 @@ static void __attribute__((constructor)) set_driver(void) \ + wd_cipher_set_driver(&drv); \ + } + #endif ++ ++#ifdef __cplusplus ++} ++#endif ++ + #endif /* __WD_CIPHER_DRV_H */ +diff --git a/include/drv/wd_comp_drv.h b/include/drv/wd_comp_drv.h +index b4dc722..8146a50 100644 +--- a/include/drv/wd_comp_drv.h ++++ b/include/drv/wd_comp_drv.h +@@ -7,6 +7,10 @@ + #include + #include "../wd_comp.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + enum wd_comp_strm_pos { + WD_COMP_STREAM_NEW, + WD_COMP_STREAM_OLD, +@@ -79,4 +83,8 @@ static void __attribute__((constructor)) set_driver(void) \ + } + #endif + ++#ifdef __cplusplus ++} ++#endif ++ + #endif /* __WD_COMP_DRV_H */ +diff --git a/include/drv/wd_dh_drv.h b/include/drv/wd_dh_drv.h +index 08212b1..5d436d1 100644 +--- a/include/drv/wd_dh_drv.h ++++ b/include/drv/wd_dh_drv.h +@@ -6,6 +6,10 @@ + + #include "../wd_dh.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + /* DH message format */ + struct wd_dh_msg { + struct wd_dh_req req; +@@ -45,4 +49,8 @@ static void __attribute__((constructor)) set_driver_dh(void) \ + } + #endif + ++#ifdef __cplusplus ++} ++#endif ++ + #endif /* __WD_DH_DRV_H */ +diff --git a/include/drv/wd_digest_drv.h b/include/drv/wd_digest_drv.h +index ac3b028..fdde772 100644 +--- a/include/drv/wd_digest_drv.h ++++ b/include/drv/wd_digest_drv.h +@@ -6,6 +6,10 @@ + #include "include/wd_digest.h" + #include "include/wd_alg_common.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + /* fixme wd_digest_msg */ + struct wd_digest_msg { + struct wd_digest_req req; +@@ -75,4 +79,9 @@ static void __attribute__((constructor)) set_drivers(void) \ + wd_digest_set_driver(&drv); \ + } + #endif ++ ++#ifdef __cplusplus ++} ++#endif ++ + #endif /* __WD_DIGEST_DRV_H */ +diff --git a/include/drv/wd_ecc_drv.h b/include/drv/wd_ecc_drv.h +index 9f4575f..7e0d27e 100644 +--- a/include/drv/wd_ecc_drv.h ++++ b/include/drv/wd_ecc_drv.h +@@ -7,6 +7,10 @@ + #include "../wd_ecc.h" + #include "../wd_alg_common.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + /* ECC */ + #define ECDH_IN_PARAM_NUM 2 + #define ECDH_OUT_PARAM_NUM 2 +@@ -198,4 +202,8 @@ static void __attribute__((constructor)) set_driver_ecc(void) \ + } + #endif + ++#ifdef __cplusplus ++} ++#endif ++ + #endif /* __WD_ECC_DRV_H */ +diff --git a/include/drv/wd_rsa_drv.h b/include/drv/wd_rsa_drv.h +index 3c4b144..948625f 100644 +--- a/include/drv/wd_rsa_drv.h ++++ b/include/drv/wd_rsa_drv.h +@@ -5,6 +5,10 @@ + + #include "../wd_rsa.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + struct wd_rsa_kg_in { + __u8 *e; + __u8 *p; +@@ -70,4 +74,8 @@ static void __attribute__((constructor)) set_driver_rsa(void) \ + } + #endif + ++#ifdef __cplusplus ++} ++#endif ++ + #endif /* __WD_RSA_DRV_H */ +diff --git a/include/hisi_qm_udrv.h b/include/hisi_qm_udrv.h +index 11ee4ad..707d0e3 100644 +--- a/include/hisi_qm_udrv.h ++++ b/include/hisi_qm_udrv.h +@@ -12,6 +12,10 @@ + #include "wd.h" + #include "wd_alg_common.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + #define WD_CAPA_PRIV_DATA_SIZE 64 + + #define QM_L32BITS_MASK 0xffffffff +@@ -180,4 +184,8 @@ __u32 hisi_qm_get_list_size(struct wd_datalist *start_node, + + void hisi_qm_enable_interrupt(handle_t ctx, __u8 enable); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif +diff --git a/include/uacce.h b/include/uacce.h +index 7c69df8..07e36fe 100644 +--- a/include/uacce.h ++++ b/include/uacce.h +@@ -10,6 +10,10 @@ + #include + #include + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + #define UACCE_CMD_START _IO('W', 0) + #define UACCE_CMD_PUT_Q _IO('W', 1) + #define UACCE_CMD_GET_SS_DMA _IOR('W', 100, unsigned long) +@@ -33,4 +37,9 @@ enum uacce_qfrt { + UACCE_QFRT_DUS = 1, /* device user share */ + UACCE_QFRT_MAX, + }; ++ ++#ifdef __cplusplus ++} ++#endif ++ + #endif +diff --git a/include/wd.h b/include/wd.h +index ac564d8..273cbb8 100644 +--- a/include/wd.h ++++ b/include/wd.h +@@ -14,6 +14,10 @@ + #include + #include "uacce.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + #define PATH_STR_SIZE 256 + #define MAX_ATTR_STR_SIZE 384 + #define WD_NAME_SIZE 64 +@@ -483,4 +487,8 @@ void wd_mempool_stats(handle_t mempool, struct wd_mempool_stats *stats); + */ + void wd_blockpool_stats(handle_t blkpool, struct wd_blockpool_stats *stats); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif +diff --git a/include/wd_aead.h b/include/wd_aead.h +index 6377008..f169812 100644 +--- a/include/wd_aead.h ++++ b/include/wd_aead.h +@@ -14,6 +14,10 @@ + #include "wd_digest.h" + #include "wd.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + /** + * wd_aead_op_type - Algorithm type of option + */ +@@ -214,4 +218,8 @@ void wd_aead_ctx_num_uninit(void); + int wd_aead_get_env_param(__u32 node, __u32 type, __u32 mode, + __u32 *num, __u8 *is_enable); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif /* __WD_AEAD_H */ +diff --git a/include/wd_alg_common.h b/include/wd_alg_common.h +index 01a12ca..94336f0 100644 +--- a/include/wd_alg_common.h ++++ b/include/wd_alg_common.h +@@ -12,6 +12,10 @@ + #include "wd.h" + #include "wd_common.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + /* Required compiler attributes */ + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +@@ -103,4 +107,8 @@ struct wd_datalist { + struct wd_datalist *next; + }; + ++#ifdef __cplusplus ++} ++#endif ++ + #endif +diff --git a/include/wd_cipher.h b/include/wd_cipher.h +index 8c73396..660d7e8 100644 +--- a/include/wd_cipher.h ++++ b/include/wd_cipher.h +@@ -11,6 +11,10 @@ + #include "wd.h" + #include "wd_alg_common.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + #define AES_KEYSIZE_128 16 + #define AES_KEYSIZE_192 24 + #define AES_KEYSIZE_256 32 +@@ -185,4 +189,8 @@ void wd_cipher_ctx_num_uninit(void); + int wd_cipher_get_env_param(__u32 node, __u32 type, __u32 mode, + __u32 *num, __u8 *is_enable); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif /* __WD_CIPHER_H */ +diff --git a/include/wd_common.h b/include/wd_common.h +index 61919d5..91dd066 100644 +--- a/include/wd_common.h ++++ b/include/wd_common.h +@@ -7,9 +7,17 @@ + #ifndef __WD_COMMON_H + #define __WD_COMMON_H + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + enum wd_buff_type { + WD_FLAT_BUF, + WD_SGL_BUF, + }; + ++#ifdef __cplusplus ++} ++#endif ++ + #endif /* __WD_COMMON_H */ +diff --git a/include/wd_comp.h b/include/wd_comp.h +index b6225df..460cfa7 100644 +--- a/include/wd_comp.h ++++ b/include/wd_comp.h +@@ -12,6 +12,10 @@ + #include "wd.h" + #include "wd_alg_common.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + enum wd_comp_alg_type { + WD_DEFLATE, + WD_ZLIB, +@@ -217,4 +221,8 @@ void wd_comp_ctx_num_uninit(void); + int wd_comp_get_env_param(__u32 node, __u32 type, __u32 mode, + __u32 *num, __u8 *is_enable); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif /* __WD_COMP_H */ +diff --git a/include/wd_dh.h b/include/wd_dh.h +index c0bce85..f342722 100644 +--- a/include/wd_dh.h ++++ b/include/wd_dh.h +@@ -12,6 +12,10 @@ + #include "wd.h" + #include "wd_alg_common.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + #define BYTE_BITS 8 + #define BYTE_BITS_SHIFT 3 + #define GET_NEGATIVE(val) (0 - (val)) +@@ -69,4 +73,8 @@ void wd_dh_ctx_num_uninit(void); + int wd_dh_get_env_param(__u32 node, __u32 type, __u32 mode, + __u32 *num, __u8 *is_enable); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif /* __WD_DH_H */ +diff --git a/include/wd_digest.h b/include/wd_digest.h +index 8e8e236..7e93a80 100644 +--- a/include/wd_digest.h ++++ b/include/wd_digest.h +@@ -11,6 +11,10 @@ + #include "wd_alg_common.h" + #include "wd.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + #define MAX_HMAC_KEY_SIZE 128U + + /** +@@ -209,4 +213,8 @@ void wd_digest_ctx_num_uninit(void); + int wd_digest_get_env_param(__u32 node, __u32 type, __u32 mode, + __u32 *num, __u8 *is_enable); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif /* __WD_DIGEST_H */ +diff --git a/include/wd_rsa.h b/include/wd_rsa.h +index 044819b..081bc2a 100644 +--- a/include/wd_rsa.h ++++ b/include/wd_rsa.h +@@ -12,6 +12,10 @@ + #include "wd.h" + #include "wd_alg_common.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + #define BYTE_BITS 8 + #define BYTE_BITS_SHIFT 3 + #define CRT_PARAMS_SZ(key_size) ((5 * (key_size)) >> 1) +@@ -216,4 +220,8 @@ void wd_rsa_ctx_num_uninit(void); + int wd_rsa_get_env_param(__u32 node, __u32 type, __u32 mode, + __u32 *num, __u8 *is_enable); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif /* __WD_RSA_H */ +diff --git a/include/wd_sched.h b/include/wd_sched.h +index 78125f4..2ae6103 100644 +--- a/include/wd_sched.h ++++ b/include/wd_sched.h +@@ -8,6 +8,10 @@ + #define SCHED_SAMPLE_h + #include "wd_alg_common.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + #define INVALID_POS 0xFFFFFFFF + + /* The global policy type */ +@@ -56,4 +60,8 @@ struct wd_sched *wd_sched_rr_alloc(__u8 sched_type, __u8 type_num, + */ + void wd_sched_rr_release(struct wd_sched *sched); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif +diff --git a/include/wd_util.h b/include/wd_util.h +index de2cd44..ef95907 100644 +--- a/include/wd_util.h ++++ b/include/wd_util.h +@@ -10,6 +10,10 @@ + #include + #include "wd_alg_common.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + #define FOREACH_NUMA(i, config, config_numa) \ + for (i = 0, config_numa = config->config_per_numa; \ + i < config->numa_num; config_numa++, i++) +@@ -309,4 +313,8 @@ int wd_set_ctx_attr(struct wd_ctx_attr *ctx_attr, + */ + int wd_check_ctx(struct wd_ctx_config_internal *config, __u8 mode, __u32 idx); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif /* __WD_UTIL_H */ +-- +2.25.1 + diff --git a/0039-uadk-fix-for-resources-are-repeatedly-released.patch b/0039-uadk-fix-for-resources-are-repeatedly-released.patch new file mode 100644 index 0000000..8b4a1d2 --- /dev/null +++ b/0039-uadk-fix-for-resources-are-repeatedly-released.patch @@ -0,0 +1,50 @@ +From bb09e342c186f111600e763ca7a5bfb8713df6f7 Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Wed, 12 Jan 2022 09:44:57 +0800 +Subject: [PATCH 42/53] uadk: fix for resources are repeatedly released + +Segment fault occur when environment resources +are repeatedly released, so add pointer check +for wd_free_ctx and wd_free_env and clear dirty +global Variables. + +Signed-off-by: Wenkai Lin +--- + wd_util.c | 7 +++++++ + 1 file changed, 7 insertions(+) + +diff --git a/wd_util.c b/wd_util.c +index c2c109c..6cae768 100644 +--- a/wd_util.c ++++ b/wd_util.c +@@ -825,6 +825,9 @@ static void wd_free_env(struct wd_env_config *config) + struct wd_env_config_per_numa *config_numa; + int i, j; + ++ if (!config->config_per_numa) ++ return; ++ + FOREACH_NUMA(i, config, config_numa) { + if (!config_numa->ctx_table) + continue; +@@ -1010,6 +1013,9 @@ err_free_ctx_config: + + static void wd_free_ctx(struct wd_ctx_config *ctx_config) + { ++ if (!ctx_config) ++ return; ++ + wd_put_wd_ctx(ctx_config, ctx_config->ctx_num); + free(ctx_config->ctxs); + free(ctx_config); +@@ -1451,6 +1457,7 @@ err_uninit_sched: + } + err_uninit_ctx: + wd_free_ctx(config->ctx_config); ++ config->ctx_config = NULL; + return ret; + } + +-- +2.25.1 + diff --git a/0040-aead-modify-the-aead-s-request-api.patch b/0040-aead-modify-the-aead-s-request-api.patch new file mode 100644 index 0000000..ac0ab86 --- /dev/null +++ b/0040-aead-modify-the-aead-s-request-api.patch @@ -0,0 +1,785 @@ +From c421a68ee4f70675235443f9cc968f264c7a39a6 Mon Sep 17 00:00:00 2001 +From: Kai Ye +Date: Thu, 13 Jan 2022 10:37:10 +0800 +Subject: [PATCH 43/53] aead: modify the aead's request api + +1. Add the parameter of mac address for Openssl engine. Previous + plan not adapted to the Openssl engine, it caused the low performance. + So after modification, user should allocated the mac memory and set + the mac length as doing task. +2. Deleted a parameter in api. the out_buffer_bytes is a redundant + code. + +Signed-off-by: Kai Ye +--- + drv/hisi_sec.c | 72 ++---------------- + include/wd_aead.h | 6 +- + test/hisi_sec_test/test_hisi_sec.c | 116 ++++++++++++++++++++++------- + uadk_tool/sec_uadk_benchmark.c | 33 ++++---- + wd_aead.c | 46 ++++++++---- + 5 files changed, 152 insertions(+), 121 deletions(-) + +diff --git a/drv/hisi_sec.c b/drv/hisi_sec.c +index d31a1b9..f5db7eb 100644 +--- a/drv/hisi_sec.c ++++ b/drv/hisi_sec.c +@@ -73,8 +73,8 @@ + /* The max BD data length is 16M-512B */ + #define MAX_INPUT_DATA_LEN 0xFFFE00 + #define MAX_CCM_AAD_LEN 65279 +-#define SHA1_ALIGN_SZ 64 +-#define SHA512_ALIGN_SZ 128 ++#define SHA1_ALIGN_SZ 64U ++#define SHA512_ALIGN_SZ 128U + + #define AUTHPAD_OFFSET 2 + #define AUTHTYPE_OFFSET 6 +@@ -1739,48 +1739,12 @@ static void set_aead_auth_iv(struct wd_aead_msg *msg) + } + } + +-static void fill_aead_mac_addr_pbuff(struct wd_aead_msg *msg, __u64 *mac_addr) +-{ +- __u64 addr = 0; +- +- if (msg->op_type == WD_CIPHER_DECRYPTION_DIGEST) +- addr = (__u64)(uintptr_t)msg->in + msg->in_bytes + msg->assoc_bytes; +- +- /* AEAD output MAC addr use out addr */ +- if (msg->op_type == WD_CIPHER_ENCRYPTION_DIGEST) +- addr = (__u64)(uintptr_t)msg->out + msg->out_bytes - msg->auth_bytes; +- +- *mac_addr = addr; +-} +- +-static void fill_aead_mac_addr_sgl(struct wd_aead_msg *msg, __u64 *mac_addr) +-{ +- msg->mac = calloc(1, msg->auth_bytes); +- if (!msg->mac) { +- WD_ERR("failed to alloc mac memory!\n"); +- return; +- } +- +- if (msg->op_type == WD_CIPHER_DECRYPTION_DIGEST) +- hisi_qm_sgl_copy(msg->mac, msg->in, +- msg->in_bytes + msg->assoc_bytes, +- msg->auth_bytes, COPY_SGL_TO_PBUFF); +- +- *mac_addr = (__u64)(uintptr_t)msg->mac; +-} +- + static void fill_aead_bd2_addr(struct wd_aead_msg *msg, + struct hisi_sec_sqe *sqe) + { + sqe->type2.data_src_addr = (__u64)(uintptr_t)msg->in; + sqe->type2.data_dst_addr = (__u64)(uintptr_t)msg->out; +- +- /* AEAD input MAC addr use in addr */ +- if (msg->data_fmt == WD_FLAT_BUF) +- fill_aead_mac_addr_pbuff(msg, &sqe->type2.mac_addr); +- else +- fill_aead_mac_addr_sgl(msg, &sqe->type2.mac_addr); +- ++ sqe->type2.mac_addr = (__u64)(uintptr_t)msg->mac; + sqe->type2.c_key_addr = (__u64)(uintptr_t)msg->ckey; + sqe->type2.a_key_addr = (__u64)(uintptr_t)msg->akey; + sqe->type2.c_ivin_addr = (__u64)(uintptr_t)msg->iv; +@@ -1939,7 +1903,7 @@ static void parse_aead_bd2(struct hisi_sec_sqe *sqe, + if (recv_msg->auth_bytes == 0) + recv_msg->auth_bytes = sqe->type2.icvw_kmode & + SEC_AUTH_LEN_MASK; +- recv_msg->out_bytes = sqe->type2.clen_ivhlen + recv_msg->auth_bytes + ++ recv_msg->out_bytes = sqe->type2.clen_ivhlen + + sqe->type2.cipher_src_offset; + + #ifdef DEBUG +@@ -1961,15 +1925,9 @@ int hisi_sec_aead_recv(handle_t ctx, struct wd_aead_msg *recv_msg) + + parse_aead_bd2(&sqe, recv_msg); + +- if (recv_msg->data_fmt == WD_SGL_BUF) { +- if (sqe.type_auth_cipher & (SEC_CIPHER_ENC << SEC_CIPHER_OFFSET)) +- hisi_qm_sgl_copy(recv_msg->mac, recv_msg->out, +- recv_msg->out_bytes - recv_msg->auth_bytes, +- recv_msg->auth_bytes, COPY_PBUFF_TO_SGL); +- ++ if (recv_msg->data_fmt == WD_SGL_BUF) + hisi_sec_put_sgl(h_qp, recv_msg->alg_type, recv_msg->in, + recv_msg->out); +- } + + return 0; + } +@@ -2089,18 +2047,10 @@ static int fill_aead_bd3_mode(struct wd_aead_msg *msg, + static void fill_aead_bd3_addr(struct wd_aead_msg *msg, + struct hisi_sec_sqe3 *sqe) + { +- __u64 mac_addr; +- + sqe->data_src_addr = (__u64)(uintptr_t)msg->in; + sqe->data_dst_addr = (__u64)(uintptr_t)msg->out; + +- /* AEAD input MAC addr use in and out addr */ +- if (msg->data_fmt == WD_FLAT_BUF) +- fill_aead_mac_addr_pbuff(msg, &mac_addr); +- else +- fill_aead_mac_addr_sgl(msg, &mac_addr); +- +- sqe->mac_addr = mac_addr; ++ sqe->mac_addr = (__u64)(uintptr_t)msg->mac; + sqe->c_key_addr = (__u64)(uintptr_t)msg->ckey; + sqe->a_key_addr = (__u64)(uintptr_t)msg->akey; + sqe->no_scene.c_ivin_addr = (__u64)(uintptr_t)msg->iv; +@@ -2237,7 +2187,7 @@ static void parse_aead_bd3(struct hisi_sec_sqe3 *sqe, + if (recv_msg->auth_bytes == 0) + recv_msg->auth_bytes = (sqe->c_icv_key >> SEC_MAC_OFFSET_V3) & + SEC_MAC_LEN_MASK; +- recv_msg->out_bytes = sqe->c_len_ivin + recv_msg->auth_bytes + ++ recv_msg->out_bytes = sqe->c_len_ivin + + sqe->cipher_src_offset; + + #ifdef DEBUG +@@ -2259,15 +2209,9 @@ int hisi_sec_aead_recv_v3(handle_t ctx, struct wd_aead_msg *recv_msg) + + parse_aead_bd3(&sqe, recv_msg); + +- if (recv_msg->data_fmt == WD_SGL_BUF) { +- if (sqe.c_icv_key & SEC_CIPHER_ENC) +- hisi_qm_sgl_copy(recv_msg->mac, recv_msg->out, +- recv_msg->out_bytes - recv_msg->auth_bytes, +- recv_msg->auth_bytes, COPY_PBUFF_TO_SGL); +- ++ if (recv_msg->data_fmt == WD_SGL_BUF) + hisi_sec_put_sgl(h_qp, recv_msg->alg_type, + recv_msg->in, recv_msg->out); +- } + + return 0; + } +diff --git a/include/wd_aead.h b/include/wd_aead.h +index f169812..a632cd8 100644 +--- a/include/wd_aead.h ++++ b/include/wd_aead.h +@@ -52,11 +52,12 @@ typedef void *wd_alg_aead_cb_t(struct wd_aead_req *req, void *cb_param); + * @ op_type: denoted by enum wd_aead_op_type + * @ src: input data pointer + * @ dst: output data pointer ++ * @ mac: mac data pointer + * @ iv: input iv pointer + * @ in_bytes: input data length + * @ out_bytes: output data length +- * @ out_buf_bytes: output data buffer length + * @ iv_bytes: input iv length ++ * @ mac_bytes: mac data buffer length + * @ assoc_bytes: input associated data length + * @ state: operation result, denoted by WD error code + * @ cb: callback function pointer +@@ -72,11 +73,12 @@ struct wd_aead_req { + struct wd_datalist *list_dst; + void *dst; + }; ++ void *mac; + void *iv; + __u32 in_bytes; + __u32 out_bytes; +- __u32 out_buf_bytes; + __u16 iv_bytes; ++ __u16 mac_bytes; + __u16 assoc_bytes; + __u16 state; + __u8 data_fmt; +diff --git a/test/hisi_sec_test/test_hisi_sec.c b/test/hisi_sec_test/test_hisi_sec.c +index dda291d..6f27cd1 100644 +--- a/test/hisi_sec_test/test_hisi_sec.c ++++ b/test/hisi_sec_test/test_hisi_sec.c +@@ -279,6 +279,7 @@ static void dump_mem(int sgl, unsigned char *buf, size_t len) + if ((i + 1) % 8 == 0) + SEC_TST_PRT("\n"); + } ++ SEC_TST_PRT("\n"); + } + } + +@@ -2523,6 +2524,7 @@ static int sec_aead_sync_once(void) + unsigned long Perf = 0; + float speed, time_used; + unsigned long cnt = g_times; ++ __u16 mac_bytes; + __u16 auth_size; + __u16 in_size; + __u16 iv_len; +@@ -2553,8 +2555,7 @@ static int sec_aead_sync_once(void) + + /* should set key */ + dump_mem(WD_FLAT_BUF, (void *)tv->key, tv->klen); +- if (setup.cmode == WD_CIPHER_CCM || +- setup.cmode == WD_CIPHER_GCM) { ++ if (setup.cmode == WD_CIPHER_CCM || setup.cmode == WD_CIPHER_GCM) { + ret = wd_aead_set_ckey(h_sess, (const __u8*)tv->key, tv->klen); + if (ret) { + SEC_TST_PRT("aead sess set key failed!\n"); +@@ -2576,6 +2577,7 @@ static int sec_aead_sync_once(void) + } + + auth_size = (__u16)(tv->clen - tv->plen); ++ mac_bytes = auth_size; + ret = wd_aead_set_authsize(h_sess, auth_size); + if (ret) { + SEC_TST_PRT("set auth size fail, authsize: %u\n", auth_size); +@@ -2596,6 +2598,18 @@ static int sec_aead_sync_once(void) + } + SEC_TST_PRT("aead get max auth size: %u\n", ret); + ++ if (setup.cmode == WD_CIPHER_CCM || setup.cmode == WD_CIPHER_GCM) ++ mac_bytes = 16; ++ ++ req.mac = malloc(mac_bytes); ++ if (!req.mac) { ++ SEC_TST_PRT("req iv mem malloc failed!\n"); ++ ret = -ENOMEM; ++ goto out_key; ++ } ++ memset(req.mac, 0, mac_bytes); ++ req.mac_bytes = mac_bytes; ++ + if (g_direction == 0) + req.op_type = WD_CIPHER_ENCRYPTION_DIGEST; + else +@@ -2609,7 +2623,7 @@ static int sec_aead_sync_once(void) + } + if (in_size > BUFF_SIZE) { + SEC_TST_PRT("alloc in buffer block size too small!\n"); +- goto out_key; ++ goto out_mac; + } + unit_sz = cal_unit_sz(in_size, g_sgl_num); + void *src = create_buf(WD_FLAT_BUF, in_size, unit_sz); +@@ -2627,10 +2641,14 @@ static int sec_aead_sync_once(void) + req.in_bytes = tv->plen; + } else { + memcpy(src, tv->assoc, tv->alen); +- memcpy((src + req.assoc_bytes), tv->ctext, tv->clen); ++ memcpy(src + req.assoc_bytes, tv->ctext, tv->clen - auth_size); + req.in_bytes = tv->clen - auth_size; ++ memcpy(req.mac, tv->ctext + tv->clen - auth_size, auth_size); + } + ++ SEC_TST_PRT("mac addr src is:\n"); ++ dump_mem(0, req.mac, auth_size); ++ + req.src = create_buf(g_data_fmt, in_size, unit_sz); + if (!req.src) { + ret = -ENOMEM; +@@ -2643,21 +2661,19 @@ static int sec_aead_sync_once(void) + dump_mem(g_data_fmt, req.src, tv->alen + req.in_bytes); + + if (g_direction == 0) { +- req.out_bytes = req.assoc_bytes + tv->clen; ++ req.out_bytes = req.assoc_bytes + tv->clen - auth_size; + } else { + req.out_bytes = req.assoc_bytes + tv->plen; + } + +- req.out_buf_bytes = req.out_bytes + auth_size; + // alloc out buffer memory +- unit_sz = cal_unit_sz(req.out_buf_bytes, g_sgl_num); +- req.dst = create_buf(g_data_fmt, req.out_buf_bytes, unit_sz); ++ unit_sz = cal_unit_sz(req.out_bytes, g_sgl_num); ++ req.dst = create_buf(g_data_fmt, req.out_bytes, unit_sz); + if (!req.dst) { + ret = -ENOMEM; + goto out_dst; + } + +- // set iv + req.iv = malloc(AES_BLOCK_SIZE); + if (!req.iv) { + SEC_TST_PRT("req iv mem malloc failed!\n"); +@@ -2688,7 +2704,10 @@ static int sec_aead_sync_once(void) + SEC_TST_PRT("Pro-%d, thread_id-%d, speed:%0.3f ops, Perf: %ld KB/s\n", getpid(), + (int)syscall(__NR_gettid), speed, Perf); + ++ SEC_TST_PRT("aead dump out addr is:\n"); + dump_mem(g_data_fmt, req.dst, req.out_bytes); ++ SEC_TST_PRT("aead dump mac addr is:\n"); ++ dump_mem(0, req.mac, auth_size); + + free(req.iv); + out_iv: +@@ -2696,6 +2715,8 @@ out_iv: + out_dst: + free_buf(g_data_fmt, req.src); + out_src: ++out_mac: ++ free(req.mac); + out_key: + wd_aead_free_sess(h_sess); + out: +@@ -2827,6 +2848,7 @@ static int sec_aead_async_once(void) + static pthread_t send_td; + static pthread_t poll_td; + thread_data_d td_data; ++ __u16 mac_bytes; + __u16 auth_size; + __u16 in_size; + __u16 iv_len; +@@ -2857,8 +2879,7 @@ static int sec_aead_async_once(void) + + /* should set key */ + dump_mem(WD_FLAT_BUF, (void *)tv->key, tv->klen); +- if (setup.cmode == WD_CIPHER_CCM || +- setup.cmode == WD_CIPHER_GCM) { ++ if (setup.cmode == WD_CIPHER_CCM || setup.cmode == WD_CIPHER_GCM) { + ret = wd_aead_set_ckey(h_sess, (const __u8*)tv->key, tv->klen); + if (ret) { + SEC_TST_PRT("aead sess set key failed!\n"); +@@ -2880,6 +2901,7 @@ static int sec_aead_async_once(void) + } + + auth_size = (__u16)(tv->clen - tv->plen); ++ mac_bytes = auth_size; + ret = wd_aead_set_authsize(h_sess, auth_size); + if (ret) { + SEC_TST_PRT("set auth size fail, authsize: %u\n", auth_size); +@@ -2898,6 +2920,17 @@ static int sec_aead_async_once(void) + goto out_key; + } + SEC_TST_PRT("aead get max auth size: %u\n", ret); ++ if (setup.cmode == WD_CIPHER_CCM || setup.cmode == WD_CIPHER_GCM) ++ mac_bytes = 16; ++ ++ req.mac = malloc(mac_bytes); ++ if (!req.mac) { ++ SEC_TST_PRT("req iv mem malloc failed!\n"); ++ ret = -ENOMEM; ++ goto out_key; ++ } ++ memset(req.mac, 0, mac_bytes); ++ req.mac_bytes = mac_bytes; + + if (g_direction == 0) + req.op_type = WD_CIPHER_ENCRYPTION_DIGEST; +@@ -2908,7 +2941,7 @@ static int sec_aead_async_once(void) + in_size = tv->alen + tv->plen + auth_size; + if (in_size > BUFF_SIZE) { + SEC_TST_PRT("alloc in buffer block size too small!\n"); +- goto out_key; ++ goto out_mac; + } + req.assoc_bytes = tv->alen; + unit_sz = cal_unit_sz(BUFF_SIZE, g_sgl_num); +@@ -2931,15 +2964,15 @@ static int sec_aead_async_once(void) + req.in_bytes = tv->plen; + } else { + memcpy(src, tv->assoc, tv->alen); +- memcpy((src + tv->alen), tv->ctext, tv->clen); ++ memcpy(src + tv->alen, tv->ctext, tv->clen - auth_size); + req.in_bytes = tv->clen - auth_size; ++ memcpy(req.mac, tv->ctext + tv->clen - auth_size, auth_size); + } + +- + copy_mem(g_data_fmt, req.src, WD_FLAT_BUF, src, + (size_t)(req.in_bytes + tv->alen)); + free(src); +- SEC_TST_PRT("aead req src in--------->: %u\n", tv->alen + req.in_bytes); ++ SEC_TST_PRT("aead req alen---->: %u. in_bytes--->:%u\n", tv->alen, req.in_bytes); + dump_mem(g_data_fmt, req.src, tv->alen + req.in_bytes); + + // alloc out buffer memory +@@ -2949,7 +2982,6 @@ static int sec_aead_async_once(void) + goto out_dst; + } + +- req.out_buf_bytes = BUFF_SIZE; + if (g_direction == 0) + req.out_bytes = tv->alen + tv->clen; + else +@@ -3010,6 +3042,8 @@ out_iv: + out_dst: + free_buf(g_data_fmt, req.src); + out_src: ++out_mac: ++ free(req.mac); + out_key: + wd_aead_free_sess(h_sess); + out: +@@ -3026,6 +3060,7 @@ static int sec_aead_sync_multi(void) + struct wd_aead_req req; + static pthread_t sendtd[64]; + thread_data_d td_data; ++ __u16 mac_bytes; + __u16 auth_size; + __u16 in_size; + __u16 iv_len; +@@ -3056,8 +3091,7 @@ static int sec_aead_sync_multi(void) + + /* should set key */ + dump_mem(WD_FLAT_BUF, (void *)tv->key, tv->klen); +- if (setup.cmode == WD_CIPHER_CCM || +- setup.cmode == WD_CIPHER_GCM) { ++ if (setup.cmode == WD_CIPHER_CCM || setup.cmode == WD_CIPHER_GCM) { + ret = wd_aead_set_ckey(h_sess, (const __u8*)tv->key, tv->klen); + if (ret) { + SEC_TST_PRT("aead sess set key failed!\n"); +@@ -3079,6 +3113,7 @@ static int sec_aead_sync_multi(void) + } + + auth_size = (__u16)(tv->clen - tv->plen); ++ mac_bytes = auth_size; + ret = wd_aead_set_authsize(h_sess, auth_size); + if (ret) { + SEC_TST_PRT("set auth size fail, authsize: %u\n", auth_size); +@@ -3098,6 +3133,18 @@ static int sec_aead_sync_multi(void) + } + SEC_TST_PRT("aead get max auth size: %u\n", ret); + ++ if (setup.cmode == WD_CIPHER_CCM || setup.cmode == WD_CIPHER_GCM) ++ mac_bytes = 16; ++ ++ req.mac = malloc(mac_bytes); ++ if (!req.mac) { ++ SEC_TST_PRT("req iv mem malloc failed!\n"); ++ ret = -ENOMEM; ++ goto out_key; ++ } ++ memset(req.mac, 0, mac_bytes); ++ req.mac_bytes = mac_bytes; ++ + if (g_direction == 0) + req.op_type = WD_CIPHER_ENCRYPTION_DIGEST; + else +@@ -3108,7 +3155,7 @@ static int sec_aead_sync_multi(void) + in_size = tv->alen + tv->plen + auth_size; + if (in_size > BUFF_SIZE) { + SEC_TST_PRT("alloc in buffer block size too small!\n"); +- goto out_key; ++ goto out_mac; + } + unit_sz = cal_unit_sz(BUFF_SIZE, g_sgl_num); + void *src = create_buf(WD_FLAT_BUF, BUFF_SIZE, unit_sz); +@@ -3123,8 +3170,9 @@ static int sec_aead_sync_multi(void) + req.in_bytes = tv->plen; + } else { + memcpy(src, tv->assoc, tv->alen); +- memcpy((src + tv->alen), tv->ctext, tv->clen); ++ memcpy(src + tv->alen, tv->ctext, tv->clen - auth_size); + req.in_bytes = tv->clen - auth_size; ++ memcpy(req.mac, tv->ctext + tv->clen - auth_size, auth_size); + } + + req.src = create_buf(g_data_fmt, in_size, unit_sz); +@@ -3137,7 +3185,7 @@ static int sec_aead_sync_multi(void) + (size_t)(req.in_bytes + tv->alen)); + free(src); + +- SEC_TST_PRT("aead req src in--------->: %u\n", tv->alen + req.in_bytes); ++ SEC_TST_PRT("aead req src in>: alen:%u, input len:%d\n", tv->alen, req.in_bytes); + dump_mem(g_data_fmt, req.src, tv->alen + req.in_bytes); + + // alloc out buffer memory +@@ -3147,7 +3195,6 @@ static int sec_aead_sync_multi(void) + goto out_dst; + } + +- req.out_buf_bytes = BUFF_SIZE; + if (g_direction == 0) + req.out_bytes = tv->alen + tv->clen; + else +@@ -3175,6 +3222,7 @@ static int sec_aead_sync_multi(void) + td_data.recv_num = g_times; + td_data.sum_perf = 0; + ++ printf("%s, req->in_bytes:%d\n", __func__, req.in_bytes); + for (i = 0; i < g_thread_num; i++) { + ret = pthread_create(&sendtd[i], NULL, aead_sync_send_thread, &td_data); + if (ret) { +@@ -3200,6 +3248,8 @@ out_iv: + out_dst: + free_buf(g_data_fmt, req.src); + out_src: ++out_mac: ++ free(req.mac); + out_key: + wd_aead_free_sess(h_sess); + out: +@@ -3217,6 +3267,7 @@ static int sec_aead_async_multi(void) + static pthread_t send_td[64]; + static pthread_t poll_td; + thread_data_d td_data; ++ __u16 mac_bytes; + __u16 auth_size; + __u16 in_size; + __u16 iv_len; +@@ -3247,8 +3298,7 @@ static int sec_aead_async_multi(void) + + /* should set key */ + dump_mem(WD_FLAT_BUF, (void *)tv->key, tv->klen); +- if (setup.cmode == WD_CIPHER_CCM || +- setup.cmode == WD_CIPHER_GCM) { ++ if (setup.cmode == WD_CIPHER_CCM || setup.cmode == WD_CIPHER_GCM) { + ret = wd_aead_set_ckey(h_sess, (const __u8*)tv->key, tv->klen); + if (ret) { + SEC_TST_PRT("aead sess set key failed!\n"); +@@ -3270,6 +3320,7 @@ static int sec_aead_async_multi(void) + } + + auth_size = (__u16)(tv->clen - tv->plen); ++ mac_bytes = auth_size; + ret = wd_aead_set_authsize(h_sess, auth_size); + if (ret) { + SEC_TST_PRT("set auth size fail, authsize: %u\n", auth_size); +@@ -3289,6 +3340,15 @@ static int sec_aead_async_multi(void) + } + SEC_TST_PRT("aead get max auth size: %u\n", ret); + ++ if (setup.cmode == WD_CIPHER_CCM || setup.cmode == WD_CIPHER_GCM) ++ mac_bytes = 16; ++ ++ req.mac = malloc(mac_bytes); ++ if (req.mac == NULL) ++ goto out; ++ memset(req.mac, 0, mac_bytes); ++ req.mac_bytes = mac_bytes; ++ + if (g_direction == 0) + req.op_type = WD_CIPHER_ENCRYPTION_DIGEST; + else +@@ -3321,8 +3381,9 @@ static int sec_aead_async_multi(void) + req.in_bytes = tv->plen; + } else { + memcpy(src, tv->assoc, tv->alen); +- memcpy((src + tv->alen), tv->ctext, tv->clen); ++ memcpy(src + tv->alen, tv->ctext, tv->clen - auth_size); + req.in_bytes = tv->clen - auth_size; ++ memcpy(req.mac, tv->ctext + (tv->clen - auth_size), auth_size); + } + + copy_mem(g_data_fmt, req.src, WD_FLAT_BUF, src, +@@ -3338,9 +3399,8 @@ static int sec_aead_async_multi(void) + ret = -1; + goto out; + } +- req.out_buf_bytes = BUFF_SIZE; + if (g_direction == 0) +- req.out_bytes = tv->alen + tv->clen; ++ req.out_bytes = tv->alen + tv->clen - auth_size; + else + req.out_bytes = tv->alen + tv->plen; + +@@ -3396,6 +3456,8 @@ static int sec_aead_async_multi(void) + + dump_mem(g_data_fmt, req.dst, req.out_bytes); + out: ++ if (req.mac) ++ free(req.mac); + if (req.src) + free_buf(g_data_fmt, req.src); + if (req.dst) +diff --git a/uadk_tool/sec_uadk_benchmark.c b/uadk_tool/sec_uadk_benchmark.c +index 40ba227..d68ac25 100644 +--- a/uadk_tool/sec_uadk_benchmark.c ++++ b/uadk_tool/sec_uadk_benchmark.c +@@ -24,6 +24,7 @@ struct thread_pool { + struct bd_pool *pool; + u8 *iv; + u8 *key; ++ u8 *mac; + } g_uadk_pool; + + typedef struct uadk_thread_res { +@@ -475,6 +476,7 @@ int init_uadk_bd_pool(void) + + g_uadk_pool.iv = malloc(g_thread_num * MAX_IVK_LENTH * sizeof(char)); + g_uadk_pool.key = malloc(g_thread_num * MAX_IVK_LENTH * sizeof(char)); ++ g_uadk_pool.mac = malloc(g_thread_num * MAX_IVK_LENTH * sizeof(char)); + + g_uadk_pool.pool = malloc(g_thread_num * sizeof(struct bd_pool)); + if (!g_uadk_pool.pool) { +@@ -611,9 +613,10 @@ static void *sec_uadk_async_run(void *arg) + struct wd_aead_req areq; + struct wd_digest_req dreq; + struct bd_pool *uadk_pool; +- u8 *priv_iv, *priv_key; ++ u8 *priv_iv, *priv_key, *priv_mac; + int try_cnt = 0; + handle_t h_sess; ++ u32 auth_size = 16; + u32 count = 0; + int ret, i = 0; + +@@ -623,6 +626,7 @@ static void *sec_uadk_async_run(void *arg) + uadk_pool = &g_uadk_pool.pool[pdata->td_id]; + priv_iv = &g_uadk_pool.iv[pdata->td_id]; + priv_key = &g_uadk_pool.key[pdata->td_id]; ++ priv_mac = &g_uadk_pool.mac[pdata->td_id]; + + memset(priv_iv, DEF_IVK_DATA, MAX_IVK_LENTH); + memset(priv_key, DEF_IVK_DATA, MAX_IVK_LENTH); +@@ -687,7 +691,7 @@ static void *sec_uadk_async_run(void *arg) + wd_aead_free_sess(h_sess); + return NULL; + } +- ret = wd_aead_set_authsize(h_sess, 16); ++ ret = wd_aead_set_authsize(h_sess, auth_size); + if (ret) { + SEC_TST_PRT("set auth size fail, authsize: 16\n"); + wd_aead_free_sess(h_sess); +@@ -696,16 +700,15 @@ static void *sec_uadk_async_run(void *arg) + + areq.op_type = pdata->optype; + areq.iv = priv_iv; // aead IV need update with param ++ areq.mac = priv_mac; + areq.iv_bytes = pdata->ivsize; ++ areq.mac_bytes = auth_size; + areq.assoc_bytes = 16; + areq.in_bytes = g_pktlen; +- if (areq.op_type) {// decrypto ++ if (areq.op_type)// decrypto + areq.out_bytes = g_pktlen + 16; // aadsize = 16; +- areq.out_buf_bytes = areq.out_bytes + 16; // authsize = 16 +- } else { ++ else + areq.out_bytes = g_pktlen + 32; // aadsize + authsize = 32; +- areq.out_buf_bytes = areq.out_bytes + 32; +- } + + areq.data_fmt = 0; + areq.state = 0; +@@ -795,8 +798,9 @@ static void *sec_uadk_sync_run(void *arg) + struct wd_aead_req areq; + struct wd_digest_req dreq; + struct bd_pool *uadk_pool; +- u8 *priv_iv, *priv_key; ++ u8 *priv_iv, *priv_key, *priv_mac; + handle_t h_sess; ++ u32 auth_size = 16; + u32 count = 0; + int ret, i = 0; + +@@ -806,6 +810,7 @@ static void *sec_uadk_sync_run(void *arg) + uadk_pool = &g_uadk_pool.pool[pdata->td_id]; + priv_iv = &g_uadk_pool.iv[pdata->td_id]; + priv_key = &g_uadk_pool.key[pdata->td_id]; ++ priv_mac = &g_uadk_pool.mac[pdata->td_id]; + + memset(priv_iv, DEF_IVK_DATA, MAX_IVK_LENTH); + memset(priv_key, DEF_IVK_DATA, MAX_IVK_LENTH); +@@ -860,7 +865,7 @@ static void *sec_uadk_sync_run(void *arg) + wd_aead_free_sess(h_sess); + return NULL; + } +- ret = wd_aead_set_authsize(h_sess, 16); ++ ret = wd_aead_set_authsize(h_sess, auth_size); + if (ret) { + SEC_TST_PRT("set auth size fail, authsize: 16\n"); + wd_aead_free_sess(h_sess); +@@ -869,16 +874,16 @@ static void *sec_uadk_sync_run(void *arg) + + areq.op_type = pdata->optype; + areq.iv = priv_iv; // aead IV need update with param ++ areq.mac = priv_mac; ++ areq.mac_bytes = 16; + areq.iv_bytes = pdata->ivsize; + areq.assoc_bytes = 16; + areq.in_bytes = g_pktlen; +- if (areq.op_type) {// decrypto ++ areq.mac_bytes = auth_size; ++ if (areq.op_type)// decrypto + areq.out_bytes = g_pktlen + 16; // aadsize = 16; +- areq.out_buf_bytes = areq.out_bytes + 16; // authsize = 16 +- } else { ++ else + areq.out_bytes = g_pktlen + 32; // aadsize + authsize = 32; +- areq.out_buf_bytes = areq.out_bytes + 32; +- } + + areq.data_fmt = 0; + areq.state = 0; +diff --git a/wd_aead.c b/wd_aead.c +index ebad440..670bb33 100644 +--- a/wd_aead.c ++++ b/wd_aead.c +@@ -305,6 +305,33 @@ void wd_aead_free_sess(handle_t h_sess) + free(sess); + } + ++static int aead_mac_param_check(struct wd_aead_sess *sess, ++ struct wd_aead_req *req) ++{ ++ int ret = 0; ++ ++ switch (sess->cmode) { ++ case WD_CIPHER_CBC: ++ if (req->mac_bytes < g_aead_mac_len[sess->dalg]) { ++ WD_ERR("failed to check cbc-hmac mac buffer length!\n"); ++ ret = -WD_EINVAL; ++ } ++ break; ++ case WD_CIPHER_CCM: ++ case WD_CIPHER_GCM: ++ if (req->mac_bytes < WD_AEAD_CCM_GCM_MAX) { ++ WD_ERR("failed to check CCM or GCM mac buffer length!\n"); ++ ret = -WD_EINVAL; ++ } ++ break; ++ default: ++ ret = -WD_EINVAL; ++ WD_ERR("set the aead cmode is error!\n"); ++ } ++ ++ return ret; ++} ++ + static int aead_param_check(struct wd_aead_sess *sess, + struct wd_aead_req *req) + { +@@ -328,33 +355,23 @@ static int aead_param_check(struct wd_aead_sess *sess, + } + + if (unlikely(req->iv_bytes != get_iv_block_size(sess->cmode))) { +- WD_ERR("failed to check aead IV length!\n"); ++ WD_ERR("failed to check aead IV length, size:%u\n", req->iv_bytes); + return -WD_EINVAL; + } + +- if (unlikely(req->out_buf_bytes < req->out_bytes)) { +- WD_ERR("failed to check aead out buffer length!\n"); +- return -WD_EINVAL; +- } +- +- if (unlikely(req->op_type == WD_CIPHER_ENCRYPTION_DIGEST && +- req->out_buf_bytes < (req->out_bytes + sess->auth_bytes))) { +- WD_ERR("failed to check aead type or mac length!\n"); ++ ret = aead_mac_param_check(sess, req); ++ if (unlikely(ret)) + return -WD_EINVAL; +- } + + if (req->data_fmt == WD_SGL_BUF) { + len = req->in_bytes + req->assoc_bytes; +- if (req->op_type == WD_CIPHER_DECRYPTION_DIGEST) +- len += sess->auth_bytes; +- + ret = wd_check_datalist(req->list_src, len); + if (unlikely(ret)) { + WD_ERR("failed to check the src datalist!\n"); + return -WD_EINVAL; + } + +- ret = wd_check_datalist(req->list_dst, req->out_buf_bytes); ++ ret = wd_check_datalist(req->list_dst, req->out_bytes); + if (unlikely(ret)) { + WD_ERR("failed to check the dst datalist!\n"); + return -WD_EINVAL; +@@ -480,6 +497,7 @@ static void fill_request_msg(struct wd_aead_msg *msg, struct wd_aead_req *req, + msg->iv = req->iv; + msg->iv_bytes = req->iv_bytes; + msg->assoc_bytes = req->assoc_bytes; ++ msg->mac = req->mac; + msg->auth_bytes = sess->auth_bytes; + msg->data_fmt = req->data_fmt; + } +-- +2.25.1 + diff --git a/0041-cipher-add-semi-weak-keys-checking.patch b/0041-cipher-add-semi-weak-keys-checking.patch new file mode 100644 index 0000000..d6d2b00 --- /dev/null +++ b/0041-cipher-add-semi-weak-keys-checking.patch @@ -0,0 +1,80 @@ +From e191549317c08e340b9406bf2958868b1f119df2 Mon Sep 17 00:00:00 2001 +From: Kai Ye +Date: Thu, 13 Jan 2022 16:33:37 +0800 +Subject: [PATCH 44/53] cipher: add semi-weak keys checking + +Add semi-weak keys checking based on OpenSSL. it will improve the +security of the system. + +Signed-off-by: Kai Ye +--- + wd_cipher.c | 30 +++++++++++++++++++++++------- + 1 file changed, 23 insertions(+), 7 deletions(-) + +diff --git a/wd_cipher.c b/wd_cipher.c +index 9c1f98c..85f7e65 100644 +--- a/wd_cipher.c ++++ b/wd_cipher.c +@@ -19,15 +19,31 @@ + #define DES3_3KEY_SIZE (3 * DES_KEY_SIZE) + + #define WD_POOL_MAX_ENTRIES 1024 +-#define DES_WEAK_KEY_NUM 4 ++#define DES_WEAK_KEY_NUM 16 + #define MAX_RETRY_COUNTS 200000000 + + #define POLL_SIZE 100000 + #define POLL_TIME 1000 + +-static __u64 des_weak_key[DES_WEAK_KEY_NUM] = { +- 0x0101010101010101, 0xFEFEFEFEFEFEFEFE, +- 0xE0E0E0E0F1F1F1F1, 0x1F1F1F1F0E0E0E0E ++static const unsigned char des_weak_keys[DES_WEAK_KEY_NUM][DES_KEY_SIZE] = { ++ /* weak keys */ ++ {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}, ++ {0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE}, ++ {0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E}, ++ {0xE0, 0xE0, 0xE0, 0xE0, 0xF1, 0xF1, 0xF1, 0xF1}, ++ /* semi-weak keys */ ++ {0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE}, ++ {0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01}, ++ {0x1F, 0xE0, 0x1F, 0xE0, 0x0E, 0xF1, 0x0E, 0xF1}, ++ {0xE0, 0x1F, 0xE0, 0x1F, 0xF1, 0x0E, 0xF1, 0x0E}, ++ {0x01, 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1}, ++ {0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1, 0x01}, ++ {0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E, 0xFE}, ++ {0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E}, ++ {0x01, 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E}, ++ {0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E, 0x01}, ++ {0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE}, ++ {0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1} + }; + + struct wd_cipher_setting { +@@ -81,12 +97,12 @@ void wd_cipher_set_driver(struct wd_cipher_driver *drv) + wd_cipher_setting.driver = drv; + } + +-static bool is_des_weak_key(const __u64 *key) ++static bool is_des_weak_key(const __u8 *key) + { + int i; + + for (i = 0; i < DES_WEAK_KEY_NUM; i++) { +- if (*key == des_weak_key[i]) ++ if (memcmp(des_weak_keys[i], key, DES_KEY_SIZE) == 0) + return true; + } + +@@ -173,7 +189,7 @@ int wd_cipher_set_key(handle_t h_sess, const __u8 *key, __u32 key_len) + WD_ERR("cipher set key input key length err!\n"); + return -WD_EINVAL; + } +- if (sess->alg == WD_CIPHER_DES && is_des_weak_key((__u64 *)key)) { ++ if (sess->alg == WD_CIPHER_DES && is_des_weak_key(key)) { + WD_ERR("input des key is weak key!\n"); + return -WD_EINVAL; + } +-- +2.25.1 + diff --git a/0042-uadk-ioctl-return-result-should-be-printed.patch b/0042-uadk-ioctl-return-result-should-be-printed.patch new file mode 100644 index 0000000..bf64a06 --- /dev/null +++ b/0042-uadk-ioctl-return-result-should-be-printed.patch @@ -0,0 +1,41 @@ +From ef361818b1a67a6540ea4b0d2538090eea56863e Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Sat, 15 Jan 2022 16:53:58 +0800 +Subject: [PATCH 45/53] uadk: ioctl return result should be printed + +ioctl return result may be discarded, +it is useful to debug kernel error, +so it should be printed directly. + +Signed-off-by: Wenkai Lin +--- + wd.c | 6 ++++-- + 1 file changed, 4 insertions(+), 2 deletions(-) + +diff --git a/wd.c b/wd.c +index 787d74b..6bbf677 100644 +--- a/wd.c ++++ b/wd.c +@@ -386,7 +386,8 @@ int wd_ctx_start(handle_t h_ctx) + + ret = wd_ctx_set_io_cmd(h_ctx, UACCE_CMD_START, NULL); + if (ret) +- WD_ERR("Fail to start on %s (%d).\n", ctx->dev_path, -errno); ++ WD_ERR("Fail to start on %s (%d), ret = %d!\n", ++ ctx->dev_path, -errno, ret); + + return ret; + } +@@ -401,7 +402,8 @@ int wd_release_ctx_force(handle_t h_ctx) + + ret = wd_ctx_set_io_cmd(h_ctx, UACCE_CMD_PUT_Q, NULL); + if (ret) +- WD_ERR("Fail to stop on %s (%d).\n", ctx->dev_path, -errno); ++ WD_ERR("Fail to stop on %s (%d), ret = %d!\n", ++ ctx->dev_path, -errno, ret); + + return ret; + } +-- +2.25.1 + diff --git a/0043-uadk-fix-environment-uninit-repeatly-error.patch b/0043-uadk-fix-environment-uninit-repeatly-error.patch new file mode 100644 index 0000000..bb95519 --- /dev/null +++ b/0043-uadk-fix-environment-uninit-repeatly-error.patch @@ -0,0 +1,412 @@ +From 282d7d06d0585d117ab62263ab3722950e9693f0 Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Sat, 15 Jan 2022 16:53:59 +0800 +Subject: [PATCH 46/53] uadk: fix environment uninit repeatly error + +use wd_uninit_env_config to restore wd_init_env_config do, +move setting gloab environment config to wd_init_env_config. +function should not be set to NULL, because it may used to +uninit resource. + +Signed-off-by: Wenkai Lin +--- + include/wd_util.h | 7 ++-- + wd_aead.c | 4 +-- + wd_cipher.c | 4 +-- + wd_comp.c | 4 +-- + wd_dh.c | 4 +-- + wd_digest.c | 4 +-- + wd_ecc.c | 4 +-- + wd_rsa.c | 4 +-- + wd_util.c | 88 ++++++++++++++++++++++++++++++----------------- + 9 files changed, 74 insertions(+), 49 deletions(-) + +diff --git a/include/wd_util.h b/include/wd_util.h +index ef95907..2d3c1e4 100644 +--- a/include/wd_util.h ++++ b/include/wd_util.h +@@ -66,8 +66,6 @@ struct wd_env_config { + struct wd_env_config_per_numa *config_per_numa; + /* Let's make it as a gobal config, not per numa */ + bool enable_internal_poll; +- int (*alg_poll_ctx)(__u32, __u32, __u32 *); +- void (*alg_uninit)(void); + + /* resource config */ + struct wd_sched *sched; +@@ -263,8 +261,11 @@ int wd_alg_env_init(struct wd_env_config *config, + * wd_alg_env_uninit() - uninit specific wd algorithm environment configuration. + * @config: Pointer of wd_env_config which is used to store environment + * variable information. ++ * @ops: Define functions which will be used by specific wd algorithm ++ * environment init. + */ +-void wd_alg_env_uninit(struct wd_env_config *env_config); ++void wd_alg_env_uninit(struct wd_env_config *env_config, ++ const struct wd_alg_ops *ops); + + /* + * wd_add_task_to_async_queue() - Add an async request to its related async +diff --git a/wd_aead.c b/wd_aead.c +index 670bb33..32d06ec 100644 +--- a/wd_aead.c ++++ b/wd_aead.c +@@ -716,7 +716,7 @@ int wd_aead_env_init(struct wd_sched *sched) + + void wd_aead_env_uninit(void) + { +- return wd_alg_env_uninit(&wd_aead_env_config); ++ return wd_alg_env_uninit(&wd_aead_env_config, &wd_aead_ops); + } + + int wd_aead_ctx_num_init(__u32 node, __u32 type, __u32 num, __u8 mode) +@@ -734,7 +734,7 @@ int wd_aead_ctx_num_init(__u32 node, __u32 type, __u32 num, __u8 mode) + + void wd_aead_ctx_num_uninit(void) + { +- return wd_alg_env_uninit(&wd_aead_env_config); ++ return wd_alg_env_uninit(&wd_aead_env_config, &wd_aead_ops); + } + + int wd_aead_get_env_param(__u32 node, __u32 type, __u32 mode, +diff --git a/wd_cipher.c b/wd_cipher.c +index 85f7e65..5be3123 100644 +--- a/wd_cipher.c ++++ b/wd_cipher.c +@@ -634,7 +634,7 @@ int wd_cipher_env_init(struct wd_sched *sched) + + void wd_cipher_env_uninit(void) + { +- return wd_alg_env_uninit(&wd_cipher_env_config); ++ return wd_alg_env_uninit(&wd_cipher_env_config, &wd_cipher_ops); + } + + int wd_cipher_ctx_num_init(__u32 node, __u32 type, __u32 num, __u8 mode) +@@ -652,7 +652,7 @@ int wd_cipher_ctx_num_init(__u32 node, __u32 type, __u32 num, __u8 mode) + + void wd_cipher_ctx_num_uninit(void) + { +- return wd_alg_env_uninit(&wd_cipher_env_config); ++ return wd_alg_env_uninit(&wd_cipher_env_config, &wd_cipher_ops); + } + + int wd_cipher_get_env_param(__u32 node, __u32 type, __u32 mode, +diff --git a/wd_comp.c b/wd_comp.c +index fc355a9..7868551 100644 +--- a/wd_comp.c ++++ b/wd_comp.c +@@ -775,7 +775,7 @@ int wd_comp_env_init(struct wd_sched *sched) + + void wd_comp_env_uninit(void) + { +- return wd_alg_env_uninit(&wd_comp_env_config); ++ return wd_alg_env_uninit(&wd_comp_env_config, &wd_comp_ops); + } + + int wd_comp_ctx_num_init(__u32 node, __u32 type, __u32 num, __u8 mode) +@@ -798,7 +798,7 @@ int wd_comp_ctx_num_init(__u32 node, __u32 type, __u32 num, __u8 mode) + + void wd_comp_ctx_num_uninit(void) + { +- return wd_alg_env_uninit(&wd_comp_env_config); ++ return wd_alg_env_uninit(&wd_comp_env_config, &wd_comp_ops); + } + + int wd_comp_get_env_param(__u32 node, __u32 type, __u32 mode, +diff --git a/wd_dh.c b/wd_dh.c +index 7b849ac..1784099 100644 +--- a/wd_dh.c ++++ b/wd_dh.c +@@ -564,7 +564,7 @@ int wd_dh_env_init(struct wd_sched *sched) + + void wd_dh_env_uninit(void) + { +- return wd_alg_env_uninit(&wd_dh_env_config); ++ return wd_alg_env_uninit(&wd_dh_env_config, &wd_dh_ops); + } + + int wd_dh_ctx_num_init(__u32 node, __u32 type, __u32 num, __u8 mode) +@@ -582,7 +582,7 @@ int wd_dh_ctx_num_init(__u32 node, __u32 type, __u32 num, __u8 mode) + + void wd_dh_ctx_num_uninit(void) + { +- return wd_alg_env_uninit(&wd_dh_env_config); ++ return wd_alg_env_uninit(&wd_dh_env_config, &wd_dh_ops); + } + + int wd_dh_get_env_param(__u32 node, __u32 type, __u32 mode, +diff --git a/wd_digest.c b/wd_digest.c +index 2b3661d..525d6a9 100644 +--- a/wd_digest.c ++++ b/wd_digest.c +@@ -525,7 +525,7 @@ int wd_digest_env_init(struct wd_sched *sched) + + void wd_digest_env_uninit(void) + { +- return wd_alg_env_uninit(&wd_digest_env_config); ++ return wd_alg_env_uninit(&wd_digest_env_config, &wd_digest_ops); + } + + int wd_digest_ctx_num_init(__u32 node, __u32 type, __u32 num, __u8 mode) +@@ -543,7 +543,7 @@ int wd_digest_ctx_num_init(__u32 node, __u32 type, __u32 num, __u8 mode) + + void wd_digest_ctx_num_uninit(void) + { +- return wd_alg_env_uninit(&wd_digest_env_config); ++ return wd_alg_env_uninit(&wd_digest_env_config, &wd_digest_ops); + } + + int wd_digest_get_env_param(__u32 node, __u32 type, __u32 mode, +diff --git a/wd_ecc.c b/wd_ecc.c +index e37fb39..e324473 100644 +--- a/wd_ecc.c ++++ b/wd_ecc.c +@@ -2286,7 +2286,7 @@ int wd_ecc_env_init(struct wd_sched *sched) + + void wd_ecc_env_uninit(void) + { +- return wd_alg_env_uninit(&wd_ecc_env_config); ++ return wd_alg_env_uninit(&wd_ecc_env_config, &wd_ecc_ops); + } + + int wd_ecc_ctx_num_init(__u32 node, __u32 type, __u32 num, __u8 mode) +@@ -2304,7 +2304,7 @@ int wd_ecc_ctx_num_init(__u32 node, __u32 type, __u32 num, __u8 mode) + + void wd_ecc_ctx_num_uninit(void) + { +- return wd_alg_env_uninit(&wd_ecc_env_config); ++ return wd_alg_env_uninit(&wd_ecc_env_config, &wd_ecc_ops); + } + + int wd_ecc_get_env_param(__u32 node, __u32 type, __u32 mode, +diff --git a/wd_rsa.c b/wd_rsa.c +index b6cc0d1..1f911b4 100644 +--- a/wd_rsa.c ++++ b/wd_rsa.c +@@ -1160,7 +1160,7 @@ int wd_rsa_env_init(struct wd_sched *sched) + + void wd_rsa_env_uninit(void) + { +- return wd_alg_env_uninit(&wd_rsa_env_config); ++ return wd_alg_env_uninit(&wd_rsa_env_config, &wd_rsa_ops); + } + + int wd_rsa_ctx_num_init(__u32 node, __u32 type, __u32 num, __u8 mode) +@@ -1178,7 +1178,7 @@ int wd_rsa_ctx_num_init(__u32 node, __u32 type, __u32 num, __u8 mode) + + void wd_rsa_ctx_num_uninit(void) + { +- return wd_alg_env_uninit(&wd_rsa_env_config); ++ return wd_alg_env_uninit(&wd_rsa_env_config, &wd_rsa_ops); + } + + int wd_rsa_get_env_param(__u32 node, __u32 type, __u32 mode, +diff --git a/wd_util.c b/wd_util.c +index 6cae768..38599c2 100644 +--- a/wd_util.c ++++ b/wd_util.c +@@ -868,11 +868,27 @@ static int wd_parse_ctx_attr(struct wd_env_config *env_config, + } + + static int wd_init_env_config(struct wd_env_config *config, +- struct wd_ctx_attr *attr) ++ struct wd_ctx_attr *attr, ++ const struct wd_alg_ops *ops, ++ const struct wd_config_variable *table, ++ __u32 table_size) + { ++ config->op_type_num = ops->op_type_num; ++ config->table_size = table_size; ++ config->table = table; ++ + return attr ? wd_parse_ctx_attr(config, attr) : wd_parse_env(config); + } + ++static void wd_uninit_env_config(struct wd_env_config *config) ++{ ++ config->op_type_num = 0; ++ config->table_size = 0; ++ config->table = NULL; ++ ++ wd_free_env(config); ++} ++ + static __u8 get_ctx_mode(struct wd_env_config_per_numa *config, int idx) + { + struct wd_ctx_range **ctx_table = config->ctx_table; +@@ -1051,7 +1067,8 @@ static int wd_sched_fill_table(struct wd_env_config_per_numa *config_numa, + return 0; + } + +-static int wd_init_sched_config(struct wd_env_config *config) ++static int wd_init_sched_config(struct wd_env_config *config, ++ void *alg_poll_ctx) + { + struct wd_env_config_per_numa *config_numa; + int i, j, ret, max_node, type_num; +@@ -1063,7 +1080,7 @@ static int wd_init_sched_config(struct wd_env_config *config) + return -WD_EINVAL; + + if (!config->enable_internal_poll) +- func = config->alg_poll_ctx; ++ func = alg_poll_ctx; + + config->internal_sched = false; + type_num = config->op_type_num; +@@ -1340,7 +1357,8 @@ static void wd_uninit_one_task_queue(struct async_task_queue *task_queue) + } + + static int wd_init_async_polling_thread_per_numa(struct wd_env_config *config, +- struct wd_env_config_per_numa *config_numa) ++ struct wd_env_config_per_numa *config_numa, ++ void *alg_poll_ctx) + { + struct async_task_queue *task_queue, *queue_head; + int i, j, ret; +@@ -1365,7 +1383,7 @@ static int wd_init_async_polling_thread_per_numa(struct wd_env_config *config, + + task_queue = queue_head; + for (i = 0; i < num; task_queue++, i++) { +- ret = wd_init_one_task_queue(task_queue, config->alg_poll_ctx); ++ ret = wd_init_one_task_queue(task_queue, alg_poll_ctx); + if (ret) { + for (j = 0; j < i; task_queue++, j++) + wd_uninit_one_task_queue(task_queue); +@@ -1386,6 +1404,9 @@ static void wd_uninit_async_polling_thread_per_numa(struct wd_env_config *cfg, + double num; + int i; + ++ if (!config_numa || !config_numa->async_task_queue_array) ++ return; ++ + head = config_numa->async_task_queue_array; + task_queue = head; + num = fmin(config_numa->async_poll_num, config_numa->async_ctx_num); +@@ -1396,7 +1417,8 @@ static void wd_uninit_async_polling_thread_per_numa(struct wd_env_config *cfg, + config_numa->async_task_queue_array = NULL; + } + +-static int wd_init_async_polling_thread(struct wd_env_config *config) ++static int wd_init_async_polling_thread(struct wd_env_config *config, ++ void *alg_poll_ctx) + { + struct wd_env_config_per_numa *config_numa; + int i, ret; +@@ -1405,12 +1427,19 @@ static int wd_init_async_polling_thread(struct wd_env_config *config) + return 0; + + FOREACH_NUMA(i, config, config_numa) { +- ret = wd_init_async_polling_thread_per_numa(config, config_numa); ++ ret = wd_init_async_polling_thread_per_numa(config, config_numa, ++ alg_poll_ctx); + if (ret) +- return ret; ++ goto out; + } + + return 0; ++ ++out: ++ FOREACH_NUMA(i, config, config_numa) ++ wd_uninit_async_polling_thread_per_numa(config, config_numa); ++ ++ return ret; + } + + static void wd_uninit_async_polling_thread(struct wd_env_config *config) +@@ -1434,7 +1463,7 @@ static int wd_init_resource(struct wd_env_config *config, + if (ret) + return ret; + +- ret = wd_init_sched_config(config); ++ ret = wd_init_sched_config(config, ops->alg_poll_ctx); + if (ret) + goto err_uninit_ctx; + +@@ -1442,7 +1471,7 @@ static int wd_init_resource(struct wd_env_config *config, + if (ret) + goto err_uninit_sched; + +- ret = wd_init_async_polling_thread(config); ++ ret = wd_init_async_polling_thread(config, ops->alg_poll_ctx); + if (ret) + goto err_uninit_alg; + +@@ -1461,13 +1490,19 @@ err_uninit_ctx: + return ret; + } + +-static void wd_uninit_resource(struct wd_env_config *config) ++static void wd_uninit_resource(struct wd_env_config *config, ++ const struct wd_alg_ops *ops) + { + wd_uninit_async_polling_thread(config); +- config->alg_uninit(); +- if (config->internal_sched) ++ ops->alg_uninit(); ++ ++ if (config->internal_sched) { + wd_uninit_sched_config(config->sched); ++ config->sched = NULL; ++ } ++ + wd_free_ctx(config->ctx_config); ++ config->ctx_config = NULL; + } + + int wd_alg_env_init(struct wd_env_config *env_config, +@@ -1478,43 +1513,32 @@ int wd_alg_env_init(struct wd_env_config *env_config, + { + int ret; + +- env_config->op_type_num = ops->op_type_num; +- env_config->alg_poll_ctx = ops->alg_poll_ctx; +- env_config->table = table; +- env_config->table_size = table_size; +- + ret = wd_alloc_numa(env_config, ops); + if (ret) + return ret; + +- ret = wd_init_env_config(env_config, ctx_attr); ++ ret = wd_init_env_config(env_config, ctx_attr, ops, table, table_size); + if (ret) + goto free_numa; + + ret = wd_init_resource(env_config, ops); + if (ret) +- goto free_env; +- +- /* Use alg_uninit as a sign of initialization complete */ +- env_config->alg_uninit = ops->alg_uninit; ++ goto uninit_env_config; + + return 0; + +-free_env: +- wd_free_env(env_config); ++uninit_env_config: ++ wd_uninit_env_config(env_config); + free_numa: + wd_free_numa(env_config); + return ret; + } + +-void wd_alg_env_uninit(struct wd_env_config *env_config) ++void wd_alg_env_uninit(struct wd_env_config *env_config, ++ const struct wd_alg_ops *ops) + { +- /* Check whether the initialization is complete */ +- if (!env_config->alg_uninit) +- return; +- +- wd_uninit_resource(env_config); +- wd_free_env(env_config); ++ wd_uninit_resource(env_config, ops); ++ wd_uninit_env_config(env_config); + wd_free_numa(env_config); + } + +-- +2.25.1 + diff --git a/0044-uadk-fix-wd_free_ctx-and-wd_uninit_sched_config.patch b/0044-uadk-fix-wd_free_ctx-and-wd_uninit_sched_config.patch new file mode 100644 index 0000000..bda682b --- /dev/null +++ b/0044-uadk-fix-wd_free_ctx-and-wd_uninit_sched_config.patch @@ -0,0 +1,140 @@ +From e4a3312ea000abb796d513c59a8ae10dd9ef605b Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Sat, 15 Jan 2022 16:54:00 +0800 +Subject: [PATCH 47/53] uadk: fix wd_free_ctx and wd_uninit_sched_config + +wd_free_ctx and wd_uninit_sched_config not use struct wd_env_config +as an input parameter, they need to clear wd_env_config member outside, +so optimize it to set null within the function. + +Signed-off-by: Wenkai Lin +--- + wd_util.c | 51 ++++++++++++++++++++++++--------------------------- + 1 file changed, 24 insertions(+), 27 deletions(-) + +diff --git a/wd_util.c b/wd_util.c +index 38599c2..8ad2bd0 100644 +--- a/wd_util.c ++++ b/wd_util.c +@@ -1027,14 +1027,18 @@ err_free_ctx_config: + return ret; + } + +-static void wd_free_ctx(struct wd_ctx_config *ctx_config) ++static void wd_free_ctx(struct wd_env_config *config) + { +- if (!ctx_config) ++ struct wd_ctx_config *ctx_config; ++ ++ if (!config->ctx_config) + return; + ++ ctx_config = config->ctx_config; + wd_put_wd_ctx(ctx_config, ctx_config->ctx_num); + free(ctx_config->ctxs); + free(ctx_config); ++ config->ctx_config = NULL; + } + + static int wd_sched_fill_table(struct wd_env_config_per_numa *config_numa, +@@ -1067,14 +1071,23 @@ static int wd_sched_fill_table(struct wd_env_config_per_numa *config_numa, + return 0; + } + ++static void wd_uninit_sched_config(struct wd_env_config *config) ++{ ++ if (!config->sched || !config->internal_sched) ++ return; ++ ++ wd_sched_rr_release(config->sched); ++ config->sched = NULL; ++} ++ + static int wd_init_sched_config(struct wd_env_config *config, + void *alg_poll_ctx) + { + struct wd_env_config_per_numa *config_numa; + int i, j, ret, max_node, type_num; +- struct wd_sched *sched; + void *func = NULL; + ++ type_num = config->op_type_num; + max_node = numa_max_node() + 1; + if (max_node <= 0) + return -WD_EINVAL; +@@ -1083,7 +1096,6 @@ static int wd_init_sched_config(struct wd_env_config *config, + func = alg_poll_ctx; + + config->internal_sched = false; +- type_num = config->op_type_num; + if (!config->sched) { + WD_ERR("no sched is specified, alloc a default sched!\n"); + config->sched = wd_sched_rr_alloc(SCHED_POLICY_RR, type_num, +@@ -1094,13 +1106,12 @@ static int wd_init_sched_config(struct wd_env_config *config, + config->internal_sched = true; + } + +- sched = config->sched; +- sched->name = "SCHED_RR"; ++ config->sched->name = "SCHED_RR"; + + FOREACH_NUMA(i, config, config_numa) { + for (j = 0; j < CTX_MODE_MAX; j++) { + ret = wd_sched_fill_table(config_numa, +- sched, j, ++ config->sched, j, + type_num); + if (ret) + goto err_release_sched; +@@ -1110,13 +1121,9 @@ static int wd_init_sched_config(struct wd_env_config *config, + return 0; + + err_release_sched: +- wd_sched_rr_release(sched); +- return ret; +-} ++ wd_uninit_sched_config(config); + +-static void wd_uninit_sched_config(struct wd_sched *sched_config) +-{ +- return wd_sched_rr_release(sched_config); ++ return ret; + } + + static struct async_task_queue *find_async_queue(struct wd_env_config *config, +@@ -1480,13 +1487,9 @@ static int wd_init_resource(struct wd_env_config *config, + err_uninit_alg: + ops->alg_uninit(); + err_uninit_sched: +- if (config->internal_sched) { +- wd_uninit_sched_config(config->sched); +- config->sched = NULL; +- } ++ wd_uninit_sched_config(config); + err_uninit_ctx: +- wd_free_ctx(config->ctx_config); +- config->ctx_config = NULL; ++ wd_free_ctx(config); + return ret; + } + +@@ -1495,14 +1498,8 @@ static void wd_uninit_resource(struct wd_env_config *config, + { + wd_uninit_async_polling_thread(config); + ops->alg_uninit(); +- +- if (config->internal_sched) { +- wd_uninit_sched_config(config->sched); +- config->sched = NULL; +- } +- +- wd_free_ctx(config->ctx_config); +- config->ctx_config = NULL; ++ wd_uninit_sched_config(config); ++ wd_free_ctx(config); + } + + int wd_alg_env_init(struct wd_env_config *env_config, +-- +2.25.1 + diff --git a/0045-uadk-env-fix-free-ctx-table-memory-leak.patch b/0045-uadk-env-fix-free-ctx-table-memory-leak.patch new file mode 100644 index 0000000..e83abf8 --- /dev/null +++ b/0045-uadk-env-fix-free-ctx-table-memory-leak.patch @@ -0,0 +1,206 @@ +From 8ad7bf917ea2940042e707cf37187d2623004bbc Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Sat, 15 Jan 2022 16:54:01 +0800 +Subject: [PATCH 48/53] uadk: env: fix free ctx table memory leak + +Add wd_free_ctx_table to free ctx table of all numa and +wd_free_ctx_table_per_numa to free single numa's ctx table. + +Signed-off-by: Wenkai Lin +--- + include/wd_util.h | 2 +- + wd_util.c | 79 +++++++++++++++++++++++------------------------ + 2 files changed, 40 insertions(+), 41 deletions(-) + +diff --git a/include/wd_util.h b/include/wd_util.h +index 2d3c1e4..c07ecce 100644 +--- a/include/wd_util.h ++++ b/include/wd_util.h +@@ -16,7 +16,7 @@ extern "C" { + + #define FOREACH_NUMA(i, config, config_numa) \ + for (i = 0, config_numa = config->config_per_numa; \ +- i < config->numa_num; config_numa++, i++) ++ config_numa && i < config->numa_num; config_numa++, i++) + + struct wd_async_msg_pool { + struct msg_pool *pools; +diff --git a/wd_util.c b/wd_util.c +index 8ad2bd0..7fa688d 100644 +--- a/wd_util.c ++++ b/wd_util.c +@@ -351,9 +351,6 @@ static void wd_free_numa(struct wd_env_config *config) + struct wd_env_config_per_numa *config_numa; + int i; + +- if (!config->config_per_numa) +- return; +- + FOREACH_NUMA(i, config, config_numa) + free(config_numa->dev); + +@@ -566,12 +563,12 @@ out: + return -WD_EINVAL; + } + +-static int wd_alloc_ctx_table(struct wd_env_config_per_numa *config_numa) ++static int wd_alloc_ctx_table_per_numa(struct wd_env_config_per_numa *config) + { + struct wd_ctx_range **ctx_table; + int i, j, ret; + +- if (config_numa->ctx_table) ++ if (config->ctx_table) + return 0; + + ctx_table = calloc(1, sizeof(struct wd_ctx_range *) * CTX_MODE_MAX); +@@ -581,27 +578,48 @@ static int wd_alloc_ctx_table(struct wd_env_config_per_numa *config_numa) + for (i = 0; i < CTX_MODE_MAX; i++) { + ctx_table[i] = calloc(1, + sizeof(struct wd_ctx_range) * +- config_numa->op_type_num); ++ config->op_type_num); + if (!ctx_table[i]) { + ret = -WD_ENOMEM; + goto free_mem; + } + } + +- config_numa->ctx_table = ctx_table; ++ config->ctx_table = ctx_table; + + return 0; + + free_mem: +- for (j = 0; j < i; j++) { ++ for (j = 0; j < i; j++) + free(ctx_table[j]); +- ctx_table[j] = NULL; +- } + + free(ctx_table); + return ret; + } + ++static void wd_free_ctx_table_per_numa(struct wd_env_config_per_numa *config) ++{ ++ int i; ++ ++ if (!config->ctx_table) ++ return; ++ ++ for (i = 0; i < CTX_MODE_MAX; i++) ++ free(config->ctx_table[i]); ++ ++ free(config->ctx_table); ++ config->ctx_table = NULL; ++} ++ ++static void wd_free_ctx_table(struct wd_env_config *config) ++{ ++ struct wd_env_config_per_numa *config_numa; ++ int i; ++ ++ FOREACH_NUMA(i, config, config_numa) ++ wd_free_ctx_table_per_numa(config_numa); ++} ++ + static int get_and_fill_ctx_num(struct wd_env_config_per_numa *config_numa, + const char *p, int ctx_num) + { +@@ -655,15 +673,18 @@ static int wd_parse_section(struct wd_env_config *config, char *section) + } + + config_numa->op_type_num = config->op_type_num; +- ret = wd_alloc_ctx_table(config_numa); ++ ret = wd_alloc_ctx_table_per_numa(config_numa); + if (ret) + return ret; + + ret = get_and_fill_ctx_num(config_numa, section, ctx_num); +- if (ret) ++ if (ret) { + WD_ERR("%s got wrong ctx type: %s!\n", __func__, section); ++ wd_free_ctx_table_per_numa(config_numa); ++ return ret; ++ } + +- return ret; ++ return 0; + } + + static int get_start_ctx_index(struct wd_env_config *config, +@@ -722,9 +743,8 @@ static void wd_fill_ctx_table(struct wd_env_config *config) + + static int parse_ctx_num(struct wd_env_config *config, const char *s) + { +- struct wd_env_config_per_numa *config_numa; + char *left, *section, *start; +- int i, ret; ++ int ret; + + start = strdup(s); + if (!start) +@@ -744,9 +764,7 @@ static int parse_ctx_num(struct wd_env_config *config, const char *s) + return 0; + + err_free_ctx_table: +- FOREACH_NUMA(i, config, config_numa) +- free(config_numa->ctx_table); +- ++ wd_free_ctx_table(config); + free(start); + return ret; + } +@@ -820,25 +838,6 @@ static int wd_parse_env(struct wd_env_config *config) + return 0; + } + +-static void wd_free_env(struct wd_env_config *config) +-{ +- struct wd_env_config_per_numa *config_numa; +- int i, j; +- +- if (!config->config_per_numa) +- return; +- +- FOREACH_NUMA(i, config, config_numa) { +- if (!config_numa->ctx_table) +- continue; +- +- for (j = 0; j < CTX_MODE_MAX; j++) +- free(config_numa->ctx_table[j]); +- +- free(config_numa->ctx_table); +- } +-} +- + static int wd_parse_ctx_attr(struct wd_env_config *env_config, + struct wd_ctx_attr *attr) + { +@@ -852,7 +851,7 @@ static int wd_parse_ctx_attr(struct wd_env_config *env_config, + } + + config_numa->op_type_num = env_config->op_type_num; +- ret = wd_alloc_ctx_table(config_numa); ++ ret = wd_alloc_ctx_table_per_numa(config_numa); + if (ret) + return ret; + +@@ -882,11 +881,11 @@ static int wd_init_env_config(struct wd_env_config *config, + + static void wd_uninit_env_config(struct wd_env_config *config) + { ++ wd_free_ctx_table(config); ++ + config->op_type_num = 0; + config->table_size = 0; + config->table = NULL; +- +- wd_free_env(config); + } + + static __u8 get_ctx_mode(struct wd_env_config_per_numa *config, int idx) +-- +2.25.1 + diff --git a/0046-uadk-remove-uadk_benchmark-binary-and-header-file.patch b/0046-uadk-remove-uadk_benchmark-binary-and-header-file.patch new file mode 100644 index 0000000..2909e64 --- /dev/null +++ b/0046-uadk-remove-uadk_benchmark-binary-and-header-file.patch @@ -0,0 +1,32869 @@ +From b77869c86aa88e3d32260a0cd8563a24c07071fe Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Mon, 21 Feb 2022 03:11:35 +0000 +Subject: [PATCH 50/53] uadk: remove uadk_benchmark binary and header file + +Binary files and openssl header files should not +be added to uadk, so remove it. + +Signed-off-by: Wenkai Lin +--- + uadk_tool/Makefile.am | 22 +- + uadk_tool/include/openssl/aes.h | 92 - + uadk_tool/include/openssl/asn1.h | 886 ---- + uadk_tool/include/openssl/asn1_mac.h | 10 - + uadk_tool/include/openssl/asn1err.h | 256 -- + uadk_tool/include/openssl/asn1t.h | 945 ---- + uadk_tool/include/openssl/async.h | 76 - + uadk_tool/include/openssl/asyncerr.h | 42 - + uadk_tool/include/openssl/bio.h | 801 ---- + uadk_tool/include/openssl/bioerr.h | 124 - + uadk_tool/include/openssl/blowfish.h | 61 - + uadk_tool/include/openssl/bn.h | 539 --- + uadk_tool/include/openssl/bnerr.h | 100 - + uadk_tool/include/openssl/buffer.h | 58 - + uadk_tool/include/openssl/buffererr.h | 34 - + uadk_tool/include/openssl/camellia.h | 83 - + uadk_tool/include/openssl/cast.h | 53 - + uadk_tool/include/openssl/cmac.h | 41 - + uadk_tool/include/openssl/cms.h | 339 -- + uadk_tool/include/openssl/cmserr.h | 202 - + uadk_tool/include/openssl/comp.h | 53 - + uadk_tool/include/openssl/comperr.h | 44 - + uadk_tool/include/openssl/conf.h | 168 - + uadk_tool/include/openssl/conf_api.h | 40 - + uadk_tool/include/openssl/conferr.h | 76 - + uadk_tool/include/openssl/crypto.h | 445 -- + uadk_tool/include/openssl/cryptoerr.h | 57 - + uadk_tool/include/openssl/ct.h | 474 --- + uadk_tool/include/openssl/cterr.h | 80 - + uadk_tool/include/openssl/des.h | 174 - + uadk_tool/include/openssl/dh.h | 340 -- + uadk_tool/include/openssl/dherr.h | 88 - + uadk_tool/include/openssl/dsa.h | 244 -- + uadk_tool/include/openssl/dsaerr.h | 72 - + uadk_tool/include/openssl/dtls1.h | 55 - + uadk_tool/include/openssl/e_os2.h | 301 -- + uadk_tool/include/openssl/ebcdic.h | 33 - + uadk_tool/include/openssl/ec.h | 1484 ------- + uadk_tool/include/openssl/ecdh.h | 10 - + uadk_tool/include/openssl/ecdsa.h | 10 - + uadk_tool/include/openssl/ecerr.h | 276 -- + uadk_tool/include/openssl/engine.h | 751 ---- + uadk_tool/include/openssl/engineerr.h | 111 - + uadk_tool/include/openssl/err.h | 274 -- + uadk_tool/include/openssl/evp.h | 1666 -------- + uadk_tool/include/openssl/evperr.h | 204 - + uadk_tool/include/openssl/hmac.h | 51 - + uadk_tool/include/openssl/idea.h | 64 - + uadk_tool/include/openssl/kdf.h | 97 - + uadk_tool/include/openssl/kdferr.h | 55 - + uadk_tool/include/openssl/lhash.h | 241 -- + uadk_tool/include/openssl/md2.h | 44 - + uadk_tool/include/openssl/md4.h | 51 - + uadk_tool/include/openssl/md5.h | 50 - + uadk_tool/include/openssl/mdc2.h | 42 - + uadk_tool/include/openssl/modes.h | 208 - + uadk_tool/include/openssl/obj_mac.h | 5198 ----------------------- + uadk_tool/include/openssl/objects.h | 175 - + uadk_tool/include/openssl/objectserr.h | 42 - + uadk_tool/include/openssl/ocsp.h | 352 -- + uadk_tool/include/openssl/ocsperr.h | 78 - + uadk_tool/include/openssl/opensslconf.h | 197 - + uadk_tool/include/openssl/opensslv.h | 101 - + uadk_tool/include/openssl/ossl_typ.h | 197 - + uadk_tool/include/openssl/pem.h | 378 -- + uadk_tool/include/openssl/pem2.h | 13 - + uadk_tool/include/openssl/pemerr.h | 105 - + uadk_tool/include/openssl/pkcs12.h | 223 - + uadk_tool/include/openssl/pkcs12err.h | 81 - + uadk_tool/include/openssl/pkcs7.h | 319 -- + uadk_tool/include/openssl/pkcs7err.h | 103 - + uadk_tool/include/openssl/rand.h | 77 - + uadk_tool/include/openssl/rand_drbg.h | 130 - + uadk_tool/include/openssl/randerr.h | 94 - + uadk_tool/include/openssl/rc2.h | 51 - + uadk_tool/include/openssl/rc4.h | 36 - + uadk_tool/include/openssl/rc5.h | 63 - + uadk_tool/include/openssl/ripemd.h | 47 - + uadk_tool/include/openssl/rsa.h | 513 --- + uadk_tool/include/openssl/rsaerr.h | 167 - + uadk_tool/include/openssl/safestack.h | 207 - + uadk_tool/include/openssl/seed.h | 96 - + uadk_tool/include/openssl/sha.h | 119 - + uadk_tool/include/openssl/srp.h | 135 - + uadk_tool/include/openssl/srtp.h | 50 - + uadk_tool/include/openssl/ssl.h | 2438 ----------- + uadk_tool/include/openssl/ssl2.h | 24 - + uadk_tool/include/openssl/ssl3.h | 342 -- + uadk_tool/include/openssl/sslerr.h | 776 ---- + uadk_tool/include/openssl/stack.h | 83 - + uadk_tool/include/openssl/store.h | 266 -- + uadk_tool/include/openssl/storeerr.h | 91 - + uadk_tool/include/openssl/symhacks.h | 37 - + uadk_tool/include/openssl/tls1.h | 1237 ------ + uadk_tool/include/openssl/ts.h | 559 --- + uadk_tool/include/openssl/tserr.h | 132 - + uadk_tool/include/openssl/txt_db.h | 57 - + uadk_tool/include/openssl/ui.h | 368 -- + uadk_tool/include/openssl/uierr.h | 65 - + uadk_tool/include/openssl/whrlpool.h | 48 - + uadk_tool/include/openssl/x509.h | 1050 ----- + uadk_tool/include/openssl/x509_vfy.h | 632 --- + uadk_tool/include/openssl/x509err.h | 129 - + uadk_tool/include/openssl/x509v3.h | 938 ---- + uadk_tool/include/openssl/x509v3err.h | 164 - + uadk_tool/uadk_benchmark.c | 2 + + 106 files changed, 20 insertions(+), 31962 deletions(-) + delete mode 100644 uadk_tool/include/openssl/aes.h + delete mode 100644 uadk_tool/include/openssl/asn1.h + delete mode 100644 uadk_tool/include/openssl/asn1_mac.h + delete mode 100644 uadk_tool/include/openssl/asn1err.h + delete mode 100644 uadk_tool/include/openssl/asn1t.h + delete mode 100644 uadk_tool/include/openssl/async.h + delete mode 100644 uadk_tool/include/openssl/asyncerr.h + delete mode 100644 uadk_tool/include/openssl/bio.h + delete mode 100644 uadk_tool/include/openssl/bioerr.h + delete mode 100644 uadk_tool/include/openssl/blowfish.h + delete mode 100644 uadk_tool/include/openssl/bn.h + delete mode 100644 uadk_tool/include/openssl/bnerr.h + delete mode 100644 uadk_tool/include/openssl/buffer.h + delete mode 100644 uadk_tool/include/openssl/buffererr.h + delete mode 100644 uadk_tool/include/openssl/camellia.h + delete mode 100644 uadk_tool/include/openssl/cast.h + delete mode 100644 uadk_tool/include/openssl/cmac.h + delete mode 100644 uadk_tool/include/openssl/cms.h + delete mode 100644 uadk_tool/include/openssl/cmserr.h + delete mode 100644 uadk_tool/include/openssl/comp.h + delete mode 100644 uadk_tool/include/openssl/comperr.h + delete mode 100644 uadk_tool/include/openssl/conf.h + delete mode 100644 uadk_tool/include/openssl/conf_api.h + delete mode 100644 uadk_tool/include/openssl/conferr.h + delete mode 100644 uadk_tool/include/openssl/crypto.h + delete mode 100644 uadk_tool/include/openssl/cryptoerr.h + delete mode 100644 uadk_tool/include/openssl/ct.h + delete mode 100644 uadk_tool/include/openssl/cterr.h + delete mode 100644 uadk_tool/include/openssl/des.h + delete mode 100644 uadk_tool/include/openssl/dh.h + delete mode 100644 uadk_tool/include/openssl/dherr.h + delete mode 100644 uadk_tool/include/openssl/dsa.h + delete mode 100644 uadk_tool/include/openssl/dsaerr.h + delete mode 100644 uadk_tool/include/openssl/dtls1.h + delete mode 100644 uadk_tool/include/openssl/e_os2.h + delete mode 100644 uadk_tool/include/openssl/ebcdic.h + delete mode 100644 uadk_tool/include/openssl/ec.h + delete mode 100644 uadk_tool/include/openssl/ecdh.h + delete mode 100644 uadk_tool/include/openssl/ecdsa.h + delete mode 100644 uadk_tool/include/openssl/ecerr.h + delete mode 100644 uadk_tool/include/openssl/engine.h + delete mode 100644 uadk_tool/include/openssl/engineerr.h + delete mode 100644 uadk_tool/include/openssl/err.h + delete mode 100644 uadk_tool/include/openssl/evp.h + delete mode 100644 uadk_tool/include/openssl/evperr.h + delete mode 100644 uadk_tool/include/openssl/hmac.h + delete mode 100644 uadk_tool/include/openssl/idea.h + delete mode 100644 uadk_tool/include/openssl/kdf.h + delete mode 100644 uadk_tool/include/openssl/kdferr.h + delete mode 100644 uadk_tool/include/openssl/lhash.h + delete mode 100644 uadk_tool/include/openssl/md2.h + delete mode 100644 uadk_tool/include/openssl/md4.h + delete mode 100644 uadk_tool/include/openssl/md5.h + delete mode 100644 uadk_tool/include/openssl/mdc2.h + delete mode 100644 uadk_tool/include/openssl/modes.h + delete mode 100644 uadk_tool/include/openssl/obj_mac.h + delete mode 100644 uadk_tool/include/openssl/objects.h + delete mode 100644 uadk_tool/include/openssl/objectserr.h + delete mode 100644 uadk_tool/include/openssl/ocsp.h + delete mode 100644 uadk_tool/include/openssl/ocsperr.h + delete mode 100644 uadk_tool/include/openssl/opensslconf.h + delete mode 100644 uadk_tool/include/openssl/opensslv.h + delete mode 100644 uadk_tool/include/openssl/ossl_typ.h + delete mode 100644 uadk_tool/include/openssl/pem.h + delete mode 100644 uadk_tool/include/openssl/pem2.h + delete mode 100644 uadk_tool/include/openssl/pemerr.h + delete mode 100644 uadk_tool/include/openssl/pkcs12.h + delete mode 100644 uadk_tool/include/openssl/pkcs12err.h + delete mode 100644 uadk_tool/include/openssl/pkcs7.h + delete mode 100644 uadk_tool/include/openssl/pkcs7err.h + delete mode 100644 uadk_tool/include/openssl/rand.h + delete mode 100644 uadk_tool/include/openssl/rand_drbg.h + delete mode 100644 uadk_tool/include/openssl/randerr.h + delete mode 100644 uadk_tool/include/openssl/rc2.h + delete mode 100644 uadk_tool/include/openssl/rc4.h + delete mode 100644 uadk_tool/include/openssl/rc5.h + delete mode 100644 uadk_tool/include/openssl/ripemd.h + delete mode 100644 uadk_tool/include/openssl/rsa.h + delete mode 100644 uadk_tool/include/openssl/rsaerr.h + delete mode 100644 uadk_tool/include/openssl/safestack.h + delete mode 100644 uadk_tool/include/openssl/seed.h + delete mode 100644 uadk_tool/include/openssl/sha.h + delete mode 100644 uadk_tool/include/openssl/srp.h + delete mode 100644 uadk_tool/include/openssl/srtp.h + delete mode 100644 uadk_tool/include/openssl/ssl.h + delete mode 100644 uadk_tool/include/openssl/ssl2.h + delete mode 100644 uadk_tool/include/openssl/ssl3.h + delete mode 100644 uadk_tool/include/openssl/sslerr.h + delete mode 100644 uadk_tool/include/openssl/stack.h + delete mode 100644 uadk_tool/include/openssl/store.h + delete mode 100644 uadk_tool/include/openssl/storeerr.h + delete mode 100644 uadk_tool/include/openssl/symhacks.h + delete mode 100644 uadk_tool/include/openssl/tls1.h + delete mode 100644 uadk_tool/include/openssl/ts.h + delete mode 100644 uadk_tool/include/openssl/tserr.h + delete mode 100644 uadk_tool/include/openssl/txt_db.h + delete mode 100644 uadk_tool/include/openssl/ui.h + delete mode 100644 uadk_tool/include/openssl/uierr.h + delete mode 100644 uadk_tool/include/openssl/whrlpool.h + delete mode 100644 uadk_tool/include/openssl/x509.h + delete mode 100644 uadk_tool/include/openssl/x509_vfy.h + delete mode 100644 uadk_tool/include/openssl/x509err.h + delete mode 100644 uadk_tool/include/openssl/x509v3.h + delete mode 100644 uadk_tool/include/openssl/x509v3err.h + +diff --git a/uadk_tool/Makefile.am b/uadk_tool/Makefile.am +index f79a6e3..da5b229 100644 +--- a/uadk_tool/Makefile.am ++++ b/uadk_tool/Makefile.am +@@ -1,13 +1,13 @@ + ACLOCAL_AMFLAGS = -I m4 -I./include + AM_CFLAGS=-Wall -fno-strict-aliasing -I$(top_srcdir) -I$(top_srcdir)/include \ +- -I$(top_srcdir)/uadk_tool/include -pthread ++ -pthread + + #AUTOMAKE_OPTIONS = subdir-objects + + bin_PROGRAMS=uadk_tool + + uadk_tool_SOURCES=uadk_tool.c uadk_dfx.c uadk_benchmark.c \ +- sec_uadk_benchmark.c sec_wd_benchmark.c sec_soft_benchmark.c ++ sec_uadk_benchmark.c sec_wd_benchmark.c + + if WD_STATIC_DRV + AM_CFLAGS+=-Bstatic +@@ -16,9 +16,23 @@ uadk_tool_LDADD=$(libwd_la_OBJECTS) \ + ../.libs/libhisi_sec.a \ + ../.libs/libhisi_hpre.a \ + ../.libs/libhisi_zip.a \ +- $(top_srcdir)/uadk_tool/include/libcrypto.a -ldl -lnuma ++ -ldl -lnuma + else + uadk_tool_LDADD=-L../.libs -l:libwd.so.2 -l:libwd_crypto.so.2 \ +- -L$(top_srcdir)/uadk_tool/include -l:libcrypto.so.1.1 -lnuma ++ -lnuma + endif ++ + uadk_tool_LDFLAGS=-Wl,-rpath,'/usr/local/lib' ++ ++if WITH_OPENSSL_DIR ++AM_CFLAGS+= -DWITH_OPENSSL_DIR -I$(with_openssl_dir)/include ++ ++uadk_tool_SOURCES+=sec_soft_benchmark.c ++ ++if WD_STATIC_DRV ++uadk_tool_LDADD+= $(with_openssl_dir)/libcrypto.a ++else ++uadk_tool_LDADD+= $(with_openssl_dir)/libcrypto.so.1.1 ++endif ++ ++endif +diff --git a/uadk_tool/include/openssl/aes.h b/uadk_tool/include/openssl/aes.h +deleted file mode 100644 +index 245c552..0000000 +--- a/uadk_tool/include/openssl/aes.h ++++ /dev/null +@@ -1,92 +0,0 @@ +-/* +- * Copyright 2002-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_AES_H +-# define HEADER_AES_H +- +-# include +- +-# include +-# ifdef __cplusplus +-extern "C" { +-# endif +- +-# define AES_ENCRYPT 1 +-# define AES_DECRYPT 0 +- +-/* +- * Because array size can't be a const in C, the following two are macros. +- * Both sizes are in bytes. +- */ +-# define AES_MAXNR 14 +-# define AES_BLOCK_SIZE 16 +- +-/* This should be a hidden type, but EVP requires that the size be known */ +-struct aes_key_st { +-# ifdef AES_LONG +- unsigned long rd_key[4 * (AES_MAXNR + 1)]; +-# else +- unsigned int rd_key[4 * (AES_MAXNR + 1)]; +-# endif +- int rounds; +-}; +-typedef struct aes_key_st AES_KEY; +- +-const char *AES_options(void); +- +-int AES_set_encrypt_key(const unsigned char *userKey, const int bits, +- AES_KEY *key); +-int AES_set_decrypt_key(const unsigned char *userKey, const int bits, +- AES_KEY *key); +- +-void AES_encrypt(const unsigned char *in, unsigned char *out, +- const AES_KEY *key); +-void AES_decrypt(const unsigned char *in, unsigned char *out, +- const AES_KEY *key); +- +-void AES_ecb_encrypt(const unsigned char *in, unsigned char *out, +- const AES_KEY *key, const int enc); +-void AES_cbc_encrypt(const unsigned char *in, unsigned char *out, +- size_t length, const AES_KEY *key, +- unsigned char *ivec, const int enc); +-void AES_cfb128_encrypt(const unsigned char *in, unsigned char *out, +- size_t length, const AES_KEY *key, +- unsigned char *ivec, int *num, const int enc); +-void AES_cfb1_encrypt(const unsigned char *in, unsigned char *out, +- size_t length, const AES_KEY *key, +- unsigned char *ivec, int *num, const int enc); +-void AES_cfb8_encrypt(const unsigned char *in, unsigned char *out, +- size_t length, const AES_KEY *key, +- unsigned char *ivec, int *num, const int enc); +-void AES_ofb128_encrypt(const unsigned char *in, unsigned char *out, +- size_t length, const AES_KEY *key, +- unsigned char *ivec, int *num); +-/* NB: the IV is _two_ blocks long */ +-void AES_ige_encrypt(const unsigned char *in, unsigned char *out, +- size_t length, const AES_KEY *key, +- unsigned char *ivec, const int enc); +-/* NB: the IV is _four_ blocks long */ +-void AES_bi_ige_encrypt(const unsigned char *in, unsigned char *out, +- size_t length, const AES_KEY *key, +- const AES_KEY *key2, const unsigned char *ivec, +- const int enc); +- +-int AES_wrap_key(AES_KEY *key, const unsigned char *iv, +- unsigned char *out, +- const unsigned char *in, unsigned int inlen); +-int AES_unwrap_key(AES_KEY *key, const unsigned char *iv, +- unsigned char *out, +- const unsigned char *in, unsigned int inlen); +- +- +-# ifdef __cplusplus +-} +-# endif +- +-#endif +diff --git a/uadk_tool/include/openssl/asn1.h b/uadk_tool/include/openssl/asn1.h +deleted file mode 100644 +index 9522eec..0000000 +--- a/uadk_tool/include/openssl/asn1.h ++++ /dev/null +@@ -1,886 +0,0 @@ +-/* +- * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_ASN1_H +-# define HEADER_ASN1_H +- +-# include +-# include +-# include +-# include +-# include +-# include +-# include +- +-# include +-# if OPENSSL_API_COMPAT < 0x10100000L +-# include +-# endif +- +-# ifdef OPENSSL_BUILD_SHLIBCRYPTO +-# undef OPENSSL_EXTERN +-# define OPENSSL_EXTERN OPENSSL_EXPORT +-# endif +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-# define V_ASN1_UNIVERSAL 0x00 +-# define V_ASN1_APPLICATION 0x40 +-# define V_ASN1_CONTEXT_SPECIFIC 0x80 +-# define V_ASN1_PRIVATE 0xc0 +- +-# define V_ASN1_CONSTRUCTED 0x20 +-# define V_ASN1_PRIMITIVE_TAG 0x1f +-# define V_ASN1_PRIMATIVE_TAG /*compat*/ V_ASN1_PRIMITIVE_TAG +- +-# define V_ASN1_APP_CHOOSE -2/* let the recipient choose */ +-# define V_ASN1_OTHER -3/* used in ASN1_TYPE */ +-# define V_ASN1_ANY -4/* used in ASN1 template code */ +- +-# define V_ASN1_UNDEF -1 +-/* ASN.1 tag values */ +-# define V_ASN1_EOC 0 +-# define V_ASN1_BOOLEAN 1 /**/ +-# define V_ASN1_INTEGER 2 +-# define V_ASN1_BIT_STRING 3 +-# define V_ASN1_OCTET_STRING 4 +-# define V_ASN1_NULL 5 +-# define V_ASN1_OBJECT 6 +-# define V_ASN1_OBJECT_DESCRIPTOR 7 +-# define V_ASN1_EXTERNAL 8 +-# define V_ASN1_REAL 9 +-# define V_ASN1_ENUMERATED 10 +-# define V_ASN1_UTF8STRING 12 +-# define V_ASN1_SEQUENCE 16 +-# define V_ASN1_SET 17 +-# define V_ASN1_NUMERICSTRING 18 /**/ +-# define V_ASN1_PRINTABLESTRING 19 +-# define V_ASN1_T61STRING 20 +-# define V_ASN1_TELETEXSTRING 20/* alias */ +-# define V_ASN1_VIDEOTEXSTRING 21 /**/ +-# define V_ASN1_IA5STRING 22 +-# define V_ASN1_UTCTIME 23 +-# define V_ASN1_GENERALIZEDTIME 24 /**/ +-# define V_ASN1_GRAPHICSTRING 25 /**/ +-# define V_ASN1_ISO64STRING 26 /**/ +-# define V_ASN1_VISIBLESTRING 26/* alias */ +-# define V_ASN1_GENERALSTRING 27 /**/ +-# define V_ASN1_UNIVERSALSTRING 28 /**/ +-# define V_ASN1_BMPSTRING 30 +- +-/* +- * NB the constants below are used internally by ASN1_INTEGER +- * and ASN1_ENUMERATED to indicate the sign. They are *not* on +- * the wire tag values. +- */ +- +-# define V_ASN1_NEG 0x100 +-# define V_ASN1_NEG_INTEGER (2 | V_ASN1_NEG) +-# define V_ASN1_NEG_ENUMERATED (10 | V_ASN1_NEG) +- +-/* For use with d2i_ASN1_type_bytes() */ +-# define B_ASN1_NUMERICSTRING 0x0001 +-# define B_ASN1_PRINTABLESTRING 0x0002 +-# define B_ASN1_T61STRING 0x0004 +-# define B_ASN1_TELETEXSTRING 0x0004 +-# define B_ASN1_VIDEOTEXSTRING 0x0008 +-# define B_ASN1_IA5STRING 0x0010 +-# define B_ASN1_GRAPHICSTRING 0x0020 +-# define B_ASN1_ISO64STRING 0x0040 +-# define B_ASN1_VISIBLESTRING 0x0040 +-# define B_ASN1_GENERALSTRING 0x0080 +-# define B_ASN1_UNIVERSALSTRING 0x0100 +-# define B_ASN1_OCTET_STRING 0x0200 +-# define B_ASN1_BIT_STRING 0x0400 +-# define B_ASN1_BMPSTRING 0x0800 +-# define B_ASN1_UNKNOWN 0x1000 +-# define B_ASN1_UTF8STRING 0x2000 +-# define B_ASN1_UTCTIME 0x4000 +-# define B_ASN1_GENERALIZEDTIME 0x8000 +-# define B_ASN1_SEQUENCE 0x10000 +-/* For use with ASN1_mbstring_copy() */ +-# define MBSTRING_FLAG 0x1000 +-# define MBSTRING_UTF8 (MBSTRING_FLAG) +-# define MBSTRING_ASC (MBSTRING_FLAG|1) +-# define MBSTRING_BMP (MBSTRING_FLAG|2) +-# define MBSTRING_UNIV (MBSTRING_FLAG|4) +-# define SMIME_OLDMIME 0x400 +-# define SMIME_CRLFEOL 0x800 +-# define SMIME_STREAM 0x1000 +- struct X509_algor_st; +-DEFINE_STACK_OF(X509_ALGOR) +- +-# define ASN1_STRING_FLAG_BITS_LEFT 0x08/* Set if 0x07 has bits left value */ +-/* +- * This indicates that the ASN1_STRING is not a real value but just a place +- * holder for the location where indefinite length constructed data should be +- * inserted in the memory buffer +- */ +-# define ASN1_STRING_FLAG_NDEF 0x010 +- +-/* +- * This flag is used by the CMS code to indicate that a string is not +- * complete and is a place holder for content when it had all been accessed. +- * The flag will be reset when content has been written to it. +- */ +- +-# define ASN1_STRING_FLAG_CONT 0x020 +-/* +- * This flag is used by ASN1 code to indicate an ASN1_STRING is an MSTRING +- * type. +- */ +-# define ASN1_STRING_FLAG_MSTRING 0x040 +-/* String is embedded and only content should be freed */ +-# define ASN1_STRING_FLAG_EMBED 0x080 +-/* String should be parsed in RFC 5280's time format */ +-# define ASN1_STRING_FLAG_X509_TIME 0x100 +-/* This is the base type that holds just about everything :-) */ +-struct asn1_string_st { +- int length; +- int type; +- unsigned char *data; +- /* +- * The value of the following field depends on the type being held. It +- * is mostly being used for BIT_STRING so if the input data has a +- * non-zero 'unused bits' value, it will be handled correctly +- */ +- long flags; +-}; +- +-/* +- * ASN1_ENCODING structure: this is used to save the received encoding of an +- * ASN1 type. This is useful to get round problems with invalid encodings +- * which can break signatures. +- */ +- +-typedef struct ASN1_ENCODING_st { +- unsigned char *enc; /* DER encoding */ +- long len; /* Length of encoding */ +- int modified; /* set to 1 if 'enc' is invalid */ +-} ASN1_ENCODING; +- +-/* Used with ASN1 LONG type: if a long is set to this it is omitted */ +-# define ASN1_LONG_UNDEF 0x7fffffffL +- +-# define STABLE_FLAGS_MALLOC 0x01 +-/* +- * A zero passed to ASN1_STRING_TABLE_new_add for the flags is interpreted +- * as "don't change" and STABLE_FLAGS_MALLOC is always set. By setting +- * STABLE_FLAGS_MALLOC only we can clear the existing value. Use the alias +- * STABLE_FLAGS_CLEAR to reflect this. +- */ +-# define STABLE_FLAGS_CLEAR STABLE_FLAGS_MALLOC +-# define STABLE_NO_MASK 0x02 +-# define DIRSTRING_TYPE \ +- (B_ASN1_PRINTABLESTRING|B_ASN1_T61STRING|B_ASN1_BMPSTRING|B_ASN1_UTF8STRING) +-# define PKCS9STRING_TYPE (DIRSTRING_TYPE|B_ASN1_IA5STRING) +- +-typedef struct asn1_string_table_st { +- int nid; +- long minsize; +- long maxsize; +- unsigned long mask; +- unsigned long flags; +-} ASN1_STRING_TABLE; +- +-DEFINE_STACK_OF(ASN1_STRING_TABLE) +- +-/* size limits: this stuff is taken straight from RFC2459 */ +- +-# define ub_name 32768 +-# define ub_common_name 64 +-# define ub_locality_name 128 +-# define ub_state_name 128 +-# define ub_organization_name 64 +-# define ub_organization_unit_name 64 +-# define ub_title 64 +-# define ub_email_address 128 +- +-/* +- * Declarations for template structures: for full definitions see asn1t.h +- */ +-typedef struct ASN1_TEMPLATE_st ASN1_TEMPLATE; +-typedef struct ASN1_TLC_st ASN1_TLC; +-/* This is just an opaque pointer */ +-typedef struct ASN1_VALUE_st ASN1_VALUE; +- +-/* Declare ASN1 functions: the implement macro in in asn1t.h */ +- +-# define DECLARE_ASN1_FUNCTIONS(type) DECLARE_ASN1_FUNCTIONS_name(type, type) +- +-# define DECLARE_ASN1_ALLOC_FUNCTIONS(type) \ +- DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, type) +- +-# define DECLARE_ASN1_FUNCTIONS_name(type, name) \ +- DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \ +- DECLARE_ASN1_ENCODE_FUNCTIONS(type, name, name) +- +-# define DECLARE_ASN1_FUNCTIONS_fname(type, itname, name) \ +- DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \ +- DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name) +- +-# define DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name) \ +- type *d2i_##name(type **a, const unsigned char **in, long len); \ +- int i2d_##name(type *a, unsigned char **out); \ +- DECLARE_ASN1_ITEM(itname) +- +-# define DECLARE_ASN1_ENCODE_FUNCTIONS_const(type, name) \ +- type *d2i_##name(type **a, const unsigned char **in, long len); \ +- int i2d_##name(const type *a, unsigned char **out); \ +- DECLARE_ASN1_ITEM(name) +- +-# define DECLARE_ASN1_NDEF_FUNCTION(name) \ +- int i2d_##name##_NDEF(name *a, unsigned char **out); +- +-# define DECLARE_ASN1_FUNCTIONS_const(name) \ +- DECLARE_ASN1_ALLOC_FUNCTIONS(name) \ +- DECLARE_ASN1_ENCODE_FUNCTIONS_const(name, name) +- +-# define DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \ +- type *name##_new(void); \ +- void name##_free(type *a); +- +-# define DECLARE_ASN1_PRINT_FUNCTION(stname) \ +- DECLARE_ASN1_PRINT_FUNCTION_fname(stname, stname) +- +-# define DECLARE_ASN1_PRINT_FUNCTION_fname(stname, fname) \ +- int fname##_print_ctx(BIO *out, stname *x, int indent, \ +- const ASN1_PCTX *pctx); +- +-# define D2I_OF(type) type *(*)(type **,const unsigned char **,long) +-# define I2D_OF(type) int (*)(type *,unsigned char **) +-# define I2D_OF_const(type) int (*)(const type *,unsigned char **) +- +-# define CHECKED_D2I_OF(type, d2i) \ +- ((d2i_of_void*) (1 ? d2i : ((D2I_OF(type))0))) +-# define CHECKED_I2D_OF(type, i2d) \ +- ((i2d_of_void*) (1 ? i2d : ((I2D_OF(type))0))) +-# define CHECKED_NEW_OF(type, xnew) \ +- ((void *(*)(void)) (1 ? xnew : ((type *(*)(void))0))) +-# define CHECKED_PTR_OF(type, p) \ +- ((void*) (1 ? p : (type*)0)) +-# define CHECKED_PPTR_OF(type, p) \ +- ((void**) (1 ? p : (type**)0)) +- +-# define TYPEDEF_D2I_OF(type) typedef type *d2i_of_##type(type **,const unsigned char **,long) +-# define TYPEDEF_I2D_OF(type) typedef int i2d_of_##type(type *,unsigned char **) +-# define TYPEDEF_D2I2D_OF(type) TYPEDEF_D2I_OF(type); TYPEDEF_I2D_OF(type) +- +-TYPEDEF_D2I2D_OF(void); +- +-/*- +- * The following macros and typedefs allow an ASN1_ITEM +- * to be embedded in a structure and referenced. Since +- * the ASN1_ITEM pointers need to be globally accessible +- * (possibly from shared libraries) they may exist in +- * different forms. On platforms that support it the +- * ASN1_ITEM structure itself will be globally exported. +- * Other platforms will export a function that returns +- * an ASN1_ITEM pointer. +- * +- * To handle both cases transparently the macros below +- * should be used instead of hard coding an ASN1_ITEM +- * pointer in a structure. +- * +- * The structure will look like this: +- * +- * typedef struct SOMETHING_st { +- * ... +- * ASN1_ITEM_EXP *iptr; +- * ... +- * } SOMETHING; +- * +- * It would be initialised as e.g.: +- * +- * SOMETHING somevar = {...,ASN1_ITEM_ref(X509),...}; +- * +- * and the actual pointer extracted with: +- * +- * const ASN1_ITEM *it = ASN1_ITEM_ptr(somevar.iptr); +- * +- * Finally an ASN1_ITEM pointer can be extracted from an +- * appropriate reference with: ASN1_ITEM_rptr(X509). This +- * would be used when a function takes an ASN1_ITEM * argument. +- * +- */ +- +-# ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION +- +-/* ASN1_ITEM pointer exported type */ +-typedef const ASN1_ITEM ASN1_ITEM_EXP; +- +-/* Macro to obtain ASN1_ITEM pointer from exported type */ +-# define ASN1_ITEM_ptr(iptr) (iptr) +- +-/* Macro to include ASN1_ITEM pointer from base type */ +-# define ASN1_ITEM_ref(iptr) (&(iptr##_it)) +- +-# define ASN1_ITEM_rptr(ref) (&(ref##_it)) +- +-# define DECLARE_ASN1_ITEM(name) \ +- OPENSSL_EXTERN const ASN1_ITEM name##_it; +- +-# else +- +-/* +- * Platforms that can't easily handle shared global variables are declared as +- * functions returning ASN1_ITEM pointers. +- */ +- +-/* ASN1_ITEM pointer exported type */ +-typedef const ASN1_ITEM *ASN1_ITEM_EXP (void); +- +-/* Macro to obtain ASN1_ITEM pointer from exported type */ +-# define ASN1_ITEM_ptr(iptr) (iptr()) +- +-/* Macro to include ASN1_ITEM pointer from base type */ +-# define ASN1_ITEM_ref(iptr) (iptr##_it) +- +-# define ASN1_ITEM_rptr(ref) (ref##_it()) +- +-# define DECLARE_ASN1_ITEM(name) \ +- const ASN1_ITEM * name##_it(void); +- +-# endif +- +-/* Parameters used by ASN1_STRING_print_ex() */ +- +-/* +- * These determine which characters to escape: RFC2253 special characters, +- * control characters and MSB set characters +- */ +- +-# define ASN1_STRFLGS_ESC_2253 1 +-# define ASN1_STRFLGS_ESC_CTRL 2 +-# define ASN1_STRFLGS_ESC_MSB 4 +- +-/* +- * This flag determines how we do escaping: normally RC2253 backslash only, +- * set this to use backslash and quote. +- */ +- +-# define ASN1_STRFLGS_ESC_QUOTE 8 +- +-/* These three flags are internal use only. */ +- +-/* Character is a valid PrintableString character */ +-# define CHARTYPE_PRINTABLESTRING 0x10 +-/* Character needs escaping if it is the first character */ +-# define CHARTYPE_FIRST_ESC_2253 0x20 +-/* Character needs escaping if it is the last character */ +-# define CHARTYPE_LAST_ESC_2253 0x40 +- +-/* +- * NB the internal flags are safely reused below by flags handled at the top +- * level. +- */ +- +-/* +- * If this is set we convert all character strings to UTF8 first +- */ +- +-# define ASN1_STRFLGS_UTF8_CONVERT 0x10 +- +-/* +- * If this is set we don't attempt to interpret content: just assume all +- * strings are 1 byte per character. This will produce some pretty odd +- * looking output! +- */ +- +-# define ASN1_STRFLGS_IGNORE_TYPE 0x20 +- +-/* If this is set we include the string type in the output */ +-# define ASN1_STRFLGS_SHOW_TYPE 0x40 +- +-/* +- * This determines which strings to display and which to 'dump' (hex dump of +- * content octets or DER encoding). We can only dump non character strings or +- * everything. If we don't dump 'unknown' they are interpreted as character +- * strings with 1 octet per character and are subject to the usual escaping +- * options. +- */ +- +-# define ASN1_STRFLGS_DUMP_ALL 0x80 +-# define ASN1_STRFLGS_DUMP_UNKNOWN 0x100 +- +-/* +- * These determine what 'dumping' does, we can dump the content octets or the +- * DER encoding: both use the RFC2253 #XXXXX notation. +- */ +- +-# define ASN1_STRFLGS_DUMP_DER 0x200 +- +-/* +- * This flag specifies that RC2254 escaping shall be performed. +- */ +-#define ASN1_STRFLGS_ESC_2254 0x400 +- +-/* +- * All the string flags consistent with RFC2253, escaping control characters +- * isn't essential in RFC2253 but it is advisable anyway. +- */ +- +-# define ASN1_STRFLGS_RFC2253 (ASN1_STRFLGS_ESC_2253 | \ +- ASN1_STRFLGS_ESC_CTRL | \ +- ASN1_STRFLGS_ESC_MSB | \ +- ASN1_STRFLGS_UTF8_CONVERT | \ +- ASN1_STRFLGS_DUMP_UNKNOWN | \ +- ASN1_STRFLGS_DUMP_DER) +- +-DEFINE_STACK_OF(ASN1_INTEGER) +- +-DEFINE_STACK_OF(ASN1_GENERALSTRING) +- +-DEFINE_STACK_OF(ASN1_UTF8STRING) +- +-typedef struct asn1_type_st { +- int type; +- union { +- char *ptr; +- ASN1_BOOLEAN boolean; +- ASN1_STRING *asn1_string; +- ASN1_OBJECT *object; +- ASN1_INTEGER *integer; +- ASN1_ENUMERATED *enumerated; +- ASN1_BIT_STRING *bit_string; +- ASN1_OCTET_STRING *octet_string; +- ASN1_PRINTABLESTRING *printablestring; +- ASN1_T61STRING *t61string; +- ASN1_IA5STRING *ia5string; +- ASN1_GENERALSTRING *generalstring; +- ASN1_BMPSTRING *bmpstring; +- ASN1_UNIVERSALSTRING *universalstring; +- ASN1_UTCTIME *utctime; +- ASN1_GENERALIZEDTIME *generalizedtime; +- ASN1_VISIBLESTRING *visiblestring; +- ASN1_UTF8STRING *utf8string; +- /* +- * set and sequence are left complete and still contain the set or +- * sequence bytes +- */ +- ASN1_STRING *set; +- ASN1_STRING *sequence; +- ASN1_VALUE *asn1_value; +- } value; +-} ASN1_TYPE; +- +-DEFINE_STACK_OF(ASN1_TYPE) +- +-typedef STACK_OF(ASN1_TYPE) ASN1_SEQUENCE_ANY; +- +-DECLARE_ASN1_ENCODE_FUNCTIONS_const(ASN1_SEQUENCE_ANY, ASN1_SEQUENCE_ANY) +-DECLARE_ASN1_ENCODE_FUNCTIONS_const(ASN1_SEQUENCE_ANY, ASN1_SET_ANY) +- +-/* This is used to contain a list of bit names */ +-typedef struct BIT_STRING_BITNAME_st { +- int bitnum; +- const char *lname; +- const char *sname; +-} BIT_STRING_BITNAME; +- +-# define B_ASN1_TIME \ +- B_ASN1_UTCTIME | \ +- B_ASN1_GENERALIZEDTIME +- +-# define B_ASN1_PRINTABLE \ +- B_ASN1_NUMERICSTRING| \ +- B_ASN1_PRINTABLESTRING| \ +- B_ASN1_T61STRING| \ +- B_ASN1_IA5STRING| \ +- B_ASN1_BIT_STRING| \ +- B_ASN1_UNIVERSALSTRING|\ +- B_ASN1_BMPSTRING|\ +- B_ASN1_UTF8STRING|\ +- B_ASN1_SEQUENCE|\ +- B_ASN1_UNKNOWN +- +-# define B_ASN1_DIRECTORYSTRING \ +- B_ASN1_PRINTABLESTRING| \ +- B_ASN1_TELETEXSTRING|\ +- B_ASN1_BMPSTRING|\ +- B_ASN1_UNIVERSALSTRING|\ +- B_ASN1_UTF8STRING +- +-# define B_ASN1_DISPLAYTEXT \ +- B_ASN1_IA5STRING| \ +- B_ASN1_VISIBLESTRING| \ +- B_ASN1_BMPSTRING|\ +- B_ASN1_UTF8STRING +- +-DECLARE_ASN1_FUNCTIONS_fname(ASN1_TYPE, ASN1_ANY, ASN1_TYPE) +- +-int ASN1_TYPE_get(const ASN1_TYPE *a); +-void ASN1_TYPE_set(ASN1_TYPE *a, int type, void *value); +-int ASN1_TYPE_set1(ASN1_TYPE *a, int type, const void *value); +-int ASN1_TYPE_cmp(const ASN1_TYPE *a, const ASN1_TYPE *b); +- +-ASN1_TYPE *ASN1_TYPE_pack_sequence(const ASN1_ITEM *it, void *s, ASN1_TYPE **t); +-void *ASN1_TYPE_unpack_sequence(const ASN1_ITEM *it, const ASN1_TYPE *t); +- +-ASN1_OBJECT *ASN1_OBJECT_new(void); +-void ASN1_OBJECT_free(ASN1_OBJECT *a); +-int i2d_ASN1_OBJECT(const ASN1_OBJECT *a, unsigned char **pp); +-ASN1_OBJECT *d2i_ASN1_OBJECT(ASN1_OBJECT **a, const unsigned char **pp, +- long length); +- +-DECLARE_ASN1_ITEM(ASN1_OBJECT) +- +-DEFINE_STACK_OF(ASN1_OBJECT) +- +-ASN1_STRING *ASN1_STRING_new(void); +-void ASN1_STRING_free(ASN1_STRING *a); +-void ASN1_STRING_clear_free(ASN1_STRING *a); +-int ASN1_STRING_copy(ASN1_STRING *dst, const ASN1_STRING *str); +-ASN1_STRING *ASN1_STRING_dup(const ASN1_STRING *a); +-ASN1_STRING *ASN1_STRING_type_new(int type); +-int ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b); +- /* +- * Since this is used to store all sorts of things, via macros, for now, +- * make its data void * +- */ +-int ASN1_STRING_set(ASN1_STRING *str, const void *data, int len); +-void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len); +-int ASN1_STRING_length(const ASN1_STRING *x); +-void ASN1_STRING_length_set(ASN1_STRING *x, int n); +-int ASN1_STRING_type(const ASN1_STRING *x); +-DEPRECATEDIN_1_1_0(unsigned char *ASN1_STRING_data(ASN1_STRING *x)) +-const unsigned char *ASN1_STRING_get0_data(const ASN1_STRING *x); +- +-DECLARE_ASN1_FUNCTIONS(ASN1_BIT_STRING) +-int ASN1_BIT_STRING_set(ASN1_BIT_STRING *a, unsigned char *d, int length); +-int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value); +-int ASN1_BIT_STRING_get_bit(const ASN1_BIT_STRING *a, int n); +-int ASN1_BIT_STRING_check(const ASN1_BIT_STRING *a, +- const unsigned char *flags, int flags_len); +- +-int ASN1_BIT_STRING_name_print(BIO *out, ASN1_BIT_STRING *bs, +- BIT_STRING_BITNAME *tbl, int indent); +-int ASN1_BIT_STRING_num_asc(const char *name, BIT_STRING_BITNAME *tbl); +-int ASN1_BIT_STRING_set_asc(ASN1_BIT_STRING *bs, const char *name, int value, +- BIT_STRING_BITNAME *tbl); +- +-DECLARE_ASN1_FUNCTIONS(ASN1_INTEGER) +-ASN1_INTEGER *d2i_ASN1_UINTEGER(ASN1_INTEGER **a, const unsigned char **pp, +- long length); +-ASN1_INTEGER *ASN1_INTEGER_dup(const ASN1_INTEGER *x); +-int ASN1_INTEGER_cmp(const ASN1_INTEGER *x, const ASN1_INTEGER *y); +- +-DECLARE_ASN1_FUNCTIONS(ASN1_ENUMERATED) +- +-int ASN1_UTCTIME_check(const ASN1_UTCTIME *a); +-ASN1_UTCTIME *ASN1_UTCTIME_set(ASN1_UTCTIME *s, time_t t); +-ASN1_UTCTIME *ASN1_UTCTIME_adj(ASN1_UTCTIME *s, time_t t, +- int offset_day, long offset_sec); +-int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str); +-int ASN1_UTCTIME_cmp_time_t(const ASN1_UTCTIME *s, time_t t); +- +-int ASN1_GENERALIZEDTIME_check(const ASN1_GENERALIZEDTIME *a); +-ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME *s, +- time_t t); +-ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME *s, +- time_t t, int offset_day, +- long offset_sec); +-int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, const char *str); +- +-int ASN1_TIME_diff(int *pday, int *psec, +- const ASN1_TIME *from, const ASN1_TIME *to); +- +-DECLARE_ASN1_FUNCTIONS(ASN1_OCTET_STRING) +-ASN1_OCTET_STRING *ASN1_OCTET_STRING_dup(const ASN1_OCTET_STRING *a); +-int ASN1_OCTET_STRING_cmp(const ASN1_OCTET_STRING *a, +- const ASN1_OCTET_STRING *b); +-int ASN1_OCTET_STRING_set(ASN1_OCTET_STRING *str, const unsigned char *data, +- int len); +- +-DECLARE_ASN1_FUNCTIONS(ASN1_VISIBLESTRING) +-DECLARE_ASN1_FUNCTIONS(ASN1_UNIVERSALSTRING) +-DECLARE_ASN1_FUNCTIONS(ASN1_UTF8STRING) +-DECLARE_ASN1_FUNCTIONS(ASN1_NULL) +-DECLARE_ASN1_FUNCTIONS(ASN1_BMPSTRING) +- +-int UTF8_getc(const unsigned char *str, int len, unsigned long *val); +-int UTF8_putc(unsigned char *str, int len, unsigned long value); +- +-DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, ASN1_PRINTABLE) +- +-DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, DIRECTORYSTRING) +-DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, DISPLAYTEXT) +-DECLARE_ASN1_FUNCTIONS(ASN1_PRINTABLESTRING) +-DECLARE_ASN1_FUNCTIONS(ASN1_T61STRING) +-DECLARE_ASN1_FUNCTIONS(ASN1_IA5STRING) +-DECLARE_ASN1_FUNCTIONS(ASN1_GENERALSTRING) +-DECLARE_ASN1_FUNCTIONS(ASN1_UTCTIME) +-DECLARE_ASN1_FUNCTIONS(ASN1_GENERALIZEDTIME) +-DECLARE_ASN1_FUNCTIONS(ASN1_TIME) +- +-DECLARE_ASN1_ITEM(ASN1_OCTET_STRING_NDEF) +- +-ASN1_TIME *ASN1_TIME_set(ASN1_TIME *s, time_t t); +-ASN1_TIME *ASN1_TIME_adj(ASN1_TIME *s, time_t t, +- int offset_day, long offset_sec); +-int ASN1_TIME_check(const ASN1_TIME *t); +-ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(const ASN1_TIME *t, +- ASN1_GENERALIZEDTIME **out); +-int ASN1_TIME_set_string(ASN1_TIME *s, const char *str); +-int ASN1_TIME_set_string_X509(ASN1_TIME *s, const char *str); +-int ASN1_TIME_to_tm(const ASN1_TIME *s, struct tm *tm); +-int ASN1_TIME_normalize(ASN1_TIME *s); +-int ASN1_TIME_cmp_time_t(const ASN1_TIME *s, time_t t); +-int ASN1_TIME_compare(const ASN1_TIME *a, const ASN1_TIME *b); +- +-int i2a_ASN1_INTEGER(BIO *bp, const ASN1_INTEGER *a); +-int a2i_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *bs, char *buf, int size); +-int i2a_ASN1_ENUMERATED(BIO *bp, const ASN1_ENUMERATED *a); +-int a2i_ASN1_ENUMERATED(BIO *bp, ASN1_ENUMERATED *bs, char *buf, int size); +-int i2a_ASN1_OBJECT(BIO *bp, const ASN1_OBJECT *a); +-int a2i_ASN1_STRING(BIO *bp, ASN1_STRING *bs, char *buf, int size); +-int i2a_ASN1_STRING(BIO *bp, const ASN1_STRING *a, int type); +-int i2t_ASN1_OBJECT(char *buf, int buf_len, const ASN1_OBJECT *a); +- +-int a2d_ASN1_OBJECT(unsigned char *out, int olen, const char *buf, int num); +-ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data, int len, +- const char *sn, const char *ln); +- +-int ASN1_INTEGER_get_int64(int64_t *pr, const ASN1_INTEGER *a); +-int ASN1_INTEGER_set_int64(ASN1_INTEGER *a, int64_t r); +-int ASN1_INTEGER_get_uint64(uint64_t *pr, const ASN1_INTEGER *a); +-int ASN1_INTEGER_set_uint64(ASN1_INTEGER *a, uint64_t r); +- +-int ASN1_INTEGER_set(ASN1_INTEGER *a, long v); +-long ASN1_INTEGER_get(const ASN1_INTEGER *a); +-ASN1_INTEGER *BN_to_ASN1_INTEGER(const BIGNUM *bn, ASN1_INTEGER *ai); +-BIGNUM *ASN1_INTEGER_to_BN(const ASN1_INTEGER *ai, BIGNUM *bn); +- +-int ASN1_ENUMERATED_get_int64(int64_t *pr, const ASN1_ENUMERATED *a); +-int ASN1_ENUMERATED_set_int64(ASN1_ENUMERATED *a, int64_t r); +- +- +-int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v); +-long ASN1_ENUMERATED_get(const ASN1_ENUMERATED *a); +-ASN1_ENUMERATED *BN_to_ASN1_ENUMERATED(const BIGNUM *bn, ASN1_ENUMERATED *ai); +-BIGNUM *ASN1_ENUMERATED_to_BN(const ASN1_ENUMERATED *ai, BIGNUM *bn); +- +-/* General */ +-/* given a string, return the correct type, max is the maximum length */ +-int ASN1_PRINTABLE_type(const unsigned char *s, int max); +- +-unsigned long ASN1_tag2bit(int tag); +- +-/* SPECIALS */ +-int ASN1_get_object(const unsigned char **pp, long *plength, int *ptag, +- int *pclass, long omax); +-int ASN1_check_infinite_end(unsigned char **p, long len); +-int ASN1_const_check_infinite_end(const unsigned char **p, long len); +-void ASN1_put_object(unsigned char **pp, int constructed, int length, +- int tag, int xclass); +-int ASN1_put_eoc(unsigned char **pp); +-int ASN1_object_size(int constructed, int length, int tag); +- +-/* Used to implement other functions */ +-void *ASN1_dup(i2d_of_void *i2d, d2i_of_void *d2i, void *x); +- +-# define ASN1_dup_of(type,i2d,d2i,x) \ +- ((type*)ASN1_dup(CHECKED_I2D_OF(type, i2d), \ +- CHECKED_D2I_OF(type, d2i), \ +- CHECKED_PTR_OF(type, x))) +- +-# define ASN1_dup_of_const(type,i2d,d2i,x) \ +- ((type*)ASN1_dup(CHECKED_I2D_OF(const type, i2d), \ +- CHECKED_D2I_OF(type, d2i), \ +- CHECKED_PTR_OF(const type, x))) +- +-void *ASN1_item_dup(const ASN1_ITEM *it, void *x); +- +-/* ASN1 alloc/free macros for when a type is only used internally */ +- +-# define M_ASN1_new_of(type) (type *)ASN1_item_new(ASN1_ITEM_rptr(type)) +-# define M_ASN1_free_of(x, type) \ +- ASN1_item_free(CHECKED_PTR_OF(type, x), ASN1_ITEM_rptr(type)) +- +-# ifndef OPENSSL_NO_STDIO +-void *ASN1_d2i_fp(void *(*xnew) (void), d2i_of_void *d2i, FILE *in, void **x); +- +-# define ASN1_d2i_fp_of(type,xnew,d2i,in,x) \ +- ((type*)ASN1_d2i_fp(CHECKED_NEW_OF(type, xnew), \ +- CHECKED_D2I_OF(type, d2i), \ +- in, \ +- CHECKED_PPTR_OF(type, x))) +- +-void *ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x); +-int ASN1_i2d_fp(i2d_of_void *i2d, FILE *out, void *x); +- +-# define ASN1_i2d_fp_of(type,i2d,out,x) \ +- (ASN1_i2d_fp(CHECKED_I2D_OF(type, i2d), \ +- out, \ +- CHECKED_PTR_OF(type, x))) +- +-# define ASN1_i2d_fp_of_const(type,i2d,out,x) \ +- (ASN1_i2d_fp(CHECKED_I2D_OF(const type, i2d), \ +- out, \ +- CHECKED_PTR_OF(const type, x))) +- +-int ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, void *x); +-int ASN1_STRING_print_ex_fp(FILE *fp, const ASN1_STRING *str, unsigned long flags); +-# endif +- +-int ASN1_STRING_to_UTF8(unsigned char **out, const ASN1_STRING *in); +- +-void *ASN1_d2i_bio(void *(*xnew) (void), d2i_of_void *d2i, BIO *in, void **x); +- +-# define ASN1_d2i_bio_of(type,xnew,d2i,in,x) \ +- ((type*)ASN1_d2i_bio( CHECKED_NEW_OF(type, xnew), \ +- CHECKED_D2I_OF(type, d2i), \ +- in, \ +- CHECKED_PPTR_OF(type, x))) +- +-void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *x); +-int ASN1_i2d_bio(i2d_of_void *i2d, BIO *out, unsigned char *x); +- +-# define ASN1_i2d_bio_of(type,i2d,out,x) \ +- (ASN1_i2d_bio(CHECKED_I2D_OF(type, i2d), \ +- out, \ +- CHECKED_PTR_OF(type, x))) +- +-# define ASN1_i2d_bio_of_const(type,i2d,out,x) \ +- (ASN1_i2d_bio(CHECKED_I2D_OF(const type, i2d), \ +- out, \ +- CHECKED_PTR_OF(const type, x))) +- +-int ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, void *x); +-int ASN1_UTCTIME_print(BIO *fp, const ASN1_UTCTIME *a); +-int ASN1_GENERALIZEDTIME_print(BIO *fp, const ASN1_GENERALIZEDTIME *a); +-int ASN1_TIME_print(BIO *fp, const ASN1_TIME *a); +-int ASN1_STRING_print(BIO *bp, const ASN1_STRING *v); +-int ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str, unsigned long flags); +-int ASN1_buf_print(BIO *bp, const unsigned char *buf, size_t buflen, int off); +-int ASN1_bn_print(BIO *bp, const char *number, const BIGNUM *num, +- unsigned char *buf, int off); +-int ASN1_parse(BIO *bp, const unsigned char *pp, long len, int indent); +-int ASN1_parse_dump(BIO *bp, const unsigned char *pp, long len, int indent, +- int dump); +-const char *ASN1_tag2str(int tag); +- +-/* Used to load and write Netscape format cert */ +- +-int ASN1_UNIVERSALSTRING_to_string(ASN1_UNIVERSALSTRING *s); +- +-int ASN1_TYPE_set_octetstring(ASN1_TYPE *a, unsigned char *data, int len); +-int ASN1_TYPE_get_octetstring(const ASN1_TYPE *a, unsigned char *data, int max_len); +-int ASN1_TYPE_set_int_octetstring(ASN1_TYPE *a, long num, +- unsigned char *data, int len); +-int ASN1_TYPE_get_int_octetstring(const ASN1_TYPE *a, long *num, +- unsigned char *data, int max_len); +- +-void *ASN1_item_unpack(const ASN1_STRING *oct, const ASN1_ITEM *it); +- +-ASN1_STRING *ASN1_item_pack(void *obj, const ASN1_ITEM *it, +- ASN1_OCTET_STRING **oct); +- +-void ASN1_STRING_set_default_mask(unsigned long mask); +-int ASN1_STRING_set_default_mask_asc(const char *p); +-unsigned long ASN1_STRING_get_default_mask(void); +-int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, int len, +- int inform, unsigned long mask); +-int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len, +- int inform, unsigned long mask, +- long minsize, long maxsize); +- +-ASN1_STRING *ASN1_STRING_set_by_NID(ASN1_STRING **out, +- const unsigned char *in, int inlen, +- int inform, int nid); +-ASN1_STRING_TABLE *ASN1_STRING_TABLE_get(int nid); +-int ASN1_STRING_TABLE_add(int, long, long, unsigned long, unsigned long); +-void ASN1_STRING_TABLE_cleanup(void); +- +-/* ASN1 template functions */ +- +-/* Old API compatible functions */ +-ASN1_VALUE *ASN1_item_new(const ASN1_ITEM *it); +-void ASN1_item_free(ASN1_VALUE *val, const ASN1_ITEM *it); +-ASN1_VALUE *ASN1_item_d2i(ASN1_VALUE **val, const unsigned char **in, +- long len, const ASN1_ITEM *it); +-int ASN1_item_i2d(ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it); +-int ASN1_item_ndef_i2d(ASN1_VALUE *val, unsigned char **out, +- const ASN1_ITEM *it); +- +-void ASN1_add_oid_module(void); +-void ASN1_add_stable_module(void); +- +-ASN1_TYPE *ASN1_generate_nconf(const char *str, CONF *nconf); +-ASN1_TYPE *ASN1_generate_v3(const char *str, X509V3_CTX *cnf); +-int ASN1_str2mask(const char *str, unsigned long *pmask); +- +-/* ASN1 Print flags */ +- +-/* Indicate missing OPTIONAL fields */ +-# define ASN1_PCTX_FLAGS_SHOW_ABSENT 0x001 +-/* Mark start and end of SEQUENCE */ +-# define ASN1_PCTX_FLAGS_SHOW_SEQUENCE 0x002 +-/* Mark start and end of SEQUENCE/SET OF */ +-# define ASN1_PCTX_FLAGS_SHOW_SSOF 0x004 +-/* Show the ASN1 type of primitives */ +-# define ASN1_PCTX_FLAGS_SHOW_TYPE 0x008 +-/* Don't show ASN1 type of ANY */ +-# define ASN1_PCTX_FLAGS_NO_ANY_TYPE 0x010 +-/* Don't show ASN1 type of MSTRINGs */ +-# define ASN1_PCTX_FLAGS_NO_MSTRING_TYPE 0x020 +-/* Don't show field names in SEQUENCE */ +-# define ASN1_PCTX_FLAGS_NO_FIELD_NAME 0x040 +-/* Show structure names of each SEQUENCE field */ +-# define ASN1_PCTX_FLAGS_SHOW_FIELD_STRUCT_NAME 0x080 +-/* Don't show structure name even at top level */ +-# define ASN1_PCTX_FLAGS_NO_STRUCT_NAME 0x100 +- +-int ASN1_item_print(BIO *out, ASN1_VALUE *ifld, int indent, +- const ASN1_ITEM *it, const ASN1_PCTX *pctx); +-ASN1_PCTX *ASN1_PCTX_new(void); +-void ASN1_PCTX_free(ASN1_PCTX *p); +-unsigned long ASN1_PCTX_get_flags(const ASN1_PCTX *p); +-void ASN1_PCTX_set_flags(ASN1_PCTX *p, unsigned long flags); +-unsigned long ASN1_PCTX_get_nm_flags(const ASN1_PCTX *p); +-void ASN1_PCTX_set_nm_flags(ASN1_PCTX *p, unsigned long flags); +-unsigned long ASN1_PCTX_get_cert_flags(const ASN1_PCTX *p); +-void ASN1_PCTX_set_cert_flags(ASN1_PCTX *p, unsigned long flags); +-unsigned long ASN1_PCTX_get_oid_flags(const ASN1_PCTX *p); +-void ASN1_PCTX_set_oid_flags(ASN1_PCTX *p, unsigned long flags); +-unsigned long ASN1_PCTX_get_str_flags(const ASN1_PCTX *p); +-void ASN1_PCTX_set_str_flags(ASN1_PCTX *p, unsigned long flags); +- +-ASN1_SCTX *ASN1_SCTX_new(int (*scan_cb) (ASN1_SCTX *ctx)); +-void ASN1_SCTX_free(ASN1_SCTX *p); +-const ASN1_ITEM *ASN1_SCTX_get_item(ASN1_SCTX *p); +-const ASN1_TEMPLATE *ASN1_SCTX_get_template(ASN1_SCTX *p); +-unsigned long ASN1_SCTX_get_flags(ASN1_SCTX *p); +-void ASN1_SCTX_set_app_data(ASN1_SCTX *p, void *data); +-void *ASN1_SCTX_get_app_data(ASN1_SCTX *p); +- +-const BIO_METHOD *BIO_f_asn1(void); +- +-BIO *BIO_new_NDEF(BIO *out, ASN1_VALUE *val, const ASN1_ITEM *it); +- +-int i2d_ASN1_bio_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags, +- const ASN1_ITEM *it); +-int PEM_write_bio_ASN1_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags, +- const char *hdr, const ASN1_ITEM *it); +-int SMIME_write_ASN1(BIO *bio, ASN1_VALUE *val, BIO *data, int flags, +- int ctype_nid, int econt_nid, +- STACK_OF(X509_ALGOR) *mdalgs, const ASN1_ITEM *it); +-ASN1_VALUE *SMIME_read_ASN1(BIO *bio, BIO **bcont, const ASN1_ITEM *it); +-int SMIME_crlf_copy(BIO *in, BIO *out, int flags); +-int SMIME_text(BIO *in, BIO *out); +- +-const ASN1_ITEM *ASN1_ITEM_lookup(const char *name); +-const ASN1_ITEM *ASN1_ITEM_get(size_t i); +- +-# ifdef __cplusplus +-} +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/asn1_mac.h b/uadk_tool/include/openssl/asn1_mac.h +deleted file mode 100644 +index 7ac1782..0000000 +--- a/uadk_tool/include/openssl/asn1_mac.h ++++ /dev/null +@@ -1,10 +0,0 @@ +-/* +- * Copyright 2015-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#error "This file is obsolete; please update your software." +diff --git a/uadk_tool/include/openssl/asn1err.h b/uadk_tool/include/openssl/asn1err.h +deleted file mode 100644 +index e1ad1fe..0000000 +--- a/uadk_tool/include/openssl/asn1err.h ++++ /dev/null +@@ -1,256 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_ASN1ERR_H +-# define HEADER_ASN1ERR_H +- +-# include +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_ASN1_strings(void); +- +-/* +- * ASN1 function codes. +- */ +-# define ASN1_F_A2D_ASN1_OBJECT 100 +-# define ASN1_F_A2I_ASN1_INTEGER 102 +-# define ASN1_F_A2I_ASN1_STRING 103 +-# define ASN1_F_APPEND_EXP 176 +-# define ASN1_F_ASN1_BIO_INIT 113 +-# define ASN1_F_ASN1_BIT_STRING_SET_BIT 183 +-# define ASN1_F_ASN1_CB 177 +-# define ASN1_F_ASN1_CHECK_TLEN 104 +-# define ASN1_F_ASN1_COLLECT 106 +-# define ASN1_F_ASN1_D2I_EX_PRIMITIVE 108 +-# define ASN1_F_ASN1_D2I_FP 109 +-# define ASN1_F_ASN1_D2I_READ_BIO 107 +-# define ASN1_F_ASN1_DIGEST 184 +-# define ASN1_F_ASN1_DO_ADB 110 +-# define ASN1_F_ASN1_DO_LOCK 233 +-# define ASN1_F_ASN1_DUP 111 +-# define ASN1_F_ASN1_ENC_SAVE 115 +-# define ASN1_F_ASN1_EX_C2I 204 +-# define ASN1_F_ASN1_FIND_END 190 +-# define ASN1_F_ASN1_GENERALIZEDTIME_ADJ 216 +-# define ASN1_F_ASN1_GENERATE_V3 178 +-# define ASN1_F_ASN1_GET_INT64 224 +-# define ASN1_F_ASN1_GET_OBJECT 114 +-# define ASN1_F_ASN1_GET_UINT64 225 +-# define ASN1_F_ASN1_I2D_BIO 116 +-# define ASN1_F_ASN1_I2D_FP 117 +-# define ASN1_F_ASN1_ITEM_D2I_FP 206 +-# define ASN1_F_ASN1_ITEM_DUP 191 +-# define ASN1_F_ASN1_ITEM_EMBED_D2I 120 +-# define ASN1_F_ASN1_ITEM_EMBED_NEW 121 +-# define ASN1_F_ASN1_ITEM_EX_I2D 144 +-# define ASN1_F_ASN1_ITEM_FLAGS_I2D 118 +-# define ASN1_F_ASN1_ITEM_I2D_BIO 192 +-# define ASN1_F_ASN1_ITEM_I2D_FP 193 +-# define ASN1_F_ASN1_ITEM_PACK 198 +-# define ASN1_F_ASN1_ITEM_SIGN 195 +-# define ASN1_F_ASN1_ITEM_SIGN_CTX 220 +-# define ASN1_F_ASN1_ITEM_UNPACK 199 +-# define ASN1_F_ASN1_ITEM_VERIFY 197 +-# define ASN1_F_ASN1_MBSTRING_NCOPY 122 +-# define ASN1_F_ASN1_OBJECT_NEW 123 +-# define ASN1_F_ASN1_OUTPUT_DATA 214 +-# define ASN1_F_ASN1_PCTX_NEW 205 +-# define ASN1_F_ASN1_PRIMITIVE_NEW 119 +-# define ASN1_F_ASN1_SCTX_NEW 221 +-# define ASN1_F_ASN1_SIGN 128 +-# define ASN1_F_ASN1_STR2TYPE 179 +-# define ASN1_F_ASN1_STRING_GET_INT64 227 +-# define ASN1_F_ASN1_STRING_GET_UINT64 230 +-# define ASN1_F_ASN1_STRING_SET 186 +-# define ASN1_F_ASN1_STRING_TABLE_ADD 129 +-# define ASN1_F_ASN1_STRING_TO_BN 228 +-# define ASN1_F_ASN1_STRING_TYPE_NEW 130 +-# define ASN1_F_ASN1_TEMPLATE_EX_D2I 132 +-# define ASN1_F_ASN1_TEMPLATE_NEW 133 +-# define ASN1_F_ASN1_TEMPLATE_NOEXP_D2I 131 +-# define ASN1_F_ASN1_TIME_ADJ 217 +-# define ASN1_F_ASN1_TYPE_GET_INT_OCTETSTRING 134 +-# define ASN1_F_ASN1_TYPE_GET_OCTETSTRING 135 +-# define ASN1_F_ASN1_UTCTIME_ADJ 218 +-# define ASN1_F_ASN1_VERIFY 137 +-# define ASN1_F_B64_READ_ASN1 209 +-# define ASN1_F_B64_WRITE_ASN1 210 +-# define ASN1_F_BIO_NEW_NDEF 208 +-# define ASN1_F_BITSTR_CB 180 +-# define ASN1_F_BN_TO_ASN1_STRING 229 +-# define ASN1_F_C2I_ASN1_BIT_STRING 189 +-# define ASN1_F_C2I_ASN1_INTEGER 194 +-# define ASN1_F_C2I_ASN1_OBJECT 196 +-# define ASN1_F_C2I_IBUF 226 +-# define ASN1_F_C2I_UINT64_INT 101 +-# define ASN1_F_COLLECT_DATA 140 +-# define ASN1_F_D2I_ASN1_OBJECT 147 +-# define ASN1_F_D2I_ASN1_UINTEGER 150 +-# define ASN1_F_D2I_AUTOPRIVATEKEY 207 +-# define ASN1_F_D2I_PRIVATEKEY 154 +-# define ASN1_F_D2I_PUBLICKEY 155 +-# define ASN1_F_DO_BUF 142 +-# define ASN1_F_DO_CREATE 124 +-# define ASN1_F_DO_DUMP 125 +-# define ASN1_F_DO_TCREATE 222 +-# define ASN1_F_I2A_ASN1_OBJECT 126 +-# define ASN1_F_I2D_ASN1_BIO_STREAM 211 +-# define ASN1_F_I2D_ASN1_OBJECT 143 +-# define ASN1_F_I2D_DSA_PUBKEY 161 +-# define ASN1_F_I2D_EC_PUBKEY 181 +-# define ASN1_F_I2D_PRIVATEKEY 163 +-# define ASN1_F_I2D_PUBLICKEY 164 +-# define ASN1_F_I2D_RSA_PUBKEY 165 +-# define ASN1_F_LONG_C2I 166 +-# define ASN1_F_NDEF_PREFIX 127 +-# define ASN1_F_NDEF_SUFFIX 136 +-# define ASN1_F_OID_MODULE_INIT 174 +-# define ASN1_F_PARSE_TAGGING 182 +-# define ASN1_F_PKCS5_PBE2_SET_IV 167 +-# define ASN1_F_PKCS5_PBE2_SET_SCRYPT 231 +-# define ASN1_F_PKCS5_PBE_SET 202 +-# define ASN1_F_PKCS5_PBE_SET0_ALGOR 215 +-# define ASN1_F_PKCS5_PBKDF2_SET 219 +-# define ASN1_F_PKCS5_SCRYPT_SET 232 +-# define ASN1_F_SMIME_READ_ASN1 212 +-# define ASN1_F_SMIME_TEXT 213 +-# define ASN1_F_STABLE_GET 138 +-# define ASN1_F_STBL_MODULE_INIT 223 +-# define ASN1_F_UINT32_C2I 105 +-# define ASN1_F_UINT32_NEW 139 +-# define ASN1_F_UINT64_C2I 112 +-# define ASN1_F_UINT64_NEW 141 +-# define ASN1_F_X509_CRL_ADD0_REVOKED 169 +-# define ASN1_F_X509_INFO_NEW 170 +-# define ASN1_F_X509_NAME_ENCODE 203 +-# define ASN1_F_X509_NAME_EX_D2I 158 +-# define ASN1_F_X509_NAME_EX_NEW 171 +-# define ASN1_F_X509_PKEY_NEW 173 +- +-/* +- * ASN1 reason codes. +- */ +-# define ASN1_R_ADDING_OBJECT 171 +-# define ASN1_R_ASN1_PARSE_ERROR 203 +-# define ASN1_R_ASN1_SIG_PARSE_ERROR 204 +-# define ASN1_R_AUX_ERROR 100 +-# define ASN1_R_BAD_OBJECT_HEADER 102 +-# define ASN1_R_BAD_TEMPLATE 230 +-# define ASN1_R_BMPSTRING_IS_WRONG_LENGTH 214 +-# define ASN1_R_BN_LIB 105 +-# define ASN1_R_BOOLEAN_IS_WRONG_LENGTH 106 +-# define ASN1_R_BUFFER_TOO_SMALL 107 +-# define ASN1_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER 108 +-# define ASN1_R_CONTEXT_NOT_INITIALISED 217 +-# define ASN1_R_DATA_IS_WRONG 109 +-# define ASN1_R_DECODE_ERROR 110 +-# define ASN1_R_DEPTH_EXCEEDED 174 +-# define ASN1_R_DIGEST_AND_KEY_TYPE_NOT_SUPPORTED 198 +-# define ASN1_R_ENCODE_ERROR 112 +-# define ASN1_R_ERROR_GETTING_TIME 173 +-# define ASN1_R_ERROR_LOADING_SECTION 172 +-# define ASN1_R_ERROR_SETTING_CIPHER_PARAMS 114 +-# define ASN1_R_EXPECTING_AN_INTEGER 115 +-# define ASN1_R_EXPECTING_AN_OBJECT 116 +-# define ASN1_R_EXPLICIT_LENGTH_MISMATCH 119 +-# define ASN1_R_EXPLICIT_TAG_NOT_CONSTRUCTED 120 +-# define ASN1_R_FIELD_MISSING 121 +-# define ASN1_R_FIRST_NUM_TOO_LARGE 122 +-# define ASN1_R_HEADER_TOO_LONG 123 +-# define ASN1_R_ILLEGAL_BITSTRING_FORMAT 175 +-# define ASN1_R_ILLEGAL_BOOLEAN 176 +-# define ASN1_R_ILLEGAL_CHARACTERS 124 +-# define ASN1_R_ILLEGAL_FORMAT 177 +-# define ASN1_R_ILLEGAL_HEX 178 +-# define ASN1_R_ILLEGAL_IMPLICIT_TAG 179 +-# define ASN1_R_ILLEGAL_INTEGER 180 +-# define ASN1_R_ILLEGAL_NEGATIVE_VALUE 226 +-# define ASN1_R_ILLEGAL_NESTED_TAGGING 181 +-# define ASN1_R_ILLEGAL_NULL 125 +-# define ASN1_R_ILLEGAL_NULL_VALUE 182 +-# define ASN1_R_ILLEGAL_OBJECT 183 +-# define ASN1_R_ILLEGAL_OPTIONAL_ANY 126 +-# define ASN1_R_ILLEGAL_OPTIONS_ON_ITEM_TEMPLATE 170 +-# define ASN1_R_ILLEGAL_PADDING 221 +-# define ASN1_R_ILLEGAL_TAGGED_ANY 127 +-# define ASN1_R_ILLEGAL_TIME_VALUE 184 +-# define ASN1_R_ILLEGAL_ZERO_CONTENT 222 +-# define ASN1_R_INTEGER_NOT_ASCII_FORMAT 185 +-# define ASN1_R_INTEGER_TOO_LARGE_FOR_LONG 128 +-# define ASN1_R_INVALID_BIT_STRING_BITS_LEFT 220 +-# define ASN1_R_INVALID_BMPSTRING_LENGTH 129 +-# define ASN1_R_INVALID_DIGIT 130 +-# define ASN1_R_INVALID_MIME_TYPE 205 +-# define ASN1_R_INVALID_MODIFIER 186 +-# define ASN1_R_INVALID_NUMBER 187 +-# define ASN1_R_INVALID_OBJECT_ENCODING 216 +-# define ASN1_R_INVALID_SCRYPT_PARAMETERS 227 +-# define ASN1_R_INVALID_SEPARATOR 131 +-# define ASN1_R_INVALID_STRING_TABLE_VALUE 218 +-# define ASN1_R_INVALID_UNIVERSALSTRING_LENGTH 133 +-# define ASN1_R_INVALID_UTF8STRING 134 +-# define ASN1_R_INVALID_VALUE 219 +-# define ASN1_R_LIST_ERROR 188 +-# define ASN1_R_MIME_NO_CONTENT_TYPE 206 +-# define ASN1_R_MIME_PARSE_ERROR 207 +-# define ASN1_R_MIME_SIG_PARSE_ERROR 208 +-# define ASN1_R_MISSING_EOC 137 +-# define ASN1_R_MISSING_SECOND_NUMBER 138 +-# define ASN1_R_MISSING_VALUE 189 +-# define ASN1_R_MSTRING_NOT_UNIVERSAL 139 +-# define ASN1_R_MSTRING_WRONG_TAG 140 +-# define ASN1_R_NESTED_ASN1_STRING 197 +-# define ASN1_R_NESTED_TOO_DEEP 201 +-# define ASN1_R_NON_HEX_CHARACTERS 141 +-# define ASN1_R_NOT_ASCII_FORMAT 190 +-# define ASN1_R_NOT_ENOUGH_DATA 142 +-# define ASN1_R_NO_CONTENT_TYPE 209 +-# define ASN1_R_NO_MATCHING_CHOICE_TYPE 143 +-# define ASN1_R_NO_MULTIPART_BODY_FAILURE 210 +-# define ASN1_R_NO_MULTIPART_BOUNDARY 211 +-# define ASN1_R_NO_SIG_CONTENT_TYPE 212 +-# define ASN1_R_NULL_IS_WRONG_LENGTH 144 +-# define ASN1_R_OBJECT_NOT_ASCII_FORMAT 191 +-# define ASN1_R_ODD_NUMBER_OF_CHARS 145 +-# define ASN1_R_SECOND_NUMBER_TOO_LARGE 147 +-# define ASN1_R_SEQUENCE_LENGTH_MISMATCH 148 +-# define ASN1_R_SEQUENCE_NOT_CONSTRUCTED 149 +-# define ASN1_R_SEQUENCE_OR_SET_NEEDS_CONFIG 192 +-# define ASN1_R_SHORT_LINE 150 +-# define ASN1_R_SIG_INVALID_MIME_TYPE 213 +-# define ASN1_R_STREAMING_NOT_SUPPORTED 202 +-# define ASN1_R_STRING_TOO_LONG 151 +-# define ASN1_R_STRING_TOO_SHORT 152 +-# define ASN1_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD 154 +-# define ASN1_R_TIME_NOT_ASCII_FORMAT 193 +-# define ASN1_R_TOO_LARGE 223 +-# define ASN1_R_TOO_LONG 155 +-# define ASN1_R_TOO_SMALL 224 +-# define ASN1_R_TYPE_NOT_CONSTRUCTED 156 +-# define ASN1_R_TYPE_NOT_PRIMITIVE 195 +-# define ASN1_R_UNEXPECTED_EOC 159 +-# define ASN1_R_UNIVERSALSTRING_IS_WRONG_LENGTH 215 +-# define ASN1_R_UNKNOWN_FORMAT 160 +-# define ASN1_R_UNKNOWN_MESSAGE_DIGEST_ALGORITHM 161 +-# define ASN1_R_UNKNOWN_OBJECT_TYPE 162 +-# define ASN1_R_UNKNOWN_PUBLIC_KEY_TYPE 163 +-# define ASN1_R_UNKNOWN_SIGNATURE_ALGORITHM 199 +-# define ASN1_R_UNKNOWN_TAG 194 +-# define ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE 164 +-# define ASN1_R_UNSUPPORTED_CIPHER 228 +-# define ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE 167 +-# define ASN1_R_UNSUPPORTED_TYPE 196 +-# define ASN1_R_WRONG_INTEGER_TYPE 225 +-# define ASN1_R_WRONG_PUBLIC_KEY_TYPE 200 +-# define ASN1_R_WRONG_TAG 168 +- +-#endif +diff --git a/uadk_tool/include/openssl/asn1t.h b/uadk_tool/include/openssl/asn1t.h +deleted file mode 100644 +index a450ba0..0000000 +--- a/uadk_tool/include/openssl/asn1t.h ++++ /dev/null +@@ -1,945 +0,0 @@ +-/* +- * Copyright 2000-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_ASN1T_H +-# define HEADER_ASN1T_H +- +-# include +-# include +-# include +- +-# ifdef OPENSSL_BUILD_SHLIBCRYPTO +-# undef OPENSSL_EXTERN +-# define OPENSSL_EXTERN OPENSSL_EXPORT +-# endif +- +-/* ASN1 template defines, structures and functions */ +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-# ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION +- +-/* Macro to obtain ASN1_ADB pointer from a type (only used internally) */ +-# define ASN1_ADB_ptr(iptr) ((const ASN1_ADB *)(iptr)) +- +-/* Macros for start and end of ASN1_ITEM definition */ +- +-# define ASN1_ITEM_start(itname) \ +- const ASN1_ITEM itname##_it = { +- +-# define static_ASN1_ITEM_start(itname) \ +- static const ASN1_ITEM itname##_it = { +- +-# define ASN1_ITEM_end(itname) \ +- }; +- +-# else +- +-/* Macro to obtain ASN1_ADB pointer from a type (only used internally) */ +-# define ASN1_ADB_ptr(iptr) ((const ASN1_ADB *)((iptr)())) +- +-/* Macros for start and end of ASN1_ITEM definition */ +- +-# define ASN1_ITEM_start(itname) \ +- const ASN1_ITEM * itname##_it(void) \ +- { \ +- static const ASN1_ITEM local_it = { +- +-# define static_ASN1_ITEM_start(itname) \ +- static ASN1_ITEM_start(itname) +- +-# define ASN1_ITEM_end(itname) \ +- }; \ +- return &local_it; \ +- } +- +-# endif +- +-/* Macros to aid ASN1 template writing */ +- +-# define ASN1_ITEM_TEMPLATE(tname) \ +- static const ASN1_TEMPLATE tname##_item_tt +- +-# define ASN1_ITEM_TEMPLATE_END(tname) \ +- ;\ +- ASN1_ITEM_start(tname) \ +- ASN1_ITYPE_PRIMITIVE,\ +- -1,\ +- &tname##_item_tt,\ +- 0,\ +- NULL,\ +- 0,\ +- #tname \ +- ASN1_ITEM_end(tname) +-# define static_ASN1_ITEM_TEMPLATE_END(tname) \ +- ;\ +- static_ASN1_ITEM_start(tname) \ +- ASN1_ITYPE_PRIMITIVE,\ +- -1,\ +- &tname##_item_tt,\ +- 0,\ +- NULL,\ +- 0,\ +- #tname \ +- ASN1_ITEM_end(tname) +- +-/* This is a ASN1 type which just embeds a template */ +- +-/*- +- * This pair helps declare a SEQUENCE. We can do: +- * +- * ASN1_SEQUENCE(stname) = { +- * ... SEQUENCE components ... +- * } ASN1_SEQUENCE_END(stname) +- * +- * This will produce an ASN1_ITEM called stname_it +- * for a structure called stname. +- * +- * If you want the same structure but a different +- * name then use: +- * +- * ASN1_SEQUENCE(itname) = { +- * ... SEQUENCE components ... +- * } ASN1_SEQUENCE_END_name(stname, itname) +- * +- * This will create an item called itname_it using +- * a structure called stname. +- */ +- +-# define ASN1_SEQUENCE(tname) \ +- static const ASN1_TEMPLATE tname##_seq_tt[] +- +-# define ASN1_SEQUENCE_END(stname) ASN1_SEQUENCE_END_name(stname, stname) +- +-# define static_ASN1_SEQUENCE_END(stname) static_ASN1_SEQUENCE_END_name(stname, stname) +- +-# define ASN1_SEQUENCE_END_name(stname, tname) \ +- ;\ +- ASN1_ITEM_start(tname) \ +- ASN1_ITYPE_SEQUENCE,\ +- V_ASN1_SEQUENCE,\ +- tname##_seq_tt,\ +- sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ +- NULL,\ +- sizeof(stname),\ +- #tname \ +- ASN1_ITEM_end(tname) +- +-# define static_ASN1_SEQUENCE_END_name(stname, tname) \ +- ;\ +- static_ASN1_ITEM_start(tname) \ +- ASN1_ITYPE_SEQUENCE,\ +- V_ASN1_SEQUENCE,\ +- tname##_seq_tt,\ +- sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ +- NULL,\ +- sizeof(stname),\ +- #stname \ +- ASN1_ITEM_end(tname) +- +-# define ASN1_NDEF_SEQUENCE(tname) \ +- ASN1_SEQUENCE(tname) +- +-# define ASN1_NDEF_SEQUENCE_cb(tname, cb) \ +- ASN1_SEQUENCE_cb(tname, cb) +- +-# define ASN1_SEQUENCE_cb(tname, cb) \ +- static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0}; \ +- ASN1_SEQUENCE(tname) +- +-# define ASN1_BROKEN_SEQUENCE(tname) \ +- static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_BROKEN, 0, 0, 0, 0}; \ +- ASN1_SEQUENCE(tname) +- +-# define ASN1_SEQUENCE_ref(tname, cb) \ +- static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_REFCOUNT, offsetof(tname, references), offsetof(tname, lock), cb, 0}; \ +- ASN1_SEQUENCE(tname) +- +-# define ASN1_SEQUENCE_enc(tname, enc, cb) \ +- static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_ENCODING, 0, 0, cb, offsetof(tname, enc)}; \ +- ASN1_SEQUENCE(tname) +- +-# define ASN1_NDEF_SEQUENCE_END(tname) \ +- ;\ +- ASN1_ITEM_start(tname) \ +- ASN1_ITYPE_NDEF_SEQUENCE,\ +- V_ASN1_SEQUENCE,\ +- tname##_seq_tt,\ +- sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ +- NULL,\ +- sizeof(tname),\ +- #tname \ +- ASN1_ITEM_end(tname) +-# define static_ASN1_NDEF_SEQUENCE_END(tname) \ +- ;\ +- static_ASN1_ITEM_start(tname) \ +- ASN1_ITYPE_NDEF_SEQUENCE,\ +- V_ASN1_SEQUENCE,\ +- tname##_seq_tt,\ +- sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ +- NULL,\ +- sizeof(tname),\ +- #tname \ +- ASN1_ITEM_end(tname) +- +-# define ASN1_BROKEN_SEQUENCE_END(stname) ASN1_SEQUENCE_END_ref(stname, stname) +-# define static_ASN1_BROKEN_SEQUENCE_END(stname) \ +- static_ASN1_SEQUENCE_END_ref(stname, stname) +- +-# define ASN1_SEQUENCE_END_enc(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname) +- +-# define ASN1_SEQUENCE_END_cb(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname) +-# define static_ASN1_SEQUENCE_END_cb(stname, tname) static_ASN1_SEQUENCE_END_ref(stname, tname) +- +-# define ASN1_SEQUENCE_END_ref(stname, tname) \ +- ;\ +- ASN1_ITEM_start(tname) \ +- ASN1_ITYPE_SEQUENCE,\ +- V_ASN1_SEQUENCE,\ +- tname##_seq_tt,\ +- sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ +- &tname##_aux,\ +- sizeof(stname),\ +- #tname \ +- ASN1_ITEM_end(tname) +-# define static_ASN1_SEQUENCE_END_ref(stname, tname) \ +- ;\ +- static_ASN1_ITEM_start(tname) \ +- ASN1_ITYPE_SEQUENCE,\ +- V_ASN1_SEQUENCE,\ +- tname##_seq_tt,\ +- sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ +- &tname##_aux,\ +- sizeof(stname),\ +- #stname \ +- ASN1_ITEM_end(tname) +- +-# define ASN1_NDEF_SEQUENCE_END_cb(stname, tname) \ +- ;\ +- ASN1_ITEM_start(tname) \ +- ASN1_ITYPE_NDEF_SEQUENCE,\ +- V_ASN1_SEQUENCE,\ +- tname##_seq_tt,\ +- sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ +- &tname##_aux,\ +- sizeof(stname),\ +- #stname \ +- ASN1_ITEM_end(tname) +- +-/*- +- * This pair helps declare a CHOICE type. We can do: +- * +- * ASN1_CHOICE(chname) = { +- * ... CHOICE options ... +- * ASN1_CHOICE_END(chname) +- * +- * This will produce an ASN1_ITEM called chname_it +- * for a structure called chname. The structure +- * definition must look like this: +- * typedef struct { +- * int type; +- * union { +- * ASN1_SOMETHING *opt1; +- * ASN1_SOMEOTHER *opt2; +- * } value; +- * } chname; +- * +- * the name of the selector must be 'type'. +- * to use an alternative selector name use the +- * ASN1_CHOICE_END_selector() version. +- */ +- +-# define ASN1_CHOICE(tname) \ +- static const ASN1_TEMPLATE tname##_ch_tt[] +- +-# define ASN1_CHOICE_cb(tname, cb) \ +- static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0}; \ +- ASN1_CHOICE(tname) +- +-# define ASN1_CHOICE_END(stname) ASN1_CHOICE_END_name(stname, stname) +- +-# define static_ASN1_CHOICE_END(stname) static_ASN1_CHOICE_END_name(stname, stname) +- +-# define ASN1_CHOICE_END_name(stname, tname) ASN1_CHOICE_END_selector(stname, tname, type) +- +-# define static_ASN1_CHOICE_END_name(stname, tname) static_ASN1_CHOICE_END_selector(stname, tname, type) +- +-# define ASN1_CHOICE_END_selector(stname, tname, selname) \ +- ;\ +- ASN1_ITEM_start(tname) \ +- ASN1_ITYPE_CHOICE,\ +- offsetof(stname,selname) ,\ +- tname##_ch_tt,\ +- sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\ +- NULL,\ +- sizeof(stname),\ +- #stname \ +- ASN1_ITEM_end(tname) +- +-# define static_ASN1_CHOICE_END_selector(stname, tname, selname) \ +- ;\ +- static_ASN1_ITEM_start(tname) \ +- ASN1_ITYPE_CHOICE,\ +- offsetof(stname,selname) ,\ +- tname##_ch_tt,\ +- sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\ +- NULL,\ +- sizeof(stname),\ +- #stname \ +- ASN1_ITEM_end(tname) +- +-# define ASN1_CHOICE_END_cb(stname, tname, selname) \ +- ;\ +- ASN1_ITEM_start(tname) \ +- ASN1_ITYPE_CHOICE,\ +- offsetof(stname,selname) ,\ +- tname##_ch_tt,\ +- sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\ +- &tname##_aux,\ +- sizeof(stname),\ +- #stname \ +- ASN1_ITEM_end(tname) +- +-/* This helps with the template wrapper form of ASN1_ITEM */ +- +-# define ASN1_EX_TEMPLATE_TYPE(flags, tag, name, type) { \ +- (flags), (tag), 0,\ +- #name, ASN1_ITEM_ref(type) } +- +-/* These help with SEQUENCE or CHOICE components */ +- +-/* used to declare other types */ +- +-# define ASN1_EX_TYPE(flags, tag, stname, field, type) { \ +- (flags), (tag), offsetof(stname, field),\ +- #field, ASN1_ITEM_ref(type) } +- +-/* implicit and explicit helper macros */ +- +-# define ASN1_IMP_EX(stname, field, type, tag, ex) \ +- ASN1_EX_TYPE(ASN1_TFLG_IMPLICIT | (ex), tag, stname, field, type) +- +-# define ASN1_EXP_EX(stname, field, type, tag, ex) \ +- ASN1_EX_TYPE(ASN1_TFLG_EXPLICIT | (ex), tag, stname, field, type) +- +-/* Any defined by macros: the field used is in the table itself */ +- +-# ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION +-# define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, (const ASN1_ITEM *)&(tblname##_adb) } +-# define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, (const ASN1_ITEM *)&(tblname##_adb) } +-# else +-# define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, tblname##_adb } +-# define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, tblname##_adb } +-# endif +-/* Plain simple type */ +-# define ASN1_SIMPLE(stname, field, type) ASN1_EX_TYPE(0,0, stname, field, type) +-/* Embedded simple type */ +-# define ASN1_EMBED(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_EMBED,0, stname, field, type) +- +-/* OPTIONAL simple type */ +-# define ASN1_OPT(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL, 0, stname, field, type) +-# define ASN1_OPT_EMBED(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL|ASN1_TFLG_EMBED, 0, stname, field, type) +- +-/* IMPLICIT tagged simple type */ +-# define ASN1_IMP(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, 0) +-# define ASN1_IMP_EMBED(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_EMBED) +- +-/* IMPLICIT tagged OPTIONAL simple type */ +-# define ASN1_IMP_OPT(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL) +-# define ASN1_IMP_OPT_EMBED(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_EMBED) +- +-/* Same as above but EXPLICIT */ +- +-# define ASN1_EXP(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, 0) +-# define ASN1_EXP_EMBED(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_EMBED) +-# define ASN1_EXP_OPT(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL) +-# define ASN1_EXP_OPT_EMBED(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_EMBED) +- +-/* SEQUENCE OF type */ +-# define ASN1_SEQUENCE_OF(stname, field, type) \ +- ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, stname, field, type) +- +-/* OPTIONAL SEQUENCE OF */ +-# define ASN1_SEQUENCE_OF_OPT(stname, field, type) \ +- ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type) +- +-/* Same as above but for SET OF */ +- +-# define ASN1_SET_OF(stname, field, type) \ +- ASN1_EX_TYPE(ASN1_TFLG_SET_OF, 0, stname, field, type) +- +-# define ASN1_SET_OF_OPT(stname, field, type) \ +- ASN1_EX_TYPE(ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type) +- +-/* Finally compound types of SEQUENCE, SET, IMPLICIT, EXPLICIT and OPTIONAL */ +- +-# define ASN1_IMP_SET_OF(stname, field, type, tag) \ +- ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF) +- +-# define ASN1_EXP_SET_OF(stname, field, type, tag) \ +- ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF) +- +-# define ASN1_IMP_SET_OF_OPT(stname, field, type, tag) \ +- ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL) +- +-# define ASN1_EXP_SET_OF_OPT(stname, field, type, tag) \ +- ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL) +- +-# define ASN1_IMP_SEQUENCE_OF(stname, field, type, tag) \ +- ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF) +- +-# define ASN1_IMP_SEQUENCE_OF_OPT(stname, field, type, tag) \ +- ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL) +- +-# define ASN1_EXP_SEQUENCE_OF(stname, field, type, tag) \ +- ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF) +- +-# define ASN1_EXP_SEQUENCE_OF_OPT(stname, field, type, tag) \ +- ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL) +- +-/* EXPLICIT using indefinite length constructed form */ +-# define ASN1_NDEF_EXP(stname, field, type, tag) \ +- ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_NDEF) +- +-/* EXPLICIT OPTIONAL using indefinite length constructed form */ +-# define ASN1_NDEF_EXP_OPT(stname, field, type, tag) \ +- ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_NDEF) +- +-/* Macros for the ASN1_ADB structure */ +- +-# define ASN1_ADB(name) \ +- static const ASN1_ADB_TABLE name##_adbtbl[] +- +-# ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION +- +-# define ASN1_ADB_END(name, flags, field, adb_cb, def, none) \ +- ;\ +- static const ASN1_ADB name##_adb = {\ +- flags,\ +- offsetof(name, field),\ +- adb_cb,\ +- name##_adbtbl,\ +- sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE),\ +- def,\ +- none\ +- } +- +-# else +- +-# define ASN1_ADB_END(name, flags, field, adb_cb, def, none) \ +- ;\ +- static const ASN1_ITEM *name##_adb(void) \ +- { \ +- static const ASN1_ADB internal_adb = \ +- {\ +- flags,\ +- offsetof(name, field),\ +- adb_cb,\ +- name##_adbtbl,\ +- sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE),\ +- def,\ +- none\ +- }; \ +- return (const ASN1_ITEM *) &internal_adb; \ +- } \ +- void dummy_function(void) +- +-# endif +- +-# define ADB_ENTRY(val, template) {val, template} +- +-# define ASN1_ADB_TEMPLATE(name) \ +- static const ASN1_TEMPLATE name##_tt +- +-/* +- * This is the ASN1 template structure that defines a wrapper round the +- * actual type. It determines the actual position of the field in the value +- * structure, various flags such as OPTIONAL and the field name. +- */ +- +-struct ASN1_TEMPLATE_st { +- unsigned long flags; /* Various flags */ +- long tag; /* tag, not used if no tagging */ +- unsigned long offset; /* Offset of this field in structure */ +- const char *field_name; /* Field name */ +- ASN1_ITEM_EXP *item; /* Relevant ASN1_ITEM or ASN1_ADB */ +-}; +- +-/* Macro to extract ASN1_ITEM and ASN1_ADB pointer from ASN1_TEMPLATE */ +- +-# define ASN1_TEMPLATE_item(t) (t->item_ptr) +-# define ASN1_TEMPLATE_adb(t) (t->item_ptr) +- +-typedef struct ASN1_ADB_TABLE_st ASN1_ADB_TABLE; +-typedef struct ASN1_ADB_st ASN1_ADB; +- +-struct ASN1_ADB_st { +- unsigned long flags; /* Various flags */ +- unsigned long offset; /* Offset of selector field */ +- int (*adb_cb)(long *psel); /* Application callback */ +- const ASN1_ADB_TABLE *tbl; /* Table of possible types */ +- long tblcount; /* Number of entries in tbl */ +- const ASN1_TEMPLATE *default_tt; /* Type to use if no match */ +- const ASN1_TEMPLATE *null_tt; /* Type to use if selector is NULL */ +-}; +- +-struct ASN1_ADB_TABLE_st { +- long value; /* NID for an object or value for an int */ +- const ASN1_TEMPLATE tt; /* item for this value */ +-}; +- +-/* template flags */ +- +-/* Field is optional */ +-# define ASN1_TFLG_OPTIONAL (0x1) +- +-/* Field is a SET OF */ +-# define ASN1_TFLG_SET_OF (0x1 << 1) +- +-/* Field is a SEQUENCE OF */ +-# define ASN1_TFLG_SEQUENCE_OF (0x2 << 1) +- +-/* +- * Special case: this refers to a SET OF that will be sorted into DER order +- * when encoded *and* the corresponding STACK will be modified to match the +- * new order. +- */ +-# define ASN1_TFLG_SET_ORDER (0x3 << 1) +- +-/* Mask for SET OF or SEQUENCE OF */ +-# define ASN1_TFLG_SK_MASK (0x3 << 1) +- +-/* +- * These flags mean the tag should be taken from the tag field. If EXPLICIT +- * then the underlying type is used for the inner tag. +- */ +- +-/* IMPLICIT tagging */ +-# define ASN1_TFLG_IMPTAG (0x1 << 3) +- +-/* EXPLICIT tagging, inner tag from underlying type */ +-# define ASN1_TFLG_EXPTAG (0x2 << 3) +- +-# define ASN1_TFLG_TAG_MASK (0x3 << 3) +- +-/* context specific IMPLICIT */ +-# define ASN1_TFLG_IMPLICIT (ASN1_TFLG_IMPTAG|ASN1_TFLG_CONTEXT) +- +-/* context specific EXPLICIT */ +-# define ASN1_TFLG_EXPLICIT (ASN1_TFLG_EXPTAG|ASN1_TFLG_CONTEXT) +- +-/* +- * If tagging is in force these determine the type of tag to use. Otherwise +- * the tag is determined by the underlying type. These values reflect the +- * actual octet format. +- */ +- +-/* Universal tag */ +-# define ASN1_TFLG_UNIVERSAL (0x0<<6) +-/* Application tag */ +-# define ASN1_TFLG_APPLICATION (0x1<<6) +-/* Context specific tag */ +-# define ASN1_TFLG_CONTEXT (0x2<<6) +-/* Private tag */ +-# define ASN1_TFLG_PRIVATE (0x3<<6) +- +-# define ASN1_TFLG_TAG_CLASS (0x3<<6) +- +-/* +- * These are for ANY DEFINED BY type. In this case the 'item' field points to +- * an ASN1_ADB structure which contains a table of values to decode the +- * relevant type +- */ +- +-# define ASN1_TFLG_ADB_MASK (0x3<<8) +- +-# define ASN1_TFLG_ADB_OID (0x1<<8) +- +-# define ASN1_TFLG_ADB_INT (0x1<<9) +- +-/* +- * This flag when present in a SEQUENCE OF, SET OF or EXPLICIT causes +- * indefinite length constructed encoding to be used if required. +- */ +- +-# define ASN1_TFLG_NDEF (0x1<<11) +- +-/* Field is embedded and not a pointer */ +-# define ASN1_TFLG_EMBED (0x1 << 12) +- +-/* This is the actual ASN1 item itself */ +- +-struct ASN1_ITEM_st { +- char itype; /* The item type, primitive, SEQUENCE, CHOICE +- * or extern */ +- long utype; /* underlying type */ +- const ASN1_TEMPLATE *templates; /* If SEQUENCE or CHOICE this contains +- * the contents */ +- long tcount; /* Number of templates if SEQUENCE or CHOICE */ +- const void *funcs; /* functions that handle this type */ +- long size; /* Structure size (usually) */ +- const char *sname; /* Structure name */ +-}; +- +-/*- +- * These are values for the itype field and +- * determine how the type is interpreted. +- * +- * For PRIMITIVE types the underlying type +- * determines the behaviour if items is NULL. +- * +- * Otherwise templates must contain a single +- * template and the type is treated in the +- * same way as the type specified in the template. +- * +- * For SEQUENCE types the templates field points +- * to the members, the size field is the +- * structure size. +- * +- * For CHOICE types the templates field points +- * to each possible member (typically a union) +- * and the 'size' field is the offset of the +- * selector. +- * +- * The 'funcs' field is used for application +- * specific functions. +- * +- * The EXTERN type uses a new style d2i/i2d. +- * The new style should be used where possible +- * because it avoids things like the d2i IMPLICIT +- * hack. +- * +- * MSTRING is a multiple string type, it is used +- * for a CHOICE of character strings where the +- * actual strings all occupy an ASN1_STRING +- * structure. In this case the 'utype' field +- * has a special meaning, it is used as a mask +- * of acceptable types using the B_ASN1 constants. +- * +- * NDEF_SEQUENCE is the same as SEQUENCE except +- * that it will use indefinite length constructed +- * encoding if requested. +- * +- */ +- +-# define ASN1_ITYPE_PRIMITIVE 0x0 +- +-# define ASN1_ITYPE_SEQUENCE 0x1 +- +-# define ASN1_ITYPE_CHOICE 0x2 +- +-# define ASN1_ITYPE_EXTERN 0x4 +- +-# define ASN1_ITYPE_MSTRING 0x5 +- +-# define ASN1_ITYPE_NDEF_SEQUENCE 0x6 +- +-/* +- * Cache for ASN1 tag and length, so we don't keep re-reading it for things +- * like CHOICE +- */ +- +-struct ASN1_TLC_st { +- char valid; /* Values below are valid */ +- int ret; /* return value */ +- long plen; /* length */ +- int ptag; /* class value */ +- int pclass; /* class value */ +- int hdrlen; /* header length */ +-}; +- +-/* Typedefs for ASN1 function pointers */ +-typedef int ASN1_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len, +- const ASN1_ITEM *it, int tag, int aclass, char opt, +- ASN1_TLC *ctx); +- +-typedef int ASN1_ex_i2d(ASN1_VALUE **pval, unsigned char **out, +- const ASN1_ITEM *it, int tag, int aclass); +-typedef int ASN1_ex_new_func(ASN1_VALUE **pval, const ASN1_ITEM *it); +-typedef void ASN1_ex_free_func(ASN1_VALUE **pval, const ASN1_ITEM *it); +- +-typedef int ASN1_ex_print_func(BIO *out, ASN1_VALUE **pval, +- int indent, const char *fname, +- const ASN1_PCTX *pctx); +- +-typedef int ASN1_primitive_i2c(ASN1_VALUE **pval, unsigned char *cont, +- int *putype, const ASN1_ITEM *it); +-typedef int ASN1_primitive_c2i(ASN1_VALUE **pval, const unsigned char *cont, +- int len, int utype, char *free_cont, +- const ASN1_ITEM *it); +-typedef int ASN1_primitive_print(BIO *out, ASN1_VALUE **pval, +- const ASN1_ITEM *it, int indent, +- const ASN1_PCTX *pctx); +- +-typedef struct ASN1_EXTERN_FUNCS_st { +- void *app_data; +- ASN1_ex_new_func *asn1_ex_new; +- ASN1_ex_free_func *asn1_ex_free; +- ASN1_ex_free_func *asn1_ex_clear; +- ASN1_ex_d2i *asn1_ex_d2i; +- ASN1_ex_i2d *asn1_ex_i2d; +- ASN1_ex_print_func *asn1_ex_print; +-} ASN1_EXTERN_FUNCS; +- +-typedef struct ASN1_PRIMITIVE_FUNCS_st { +- void *app_data; +- unsigned long flags; +- ASN1_ex_new_func *prim_new; +- ASN1_ex_free_func *prim_free; +- ASN1_ex_free_func *prim_clear; +- ASN1_primitive_c2i *prim_c2i; +- ASN1_primitive_i2c *prim_i2c; +- ASN1_primitive_print *prim_print; +-} ASN1_PRIMITIVE_FUNCS; +- +-/* +- * This is the ASN1_AUX structure: it handles various miscellaneous +- * requirements. For example the use of reference counts and an informational +- * callback. The "informational callback" is called at various points during +- * the ASN1 encoding and decoding. It can be used to provide minor +- * customisation of the structures used. This is most useful where the +- * supplied routines *almost* do the right thing but need some extra help at +- * a few points. If the callback returns zero then it is assumed a fatal +- * error has occurred and the main operation should be abandoned. If major +- * changes in the default behaviour are required then an external type is +- * more appropriate. +- */ +- +-typedef int ASN1_aux_cb(int operation, ASN1_VALUE **in, const ASN1_ITEM *it, +- void *exarg); +- +-typedef struct ASN1_AUX_st { +- void *app_data; +- int flags; +- int ref_offset; /* Offset of reference value */ +- int ref_lock; /* Lock type to use */ +- ASN1_aux_cb *asn1_cb; +- int enc_offset; /* Offset of ASN1_ENCODING structure */ +-} ASN1_AUX; +- +-/* For print related callbacks exarg points to this structure */ +-typedef struct ASN1_PRINT_ARG_st { +- BIO *out; +- int indent; +- const ASN1_PCTX *pctx; +-} ASN1_PRINT_ARG; +- +-/* For streaming related callbacks exarg points to this structure */ +-typedef struct ASN1_STREAM_ARG_st { +- /* BIO to stream through */ +- BIO *out; +- /* BIO with filters appended */ +- BIO *ndef_bio; +- /* Streaming I/O boundary */ +- unsigned char **boundary; +-} ASN1_STREAM_ARG; +- +-/* Flags in ASN1_AUX */ +- +-/* Use a reference count */ +-# define ASN1_AFLG_REFCOUNT 1 +-/* Save the encoding of structure (useful for signatures) */ +-# define ASN1_AFLG_ENCODING 2 +-/* The Sequence length is invalid */ +-# define ASN1_AFLG_BROKEN 4 +- +-/* operation values for asn1_cb */ +- +-# define ASN1_OP_NEW_PRE 0 +-# define ASN1_OP_NEW_POST 1 +-# define ASN1_OP_FREE_PRE 2 +-# define ASN1_OP_FREE_POST 3 +-# define ASN1_OP_D2I_PRE 4 +-# define ASN1_OP_D2I_POST 5 +-# define ASN1_OP_I2D_PRE 6 +-# define ASN1_OP_I2D_POST 7 +-# define ASN1_OP_PRINT_PRE 8 +-# define ASN1_OP_PRINT_POST 9 +-# define ASN1_OP_STREAM_PRE 10 +-# define ASN1_OP_STREAM_POST 11 +-# define ASN1_OP_DETACHED_PRE 12 +-# define ASN1_OP_DETACHED_POST 13 +- +-/* Macro to implement a primitive type */ +-# define IMPLEMENT_ASN1_TYPE(stname) IMPLEMENT_ASN1_TYPE_ex(stname, stname, 0) +-# define IMPLEMENT_ASN1_TYPE_ex(itname, vname, ex) \ +- ASN1_ITEM_start(itname) \ +- ASN1_ITYPE_PRIMITIVE, V_##vname, NULL, 0, NULL, ex, #itname \ +- ASN1_ITEM_end(itname) +- +-/* Macro to implement a multi string type */ +-# define IMPLEMENT_ASN1_MSTRING(itname, mask) \ +- ASN1_ITEM_start(itname) \ +- ASN1_ITYPE_MSTRING, mask, NULL, 0, NULL, sizeof(ASN1_STRING), #itname \ +- ASN1_ITEM_end(itname) +- +-# define IMPLEMENT_EXTERN_ASN1(sname, tag, fptrs) \ +- ASN1_ITEM_start(sname) \ +- ASN1_ITYPE_EXTERN, \ +- tag, \ +- NULL, \ +- 0, \ +- &fptrs, \ +- 0, \ +- #sname \ +- ASN1_ITEM_end(sname) +- +-/* Macro to implement standard functions in terms of ASN1_ITEM structures */ +- +-# define IMPLEMENT_ASN1_FUNCTIONS(stname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, stname, stname) +- +-# define IMPLEMENT_ASN1_FUNCTIONS_name(stname, itname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, itname) +- +-# define IMPLEMENT_ASN1_FUNCTIONS_ENCODE_name(stname, itname) \ +- IMPLEMENT_ASN1_FUNCTIONS_ENCODE_fname(stname, itname, itname) +- +-# define IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(stname) \ +- IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(static, stname, stname, stname) +- +-# define IMPLEMENT_ASN1_ALLOC_FUNCTIONS(stname) \ +- IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, stname, stname) +- +-# define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(pre, stname, itname, fname) \ +- pre stname *fname##_new(void) \ +- { \ +- return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \ +- } \ +- pre void fname##_free(stname *a) \ +- { \ +- ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \ +- } +- +-# define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) \ +- stname *fname##_new(void) \ +- { \ +- return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \ +- } \ +- void fname##_free(stname *a) \ +- { \ +- ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \ +- } +- +-# define IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, fname) \ +- IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \ +- IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) +- +-# define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \ +- stname *d2i_##fname(stname **a, const unsigned char **in, long len) \ +- { \ +- return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\ +- } \ +- int i2d_##fname(stname *a, unsigned char **out) \ +- { \ +- return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\ +- } +- +-# define IMPLEMENT_ASN1_NDEF_FUNCTION(stname) \ +- int i2d_##stname##_NDEF(stname *a, unsigned char **out) \ +- { \ +- return ASN1_item_ndef_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(stname));\ +- } +- +-# define IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(stname) \ +- static stname *d2i_##stname(stname **a, \ +- const unsigned char **in, long len) \ +- { \ +- return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, \ +- ASN1_ITEM_rptr(stname)); \ +- } \ +- static int i2d_##stname(stname *a, unsigned char **out) \ +- { \ +- return ASN1_item_i2d((ASN1_VALUE *)a, out, \ +- ASN1_ITEM_rptr(stname)); \ +- } +- +-/* +- * This includes evil casts to remove const: they will go away when full ASN1 +- * constification is done. +- */ +-# define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \ +- stname *d2i_##fname(stname **a, const unsigned char **in, long len) \ +- { \ +- return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\ +- } \ +- int i2d_##fname(const stname *a, unsigned char **out) \ +- { \ +- return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\ +- } +- +-# define IMPLEMENT_ASN1_DUP_FUNCTION(stname) \ +- stname * stname##_dup(stname *x) \ +- { \ +- return ASN1_item_dup(ASN1_ITEM_rptr(stname), x); \ +- } +- +-# define IMPLEMENT_ASN1_PRINT_FUNCTION(stname) \ +- IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, stname, stname) +- +-# define IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, itname, fname) \ +- int fname##_print_ctx(BIO *out, stname *x, int indent, \ +- const ASN1_PCTX *pctx) \ +- { \ +- return ASN1_item_print(out, (ASN1_VALUE *)x, indent, \ +- ASN1_ITEM_rptr(itname), pctx); \ +- } +- +-# define IMPLEMENT_ASN1_FUNCTIONS_const(name) \ +- IMPLEMENT_ASN1_FUNCTIONS_const_fname(name, name, name) +- +-# define IMPLEMENT_ASN1_FUNCTIONS_const_fname(stname, itname, fname) \ +- IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \ +- IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) +- +-/* external definitions for primitive types */ +- +-DECLARE_ASN1_ITEM(ASN1_BOOLEAN) +-DECLARE_ASN1_ITEM(ASN1_TBOOLEAN) +-DECLARE_ASN1_ITEM(ASN1_FBOOLEAN) +-DECLARE_ASN1_ITEM(ASN1_SEQUENCE) +-DECLARE_ASN1_ITEM(CBIGNUM) +-DECLARE_ASN1_ITEM(BIGNUM) +-DECLARE_ASN1_ITEM(INT32) +-DECLARE_ASN1_ITEM(ZINT32) +-DECLARE_ASN1_ITEM(UINT32) +-DECLARE_ASN1_ITEM(ZUINT32) +-DECLARE_ASN1_ITEM(INT64) +-DECLARE_ASN1_ITEM(ZINT64) +-DECLARE_ASN1_ITEM(UINT64) +-DECLARE_ASN1_ITEM(ZUINT64) +- +-# if OPENSSL_API_COMPAT < 0x10200000L +-/* +- * LONG and ZLONG are strongly discouraged for use as stored data, as the +- * underlying C type (long) differs in size depending on the architecture. +- * They are designed with 32-bit longs in mind. +- */ +-DECLARE_ASN1_ITEM(LONG) +-DECLARE_ASN1_ITEM(ZLONG) +-# endif +- +-DEFINE_STACK_OF(ASN1_VALUE) +- +-/* Functions used internally by the ASN1 code */ +- +-int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it); +-void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it); +- +-int ASN1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len, +- const ASN1_ITEM *it, int tag, int aclass, char opt, +- ASN1_TLC *ctx); +- +-int ASN1_item_ex_i2d(ASN1_VALUE **pval, unsigned char **out, +- const ASN1_ITEM *it, int tag, int aclass); +- +-#ifdef __cplusplus +-} +-#endif +-#endif +diff --git a/uadk_tool/include/openssl/async.h b/uadk_tool/include/openssl/async.h +deleted file mode 100644 +index 7052b89..0000000 +--- a/uadk_tool/include/openssl/async.h ++++ /dev/null +@@ -1,76 +0,0 @@ +-/* +- * Copyright 2015-2018 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#include +- +-#ifndef HEADER_ASYNC_H +-# define HEADER_ASYNC_H +- +-#if defined(_WIN32) +-# if defined(BASETYPES) || defined(_WINDEF_H) +-/* application has to include to use this */ +-#define OSSL_ASYNC_FD HANDLE +-#define OSSL_BAD_ASYNC_FD INVALID_HANDLE_VALUE +-# endif +-#else +-#define OSSL_ASYNC_FD int +-#define OSSL_BAD_ASYNC_FD -1 +-#endif +-# include +- +- +-# ifdef __cplusplus +-extern "C" { +-# endif +- +-typedef struct async_job_st ASYNC_JOB; +-typedef struct async_wait_ctx_st ASYNC_WAIT_CTX; +- +-#define ASYNC_ERR 0 +-#define ASYNC_NO_JOBS 1 +-#define ASYNC_PAUSE 2 +-#define ASYNC_FINISH 3 +- +-int ASYNC_init_thread(size_t max_size, size_t init_size); +-void ASYNC_cleanup_thread(void); +- +-#ifdef OSSL_ASYNC_FD +-ASYNC_WAIT_CTX *ASYNC_WAIT_CTX_new(void); +-void ASYNC_WAIT_CTX_free(ASYNC_WAIT_CTX *ctx); +-int ASYNC_WAIT_CTX_set_wait_fd(ASYNC_WAIT_CTX *ctx, const void *key, +- OSSL_ASYNC_FD fd, +- void *custom_data, +- void (*cleanup)(ASYNC_WAIT_CTX *, const void *, +- OSSL_ASYNC_FD, void *)); +-int ASYNC_WAIT_CTX_get_fd(ASYNC_WAIT_CTX *ctx, const void *key, +- OSSL_ASYNC_FD *fd, void **custom_data); +-int ASYNC_WAIT_CTX_get_all_fds(ASYNC_WAIT_CTX *ctx, OSSL_ASYNC_FD *fd, +- size_t *numfds); +-int ASYNC_WAIT_CTX_get_changed_fds(ASYNC_WAIT_CTX *ctx, OSSL_ASYNC_FD *addfd, +- size_t *numaddfds, OSSL_ASYNC_FD *delfd, +- size_t *numdelfds); +-int ASYNC_WAIT_CTX_clear_fd(ASYNC_WAIT_CTX *ctx, const void *key); +-#endif +- +-int ASYNC_is_capable(void); +- +-int ASYNC_start_job(ASYNC_JOB **job, ASYNC_WAIT_CTX *ctx, int *ret, +- int (*func)(void *), void *args, size_t size); +-int ASYNC_pause_job(void); +- +-ASYNC_JOB *ASYNC_get_current_job(void); +-ASYNC_WAIT_CTX *ASYNC_get_wait_ctx(ASYNC_JOB *job); +-void ASYNC_block_pause(void); +-void ASYNC_unblock_pause(void); +- +- +-# ifdef __cplusplus +-} +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/asyncerr.h b/uadk_tool/include/openssl/asyncerr.h +deleted file mode 100644 +index 91afbbb..0000000 +--- a/uadk_tool/include/openssl/asyncerr.h ++++ /dev/null +@@ -1,42 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_ASYNCERR_H +-# define HEADER_ASYNCERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_ASYNC_strings(void); +- +-/* +- * ASYNC function codes. +- */ +-# define ASYNC_F_ASYNC_CTX_NEW 100 +-# define ASYNC_F_ASYNC_INIT_THREAD 101 +-# define ASYNC_F_ASYNC_JOB_NEW 102 +-# define ASYNC_F_ASYNC_PAUSE_JOB 103 +-# define ASYNC_F_ASYNC_START_FUNC 104 +-# define ASYNC_F_ASYNC_START_JOB 105 +-# define ASYNC_F_ASYNC_WAIT_CTX_SET_WAIT_FD 106 +- +-/* +- * ASYNC reason codes. +- */ +-# define ASYNC_R_FAILED_TO_SET_POOL 101 +-# define ASYNC_R_FAILED_TO_SWAP_CONTEXT 102 +-# define ASYNC_R_INIT_FAILED 105 +-# define ASYNC_R_INVALID_POOL_SIZE 103 +- +-#endif +diff --git a/uadk_tool/include/openssl/bio.h b/uadk_tool/include/openssl/bio.h +deleted file mode 100644 +index ae559a5..0000000 +--- a/uadk_tool/include/openssl/bio.h ++++ /dev/null +@@ -1,801 +0,0 @@ +-/* +- * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_BIO_H +-# define HEADER_BIO_H +- +-# include +- +-# ifndef OPENSSL_NO_STDIO +-# include +-# endif +-# include +- +-# include +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-/* There are the classes of BIOs */ +-# define BIO_TYPE_DESCRIPTOR 0x0100 /* socket, fd, connect or accept */ +-# define BIO_TYPE_FILTER 0x0200 +-# define BIO_TYPE_SOURCE_SINK 0x0400 +- +-/* These are the 'types' of BIOs */ +-# define BIO_TYPE_NONE 0 +-# define BIO_TYPE_MEM ( 1|BIO_TYPE_SOURCE_SINK) +-# define BIO_TYPE_FILE ( 2|BIO_TYPE_SOURCE_SINK) +- +-# define BIO_TYPE_FD ( 4|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR) +-# define BIO_TYPE_SOCKET ( 5|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR) +-# define BIO_TYPE_NULL ( 6|BIO_TYPE_SOURCE_SINK) +-# define BIO_TYPE_SSL ( 7|BIO_TYPE_FILTER) +-# define BIO_TYPE_MD ( 8|BIO_TYPE_FILTER) +-# define BIO_TYPE_BUFFER ( 9|BIO_TYPE_FILTER) +-# define BIO_TYPE_CIPHER (10|BIO_TYPE_FILTER) +-# define BIO_TYPE_BASE64 (11|BIO_TYPE_FILTER) +-# define BIO_TYPE_CONNECT (12|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR) +-# define BIO_TYPE_ACCEPT (13|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR) +- +-# define BIO_TYPE_NBIO_TEST (16|BIO_TYPE_FILTER)/* server proxy BIO */ +-# define BIO_TYPE_NULL_FILTER (17|BIO_TYPE_FILTER) +-# define BIO_TYPE_BIO (19|BIO_TYPE_SOURCE_SINK)/* half a BIO pair */ +-# define BIO_TYPE_LINEBUFFER (20|BIO_TYPE_FILTER) +-# define BIO_TYPE_DGRAM (21|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR) +-# define BIO_TYPE_ASN1 (22|BIO_TYPE_FILTER) +-# define BIO_TYPE_COMP (23|BIO_TYPE_FILTER) +-# ifndef OPENSSL_NO_SCTP +-# define BIO_TYPE_DGRAM_SCTP (24|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR) +-# endif +- +-#define BIO_TYPE_START 128 +- +-/* +- * BIO_FILENAME_READ|BIO_CLOSE to open or close on free. +- * BIO_set_fp(in,stdin,BIO_NOCLOSE); +- */ +-# define BIO_NOCLOSE 0x00 +-# define BIO_CLOSE 0x01 +- +-/* +- * These are used in the following macros and are passed to BIO_ctrl() +- */ +-# define BIO_CTRL_RESET 1/* opt - rewind/zero etc */ +-# define BIO_CTRL_EOF 2/* opt - are we at the eof */ +-# define BIO_CTRL_INFO 3/* opt - extra tit-bits */ +-# define BIO_CTRL_SET 4/* man - set the 'IO' type */ +-# define BIO_CTRL_GET 5/* man - get the 'IO' type */ +-# define BIO_CTRL_PUSH 6/* opt - internal, used to signify change */ +-# define BIO_CTRL_POP 7/* opt - internal, used to signify change */ +-# define BIO_CTRL_GET_CLOSE 8/* man - set the 'close' on free */ +-# define BIO_CTRL_SET_CLOSE 9/* man - set the 'close' on free */ +-# define BIO_CTRL_PENDING 10/* opt - is their more data buffered */ +-# define BIO_CTRL_FLUSH 11/* opt - 'flush' buffered output */ +-# define BIO_CTRL_DUP 12/* man - extra stuff for 'duped' BIO */ +-# define BIO_CTRL_WPENDING 13/* opt - number of bytes still to write */ +-# define BIO_CTRL_SET_CALLBACK 14/* opt - set callback function */ +-# define BIO_CTRL_GET_CALLBACK 15/* opt - set callback function */ +- +-# define BIO_CTRL_PEEK 29/* BIO_f_buffer special */ +-# define BIO_CTRL_SET_FILENAME 30/* BIO_s_file special */ +- +-/* dgram BIO stuff */ +-# define BIO_CTRL_DGRAM_CONNECT 31/* BIO dgram special */ +-# define BIO_CTRL_DGRAM_SET_CONNECTED 32/* allow for an externally connected +- * socket to be passed in */ +-# define BIO_CTRL_DGRAM_SET_RECV_TIMEOUT 33/* setsockopt, essentially */ +-# define BIO_CTRL_DGRAM_GET_RECV_TIMEOUT 34/* getsockopt, essentially */ +-# define BIO_CTRL_DGRAM_SET_SEND_TIMEOUT 35/* setsockopt, essentially */ +-# define BIO_CTRL_DGRAM_GET_SEND_TIMEOUT 36/* getsockopt, essentially */ +- +-# define BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP 37/* flag whether the last */ +-# define BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP 38/* I/O operation tiemd out */ +- +-/* #ifdef IP_MTU_DISCOVER */ +-# define BIO_CTRL_DGRAM_MTU_DISCOVER 39/* set DF bit on egress packets */ +-/* #endif */ +- +-# define BIO_CTRL_DGRAM_QUERY_MTU 40/* as kernel for current MTU */ +-# define BIO_CTRL_DGRAM_GET_FALLBACK_MTU 47 +-# define BIO_CTRL_DGRAM_GET_MTU 41/* get cached value for MTU */ +-# define BIO_CTRL_DGRAM_SET_MTU 42/* set cached value for MTU. +- * want to use this if asking +- * the kernel fails */ +- +-# define BIO_CTRL_DGRAM_MTU_EXCEEDED 43/* check whether the MTU was +- * exceed in the previous write +- * operation */ +- +-# define BIO_CTRL_DGRAM_GET_PEER 46 +-# define BIO_CTRL_DGRAM_SET_PEER 44/* Destination for the data */ +- +-# define BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT 45/* Next DTLS handshake timeout +- * to adjust socket timeouts */ +-# define BIO_CTRL_DGRAM_SET_DONT_FRAG 48 +- +-# define BIO_CTRL_DGRAM_GET_MTU_OVERHEAD 49 +- +-/* Deliberately outside of OPENSSL_NO_SCTP - used in bss_dgram.c */ +-# define BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE 50 +-# ifndef OPENSSL_NO_SCTP +-/* SCTP stuff */ +-# define BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY 51 +-# define BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY 52 +-# define BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD 53 +-# define BIO_CTRL_DGRAM_SCTP_GET_SNDINFO 60 +-# define BIO_CTRL_DGRAM_SCTP_SET_SNDINFO 61 +-# define BIO_CTRL_DGRAM_SCTP_GET_RCVINFO 62 +-# define BIO_CTRL_DGRAM_SCTP_SET_RCVINFO 63 +-# define BIO_CTRL_DGRAM_SCTP_GET_PRINFO 64 +-# define BIO_CTRL_DGRAM_SCTP_SET_PRINFO 65 +-# define BIO_CTRL_DGRAM_SCTP_SAVE_SHUTDOWN 70 +-# endif +- +-# define BIO_CTRL_DGRAM_SET_PEEK_MODE 71 +- +-/* modifiers */ +-# define BIO_FP_READ 0x02 +-# define BIO_FP_WRITE 0x04 +-# define BIO_FP_APPEND 0x08 +-# define BIO_FP_TEXT 0x10 +- +-# define BIO_FLAGS_READ 0x01 +-# define BIO_FLAGS_WRITE 0x02 +-# define BIO_FLAGS_IO_SPECIAL 0x04 +-# define BIO_FLAGS_RWS (BIO_FLAGS_READ|BIO_FLAGS_WRITE|BIO_FLAGS_IO_SPECIAL) +-# define BIO_FLAGS_SHOULD_RETRY 0x08 +-# ifndef BIO_FLAGS_UPLINK +-/* +- * "UPLINK" flag denotes file descriptors provided by application. It +- * defaults to 0, as most platforms don't require UPLINK interface. +- */ +-# define BIO_FLAGS_UPLINK 0 +-# endif +- +-# define BIO_FLAGS_BASE64_NO_NL 0x100 +- +-/* +- * This is used with memory BIOs: +- * BIO_FLAGS_MEM_RDONLY means we shouldn't free up or change the data in any way; +- * BIO_FLAGS_NONCLEAR_RST means we shouldn't clear data on reset. +- */ +-# define BIO_FLAGS_MEM_RDONLY 0x200 +-# define BIO_FLAGS_NONCLEAR_RST 0x400 +-# define BIO_FLAGS_IN_EOF 0x800 +- +-typedef union bio_addr_st BIO_ADDR; +-typedef struct bio_addrinfo_st BIO_ADDRINFO; +- +-int BIO_get_new_index(void); +-void BIO_set_flags(BIO *b, int flags); +-int BIO_test_flags(const BIO *b, int flags); +-void BIO_clear_flags(BIO *b, int flags); +- +-# define BIO_get_flags(b) BIO_test_flags(b, ~(0x0)) +-# define BIO_set_retry_special(b) \ +- BIO_set_flags(b, (BIO_FLAGS_IO_SPECIAL|BIO_FLAGS_SHOULD_RETRY)) +-# define BIO_set_retry_read(b) \ +- BIO_set_flags(b, (BIO_FLAGS_READ|BIO_FLAGS_SHOULD_RETRY)) +-# define BIO_set_retry_write(b) \ +- BIO_set_flags(b, (BIO_FLAGS_WRITE|BIO_FLAGS_SHOULD_RETRY)) +- +-/* These are normally used internally in BIOs */ +-# define BIO_clear_retry_flags(b) \ +- BIO_clear_flags(b, (BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY)) +-# define BIO_get_retry_flags(b) \ +- BIO_test_flags(b, (BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY)) +- +-/* These should be used by the application to tell why we should retry */ +-# define BIO_should_read(a) BIO_test_flags(a, BIO_FLAGS_READ) +-# define BIO_should_write(a) BIO_test_flags(a, BIO_FLAGS_WRITE) +-# define BIO_should_io_special(a) BIO_test_flags(a, BIO_FLAGS_IO_SPECIAL) +-# define BIO_retry_type(a) BIO_test_flags(a, BIO_FLAGS_RWS) +-# define BIO_should_retry(a) BIO_test_flags(a, BIO_FLAGS_SHOULD_RETRY) +- +-/* +- * The next three are used in conjunction with the BIO_should_io_special() +- * condition. After this returns true, BIO *BIO_get_retry_BIO(BIO *bio, int +- * *reason); will walk the BIO stack and return the 'reason' for the special +- * and the offending BIO. Given a BIO, BIO_get_retry_reason(bio) will return +- * the code. +- */ +-/* +- * Returned from the SSL bio when the certificate retrieval code had an error +- */ +-# define BIO_RR_SSL_X509_LOOKUP 0x01 +-/* Returned from the connect BIO when a connect would have blocked */ +-# define BIO_RR_CONNECT 0x02 +-/* Returned from the accept BIO when an accept would have blocked */ +-# define BIO_RR_ACCEPT 0x03 +- +-/* These are passed by the BIO callback */ +-# define BIO_CB_FREE 0x01 +-# define BIO_CB_READ 0x02 +-# define BIO_CB_WRITE 0x03 +-# define BIO_CB_PUTS 0x04 +-# define BIO_CB_GETS 0x05 +-# define BIO_CB_CTRL 0x06 +- +-/* +- * The callback is called before and after the underling operation, The +- * BIO_CB_RETURN flag indicates if it is after the call +- */ +-# define BIO_CB_RETURN 0x80 +-# define BIO_CB_return(a) ((a)|BIO_CB_RETURN) +-# define BIO_cb_pre(a) (!((a)&BIO_CB_RETURN)) +-# define BIO_cb_post(a) ((a)&BIO_CB_RETURN) +- +-typedef long (*BIO_callback_fn)(BIO *b, int oper, const char *argp, int argi, +- long argl, long ret); +-typedef long (*BIO_callback_fn_ex)(BIO *b, int oper, const char *argp, +- size_t len, int argi, +- long argl, int ret, size_t *processed); +-BIO_callback_fn BIO_get_callback(const BIO *b); +-void BIO_set_callback(BIO *b, BIO_callback_fn callback); +- +-BIO_callback_fn_ex BIO_get_callback_ex(const BIO *b); +-void BIO_set_callback_ex(BIO *b, BIO_callback_fn_ex callback); +- +-char *BIO_get_callback_arg(const BIO *b); +-void BIO_set_callback_arg(BIO *b, char *arg); +- +-typedef struct bio_method_st BIO_METHOD; +- +-const char *BIO_method_name(const BIO *b); +-int BIO_method_type(const BIO *b); +- +-typedef int BIO_info_cb(BIO *, int, int); +-typedef BIO_info_cb bio_info_cb; /* backward compatibility */ +- +-DEFINE_STACK_OF(BIO) +- +-/* Prefix and suffix callback in ASN1 BIO */ +-typedef int asn1_ps_func (BIO *b, unsigned char **pbuf, int *plen, +- void *parg); +- +-# ifndef OPENSSL_NO_SCTP +-/* SCTP parameter structs */ +-struct bio_dgram_sctp_sndinfo { +- uint16_t snd_sid; +- uint16_t snd_flags; +- uint32_t snd_ppid; +- uint32_t snd_context; +-}; +- +-struct bio_dgram_sctp_rcvinfo { +- uint16_t rcv_sid; +- uint16_t rcv_ssn; +- uint16_t rcv_flags; +- uint32_t rcv_ppid; +- uint32_t rcv_tsn; +- uint32_t rcv_cumtsn; +- uint32_t rcv_context; +-}; +- +-struct bio_dgram_sctp_prinfo { +- uint16_t pr_policy; +- uint32_t pr_value; +-}; +-# endif +- +-/* +- * #define BIO_CONN_get_param_hostname BIO_ctrl +- */ +- +-# define BIO_C_SET_CONNECT 100 +-# define BIO_C_DO_STATE_MACHINE 101 +-# define BIO_C_SET_NBIO 102 +-/* # define BIO_C_SET_PROXY_PARAM 103 */ +-# define BIO_C_SET_FD 104 +-# define BIO_C_GET_FD 105 +-# define BIO_C_SET_FILE_PTR 106 +-# define BIO_C_GET_FILE_PTR 107 +-# define BIO_C_SET_FILENAME 108 +-# define BIO_C_SET_SSL 109 +-# define BIO_C_GET_SSL 110 +-# define BIO_C_SET_MD 111 +-# define BIO_C_GET_MD 112 +-# define BIO_C_GET_CIPHER_STATUS 113 +-# define BIO_C_SET_BUF_MEM 114 +-# define BIO_C_GET_BUF_MEM_PTR 115 +-# define BIO_C_GET_BUFF_NUM_LINES 116 +-# define BIO_C_SET_BUFF_SIZE 117 +-# define BIO_C_SET_ACCEPT 118 +-# define BIO_C_SSL_MODE 119 +-# define BIO_C_GET_MD_CTX 120 +-/* # define BIO_C_GET_PROXY_PARAM 121 */ +-# define BIO_C_SET_BUFF_READ_DATA 122/* data to read first */ +-# define BIO_C_GET_CONNECT 123 +-# define BIO_C_GET_ACCEPT 124 +-# define BIO_C_SET_SSL_RENEGOTIATE_BYTES 125 +-# define BIO_C_GET_SSL_NUM_RENEGOTIATES 126 +-# define BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT 127 +-# define BIO_C_FILE_SEEK 128 +-# define BIO_C_GET_CIPHER_CTX 129 +-# define BIO_C_SET_BUF_MEM_EOF_RETURN 130/* return end of input +- * value */ +-# define BIO_C_SET_BIND_MODE 131 +-# define BIO_C_GET_BIND_MODE 132 +-# define BIO_C_FILE_TELL 133 +-# define BIO_C_GET_SOCKS 134 +-# define BIO_C_SET_SOCKS 135 +- +-# define BIO_C_SET_WRITE_BUF_SIZE 136/* for BIO_s_bio */ +-# define BIO_C_GET_WRITE_BUF_SIZE 137 +-# define BIO_C_MAKE_BIO_PAIR 138 +-# define BIO_C_DESTROY_BIO_PAIR 139 +-# define BIO_C_GET_WRITE_GUARANTEE 140 +-# define BIO_C_GET_READ_REQUEST 141 +-# define BIO_C_SHUTDOWN_WR 142 +-# define BIO_C_NREAD0 143 +-# define BIO_C_NREAD 144 +-# define BIO_C_NWRITE0 145 +-# define BIO_C_NWRITE 146 +-# define BIO_C_RESET_READ_REQUEST 147 +-# define BIO_C_SET_MD_CTX 148 +- +-# define BIO_C_SET_PREFIX 149 +-# define BIO_C_GET_PREFIX 150 +-# define BIO_C_SET_SUFFIX 151 +-# define BIO_C_GET_SUFFIX 152 +- +-# define BIO_C_SET_EX_ARG 153 +-# define BIO_C_GET_EX_ARG 154 +- +-# define BIO_C_SET_CONNECT_MODE 155 +- +-# define BIO_set_app_data(s,arg) BIO_set_ex_data(s,0,arg) +-# define BIO_get_app_data(s) BIO_get_ex_data(s,0) +- +-# define BIO_set_nbio(b,n) BIO_ctrl(b,BIO_C_SET_NBIO,(n),NULL) +- +-# ifndef OPENSSL_NO_SOCK +-/* IP families we support, for BIO_s_connect() and BIO_s_accept() */ +-/* Note: the underlying operating system may not support some of them */ +-# define BIO_FAMILY_IPV4 4 +-# define BIO_FAMILY_IPV6 6 +-# define BIO_FAMILY_IPANY 256 +- +-/* BIO_s_connect() */ +-# define BIO_set_conn_hostname(b,name) BIO_ctrl(b,BIO_C_SET_CONNECT,0, \ +- (char *)(name)) +-# define BIO_set_conn_port(b,port) BIO_ctrl(b,BIO_C_SET_CONNECT,1, \ +- (char *)(port)) +-# define BIO_set_conn_address(b,addr) BIO_ctrl(b,BIO_C_SET_CONNECT,2, \ +- (char *)(addr)) +-# define BIO_set_conn_ip_family(b,f) BIO_int_ctrl(b,BIO_C_SET_CONNECT,3,f) +-# define BIO_get_conn_hostname(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,0)) +-# define BIO_get_conn_port(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,1)) +-# define BIO_get_conn_address(b) ((const BIO_ADDR *)BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,2)) +-# define BIO_get_conn_ip_family(b) BIO_ctrl(b,BIO_C_GET_CONNECT,3,NULL) +-# define BIO_set_conn_mode(b,n) BIO_ctrl(b,BIO_C_SET_CONNECT_MODE,(n),NULL) +- +-/* BIO_s_accept() */ +-# define BIO_set_accept_name(b,name) BIO_ctrl(b,BIO_C_SET_ACCEPT,0, \ +- (char *)(name)) +-# define BIO_set_accept_port(b,port) BIO_ctrl(b,BIO_C_SET_ACCEPT,1, \ +- (char *)(port)) +-# define BIO_get_accept_name(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,0)) +-# define BIO_get_accept_port(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,1)) +-# define BIO_get_peer_name(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,2)) +-# define BIO_get_peer_port(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,3)) +-/* #define BIO_set_nbio(b,n) BIO_ctrl(b,BIO_C_SET_NBIO,(n),NULL) */ +-# define BIO_set_nbio_accept(b,n) BIO_ctrl(b,BIO_C_SET_ACCEPT,2,(n)?(void *)"a":NULL) +-# define BIO_set_accept_bios(b,bio) BIO_ctrl(b,BIO_C_SET_ACCEPT,3, \ +- (char *)(bio)) +-# define BIO_set_accept_ip_family(b,f) BIO_int_ctrl(b,BIO_C_SET_ACCEPT,4,f) +-# define BIO_get_accept_ip_family(b) BIO_ctrl(b,BIO_C_GET_ACCEPT,4,NULL) +- +-/* Aliases kept for backward compatibility */ +-# define BIO_BIND_NORMAL 0 +-# define BIO_BIND_REUSEADDR BIO_SOCK_REUSEADDR +-# define BIO_BIND_REUSEADDR_IF_UNUSED BIO_SOCK_REUSEADDR +-# define BIO_set_bind_mode(b,mode) BIO_ctrl(b,BIO_C_SET_BIND_MODE,mode,NULL) +-# define BIO_get_bind_mode(b) BIO_ctrl(b,BIO_C_GET_BIND_MODE,0,NULL) +- +-/* BIO_s_accept() and BIO_s_connect() */ +-# define BIO_do_connect(b) BIO_do_handshake(b) +-# define BIO_do_accept(b) BIO_do_handshake(b) +-# endif /* OPENSSL_NO_SOCK */ +- +-# define BIO_do_handshake(b) BIO_ctrl(b,BIO_C_DO_STATE_MACHINE,0,NULL) +- +-/* BIO_s_datagram(), BIO_s_fd(), BIO_s_socket(), BIO_s_accept() and BIO_s_connect() */ +-# define BIO_set_fd(b,fd,c) BIO_int_ctrl(b,BIO_C_SET_FD,c,fd) +-# define BIO_get_fd(b,c) BIO_ctrl(b,BIO_C_GET_FD,0,(char *)(c)) +- +-/* BIO_s_file() */ +-# define BIO_set_fp(b,fp,c) BIO_ctrl(b,BIO_C_SET_FILE_PTR,c,(char *)(fp)) +-# define BIO_get_fp(b,fpp) BIO_ctrl(b,BIO_C_GET_FILE_PTR,0,(char *)(fpp)) +- +-/* BIO_s_fd() and BIO_s_file() */ +-# define BIO_seek(b,ofs) (int)BIO_ctrl(b,BIO_C_FILE_SEEK,ofs,NULL) +-# define BIO_tell(b) (int)BIO_ctrl(b,BIO_C_FILE_TELL,0,NULL) +- +-/* +- * name is cast to lose const, but might be better to route through a +- * function so we can do it safely +- */ +-# ifdef CONST_STRICT +-/* +- * If you are wondering why this isn't defined, its because CONST_STRICT is +- * purely a compile-time kludge to allow const to be checked. +- */ +-int BIO_read_filename(BIO *b, const char *name); +-# else +-# define BIO_read_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \ +- BIO_CLOSE|BIO_FP_READ,(char *)(name)) +-# endif +-# define BIO_write_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \ +- BIO_CLOSE|BIO_FP_WRITE,name) +-# define BIO_append_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \ +- BIO_CLOSE|BIO_FP_APPEND,name) +-# define BIO_rw_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \ +- BIO_CLOSE|BIO_FP_READ|BIO_FP_WRITE,name) +- +-/* +- * WARNING WARNING, this ups the reference count on the read bio of the SSL +- * structure. This is because the ssl read BIO is now pointed to by the +- * next_bio field in the bio. So when you free the BIO, make sure you are +- * doing a BIO_free_all() to catch the underlying BIO. +- */ +-# define BIO_set_ssl(b,ssl,c) BIO_ctrl(b,BIO_C_SET_SSL,c,(char *)(ssl)) +-# define BIO_get_ssl(b,sslp) BIO_ctrl(b,BIO_C_GET_SSL,0,(char *)(sslp)) +-# define BIO_set_ssl_mode(b,client) BIO_ctrl(b,BIO_C_SSL_MODE,client,NULL) +-# define BIO_set_ssl_renegotiate_bytes(b,num) \ +- BIO_ctrl(b,BIO_C_SET_SSL_RENEGOTIATE_BYTES,num,NULL) +-# define BIO_get_num_renegotiates(b) \ +- BIO_ctrl(b,BIO_C_GET_SSL_NUM_RENEGOTIATES,0,NULL) +-# define BIO_set_ssl_renegotiate_timeout(b,seconds) \ +- BIO_ctrl(b,BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT,seconds,NULL) +- +-/* defined in evp.h */ +-/* #define BIO_set_md(b,md) BIO_ctrl(b,BIO_C_SET_MD,1,(char *)(md)) */ +- +-# define BIO_get_mem_data(b,pp) BIO_ctrl(b,BIO_CTRL_INFO,0,(char *)(pp)) +-# define BIO_set_mem_buf(b,bm,c) BIO_ctrl(b,BIO_C_SET_BUF_MEM,c,(char *)(bm)) +-# define BIO_get_mem_ptr(b,pp) BIO_ctrl(b,BIO_C_GET_BUF_MEM_PTR,0, \ +- (char *)(pp)) +-# define BIO_set_mem_eof_return(b,v) \ +- BIO_ctrl(b,BIO_C_SET_BUF_MEM_EOF_RETURN,v,NULL) +- +-/* For the BIO_f_buffer() type */ +-# define BIO_get_buffer_num_lines(b) BIO_ctrl(b,BIO_C_GET_BUFF_NUM_LINES,0,NULL) +-# define BIO_set_buffer_size(b,size) BIO_ctrl(b,BIO_C_SET_BUFF_SIZE,size,NULL) +-# define BIO_set_read_buffer_size(b,size) BIO_int_ctrl(b,BIO_C_SET_BUFF_SIZE,size,0) +-# define BIO_set_write_buffer_size(b,size) BIO_int_ctrl(b,BIO_C_SET_BUFF_SIZE,size,1) +-# define BIO_set_buffer_read_data(b,buf,num) BIO_ctrl(b,BIO_C_SET_BUFF_READ_DATA,num,buf) +- +-/* Don't use the next one unless you know what you are doing :-) */ +-# define BIO_dup_state(b,ret) BIO_ctrl(b,BIO_CTRL_DUP,0,(char *)(ret)) +- +-# define BIO_reset(b) (int)BIO_ctrl(b,BIO_CTRL_RESET,0,NULL) +-# define BIO_eof(b) (int)BIO_ctrl(b,BIO_CTRL_EOF,0,NULL) +-# define BIO_set_close(b,c) (int)BIO_ctrl(b,BIO_CTRL_SET_CLOSE,(c),NULL) +-# define BIO_get_close(b) (int)BIO_ctrl(b,BIO_CTRL_GET_CLOSE,0,NULL) +-# define BIO_pending(b) (int)BIO_ctrl(b,BIO_CTRL_PENDING,0,NULL) +-# define BIO_wpending(b) (int)BIO_ctrl(b,BIO_CTRL_WPENDING,0,NULL) +-/* ...pending macros have inappropriate return type */ +-size_t BIO_ctrl_pending(BIO *b); +-size_t BIO_ctrl_wpending(BIO *b); +-# define BIO_flush(b) (int)BIO_ctrl(b,BIO_CTRL_FLUSH,0,NULL) +-# define BIO_get_info_callback(b,cbp) (int)BIO_ctrl(b,BIO_CTRL_GET_CALLBACK,0, \ +- cbp) +-# define BIO_set_info_callback(b,cb) (int)BIO_callback_ctrl(b,BIO_CTRL_SET_CALLBACK,cb) +- +-/* For the BIO_f_buffer() type */ +-# define BIO_buffer_get_num_lines(b) BIO_ctrl(b,BIO_CTRL_GET,0,NULL) +-# define BIO_buffer_peek(b,s,l) BIO_ctrl(b,BIO_CTRL_PEEK,(l),(s)) +- +-/* For BIO_s_bio() */ +-# define BIO_set_write_buf_size(b,size) (int)BIO_ctrl(b,BIO_C_SET_WRITE_BUF_SIZE,size,NULL) +-# define BIO_get_write_buf_size(b,size) (size_t)BIO_ctrl(b,BIO_C_GET_WRITE_BUF_SIZE,size,NULL) +-# define BIO_make_bio_pair(b1,b2) (int)BIO_ctrl(b1,BIO_C_MAKE_BIO_PAIR,0,b2) +-# define BIO_destroy_bio_pair(b) (int)BIO_ctrl(b,BIO_C_DESTROY_BIO_PAIR,0,NULL) +-# define BIO_shutdown_wr(b) (int)BIO_ctrl(b, BIO_C_SHUTDOWN_WR, 0, NULL) +-/* macros with inappropriate type -- but ...pending macros use int too: */ +-# define BIO_get_write_guarantee(b) (int)BIO_ctrl(b,BIO_C_GET_WRITE_GUARANTEE,0,NULL) +-# define BIO_get_read_request(b) (int)BIO_ctrl(b,BIO_C_GET_READ_REQUEST,0,NULL) +-size_t BIO_ctrl_get_write_guarantee(BIO *b); +-size_t BIO_ctrl_get_read_request(BIO *b); +-int BIO_ctrl_reset_read_request(BIO *b); +- +-/* ctrl macros for dgram */ +-# define BIO_ctrl_dgram_connect(b,peer) \ +- (int)BIO_ctrl(b,BIO_CTRL_DGRAM_CONNECT,0, (char *)(peer)) +-# define BIO_ctrl_set_connected(b,peer) \ +- (int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_CONNECTED, 0, (char *)(peer)) +-# define BIO_dgram_recv_timedout(b) \ +- (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP, 0, NULL) +-# define BIO_dgram_send_timedout(b) \ +- (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP, 0, NULL) +-# define BIO_dgram_get_peer(b,peer) \ +- (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_PEER, 0, (char *)(peer)) +-# define BIO_dgram_set_peer(b,peer) \ +- (int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_PEER, 0, (char *)(peer)) +-# define BIO_dgram_get_mtu_overhead(b) \ +- (unsigned int)BIO_ctrl((b), BIO_CTRL_DGRAM_GET_MTU_OVERHEAD, 0, NULL) +- +-#define BIO_get_ex_new_index(l, p, newf, dupf, freef) \ +- CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_BIO, l, p, newf, dupf, freef) +-int BIO_set_ex_data(BIO *bio, int idx, void *data); +-void *BIO_get_ex_data(BIO *bio, int idx); +-uint64_t BIO_number_read(BIO *bio); +-uint64_t BIO_number_written(BIO *bio); +- +-/* For BIO_f_asn1() */ +-int BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix, +- asn1_ps_func *prefix_free); +-int BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix, +- asn1_ps_func **pprefix_free); +-int BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix, +- asn1_ps_func *suffix_free); +-int BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix, +- asn1_ps_func **psuffix_free); +- +-const BIO_METHOD *BIO_s_file(void); +-BIO *BIO_new_file(const char *filename, const char *mode); +-# ifndef OPENSSL_NO_STDIO +-BIO *BIO_new_fp(FILE *stream, int close_flag); +-# endif +-BIO *BIO_new(const BIO_METHOD *type); +-int BIO_free(BIO *a); +-void BIO_set_data(BIO *a, void *ptr); +-void *BIO_get_data(BIO *a); +-void BIO_set_init(BIO *a, int init); +-int BIO_get_init(BIO *a); +-void BIO_set_shutdown(BIO *a, int shut); +-int BIO_get_shutdown(BIO *a); +-void BIO_vfree(BIO *a); +-int BIO_up_ref(BIO *a); +-int BIO_read(BIO *b, void *data, int dlen); +-int BIO_read_ex(BIO *b, void *data, size_t dlen, size_t *readbytes); +-int BIO_gets(BIO *bp, char *buf, int size); +-int BIO_write(BIO *b, const void *data, int dlen); +-int BIO_write_ex(BIO *b, const void *data, size_t dlen, size_t *written); +-int BIO_puts(BIO *bp, const char *buf); +-int BIO_indent(BIO *b, int indent, int max); +-long BIO_ctrl(BIO *bp, int cmd, long larg, void *parg); +-long BIO_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp); +-void *BIO_ptr_ctrl(BIO *bp, int cmd, long larg); +-long BIO_int_ctrl(BIO *bp, int cmd, long larg, int iarg); +-BIO *BIO_push(BIO *b, BIO *append); +-BIO *BIO_pop(BIO *b); +-void BIO_free_all(BIO *a); +-BIO *BIO_find_type(BIO *b, int bio_type); +-BIO *BIO_next(BIO *b); +-void BIO_set_next(BIO *b, BIO *next); +-BIO *BIO_get_retry_BIO(BIO *bio, int *reason); +-int BIO_get_retry_reason(BIO *bio); +-void BIO_set_retry_reason(BIO *bio, int reason); +-BIO *BIO_dup_chain(BIO *in); +- +-int BIO_nread0(BIO *bio, char **buf); +-int BIO_nread(BIO *bio, char **buf, int num); +-int BIO_nwrite0(BIO *bio, char **buf); +-int BIO_nwrite(BIO *bio, char **buf, int num); +- +-long BIO_debug_callback(BIO *bio, int cmd, const char *argp, int argi, +- long argl, long ret); +- +-const BIO_METHOD *BIO_s_mem(void); +-const BIO_METHOD *BIO_s_secmem(void); +-BIO *BIO_new_mem_buf(const void *buf, int len); +-# ifndef OPENSSL_NO_SOCK +-const BIO_METHOD *BIO_s_socket(void); +-const BIO_METHOD *BIO_s_connect(void); +-const BIO_METHOD *BIO_s_accept(void); +-# endif +-const BIO_METHOD *BIO_s_fd(void); +-const BIO_METHOD *BIO_s_log(void); +-const BIO_METHOD *BIO_s_bio(void); +-const BIO_METHOD *BIO_s_null(void); +-const BIO_METHOD *BIO_f_null(void); +-const BIO_METHOD *BIO_f_buffer(void); +-const BIO_METHOD *BIO_f_linebuffer(void); +-const BIO_METHOD *BIO_f_nbio_test(void); +-# ifndef OPENSSL_NO_DGRAM +-const BIO_METHOD *BIO_s_datagram(void); +-int BIO_dgram_non_fatal_error(int error); +-BIO *BIO_new_dgram(int fd, int close_flag); +-# ifndef OPENSSL_NO_SCTP +-const BIO_METHOD *BIO_s_datagram_sctp(void); +-BIO *BIO_new_dgram_sctp(int fd, int close_flag); +-int BIO_dgram_is_sctp(BIO *bio); +-int BIO_dgram_sctp_notification_cb(BIO *b, +- void (*handle_notifications) (BIO *bio, +- void *context, +- void *buf), +- void *context); +-int BIO_dgram_sctp_wait_for_dry(BIO *b); +-int BIO_dgram_sctp_msg_waiting(BIO *b); +-# endif +-# endif +- +-# ifndef OPENSSL_NO_SOCK +-int BIO_sock_should_retry(int i); +-int BIO_sock_non_fatal_error(int error); +-# endif +- +-int BIO_fd_should_retry(int i); +-int BIO_fd_non_fatal_error(int error); +-int BIO_dump_cb(int (*cb) (const void *data, size_t len, void *u), +- void *u, const char *s, int len); +-int BIO_dump_indent_cb(int (*cb) (const void *data, size_t len, void *u), +- void *u, const char *s, int len, int indent); +-int BIO_dump(BIO *b, const char *bytes, int len); +-int BIO_dump_indent(BIO *b, const char *bytes, int len, int indent); +-# ifndef OPENSSL_NO_STDIO +-int BIO_dump_fp(FILE *fp, const char *s, int len); +-int BIO_dump_indent_fp(FILE *fp, const char *s, int len, int indent); +-# endif +-int BIO_hex_string(BIO *out, int indent, int width, unsigned char *data, +- int datalen); +- +-# ifndef OPENSSL_NO_SOCK +-BIO_ADDR *BIO_ADDR_new(void); +-int BIO_ADDR_rawmake(BIO_ADDR *ap, int family, +- const void *where, size_t wherelen, unsigned short port); +-void BIO_ADDR_free(BIO_ADDR *); +-void BIO_ADDR_clear(BIO_ADDR *ap); +-int BIO_ADDR_family(const BIO_ADDR *ap); +-int BIO_ADDR_rawaddress(const BIO_ADDR *ap, void *p, size_t *l); +-unsigned short BIO_ADDR_rawport(const BIO_ADDR *ap); +-char *BIO_ADDR_hostname_string(const BIO_ADDR *ap, int numeric); +-char *BIO_ADDR_service_string(const BIO_ADDR *ap, int numeric); +-char *BIO_ADDR_path_string(const BIO_ADDR *ap); +- +-const BIO_ADDRINFO *BIO_ADDRINFO_next(const BIO_ADDRINFO *bai); +-int BIO_ADDRINFO_family(const BIO_ADDRINFO *bai); +-int BIO_ADDRINFO_socktype(const BIO_ADDRINFO *bai); +-int BIO_ADDRINFO_protocol(const BIO_ADDRINFO *bai); +-const BIO_ADDR *BIO_ADDRINFO_address(const BIO_ADDRINFO *bai); +-void BIO_ADDRINFO_free(BIO_ADDRINFO *bai); +- +-enum BIO_hostserv_priorities { +- BIO_PARSE_PRIO_HOST, BIO_PARSE_PRIO_SERV +-}; +-int BIO_parse_hostserv(const char *hostserv, char **host, char **service, +- enum BIO_hostserv_priorities hostserv_prio); +-enum BIO_lookup_type { +- BIO_LOOKUP_CLIENT, BIO_LOOKUP_SERVER +-}; +-int BIO_lookup(const char *host, const char *service, +- enum BIO_lookup_type lookup_type, +- int family, int socktype, BIO_ADDRINFO **res); +-int BIO_lookup_ex(const char *host, const char *service, +- int lookup_type, int family, int socktype, int protocol, +- BIO_ADDRINFO **res); +-int BIO_sock_error(int sock); +-int BIO_socket_ioctl(int fd, long type, void *arg); +-int BIO_socket_nbio(int fd, int mode); +-int BIO_sock_init(void); +-# if OPENSSL_API_COMPAT < 0x10100000L +-# define BIO_sock_cleanup() while(0) continue +-# endif +-int BIO_set_tcp_ndelay(int sock, int turn_on); +- +-DEPRECATEDIN_1_1_0(struct hostent *BIO_gethostbyname(const char *name)) +-DEPRECATEDIN_1_1_0(int BIO_get_port(const char *str, unsigned short *port_ptr)) +-DEPRECATEDIN_1_1_0(int BIO_get_host_ip(const char *str, unsigned char *ip)) +-DEPRECATEDIN_1_1_0(int BIO_get_accept_socket(char *host_port, int mode)) +-DEPRECATEDIN_1_1_0(int BIO_accept(int sock, char **ip_port)) +- +-union BIO_sock_info_u { +- BIO_ADDR *addr; +-}; +-enum BIO_sock_info_type { +- BIO_SOCK_INFO_ADDRESS +-}; +-int BIO_sock_info(int sock, +- enum BIO_sock_info_type type, union BIO_sock_info_u *info); +- +-# define BIO_SOCK_REUSEADDR 0x01 +-# define BIO_SOCK_V6_ONLY 0x02 +-# define BIO_SOCK_KEEPALIVE 0x04 +-# define BIO_SOCK_NONBLOCK 0x08 +-# define BIO_SOCK_NODELAY 0x10 +- +-int BIO_socket(int domain, int socktype, int protocol, int options); +-int BIO_connect(int sock, const BIO_ADDR *addr, int options); +-int BIO_bind(int sock, const BIO_ADDR *addr, int options); +-int BIO_listen(int sock, const BIO_ADDR *addr, int options); +-int BIO_accept_ex(int accept_sock, BIO_ADDR *addr, int options); +-int BIO_closesocket(int sock); +- +-BIO *BIO_new_socket(int sock, int close_flag); +-BIO *BIO_new_connect(const char *host_port); +-BIO *BIO_new_accept(const char *host_port); +-# endif /* OPENSSL_NO_SOCK*/ +- +-BIO *BIO_new_fd(int fd, int close_flag); +- +-int BIO_new_bio_pair(BIO **bio1, size_t writebuf1, +- BIO **bio2, size_t writebuf2); +-/* +- * If successful, returns 1 and in *bio1, *bio2 two BIO pair endpoints. +- * Otherwise returns 0 and sets *bio1 and *bio2 to NULL. Size 0 uses default +- * value. +- */ +- +-void BIO_copy_next_retry(BIO *b); +- +-/* +- * long BIO_ghbn_ctrl(int cmd,int iarg,char *parg); +- */ +- +-# define ossl_bio__attr__(x) +-# if defined(__GNUC__) && defined(__STDC_VERSION__) \ +- && !defined(__APPLE__) +- /* +- * Because we support the 'z' modifier, which made its appearance in C99, +- * we can't use __attribute__ with pre C99 dialects. +- */ +-# if __STDC_VERSION__ >= 199901L +-# undef ossl_bio__attr__ +-# define ossl_bio__attr__ __attribute__ +-# if __GNUC__*10 + __GNUC_MINOR__ >= 44 +-# define ossl_bio__printf__ __gnu_printf__ +-# else +-# define ossl_bio__printf__ __printf__ +-# endif +-# endif +-# endif +-int BIO_printf(BIO *bio, const char *format, ...) +-ossl_bio__attr__((__format__(ossl_bio__printf__, 2, 3))); +-int BIO_vprintf(BIO *bio, const char *format, va_list args) +-ossl_bio__attr__((__format__(ossl_bio__printf__, 2, 0))); +-int BIO_snprintf(char *buf, size_t n, const char *format, ...) +-ossl_bio__attr__((__format__(ossl_bio__printf__, 3, 4))); +-int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args) +-ossl_bio__attr__((__format__(ossl_bio__printf__, 3, 0))); +-# undef ossl_bio__attr__ +-# undef ossl_bio__printf__ +- +- +-BIO_METHOD *BIO_meth_new(int type, const char *name); +-void BIO_meth_free(BIO_METHOD *biom); +-int (*BIO_meth_get_write(const BIO_METHOD *biom)) (BIO *, const char *, int); +-int (*BIO_meth_get_write_ex(const BIO_METHOD *biom)) (BIO *, const char *, size_t, +- size_t *); +-int BIO_meth_set_write(BIO_METHOD *biom, +- int (*write) (BIO *, const char *, int)); +-int BIO_meth_set_write_ex(BIO_METHOD *biom, +- int (*bwrite) (BIO *, const char *, size_t, size_t *)); +-int (*BIO_meth_get_read(const BIO_METHOD *biom)) (BIO *, char *, int); +-int (*BIO_meth_get_read_ex(const BIO_METHOD *biom)) (BIO *, char *, size_t, size_t *); +-int BIO_meth_set_read(BIO_METHOD *biom, +- int (*read) (BIO *, char *, int)); +-int BIO_meth_set_read_ex(BIO_METHOD *biom, +- int (*bread) (BIO *, char *, size_t, size_t *)); +-int (*BIO_meth_get_puts(const BIO_METHOD *biom)) (BIO *, const char *); +-int BIO_meth_set_puts(BIO_METHOD *biom, +- int (*puts) (BIO *, const char *)); +-int (*BIO_meth_get_gets(const BIO_METHOD *biom)) (BIO *, char *, int); +-int BIO_meth_set_gets(BIO_METHOD *biom, +- int (*gets) (BIO *, char *, int)); +-long (*BIO_meth_get_ctrl(const BIO_METHOD *biom)) (BIO *, int, long, void *); +-int BIO_meth_set_ctrl(BIO_METHOD *biom, +- long (*ctrl) (BIO *, int, long, void *)); +-int (*BIO_meth_get_create(const BIO_METHOD *bion)) (BIO *); +-int BIO_meth_set_create(BIO_METHOD *biom, int (*create) (BIO *)); +-int (*BIO_meth_get_destroy(const BIO_METHOD *biom)) (BIO *); +-int BIO_meth_set_destroy(BIO_METHOD *biom, int (*destroy) (BIO *)); +-long (*BIO_meth_get_callback_ctrl(const BIO_METHOD *biom)) +- (BIO *, int, BIO_info_cb *); +-int BIO_meth_set_callback_ctrl(BIO_METHOD *biom, +- long (*callback_ctrl) (BIO *, int, +- BIO_info_cb *)); +- +-# ifdef __cplusplus +-} +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/bioerr.h b/uadk_tool/include/openssl/bioerr.h +deleted file mode 100644 +index 46e2c96..0000000 +--- a/uadk_tool/include/openssl/bioerr.h ++++ /dev/null +@@ -1,124 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_BIOERR_H +-# define HEADER_BIOERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_BIO_strings(void); +- +-/* +- * BIO function codes. +- */ +-# define BIO_F_ACPT_STATE 100 +-# define BIO_F_ADDRINFO_WRAP 148 +-# define BIO_F_ADDR_STRINGS 134 +-# define BIO_F_BIO_ACCEPT 101 +-# define BIO_F_BIO_ACCEPT_EX 137 +-# define BIO_F_BIO_ACCEPT_NEW 152 +-# define BIO_F_BIO_ADDR_NEW 144 +-# define BIO_F_BIO_BIND 147 +-# define BIO_F_BIO_CALLBACK_CTRL 131 +-# define BIO_F_BIO_CONNECT 138 +-# define BIO_F_BIO_CONNECT_NEW 153 +-# define BIO_F_BIO_CTRL 103 +-# define BIO_F_BIO_GETS 104 +-# define BIO_F_BIO_GET_HOST_IP 106 +-# define BIO_F_BIO_GET_NEW_INDEX 102 +-# define BIO_F_BIO_GET_PORT 107 +-# define BIO_F_BIO_LISTEN 139 +-# define BIO_F_BIO_LOOKUP 135 +-# define BIO_F_BIO_LOOKUP_EX 143 +-# define BIO_F_BIO_MAKE_PAIR 121 +-# define BIO_F_BIO_METH_NEW 146 +-# define BIO_F_BIO_NEW 108 +-# define BIO_F_BIO_NEW_DGRAM_SCTP 145 +-# define BIO_F_BIO_NEW_FILE 109 +-# define BIO_F_BIO_NEW_MEM_BUF 126 +-# define BIO_F_BIO_NREAD 123 +-# define BIO_F_BIO_NREAD0 124 +-# define BIO_F_BIO_NWRITE 125 +-# define BIO_F_BIO_NWRITE0 122 +-# define BIO_F_BIO_PARSE_HOSTSERV 136 +-# define BIO_F_BIO_PUTS 110 +-# define BIO_F_BIO_READ 111 +-# define BIO_F_BIO_READ_EX 105 +-# define BIO_F_BIO_READ_INTERN 120 +-# define BIO_F_BIO_SOCKET 140 +-# define BIO_F_BIO_SOCKET_NBIO 142 +-# define BIO_F_BIO_SOCK_INFO 141 +-# define BIO_F_BIO_SOCK_INIT 112 +-# define BIO_F_BIO_WRITE 113 +-# define BIO_F_BIO_WRITE_EX 119 +-# define BIO_F_BIO_WRITE_INTERN 128 +-# define BIO_F_BUFFER_CTRL 114 +-# define BIO_F_CONN_CTRL 127 +-# define BIO_F_CONN_STATE 115 +-# define BIO_F_DGRAM_SCTP_NEW 149 +-# define BIO_F_DGRAM_SCTP_READ 132 +-# define BIO_F_DGRAM_SCTP_WRITE 133 +-# define BIO_F_DOAPR_OUTCH 150 +-# define BIO_F_FILE_CTRL 116 +-# define BIO_F_FILE_READ 130 +-# define BIO_F_LINEBUFFER_CTRL 129 +-# define BIO_F_LINEBUFFER_NEW 151 +-# define BIO_F_MEM_WRITE 117 +-# define BIO_F_NBIOF_NEW 154 +-# define BIO_F_SLG_WRITE 155 +-# define BIO_F_SSL_NEW 118 +- +-/* +- * BIO reason codes. +- */ +-# define BIO_R_ACCEPT_ERROR 100 +-# define BIO_R_ADDRINFO_ADDR_IS_NOT_AF_INET 141 +-# define BIO_R_AMBIGUOUS_HOST_OR_SERVICE 129 +-# define BIO_R_BAD_FOPEN_MODE 101 +-# define BIO_R_BROKEN_PIPE 124 +-# define BIO_R_CONNECT_ERROR 103 +-# define BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET 107 +-# define BIO_R_GETSOCKNAME_ERROR 132 +-# define BIO_R_GETSOCKNAME_TRUNCATED_ADDRESS 133 +-# define BIO_R_GETTING_SOCKTYPE 134 +-# define BIO_R_INVALID_ARGUMENT 125 +-# define BIO_R_INVALID_SOCKET 135 +-# define BIO_R_IN_USE 123 +-# define BIO_R_LENGTH_TOO_LONG 102 +-# define BIO_R_LISTEN_V6_ONLY 136 +-# define BIO_R_LOOKUP_RETURNED_NOTHING 142 +-# define BIO_R_MALFORMED_HOST_OR_SERVICE 130 +-# define BIO_R_NBIO_CONNECT_ERROR 110 +-# define BIO_R_NO_ACCEPT_ADDR_OR_SERVICE_SPECIFIED 143 +-# define BIO_R_NO_HOSTNAME_OR_SERVICE_SPECIFIED 144 +-# define BIO_R_NO_PORT_DEFINED 113 +-# define BIO_R_NO_SUCH_FILE 128 +-# define BIO_R_NULL_PARAMETER 115 +-# define BIO_R_UNABLE_TO_BIND_SOCKET 117 +-# define BIO_R_UNABLE_TO_CREATE_SOCKET 118 +-# define BIO_R_UNABLE_TO_KEEPALIVE 137 +-# define BIO_R_UNABLE_TO_LISTEN_SOCKET 119 +-# define BIO_R_UNABLE_TO_NODELAY 138 +-# define BIO_R_UNABLE_TO_REUSEADDR 139 +-# define BIO_R_UNAVAILABLE_IP_FAMILY 145 +-# define BIO_R_UNINITIALIZED 120 +-# define BIO_R_UNKNOWN_INFO_TYPE 140 +-# define BIO_R_UNSUPPORTED_IP_FAMILY 146 +-# define BIO_R_UNSUPPORTED_METHOD 121 +-# define BIO_R_UNSUPPORTED_PROTOCOL_FAMILY 131 +-# define BIO_R_WRITE_TO_READ_ONLY_BIO 126 +-# define BIO_R_WSASTARTUP 122 +- +-#endif +diff --git a/uadk_tool/include/openssl/blowfish.h b/uadk_tool/include/openssl/blowfish.h +deleted file mode 100644 +index cd3e460..0000000 +--- a/uadk_tool/include/openssl/blowfish.h ++++ /dev/null +@@ -1,61 +0,0 @@ +-/* +- * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_BLOWFISH_H +-# define HEADER_BLOWFISH_H +- +-# include +- +-# ifndef OPENSSL_NO_BF +-# include +-# ifdef __cplusplus +-extern "C" { +-# endif +- +-# define BF_ENCRYPT 1 +-# define BF_DECRYPT 0 +- +-/*- +- * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +- * ! BF_LONG has to be at least 32 bits wide. ! +- * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +- */ +-# define BF_LONG unsigned int +- +-# define BF_ROUNDS 16 +-# define BF_BLOCK 8 +- +-typedef struct bf_key_st { +- BF_LONG P[BF_ROUNDS + 2]; +- BF_LONG S[4 * 256]; +-} BF_KEY; +- +-void BF_set_key(BF_KEY *key, int len, const unsigned char *data); +- +-void BF_encrypt(BF_LONG *data, const BF_KEY *key); +-void BF_decrypt(BF_LONG *data, const BF_KEY *key); +- +-void BF_ecb_encrypt(const unsigned char *in, unsigned char *out, +- const BF_KEY *key, int enc); +-void BF_cbc_encrypt(const unsigned char *in, unsigned char *out, long length, +- const BF_KEY *schedule, unsigned char *ivec, int enc); +-void BF_cfb64_encrypt(const unsigned char *in, unsigned char *out, +- long length, const BF_KEY *schedule, +- unsigned char *ivec, int *num, int enc); +-void BF_ofb64_encrypt(const unsigned char *in, unsigned char *out, +- long length, const BF_KEY *schedule, +- unsigned char *ivec, int *num); +-const char *BF_options(void); +- +-# ifdef __cplusplus +-} +-# endif +-# endif +- +-#endif +diff --git a/uadk_tool/include/openssl/bn.h b/uadk_tool/include/openssl/bn.h +deleted file mode 100644 +index d877660..0000000 +--- a/uadk_tool/include/openssl/bn.h ++++ /dev/null +@@ -1,539 +0,0 @@ +-/* +- * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. +- * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_BN_H +-# define HEADER_BN_H +- +-# include +-# ifndef OPENSSL_NO_STDIO +-# include +-# endif +-# include +-# include +-# include +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-/* +- * 64-bit processor with LP64 ABI +- */ +-# ifdef SIXTY_FOUR_BIT_LONG +-# define BN_ULONG unsigned long +-# define BN_BYTES 8 +-# endif +- +-/* +- * 64-bit processor other than LP64 ABI +- */ +-# ifdef SIXTY_FOUR_BIT +-# define BN_ULONG unsigned long long +-# define BN_BYTES 8 +-# endif +- +-# ifdef THIRTY_TWO_BIT +-# define BN_ULONG unsigned int +-# define BN_BYTES 4 +-# endif +- +-# define BN_BITS2 (BN_BYTES * 8) +-# define BN_BITS (BN_BITS2 * 2) +-# define BN_TBIT ((BN_ULONG)1 << (BN_BITS2 - 1)) +- +-# define BN_FLG_MALLOCED 0x01 +-# define BN_FLG_STATIC_DATA 0x02 +- +-/* +- * avoid leaking exponent information through timing, +- * BN_mod_exp_mont() will call BN_mod_exp_mont_consttime, +- * BN_div() will call BN_div_no_branch, +- * BN_mod_inverse() will call bn_mod_inverse_no_branch. +- */ +-# define BN_FLG_CONSTTIME 0x04 +-# define BN_FLG_SECURE 0x08 +- +-# if OPENSSL_API_COMPAT < 0x00908000L +-/* deprecated name for the flag */ +-# define BN_FLG_EXP_CONSTTIME BN_FLG_CONSTTIME +-# define BN_FLG_FREE 0x8000 /* used for debugging */ +-# endif +- +-void BN_set_flags(BIGNUM *b, int n); +-int BN_get_flags(const BIGNUM *b, int n); +- +-/* Values for |top| in BN_rand() */ +-#define BN_RAND_TOP_ANY -1 +-#define BN_RAND_TOP_ONE 0 +-#define BN_RAND_TOP_TWO 1 +- +-/* Values for |bottom| in BN_rand() */ +-#define BN_RAND_BOTTOM_ANY 0 +-#define BN_RAND_BOTTOM_ODD 1 +- +-/* +- * get a clone of a BIGNUM with changed flags, for *temporary* use only (the +- * two BIGNUMs cannot be used in parallel!). Also only for *read only* use. The +- * value |dest| should be a newly allocated BIGNUM obtained via BN_new() that +- * has not been otherwise initialised or used. +- */ +-void BN_with_flags(BIGNUM *dest, const BIGNUM *b, int flags); +- +-/* Wrapper function to make using BN_GENCB easier */ +-int BN_GENCB_call(BN_GENCB *cb, int a, int b); +- +-BN_GENCB *BN_GENCB_new(void); +-void BN_GENCB_free(BN_GENCB *cb); +- +-/* Populate a BN_GENCB structure with an "old"-style callback */ +-void BN_GENCB_set_old(BN_GENCB *gencb, void (*callback) (int, int, void *), +- void *cb_arg); +- +-/* Populate a BN_GENCB structure with a "new"-style callback */ +-void BN_GENCB_set(BN_GENCB *gencb, int (*callback) (int, int, BN_GENCB *), +- void *cb_arg); +- +-void *BN_GENCB_get_arg(BN_GENCB *cb); +- +-# define BN_prime_checks 0 /* default: select number of iterations based +- * on the size of the number */ +- +-/* +- * BN_prime_checks_for_size() returns the number of Miller-Rabin iterations +- * that will be done for checking that a random number is probably prime. The +- * error rate for accepting a composite number as prime depends on the size of +- * the prime |b|. The error rates used are for calculating an RSA key with 2 primes, +- * and so the level is what you would expect for a key of double the size of the +- * prime. +- * +- * This table is generated using the algorithm of FIPS PUB 186-4 +- * Digital Signature Standard (DSS), section F.1, page 117. +- * (https://dx.doi.org/10.6028/NIST.FIPS.186-4) +- * +- * The following magma script was used to generate the output: +- * securitybits:=125; +- * k:=1024; +- * for t:=1 to 65 do +- * for M:=3 to Floor(2*Sqrt(k-1)-1) do +- * S:=0; +- * // Sum over m +- * for m:=3 to M do +- * s:=0; +- * // Sum over j +- * for j:=2 to m do +- * s+:=(RealField(32)!2)^-(j+(k-1)/j); +- * end for; +- * S+:=2^(m-(m-1)*t)*s; +- * end for; +- * A:=2^(k-2-M*t); +- * B:=8*(Pi(RealField(32))^2-6)/3*2^(k-2)*S; +- * pkt:=2.00743*Log(2)*k*2^-k*(A+B); +- * seclevel:=Floor(-Log(2,pkt)); +- * if seclevel ge securitybits then +- * printf "k: %5o, security: %o bits (t: %o, M: %o)\n",k,seclevel,t,M; +- * break; +- * end if; +- * end for; +- * if seclevel ge securitybits then break; end if; +- * end for; +- * +- * It can be run online at: +- * http://magma.maths.usyd.edu.au/calc +- * +- * And will output: +- * k: 1024, security: 129 bits (t: 6, M: 23) +- * +- * k is the number of bits of the prime, securitybits is the level we want to +- * reach. +- * +- * prime length | RSA key size | # MR tests | security level +- * -------------+--------------|------------+--------------- +- * (b) >= 6394 | >= 12788 | 3 | 256 bit +- * (b) >= 3747 | >= 7494 | 3 | 192 bit +- * (b) >= 1345 | >= 2690 | 4 | 128 bit +- * (b) >= 1080 | >= 2160 | 5 | 128 bit +- * (b) >= 852 | >= 1704 | 5 | 112 bit +- * (b) >= 476 | >= 952 | 5 | 80 bit +- * (b) >= 400 | >= 800 | 6 | 80 bit +- * (b) >= 347 | >= 694 | 7 | 80 bit +- * (b) >= 308 | >= 616 | 8 | 80 bit +- * (b) >= 55 | >= 110 | 27 | 64 bit +- * (b) >= 6 | >= 12 | 34 | 64 bit +- */ +- +-# define BN_prime_checks_for_size(b) ((b) >= 3747 ? 3 : \ +- (b) >= 1345 ? 4 : \ +- (b) >= 476 ? 5 : \ +- (b) >= 400 ? 6 : \ +- (b) >= 347 ? 7 : \ +- (b) >= 308 ? 8 : \ +- (b) >= 55 ? 27 : \ +- /* b >= 6 */ 34) +- +-# define BN_num_bytes(a) ((BN_num_bits(a)+7)/8) +- +-int BN_abs_is_word(const BIGNUM *a, const BN_ULONG w); +-int BN_is_zero(const BIGNUM *a); +-int BN_is_one(const BIGNUM *a); +-int BN_is_word(const BIGNUM *a, const BN_ULONG w); +-int BN_is_odd(const BIGNUM *a); +- +-# define BN_one(a) (BN_set_word((a),1)) +- +-void BN_zero_ex(BIGNUM *a); +- +-# if OPENSSL_API_COMPAT >= 0x00908000L +-# define BN_zero(a) BN_zero_ex(a) +-# else +-# define BN_zero(a) (BN_set_word((a),0)) +-# endif +- +-const BIGNUM *BN_value_one(void); +-char *BN_options(void); +-BN_CTX *BN_CTX_new(void); +-BN_CTX *BN_CTX_secure_new(void); +-void BN_CTX_free(BN_CTX *c); +-void BN_CTX_start(BN_CTX *ctx); +-BIGNUM *BN_CTX_get(BN_CTX *ctx); +-void BN_CTX_end(BN_CTX *ctx); +-int BN_rand(BIGNUM *rnd, int bits, int top, int bottom); +-int BN_priv_rand(BIGNUM *rnd, int bits, int top, int bottom); +-int BN_rand_range(BIGNUM *rnd, const BIGNUM *range); +-int BN_priv_rand_range(BIGNUM *rnd, const BIGNUM *range); +-int BN_pseudo_rand(BIGNUM *rnd, int bits, int top, int bottom); +-int BN_pseudo_rand_range(BIGNUM *rnd, const BIGNUM *range); +-int BN_num_bits(const BIGNUM *a); +-int BN_num_bits_word(BN_ULONG l); +-int BN_security_bits(int L, int N); +-BIGNUM *BN_new(void); +-BIGNUM *BN_secure_new(void); +-void BN_clear_free(BIGNUM *a); +-BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b); +-void BN_swap(BIGNUM *a, BIGNUM *b); +-BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret); +-int BN_bn2bin(const BIGNUM *a, unsigned char *to); +-int BN_bn2binpad(const BIGNUM *a, unsigned char *to, int tolen); +-BIGNUM *BN_lebin2bn(const unsigned char *s, int len, BIGNUM *ret); +-int BN_bn2lebinpad(const BIGNUM *a, unsigned char *to, int tolen); +-BIGNUM *BN_mpi2bn(const unsigned char *s, int len, BIGNUM *ret); +-int BN_bn2mpi(const BIGNUM *a, unsigned char *to); +-int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); +-int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); +-int BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); +-int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); +-int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); +-int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx); +-/** BN_set_negative sets sign of a BIGNUM +- * \param b pointer to the BIGNUM object +- * \param n 0 if the BIGNUM b should be positive and a value != 0 otherwise +- */ +-void BN_set_negative(BIGNUM *b, int n); +-/** BN_is_negative returns 1 if the BIGNUM is negative +- * \param b pointer to the BIGNUM object +- * \return 1 if a < 0 and 0 otherwise +- */ +-int BN_is_negative(const BIGNUM *b); +- +-int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d, +- BN_CTX *ctx); +-# define BN_mod(rem,m,d,ctx) BN_div(NULL,(rem),(m),(d),(ctx)) +-int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx); +-int BN_mod_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, +- BN_CTX *ctx); +-int BN_mod_add_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, +- const BIGNUM *m); +-int BN_mod_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, +- BN_CTX *ctx); +-int BN_mod_sub_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, +- const BIGNUM *m); +-int BN_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, +- BN_CTX *ctx); +-int BN_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx); +-int BN_mod_lshift1(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx); +-int BN_mod_lshift1_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *m); +-int BN_mod_lshift(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m, +- BN_CTX *ctx); +-int BN_mod_lshift_quick(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m); +- +-BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w); +-BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w); +-int BN_mul_word(BIGNUM *a, BN_ULONG w); +-int BN_add_word(BIGNUM *a, BN_ULONG w); +-int BN_sub_word(BIGNUM *a, BN_ULONG w); +-int BN_set_word(BIGNUM *a, BN_ULONG w); +-BN_ULONG BN_get_word(const BIGNUM *a); +- +-int BN_cmp(const BIGNUM *a, const BIGNUM *b); +-void BN_free(BIGNUM *a); +-int BN_is_bit_set(const BIGNUM *a, int n); +-int BN_lshift(BIGNUM *r, const BIGNUM *a, int n); +-int BN_lshift1(BIGNUM *r, const BIGNUM *a); +-int BN_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); +- +-int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, +- const BIGNUM *m, BN_CTX *ctx); +-int BN_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, +- const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); +-int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p, +- const BIGNUM *m, BN_CTX *ctx, +- BN_MONT_CTX *in_mont); +-int BN_mod_exp_mont_word(BIGNUM *r, BN_ULONG a, const BIGNUM *p, +- const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); +-int BN_mod_exp2_mont(BIGNUM *r, const BIGNUM *a1, const BIGNUM *p1, +- const BIGNUM *a2, const BIGNUM *p2, const BIGNUM *m, +- BN_CTX *ctx, BN_MONT_CTX *m_ctx); +-int BN_mod_exp_simple(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, +- const BIGNUM *m, BN_CTX *ctx); +- +-int BN_mask_bits(BIGNUM *a, int n); +-# ifndef OPENSSL_NO_STDIO +-int BN_print_fp(FILE *fp, const BIGNUM *a); +-# endif +-int BN_print(BIO *bio, const BIGNUM *a); +-int BN_reciprocal(BIGNUM *r, const BIGNUM *m, int len, BN_CTX *ctx); +-int BN_rshift(BIGNUM *r, const BIGNUM *a, int n); +-int BN_rshift1(BIGNUM *r, const BIGNUM *a); +-void BN_clear(BIGNUM *a); +-BIGNUM *BN_dup(const BIGNUM *a); +-int BN_ucmp(const BIGNUM *a, const BIGNUM *b); +-int BN_set_bit(BIGNUM *a, int n); +-int BN_clear_bit(BIGNUM *a, int n); +-char *BN_bn2hex(const BIGNUM *a); +-char *BN_bn2dec(const BIGNUM *a); +-int BN_hex2bn(BIGNUM **a, const char *str); +-int BN_dec2bn(BIGNUM **a, const char *str); +-int BN_asc2bn(BIGNUM **a, const char *str); +-int BN_gcd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); +-int BN_kronecker(const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); /* returns +- * -2 for +- * error */ +-BIGNUM *BN_mod_inverse(BIGNUM *ret, +- const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx); +-BIGNUM *BN_mod_sqrt(BIGNUM *ret, +- const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx); +- +-void BN_consttime_swap(BN_ULONG swap, BIGNUM *a, BIGNUM *b, int nwords); +- +-/* Deprecated versions */ +-DEPRECATEDIN_0_9_8(BIGNUM *BN_generate_prime(BIGNUM *ret, int bits, int safe, +- const BIGNUM *add, +- const BIGNUM *rem, +- void (*callback) (int, int, +- void *), +- void *cb_arg)) +-DEPRECATEDIN_0_9_8(int +- BN_is_prime(const BIGNUM *p, int nchecks, +- void (*callback) (int, int, void *), +- BN_CTX *ctx, void *cb_arg)) +-DEPRECATEDIN_0_9_8(int +- BN_is_prime_fasttest(const BIGNUM *p, int nchecks, +- void (*callback) (int, int, void *), +- BN_CTX *ctx, void *cb_arg, +- int do_trial_division)) +- +-/* Newer versions */ +-int BN_generate_prime_ex(BIGNUM *ret, int bits, int safe, const BIGNUM *add, +- const BIGNUM *rem, BN_GENCB *cb); +-int BN_is_prime_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx, BN_GENCB *cb); +-int BN_is_prime_fasttest_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx, +- int do_trial_division, BN_GENCB *cb); +- +-int BN_X931_generate_Xpq(BIGNUM *Xp, BIGNUM *Xq, int nbits, BN_CTX *ctx); +- +-int BN_X931_derive_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, +- const BIGNUM *Xp, const BIGNUM *Xp1, +- const BIGNUM *Xp2, const BIGNUM *e, BN_CTX *ctx, +- BN_GENCB *cb); +-int BN_X931_generate_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, BIGNUM *Xp1, +- BIGNUM *Xp2, const BIGNUM *Xp, const BIGNUM *e, +- BN_CTX *ctx, BN_GENCB *cb); +- +-BN_MONT_CTX *BN_MONT_CTX_new(void); +-int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, +- BN_MONT_CTX *mont, BN_CTX *ctx); +-int BN_to_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont, +- BN_CTX *ctx); +-int BN_from_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont, +- BN_CTX *ctx); +-void BN_MONT_CTX_free(BN_MONT_CTX *mont); +-int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx); +-BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to, BN_MONT_CTX *from); +-BN_MONT_CTX *BN_MONT_CTX_set_locked(BN_MONT_CTX **pmont, CRYPTO_RWLOCK *lock, +- const BIGNUM *mod, BN_CTX *ctx); +- +-/* BN_BLINDING flags */ +-# define BN_BLINDING_NO_UPDATE 0x00000001 +-# define BN_BLINDING_NO_RECREATE 0x00000002 +- +-BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai, BIGNUM *mod); +-void BN_BLINDING_free(BN_BLINDING *b); +-int BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx); +-int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx); +-int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx); +-int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *); +-int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b, +- BN_CTX *); +- +-int BN_BLINDING_is_current_thread(BN_BLINDING *b); +-void BN_BLINDING_set_current_thread(BN_BLINDING *b); +-int BN_BLINDING_lock(BN_BLINDING *b); +-int BN_BLINDING_unlock(BN_BLINDING *b); +- +-unsigned long BN_BLINDING_get_flags(const BN_BLINDING *); +-void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long); +-BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b, +- const BIGNUM *e, BIGNUM *m, BN_CTX *ctx, +- int (*bn_mod_exp) (BIGNUM *r, +- const BIGNUM *a, +- const BIGNUM *p, +- const BIGNUM *m, +- BN_CTX *ctx, +- BN_MONT_CTX *m_ctx), +- BN_MONT_CTX *m_ctx); +- +-DEPRECATEDIN_0_9_8(void BN_set_params(int mul, int high, int low, int mont)) +-DEPRECATEDIN_0_9_8(int BN_get_params(int which)) /* 0, mul, 1 high, 2 low, 3 +- * mont */ +- +-BN_RECP_CTX *BN_RECP_CTX_new(void); +-void BN_RECP_CTX_free(BN_RECP_CTX *recp); +-int BN_RECP_CTX_set(BN_RECP_CTX *recp, const BIGNUM *rdiv, BN_CTX *ctx); +-int BN_mod_mul_reciprocal(BIGNUM *r, const BIGNUM *x, const BIGNUM *y, +- BN_RECP_CTX *recp, BN_CTX *ctx); +-int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, +- const BIGNUM *m, BN_CTX *ctx); +-int BN_div_recp(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, +- BN_RECP_CTX *recp, BN_CTX *ctx); +- +-# ifndef OPENSSL_NO_EC2M +- +-/* +- * Functions for arithmetic over binary polynomials represented by BIGNUMs. +- * The BIGNUM::neg property of BIGNUMs representing binary polynomials is +- * ignored. Note that input arguments are not const so that their bit arrays +- * can be expanded to the appropriate size if needed. +- */ +- +-/* +- * r = a + b +- */ +-int BN_GF2m_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); +-# define BN_GF2m_sub(r, a, b) BN_GF2m_add(r, a, b) +-/* +- * r=a mod p +- */ +-int BN_GF2m_mod(BIGNUM *r, const BIGNUM *a, const BIGNUM *p); +-/* r = (a * b) mod p */ +-int BN_GF2m_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, +- const BIGNUM *p, BN_CTX *ctx); +-/* r = (a * a) mod p */ +-int BN_GF2m_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); +-/* r = (1 / b) mod p */ +-int BN_GF2m_mod_inv(BIGNUM *r, const BIGNUM *b, const BIGNUM *p, BN_CTX *ctx); +-/* r = (a / b) mod p */ +-int BN_GF2m_mod_div(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, +- const BIGNUM *p, BN_CTX *ctx); +-/* r = (a ^ b) mod p */ +-int BN_GF2m_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, +- const BIGNUM *p, BN_CTX *ctx); +-/* r = sqrt(a) mod p */ +-int BN_GF2m_mod_sqrt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, +- BN_CTX *ctx); +-/* r^2 + r = a mod p */ +-int BN_GF2m_mod_solve_quad(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, +- BN_CTX *ctx); +-# define BN_GF2m_cmp(a, b) BN_ucmp((a), (b)) +-/*- +- * Some functions allow for representation of the irreducible polynomials +- * as an unsigned int[], say p. The irreducible f(t) is then of the form: +- * t^p[0] + t^p[1] + ... + t^p[k] +- * where m = p[0] > p[1] > ... > p[k] = 0. +- */ +-/* r = a mod p */ +-int BN_GF2m_mod_arr(BIGNUM *r, const BIGNUM *a, const int p[]); +-/* r = (a * b) mod p */ +-int BN_GF2m_mod_mul_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, +- const int p[], BN_CTX *ctx); +-/* r = (a * a) mod p */ +-int BN_GF2m_mod_sqr_arr(BIGNUM *r, const BIGNUM *a, const int p[], +- BN_CTX *ctx); +-/* r = (1 / b) mod p */ +-int BN_GF2m_mod_inv_arr(BIGNUM *r, const BIGNUM *b, const int p[], +- BN_CTX *ctx); +-/* r = (a / b) mod p */ +-int BN_GF2m_mod_div_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, +- const int p[], BN_CTX *ctx); +-/* r = (a ^ b) mod p */ +-int BN_GF2m_mod_exp_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, +- const int p[], BN_CTX *ctx); +-/* r = sqrt(a) mod p */ +-int BN_GF2m_mod_sqrt_arr(BIGNUM *r, const BIGNUM *a, +- const int p[], BN_CTX *ctx); +-/* r^2 + r = a mod p */ +-int BN_GF2m_mod_solve_quad_arr(BIGNUM *r, const BIGNUM *a, +- const int p[], BN_CTX *ctx); +-int BN_GF2m_poly2arr(const BIGNUM *a, int p[], int max); +-int BN_GF2m_arr2poly(const int p[], BIGNUM *a); +- +-# endif +- +-/* +- * faster mod functions for the 'NIST primes' 0 <= a < p^2 +- */ +-int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); +-int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); +-int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); +-int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); +-int BN_nist_mod_521(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); +- +-const BIGNUM *BN_get0_nist_prime_192(void); +-const BIGNUM *BN_get0_nist_prime_224(void); +-const BIGNUM *BN_get0_nist_prime_256(void); +-const BIGNUM *BN_get0_nist_prime_384(void); +-const BIGNUM *BN_get0_nist_prime_521(void); +- +-int (*BN_nist_mod_func(const BIGNUM *p)) (BIGNUM *r, const BIGNUM *a, +- const BIGNUM *field, BN_CTX *ctx); +- +-int BN_generate_dsa_nonce(BIGNUM *out, const BIGNUM *range, +- const BIGNUM *priv, const unsigned char *message, +- size_t message_len, BN_CTX *ctx); +- +-/* Primes from RFC 2409 */ +-BIGNUM *BN_get_rfc2409_prime_768(BIGNUM *bn); +-BIGNUM *BN_get_rfc2409_prime_1024(BIGNUM *bn); +- +-/* Primes from RFC 3526 */ +-BIGNUM *BN_get_rfc3526_prime_1536(BIGNUM *bn); +-BIGNUM *BN_get_rfc3526_prime_2048(BIGNUM *bn); +-BIGNUM *BN_get_rfc3526_prime_3072(BIGNUM *bn); +-BIGNUM *BN_get_rfc3526_prime_4096(BIGNUM *bn); +-BIGNUM *BN_get_rfc3526_prime_6144(BIGNUM *bn); +-BIGNUM *BN_get_rfc3526_prime_8192(BIGNUM *bn); +- +-# if OPENSSL_API_COMPAT < 0x10100000L +-# define get_rfc2409_prime_768 BN_get_rfc2409_prime_768 +-# define get_rfc2409_prime_1024 BN_get_rfc2409_prime_1024 +-# define get_rfc3526_prime_1536 BN_get_rfc3526_prime_1536 +-# define get_rfc3526_prime_2048 BN_get_rfc3526_prime_2048 +-# define get_rfc3526_prime_3072 BN_get_rfc3526_prime_3072 +-# define get_rfc3526_prime_4096 BN_get_rfc3526_prime_4096 +-# define get_rfc3526_prime_6144 BN_get_rfc3526_prime_6144 +-# define get_rfc3526_prime_8192 BN_get_rfc3526_prime_8192 +-# endif +- +-int BN_bntest_rand(BIGNUM *rnd, int bits, int top, int bottom); +- +- +-# ifdef __cplusplus +-} +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/bnerr.h b/uadk_tool/include/openssl/bnerr.h +deleted file mode 100644 +index 9f3c7cf..0000000 +--- a/uadk_tool/include/openssl/bnerr.h ++++ /dev/null +@@ -1,100 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_BNERR_H +-# define HEADER_BNERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_BN_strings(void); +- +-/* +- * BN function codes. +- */ +-# define BN_F_BNRAND 127 +-# define BN_F_BNRAND_RANGE 138 +-# define BN_F_BN_BLINDING_CONVERT_EX 100 +-# define BN_F_BN_BLINDING_CREATE_PARAM 128 +-# define BN_F_BN_BLINDING_INVERT_EX 101 +-# define BN_F_BN_BLINDING_NEW 102 +-# define BN_F_BN_BLINDING_UPDATE 103 +-# define BN_F_BN_BN2DEC 104 +-# define BN_F_BN_BN2HEX 105 +-# define BN_F_BN_COMPUTE_WNAF 142 +-# define BN_F_BN_CTX_GET 116 +-# define BN_F_BN_CTX_NEW 106 +-# define BN_F_BN_CTX_START 129 +-# define BN_F_BN_DIV 107 +-# define BN_F_BN_DIV_RECP 130 +-# define BN_F_BN_EXP 123 +-# define BN_F_BN_EXPAND_INTERNAL 120 +-# define BN_F_BN_GENCB_NEW 143 +-# define BN_F_BN_GENERATE_DSA_NONCE 140 +-# define BN_F_BN_GENERATE_PRIME_EX 141 +-# define BN_F_BN_GF2M_MOD 131 +-# define BN_F_BN_GF2M_MOD_EXP 132 +-# define BN_F_BN_GF2M_MOD_MUL 133 +-# define BN_F_BN_GF2M_MOD_SOLVE_QUAD 134 +-# define BN_F_BN_GF2M_MOD_SOLVE_QUAD_ARR 135 +-# define BN_F_BN_GF2M_MOD_SQR 136 +-# define BN_F_BN_GF2M_MOD_SQRT 137 +-# define BN_F_BN_LSHIFT 145 +-# define BN_F_BN_MOD_EXP2_MONT 118 +-# define BN_F_BN_MOD_EXP_MONT 109 +-# define BN_F_BN_MOD_EXP_MONT_CONSTTIME 124 +-# define BN_F_BN_MOD_EXP_MONT_WORD 117 +-# define BN_F_BN_MOD_EXP_RECP 125 +-# define BN_F_BN_MOD_EXP_SIMPLE 126 +-# define BN_F_BN_MOD_INVERSE 110 +-# define BN_F_BN_MOD_INVERSE_NO_BRANCH 139 +-# define BN_F_BN_MOD_LSHIFT_QUICK 119 +-# define BN_F_BN_MOD_SQRT 121 +-# define BN_F_BN_MONT_CTX_NEW 149 +-# define BN_F_BN_MPI2BN 112 +-# define BN_F_BN_NEW 113 +-# define BN_F_BN_POOL_GET 147 +-# define BN_F_BN_RAND 114 +-# define BN_F_BN_RAND_RANGE 122 +-# define BN_F_BN_RECP_CTX_NEW 150 +-# define BN_F_BN_RSHIFT 146 +-# define BN_F_BN_SET_WORDS 144 +-# define BN_F_BN_STACK_PUSH 148 +-# define BN_F_BN_USUB 115 +- +-/* +- * BN reason codes. +- */ +-# define BN_R_ARG2_LT_ARG3 100 +-# define BN_R_BAD_RECIPROCAL 101 +-# define BN_R_BIGNUM_TOO_LONG 114 +-# define BN_R_BITS_TOO_SMALL 118 +-# define BN_R_CALLED_WITH_EVEN_MODULUS 102 +-# define BN_R_DIV_BY_ZERO 103 +-# define BN_R_ENCODING_ERROR 104 +-# define BN_R_EXPAND_ON_STATIC_BIGNUM_DATA 105 +-# define BN_R_INPUT_NOT_REDUCED 110 +-# define BN_R_INVALID_LENGTH 106 +-# define BN_R_INVALID_RANGE 115 +-# define BN_R_INVALID_SHIFT 119 +-# define BN_R_NOT_A_SQUARE 111 +-# define BN_R_NOT_INITIALIZED 107 +-# define BN_R_NO_INVERSE 108 +-# define BN_R_NO_SOLUTION 116 +-# define BN_R_PRIVATE_KEY_TOO_LARGE 117 +-# define BN_R_P_IS_NOT_PRIME 112 +-# define BN_R_TOO_MANY_ITERATIONS 113 +-# define BN_R_TOO_MANY_TEMPORARY_VARIABLES 109 +- +-#endif +diff --git a/uadk_tool/include/openssl/buffer.h b/uadk_tool/include/openssl/buffer.h +deleted file mode 100644 +index d276576..0000000 +--- a/uadk_tool/include/openssl/buffer.h ++++ /dev/null +@@ -1,58 +0,0 @@ +-/* +- * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_BUFFER_H +-# define HEADER_BUFFER_H +- +-# include +-# ifndef HEADER_CRYPTO_H +-# include +-# endif +-# include +- +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-# include +-# include +- +-/* +- * These names are outdated as of OpenSSL 1.1; a future release +- * will move them to be deprecated. +- */ +-# define BUF_strdup(s) OPENSSL_strdup(s) +-# define BUF_strndup(s, size) OPENSSL_strndup(s, size) +-# define BUF_memdup(data, size) OPENSSL_memdup(data, size) +-# define BUF_strlcpy(dst, src, size) OPENSSL_strlcpy(dst, src, size) +-# define BUF_strlcat(dst, src, size) OPENSSL_strlcat(dst, src, size) +-# define BUF_strnlen(str, maxlen) OPENSSL_strnlen(str, maxlen) +- +-struct buf_mem_st { +- size_t length; /* current number of bytes */ +- char *data; +- size_t max; /* size of buffer */ +- unsigned long flags; +-}; +- +-# define BUF_MEM_FLAG_SECURE 0x01 +- +-BUF_MEM *BUF_MEM_new(void); +-BUF_MEM *BUF_MEM_new_ex(unsigned long flags); +-void BUF_MEM_free(BUF_MEM *a); +-size_t BUF_MEM_grow(BUF_MEM *str, size_t len); +-size_t BUF_MEM_grow_clean(BUF_MEM *str, size_t len); +-void BUF_reverse(unsigned char *out, const unsigned char *in, size_t siz); +- +- +-# ifdef __cplusplus +-} +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/buffererr.h b/uadk_tool/include/openssl/buffererr.h +deleted file mode 100644 +index 04f6ff7..0000000 +--- a/uadk_tool/include/openssl/buffererr.h ++++ /dev/null +@@ -1,34 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_BUFERR_H +-# define HEADER_BUFERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_BUF_strings(void); +- +-/* +- * BUF function codes. +- */ +-# define BUF_F_BUF_MEM_GROW 100 +-# define BUF_F_BUF_MEM_GROW_CLEAN 105 +-# define BUF_F_BUF_MEM_NEW 101 +- +-/* +- * BUF reason codes. +- */ +- +-#endif +diff --git a/uadk_tool/include/openssl/camellia.h b/uadk_tool/include/openssl/camellia.h +deleted file mode 100644 +index 151f3c1..0000000 +--- a/uadk_tool/include/openssl/camellia.h ++++ /dev/null +@@ -1,83 +0,0 @@ +-/* +- * Copyright 2006-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_CAMELLIA_H +-# define HEADER_CAMELLIA_H +- +-# include +- +-# ifndef OPENSSL_NO_CAMELLIA +-# include +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-# define CAMELLIA_ENCRYPT 1 +-# define CAMELLIA_DECRYPT 0 +- +-/* +- * Because array size can't be a const in C, the following two are macros. +- * Both sizes are in bytes. +- */ +- +-/* This should be a hidden type, but EVP requires that the size be known */ +- +-# define CAMELLIA_BLOCK_SIZE 16 +-# define CAMELLIA_TABLE_BYTE_LEN 272 +-# define CAMELLIA_TABLE_WORD_LEN (CAMELLIA_TABLE_BYTE_LEN / 4) +- +-typedef unsigned int KEY_TABLE_TYPE[CAMELLIA_TABLE_WORD_LEN]; /* to match +- * with WORD */ +- +-struct camellia_key_st { +- union { +- double d; /* ensures 64-bit align */ +- KEY_TABLE_TYPE rd_key; +- } u; +- int grand_rounds; +-}; +-typedef struct camellia_key_st CAMELLIA_KEY; +- +-int Camellia_set_key(const unsigned char *userKey, const int bits, +- CAMELLIA_KEY *key); +- +-void Camellia_encrypt(const unsigned char *in, unsigned char *out, +- const CAMELLIA_KEY *key); +-void Camellia_decrypt(const unsigned char *in, unsigned char *out, +- const CAMELLIA_KEY *key); +- +-void Camellia_ecb_encrypt(const unsigned char *in, unsigned char *out, +- const CAMELLIA_KEY *key, const int enc); +-void Camellia_cbc_encrypt(const unsigned char *in, unsigned char *out, +- size_t length, const CAMELLIA_KEY *key, +- unsigned char *ivec, const int enc); +-void Camellia_cfb128_encrypt(const unsigned char *in, unsigned char *out, +- size_t length, const CAMELLIA_KEY *key, +- unsigned char *ivec, int *num, const int enc); +-void Camellia_cfb1_encrypt(const unsigned char *in, unsigned char *out, +- size_t length, const CAMELLIA_KEY *key, +- unsigned char *ivec, int *num, const int enc); +-void Camellia_cfb8_encrypt(const unsigned char *in, unsigned char *out, +- size_t length, const CAMELLIA_KEY *key, +- unsigned char *ivec, int *num, const int enc); +-void Camellia_ofb128_encrypt(const unsigned char *in, unsigned char *out, +- size_t length, const CAMELLIA_KEY *key, +- unsigned char *ivec, int *num); +-void Camellia_ctr128_encrypt(const unsigned char *in, unsigned char *out, +- size_t length, const CAMELLIA_KEY *key, +- unsigned char ivec[CAMELLIA_BLOCK_SIZE], +- unsigned char ecount_buf[CAMELLIA_BLOCK_SIZE], +- unsigned int *num); +- +-# ifdef __cplusplus +-} +-# endif +-# endif +- +-#endif +diff --git a/uadk_tool/include/openssl/cast.h b/uadk_tool/include/openssl/cast.h +deleted file mode 100644 +index 2cc89ae..0000000 +--- a/uadk_tool/include/openssl/cast.h ++++ /dev/null +@@ -1,53 +0,0 @@ +-/* +- * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_CAST_H +-# define HEADER_CAST_H +- +-# include +- +-# ifndef OPENSSL_NO_CAST +-# ifdef __cplusplus +-extern "C" { +-# endif +- +-# define CAST_ENCRYPT 1 +-# define CAST_DECRYPT 0 +- +-# define CAST_LONG unsigned int +- +-# define CAST_BLOCK 8 +-# define CAST_KEY_LENGTH 16 +- +-typedef struct cast_key_st { +- CAST_LONG data[32]; +- int short_key; /* Use reduced rounds for short key */ +-} CAST_KEY; +- +-void CAST_set_key(CAST_KEY *key, int len, const unsigned char *data); +-void CAST_ecb_encrypt(const unsigned char *in, unsigned char *out, +- const CAST_KEY *key, int enc); +-void CAST_encrypt(CAST_LONG *data, const CAST_KEY *key); +-void CAST_decrypt(CAST_LONG *data, const CAST_KEY *key); +-void CAST_cbc_encrypt(const unsigned char *in, unsigned char *out, +- long length, const CAST_KEY *ks, unsigned char *iv, +- int enc); +-void CAST_cfb64_encrypt(const unsigned char *in, unsigned char *out, +- long length, const CAST_KEY *schedule, +- unsigned char *ivec, int *num, int enc); +-void CAST_ofb64_encrypt(const unsigned char *in, unsigned char *out, +- long length, const CAST_KEY *schedule, +- unsigned char *ivec, int *num); +- +-# ifdef __cplusplus +-} +-# endif +-# endif +- +-#endif +diff --git a/uadk_tool/include/openssl/cmac.h b/uadk_tool/include/openssl/cmac.h +deleted file mode 100644 +index 3535a9a..0000000 +--- a/uadk_tool/include/openssl/cmac.h ++++ /dev/null +@@ -1,41 +0,0 @@ +-/* +- * Copyright 2010-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_CMAC_H +-# define HEADER_CMAC_H +- +-# ifndef OPENSSL_NO_CMAC +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-# include +- +-/* Opaque */ +-typedef struct CMAC_CTX_st CMAC_CTX; +- +-CMAC_CTX *CMAC_CTX_new(void); +-void CMAC_CTX_cleanup(CMAC_CTX *ctx); +-void CMAC_CTX_free(CMAC_CTX *ctx); +-EVP_CIPHER_CTX *CMAC_CTX_get0_cipher_ctx(CMAC_CTX *ctx); +-int CMAC_CTX_copy(CMAC_CTX *out, const CMAC_CTX *in); +- +-int CMAC_Init(CMAC_CTX *ctx, const void *key, size_t keylen, +- const EVP_CIPHER *cipher, ENGINE *impl); +-int CMAC_Update(CMAC_CTX *ctx, const void *data, size_t dlen); +-int CMAC_Final(CMAC_CTX *ctx, unsigned char *out, size_t *poutlen); +-int CMAC_resume(CMAC_CTX *ctx); +- +-#ifdef __cplusplus +-} +-#endif +- +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/cms.h b/uadk_tool/include/openssl/cms.h +deleted file mode 100644 +index c762796..0000000 +--- a/uadk_tool/include/openssl/cms.h ++++ /dev/null +@@ -1,339 +0,0 @@ +-/* +- * Copyright 2008-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_CMS_H +-# define HEADER_CMS_H +- +-# include +- +-# ifndef OPENSSL_NO_CMS +-# include +-# include +-# include +-# ifdef __cplusplus +-extern "C" { +-# endif +- +-typedef struct CMS_ContentInfo_st CMS_ContentInfo; +-typedef struct CMS_SignerInfo_st CMS_SignerInfo; +-typedef struct CMS_CertificateChoices CMS_CertificateChoices; +-typedef struct CMS_RevocationInfoChoice_st CMS_RevocationInfoChoice; +-typedef struct CMS_RecipientInfo_st CMS_RecipientInfo; +-typedef struct CMS_ReceiptRequest_st CMS_ReceiptRequest; +-typedef struct CMS_Receipt_st CMS_Receipt; +-typedef struct CMS_RecipientEncryptedKey_st CMS_RecipientEncryptedKey; +-typedef struct CMS_OtherKeyAttribute_st CMS_OtherKeyAttribute; +- +-DEFINE_STACK_OF(CMS_SignerInfo) +-DEFINE_STACK_OF(CMS_RecipientEncryptedKey) +-DEFINE_STACK_OF(CMS_RecipientInfo) +-DEFINE_STACK_OF(CMS_RevocationInfoChoice) +-DECLARE_ASN1_FUNCTIONS(CMS_ContentInfo) +-DECLARE_ASN1_FUNCTIONS(CMS_ReceiptRequest) +-DECLARE_ASN1_PRINT_FUNCTION(CMS_ContentInfo) +- +-# define CMS_SIGNERINFO_ISSUER_SERIAL 0 +-# define CMS_SIGNERINFO_KEYIDENTIFIER 1 +- +-# define CMS_RECIPINFO_NONE -1 +-# define CMS_RECIPINFO_TRANS 0 +-# define CMS_RECIPINFO_AGREE 1 +-# define CMS_RECIPINFO_KEK 2 +-# define CMS_RECIPINFO_PASS 3 +-# define CMS_RECIPINFO_OTHER 4 +- +-/* S/MIME related flags */ +- +-# define CMS_TEXT 0x1 +-# define CMS_NOCERTS 0x2 +-# define CMS_NO_CONTENT_VERIFY 0x4 +-# define CMS_NO_ATTR_VERIFY 0x8 +-# define CMS_NOSIGS \ +- (CMS_NO_CONTENT_VERIFY|CMS_NO_ATTR_VERIFY) +-# define CMS_NOINTERN 0x10 +-# define CMS_NO_SIGNER_CERT_VERIFY 0x20 +-# define CMS_NOVERIFY 0x20 +-# define CMS_DETACHED 0x40 +-# define CMS_BINARY 0x80 +-# define CMS_NOATTR 0x100 +-# define CMS_NOSMIMECAP 0x200 +-# define CMS_NOOLDMIMETYPE 0x400 +-# define CMS_CRLFEOL 0x800 +-# define CMS_STREAM 0x1000 +-# define CMS_NOCRL 0x2000 +-# define CMS_PARTIAL 0x4000 +-# define CMS_REUSE_DIGEST 0x8000 +-# define CMS_USE_KEYID 0x10000 +-# define CMS_DEBUG_DECRYPT 0x20000 +-# define CMS_KEY_PARAM 0x40000 +-# define CMS_ASCIICRLF 0x80000 +- +-const ASN1_OBJECT *CMS_get0_type(const CMS_ContentInfo *cms); +- +-BIO *CMS_dataInit(CMS_ContentInfo *cms, BIO *icont); +-int CMS_dataFinal(CMS_ContentInfo *cms, BIO *bio); +- +-ASN1_OCTET_STRING **CMS_get0_content(CMS_ContentInfo *cms); +-int CMS_is_detached(CMS_ContentInfo *cms); +-int CMS_set_detached(CMS_ContentInfo *cms, int detached); +- +-# ifdef HEADER_PEM_H +-DECLARE_PEM_rw_const(CMS, CMS_ContentInfo) +-# endif +-int CMS_stream(unsigned char ***boundary, CMS_ContentInfo *cms); +-CMS_ContentInfo *d2i_CMS_bio(BIO *bp, CMS_ContentInfo **cms); +-int i2d_CMS_bio(BIO *bp, CMS_ContentInfo *cms); +- +-BIO *BIO_new_CMS(BIO *out, CMS_ContentInfo *cms); +-int i2d_CMS_bio_stream(BIO *out, CMS_ContentInfo *cms, BIO *in, int flags); +-int PEM_write_bio_CMS_stream(BIO *out, CMS_ContentInfo *cms, BIO *in, +- int flags); +-CMS_ContentInfo *SMIME_read_CMS(BIO *bio, BIO **bcont); +-int SMIME_write_CMS(BIO *bio, CMS_ContentInfo *cms, BIO *data, int flags); +- +-int CMS_final(CMS_ContentInfo *cms, BIO *data, BIO *dcont, +- unsigned int flags); +- +-CMS_ContentInfo *CMS_sign(X509 *signcert, EVP_PKEY *pkey, +- STACK_OF(X509) *certs, BIO *data, +- unsigned int flags); +- +-CMS_ContentInfo *CMS_sign_receipt(CMS_SignerInfo *si, +- X509 *signcert, EVP_PKEY *pkey, +- STACK_OF(X509) *certs, unsigned int flags); +- +-int CMS_data(CMS_ContentInfo *cms, BIO *out, unsigned int flags); +-CMS_ContentInfo *CMS_data_create(BIO *in, unsigned int flags); +- +-int CMS_digest_verify(CMS_ContentInfo *cms, BIO *dcont, BIO *out, +- unsigned int flags); +-CMS_ContentInfo *CMS_digest_create(BIO *in, const EVP_MD *md, +- unsigned int flags); +- +-int CMS_EncryptedData_decrypt(CMS_ContentInfo *cms, +- const unsigned char *key, size_t keylen, +- BIO *dcont, BIO *out, unsigned int flags); +- +-CMS_ContentInfo *CMS_EncryptedData_encrypt(BIO *in, const EVP_CIPHER *cipher, +- const unsigned char *key, +- size_t keylen, unsigned int flags); +- +-int CMS_EncryptedData_set1_key(CMS_ContentInfo *cms, const EVP_CIPHER *ciph, +- const unsigned char *key, size_t keylen); +- +-int CMS_verify(CMS_ContentInfo *cms, STACK_OF(X509) *certs, +- X509_STORE *store, BIO *dcont, BIO *out, unsigned int flags); +- +-int CMS_verify_receipt(CMS_ContentInfo *rcms, CMS_ContentInfo *ocms, +- STACK_OF(X509) *certs, +- X509_STORE *store, unsigned int flags); +- +-STACK_OF(X509) *CMS_get0_signers(CMS_ContentInfo *cms); +- +-CMS_ContentInfo *CMS_encrypt(STACK_OF(X509) *certs, BIO *in, +- const EVP_CIPHER *cipher, unsigned int flags); +- +-int CMS_decrypt(CMS_ContentInfo *cms, EVP_PKEY *pkey, X509 *cert, +- BIO *dcont, BIO *out, unsigned int flags); +- +-int CMS_decrypt_set1_pkey(CMS_ContentInfo *cms, EVP_PKEY *pk, X509 *cert); +-int CMS_decrypt_set1_key(CMS_ContentInfo *cms, +- unsigned char *key, size_t keylen, +- const unsigned char *id, size_t idlen); +-int CMS_decrypt_set1_password(CMS_ContentInfo *cms, +- unsigned char *pass, ossl_ssize_t passlen); +- +-STACK_OF(CMS_RecipientInfo) *CMS_get0_RecipientInfos(CMS_ContentInfo *cms); +-int CMS_RecipientInfo_type(CMS_RecipientInfo *ri); +-EVP_PKEY_CTX *CMS_RecipientInfo_get0_pkey_ctx(CMS_RecipientInfo *ri); +-CMS_ContentInfo *CMS_EnvelopedData_create(const EVP_CIPHER *cipher); +-CMS_RecipientInfo *CMS_add1_recipient_cert(CMS_ContentInfo *cms, +- X509 *recip, unsigned int flags); +-int CMS_RecipientInfo_set0_pkey(CMS_RecipientInfo *ri, EVP_PKEY *pkey); +-int CMS_RecipientInfo_ktri_cert_cmp(CMS_RecipientInfo *ri, X509 *cert); +-int CMS_RecipientInfo_ktri_get0_algs(CMS_RecipientInfo *ri, +- EVP_PKEY **pk, X509 **recip, +- X509_ALGOR **palg); +-int CMS_RecipientInfo_ktri_get0_signer_id(CMS_RecipientInfo *ri, +- ASN1_OCTET_STRING **keyid, +- X509_NAME **issuer, +- ASN1_INTEGER **sno); +- +-CMS_RecipientInfo *CMS_add0_recipient_key(CMS_ContentInfo *cms, int nid, +- unsigned char *key, size_t keylen, +- unsigned char *id, size_t idlen, +- ASN1_GENERALIZEDTIME *date, +- ASN1_OBJECT *otherTypeId, +- ASN1_TYPE *otherType); +- +-int CMS_RecipientInfo_kekri_get0_id(CMS_RecipientInfo *ri, +- X509_ALGOR **palg, +- ASN1_OCTET_STRING **pid, +- ASN1_GENERALIZEDTIME **pdate, +- ASN1_OBJECT **potherid, +- ASN1_TYPE **pothertype); +- +-int CMS_RecipientInfo_set0_key(CMS_RecipientInfo *ri, +- unsigned char *key, size_t keylen); +- +-int CMS_RecipientInfo_kekri_id_cmp(CMS_RecipientInfo *ri, +- const unsigned char *id, size_t idlen); +- +-int CMS_RecipientInfo_set0_password(CMS_RecipientInfo *ri, +- unsigned char *pass, +- ossl_ssize_t passlen); +- +-CMS_RecipientInfo *CMS_add0_recipient_password(CMS_ContentInfo *cms, +- int iter, int wrap_nid, +- int pbe_nid, +- unsigned char *pass, +- ossl_ssize_t passlen, +- const EVP_CIPHER *kekciph); +- +-int CMS_RecipientInfo_decrypt(CMS_ContentInfo *cms, CMS_RecipientInfo *ri); +-int CMS_RecipientInfo_encrypt(CMS_ContentInfo *cms, CMS_RecipientInfo *ri); +- +-int CMS_uncompress(CMS_ContentInfo *cms, BIO *dcont, BIO *out, +- unsigned int flags); +-CMS_ContentInfo *CMS_compress(BIO *in, int comp_nid, unsigned int flags); +- +-int CMS_set1_eContentType(CMS_ContentInfo *cms, const ASN1_OBJECT *oid); +-const ASN1_OBJECT *CMS_get0_eContentType(CMS_ContentInfo *cms); +- +-CMS_CertificateChoices *CMS_add0_CertificateChoices(CMS_ContentInfo *cms); +-int CMS_add0_cert(CMS_ContentInfo *cms, X509 *cert); +-int CMS_add1_cert(CMS_ContentInfo *cms, X509 *cert); +-STACK_OF(X509) *CMS_get1_certs(CMS_ContentInfo *cms); +- +-CMS_RevocationInfoChoice *CMS_add0_RevocationInfoChoice(CMS_ContentInfo *cms); +-int CMS_add0_crl(CMS_ContentInfo *cms, X509_CRL *crl); +-int CMS_add1_crl(CMS_ContentInfo *cms, X509_CRL *crl); +-STACK_OF(X509_CRL) *CMS_get1_crls(CMS_ContentInfo *cms); +- +-int CMS_SignedData_init(CMS_ContentInfo *cms); +-CMS_SignerInfo *CMS_add1_signer(CMS_ContentInfo *cms, +- X509 *signer, EVP_PKEY *pk, const EVP_MD *md, +- unsigned int flags); +-EVP_PKEY_CTX *CMS_SignerInfo_get0_pkey_ctx(CMS_SignerInfo *si); +-EVP_MD_CTX *CMS_SignerInfo_get0_md_ctx(CMS_SignerInfo *si); +-STACK_OF(CMS_SignerInfo) *CMS_get0_SignerInfos(CMS_ContentInfo *cms); +- +-void CMS_SignerInfo_set1_signer_cert(CMS_SignerInfo *si, X509 *signer); +-int CMS_SignerInfo_get0_signer_id(CMS_SignerInfo *si, +- ASN1_OCTET_STRING **keyid, +- X509_NAME **issuer, ASN1_INTEGER **sno); +-int CMS_SignerInfo_cert_cmp(CMS_SignerInfo *si, X509 *cert); +-int CMS_set1_signers_certs(CMS_ContentInfo *cms, STACK_OF(X509) *certs, +- unsigned int flags); +-void CMS_SignerInfo_get0_algs(CMS_SignerInfo *si, EVP_PKEY **pk, +- X509 **signer, X509_ALGOR **pdig, +- X509_ALGOR **psig); +-ASN1_OCTET_STRING *CMS_SignerInfo_get0_signature(CMS_SignerInfo *si); +-int CMS_SignerInfo_sign(CMS_SignerInfo *si); +-int CMS_SignerInfo_verify(CMS_SignerInfo *si); +-int CMS_SignerInfo_verify_content(CMS_SignerInfo *si, BIO *chain); +- +-int CMS_add_smimecap(CMS_SignerInfo *si, STACK_OF(X509_ALGOR) *algs); +-int CMS_add_simple_smimecap(STACK_OF(X509_ALGOR) **algs, +- int algnid, int keysize); +-int CMS_add_standard_smimecap(STACK_OF(X509_ALGOR) **smcap); +- +-int CMS_signed_get_attr_count(const CMS_SignerInfo *si); +-int CMS_signed_get_attr_by_NID(const CMS_SignerInfo *si, int nid, +- int lastpos); +-int CMS_signed_get_attr_by_OBJ(const CMS_SignerInfo *si, const ASN1_OBJECT *obj, +- int lastpos); +-X509_ATTRIBUTE *CMS_signed_get_attr(const CMS_SignerInfo *si, int loc); +-X509_ATTRIBUTE *CMS_signed_delete_attr(CMS_SignerInfo *si, int loc); +-int CMS_signed_add1_attr(CMS_SignerInfo *si, X509_ATTRIBUTE *attr); +-int CMS_signed_add1_attr_by_OBJ(CMS_SignerInfo *si, +- const ASN1_OBJECT *obj, int type, +- const void *bytes, int len); +-int CMS_signed_add1_attr_by_NID(CMS_SignerInfo *si, +- int nid, int type, +- const void *bytes, int len); +-int CMS_signed_add1_attr_by_txt(CMS_SignerInfo *si, +- const char *attrname, int type, +- const void *bytes, int len); +-void *CMS_signed_get0_data_by_OBJ(CMS_SignerInfo *si, const ASN1_OBJECT *oid, +- int lastpos, int type); +- +-int CMS_unsigned_get_attr_count(const CMS_SignerInfo *si); +-int CMS_unsigned_get_attr_by_NID(const CMS_SignerInfo *si, int nid, +- int lastpos); +-int CMS_unsigned_get_attr_by_OBJ(const CMS_SignerInfo *si, +- const ASN1_OBJECT *obj, int lastpos); +-X509_ATTRIBUTE *CMS_unsigned_get_attr(const CMS_SignerInfo *si, int loc); +-X509_ATTRIBUTE *CMS_unsigned_delete_attr(CMS_SignerInfo *si, int loc); +-int CMS_unsigned_add1_attr(CMS_SignerInfo *si, X509_ATTRIBUTE *attr); +-int CMS_unsigned_add1_attr_by_OBJ(CMS_SignerInfo *si, +- const ASN1_OBJECT *obj, int type, +- const void *bytes, int len); +-int CMS_unsigned_add1_attr_by_NID(CMS_SignerInfo *si, +- int nid, int type, +- const void *bytes, int len); +-int CMS_unsigned_add1_attr_by_txt(CMS_SignerInfo *si, +- const char *attrname, int type, +- const void *bytes, int len); +-void *CMS_unsigned_get0_data_by_OBJ(CMS_SignerInfo *si, ASN1_OBJECT *oid, +- int lastpos, int type); +- +-int CMS_get1_ReceiptRequest(CMS_SignerInfo *si, CMS_ReceiptRequest **prr); +-CMS_ReceiptRequest *CMS_ReceiptRequest_create0(unsigned char *id, int idlen, +- int allorfirst, +- STACK_OF(GENERAL_NAMES) +- *receiptList, STACK_OF(GENERAL_NAMES) +- *receiptsTo); +-int CMS_add1_ReceiptRequest(CMS_SignerInfo *si, CMS_ReceiptRequest *rr); +-void CMS_ReceiptRequest_get0_values(CMS_ReceiptRequest *rr, +- ASN1_STRING **pcid, +- int *pallorfirst, +- STACK_OF(GENERAL_NAMES) **plist, +- STACK_OF(GENERAL_NAMES) **prto); +-int CMS_RecipientInfo_kari_get0_alg(CMS_RecipientInfo *ri, +- X509_ALGOR **palg, +- ASN1_OCTET_STRING **pukm); +-STACK_OF(CMS_RecipientEncryptedKey) +-*CMS_RecipientInfo_kari_get0_reks(CMS_RecipientInfo *ri); +- +-int CMS_RecipientInfo_kari_get0_orig_id(CMS_RecipientInfo *ri, +- X509_ALGOR **pubalg, +- ASN1_BIT_STRING **pubkey, +- ASN1_OCTET_STRING **keyid, +- X509_NAME **issuer, +- ASN1_INTEGER **sno); +- +-int CMS_RecipientInfo_kari_orig_id_cmp(CMS_RecipientInfo *ri, X509 *cert); +- +-int CMS_RecipientEncryptedKey_get0_id(CMS_RecipientEncryptedKey *rek, +- ASN1_OCTET_STRING **keyid, +- ASN1_GENERALIZEDTIME **tm, +- CMS_OtherKeyAttribute **other, +- X509_NAME **issuer, ASN1_INTEGER **sno); +-int CMS_RecipientEncryptedKey_cert_cmp(CMS_RecipientEncryptedKey *rek, +- X509 *cert); +-int CMS_RecipientInfo_kari_set0_pkey(CMS_RecipientInfo *ri, EVP_PKEY *pk); +-EVP_CIPHER_CTX *CMS_RecipientInfo_kari_get0_ctx(CMS_RecipientInfo *ri); +-int CMS_RecipientInfo_kari_decrypt(CMS_ContentInfo *cms, +- CMS_RecipientInfo *ri, +- CMS_RecipientEncryptedKey *rek); +- +-int CMS_SharedInfo_encode(unsigned char **pder, X509_ALGOR *kekalg, +- ASN1_OCTET_STRING *ukm, int keylen); +- +-/* Backward compatibility for spelling errors. */ +-# define CMS_R_UNKNOWN_DIGEST_ALGORITM CMS_R_UNKNOWN_DIGEST_ALGORITHM +-# define CMS_R_UNSUPPORTED_RECPIENTINFO_TYPE \ +- CMS_R_UNSUPPORTED_RECIPIENTINFO_TYPE +- +-# ifdef __cplusplus +-} +-# endif +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/cmserr.h b/uadk_tool/include/openssl/cmserr.h +deleted file mode 100644 +index 7dbc13d..0000000 +--- a/uadk_tool/include/openssl/cmserr.h ++++ /dev/null +@@ -1,202 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_CMSERR_H +-# define HEADER_CMSERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# include +- +-# ifndef OPENSSL_NO_CMS +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_CMS_strings(void); +- +-/* +- * CMS function codes. +- */ +-# define CMS_F_CHECK_CONTENT 99 +-# define CMS_F_CMS_ADD0_CERT 164 +-# define CMS_F_CMS_ADD0_RECIPIENT_KEY 100 +-# define CMS_F_CMS_ADD0_RECIPIENT_PASSWORD 165 +-# define CMS_F_CMS_ADD1_RECEIPTREQUEST 158 +-# define CMS_F_CMS_ADD1_RECIPIENT_CERT 101 +-# define CMS_F_CMS_ADD1_SIGNER 102 +-# define CMS_F_CMS_ADD1_SIGNINGTIME 103 +-# define CMS_F_CMS_COMPRESS 104 +-# define CMS_F_CMS_COMPRESSEDDATA_CREATE 105 +-# define CMS_F_CMS_COMPRESSEDDATA_INIT_BIO 106 +-# define CMS_F_CMS_COPY_CONTENT 107 +-# define CMS_F_CMS_COPY_MESSAGEDIGEST 108 +-# define CMS_F_CMS_DATA 109 +-# define CMS_F_CMS_DATAFINAL 110 +-# define CMS_F_CMS_DATAINIT 111 +-# define CMS_F_CMS_DECRYPT 112 +-# define CMS_F_CMS_DECRYPT_SET1_KEY 113 +-# define CMS_F_CMS_DECRYPT_SET1_PASSWORD 166 +-# define CMS_F_CMS_DECRYPT_SET1_PKEY 114 +-# define CMS_F_CMS_DIGESTALGORITHM_FIND_CTX 115 +-# define CMS_F_CMS_DIGESTALGORITHM_INIT_BIO 116 +-# define CMS_F_CMS_DIGESTEDDATA_DO_FINAL 117 +-# define CMS_F_CMS_DIGEST_VERIFY 118 +-# define CMS_F_CMS_ENCODE_RECEIPT 161 +-# define CMS_F_CMS_ENCRYPT 119 +-# define CMS_F_CMS_ENCRYPTEDCONTENT_INIT 179 +-# define CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO 120 +-# define CMS_F_CMS_ENCRYPTEDDATA_DECRYPT 121 +-# define CMS_F_CMS_ENCRYPTEDDATA_ENCRYPT 122 +-# define CMS_F_CMS_ENCRYPTEDDATA_SET1_KEY 123 +-# define CMS_F_CMS_ENVELOPEDDATA_CREATE 124 +-# define CMS_F_CMS_ENVELOPEDDATA_INIT_BIO 125 +-# define CMS_F_CMS_ENVELOPED_DATA_INIT 126 +-# define CMS_F_CMS_ENV_ASN1_CTRL 171 +-# define CMS_F_CMS_FINAL 127 +-# define CMS_F_CMS_GET0_CERTIFICATE_CHOICES 128 +-# define CMS_F_CMS_GET0_CONTENT 129 +-# define CMS_F_CMS_GET0_ECONTENT_TYPE 130 +-# define CMS_F_CMS_GET0_ENVELOPED 131 +-# define CMS_F_CMS_GET0_REVOCATION_CHOICES 132 +-# define CMS_F_CMS_GET0_SIGNED 133 +-# define CMS_F_CMS_MSGSIGDIGEST_ADD1 162 +-# define CMS_F_CMS_RECEIPTREQUEST_CREATE0 159 +-# define CMS_F_CMS_RECEIPT_VERIFY 160 +-# define CMS_F_CMS_RECIPIENTINFO_DECRYPT 134 +-# define CMS_F_CMS_RECIPIENTINFO_ENCRYPT 169 +-# define CMS_F_CMS_RECIPIENTINFO_KARI_ENCRYPT 178 +-# define CMS_F_CMS_RECIPIENTINFO_KARI_GET0_ALG 175 +-# define CMS_F_CMS_RECIPIENTINFO_KARI_GET0_ORIG_ID 173 +-# define CMS_F_CMS_RECIPIENTINFO_KARI_GET0_REKS 172 +-# define CMS_F_CMS_RECIPIENTINFO_KARI_ORIG_ID_CMP 174 +-# define CMS_F_CMS_RECIPIENTINFO_KEKRI_DECRYPT 135 +-# define CMS_F_CMS_RECIPIENTINFO_KEKRI_ENCRYPT 136 +-# define CMS_F_CMS_RECIPIENTINFO_KEKRI_GET0_ID 137 +-# define CMS_F_CMS_RECIPIENTINFO_KEKRI_ID_CMP 138 +-# define CMS_F_CMS_RECIPIENTINFO_KTRI_CERT_CMP 139 +-# define CMS_F_CMS_RECIPIENTINFO_KTRI_DECRYPT 140 +-# define CMS_F_CMS_RECIPIENTINFO_KTRI_ENCRYPT 141 +-# define CMS_F_CMS_RECIPIENTINFO_KTRI_GET0_ALGS 142 +-# define CMS_F_CMS_RECIPIENTINFO_KTRI_GET0_SIGNER_ID 143 +-# define CMS_F_CMS_RECIPIENTINFO_PWRI_CRYPT 167 +-# define CMS_F_CMS_RECIPIENTINFO_SET0_KEY 144 +-# define CMS_F_CMS_RECIPIENTINFO_SET0_PASSWORD 168 +-# define CMS_F_CMS_RECIPIENTINFO_SET0_PKEY 145 +-# define CMS_F_CMS_SD_ASN1_CTRL 170 +-# define CMS_F_CMS_SET1_IAS 176 +-# define CMS_F_CMS_SET1_KEYID 177 +-# define CMS_F_CMS_SET1_SIGNERIDENTIFIER 146 +-# define CMS_F_CMS_SET_DETACHED 147 +-# define CMS_F_CMS_SIGN 148 +-# define CMS_F_CMS_SIGNED_DATA_INIT 149 +-# define CMS_F_CMS_SIGNERINFO_CONTENT_SIGN 150 +-# define CMS_F_CMS_SIGNERINFO_SIGN 151 +-# define CMS_F_CMS_SIGNERINFO_VERIFY 152 +-# define CMS_F_CMS_SIGNERINFO_VERIFY_CERT 153 +-# define CMS_F_CMS_SIGNERINFO_VERIFY_CONTENT 154 +-# define CMS_F_CMS_SIGN_RECEIPT 163 +-# define CMS_F_CMS_SI_CHECK_ATTRIBUTES 183 +-# define CMS_F_CMS_STREAM 155 +-# define CMS_F_CMS_UNCOMPRESS 156 +-# define CMS_F_CMS_VERIFY 157 +-# define CMS_F_KEK_UNWRAP_KEY 180 +- +-/* +- * CMS reason codes. +- */ +-# define CMS_R_ADD_SIGNER_ERROR 99 +-# define CMS_R_ATTRIBUTE_ERROR 161 +-# define CMS_R_CERTIFICATE_ALREADY_PRESENT 175 +-# define CMS_R_CERTIFICATE_HAS_NO_KEYID 160 +-# define CMS_R_CERTIFICATE_VERIFY_ERROR 100 +-# define CMS_R_CIPHER_INITIALISATION_ERROR 101 +-# define CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR 102 +-# define CMS_R_CMS_DATAFINAL_ERROR 103 +-# define CMS_R_CMS_LIB 104 +-# define CMS_R_CONTENTIDENTIFIER_MISMATCH 170 +-# define CMS_R_CONTENT_NOT_FOUND 105 +-# define CMS_R_CONTENT_TYPE_MISMATCH 171 +-# define CMS_R_CONTENT_TYPE_NOT_COMPRESSED_DATA 106 +-# define CMS_R_CONTENT_TYPE_NOT_ENVELOPED_DATA 107 +-# define CMS_R_CONTENT_TYPE_NOT_SIGNED_DATA 108 +-# define CMS_R_CONTENT_VERIFY_ERROR 109 +-# define CMS_R_CTRL_ERROR 110 +-# define CMS_R_CTRL_FAILURE 111 +-# define CMS_R_DECRYPT_ERROR 112 +-# define CMS_R_ERROR_GETTING_PUBLIC_KEY 113 +-# define CMS_R_ERROR_READING_MESSAGEDIGEST_ATTRIBUTE 114 +-# define CMS_R_ERROR_SETTING_KEY 115 +-# define CMS_R_ERROR_SETTING_RECIPIENTINFO 116 +-# define CMS_R_INVALID_ENCRYPTED_KEY_LENGTH 117 +-# define CMS_R_INVALID_KEY_ENCRYPTION_PARAMETER 176 +-# define CMS_R_INVALID_KEY_LENGTH 118 +-# define CMS_R_MD_BIO_INIT_ERROR 119 +-# define CMS_R_MESSAGEDIGEST_ATTRIBUTE_WRONG_LENGTH 120 +-# define CMS_R_MESSAGEDIGEST_WRONG_LENGTH 121 +-# define CMS_R_MSGSIGDIGEST_ERROR 172 +-# define CMS_R_MSGSIGDIGEST_VERIFICATION_FAILURE 162 +-# define CMS_R_MSGSIGDIGEST_WRONG_LENGTH 163 +-# define CMS_R_NEED_ONE_SIGNER 164 +-# define CMS_R_NOT_A_SIGNED_RECEIPT 165 +-# define CMS_R_NOT_ENCRYPTED_DATA 122 +-# define CMS_R_NOT_KEK 123 +-# define CMS_R_NOT_KEY_AGREEMENT 181 +-# define CMS_R_NOT_KEY_TRANSPORT 124 +-# define CMS_R_NOT_PWRI 177 +-# define CMS_R_NOT_SUPPORTED_FOR_THIS_KEY_TYPE 125 +-# define CMS_R_NO_CIPHER 126 +-# define CMS_R_NO_CONTENT 127 +-# define CMS_R_NO_CONTENT_TYPE 173 +-# define CMS_R_NO_DEFAULT_DIGEST 128 +-# define CMS_R_NO_DIGEST_SET 129 +-# define CMS_R_NO_KEY 130 +-# define CMS_R_NO_KEY_OR_CERT 174 +-# define CMS_R_NO_MATCHING_DIGEST 131 +-# define CMS_R_NO_MATCHING_RECIPIENT 132 +-# define CMS_R_NO_MATCHING_SIGNATURE 166 +-# define CMS_R_NO_MSGSIGDIGEST 167 +-# define CMS_R_NO_PASSWORD 178 +-# define CMS_R_NO_PRIVATE_KEY 133 +-# define CMS_R_NO_PUBLIC_KEY 134 +-# define CMS_R_NO_RECEIPT_REQUEST 168 +-# define CMS_R_NO_SIGNERS 135 +-# define CMS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 136 +-# define CMS_R_RECEIPT_DECODE_ERROR 169 +-# define CMS_R_RECIPIENT_ERROR 137 +-# define CMS_R_SIGNER_CERTIFICATE_NOT_FOUND 138 +-# define CMS_R_SIGNFINAL_ERROR 139 +-# define CMS_R_SMIME_TEXT_ERROR 140 +-# define CMS_R_STORE_INIT_ERROR 141 +-# define CMS_R_TYPE_NOT_COMPRESSED_DATA 142 +-# define CMS_R_TYPE_NOT_DATA 143 +-# define CMS_R_TYPE_NOT_DIGESTED_DATA 144 +-# define CMS_R_TYPE_NOT_ENCRYPTED_DATA 145 +-# define CMS_R_TYPE_NOT_ENVELOPED_DATA 146 +-# define CMS_R_UNABLE_TO_FINALIZE_CONTEXT 147 +-# define CMS_R_UNKNOWN_CIPHER 148 +-# define CMS_R_UNKNOWN_DIGEST_ALGORITHM 149 +-# define CMS_R_UNKNOWN_ID 150 +-# define CMS_R_UNSUPPORTED_COMPRESSION_ALGORITHM 151 +-# define CMS_R_UNSUPPORTED_CONTENT_TYPE 152 +-# define CMS_R_UNSUPPORTED_KEK_ALGORITHM 153 +-# define CMS_R_UNSUPPORTED_KEY_ENCRYPTION_ALGORITHM 179 +-# define CMS_R_UNSUPPORTED_RECIPIENTINFO_TYPE 155 +-# define CMS_R_UNSUPPORTED_RECIPIENT_TYPE 154 +-# define CMS_R_UNSUPPORTED_TYPE 156 +-# define CMS_R_UNWRAP_ERROR 157 +-# define CMS_R_UNWRAP_FAILURE 180 +-# define CMS_R_VERIFICATION_FAILURE 158 +-# define CMS_R_WRAP_ERROR 159 +- +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/comp.h b/uadk_tool/include/openssl/comp.h +deleted file mode 100644 +index d814d3c..0000000 +--- a/uadk_tool/include/openssl/comp.h ++++ /dev/null +@@ -1,53 +0,0 @@ +-/* +- * Copyright 2015-2018 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_COMP_H +-# define HEADER_COMP_H +- +-# include +- +-# ifndef OPENSSL_NO_COMP +-# include +-# include +-# ifdef __cplusplus +-extern "C" { +-# endif +- +- +- +-COMP_CTX *COMP_CTX_new(COMP_METHOD *meth); +-const COMP_METHOD *COMP_CTX_get_method(const COMP_CTX *ctx); +-int COMP_CTX_get_type(const COMP_CTX* comp); +-int COMP_get_type(const COMP_METHOD *meth); +-const char *COMP_get_name(const COMP_METHOD *meth); +-void COMP_CTX_free(COMP_CTX *ctx); +- +-int COMP_compress_block(COMP_CTX *ctx, unsigned char *out, int olen, +- unsigned char *in, int ilen); +-int COMP_expand_block(COMP_CTX *ctx, unsigned char *out, int olen, +- unsigned char *in, int ilen); +- +-COMP_METHOD *COMP_zlib(void); +- +-#if OPENSSL_API_COMPAT < 0x10100000L +-#define COMP_zlib_cleanup() while(0) continue +-#endif +- +-# ifdef HEADER_BIO_H +-# ifdef ZLIB +-const BIO_METHOD *BIO_f_zlib(void); +-# endif +-# endif +- +- +-# ifdef __cplusplus +-} +-# endif +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/comperr.h b/uadk_tool/include/openssl/comperr.h +deleted file mode 100644 +index 90231e9..0000000 +--- a/uadk_tool/include/openssl/comperr.h ++++ /dev/null +@@ -1,44 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_COMPERR_H +-# define HEADER_COMPERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# include +- +-# ifndef OPENSSL_NO_COMP +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_COMP_strings(void); +- +-/* +- * COMP function codes. +- */ +-# define COMP_F_BIO_ZLIB_FLUSH 99 +-# define COMP_F_BIO_ZLIB_NEW 100 +-# define COMP_F_BIO_ZLIB_READ 101 +-# define COMP_F_BIO_ZLIB_WRITE 102 +-# define COMP_F_COMP_CTX_NEW 103 +- +-/* +- * COMP reason codes. +- */ +-# define COMP_R_ZLIB_DEFLATE_ERROR 99 +-# define COMP_R_ZLIB_INFLATE_ERROR 100 +-# define COMP_R_ZLIB_NOT_SUPPORTED 101 +- +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/conf.h b/uadk_tool/include/openssl/conf.h +deleted file mode 100644 +index 7336cd2..0000000 +--- a/uadk_tool/include/openssl/conf.h ++++ /dev/null +@@ -1,168 +0,0 @@ +-/* +- * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_CONF_H +-# define HEADER_CONF_H +- +-# include +-# include +-# include +-# include +-# include +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-typedef struct { +- char *section; +- char *name; +- char *value; +-} CONF_VALUE; +- +-DEFINE_STACK_OF(CONF_VALUE) +-DEFINE_LHASH_OF(CONF_VALUE); +- +-struct conf_st; +-struct conf_method_st; +-typedef struct conf_method_st CONF_METHOD; +- +-struct conf_method_st { +- const char *name; +- CONF *(*create) (CONF_METHOD *meth); +- int (*init) (CONF *conf); +- int (*destroy) (CONF *conf); +- int (*destroy_data) (CONF *conf); +- int (*load_bio) (CONF *conf, BIO *bp, long *eline); +- int (*dump) (const CONF *conf, BIO *bp); +- int (*is_number) (const CONF *conf, char c); +- int (*to_int) (const CONF *conf, char c); +- int (*load) (CONF *conf, const char *name, long *eline); +-}; +- +-/* Module definitions */ +- +-typedef struct conf_imodule_st CONF_IMODULE; +-typedef struct conf_module_st CONF_MODULE; +- +-DEFINE_STACK_OF(CONF_MODULE) +-DEFINE_STACK_OF(CONF_IMODULE) +- +-/* DSO module function typedefs */ +-typedef int conf_init_func (CONF_IMODULE *md, const CONF *cnf); +-typedef void conf_finish_func (CONF_IMODULE *md); +- +-# define CONF_MFLAGS_IGNORE_ERRORS 0x1 +-# define CONF_MFLAGS_IGNORE_RETURN_CODES 0x2 +-# define CONF_MFLAGS_SILENT 0x4 +-# define CONF_MFLAGS_NO_DSO 0x8 +-# define CONF_MFLAGS_IGNORE_MISSING_FILE 0x10 +-# define CONF_MFLAGS_DEFAULT_SECTION 0x20 +- +-int CONF_set_default_method(CONF_METHOD *meth); +-void CONF_set_nconf(CONF *conf, LHASH_OF(CONF_VALUE) *hash); +-LHASH_OF(CONF_VALUE) *CONF_load(LHASH_OF(CONF_VALUE) *conf, const char *file, +- long *eline); +-# ifndef OPENSSL_NO_STDIO +-LHASH_OF(CONF_VALUE) *CONF_load_fp(LHASH_OF(CONF_VALUE) *conf, FILE *fp, +- long *eline); +-# endif +-LHASH_OF(CONF_VALUE) *CONF_load_bio(LHASH_OF(CONF_VALUE) *conf, BIO *bp, +- long *eline); +-STACK_OF(CONF_VALUE) *CONF_get_section(LHASH_OF(CONF_VALUE) *conf, +- const char *section); +-char *CONF_get_string(LHASH_OF(CONF_VALUE) *conf, const char *group, +- const char *name); +-long CONF_get_number(LHASH_OF(CONF_VALUE) *conf, const char *group, +- const char *name); +-void CONF_free(LHASH_OF(CONF_VALUE) *conf); +-#ifndef OPENSSL_NO_STDIO +-int CONF_dump_fp(LHASH_OF(CONF_VALUE) *conf, FILE *out); +-#endif +-int CONF_dump_bio(LHASH_OF(CONF_VALUE) *conf, BIO *out); +- +-DEPRECATEDIN_1_1_0(void OPENSSL_config(const char *config_name)) +- +-#if OPENSSL_API_COMPAT < 0x10100000L +-# define OPENSSL_no_config() \ +- OPENSSL_init_crypto(OPENSSL_INIT_NO_LOAD_CONFIG, NULL) +-#endif +- +-/* +- * New conf code. The semantics are different from the functions above. If +- * that wasn't the case, the above functions would have been replaced +- */ +- +-struct conf_st { +- CONF_METHOD *meth; +- void *meth_data; +- LHASH_OF(CONF_VALUE) *data; +-}; +- +-CONF *NCONF_new(CONF_METHOD *meth); +-CONF_METHOD *NCONF_default(void); +-CONF_METHOD *NCONF_WIN32(void); +-void NCONF_free(CONF *conf); +-void NCONF_free_data(CONF *conf); +- +-int NCONF_load(CONF *conf, const char *file, long *eline); +-# ifndef OPENSSL_NO_STDIO +-int NCONF_load_fp(CONF *conf, FILE *fp, long *eline); +-# endif +-int NCONF_load_bio(CONF *conf, BIO *bp, long *eline); +-STACK_OF(CONF_VALUE) *NCONF_get_section(const CONF *conf, +- const char *section); +-char *NCONF_get_string(const CONF *conf, const char *group, const char *name); +-int NCONF_get_number_e(const CONF *conf, const char *group, const char *name, +- long *result); +-#ifndef OPENSSL_NO_STDIO +-int NCONF_dump_fp(const CONF *conf, FILE *out); +-#endif +-int NCONF_dump_bio(const CONF *conf, BIO *out); +- +-#define NCONF_get_number(c,g,n,r) NCONF_get_number_e(c,g,n,r) +- +-/* Module functions */ +- +-int CONF_modules_load(const CONF *cnf, const char *appname, +- unsigned long flags); +-int CONF_modules_load_file(const char *filename, const char *appname, +- unsigned long flags); +-void CONF_modules_unload(int all); +-void CONF_modules_finish(void); +-#if OPENSSL_API_COMPAT < 0x10100000L +-# define CONF_modules_free() while(0) continue +-#endif +-int CONF_module_add(const char *name, conf_init_func *ifunc, +- conf_finish_func *ffunc); +- +-const char *CONF_imodule_get_name(const CONF_IMODULE *md); +-const char *CONF_imodule_get_value(const CONF_IMODULE *md); +-void *CONF_imodule_get_usr_data(const CONF_IMODULE *md); +-void CONF_imodule_set_usr_data(CONF_IMODULE *md, void *usr_data); +-CONF_MODULE *CONF_imodule_get_module(const CONF_IMODULE *md); +-unsigned long CONF_imodule_get_flags(const CONF_IMODULE *md); +-void CONF_imodule_set_flags(CONF_IMODULE *md, unsigned long flags); +-void *CONF_module_get_usr_data(CONF_MODULE *pmod); +-void CONF_module_set_usr_data(CONF_MODULE *pmod, void *usr_data); +- +-char *CONF_get1_default_config_file(void); +- +-int CONF_parse_list(const char *list, int sep, int nospc, +- int (*list_cb) (const char *elem, int len, void *usr), +- void *arg); +- +-void OPENSSL_load_builtin_modules(void); +- +- +-# ifdef __cplusplus +-} +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/conf_api.h b/uadk_tool/include/openssl/conf_api.h +deleted file mode 100644 +index a0275ad..0000000 +--- a/uadk_tool/include/openssl/conf_api.h ++++ /dev/null +@@ -1,40 +0,0 @@ +-/* +- * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_CONF_API_H +-# define HEADER_CONF_API_H +- +-# include +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-/* Up until OpenSSL 0.9.5a, this was new_section */ +-CONF_VALUE *_CONF_new_section(CONF *conf, const char *section); +-/* Up until OpenSSL 0.9.5a, this was get_section */ +-CONF_VALUE *_CONF_get_section(const CONF *conf, const char *section); +-/* Up until OpenSSL 0.9.5a, this was CONF_get_section */ +-STACK_OF(CONF_VALUE) *_CONF_get_section_values(const CONF *conf, +- const char *section); +- +-int _CONF_add_string(CONF *conf, CONF_VALUE *section, CONF_VALUE *value); +-char *_CONF_get_string(const CONF *conf, const char *section, +- const char *name); +-long _CONF_get_number(const CONF *conf, const char *section, +- const char *name); +- +-int _CONF_new_data(CONF *conf); +-void _CONF_free_data(CONF *conf); +- +-#ifdef __cplusplus +-} +-#endif +-#endif +diff --git a/uadk_tool/include/openssl/conferr.h b/uadk_tool/include/openssl/conferr.h +deleted file mode 100644 +index 32b9229..0000000 +--- a/uadk_tool/include/openssl/conferr.h ++++ /dev/null +@@ -1,76 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_CONFERR_H +-# define HEADER_CONFERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_CONF_strings(void); +- +-/* +- * CONF function codes. +- */ +-# define CONF_F_CONF_DUMP_FP 104 +-# define CONF_F_CONF_LOAD 100 +-# define CONF_F_CONF_LOAD_FP 103 +-# define CONF_F_CONF_PARSE_LIST 119 +-# define CONF_F_DEF_LOAD 120 +-# define CONF_F_DEF_LOAD_BIO 121 +-# define CONF_F_GET_NEXT_FILE 107 +-# define CONF_F_MODULE_ADD 122 +-# define CONF_F_MODULE_INIT 115 +-# define CONF_F_MODULE_LOAD_DSO 117 +-# define CONF_F_MODULE_RUN 118 +-# define CONF_F_NCONF_DUMP_BIO 105 +-# define CONF_F_NCONF_DUMP_FP 106 +-# define CONF_F_NCONF_GET_NUMBER_E 112 +-# define CONF_F_NCONF_GET_SECTION 108 +-# define CONF_F_NCONF_GET_STRING 109 +-# define CONF_F_NCONF_LOAD 113 +-# define CONF_F_NCONF_LOAD_BIO 110 +-# define CONF_F_NCONF_LOAD_FP 114 +-# define CONF_F_NCONF_NEW 111 +-# define CONF_F_PROCESS_INCLUDE 116 +-# define CONF_F_SSL_MODULE_INIT 123 +-# define CONF_F_STR_COPY 101 +- +-/* +- * CONF reason codes. +- */ +-# define CONF_R_ERROR_LOADING_DSO 110 +-# define CONF_R_LIST_CANNOT_BE_NULL 115 +-# define CONF_R_MISSING_CLOSE_SQUARE_BRACKET 100 +-# define CONF_R_MISSING_EQUAL_SIGN 101 +-# define CONF_R_MISSING_INIT_FUNCTION 112 +-# define CONF_R_MODULE_INITIALIZATION_ERROR 109 +-# define CONF_R_NO_CLOSE_BRACE 102 +-# define CONF_R_NO_CONF 105 +-# define CONF_R_NO_CONF_OR_ENVIRONMENT_VARIABLE 106 +-# define CONF_R_NO_SECTION 107 +-# define CONF_R_NO_SUCH_FILE 114 +-# define CONF_R_NO_VALUE 108 +-# define CONF_R_NUMBER_TOO_LARGE 121 +-# define CONF_R_RECURSIVE_DIRECTORY_INCLUDE 111 +-# define CONF_R_SSL_COMMAND_SECTION_EMPTY 117 +-# define CONF_R_SSL_COMMAND_SECTION_NOT_FOUND 118 +-# define CONF_R_SSL_SECTION_EMPTY 119 +-# define CONF_R_SSL_SECTION_NOT_FOUND 120 +-# define CONF_R_UNABLE_TO_CREATE_NEW_SECTION 103 +-# define CONF_R_UNKNOWN_MODULE_NAME 113 +-# define CONF_R_VARIABLE_EXPANSION_TOO_LONG 116 +-# define CONF_R_VARIABLE_HAS_NO_VALUE 104 +- +-#endif +diff --git a/uadk_tool/include/openssl/crypto.h b/uadk_tool/include/openssl/crypto.h +deleted file mode 100644 +index 7d0b526..0000000 +--- a/uadk_tool/include/openssl/crypto.h ++++ /dev/null +@@ -1,445 +0,0 @@ +-/* +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_CRYPTO_H +-# define HEADER_CRYPTO_H +- +-# include +-# include +- +-# include +- +-# ifndef OPENSSL_NO_STDIO +-# include +-# endif +- +-# include +-# include +-# include +-# include +-# include +- +-# ifdef CHARSET_EBCDIC +-# include +-# endif +- +-/* +- * Resolve problems on some operating systems with symbol names that clash +- * one way or another +- */ +-# include +- +-# if OPENSSL_API_COMPAT < 0x10100000L +-# include +-# endif +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-# if OPENSSL_API_COMPAT < 0x10100000L +-# define SSLeay OpenSSL_version_num +-# define SSLeay_version OpenSSL_version +-# define SSLEAY_VERSION_NUMBER OPENSSL_VERSION_NUMBER +-# define SSLEAY_VERSION OPENSSL_VERSION +-# define SSLEAY_CFLAGS OPENSSL_CFLAGS +-# define SSLEAY_BUILT_ON OPENSSL_BUILT_ON +-# define SSLEAY_PLATFORM OPENSSL_PLATFORM +-# define SSLEAY_DIR OPENSSL_DIR +- +-/* +- * Old type for allocating dynamic locks. No longer used. Use the new thread +- * API instead. +- */ +-typedef struct { +- int dummy; +-} CRYPTO_dynlock; +- +-# endif /* OPENSSL_API_COMPAT */ +- +-typedef void CRYPTO_RWLOCK; +- +-CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void); +-int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock); +-int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock); +-int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK *lock); +-void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock); +- +-int CRYPTO_atomic_add(int *val, int amount, int *ret, CRYPTO_RWLOCK *lock); +- +-/* +- * The following can be used to detect memory leaks in the library. If +- * used, it turns on malloc checking +- */ +-# define CRYPTO_MEM_CHECK_OFF 0x0 /* Control only */ +-# define CRYPTO_MEM_CHECK_ON 0x1 /* Control and mode bit */ +-# define CRYPTO_MEM_CHECK_ENABLE 0x2 /* Control and mode bit */ +-# define CRYPTO_MEM_CHECK_DISABLE 0x3 /* Control only */ +- +-struct crypto_ex_data_st { +- STACK_OF(void) *sk; +-}; +-DEFINE_STACK_OF(void) +- +-/* +- * Per class, we have a STACK of function pointers. +- */ +-# define CRYPTO_EX_INDEX_SSL 0 +-# define CRYPTO_EX_INDEX_SSL_CTX 1 +-# define CRYPTO_EX_INDEX_SSL_SESSION 2 +-# define CRYPTO_EX_INDEX_X509 3 +-# define CRYPTO_EX_INDEX_X509_STORE 4 +-# define CRYPTO_EX_INDEX_X509_STORE_CTX 5 +-# define CRYPTO_EX_INDEX_DH 6 +-# define CRYPTO_EX_INDEX_DSA 7 +-# define CRYPTO_EX_INDEX_EC_KEY 8 +-# define CRYPTO_EX_INDEX_RSA 9 +-# define CRYPTO_EX_INDEX_ENGINE 10 +-# define CRYPTO_EX_INDEX_UI 11 +-# define CRYPTO_EX_INDEX_BIO 12 +-# define CRYPTO_EX_INDEX_APP 13 +-# define CRYPTO_EX_INDEX_UI_METHOD 14 +-# define CRYPTO_EX_INDEX_DRBG 15 +-# define CRYPTO_EX_INDEX__COUNT 16 +- +-/* No longer needed, so this is a no-op */ +-#define OPENSSL_malloc_init() while(0) continue +- +-int CRYPTO_mem_ctrl(int mode); +- +-# define OPENSSL_malloc(num) \ +- CRYPTO_malloc(num, OPENSSL_FILE, OPENSSL_LINE) +-# define OPENSSL_zalloc(num) \ +- CRYPTO_zalloc(num, OPENSSL_FILE, OPENSSL_LINE) +-# define OPENSSL_realloc(addr, num) \ +- CRYPTO_realloc(addr, num, OPENSSL_FILE, OPENSSL_LINE) +-# define OPENSSL_clear_realloc(addr, old_num, num) \ +- CRYPTO_clear_realloc(addr, old_num, num, OPENSSL_FILE, OPENSSL_LINE) +-# define OPENSSL_clear_free(addr, num) \ +- CRYPTO_clear_free(addr, num, OPENSSL_FILE, OPENSSL_LINE) +-# define OPENSSL_free(addr) \ +- CRYPTO_free(addr, OPENSSL_FILE, OPENSSL_LINE) +-# define OPENSSL_memdup(str, s) \ +- CRYPTO_memdup((str), s, OPENSSL_FILE, OPENSSL_LINE) +-# define OPENSSL_strdup(str) \ +- CRYPTO_strdup(str, OPENSSL_FILE, OPENSSL_LINE) +-# define OPENSSL_strndup(str, n) \ +- CRYPTO_strndup(str, n, OPENSSL_FILE, OPENSSL_LINE) +-# define OPENSSL_secure_malloc(num) \ +- CRYPTO_secure_malloc(num, OPENSSL_FILE, OPENSSL_LINE) +-# define OPENSSL_secure_zalloc(num) \ +- CRYPTO_secure_zalloc(num, OPENSSL_FILE, OPENSSL_LINE) +-# define OPENSSL_secure_free(addr) \ +- CRYPTO_secure_free(addr, OPENSSL_FILE, OPENSSL_LINE) +-# define OPENSSL_secure_clear_free(addr, num) \ +- CRYPTO_secure_clear_free(addr, num, OPENSSL_FILE, OPENSSL_LINE) +-# define OPENSSL_secure_actual_size(ptr) \ +- CRYPTO_secure_actual_size(ptr) +- +-size_t OPENSSL_strlcpy(char *dst, const char *src, size_t siz); +-size_t OPENSSL_strlcat(char *dst, const char *src, size_t siz); +-size_t OPENSSL_strnlen(const char *str, size_t maxlen); +-char *OPENSSL_buf2hexstr(const unsigned char *buffer, long len); +-unsigned char *OPENSSL_hexstr2buf(const char *str, long *len); +-int OPENSSL_hexchar2int(unsigned char c); +- +-# define OPENSSL_MALLOC_MAX_NELEMS(type) (((1U<<(sizeof(int)*8-1))-1)/sizeof(type)) +- +-unsigned long OpenSSL_version_num(void); +-const char *OpenSSL_version(int type); +-# define OPENSSL_VERSION 0 +-# define OPENSSL_CFLAGS 1 +-# define OPENSSL_BUILT_ON 2 +-# define OPENSSL_PLATFORM 3 +-# define OPENSSL_DIR 4 +-# define OPENSSL_ENGINES_DIR 5 +- +-int OPENSSL_issetugid(void); +- +-typedef void CRYPTO_EX_new (void *parent, void *ptr, CRYPTO_EX_DATA *ad, +- int idx, long argl, void *argp); +-typedef void CRYPTO_EX_free (void *parent, void *ptr, CRYPTO_EX_DATA *ad, +- int idx, long argl, void *argp); +-typedef int CRYPTO_EX_dup (CRYPTO_EX_DATA *to, const CRYPTO_EX_DATA *from, +- void *from_d, int idx, long argl, void *argp); +-__owur int CRYPTO_get_ex_new_index(int class_index, long argl, void *argp, +- CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func, +- CRYPTO_EX_free *free_func); +-/* No longer use an index. */ +-int CRYPTO_free_ex_index(int class_index, int idx); +- +-/* +- * Initialise/duplicate/free CRYPTO_EX_DATA variables corresponding to a +- * given class (invokes whatever per-class callbacks are applicable) +- */ +-int CRYPTO_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad); +-int CRYPTO_dup_ex_data(int class_index, CRYPTO_EX_DATA *to, +- const CRYPTO_EX_DATA *from); +- +-void CRYPTO_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad); +- +-/* +- * Get/set data in a CRYPTO_EX_DATA variable corresponding to a particular +- * index (relative to the class type involved) +- */ +-int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val); +-void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx); +- +-# if OPENSSL_API_COMPAT < 0x10100000L +-/* +- * This function cleans up all "ex_data" state. It mustn't be called under +- * potential race-conditions. +- */ +-# define CRYPTO_cleanup_all_ex_data() while(0) continue +- +-/* +- * The old locking functions have been removed completely without compatibility +- * macros. This is because the old functions either could not properly report +- * errors, or the returned error values were not clearly documented. +- * Replacing the locking functions with no-ops would cause race condition +- * issues in the affected applications. It is far better for them to fail at +- * compile time. +- * On the other hand, the locking callbacks are no longer used. Consequently, +- * the callback management functions can be safely replaced with no-op macros. +- */ +-# define CRYPTO_num_locks() (1) +-# define CRYPTO_set_locking_callback(func) +-# define CRYPTO_get_locking_callback() (NULL) +-# define CRYPTO_set_add_lock_callback(func) +-# define CRYPTO_get_add_lock_callback() (NULL) +- +-/* +- * These defines where used in combination with the old locking callbacks, +- * they are not called anymore, but old code that's not called might still +- * use them. +- */ +-# define CRYPTO_LOCK 1 +-# define CRYPTO_UNLOCK 2 +-# define CRYPTO_READ 4 +-# define CRYPTO_WRITE 8 +- +-/* This structure is no longer used */ +-typedef struct crypto_threadid_st { +- int dummy; +-} CRYPTO_THREADID; +-/* Only use CRYPTO_THREADID_set_[numeric|pointer]() within callbacks */ +-# define CRYPTO_THREADID_set_numeric(id, val) +-# define CRYPTO_THREADID_set_pointer(id, ptr) +-# define CRYPTO_THREADID_set_callback(threadid_func) (0) +-# define CRYPTO_THREADID_get_callback() (NULL) +-# define CRYPTO_THREADID_current(id) +-# define CRYPTO_THREADID_cmp(a, b) (-1) +-# define CRYPTO_THREADID_cpy(dest, src) +-# define CRYPTO_THREADID_hash(id) (0UL) +- +-# if OPENSSL_API_COMPAT < 0x10000000L +-# define CRYPTO_set_id_callback(func) +-# define CRYPTO_get_id_callback() (NULL) +-# define CRYPTO_thread_id() (0UL) +-# endif /* OPENSSL_API_COMPAT < 0x10000000L */ +- +-# define CRYPTO_set_dynlock_create_callback(dyn_create_function) +-# define CRYPTO_set_dynlock_lock_callback(dyn_lock_function) +-# define CRYPTO_set_dynlock_destroy_callback(dyn_destroy_function) +-# define CRYPTO_get_dynlock_create_callback() (NULL) +-# define CRYPTO_get_dynlock_lock_callback() (NULL) +-# define CRYPTO_get_dynlock_destroy_callback() (NULL) +-# endif /* OPENSSL_API_COMPAT < 0x10100000L */ +- +-int CRYPTO_set_mem_functions( +- void *(*m) (size_t, const char *, int), +- void *(*r) (void *, size_t, const char *, int), +- void (*f) (void *, const char *, int)); +-int CRYPTO_set_mem_debug(int flag); +-void CRYPTO_get_mem_functions( +- void *(**m) (size_t, const char *, int), +- void *(**r) (void *, size_t, const char *, int), +- void (**f) (void *, const char *, int)); +- +-void *CRYPTO_malloc(size_t num, const char *file, int line); +-void *CRYPTO_zalloc(size_t num, const char *file, int line); +-void *CRYPTO_memdup(const void *str, size_t siz, const char *file, int line); +-char *CRYPTO_strdup(const char *str, const char *file, int line); +-char *CRYPTO_strndup(const char *str, size_t s, const char *file, int line); +-void CRYPTO_free(void *ptr, const char *file, int line); +-void CRYPTO_clear_free(void *ptr, size_t num, const char *file, int line); +-void *CRYPTO_realloc(void *addr, size_t num, const char *file, int line); +-void *CRYPTO_clear_realloc(void *addr, size_t old_num, size_t num, +- const char *file, int line); +- +-int CRYPTO_secure_malloc_init(size_t sz, int minsize); +-int CRYPTO_secure_malloc_done(void); +-void *CRYPTO_secure_malloc(size_t num, const char *file, int line); +-void *CRYPTO_secure_zalloc(size_t num, const char *file, int line); +-void CRYPTO_secure_free(void *ptr, const char *file, int line); +-void CRYPTO_secure_clear_free(void *ptr, size_t num, +- const char *file, int line); +-int CRYPTO_secure_allocated(const void *ptr); +-int CRYPTO_secure_malloc_initialized(void); +-size_t CRYPTO_secure_actual_size(void *ptr); +-size_t CRYPTO_secure_used(void); +- +-void OPENSSL_cleanse(void *ptr, size_t len); +- +-# ifndef OPENSSL_NO_CRYPTO_MDEBUG +-# define OPENSSL_mem_debug_push(info) \ +- CRYPTO_mem_debug_push(info, OPENSSL_FILE, OPENSSL_LINE) +-# define OPENSSL_mem_debug_pop() \ +- CRYPTO_mem_debug_pop() +-int CRYPTO_mem_debug_push(const char *info, const char *file, int line); +-int CRYPTO_mem_debug_pop(void); +-void CRYPTO_get_alloc_counts(int *mcount, int *rcount, int *fcount); +- +-/*- +- * Debugging functions (enabled by CRYPTO_set_mem_debug(1)) +- * The flag argument has the following significance: +- * 0: called before the actual memory allocation has taken place +- * 1: called after the actual memory allocation has taken place +- */ +-void CRYPTO_mem_debug_malloc(void *addr, size_t num, int flag, +- const char *file, int line); +-void CRYPTO_mem_debug_realloc(void *addr1, void *addr2, size_t num, int flag, +- const char *file, int line); +-void CRYPTO_mem_debug_free(void *addr, int flag, +- const char *file, int line); +- +-int CRYPTO_mem_leaks_cb(int (*cb) (const char *str, size_t len, void *u), +- void *u); +-# ifndef OPENSSL_NO_STDIO +-int CRYPTO_mem_leaks_fp(FILE *); +-# endif +-int CRYPTO_mem_leaks(BIO *bio); +-# endif +- +-/* die if we have to */ +-ossl_noreturn void OPENSSL_die(const char *assertion, const char *file, int line); +-# if OPENSSL_API_COMPAT < 0x10100000L +-# define OpenSSLDie(f,l,a) OPENSSL_die((a),(f),(l)) +-# endif +-# define OPENSSL_assert(e) \ +- (void)((e) ? 0 : (OPENSSL_die("assertion failed: " #e, OPENSSL_FILE, OPENSSL_LINE), 1)) +- +-int OPENSSL_isservice(void); +- +-int FIPS_mode(void); +-int FIPS_mode_set(int r); +- +-void OPENSSL_init(void); +-# ifdef OPENSSL_SYS_UNIX +-void OPENSSL_fork_prepare(void); +-void OPENSSL_fork_parent(void); +-void OPENSSL_fork_child(void); +-# endif +- +-struct tm *OPENSSL_gmtime(const time_t *timer, struct tm *result); +-int OPENSSL_gmtime_adj(struct tm *tm, int offset_day, long offset_sec); +-int OPENSSL_gmtime_diff(int *pday, int *psec, +- const struct tm *from, const struct tm *to); +- +-/* +- * CRYPTO_memcmp returns zero iff the |len| bytes at |a| and |b| are equal. +- * It takes an amount of time dependent on |len|, but independent of the +- * contents of |a| and |b|. Unlike memcmp, it cannot be used to put elements +- * into a defined order as the return value when a != b is undefined, other +- * than to be non-zero. +- */ +-int CRYPTO_memcmp(const void * in_a, const void * in_b, size_t len); +- +-/* Standard initialisation options */ +-# define OPENSSL_INIT_NO_LOAD_CRYPTO_STRINGS 0x00000001L +-# define OPENSSL_INIT_LOAD_CRYPTO_STRINGS 0x00000002L +-# define OPENSSL_INIT_ADD_ALL_CIPHERS 0x00000004L +-# define OPENSSL_INIT_ADD_ALL_DIGESTS 0x00000008L +-# define OPENSSL_INIT_NO_ADD_ALL_CIPHERS 0x00000010L +-# define OPENSSL_INIT_NO_ADD_ALL_DIGESTS 0x00000020L +-# define OPENSSL_INIT_LOAD_CONFIG 0x00000040L +-# define OPENSSL_INIT_NO_LOAD_CONFIG 0x00000080L +-# define OPENSSL_INIT_ASYNC 0x00000100L +-# define OPENSSL_INIT_ENGINE_RDRAND 0x00000200L +-# define OPENSSL_INIT_ENGINE_DYNAMIC 0x00000400L +-# define OPENSSL_INIT_ENGINE_OPENSSL 0x00000800L +-# define OPENSSL_INIT_ENGINE_CRYPTODEV 0x00001000L +-# define OPENSSL_INIT_ENGINE_CAPI 0x00002000L +-# define OPENSSL_INIT_ENGINE_PADLOCK 0x00004000L +-# define OPENSSL_INIT_ENGINE_AFALG 0x00008000L +-/* OPENSSL_INIT_ZLIB 0x00010000L */ +-# define OPENSSL_INIT_ATFORK 0x00020000L +-/* OPENSSL_INIT_BASE_ONLY 0x00040000L */ +-# define OPENSSL_INIT_NO_ATEXIT 0x00080000L +-/* OPENSSL_INIT flag range 0xfff00000 reserved for OPENSSL_init_ssl() */ +-/* Max OPENSSL_INIT flag value is 0x80000000 */ +- +-/* openssl and dasync not counted as builtin */ +-# define OPENSSL_INIT_ENGINE_ALL_BUILTIN \ +- (OPENSSL_INIT_ENGINE_RDRAND | OPENSSL_INIT_ENGINE_DYNAMIC \ +- | OPENSSL_INIT_ENGINE_CRYPTODEV | OPENSSL_INIT_ENGINE_CAPI | \ +- OPENSSL_INIT_ENGINE_PADLOCK) +- +- +-/* Library initialisation functions */ +-void OPENSSL_cleanup(void); +-int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings); +-int OPENSSL_atexit(void (*handler)(void)); +-void OPENSSL_thread_stop(void); +- +-/* Low-level control of initialization */ +-OPENSSL_INIT_SETTINGS *OPENSSL_INIT_new(void); +-# ifndef OPENSSL_NO_STDIO +-int OPENSSL_INIT_set_config_filename(OPENSSL_INIT_SETTINGS *settings, +- const char *config_filename); +-void OPENSSL_INIT_set_config_file_flags(OPENSSL_INIT_SETTINGS *settings, +- unsigned long flags); +-int OPENSSL_INIT_set_config_appname(OPENSSL_INIT_SETTINGS *settings, +- const char *config_appname); +-# endif +-void OPENSSL_INIT_free(OPENSSL_INIT_SETTINGS *settings); +- +-# if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG) +-# if defined(_WIN32) +-# if defined(BASETYPES) || defined(_WINDEF_H) +-/* application has to include in order to use this */ +-typedef DWORD CRYPTO_THREAD_LOCAL; +-typedef DWORD CRYPTO_THREAD_ID; +- +-typedef LONG CRYPTO_ONCE; +-# define CRYPTO_ONCE_STATIC_INIT 0 +-# endif +-# else +-# include +-typedef pthread_once_t CRYPTO_ONCE; +-typedef pthread_key_t CRYPTO_THREAD_LOCAL; +-typedef pthread_t CRYPTO_THREAD_ID; +- +-# define CRYPTO_ONCE_STATIC_INIT PTHREAD_ONCE_INIT +-# endif +-# endif +- +-# if !defined(CRYPTO_ONCE_STATIC_INIT) +-typedef unsigned int CRYPTO_ONCE; +-typedef unsigned int CRYPTO_THREAD_LOCAL; +-typedef unsigned int CRYPTO_THREAD_ID; +-# define CRYPTO_ONCE_STATIC_INIT 0 +-# endif +- +-int CRYPTO_THREAD_run_once(CRYPTO_ONCE *once, void (*init)(void)); +- +-int CRYPTO_THREAD_init_local(CRYPTO_THREAD_LOCAL *key, void (*cleanup)(void *)); +-void *CRYPTO_THREAD_get_local(CRYPTO_THREAD_LOCAL *key); +-int CRYPTO_THREAD_set_local(CRYPTO_THREAD_LOCAL *key, void *val); +-int CRYPTO_THREAD_cleanup_local(CRYPTO_THREAD_LOCAL *key); +- +-CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void); +-int CRYPTO_THREAD_compare_id(CRYPTO_THREAD_ID a, CRYPTO_THREAD_ID b); +- +- +-# ifdef __cplusplus +-} +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/cryptoerr.h b/uadk_tool/include/openssl/cryptoerr.h +deleted file mode 100644 +index 3db5a4e..0000000 +--- a/uadk_tool/include/openssl/cryptoerr.h ++++ /dev/null +@@ -1,57 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_CRYPTOERR_H +-# define HEADER_CRYPTOERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_CRYPTO_strings(void); +- +-/* +- * CRYPTO function codes. +- */ +-# define CRYPTO_F_CMAC_CTX_NEW 120 +-# define CRYPTO_F_CRYPTO_DUP_EX_DATA 110 +-# define CRYPTO_F_CRYPTO_FREE_EX_DATA 111 +-# define CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX 100 +-# define CRYPTO_F_CRYPTO_MEMDUP 115 +-# define CRYPTO_F_CRYPTO_NEW_EX_DATA 112 +-# define CRYPTO_F_CRYPTO_OCB128_COPY_CTX 121 +-# define CRYPTO_F_CRYPTO_OCB128_INIT 122 +-# define CRYPTO_F_CRYPTO_SET_EX_DATA 102 +-# define CRYPTO_F_FIPS_MODE_SET 109 +-# define CRYPTO_F_GET_AND_LOCK 113 +-# define CRYPTO_F_OPENSSL_ATEXIT 114 +-# define CRYPTO_F_OPENSSL_BUF2HEXSTR 117 +-# define CRYPTO_F_OPENSSL_FOPEN 119 +-# define CRYPTO_F_OPENSSL_HEXSTR2BUF 118 +-# define CRYPTO_F_OPENSSL_INIT_CRYPTO 116 +-# define CRYPTO_F_OPENSSL_LH_NEW 126 +-# define CRYPTO_F_OPENSSL_SK_DEEP_COPY 127 +-# define CRYPTO_F_OPENSSL_SK_DUP 128 +-# define CRYPTO_F_PKEY_HMAC_INIT 123 +-# define CRYPTO_F_PKEY_POLY1305_INIT 124 +-# define CRYPTO_F_PKEY_SIPHASH_INIT 125 +-# define CRYPTO_F_SK_RESERVE 129 +- +-/* +- * CRYPTO reason codes. +- */ +-# define CRYPTO_R_FIPS_MODE_NOT_SUPPORTED 101 +-# define CRYPTO_R_ILLEGAL_HEX_DIGIT 102 +-# define CRYPTO_R_ODD_NUMBER_OF_DIGITS 103 +- +-#endif +diff --git a/uadk_tool/include/openssl/ct.h b/uadk_tool/include/openssl/ct.h +deleted file mode 100644 +index ebdba34..0000000 +--- a/uadk_tool/include/openssl/ct.h ++++ /dev/null +@@ -1,474 +0,0 @@ +-/* +- * Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_CT_H +-# define HEADER_CT_H +- +-# include +- +-# ifndef OPENSSL_NO_CT +-# include +-# include +-# include +-# include +-# ifdef __cplusplus +-extern "C" { +-# endif +- +- +-/* Minimum RSA key size, from RFC6962 */ +-# define SCT_MIN_RSA_BITS 2048 +- +-/* All hashes are SHA256 in v1 of Certificate Transparency */ +-# define CT_V1_HASHLEN SHA256_DIGEST_LENGTH +- +-typedef enum { +- CT_LOG_ENTRY_TYPE_NOT_SET = -1, +- CT_LOG_ENTRY_TYPE_X509 = 0, +- CT_LOG_ENTRY_TYPE_PRECERT = 1 +-} ct_log_entry_type_t; +- +-typedef enum { +- SCT_VERSION_NOT_SET = -1, +- SCT_VERSION_V1 = 0 +-} sct_version_t; +- +-typedef enum { +- SCT_SOURCE_UNKNOWN, +- SCT_SOURCE_TLS_EXTENSION, +- SCT_SOURCE_X509V3_EXTENSION, +- SCT_SOURCE_OCSP_STAPLED_RESPONSE +-} sct_source_t; +- +-typedef enum { +- SCT_VALIDATION_STATUS_NOT_SET, +- SCT_VALIDATION_STATUS_UNKNOWN_LOG, +- SCT_VALIDATION_STATUS_VALID, +- SCT_VALIDATION_STATUS_INVALID, +- SCT_VALIDATION_STATUS_UNVERIFIED, +- SCT_VALIDATION_STATUS_UNKNOWN_VERSION +-} sct_validation_status_t; +- +-DEFINE_STACK_OF(SCT) +-DEFINE_STACK_OF(CTLOG) +- +-/****************************************** +- * CT policy evaluation context functions * +- ******************************************/ +- +-/* +- * Creates a new, empty policy evaluation context. +- * The caller is responsible for calling CT_POLICY_EVAL_CTX_free when finished +- * with the CT_POLICY_EVAL_CTX. +- */ +-CT_POLICY_EVAL_CTX *CT_POLICY_EVAL_CTX_new(void); +- +-/* Deletes a policy evaluation context and anything it owns. */ +-void CT_POLICY_EVAL_CTX_free(CT_POLICY_EVAL_CTX *ctx); +- +-/* Gets the peer certificate that the SCTs are for */ +-X509* CT_POLICY_EVAL_CTX_get0_cert(const CT_POLICY_EVAL_CTX *ctx); +- +-/* +- * Sets the certificate associated with the received SCTs. +- * Increments the reference count of cert. +- * Returns 1 on success, 0 otherwise. +- */ +-int CT_POLICY_EVAL_CTX_set1_cert(CT_POLICY_EVAL_CTX *ctx, X509 *cert); +- +-/* Gets the issuer of the aforementioned certificate */ +-X509* CT_POLICY_EVAL_CTX_get0_issuer(const CT_POLICY_EVAL_CTX *ctx); +- +-/* +- * Sets the issuer of the certificate associated with the received SCTs. +- * Increments the reference count of issuer. +- * Returns 1 on success, 0 otherwise. +- */ +-int CT_POLICY_EVAL_CTX_set1_issuer(CT_POLICY_EVAL_CTX *ctx, X509 *issuer); +- +-/* Gets the CT logs that are trusted sources of SCTs */ +-const CTLOG_STORE *CT_POLICY_EVAL_CTX_get0_log_store(const CT_POLICY_EVAL_CTX *ctx); +- +-/* Sets the log store that is in use. It must outlive the CT_POLICY_EVAL_CTX. */ +-void CT_POLICY_EVAL_CTX_set_shared_CTLOG_STORE(CT_POLICY_EVAL_CTX *ctx, +- CTLOG_STORE *log_store); +- +-/* +- * Gets the time, in milliseconds since the Unix epoch, that will be used as the +- * current time when checking whether an SCT was issued in the future. +- * Such SCTs will fail validation, as required by RFC6962. +- */ +-uint64_t CT_POLICY_EVAL_CTX_get_time(const CT_POLICY_EVAL_CTX *ctx); +- +-/* +- * Sets the time to evaluate SCTs against, in milliseconds since the Unix epoch. +- * If an SCT's timestamp is after this time, it will be interpreted as having +- * been issued in the future. RFC6962 states that "TLS clients MUST reject SCTs +- * whose timestamp is in the future", so an SCT will not validate in this case. +- */ +-void CT_POLICY_EVAL_CTX_set_time(CT_POLICY_EVAL_CTX *ctx, uint64_t time_in_ms); +- +-/***************** +- * SCT functions * +- *****************/ +- +-/* +- * Creates a new, blank SCT. +- * The caller is responsible for calling SCT_free when finished with the SCT. +- */ +-SCT *SCT_new(void); +- +-/* +- * Creates a new SCT from some base64-encoded strings. +- * The caller is responsible for calling SCT_free when finished with the SCT. +- */ +-SCT *SCT_new_from_base64(unsigned char version, +- const char *logid_base64, +- ct_log_entry_type_t entry_type, +- uint64_t timestamp, +- const char *extensions_base64, +- const char *signature_base64); +- +-/* +- * Frees the SCT and the underlying data structures. +- */ +-void SCT_free(SCT *sct); +- +-/* +- * Free a stack of SCTs, and the underlying SCTs themselves. +- * Intended to be compatible with X509V3_EXT_FREE. +- */ +-void SCT_LIST_free(STACK_OF(SCT) *a); +- +-/* +- * Returns the version of the SCT. +- */ +-sct_version_t SCT_get_version(const SCT *sct); +- +-/* +- * Set the version of an SCT. +- * Returns 1 on success, 0 if the version is unrecognized. +- */ +-__owur int SCT_set_version(SCT *sct, sct_version_t version); +- +-/* +- * Returns the log entry type of the SCT. +- */ +-ct_log_entry_type_t SCT_get_log_entry_type(const SCT *sct); +- +-/* +- * Set the log entry type of an SCT. +- * Returns 1 on success, 0 otherwise. +- */ +-__owur int SCT_set_log_entry_type(SCT *sct, ct_log_entry_type_t entry_type); +- +-/* +- * Gets the ID of the log that an SCT came from. +- * Ownership of the log ID remains with the SCT. +- * Returns the length of the log ID. +- */ +-size_t SCT_get0_log_id(const SCT *sct, unsigned char **log_id); +- +-/* +- * Set the log ID of an SCT to point directly to the *log_id specified. +- * The SCT takes ownership of the specified pointer. +- * Returns 1 on success, 0 otherwise. +- */ +-__owur int SCT_set0_log_id(SCT *sct, unsigned char *log_id, size_t log_id_len); +- +-/* +- * Set the log ID of an SCT. +- * This makes a copy of the log_id. +- * Returns 1 on success, 0 otherwise. +- */ +-__owur int SCT_set1_log_id(SCT *sct, const unsigned char *log_id, +- size_t log_id_len); +- +-/* +- * Returns the timestamp for the SCT (epoch time in milliseconds). +- */ +-uint64_t SCT_get_timestamp(const SCT *sct); +- +-/* +- * Set the timestamp of an SCT (epoch time in milliseconds). +- */ +-void SCT_set_timestamp(SCT *sct, uint64_t timestamp); +- +-/* +- * Return the NID for the signature used by the SCT. +- * For CT v1, this will be either NID_sha256WithRSAEncryption or +- * NID_ecdsa_with_SHA256 (or NID_undef if incorrect/unset). +- */ +-int SCT_get_signature_nid(const SCT *sct); +- +-/* +- * Set the signature type of an SCT +- * For CT v1, this should be either NID_sha256WithRSAEncryption or +- * NID_ecdsa_with_SHA256. +- * Returns 1 on success, 0 otherwise. +- */ +-__owur int SCT_set_signature_nid(SCT *sct, int nid); +- +-/* +- * Set *ext to point to the extension data for the SCT. ext must not be NULL. +- * The SCT retains ownership of this pointer. +- * Returns length of the data pointed to. +- */ +-size_t SCT_get0_extensions(const SCT *sct, unsigned char **ext); +- +-/* +- * Set the extensions of an SCT to point directly to the *ext specified. +- * The SCT takes ownership of the specified pointer. +- */ +-void SCT_set0_extensions(SCT *sct, unsigned char *ext, size_t ext_len); +- +-/* +- * Set the extensions of an SCT. +- * This takes a copy of the ext. +- * Returns 1 on success, 0 otherwise. +- */ +-__owur int SCT_set1_extensions(SCT *sct, const unsigned char *ext, +- size_t ext_len); +- +-/* +- * Set *sig to point to the signature for the SCT. sig must not be NULL. +- * The SCT retains ownership of this pointer. +- * Returns length of the data pointed to. +- */ +-size_t SCT_get0_signature(const SCT *sct, unsigned char **sig); +- +-/* +- * Set the signature of an SCT to point directly to the *sig specified. +- * The SCT takes ownership of the specified pointer. +- */ +-void SCT_set0_signature(SCT *sct, unsigned char *sig, size_t sig_len); +- +-/* +- * Set the signature of an SCT to be a copy of the *sig specified. +- * Returns 1 on success, 0 otherwise. +- */ +-__owur int SCT_set1_signature(SCT *sct, const unsigned char *sig, +- size_t sig_len); +- +-/* +- * The origin of this SCT, e.g. TLS extension, OCSP response, etc. +- */ +-sct_source_t SCT_get_source(const SCT *sct); +- +-/* +- * Set the origin of this SCT, e.g. TLS extension, OCSP response, etc. +- * Returns 1 on success, 0 otherwise. +- */ +-__owur int SCT_set_source(SCT *sct, sct_source_t source); +- +-/* +- * Returns a text string describing the validation status of |sct|. +- */ +-const char *SCT_validation_status_string(const SCT *sct); +- +-/* +- * Pretty-prints an |sct| to |out|. +- * It will be indented by the number of spaces specified by |indent|. +- * If |logs| is not NULL, it will be used to lookup the CT log that the SCT came +- * from, so that the log name can be printed. +- */ +-void SCT_print(const SCT *sct, BIO *out, int indent, const CTLOG_STORE *logs); +- +-/* +- * Pretty-prints an |sct_list| to |out|. +- * It will be indented by the number of spaces specified by |indent|. +- * SCTs will be delimited by |separator|. +- * If |logs| is not NULL, it will be used to lookup the CT log that each SCT +- * came from, so that the log names can be printed. +- */ +-void SCT_LIST_print(const STACK_OF(SCT) *sct_list, BIO *out, int indent, +- const char *separator, const CTLOG_STORE *logs); +- +-/* +- * Gets the last result of validating this SCT. +- * If it has not been validated yet, returns SCT_VALIDATION_STATUS_NOT_SET. +- */ +-sct_validation_status_t SCT_get_validation_status(const SCT *sct); +- +-/* +- * Validates the given SCT with the provided context. +- * Sets the "validation_status" field of the SCT. +- * Returns 1 if the SCT is valid and the signature verifies. +- * Returns 0 if the SCT is invalid or could not be verified. +- * Returns -1 if an error occurs. +- */ +-__owur int SCT_validate(SCT *sct, const CT_POLICY_EVAL_CTX *ctx); +- +-/* +- * Validates the given list of SCTs with the provided context. +- * Sets the "validation_status" field of each SCT. +- * Returns 1 if there are no invalid SCTs and all signatures verify. +- * Returns 0 if at least one SCT is invalid or could not be verified. +- * Returns a negative integer if an error occurs. +- */ +-__owur int SCT_LIST_validate(const STACK_OF(SCT) *scts, +- CT_POLICY_EVAL_CTX *ctx); +- +- +-/********************************* +- * SCT parsing and serialisation * +- *********************************/ +- +-/* +- * Serialize (to TLS format) a stack of SCTs and return the length. +- * "a" must not be NULL. +- * If "pp" is NULL, just return the length of what would have been serialized. +- * If "pp" is not NULL and "*pp" is null, function will allocate a new pointer +- * for data that caller is responsible for freeing (only if function returns +- * successfully). +- * If "pp" is NULL and "*pp" is not NULL, caller is responsible for ensuring +- * that "*pp" is large enough to accept all of the serialized data. +- * Returns < 0 on error, >= 0 indicating bytes written (or would have been) +- * on success. +- */ +-__owur int i2o_SCT_LIST(const STACK_OF(SCT) *a, unsigned char **pp); +- +-/* +- * Convert TLS format SCT list to a stack of SCTs. +- * If "a" or "*a" is NULL, a new stack will be created that the caller is +- * responsible for freeing (by calling SCT_LIST_free). +- * "**pp" and "*pp" must not be NULL. +- * Upon success, "*pp" will point to after the last bytes read, and a stack +- * will be returned. +- * Upon failure, a NULL pointer will be returned, and the position of "*pp" is +- * not defined. +- */ +-STACK_OF(SCT) *o2i_SCT_LIST(STACK_OF(SCT) **a, const unsigned char **pp, +- size_t len); +- +-/* +- * Serialize (to DER format) a stack of SCTs and return the length. +- * "a" must not be NULL. +- * If "pp" is NULL, just returns the length of what would have been serialized. +- * If "pp" is not NULL and "*pp" is null, function will allocate a new pointer +- * for data that caller is responsible for freeing (only if function returns +- * successfully). +- * If "pp" is NULL and "*pp" is not NULL, caller is responsible for ensuring +- * that "*pp" is large enough to accept all of the serialized data. +- * Returns < 0 on error, >= 0 indicating bytes written (or would have been) +- * on success. +- */ +-__owur int i2d_SCT_LIST(const STACK_OF(SCT) *a, unsigned char **pp); +- +-/* +- * Parses an SCT list in DER format and returns it. +- * If "a" or "*a" is NULL, a new stack will be created that the caller is +- * responsible for freeing (by calling SCT_LIST_free). +- * "**pp" and "*pp" must not be NULL. +- * Upon success, "*pp" will point to after the last bytes read, and a stack +- * will be returned. +- * Upon failure, a NULL pointer will be returned, and the position of "*pp" is +- * not defined. +- */ +-STACK_OF(SCT) *d2i_SCT_LIST(STACK_OF(SCT) **a, const unsigned char **pp, +- long len); +- +-/* +- * Serialize (to TLS format) an |sct| and write it to |out|. +- * If |out| is null, no SCT will be output but the length will still be returned. +- * If |out| points to a null pointer, a string will be allocated to hold the +- * TLS-format SCT. It is the responsibility of the caller to free it. +- * If |out| points to an allocated string, the TLS-format SCT will be written +- * to it. +- * The length of the SCT in TLS format will be returned. +- */ +-__owur int i2o_SCT(const SCT *sct, unsigned char **out); +- +-/* +- * Parses an SCT in TLS format and returns it. +- * If |psct| is not null, it will end up pointing to the parsed SCT. If it +- * already points to a non-null pointer, the pointer will be free'd. +- * |in| should be a pointer to a string containing the TLS-format SCT. +- * |in| will be advanced to the end of the SCT if parsing succeeds. +- * |len| should be the length of the SCT in |in|. +- * Returns NULL if an error occurs. +- * If the SCT is an unsupported version, only the SCT's 'sct' and 'sct_len' +- * fields will be populated (with |in| and |len| respectively). +- */ +-SCT *o2i_SCT(SCT **psct, const unsigned char **in, size_t len); +- +-/******************** +- * CT log functions * +- ********************/ +- +-/* +- * Creates a new CT log instance with the given |public_key| and |name|. +- * Takes ownership of |public_key| but copies |name|. +- * Returns NULL if malloc fails or if |public_key| cannot be converted to DER. +- * Should be deleted by the caller using CTLOG_free when no longer needed. +- */ +-CTLOG *CTLOG_new(EVP_PKEY *public_key, const char *name); +- +-/* +- * Creates a new CTLOG instance with the base64-encoded SubjectPublicKeyInfo DER +- * in |pkey_base64|. The |name| is a string to help users identify this log. +- * Returns 1 on success, 0 on failure. +- * Should be deleted by the caller using CTLOG_free when no longer needed. +- */ +-int CTLOG_new_from_base64(CTLOG ** ct_log, +- const char *pkey_base64, const char *name); +- +-/* +- * Deletes a CT log instance and its fields. +- */ +-void CTLOG_free(CTLOG *log); +- +-/* Gets the name of the CT log */ +-const char *CTLOG_get0_name(const CTLOG *log); +-/* Gets the ID of the CT log */ +-void CTLOG_get0_log_id(const CTLOG *log, const uint8_t **log_id, +- size_t *log_id_len); +-/* Gets the public key of the CT log */ +-EVP_PKEY *CTLOG_get0_public_key(const CTLOG *log); +- +-/************************** +- * CT log store functions * +- **************************/ +- +-/* +- * Creates a new CT log store. +- * Should be deleted by the caller using CTLOG_STORE_free when no longer needed. +- */ +-CTLOG_STORE *CTLOG_STORE_new(void); +- +-/* +- * Deletes a CT log store and all of the CT log instances held within. +- */ +-void CTLOG_STORE_free(CTLOG_STORE *store); +- +-/* +- * Finds a CT log in the store based on its log ID. +- * Returns the CT log, or NULL if no match is found. +- */ +-const CTLOG *CTLOG_STORE_get0_log_by_id(const CTLOG_STORE *store, +- const uint8_t *log_id, +- size_t log_id_len); +- +-/* +- * Loads a CT log list into a |store| from a |file|. +- * Returns 1 if loading is successful, or 0 otherwise. +- */ +-__owur int CTLOG_STORE_load_file(CTLOG_STORE *store, const char *file); +- +-/* +- * Loads the default CT log list into a |store|. +- * Returns 1 if loading is successful, or 0 otherwise. +- */ +-__owur int CTLOG_STORE_load_default_file(CTLOG_STORE *store); +- +-# ifdef __cplusplus +-} +-# endif +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/cterr.h b/uadk_tool/include/openssl/cterr.h +deleted file mode 100644 +index feb7bc5..0000000 +--- a/uadk_tool/include/openssl/cterr.h ++++ /dev/null +@@ -1,80 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_CTERR_H +-# define HEADER_CTERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# include +- +-# ifndef OPENSSL_NO_CT +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_CT_strings(void); +- +-/* +- * CT function codes. +- */ +-# define CT_F_CTLOG_NEW 117 +-# define CT_F_CTLOG_NEW_FROM_BASE64 118 +-# define CT_F_CTLOG_NEW_FROM_CONF 119 +-# define CT_F_CTLOG_STORE_LOAD_CTX_NEW 122 +-# define CT_F_CTLOG_STORE_LOAD_FILE 123 +-# define CT_F_CTLOG_STORE_LOAD_LOG 130 +-# define CT_F_CTLOG_STORE_NEW 131 +-# define CT_F_CT_BASE64_DECODE 124 +-# define CT_F_CT_POLICY_EVAL_CTX_NEW 133 +-# define CT_F_CT_V1_LOG_ID_FROM_PKEY 125 +-# define CT_F_I2O_SCT 107 +-# define CT_F_I2O_SCT_LIST 108 +-# define CT_F_I2O_SCT_SIGNATURE 109 +-# define CT_F_O2I_SCT 110 +-# define CT_F_O2I_SCT_LIST 111 +-# define CT_F_O2I_SCT_SIGNATURE 112 +-# define CT_F_SCT_CTX_NEW 126 +-# define CT_F_SCT_CTX_VERIFY 128 +-# define CT_F_SCT_NEW 100 +-# define CT_F_SCT_NEW_FROM_BASE64 127 +-# define CT_F_SCT_SET0_LOG_ID 101 +-# define CT_F_SCT_SET1_EXTENSIONS 114 +-# define CT_F_SCT_SET1_LOG_ID 115 +-# define CT_F_SCT_SET1_SIGNATURE 116 +-# define CT_F_SCT_SET_LOG_ENTRY_TYPE 102 +-# define CT_F_SCT_SET_SIGNATURE_NID 103 +-# define CT_F_SCT_SET_VERSION 104 +- +-/* +- * CT reason codes. +- */ +-# define CT_R_BASE64_DECODE_ERROR 108 +-# define CT_R_INVALID_LOG_ID_LENGTH 100 +-# define CT_R_LOG_CONF_INVALID 109 +-# define CT_R_LOG_CONF_INVALID_KEY 110 +-# define CT_R_LOG_CONF_MISSING_DESCRIPTION 111 +-# define CT_R_LOG_CONF_MISSING_KEY 112 +-# define CT_R_LOG_KEY_INVALID 113 +-# define CT_R_SCT_FUTURE_TIMESTAMP 116 +-# define CT_R_SCT_INVALID 104 +-# define CT_R_SCT_INVALID_SIGNATURE 107 +-# define CT_R_SCT_LIST_INVALID 105 +-# define CT_R_SCT_LOG_ID_MISMATCH 114 +-# define CT_R_SCT_NOT_SET 106 +-# define CT_R_SCT_UNSUPPORTED_VERSION 115 +-# define CT_R_UNRECOGNIZED_SIGNATURE_NID 101 +-# define CT_R_UNSUPPORTED_ENTRY_TYPE 102 +-# define CT_R_UNSUPPORTED_VERSION 103 +- +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/des.h b/uadk_tool/include/openssl/des.h +deleted file mode 100644 +index be4abbd..0000000 +--- a/uadk_tool/include/openssl/des.h ++++ /dev/null +@@ -1,174 +0,0 @@ +-/* +- * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_DES_H +-# define HEADER_DES_H +- +-# include +- +-# ifndef OPENSSL_NO_DES +-# ifdef __cplusplus +-extern "C" { +-# endif +-# include +- +-typedef unsigned int DES_LONG; +- +-# ifdef OPENSSL_BUILD_SHLIBCRYPTO +-# undef OPENSSL_EXTERN +-# define OPENSSL_EXTERN OPENSSL_EXPORT +-# endif +- +-typedef unsigned char DES_cblock[8]; +-typedef /* const */ unsigned char const_DES_cblock[8]; +-/* +- * With "const", gcc 2.8.1 on Solaris thinks that DES_cblock * and +- * const_DES_cblock * are incompatible pointer types. +- */ +- +-typedef struct DES_ks { +- union { +- DES_cblock cblock; +- /* +- * make sure things are correct size on machines with 8 byte longs +- */ +- DES_LONG deslong[2]; +- } ks[16]; +-} DES_key_schedule; +- +-# define DES_KEY_SZ (sizeof(DES_cblock)) +-# define DES_SCHEDULE_SZ (sizeof(DES_key_schedule)) +- +-# define DES_ENCRYPT 1 +-# define DES_DECRYPT 0 +- +-# define DES_CBC_MODE 0 +-# define DES_PCBC_MODE 1 +- +-# define DES_ecb2_encrypt(i,o,k1,k2,e) \ +- DES_ecb3_encrypt((i),(o),(k1),(k2),(k1),(e)) +- +-# define DES_ede2_cbc_encrypt(i,o,l,k1,k2,iv,e) \ +- DES_ede3_cbc_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(e)) +- +-# define DES_ede2_cfb64_encrypt(i,o,l,k1,k2,iv,n,e) \ +- DES_ede3_cfb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n),(e)) +- +-# define DES_ede2_ofb64_encrypt(i,o,l,k1,k2,iv,n) \ +- DES_ede3_ofb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n)) +- +-OPENSSL_DECLARE_GLOBAL(int, DES_check_key); /* defaults to false */ +-# define DES_check_key OPENSSL_GLOBAL_REF(DES_check_key) +- +-const char *DES_options(void); +-void DES_ecb3_encrypt(const_DES_cblock *input, DES_cblock *output, +- DES_key_schedule *ks1, DES_key_schedule *ks2, +- DES_key_schedule *ks3, int enc); +-DES_LONG DES_cbc_cksum(const unsigned char *input, DES_cblock *output, +- long length, DES_key_schedule *schedule, +- const_DES_cblock *ivec); +-/* DES_cbc_encrypt does not update the IV! Use DES_ncbc_encrypt instead. */ +-void DES_cbc_encrypt(const unsigned char *input, unsigned char *output, +- long length, DES_key_schedule *schedule, +- DES_cblock *ivec, int enc); +-void DES_ncbc_encrypt(const unsigned char *input, unsigned char *output, +- long length, DES_key_schedule *schedule, +- DES_cblock *ivec, int enc); +-void DES_xcbc_encrypt(const unsigned char *input, unsigned char *output, +- long length, DES_key_schedule *schedule, +- DES_cblock *ivec, const_DES_cblock *inw, +- const_DES_cblock *outw, int enc); +-void DES_cfb_encrypt(const unsigned char *in, unsigned char *out, int numbits, +- long length, DES_key_schedule *schedule, +- DES_cblock *ivec, int enc); +-void DES_ecb_encrypt(const_DES_cblock *input, DES_cblock *output, +- DES_key_schedule *ks, int enc); +- +-/* +- * This is the DES encryption function that gets called by just about every +- * other DES routine in the library. You should not use this function except +- * to implement 'modes' of DES. I say this because the functions that call +- * this routine do the conversion from 'char *' to long, and this needs to be +- * done to make sure 'non-aligned' memory access do not occur. The +- * characters are loaded 'little endian'. Data is a pointer to 2 unsigned +- * long's and ks is the DES_key_schedule to use. enc, is non zero specifies +- * encryption, zero if decryption. +- */ +-void DES_encrypt1(DES_LONG *data, DES_key_schedule *ks, int enc); +- +-/* +- * This functions is the same as DES_encrypt1() except that the DES initial +- * permutation (IP) and final permutation (FP) have been left out. As for +- * DES_encrypt1(), you should not use this function. It is used by the +- * routines in the library that implement triple DES. IP() DES_encrypt2() +- * DES_encrypt2() DES_encrypt2() FP() is the same as DES_encrypt1() +- * DES_encrypt1() DES_encrypt1() except faster :-). +- */ +-void DES_encrypt2(DES_LONG *data, DES_key_schedule *ks, int enc); +- +-void DES_encrypt3(DES_LONG *data, DES_key_schedule *ks1, +- DES_key_schedule *ks2, DES_key_schedule *ks3); +-void DES_decrypt3(DES_LONG *data, DES_key_schedule *ks1, +- DES_key_schedule *ks2, DES_key_schedule *ks3); +-void DES_ede3_cbc_encrypt(const unsigned char *input, unsigned char *output, +- long length, +- DES_key_schedule *ks1, DES_key_schedule *ks2, +- DES_key_schedule *ks3, DES_cblock *ivec, int enc); +-void DES_ede3_cfb64_encrypt(const unsigned char *in, unsigned char *out, +- long length, DES_key_schedule *ks1, +- DES_key_schedule *ks2, DES_key_schedule *ks3, +- DES_cblock *ivec, int *num, int enc); +-void DES_ede3_cfb_encrypt(const unsigned char *in, unsigned char *out, +- int numbits, long length, DES_key_schedule *ks1, +- DES_key_schedule *ks2, DES_key_schedule *ks3, +- DES_cblock *ivec, int enc); +-void DES_ede3_ofb64_encrypt(const unsigned char *in, unsigned char *out, +- long length, DES_key_schedule *ks1, +- DES_key_schedule *ks2, DES_key_schedule *ks3, +- DES_cblock *ivec, int *num); +-char *DES_fcrypt(const char *buf, const char *salt, char *ret); +-char *DES_crypt(const char *buf, const char *salt); +-void DES_ofb_encrypt(const unsigned char *in, unsigned char *out, int numbits, +- long length, DES_key_schedule *schedule, +- DES_cblock *ivec); +-void DES_pcbc_encrypt(const unsigned char *input, unsigned char *output, +- long length, DES_key_schedule *schedule, +- DES_cblock *ivec, int enc); +-DES_LONG DES_quad_cksum(const unsigned char *input, DES_cblock output[], +- long length, int out_count, DES_cblock *seed); +-int DES_random_key(DES_cblock *ret); +-void DES_set_odd_parity(DES_cblock *key); +-int DES_check_key_parity(const_DES_cblock *key); +-int DES_is_weak_key(const_DES_cblock *key); +-/* +- * DES_set_key (= set_key = DES_key_sched = key_sched) calls +- * DES_set_key_checked if global variable DES_check_key is set, +- * DES_set_key_unchecked otherwise. +- */ +-int DES_set_key(const_DES_cblock *key, DES_key_schedule *schedule); +-int DES_key_sched(const_DES_cblock *key, DES_key_schedule *schedule); +-int DES_set_key_checked(const_DES_cblock *key, DES_key_schedule *schedule); +-void DES_set_key_unchecked(const_DES_cblock *key, DES_key_schedule *schedule); +-void DES_string_to_key(const char *str, DES_cblock *key); +-void DES_string_to_2keys(const char *str, DES_cblock *key1, DES_cblock *key2); +-void DES_cfb64_encrypt(const unsigned char *in, unsigned char *out, +- long length, DES_key_schedule *schedule, +- DES_cblock *ivec, int *num, int enc); +-void DES_ofb64_encrypt(const unsigned char *in, unsigned char *out, +- long length, DES_key_schedule *schedule, +- DES_cblock *ivec, int *num); +- +-# define DES_fixup_key_parity DES_set_odd_parity +- +-# ifdef __cplusplus +-} +-# endif +-# endif +- +-#endif +diff --git a/uadk_tool/include/openssl/dh.h b/uadk_tool/include/openssl/dh.h +deleted file mode 100644 +index 3527540..0000000 +--- a/uadk_tool/include/openssl/dh.h ++++ /dev/null +@@ -1,340 +0,0 @@ +-/* +- * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_DH_H +-# define HEADER_DH_H +- +-# include +- +-# ifndef OPENSSL_NO_DH +-# include +-# include +-# include +-# include +-# if OPENSSL_API_COMPAT < 0x10100000L +-# include +-# endif +-# include +- +-# ifdef __cplusplus +-extern "C" { +-# endif +- +-# ifndef OPENSSL_DH_MAX_MODULUS_BITS +-# define OPENSSL_DH_MAX_MODULUS_BITS 10000 +-# endif +- +-# define OPENSSL_DH_FIPS_MIN_MODULUS_BITS 1024 +- +-# define DH_FLAG_CACHE_MONT_P 0x01 +- +-# if OPENSSL_API_COMPAT < 0x10100000L +-/* +- * Does nothing. Previously this switched off constant time behaviour. +- */ +-# define DH_FLAG_NO_EXP_CONSTTIME 0x00 +-# endif +- +-/* +- * If this flag is set the DH method is FIPS compliant and can be used in +- * FIPS mode. This is set in the validated module method. If an application +- * sets this flag in its own methods it is its responsibility to ensure the +- * result is compliant. +- */ +- +-# define DH_FLAG_FIPS_METHOD 0x0400 +- +-/* +- * If this flag is set the operations normally disabled in FIPS mode are +- * permitted it is then the applications responsibility to ensure that the +- * usage is compliant. +- */ +- +-# define DH_FLAG_NON_FIPS_ALLOW 0x0400 +- +-/* Already defined in ossl_typ.h */ +-/* typedef struct dh_st DH; */ +-/* typedef struct dh_method DH_METHOD; */ +- +-DECLARE_ASN1_ITEM(DHparams) +- +-# define DH_GENERATOR_2 2 +-/* #define DH_GENERATOR_3 3 */ +-# define DH_GENERATOR_5 5 +- +-/* DH_check error codes */ +-# define DH_CHECK_P_NOT_PRIME 0x01 +-# define DH_CHECK_P_NOT_SAFE_PRIME 0x02 +-# define DH_UNABLE_TO_CHECK_GENERATOR 0x04 +-# define DH_NOT_SUITABLE_GENERATOR 0x08 +-# define DH_CHECK_Q_NOT_PRIME 0x10 +-# define DH_CHECK_INVALID_Q_VALUE 0x20 +-# define DH_CHECK_INVALID_J_VALUE 0x40 +- +-/* DH_check_pub_key error codes */ +-# define DH_CHECK_PUBKEY_TOO_SMALL 0x01 +-# define DH_CHECK_PUBKEY_TOO_LARGE 0x02 +-# define DH_CHECK_PUBKEY_INVALID 0x04 +- +-/* +- * primes p where (p-1)/2 is prime too are called "safe"; we define this for +- * backward compatibility: +- */ +-# define DH_CHECK_P_NOT_STRONG_PRIME DH_CHECK_P_NOT_SAFE_PRIME +- +-# define d2i_DHparams_fp(fp,x) \ +- (DH *)ASN1_d2i_fp((char *(*)())DH_new, \ +- (char *(*)())d2i_DHparams, \ +- (fp), \ +- (unsigned char **)(x)) +-# define i2d_DHparams_fp(fp,x) \ +- ASN1_i2d_fp(i2d_DHparams,(fp), (unsigned char *)(x)) +-# define d2i_DHparams_bio(bp,x) \ +- ASN1_d2i_bio_of(DH, DH_new, d2i_DHparams, bp, x) +-# define i2d_DHparams_bio(bp,x) \ +- ASN1_i2d_bio_of_const(DH,i2d_DHparams,bp,x) +- +-# define d2i_DHxparams_fp(fp,x) \ +- (DH *)ASN1_d2i_fp((char *(*)())DH_new, \ +- (char *(*)())d2i_DHxparams, \ +- (fp), \ +- (unsigned char **)(x)) +-# define i2d_DHxparams_fp(fp,x) \ +- ASN1_i2d_fp(i2d_DHxparams,(fp), (unsigned char *)(x)) +-# define d2i_DHxparams_bio(bp,x) \ +- ASN1_d2i_bio_of(DH, DH_new, d2i_DHxparams, bp, x) +-# define i2d_DHxparams_bio(bp,x) \ +- ASN1_i2d_bio_of_const(DH, i2d_DHxparams, bp, x) +- +-DH *DHparams_dup(DH *); +- +-const DH_METHOD *DH_OpenSSL(void); +- +-void DH_set_default_method(const DH_METHOD *meth); +-const DH_METHOD *DH_get_default_method(void); +-int DH_set_method(DH *dh, const DH_METHOD *meth); +-DH *DH_new_method(ENGINE *engine); +- +-DH *DH_new(void); +-void DH_free(DH *dh); +-int DH_up_ref(DH *dh); +-int DH_bits(const DH *dh); +-int DH_size(const DH *dh); +-int DH_security_bits(const DH *dh); +-#define DH_get_ex_new_index(l, p, newf, dupf, freef) \ +- CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_DH, l, p, newf, dupf, freef) +-int DH_set_ex_data(DH *d, int idx, void *arg); +-void *DH_get_ex_data(DH *d, int idx); +- +-/* Deprecated version */ +-DEPRECATEDIN_0_9_8(DH *DH_generate_parameters(int prime_len, int generator, +- void (*callback) (int, int, +- void *), +- void *cb_arg)) +- +-/* New version */ +-int DH_generate_parameters_ex(DH *dh, int prime_len, int generator, +- BN_GENCB *cb); +- +-int DH_check_params_ex(const DH *dh); +-int DH_check_ex(const DH *dh); +-int DH_check_pub_key_ex(const DH *dh, const BIGNUM *pub_key); +-int DH_check_params(const DH *dh, int *ret); +-int DH_check(const DH *dh, int *codes); +-int DH_check_pub_key(const DH *dh, const BIGNUM *pub_key, int *codes); +-int DH_generate_key(DH *dh); +-int DH_compute_key(unsigned char *key, const BIGNUM *pub_key, DH *dh); +-int DH_compute_key_padded(unsigned char *key, const BIGNUM *pub_key, DH *dh); +-DH *d2i_DHparams(DH **a, const unsigned char **pp, long length); +-int i2d_DHparams(const DH *a, unsigned char **pp); +-DH *d2i_DHxparams(DH **a, const unsigned char **pp, long length); +-int i2d_DHxparams(const DH *a, unsigned char **pp); +-# ifndef OPENSSL_NO_STDIO +-int DHparams_print_fp(FILE *fp, const DH *x); +-# endif +-int DHparams_print(BIO *bp, const DH *x); +- +-/* RFC 5114 parameters */ +-DH *DH_get_1024_160(void); +-DH *DH_get_2048_224(void); +-DH *DH_get_2048_256(void); +- +-/* Named parameters, currently RFC7919 */ +-DH *DH_new_by_nid(int nid); +-int DH_get_nid(const DH *dh); +- +-# ifndef OPENSSL_NO_CMS +-/* RFC2631 KDF */ +-int DH_KDF_X9_42(unsigned char *out, size_t outlen, +- const unsigned char *Z, size_t Zlen, +- ASN1_OBJECT *key_oid, +- const unsigned char *ukm, size_t ukmlen, const EVP_MD *md); +-# endif +- +-void DH_get0_pqg(const DH *dh, +- const BIGNUM **p, const BIGNUM **q, const BIGNUM **g); +-int DH_set0_pqg(DH *dh, BIGNUM *p, BIGNUM *q, BIGNUM *g); +-void DH_get0_key(const DH *dh, +- const BIGNUM **pub_key, const BIGNUM **priv_key); +-int DH_set0_key(DH *dh, BIGNUM *pub_key, BIGNUM *priv_key); +-const BIGNUM *DH_get0_p(const DH *dh); +-const BIGNUM *DH_get0_q(const DH *dh); +-const BIGNUM *DH_get0_g(const DH *dh); +-const BIGNUM *DH_get0_priv_key(const DH *dh); +-const BIGNUM *DH_get0_pub_key(const DH *dh); +-void DH_clear_flags(DH *dh, int flags); +-int DH_test_flags(const DH *dh, int flags); +-void DH_set_flags(DH *dh, int flags); +-ENGINE *DH_get0_engine(DH *d); +-long DH_get_length(const DH *dh); +-int DH_set_length(DH *dh, long length); +- +-DH_METHOD *DH_meth_new(const char *name, int flags); +-void DH_meth_free(DH_METHOD *dhm); +-DH_METHOD *DH_meth_dup(const DH_METHOD *dhm); +-const char *DH_meth_get0_name(const DH_METHOD *dhm); +-int DH_meth_set1_name(DH_METHOD *dhm, const char *name); +-int DH_meth_get_flags(const DH_METHOD *dhm); +-int DH_meth_set_flags(DH_METHOD *dhm, int flags); +-void *DH_meth_get0_app_data(const DH_METHOD *dhm); +-int DH_meth_set0_app_data(DH_METHOD *dhm, void *app_data); +-int (*DH_meth_get_generate_key(const DH_METHOD *dhm)) (DH *); +-int DH_meth_set_generate_key(DH_METHOD *dhm, int (*generate_key) (DH *)); +-int (*DH_meth_get_compute_key(const DH_METHOD *dhm)) +- (unsigned char *key, const BIGNUM *pub_key, DH *dh); +-int DH_meth_set_compute_key(DH_METHOD *dhm, +- int (*compute_key) (unsigned char *key, const BIGNUM *pub_key, DH *dh)); +-int (*DH_meth_get_bn_mod_exp(const DH_METHOD *dhm)) +- (const DH *, BIGNUM *, const BIGNUM *, const BIGNUM *, const BIGNUM *, +- BN_CTX *, BN_MONT_CTX *); +-int DH_meth_set_bn_mod_exp(DH_METHOD *dhm, +- int (*bn_mod_exp) (const DH *, BIGNUM *, const BIGNUM *, const BIGNUM *, +- const BIGNUM *, BN_CTX *, BN_MONT_CTX *)); +-int (*DH_meth_get_init(const DH_METHOD *dhm))(DH *); +-int DH_meth_set_init(DH_METHOD *dhm, int (*init)(DH *)); +-int (*DH_meth_get_finish(const DH_METHOD *dhm)) (DH *); +-int DH_meth_set_finish(DH_METHOD *dhm, int (*finish) (DH *)); +-int (*DH_meth_get_generate_params(const DH_METHOD *dhm)) +- (DH *, int, int, BN_GENCB *); +-int DH_meth_set_generate_params(DH_METHOD *dhm, +- int (*generate_params) (DH *, int, int, BN_GENCB *)); +- +- +-# define EVP_PKEY_CTX_set_dh_paramgen_prime_len(ctx, len) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN, \ +- EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN, len, NULL) +- +-# define EVP_PKEY_CTX_set_dh_paramgen_subprime_len(ctx, len) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN, \ +- EVP_PKEY_CTRL_DH_PARAMGEN_SUBPRIME_LEN, len, NULL) +- +-# define EVP_PKEY_CTX_set_dh_paramgen_type(ctx, typ) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN, \ +- EVP_PKEY_CTRL_DH_PARAMGEN_TYPE, typ, NULL) +- +-# define EVP_PKEY_CTX_set_dh_paramgen_generator(ctx, gen) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN, \ +- EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR, gen, NULL) +- +-# define EVP_PKEY_CTX_set_dh_rfc5114(ctx, gen) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_PARAMGEN, \ +- EVP_PKEY_CTRL_DH_RFC5114, gen, NULL) +- +-# define EVP_PKEY_CTX_set_dhx_rfc5114(ctx, gen) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_PARAMGEN, \ +- EVP_PKEY_CTRL_DH_RFC5114, gen, NULL) +- +-# define EVP_PKEY_CTX_set_dh_nid(ctx, nid) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, \ +- EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN, \ +- EVP_PKEY_CTRL_DH_NID, nid, NULL) +- +-# define EVP_PKEY_CTX_set_dh_pad(ctx, pad) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_DH_PAD, pad, NULL) +- +-# define EVP_PKEY_CTX_set_dh_kdf_type(ctx, kdf) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ +- EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_DH_KDF_TYPE, kdf, NULL) +- +-# define EVP_PKEY_CTX_get_dh_kdf_type(ctx) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ +- EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_DH_KDF_TYPE, -2, NULL) +- +-# define EVP_PKEY_CTX_set0_dh_kdf_oid(ctx, oid) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ +- EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_DH_KDF_OID, 0, (void *)(oid)) +- +-# define EVP_PKEY_CTX_get0_dh_kdf_oid(ctx, poid) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ +- EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_GET_DH_KDF_OID, 0, (void *)(poid)) +- +-# define EVP_PKEY_CTX_set_dh_kdf_md(ctx, md) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ +- EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_DH_KDF_MD, 0, (void *)(md)) +- +-# define EVP_PKEY_CTX_get_dh_kdf_md(ctx, pmd) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ +- EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_GET_DH_KDF_MD, 0, (void *)(pmd)) +- +-# define EVP_PKEY_CTX_set_dh_kdf_outlen(ctx, len) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ +- EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_DH_KDF_OUTLEN, len, NULL) +- +-# define EVP_PKEY_CTX_get_dh_kdf_outlen(ctx, plen) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ +- EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_GET_DH_KDF_OUTLEN, 0, (void *)(plen)) +- +-# define EVP_PKEY_CTX_set0_dh_kdf_ukm(ctx, p, plen) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ +- EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_DH_KDF_UKM, plen, (void *)(p)) +- +-# define EVP_PKEY_CTX_get0_dh_kdf_ukm(ctx, p) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ +- EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_GET_DH_KDF_UKM, 0, (void *)(p)) +- +-# define EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN (EVP_PKEY_ALG_CTRL + 1) +-# define EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR (EVP_PKEY_ALG_CTRL + 2) +-# define EVP_PKEY_CTRL_DH_RFC5114 (EVP_PKEY_ALG_CTRL + 3) +-# define EVP_PKEY_CTRL_DH_PARAMGEN_SUBPRIME_LEN (EVP_PKEY_ALG_CTRL + 4) +-# define EVP_PKEY_CTRL_DH_PARAMGEN_TYPE (EVP_PKEY_ALG_CTRL + 5) +-# define EVP_PKEY_CTRL_DH_KDF_TYPE (EVP_PKEY_ALG_CTRL + 6) +-# define EVP_PKEY_CTRL_DH_KDF_MD (EVP_PKEY_ALG_CTRL + 7) +-# define EVP_PKEY_CTRL_GET_DH_KDF_MD (EVP_PKEY_ALG_CTRL + 8) +-# define EVP_PKEY_CTRL_DH_KDF_OUTLEN (EVP_PKEY_ALG_CTRL + 9) +-# define EVP_PKEY_CTRL_GET_DH_KDF_OUTLEN (EVP_PKEY_ALG_CTRL + 10) +-# define EVP_PKEY_CTRL_DH_KDF_UKM (EVP_PKEY_ALG_CTRL + 11) +-# define EVP_PKEY_CTRL_GET_DH_KDF_UKM (EVP_PKEY_ALG_CTRL + 12) +-# define EVP_PKEY_CTRL_DH_KDF_OID (EVP_PKEY_ALG_CTRL + 13) +-# define EVP_PKEY_CTRL_GET_DH_KDF_OID (EVP_PKEY_ALG_CTRL + 14) +-# define EVP_PKEY_CTRL_DH_NID (EVP_PKEY_ALG_CTRL + 15) +-# define EVP_PKEY_CTRL_DH_PAD (EVP_PKEY_ALG_CTRL + 16) +- +-/* KDF types */ +-# define EVP_PKEY_DH_KDF_NONE 1 +-# ifndef OPENSSL_NO_CMS +-# define EVP_PKEY_DH_KDF_X9_42 2 +-# endif +- +- +-# ifdef __cplusplus +-} +-# endif +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/dherr.h b/uadk_tool/include/openssl/dherr.h +deleted file mode 100644 +index 916b3be..0000000 +--- a/uadk_tool/include/openssl/dherr.h ++++ /dev/null +@@ -1,88 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_DHERR_H +-# define HEADER_DHERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# include +- +-# ifndef OPENSSL_NO_DH +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_DH_strings(void); +- +-/* +- * DH function codes. +- */ +-# define DH_F_COMPUTE_KEY 102 +-# define DH_F_DHPARAMS_PRINT_FP 101 +-# define DH_F_DH_BUILTIN_GENPARAMS 106 +-# define DH_F_DH_CHECK_EX 121 +-# define DH_F_DH_CHECK_PARAMS_EX 122 +-# define DH_F_DH_CHECK_PUB_KEY_EX 123 +-# define DH_F_DH_CMS_DECRYPT 114 +-# define DH_F_DH_CMS_SET_PEERKEY 115 +-# define DH_F_DH_CMS_SET_SHARED_INFO 116 +-# define DH_F_DH_METH_DUP 117 +-# define DH_F_DH_METH_NEW 118 +-# define DH_F_DH_METH_SET1_NAME 119 +-# define DH_F_DH_NEW_BY_NID 104 +-# define DH_F_DH_NEW_METHOD 105 +-# define DH_F_DH_PARAM_DECODE 107 +-# define DH_F_DH_PKEY_PUBLIC_CHECK 124 +-# define DH_F_DH_PRIV_DECODE 110 +-# define DH_F_DH_PRIV_ENCODE 111 +-# define DH_F_DH_PUB_DECODE 108 +-# define DH_F_DH_PUB_ENCODE 109 +-# define DH_F_DO_DH_PRINT 100 +-# define DH_F_GENERATE_KEY 103 +-# define DH_F_PKEY_DH_CTRL_STR 120 +-# define DH_F_PKEY_DH_DERIVE 112 +-# define DH_F_PKEY_DH_INIT 125 +-# define DH_F_PKEY_DH_KEYGEN 113 +- +-/* +- * DH reason codes. +- */ +-# define DH_R_BAD_GENERATOR 101 +-# define DH_R_BN_DECODE_ERROR 109 +-# define DH_R_BN_ERROR 106 +-# define DH_R_CHECK_INVALID_J_VALUE 115 +-# define DH_R_CHECK_INVALID_Q_VALUE 116 +-# define DH_R_CHECK_PUBKEY_INVALID 122 +-# define DH_R_CHECK_PUBKEY_TOO_LARGE 123 +-# define DH_R_CHECK_PUBKEY_TOO_SMALL 124 +-# define DH_R_CHECK_P_NOT_PRIME 117 +-# define DH_R_CHECK_P_NOT_SAFE_PRIME 118 +-# define DH_R_CHECK_Q_NOT_PRIME 119 +-# define DH_R_DECODE_ERROR 104 +-# define DH_R_INVALID_PARAMETER_NAME 110 +-# define DH_R_INVALID_PARAMETER_NID 114 +-# define DH_R_INVALID_PUBKEY 102 +-# define DH_R_KDF_PARAMETER_ERROR 112 +-# define DH_R_KEYS_NOT_SET 108 +-# define DH_R_MISSING_PUBKEY 125 +-# define DH_R_MODULUS_TOO_LARGE 103 +-# define DH_R_NOT_SUITABLE_GENERATOR 120 +-# define DH_R_NO_PARAMETERS_SET 107 +-# define DH_R_NO_PRIVATE_VALUE 100 +-# define DH_R_PARAMETER_ENCODING_ERROR 105 +-# define DH_R_PEER_KEY_ERROR 111 +-# define DH_R_SHARED_INFO_ERROR 113 +-# define DH_R_UNABLE_TO_CHECK_GENERATOR 121 +- +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/dsa.h b/uadk_tool/include/openssl/dsa.h +deleted file mode 100644 +index 6d8a18a..0000000 +--- a/uadk_tool/include/openssl/dsa.h ++++ /dev/null +@@ -1,244 +0,0 @@ +-/* +- * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_DSA_H +-# define HEADER_DSA_H +- +-# include +- +-# ifndef OPENSSL_NO_DSA +-# ifdef __cplusplus +-extern "C" { +-# endif +-# include +-# include +-# include +-# include +-# include +-# if OPENSSL_API_COMPAT < 0x10100000L +-# include +-# endif +-# include +- +-# ifndef OPENSSL_DSA_MAX_MODULUS_BITS +-# define OPENSSL_DSA_MAX_MODULUS_BITS 10000 +-# endif +- +-# define OPENSSL_DSA_FIPS_MIN_MODULUS_BITS 1024 +- +-# define DSA_FLAG_CACHE_MONT_P 0x01 +-# if OPENSSL_API_COMPAT < 0x10100000L +-/* +- * Does nothing. Previously this switched off constant time behaviour. +- */ +-# define DSA_FLAG_NO_EXP_CONSTTIME 0x00 +-# endif +- +-/* +- * If this flag is set the DSA method is FIPS compliant and can be used in +- * FIPS mode. This is set in the validated module method. If an application +- * sets this flag in its own methods it is its responsibility to ensure the +- * result is compliant. +- */ +- +-# define DSA_FLAG_FIPS_METHOD 0x0400 +- +-/* +- * If this flag is set the operations normally disabled in FIPS mode are +- * permitted it is then the applications responsibility to ensure that the +- * usage is compliant. +- */ +- +-# define DSA_FLAG_NON_FIPS_ALLOW 0x0400 +-# define DSA_FLAG_FIPS_CHECKED 0x0800 +- +-/* Already defined in ossl_typ.h */ +-/* typedef struct dsa_st DSA; */ +-/* typedef struct dsa_method DSA_METHOD; */ +- +-typedef struct DSA_SIG_st DSA_SIG; +- +-# define d2i_DSAparams_fp(fp,x) (DSA *)ASN1_d2i_fp((char *(*)())DSA_new, \ +- (char *(*)())d2i_DSAparams,(fp),(unsigned char **)(x)) +-# define i2d_DSAparams_fp(fp,x) ASN1_i2d_fp(i2d_DSAparams,(fp), \ +- (unsigned char *)(x)) +-# define d2i_DSAparams_bio(bp,x) ASN1_d2i_bio_of(DSA,DSA_new,d2i_DSAparams,bp,x) +-# define i2d_DSAparams_bio(bp,x) ASN1_i2d_bio_of_const(DSA,i2d_DSAparams,bp,x) +- +-DSA *DSAparams_dup(DSA *x); +-DSA_SIG *DSA_SIG_new(void); +-void DSA_SIG_free(DSA_SIG *a); +-int i2d_DSA_SIG(const DSA_SIG *a, unsigned char **pp); +-DSA_SIG *d2i_DSA_SIG(DSA_SIG **v, const unsigned char **pp, long length); +-void DSA_SIG_get0(const DSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps); +-int DSA_SIG_set0(DSA_SIG *sig, BIGNUM *r, BIGNUM *s); +- +-DSA_SIG *DSA_do_sign(const unsigned char *dgst, int dlen, DSA *dsa); +-int DSA_do_verify(const unsigned char *dgst, int dgst_len, +- DSA_SIG *sig, DSA *dsa); +- +-const DSA_METHOD *DSA_OpenSSL(void); +- +-void DSA_set_default_method(const DSA_METHOD *); +-const DSA_METHOD *DSA_get_default_method(void); +-int DSA_set_method(DSA *dsa, const DSA_METHOD *); +-const DSA_METHOD *DSA_get_method(DSA *d); +- +-DSA *DSA_new(void); +-DSA *DSA_new_method(ENGINE *engine); +-void DSA_free(DSA *r); +-/* "up" the DSA object's reference count */ +-int DSA_up_ref(DSA *r); +-int DSA_size(const DSA *); +-int DSA_bits(const DSA *d); +-int DSA_security_bits(const DSA *d); +- /* next 4 return -1 on error */ +-DEPRECATEDIN_1_2_0(int DSA_sign_setup(DSA *dsa, BN_CTX *ctx_in, BIGNUM **kinvp, BIGNUM **rp)) +-int DSA_sign(int type, const unsigned char *dgst, int dlen, +- unsigned char *sig, unsigned int *siglen, DSA *dsa); +-int DSA_verify(int type, const unsigned char *dgst, int dgst_len, +- const unsigned char *sigbuf, int siglen, DSA *dsa); +-#define DSA_get_ex_new_index(l, p, newf, dupf, freef) \ +- CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_DSA, l, p, newf, dupf, freef) +-int DSA_set_ex_data(DSA *d, int idx, void *arg); +-void *DSA_get_ex_data(DSA *d, int idx); +- +-DSA *d2i_DSAPublicKey(DSA **a, const unsigned char **pp, long length); +-DSA *d2i_DSAPrivateKey(DSA **a, const unsigned char **pp, long length); +-DSA *d2i_DSAparams(DSA **a, const unsigned char **pp, long length); +- +-/* Deprecated version */ +-DEPRECATEDIN_0_9_8(DSA *DSA_generate_parameters(int bits, +- unsigned char *seed, +- int seed_len, +- int *counter_ret, +- unsigned long *h_ret, void +- (*callback) (int, int, +- void *), +- void *cb_arg)) +- +-/* New version */ +-int DSA_generate_parameters_ex(DSA *dsa, int bits, +- const unsigned char *seed, int seed_len, +- int *counter_ret, unsigned long *h_ret, +- BN_GENCB *cb); +- +-int DSA_generate_key(DSA *a); +-int i2d_DSAPublicKey(const DSA *a, unsigned char **pp); +-int i2d_DSAPrivateKey(const DSA *a, unsigned char **pp); +-int i2d_DSAparams(const DSA *a, unsigned char **pp); +- +-int DSAparams_print(BIO *bp, const DSA *x); +-int DSA_print(BIO *bp, const DSA *x, int off); +-# ifndef OPENSSL_NO_STDIO +-int DSAparams_print_fp(FILE *fp, const DSA *x); +-int DSA_print_fp(FILE *bp, const DSA *x, int off); +-# endif +- +-# define DSS_prime_checks 64 +-/* +- * Primality test according to FIPS PUB 186-4, Appendix C.3. Since we only +- * have one value here we set the number of checks to 64 which is the 128 bit +- * security level that is the highest level and valid for creating a 3072 bit +- * DSA key. +- */ +-# define DSA_is_prime(n, callback, cb_arg) \ +- BN_is_prime(n, DSS_prime_checks, callback, NULL, cb_arg) +- +-# ifndef OPENSSL_NO_DH +-/* +- * Convert DSA structure (key or just parameters) into DH structure (be +- * careful to avoid small subgroup attacks when using this!) +- */ +-DH *DSA_dup_DH(const DSA *r); +-# endif +- +-# define EVP_PKEY_CTX_set_dsa_paramgen_bits(ctx, nbits) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DSA, EVP_PKEY_OP_PARAMGEN, \ +- EVP_PKEY_CTRL_DSA_PARAMGEN_BITS, nbits, NULL) +-# define EVP_PKEY_CTX_set_dsa_paramgen_q_bits(ctx, qbits) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DSA, EVP_PKEY_OP_PARAMGEN, \ +- EVP_PKEY_CTRL_DSA_PARAMGEN_Q_BITS, qbits, NULL) +-# define EVP_PKEY_CTX_set_dsa_paramgen_md(ctx, md) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DSA, EVP_PKEY_OP_PARAMGEN, \ +- EVP_PKEY_CTRL_DSA_PARAMGEN_MD, 0, (void *)(md)) +- +-# define EVP_PKEY_CTRL_DSA_PARAMGEN_BITS (EVP_PKEY_ALG_CTRL + 1) +-# define EVP_PKEY_CTRL_DSA_PARAMGEN_Q_BITS (EVP_PKEY_ALG_CTRL + 2) +-# define EVP_PKEY_CTRL_DSA_PARAMGEN_MD (EVP_PKEY_ALG_CTRL + 3) +- +-void DSA_get0_pqg(const DSA *d, +- const BIGNUM **p, const BIGNUM **q, const BIGNUM **g); +-int DSA_set0_pqg(DSA *d, BIGNUM *p, BIGNUM *q, BIGNUM *g); +-void DSA_get0_key(const DSA *d, +- const BIGNUM **pub_key, const BIGNUM **priv_key); +-int DSA_set0_key(DSA *d, BIGNUM *pub_key, BIGNUM *priv_key); +-const BIGNUM *DSA_get0_p(const DSA *d); +-const BIGNUM *DSA_get0_q(const DSA *d); +-const BIGNUM *DSA_get0_g(const DSA *d); +-const BIGNUM *DSA_get0_pub_key(const DSA *d); +-const BIGNUM *DSA_get0_priv_key(const DSA *d); +-void DSA_clear_flags(DSA *d, int flags); +-int DSA_test_flags(const DSA *d, int flags); +-void DSA_set_flags(DSA *d, int flags); +-ENGINE *DSA_get0_engine(DSA *d); +- +-DSA_METHOD *DSA_meth_new(const char *name, int flags); +-void DSA_meth_free(DSA_METHOD *dsam); +-DSA_METHOD *DSA_meth_dup(const DSA_METHOD *dsam); +-const char *DSA_meth_get0_name(const DSA_METHOD *dsam); +-int DSA_meth_set1_name(DSA_METHOD *dsam, const char *name); +-int DSA_meth_get_flags(const DSA_METHOD *dsam); +-int DSA_meth_set_flags(DSA_METHOD *dsam, int flags); +-void *DSA_meth_get0_app_data(const DSA_METHOD *dsam); +-int DSA_meth_set0_app_data(DSA_METHOD *dsam, void *app_data); +-DSA_SIG *(*DSA_meth_get_sign(const DSA_METHOD *dsam)) +- (const unsigned char *, int, DSA *); +-int DSA_meth_set_sign(DSA_METHOD *dsam, +- DSA_SIG *(*sign) (const unsigned char *, int, DSA *)); +-int (*DSA_meth_get_sign_setup(const DSA_METHOD *dsam)) +- (DSA *, BN_CTX *, BIGNUM **, BIGNUM **); +-int DSA_meth_set_sign_setup(DSA_METHOD *dsam, +- int (*sign_setup) (DSA *, BN_CTX *, BIGNUM **, BIGNUM **)); +-int (*DSA_meth_get_verify(const DSA_METHOD *dsam)) +- (const unsigned char *, int, DSA_SIG *, DSA *); +-int DSA_meth_set_verify(DSA_METHOD *dsam, +- int (*verify) (const unsigned char *, int, DSA_SIG *, DSA *)); +-int (*DSA_meth_get_mod_exp(const DSA_METHOD *dsam)) +- (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *, const BIGNUM *, +- const BIGNUM *, const BIGNUM *, BN_CTX *, BN_MONT_CTX *); +-int DSA_meth_set_mod_exp(DSA_METHOD *dsam, +- int (*mod_exp) (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *, +- const BIGNUM *, const BIGNUM *, const BIGNUM *, BN_CTX *, +- BN_MONT_CTX *)); +-int (*DSA_meth_get_bn_mod_exp(const DSA_METHOD *dsam)) +- (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *, const BIGNUM *, +- BN_CTX *, BN_MONT_CTX *); +-int DSA_meth_set_bn_mod_exp(DSA_METHOD *dsam, +- int (*bn_mod_exp) (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *, +- const BIGNUM *, BN_CTX *, BN_MONT_CTX *)); +-int (*DSA_meth_get_init(const DSA_METHOD *dsam))(DSA *); +-int DSA_meth_set_init(DSA_METHOD *dsam, int (*init)(DSA *)); +-int (*DSA_meth_get_finish(const DSA_METHOD *dsam)) (DSA *); +-int DSA_meth_set_finish(DSA_METHOD *dsam, int (*finish) (DSA *)); +-int (*DSA_meth_get_paramgen(const DSA_METHOD *dsam)) +- (DSA *, int, const unsigned char *, int, int *, unsigned long *, +- BN_GENCB *); +-int DSA_meth_set_paramgen(DSA_METHOD *dsam, +- int (*paramgen) (DSA *, int, const unsigned char *, int, int *, +- unsigned long *, BN_GENCB *)); +-int (*DSA_meth_get_keygen(const DSA_METHOD *dsam)) (DSA *); +-int DSA_meth_set_keygen(DSA_METHOD *dsam, int (*keygen) (DSA *)); +- +- +-# ifdef __cplusplus +-} +-# endif +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/dsaerr.h b/uadk_tool/include/openssl/dsaerr.h +deleted file mode 100644 +index 495a1ac..0000000 +--- a/uadk_tool/include/openssl/dsaerr.h ++++ /dev/null +@@ -1,72 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_DSAERR_H +-# define HEADER_DSAERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# include +- +-# ifndef OPENSSL_NO_DSA +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_DSA_strings(void); +- +-/* +- * DSA function codes. +- */ +-# define DSA_F_DSAPARAMS_PRINT 100 +-# define DSA_F_DSAPARAMS_PRINT_FP 101 +-# define DSA_F_DSA_BUILTIN_PARAMGEN 125 +-# define DSA_F_DSA_BUILTIN_PARAMGEN2 126 +-# define DSA_F_DSA_DO_SIGN 112 +-# define DSA_F_DSA_DO_VERIFY 113 +-# define DSA_F_DSA_METH_DUP 127 +-# define DSA_F_DSA_METH_NEW 128 +-# define DSA_F_DSA_METH_SET1_NAME 129 +-# define DSA_F_DSA_NEW_METHOD 103 +-# define DSA_F_DSA_PARAM_DECODE 119 +-# define DSA_F_DSA_PRINT_FP 105 +-# define DSA_F_DSA_PRIV_DECODE 115 +-# define DSA_F_DSA_PRIV_ENCODE 116 +-# define DSA_F_DSA_PUB_DECODE 117 +-# define DSA_F_DSA_PUB_ENCODE 118 +-# define DSA_F_DSA_SIGN 106 +-# define DSA_F_DSA_SIGN_SETUP 107 +-# define DSA_F_DSA_SIG_NEW 102 +-# define DSA_F_OLD_DSA_PRIV_DECODE 122 +-# define DSA_F_PKEY_DSA_CTRL 120 +-# define DSA_F_PKEY_DSA_CTRL_STR 104 +-# define DSA_F_PKEY_DSA_KEYGEN 121 +- +-/* +- * DSA reason codes. +- */ +-# define DSA_R_BAD_Q_VALUE 102 +-# define DSA_R_BN_DECODE_ERROR 108 +-# define DSA_R_BN_ERROR 109 +-# define DSA_R_DECODE_ERROR 104 +-# define DSA_R_INVALID_DIGEST_TYPE 106 +-# define DSA_R_INVALID_PARAMETERS 112 +-# define DSA_R_MISSING_PARAMETERS 101 +-# define DSA_R_MISSING_PRIVATE_KEY 111 +-# define DSA_R_MODULUS_TOO_LARGE 103 +-# define DSA_R_NO_PARAMETERS_SET 107 +-# define DSA_R_PARAMETER_ENCODING_ERROR 105 +-# define DSA_R_Q_NOT_PRIME 113 +-# define DSA_R_SEED_LEN_SMALL 110 +- +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/dtls1.h b/uadk_tool/include/openssl/dtls1.h +deleted file mode 100644 +index d55ca9c..0000000 +--- a/uadk_tool/include/openssl/dtls1.h ++++ /dev/null +@@ -1,55 +0,0 @@ +-/* +- * Copyright 2005-2018 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_DTLS1_H +-# define HEADER_DTLS1_H +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-# define DTLS1_VERSION 0xFEFF +-# define DTLS1_2_VERSION 0xFEFD +-# define DTLS_MIN_VERSION DTLS1_VERSION +-# define DTLS_MAX_VERSION DTLS1_2_VERSION +-# define DTLS1_VERSION_MAJOR 0xFE +- +-# define DTLS1_BAD_VER 0x0100 +- +-/* Special value for method supporting multiple versions */ +-# define DTLS_ANY_VERSION 0x1FFFF +- +-/* lengths of messages */ +-/* +- * Actually the max cookie length in DTLS is 255. But we can't change this now +- * due to compatibility concerns. +- */ +-# define DTLS1_COOKIE_LENGTH 256 +- +-# define DTLS1_RT_HEADER_LENGTH 13 +- +-# define DTLS1_HM_HEADER_LENGTH 12 +- +-# define DTLS1_HM_BAD_FRAGMENT -2 +-# define DTLS1_HM_FRAGMENT_RETRY -3 +- +-# define DTLS1_CCS_HEADER_LENGTH 1 +- +-# define DTLS1_AL_HEADER_LENGTH 2 +- +-/* Timeout multipliers */ +-# define DTLS1_TMO_READ_COUNT 2 +-# define DTLS1_TMO_WRITE_COUNT 2 +- +-# define DTLS1_TMO_ALERT_COUNT 12 +- +-#ifdef __cplusplus +-} +-#endif +-#endif +diff --git a/uadk_tool/include/openssl/e_os2.h b/uadk_tool/include/openssl/e_os2.h +deleted file mode 100644 +index 5c88e51..0000000 +--- a/uadk_tool/include/openssl/e_os2.h ++++ /dev/null +@@ -1,301 +0,0 @@ +-/* +- * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_E_OS2_H +-# define HEADER_E_OS2_H +- +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-/****************************************************************************** +- * Detect operating systems. This probably needs completing. +- * The result is that at least one OPENSSL_SYS_os macro should be defined. +- * However, if none is defined, Unix is assumed. +- **/ +- +-# define OPENSSL_SYS_UNIX +- +-/* --------------------- Microsoft operating systems ---------------------- */ +- +-/* +- * Note that MSDOS actually denotes 32-bit environments running on top of +- * MS-DOS, such as DJGPP one. +- */ +-# if defined(OPENSSL_SYS_MSDOS) +-# undef OPENSSL_SYS_UNIX +-# endif +- +-/* +- * For 32 bit environment, there seems to be the CygWin environment and then +- * all the others that try to do the same thing Microsoft does... +- */ +-/* +- * UEFI lives here because it might be built with a Microsoft toolchain and +- * we need to avoid the false positive match on Windows. +- */ +-# if defined(OPENSSL_SYS_UEFI) +-# undef OPENSSL_SYS_UNIX +-# elif defined(OPENSSL_SYS_UWIN) +-# undef OPENSSL_SYS_UNIX +-# define OPENSSL_SYS_WIN32_UWIN +-# else +-# if defined(__CYGWIN__) || defined(OPENSSL_SYS_CYGWIN) +-# define OPENSSL_SYS_WIN32_CYGWIN +-# else +-# if defined(_WIN32) || defined(OPENSSL_SYS_WIN32) +-# undef OPENSSL_SYS_UNIX +-# if !defined(OPENSSL_SYS_WIN32) +-# define OPENSSL_SYS_WIN32 +-# endif +-# endif +-# if defined(_WIN64) || defined(OPENSSL_SYS_WIN64) +-# undef OPENSSL_SYS_UNIX +-# if !defined(OPENSSL_SYS_WIN64) +-# define OPENSSL_SYS_WIN64 +-# endif +-# endif +-# if defined(OPENSSL_SYS_WINNT) +-# undef OPENSSL_SYS_UNIX +-# endif +-# if defined(OPENSSL_SYS_WINCE) +-# undef OPENSSL_SYS_UNIX +-# endif +-# endif +-# endif +- +-/* Anything that tries to look like Microsoft is "Windows" */ +-# if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN64) || defined(OPENSSL_SYS_WINNT) || defined(OPENSSL_SYS_WINCE) +-# undef OPENSSL_SYS_UNIX +-# define OPENSSL_SYS_WINDOWS +-# ifndef OPENSSL_SYS_MSDOS +-# define OPENSSL_SYS_MSDOS +-# endif +-# endif +- +-/* +- * DLL settings. This part is a bit tough, because it's up to the +- * application implementor how he or she will link the application, so it +- * requires some macro to be used. +- */ +-# ifdef OPENSSL_SYS_WINDOWS +-# ifndef OPENSSL_OPT_WINDLL +-# if defined(_WINDLL) /* This is used when building OpenSSL to +- * indicate that DLL linkage should be used */ +-# define OPENSSL_OPT_WINDLL +-# endif +-# endif +-# endif +- +-/* ------------------------------- OpenVMS -------------------------------- */ +-# if defined(__VMS) || defined(VMS) || defined(OPENSSL_SYS_VMS) +-# if !defined(OPENSSL_SYS_VMS) +-# undef OPENSSL_SYS_UNIX +-# endif +-# define OPENSSL_SYS_VMS +-# if defined(__DECC) +-# define OPENSSL_SYS_VMS_DECC +-# elif defined(__DECCXX) +-# define OPENSSL_SYS_VMS_DECC +-# define OPENSSL_SYS_VMS_DECCXX +-# else +-# define OPENSSL_SYS_VMS_NODECC +-# endif +-# endif +- +-/* -------------------------------- Unix ---------------------------------- */ +-# ifdef OPENSSL_SYS_UNIX +-# if defined(linux) || defined(__linux__) && !defined(OPENSSL_SYS_LINUX) +-# define OPENSSL_SYS_LINUX +-# endif +-# if defined(_AIX) && !defined(OPENSSL_SYS_AIX) +-# define OPENSSL_SYS_AIX +-# endif +-# endif +- +-/* -------------------------------- VOS ----------------------------------- */ +-# if defined(__VOS__) && !defined(OPENSSL_SYS_VOS) +-# define OPENSSL_SYS_VOS +-# ifdef __HPPA__ +-# define OPENSSL_SYS_VOS_HPPA +-# endif +-# ifdef __IA32__ +-# define OPENSSL_SYS_VOS_IA32 +-# endif +-# endif +- +-/** +- * That's it for OS-specific stuff +- *****************************************************************************/ +- +-/* Specials for I/O an exit */ +-# ifdef OPENSSL_SYS_MSDOS +-# define OPENSSL_UNISTD_IO +-# define OPENSSL_DECLARE_EXIT extern void exit(int); +-# else +-# define OPENSSL_UNISTD_IO OPENSSL_UNISTD +-# define OPENSSL_DECLARE_EXIT /* declared in unistd.h */ +-# endif +- +-/*- +- * OPENSSL_EXTERN is normally used to declare a symbol with possible extra +- * attributes to handle its presence in a shared library. +- * OPENSSL_EXPORT is used to define a symbol with extra possible attributes +- * to make it visible in a shared library. +- * Care needs to be taken when a header file is used both to declare and +- * define symbols. Basically, for any library that exports some global +- * variables, the following code must be present in the header file that +- * declares them, before OPENSSL_EXTERN is used: +- * +- * #ifdef SOME_BUILD_FLAG_MACRO +- * # undef OPENSSL_EXTERN +- * # define OPENSSL_EXTERN OPENSSL_EXPORT +- * #endif +- * +- * The default is to have OPENSSL_EXPORT and OPENSSL_EXTERN +- * have some generally sensible values. +- */ +- +-# if defined(OPENSSL_SYS_WINDOWS) && defined(OPENSSL_OPT_WINDLL) +-# define OPENSSL_EXPORT extern __declspec(dllexport) +-# define OPENSSL_EXTERN extern __declspec(dllimport) +-# else +-# define OPENSSL_EXPORT extern +-# define OPENSSL_EXTERN extern +-# endif +- +-/*- +- * Macros to allow global variables to be reached through function calls when +- * required (if a shared library version requires it, for example. +- * The way it's done allows definitions like this: +- * +- * // in foobar.c +- * OPENSSL_IMPLEMENT_GLOBAL(int,foobar,0) +- * // in foobar.h +- * OPENSSL_DECLARE_GLOBAL(int,foobar); +- * #define foobar OPENSSL_GLOBAL_REF(foobar) +- */ +-# ifdef OPENSSL_EXPORT_VAR_AS_FUNCTION +-# define OPENSSL_IMPLEMENT_GLOBAL(type,name,value) \ +- type *_shadow_##name(void) \ +- { static type _hide_##name=value; return &_hide_##name; } +-# define OPENSSL_DECLARE_GLOBAL(type,name) type *_shadow_##name(void) +-# define OPENSSL_GLOBAL_REF(name) (*(_shadow_##name())) +-# else +-# define OPENSSL_IMPLEMENT_GLOBAL(type,name,value) type _shadow_##name=value; +-# define OPENSSL_DECLARE_GLOBAL(type,name) OPENSSL_EXPORT type _shadow_##name +-# define OPENSSL_GLOBAL_REF(name) _shadow_##name +-# endif +- +-# ifdef _WIN32 +-# ifdef _WIN64 +-# define ossl_ssize_t __int64 +-# define OSSL_SSIZE_MAX _I64_MAX +-# else +-# define ossl_ssize_t int +-# define OSSL_SSIZE_MAX INT_MAX +-# endif +-# endif +- +-# if defined(OPENSSL_SYS_UEFI) && !defined(ossl_ssize_t) +-# define ossl_ssize_t INTN +-# define OSSL_SSIZE_MAX MAX_INTN +-# endif +- +-# ifndef ossl_ssize_t +-# define ossl_ssize_t ssize_t +-# if defined(SSIZE_MAX) +-# define OSSL_SSIZE_MAX SSIZE_MAX +-# elif defined(_POSIX_SSIZE_MAX) +-# define OSSL_SSIZE_MAX _POSIX_SSIZE_MAX +-# else +-# define OSSL_SSIZE_MAX ((ssize_t)(SIZE_MAX>>1)) +-# endif +-# endif +- +-# ifdef DEBUG_UNUSED +-# define __owur __attribute__((__warn_unused_result__)) +-# else +-# define __owur +-# endif +- +-/* Standard integer types */ +-# if defined(OPENSSL_SYS_UEFI) +-typedef INT8 int8_t; +-typedef UINT8 uint8_t; +-typedef INT16 int16_t; +-typedef UINT16 uint16_t; +-typedef INT32 int32_t; +-typedef UINT32 uint32_t; +-typedef INT64 int64_t; +-typedef UINT64 uint64_t; +-# elif (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || \ +- defined(__osf__) || defined(__sgi) || defined(__hpux) || \ +- defined(OPENSSL_SYS_VMS) || defined (__OpenBSD__) +-# include +-# elif defined(_MSC_VER) && _MSC_VER<1600 +-/* +- * minimally required typdefs for systems not supporting inttypes.h or +- * stdint.h: currently just older VC++ +- */ +-typedef signed char int8_t; +-typedef unsigned char uint8_t; +-typedef short int16_t; +-typedef unsigned short uint16_t; +-typedef int int32_t; +-typedef unsigned int uint32_t; +-typedef __int64 int64_t; +-typedef unsigned __int64 uint64_t; +-# else +-# include +-# endif +- +-/* ossl_inline: portable inline definition usable in public headers */ +-# if !defined(inline) && !defined(__cplusplus) +-# if defined(__STDC_VERSION__) && __STDC_VERSION__>=199901L +- /* just use inline */ +-# define ossl_inline inline +-# elif defined(__GNUC__) && __GNUC__>=2 +-# define ossl_inline __inline__ +-# elif defined(_MSC_VER) +- /* +- * Visual Studio: inline is available in C++ only, however +- * __inline is available for C, see +- * http://msdn.microsoft.com/en-us/library/z8y1yy88.aspx +- */ +-# define ossl_inline __inline +-# else +-# define ossl_inline +-# endif +-# else +-# define ossl_inline inline +-# endif +- +-# if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && \ +- !defined(__cplusplus) +-# define ossl_noreturn _Noreturn +-# elif defined(__GNUC__) && __GNUC__ >= 2 +-# define ossl_noreturn __attribute__((noreturn)) +-# else +-# define ossl_noreturn +-# endif +- +-/* ossl_unused: portable unused attribute for use in public headers */ +-# if defined(__GNUC__) +-# define ossl_unused __attribute__((unused)) +-# else +-# define ossl_unused +-# endif +- +-#ifdef __cplusplus +-} +-#endif +-#endif +diff --git a/uadk_tool/include/openssl/ebcdic.h b/uadk_tool/include/openssl/ebcdic.h +deleted file mode 100644 +index aa01285..0000000 +--- a/uadk_tool/include/openssl/ebcdic.h ++++ /dev/null +@@ -1,33 +0,0 @@ +-/* +- * Copyright 1999-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_EBCDIC_H +-# define HEADER_EBCDIC_H +- +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-/* Avoid name clashes with other applications */ +-# define os_toascii _openssl_os_toascii +-# define os_toebcdic _openssl_os_toebcdic +-# define ebcdic2ascii _openssl_ebcdic2ascii +-# define ascii2ebcdic _openssl_ascii2ebcdic +- +-extern const unsigned char os_toascii[256]; +-extern const unsigned char os_toebcdic[256]; +-void *ebcdic2ascii(void *dest, const void *srce, size_t count); +-void *ascii2ebcdic(void *dest, const void *srce, size_t count); +- +-#ifdef __cplusplus +-} +-#endif +-#endif +diff --git a/uadk_tool/include/openssl/ec.h b/uadk_tool/include/openssl/ec.h +deleted file mode 100644 +index a9f77b2..0000000 +--- a/uadk_tool/include/openssl/ec.h ++++ /dev/null +@@ -1,1484 +0,0 @@ +-/* +- * Copyright 2002-2020 The OpenSSL Project Authors. All Rights Reserved. +- * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_EC_H +-# define HEADER_EC_H +- +-# include +- +-# ifndef OPENSSL_NO_EC +-# include +-# include +-# if OPENSSL_API_COMPAT < 0x10100000L +-# include +-# endif +-# include +-# ifdef __cplusplus +-extern "C" { +-# endif +- +-# ifndef OPENSSL_ECC_MAX_FIELD_BITS +-# define OPENSSL_ECC_MAX_FIELD_BITS 661 +-# endif +- +-/** Enum for the point conversion form as defined in X9.62 (ECDSA) +- * for the encoding of a elliptic curve point (x,y) */ +-typedef enum { +- /** the point is encoded as z||x, where the octet z specifies +- * which solution of the quadratic equation y is */ +- POINT_CONVERSION_COMPRESSED = 2, +- /** the point is encoded as z||x||y, where z is the octet 0x04 */ +- POINT_CONVERSION_UNCOMPRESSED = 4, +- /** the point is encoded as z||x||y, where the octet z specifies +- * which solution of the quadratic equation y is */ +- POINT_CONVERSION_HYBRID = 6 +-} point_conversion_form_t; +- +-typedef struct ec_method_st EC_METHOD; +-typedef struct ec_group_st EC_GROUP; +-typedef struct ec_point_st EC_POINT; +-typedef struct ecpk_parameters_st ECPKPARAMETERS; +-typedef struct ec_parameters_st ECPARAMETERS; +- +-/********************************************************************/ +-/* EC_METHODs for curves over GF(p) */ +-/********************************************************************/ +- +-/** Returns the basic GFp ec methods which provides the basis for the +- * optimized methods. +- * \return EC_METHOD object +- */ +-const EC_METHOD *EC_GFp_simple_method(void); +- +-/** Returns GFp methods using montgomery multiplication. +- * \return EC_METHOD object +- */ +-const EC_METHOD *EC_GFp_mont_method(void); +- +-/** Returns GFp methods using optimized methods for NIST recommended curves +- * \return EC_METHOD object +- */ +-const EC_METHOD *EC_GFp_nist_method(void); +- +-# ifndef OPENSSL_NO_EC_NISTP_64_GCC_128 +-/** Returns 64-bit optimized methods for nistp224 +- * \return EC_METHOD object +- */ +-const EC_METHOD *EC_GFp_nistp224_method(void); +- +-/** Returns 64-bit optimized methods for nistp256 +- * \return EC_METHOD object +- */ +-const EC_METHOD *EC_GFp_nistp256_method(void); +- +-/** Returns 64-bit optimized methods for nistp521 +- * \return EC_METHOD object +- */ +-const EC_METHOD *EC_GFp_nistp521_method(void); +-# endif +- +-# ifndef OPENSSL_NO_EC2M +-/********************************************************************/ +-/* EC_METHOD for curves over GF(2^m) */ +-/********************************************************************/ +- +-/** Returns the basic GF2m ec method +- * \return EC_METHOD object +- */ +-const EC_METHOD *EC_GF2m_simple_method(void); +- +-# endif +- +-/********************************************************************/ +-/* EC_GROUP functions */ +-/********************************************************************/ +- +-/** Creates a new EC_GROUP object +- * \param meth EC_METHOD to use +- * \return newly created EC_GROUP object or NULL in case of an error. +- */ +-EC_GROUP *EC_GROUP_new(const EC_METHOD *meth); +- +-/** Frees a EC_GROUP object +- * \param group EC_GROUP object to be freed. +- */ +-void EC_GROUP_free(EC_GROUP *group); +- +-/** Clears and frees a EC_GROUP object +- * \param group EC_GROUP object to be cleared and freed. +- */ +-void EC_GROUP_clear_free(EC_GROUP *group); +- +-/** Copies EC_GROUP objects. Note: both EC_GROUPs must use the same EC_METHOD. +- * \param dst destination EC_GROUP object +- * \param src source EC_GROUP object +- * \return 1 on success and 0 if an error occurred. +- */ +-int EC_GROUP_copy(EC_GROUP *dst, const EC_GROUP *src); +- +-/** Creates a new EC_GROUP object and copies the copies the content +- * form src to the newly created EC_KEY object +- * \param src source EC_GROUP object +- * \return newly created EC_GROUP object or NULL in case of an error. +- */ +-EC_GROUP *EC_GROUP_dup(const EC_GROUP *src); +- +-/** Returns the EC_METHOD of the EC_GROUP object. +- * \param group EC_GROUP object +- * \return EC_METHOD used in this EC_GROUP object. +- */ +-const EC_METHOD *EC_GROUP_method_of(const EC_GROUP *group); +- +-/** Returns the field type of the EC_METHOD. +- * \param meth EC_METHOD object +- * \return NID of the underlying field type OID. +- */ +-int EC_METHOD_get_field_type(const EC_METHOD *meth); +- +-/** Sets the generator and its order/cofactor of a EC_GROUP object. +- * \param group EC_GROUP object +- * \param generator EC_POINT object with the generator. +- * \param order the order of the group generated by the generator. +- * \param cofactor the index of the sub-group generated by the generator +- * in the group of all points on the elliptic curve. +- * \return 1 on success and 0 if an error occurred +- */ +-int EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator, +- const BIGNUM *order, const BIGNUM *cofactor); +- +-/** Returns the generator of a EC_GROUP object. +- * \param group EC_GROUP object +- * \return the currently used generator (possibly NULL). +- */ +-const EC_POINT *EC_GROUP_get0_generator(const EC_GROUP *group); +- +-/** Returns the montgomery data for order(Generator) +- * \param group EC_GROUP object +- * \return the currently used montgomery data (possibly NULL). +-*/ +-BN_MONT_CTX *EC_GROUP_get_mont_data(const EC_GROUP *group); +- +-/** Gets the order of a EC_GROUP +- * \param group EC_GROUP object +- * \param order BIGNUM to which the order is copied +- * \param ctx unused +- * \return 1 on success and 0 if an error occurred +- */ +-int EC_GROUP_get_order(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx); +- +-/** Gets the order of an EC_GROUP +- * \param group EC_GROUP object +- * \return the group order +- */ +-const BIGNUM *EC_GROUP_get0_order(const EC_GROUP *group); +- +-/** Gets the number of bits of the order of an EC_GROUP +- * \param group EC_GROUP object +- * \return number of bits of group order. +- */ +-int EC_GROUP_order_bits(const EC_GROUP *group); +- +-/** Gets the cofactor of a EC_GROUP +- * \param group EC_GROUP object +- * \param cofactor BIGNUM to which the cofactor is copied +- * \param ctx unused +- * \return 1 on success and 0 if an error occurred +- */ +-int EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor, +- BN_CTX *ctx); +- +-/** Gets the cofactor of an EC_GROUP +- * \param group EC_GROUP object +- * \return the group cofactor +- */ +-const BIGNUM *EC_GROUP_get0_cofactor(const EC_GROUP *group); +- +-/** Sets the name of a EC_GROUP object +- * \param group EC_GROUP object +- * \param nid NID of the curve name OID +- */ +-void EC_GROUP_set_curve_name(EC_GROUP *group, int nid); +- +-/** Returns the curve name of a EC_GROUP object +- * \param group EC_GROUP object +- * \return NID of the curve name OID or 0 if not set. +- */ +-int EC_GROUP_get_curve_name(const EC_GROUP *group); +- +-void EC_GROUP_set_asn1_flag(EC_GROUP *group, int flag); +-int EC_GROUP_get_asn1_flag(const EC_GROUP *group); +- +-void EC_GROUP_set_point_conversion_form(EC_GROUP *group, +- point_conversion_form_t form); +-point_conversion_form_t EC_GROUP_get_point_conversion_form(const EC_GROUP *); +- +-unsigned char *EC_GROUP_get0_seed(const EC_GROUP *x); +-size_t EC_GROUP_get_seed_len(const EC_GROUP *); +-size_t EC_GROUP_set_seed(EC_GROUP *, const unsigned char *, size_t len); +- +-/** Sets the parameters of a ec curve defined by y^2 = x^3 + a*x + b (for GFp) +- * or y^2 + x*y = x^3 + a*x^2 + b (for GF2m) +- * \param group EC_GROUP object +- * \param p BIGNUM with the prime number (GFp) or the polynomial +- * defining the underlying field (GF2m) +- * \param a BIGNUM with parameter a of the equation +- * \param b BIGNUM with parameter b of the equation +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-int EC_GROUP_set_curve(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a, +- const BIGNUM *b, BN_CTX *ctx); +- +-/** Gets the parameters of the ec curve defined by y^2 = x^3 + a*x + b (for GFp) +- * or y^2 + x*y = x^3 + a*x^2 + b (for GF2m) +- * \param group EC_GROUP object +- * \param p BIGNUM with the prime number (GFp) or the polynomial +- * defining the underlying field (GF2m) +- * \param a BIGNUM for parameter a of the equation +- * \param b BIGNUM for parameter b of the equation +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-int EC_GROUP_get_curve(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b, +- BN_CTX *ctx); +- +-/** Sets the parameters of an ec curve. Synonym for EC_GROUP_set_curve +- * \param group EC_GROUP object +- * \param p BIGNUM with the prime number (GFp) or the polynomial +- * defining the underlying field (GF2m) +- * \param a BIGNUM with parameter a of the equation +- * \param b BIGNUM with parameter b of the equation +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-DEPRECATEDIN_1_2_0(int EC_GROUP_set_curve_GFp(EC_GROUP *group, const BIGNUM *p, +- const BIGNUM *a, const BIGNUM *b, +- BN_CTX *ctx)) +- +-/** Gets the parameters of an ec curve. Synonym for EC_GROUP_get_curve +- * \param group EC_GROUP object +- * \param p BIGNUM with the prime number (GFp) or the polynomial +- * defining the underlying field (GF2m) +- * \param a BIGNUM for parameter a of the equation +- * \param b BIGNUM for parameter b of the equation +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-DEPRECATEDIN_1_2_0(int EC_GROUP_get_curve_GFp(const EC_GROUP *group, BIGNUM *p, +- BIGNUM *a, BIGNUM *b, +- BN_CTX *ctx)) +- +-# ifndef OPENSSL_NO_EC2M +-/** Sets the parameter of an ec curve. Synonym for EC_GROUP_set_curve +- * \param group EC_GROUP object +- * \param p BIGNUM with the prime number (GFp) or the polynomial +- * defining the underlying field (GF2m) +- * \param a BIGNUM with parameter a of the equation +- * \param b BIGNUM with parameter b of the equation +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-DEPRECATEDIN_1_2_0(int EC_GROUP_set_curve_GF2m(EC_GROUP *group, const BIGNUM *p, +- const BIGNUM *a, const BIGNUM *b, +- BN_CTX *ctx)) +- +-/** Gets the parameters of an ec curve. Synonym for EC_GROUP_get_curve +- * \param group EC_GROUP object +- * \param p BIGNUM with the prime number (GFp) or the polynomial +- * defining the underlying field (GF2m) +- * \param a BIGNUM for parameter a of the equation +- * \param b BIGNUM for parameter b of the equation +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-DEPRECATEDIN_1_2_0(int EC_GROUP_get_curve_GF2m(const EC_GROUP *group, BIGNUM *p, +- BIGNUM *a, BIGNUM *b, +- BN_CTX *ctx)) +-# endif +-/** Returns the number of bits needed to represent a field element +- * \param group EC_GROUP object +- * \return number of bits needed to represent a field element +- */ +-int EC_GROUP_get_degree(const EC_GROUP *group); +- +-/** Checks whether the parameter in the EC_GROUP define a valid ec group +- * \param group EC_GROUP object +- * \param ctx BN_CTX object (optional) +- * \return 1 if group is a valid ec group and 0 otherwise +- */ +-int EC_GROUP_check(const EC_GROUP *group, BN_CTX *ctx); +- +-/** Checks whether the discriminant of the elliptic curve is zero or not +- * \param group EC_GROUP object +- * \param ctx BN_CTX object (optional) +- * \return 1 if the discriminant is not zero and 0 otherwise +- */ +-int EC_GROUP_check_discriminant(const EC_GROUP *group, BN_CTX *ctx); +- +-/** Compares two EC_GROUP objects +- * \param a first EC_GROUP object +- * \param b second EC_GROUP object +- * \param ctx BN_CTX object (optional) +- * \return 0 if the groups are equal, 1 if not, or -1 on error +- */ +-int EC_GROUP_cmp(const EC_GROUP *a, const EC_GROUP *b, BN_CTX *ctx); +- +-/* +- * EC_GROUP_new_GF*() calls EC_GROUP_new() and EC_GROUP_set_GF*() after +- * choosing an appropriate EC_METHOD +- */ +- +-/** Creates a new EC_GROUP object with the specified parameters defined +- * over GFp (defined by the equation y^2 = x^3 + a*x + b) +- * \param p BIGNUM with the prime number +- * \param a BIGNUM with the parameter a of the equation +- * \param b BIGNUM with the parameter b of the equation +- * \param ctx BN_CTX object (optional) +- * \return newly created EC_GROUP object with the specified parameters +- */ +-EC_GROUP *EC_GROUP_new_curve_GFp(const BIGNUM *p, const BIGNUM *a, +- const BIGNUM *b, BN_CTX *ctx); +-# ifndef OPENSSL_NO_EC2M +-/** Creates a new EC_GROUP object with the specified parameters defined +- * over GF2m (defined by the equation y^2 + x*y = x^3 + a*x^2 + b) +- * \param p BIGNUM with the polynomial defining the underlying field +- * \param a BIGNUM with the parameter a of the equation +- * \param b BIGNUM with the parameter b of the equation +- * \param ctx BN_CTX object (optional) +- * \return newly created EC_GROUP object with the specified parameters +- */ +-EC_GROUP *EC_GROUP_new_curve_GF2m(const BIGNUM *p, const BIGNUM *a, +- const BIGNUM *b, BN_CTX *ctx); +-# endif +- +-/** Creates a EC_GROUP object with a curve specified by a NID +- * \param nid NID of the OID of the curve name +- * \return newly created EC_GROUP object with specified curve or NULL +- * if an error occurred +- */ +-EC_GROUP *EC_GROUP_new_by_curve_name(int nid); +- +-/** Creates a new EC_GROUP object from an ECPARAMETERS object +- * \param params pointer to the ECPARAMETERS object +- * \return newly created EC_GROUP object with specified curve or NULL +- * if an error occurred +- */ +-EC_GROUP *EC_GROUP_new_from_ecparameters(const ECPARAMETERS *params); +- +-/** Creates an ECPARAMETERS object for the given EC_GROUP object. +- * \param group pointer to the EC_GROUP object +- * \param params pointer to an existing ECPARAMETERS object or NULL +- * \return pointer to the new ECPARAMETERS object or NULL +- * if an error occurred. +- */ +-ECPARAMETERS *EC_GROUP_get_ecparameters(const EC_GROUP *group, +- ECPARAMETERS *params); +- +-/** Creates a new EC_GROUP object from an ECPKPARAMETERS object +- * \param params pointer to an existing ECPKPARAMETERS object, or NULL +- * \return newly created EC_GROUP object with specified curve, or NULL +- * if an error occurred +- */ +-EC_GROUP *EC_GROUP_new_from_ecpkparameters(const ECPKPARAMETERS *params); +- +-/** Creates an ECPKPARAMETERS object for the given EC_GROUP object. +- * \param group pointer to the EC_GROUP object +- * \param params pointer to an existing ECPKPARAMETERS object or NULL +- * \return pointer to the new ECPKPARAMETERS object or NULL +- * if an error occurred. +- */ +-ECPKPARAMETERS *EC_GROUP_get_ecpkparameters(const EC_GROUP *group, +- ECPKPARAMETERS *params); +- +-/********************************************************************/ +-/* handling of internal curves */ +-/********************************************************************/ +- +-typedef struct { +- int nid; +- const char *comment; +-} EC_builtin_curve; +- +-/* +- * EC_builtin_curves(EC_builtin_curve *r, size_t size) returns number of all +- * available curves or zero if a error occurred. In case r is not zero, +- * nitems EC_builtin_curve structures are filled with the data of the first +- * nitems internal groups +- */ +-size_t EC_get_builtin_curves(EC_builtin_curve *r, size_t nitems); +- +-const char *EC_curve_nid2nist(int nid); +-int EC_curve_nist2nid(const char *name); +- +-/********************************************************************/ +-/* EC_POINT functions */ +-/********************************************************************/ +- +-/** Creates a new EC_POINT object for the specified EC_GROUP +- * \param group EC_GROUP the underlying EC_GROUP object +- * \return newly created EC_POINT object or NULL if an error occurred +- */ +-EC_POINT *EC_POINT_new(const EC_GROUP *group); +- +-/** Frees a EC_POINT object +- * \param point EC_POINT object to be freed +- */ +-void EC_POINT_free(EC_POINT *point); +- +-/** Clears and frees a EC_POINT object +- * \param point EC_POINT object to be cleared and freed +- */ +-void EC_POINT_clear_free(EC_POINT *point); +- +-/** Copies EC_POINT object +- * \param dst destination EC_POINT object +- * \param src source EC_POINT object +- * \return 1 on success and 0 if an error occurred +- */ +-int EC_POINT_copy(EC_POINT *dst, const EC_POINT *src); +- +-/** Creates a new EC_POINT object and copies the content of the supplied +- * EC_POINT +- * \param src source EC_POINT object +- * \param group underlying the EC_GROUP object +- * \return newly created EC_POINT object or NULL if an error occurred +- */ +-EC_POINT *EC_POINT_dup(const EC_POINT *src, const EC_GROUP *group); +- +-/** Returns the EC_METHOD used in EC_POINT object +- * \param point EC_POINT object +- * \return the EC_METHOD used +- */ +-const EC_METHOD *EC_POINT_method_of(const EC_POINT *point); +- +-/** Sets a point to infinity (neutral element) +- * \param group underlying EC_GROUP object +- * \param point EC_POINT to set to infinity +- * \return 1 on success and 0 if an error occurred +- */ +-int EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point); +- +-/** Sets the jacobian projective coordinates of a EC_POINT over GFp +- * \param group underlying EC_GROUP object +- * \param p EC_POINT object +- * \param x BIGNUM with the x-coordinate +- * \param y BIGNUM with the y-coordinate +- * \param z BIGNUM with the z-coordinate +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-int EC_POINT_set_Jprojective_coordinates_GFp(const EC_GROUP *group, +- EC_POINT *p, const BIGNUM *x, +- const BIGNUM *y, const BIGNUM *z, +- BN_CTX *ctx); +- +-/** Gets the jacobian projective coordinates of a EC_POINT over GFp +- * \param group underlying EC_GROUP object +- * \param p EC_POINT object +- * \param x BIGNUM for the x-coordinate +- * \param y BIGNUM for the y-coordinate +- * \param z BIGNUM for the z-coordinate +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-int EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP *group, +- const EC_POINT *p, BIGNUM *x, +- BIGNUM *y, BIGNUM *z, +- BN_CTX *ctx); +- +-/** Sets the affine coordinates of an EC_POINT +- * \param group underlying EC_GROUP object +- * \param p EC_POINT object +- * \param x BIGNUM with the x-coordinate +- * \param y BIGNUM with the y-coordinate +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-int EC_POINT_set_affine_coordinates(const EC_GROUP *group, EC_POINT *p, +- const BIGNUM *x, const BIGNUM *y, +- BN_CTX *ctx); +- +-/** Gets the affine coordinates of an EC_POINT. +- * \param group underlying EC_GROUP object +- * \param p EC_POINT object +- * \param x BIGNUM for the x-coordinate +- * \param y BIGNUM for the y-coordinate +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-int EC_POINT_get_affine_coordinates(const EC_GROUP *group, const EC_POINT *p, +- BIGNUM *x, BIGNUM *y, BN_CTX *ctx); +- +-/** Sets the affine coordinates of an EC_POINT. A synonym of +- * EC_POINT_set_affine_coordinates +- * \param group underlying EC_GROUP object +- * \param p EC_POINT object +- * \param x BIGNUM with the x-coordinate +- * \param y BIGNUM with the y-coordinate +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-DEPRECATEDIN_1_2_0(int EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group, +- EC_POINT *p, +- const BIGNUM *x, +- const BIGNUM *y, +- BN_CTX *ctx)) +- +-/** Gets the affine coordinates of an EC_POINT. A synonym of +- * EC_POINT_get_affine_coordinates +- * \param group underlying EC_GROUP object +- * \param p EC_POINT object +- * \param x BIGNUM for the x-coordinate +- * \param y BIGNUM for the y-coordinate +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-DEPRECATEDIN_1_2_0(int EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group, +- const EC_POINT *p, +- BIGNUM *x, +- BIGNUM *y, +- BN_CTX *ctx)) +- +-/** Sets the x9.62 compressed coordinates of a EC_POINT +- * \param group underlying EC_GROUP object +- * \param p EC_POINT object +- * \param x BIGNUM with x-coordinate +- * \param y_bit integer with the y-Bit (either 0 or 1) +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-int EC_POINT_set_compressed_coordinates(const EC_GROUP *group, EC_POINT *p, +- const BIGNUM *x, int y_bit, +- BN_CTX *ctx); +- +-/** Sets the x9.62 compressed coordinates of a EC_POINT. A synonym of +- * EC_POINT_set_compressed_coordinates +- * \param group underlying EC_GROUP object +- * \param p EC_POINT object +- * \param x BIGNUM with x-coordinate +- * \param y_bit integer with the y-Bit (either 0 or 1) +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-DEPRECATEDIN_1_2_0(int EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP *group, +- EC_POINT *p, +- const BIGNUM *x, +- int y_bit, +- BN_CTX *ctx)) +-# ifndef OPENSSL_NO_EC2M +-/** Sets the affine coordinates of an EC_POINT. A synonym of +- * EC_POINT_set_affine_coordinates +- * \param group underlying EC_GROUP object +- * \param p EC_POINT object +- * \param x BIGNUM with the x-coordinate +- * \param y BIGNUM with the y-coordinate +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-DEPRECATEDIN_1_2_0(int EC_POINT_set_affine_coordinates_GF2m(const EC_GROUP *group, +- EC_POINT *p, +- const BIGNUM *x, +- const BIGNUM *y, +- BN_CTX *ctx)) +- +-/** Gets the affine coordinates of an EC_POINT. A synonym of +- * EC_POINT_get_affine_coordinates +- * \param group underlying EC_GROUP object +- * \param p EC_POINT object +- * \param x BIGNUM for the x-coordinate +- * \param y BIGNUM for the y-coordinate +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-DEPRECATEDIN_1_2_0(int EC_POINT_get_affine_coordinates_GF2m(const EC_GROUP *group, +- const EC_POINT *p, +- BIGNUM *x, +- BIGNUM *y, +- BN_CTX *ctx)) +- +-/** Sets the x9.62 compressed coordinates of a EC_POINT. A synonym of +- * EC_POINT_set_compressed_coordinates +- * \param group underlying EC_GROUP object +- * \param p EC_POINT object +- * \param x BIGNUM with x-coordinate +- * \param y_bit integer with the y-Bit (either 0 or 1) +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-DEPRECATEDIN_1_2_0(int EC_POINT_set_compressed_coordinates_GF2m(const EC_GROUP *group, +- EC_POINT *p, +- const BIGNUM *x, +- int y_bit, +- BN_CTX *ctx)) +-# endif +-/** Encodes a EC_POINT object to a octet string +- * \param group underlying EC_GROUP object +- * \param p EC_POINT object +- * \param form point conversion form +- * \param buf memory buffer for the result. If NULL the function returns +- * required buffer size. +- * \param len length of the memory buffer +- * \param ctx BN_CTX object (optional) +- * \return the length of the encoded octet string or 0 if an error occurred +- */ +-size_t EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *p, +- point_conversion_form_t form, +- unsigned char *buf, size_t len, BN_CTX *ctx); +- +-/** Decodes a EC_POINT from a octet string +- * \param group underlying EC_GROUP object +- * \param p EC_POINT object +- * \param buf memory buffer with the encoded ec point +- * \param len length of the encoded ec point +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-int EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *p, +- const unsigned char *buf, size_t len, BN_CTX *ctx); +- +-/** Encodes an EC_POINT object to an allocated octet string +- * \param group underlying EC_GROUP object +- * \param point EC_POINT object +- * \param form point conversion form +- * \param pbuf returns pointer to allocated buffer +- * \param ctx BN_CTX object (optional) +- * \return the length of the encoded octet string or 0 if an error occurred +- */ +-size_t EC_POINT_point2buf(const EC_GROUP *group, const EC_POINT *point, +- point_conversion_form_t form, +- unsigned char **pbuf, BN_CTX *ctx); +- +-/* other interfaces to point2oct/oct2point: */ +-BIGNUM *EC_POINT_point2bn(const EC_GROUP *, const EC_POINT *, +- point_conversion_form_t form, BIGNUM *, BN_CTX *); +-EC_POINT *EC_POINT_bn2point(const EC_GROUP *, const BIGNUM *, +- EC_POINT *, BN_CTX *); +-char *EC_POINT_point2hex(const EC_GROUP *, const EC_POINT *, +- point_conversion_form_t form, BN_CTX *); +-EC_POINT *EC_POINT_hex2point(const EC_GROUP *, const char *, +- EC_POINT *, BN_CTX *); +- +-/********************************************************************/ +-/* functions for doing EC_POINT arithmetic */ +-/********************************************************************/ +- +-/** Computes the sum of two EC_POINT +- * \param group underlying EC_GROUP object +- * \param r EC_POINT object for the result (r = a + b) +- * \param a EC_POINT object with the first summand +- * \param b EC_POINT object with the second summand +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-int EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, +- const EC_POINT *b, BN_CTX *ctx); +- +-/** Computes the double of a EC_POINT +- * \param group underlying EC_GROUP object +- * \param r EC_POINT object for the result (r = 2 * a) +- * \param a EC_POINT object +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-int EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, +- BN_CTX *ctx); +- +-/** Computes the inverse of a EC_POINT +- * \param group underlying EC_GROUP object +- * \param a EC_POINT object to be inverted (it's used for the result as well) +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-int EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx); +- +-/** Checks whether the point is the neutral element of the group +- * \param group the underlying EC_GROUP object +- * \param p EC_POINT object +- * \return 1 if the point is the neutral element and 0 otherwise +- */ +-int EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *p); +- +-/** Checks whether the point is on the curve +- * \param group underlying EC_GROUP object +- * \param point EC_POINT object to check +- * \param ctx BN_CTX object (optional) +- * \return 1 if the point is on the curve, 0 if not, or -1 on error +- */ +-int EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point, +- BN_CTX *ctx); +- +-/** Compares two EC_POINTs +- * \param group underlying EC_GROUP object +- * \param a first EC_POINT object +- * \param b second EC_POINT object +- * \param ctx BN_CTX object (optional) +- * \return 1 if the points are not equal, 0 if they are, or -1 on error +- */ +-int EC_POINT_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b, +- BN_CTX *ctx); +- +-int EC_POINT_make_affine(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx); +-int EC_POINTs_make_affine(const EC_GROUP *group, size_t num, +- EC_POINT *points[], BN_CTX *ctx); +- +-/** Computes r = generator * n + sum_{i=0}^{num-1} p[i] * m[i] +- * \param group underlying EC_GROUP object +- * \param r EC_POINT object for the result +- * \param n BIGNUM with the multiplier for the group generator (optional) +- * \param num number further summands +- * \param p array of size num of EC_POINT objects +- * \param m array of size num of BIGNUM objects +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-int EC_POINTs_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *n, +- size_t num, const EC_POINT *p[], const BIGNUM *m[], +- BN_CTX *ctx); +- +-/** Computes r = generator * n + q * m +- * \param group underlying EC_GROUP object +- * \param r EC_POINT object for the result +- * \param n BIGNUM with the multiplier for the group generator (optional) +- * \param q EC_POINT object with the first factor of the second summand +- * \param m BIGNUM with the second factor of the second summand +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-int EC_POINT_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *n, +- const EC_POINT *q, const BIGNUM *m, BN_CTX *ctx); +- +-/** Stores multiples of generator for faster point multiplication +- * \param group EC_GROUP object +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +-int EC_GROUP_precompute_mult(EC_GROUP *group, BN_CTX *ctx); +- +-/** Reports whether a precomputation has been done +- * \param group EC_GROUP object +- * \return 1 if a pre-computation has been done and 0 otherwise +- */ +-int EC_GROUP_have_precompute_mult(const EC_GROUP *group); +- +-/********************************************************************/ +-/* ASN1 stuff */ +-/********************************************************************/ +- +-DECLARE_ASN1_ITEM(ECPKPARAMETERS) +-DECLARE_ASN1_ALLOC_FUNCTIONS(ECPKPARAMETERS) +-DECLARE_ASN1_ITEM(ECPARAMETERS) +-DECLARE_ASN1_ALLOC_FUNCTIONS(ECPARAMETERS) +- +-/* +- * EC_GROUP_get_basis_type() returns the NID of the basis type used to +- * represent the field elements +- */ +-int EC_GROUP_get_basis_type(const EC_GROUP *); +-# ifndef OPENSSL_NO_EC2M +-int EC_GROUP_get_trinomial_basis(const EC_GROUP *, unsigned int *k); +-int EC_GROUP_get_pentanomial_basis(const EC_GROUP *, unsigned int *k1, +- unsigned int *k2, unsigned int *k3); +-# endif +- +-# define OPENSSL_EC_EXPLICIT_CURVE 0x000 +-# define OPENSSL_EC_NAMED_CURVE 0x001 +- +-EC_GROUP *d2i_ECPKParameters(EC_GROUP **, const unsigned char **in, long len); +-int i2d_ECPKParameters(const EC_GROUP *, unsigned char **out); +- +-# define d2i_ECPKParameters_bio(bp,x) \ +- ASN1_d2i_bio_of(EC_GROUP, NULL, d2i_ECPKParameters, bp, x) +-# define i2d_ECPKParameters_bio(bp,x) \ +- ASN1_i2d_bio_of_const(EC_GROUP, i2d_ECPKParameters, bp, x) +-# define d2i_ECPKParameters_fp(fp,x) \ +- (EC_GROUP *)ASN1_d2i_fp(NULL, (d2i_of_void *)d2i_ECPKParameters, (fp), \ +- (void **)(x)) +-# define i2d_ECPKParameters_fp(fp,x) \ +- ASN1_i2d_fp((i2d_of_void *)i2d_ECPKParameters, (fp), (void *)(x)) +- +-int ECPKParameters_print(BIO *bp, const EC_GROUP *x, int off); +-# ifndef OPENSSL_NO_STDIO +-int ECPKParameters_print_fp(FILE *fp, const EC_GROUP *x, int off); +-# endif +- +-/********************************************************************/ +-/* EC_KEY functions */ +-/********************************************************************/ +- +-/* some values for the encoding_flag */ +-# define EC_PKEY_NO_PARAMETERS 0x001 +-# define EC_PKEY_NO_PUBKEY 0x002 +- +-/* some values for the flags field */ +-# define EC_FLAG_NON_FIPS_ALLOW 0x1 +-# define EC_FLAG_FIPS_CHECKED 0x2 +-# define EC_FLAG_COFACTOR_ECDH 0x1000 +- +-/** Creates a new EC_KEY object. +- * \return EC_KEY object or NULL if an error occurred. +- */ +-EC_KEY *EC_KEY_new(void); +- +-int EC_KEY_get_flags(const EC_KEY *key); +- +-void EC_KEY_set_flags(EC_KEY *key, int flags); +- +-void EC_KEY_clear_flags(EC_KEY *key, int flags); +- +-int EC_KEY_decoded_from_explicit_params(const EC_KEY *key); +- +-/** Creates a new EC_KEY object using a named curve as underlying +- * EC_GROUP object. +- * \param nid NID of the named curve. +- * \return EC_KEY object or NULL if an error occurred. +- */ +-EC_KEY *EC_KEY_new_by_curve_name(int nid); +- +-/** Frees a EC_KEY object. +- * \param key EC_KEY object to be freed. +- */ +-void EC_KEY_free(EC_KEY *key); +- +-/** Copies a EC_KEY object. +- * \param dst destination EC_KEY object +- * \param src src EC_KEY object +- * \return dst or NULL if an error occurred. +- */ +-EC_KEY *EC_KEY_copy(EC_KEY *dst, const EC_KEY *src); +- +-/** Creates a new EC_KEY object and copies the content from src to it. +- * \param src the source EC_KEY object +- * \return newly created EC_KEY object or NULL if an error occurred. +- */ +-EC_KEY *EC_KEY_dup(const EC_KEY *src); +- +-/** Increases the internal reference count of a EC_KEY object. +- * \param key EC_KEY object +- * \return 1 on success and 0 if an error occurred. +- */ +-int EC_KEY_up_ref(EC_KEY *key); +- +-/** Returns the ENGINE object of a EC_KEY object +- * \param eckey EC_KEY object +- * \return the ENGINE object (possibly NULL). +- */ +-ENGINE *EC_KEY_get0_engine(const EC_KEY *eckey); +- +-/** Returns the EC_GROUP object of a EC_KEY object +- * \param key EC_KEY object +- * \return the EC_GROUP object (possibly NULL). +- */ +-const EC_GROUP *EC_KEY_get0_group(const EC_KEY *key); +- +-/** Sets the EC_GROUP of a EC_KEY object. +- * \param key EC_KEY object +- * \param group EC_GROUP to use in the EC_KEY object (note: the EC_KEY +- * object will use an own copy of the EC_GROUP). +- * \return 1 on success and 0 if an error occurred. +- */ +-int EC_KEY_set_group(EC_KEY *key, const EC_GROUP *group); +- +-/** Returns the private key of a EC_KEY object. +- * \param key EC_KEY object +- * \return a BIGNUM with the private key (possibly NULL). +- */ +-const BIGNUM *EC_KEY_get0_private_key(const EC_KEY *key); +- +-/** Sets the private key of a EC_KEY object. +- * \param key EC_KEY object +- * \param prv BIGNUM with the private key (note: the EC_KEY object +- * will use an own copy of the BIGNUM). +- * \return 1 on success and 0 if an error occurred. +- */ +-int EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *prv); +- +-/** Returns the public key of a EC_KEY object. +- * \param key the EC_KEY object +- * \return a EC_POINT object with the public key (possibly NULL) +- */ +-const EC_POINT *EC_KEY_get0_public_key(const EC_KEY *key); +- +-/** Sets the public key of a EC_KEY object. +- * \param key EC_KEY object +- * \param pub EC_POINT object with the public key (note: the EC_KEY object +- * will use an own copy of the EC_POINT object). +- * \return 1 on success and 0 if an error occurred. +- */ +-int EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub); +- +-unsigned EC_KEY_get_enc_flags(const EC_KEY *key); +-void EC_KEY_set_enc_flags(EC_KEY *eckey, unsigned int flags); +-point_conversion_form_t EC_KEY_get_conv_form(const EC_KEY *key); +-void EC_KEY_set_conv_form(EC_KEY *eckey, point_conversion_form_t cform); +- +-#define EC_KEY_get_ex_new_index(l, p, newf, dupf, freef) \ +- CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_EC_KEY, l, p, newf, dupf, freef) +-int EC_KEY_set_ex_data(EC_KEY *key, int idx, void *arg); +-void *EC_KEY_get_ex_data(const EC_KEY *key, int idx); +- +-/* wrapper functions for the underlying EC_GROUP object */ +-void EC_KEY_set_asn1_flag(EC_KEY *eckey, int asn1_flag); +- +-/** Creates a table of pre-computed multiples of the generator to +- * accelerate further EC_KEY operations. +- * \param key EC_KEY object +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred. +- */ +-int EC_KEY_precompute_mult(EC_KEY *key, BN_CTX *ctx); +- +-/** Creates a new ec private (and optional a new public) key. +- * \param key EC_KEY object +- * \return 1 on success and 0 if an error occurred. +- */ +-int EC_KEY_generate_key(EC_KEY *key); +- +-/** Verifies that a private and/or public key is valid. +- * \param key the EC_KEY object +- * \return 1 on success and 0 otherwise. +- */ +-int EC_KEY_check_key(const EC_KEY *key); +- +-/** Indicates if an EC_KEY can be used for signing. +- * \param eckey the EC_KEY object +- * \return 1 if can can sign and 0 otherwise. +- */ +-int EC_KEY_can_sign(const EC_KEY *eckey); +- +-/** Sets a public key from affine coordinates performing +- * necessary NIST PKV tests. +- * \param key the EC_KEY object +- * \param x public key x coordinate +- * \param y public key y coordinate +- * \return 1 on success and 0 otherwise. +- */ +-int EC_KEY_set_public_key_affine_coordinates(EC_KEY *key, BIGNUM *x, +- BIGNUM *y); +- +-/** Encodes an EC_KEY public key to an allocated octet string +- * \param key key to encode +- * \param form point conversion form +- * \param pbuf returns pointer to allocated buffer +- * \param ctx BN_CTX object (optional) +- * \return the length of the encoded octet string or 0 if an error occurred +- */ +-size_t EC_KEY_key2buf(const EC_KEY *key, point_conversion_form_t form, +- unsigned char **pbuf, BN_CTX *ctx); +- +-/** Decodes a EC_KEY public key from a octet string +- * \param key key to decode +- * \param buf memory buffer with the encoded ec point +- * \param len length of the encoded ec point +- * \param ctx BN_CTX object (optional) +- * \return 1 on success and 0 if an error occurred +- */ +- +-int EC_KEY_oct2key(EC_KEY *key, const unsigned char *buf, size_t len, +- BN_CTX *ctx); +- +-/** Decodes an EC_KEY private key from an octet string +- * \param key key to decode +- * \param buf memory buffer with the encoded private key +- * \param len length of the encoded key +- * \return 1 on success and 0 if an error occurred +- */ +- +-int EC_KEY_oct2priv(EC_KEY *key, const unsigned char *buf, size_t len); +- +-/** Encodes a EC_KEY private key to an octet string +- * \param key key to encode +- * \param buf memory buffer for the result. If NULL the function returns +- * required buffer size. +- * \param len length of the memory buffer +- * \return the length of the encoded octet string or 0 if an error occurred +- */ +- +-size_t EC_KEY_priv2oct(const EC_KEY *key, unsigned char *buf, size_t len); +- +-/** Encodes an EC_KEY private key to an allocated octet string +- * \param eckey key to encode +- * \param pbuf returns pointer to allocated buffer +- * \return the length of the encoded octet string or 0 if an error occurred +- */ +-size_t EC_KEY_priv2buf(const EC_KEY *eckey, unsigned char **pbuf); +- +-/********************************************************************/ +-/* de- and encoding functions for SEC1 ECPrivateKey */ +-/********************************************************************/ +- +-/** Decodes a private key from a memory buffer. +- * \param key a pointer to a EC_KEY object which should be used (or NULL) +- * \param in pointer to memory with the DER encoded private key +- * \param len length of the DER encoded private key +- * \return the decoded private key or NULL if an error occurred. +- */ +-EC_KEY *d2i_ECPrivateKey(EC_KEY **key, const unsigned char **in, long len); +- +-/** Encodes a private key object and stores the result in a buffer. +- * \param key the EC_KEY object to encode +- * \param out the buffer for the result (if NULL the function returns number +- * of bytes needed). +- * \return 1 on success and 0 if an error occurred. +- */ +-int i2d_ECPrivateKey(EC_KEY *key, unsigned char **out); +- +-/********************************************************************/ +-/* de- and encoding functions for EC parameters */ +-/********************************************************************/ +- +-/** Decodes ec parameter from a memory buffer. +- * \param key a pointer to a EC_KEY object which should be used (or NULL) +- * \param in pointer to memory with the DER encoded ec parameters +- * \param len length of the DER encoded ec parameters +- * \return a EC_KEY object with the decoded parameters or NULL if an error +- * occurred. +- */ +-EC_KEY *d2i_ECParameters(EC_KEY **key, const unsigned char **in, long len); +- +-/** Encodes ec parameter and stores the result in a buffer. +- * \param key the EC_KEY object with ec parameters to encode +- * \param out the buffer for the result (if NULL the function returns number +- * of bytes needed). +- * \return 1 on success and 0 if an error occurred. +- */ +-int i2d_ECParameters(EC_KEY *key, unsigned char **out); +- +-/********************************************************************/ +-/* de- and encoding functions for EC public key */ +-/* (octet string, not DER -- hence 'o2i' and 'i2o') */ +-/********************************************************************/ +- +-/** Decodes a ec public key from a octet string. +- * \param key a pointer to a EC_KEY object which should be used +- * \param in memory buffer with the encoded public key +- * \param len length of the encoded public key +- * \return EC_KEY object with decoded public key or NULL if an error +- * occurred. +- */ +-EC_KEY *o2i_ECPublicKey(EC_KEY **key, const unsigned char **in, long len); +- +-/** Encodes a ec public key in an octet string. +- * \param key the EC_KEY object with the public key +- * \param out the buffer for the result (if NULL the function returns number +- * of bytes needed). +- * \return 1 on success and 0 if an error occurred +- */ +-int i2o_ECPublicKey(const EC_KEY *key, unsigned char **out); +- +-/** Prints out the ec parameters on human readable form. +- * \param bp BIO object to which the information is printed +- * \param key EC_KEY object +- * \return 1 on success and 0 if an error occurred +- */ +-int ECParameters_print(BIO *bp, const EC_KEY *key); +- +-/** Prints out the contents of a EC_KEY object +- * \param bp BIO object to which the information is printed +- * \param key EC_KEY object +- * \param off line offset +- * \return 1 on success and 0 if an error occurred +- */ +-int EC_KEY_print(BIO *bp, const EC_KEY *key, int off); +- +-# ifndef OPENSSL_NO_STDIO +-/** Prints out the ec parameters on human readable form. +- * \param fp file descriptor to which the information is printed +- * \param key EC_KEY object +- * \return 1 on success and 0 if an error occurred +- */ +-int ECParameters_print_fp(FILE *fp, const EC_KEY *key); +- +-/** Prints out the contents of a EC_KEY object +- * \param fp file descriptor to which the information is printed +- * \param key EC_KEY object +- * \param off line offset +- * \return 1 on success and 0 if an error occurred +- */ +-int EC_KEY_print_fp(FILE *fp, const EC_KEY *key, int off); +- +-# endif +- +-const EC_KEY_METHOD *EC_KEY_OpenSSL(void); +-const EC_KEY_METHOD *EC_KEY_get_default_method(void); +-void EC_KEY_set_default_method(const EC_KEY_METHOD *meth); +-const EC_KEY_METHOD *EC_KEY_get_method(const EC_KEY *key); +-int EC_KEY_set_method(EC_KEY *key, const EC_KEY_METHOD *meth); +-EC_KEY *EC_KEY_new_method(ENGINE *engine); +- +-/** The old name for ecdh_KDF_X9_63 +- * The ECDH KDF specification has been mistakingly attributed to ANSI X9.62, +- * it is actually specified in ANSI X9.63. +- * This identifier is retained for backwards compatibility +- */ +-int ECDH_KDF_X9_62(unsigned char *out, size_t outlen, +- const unsigned char *Z, size_t Zlen, +- const unsigned char *sinfo, size_t sinfolen, +- const EVP_MD *md); +- +-int ECDH_compute_key(void *out, size_t outlen, const EC_POINT *pub_key, +- const EC_KEY *ecdh, +- void *(*KDF) (const void *in, size_t inlen, +- void *out, size_t *outlen)); +- +-typedef struct ECDSA_SIG_st ECDSA_SIG; +- +-/** Allocates and initialize a ECDSA_SIG structure +- * \return pointer to a ECDSA_SIG structure or NULL if an error occurred +- */ +-ECDSA_SIG *ECDSA_SIG_new(void); +- +-/** frees a ECDSA_SIG structure +- * \param sig pointer to the ECDSA_SIG structure +- */ +-void ECDSA_SIG_free(ECDSA_SIG *sig); +- +-/** DER encode content of ECDSA_SIG object (note: this function modifies *pp +- * (*pp += length of the DER encoded signature)). +- * \param sig pointer to the ECDSA_SIG object +- * \param pp pointer to a unsigned char pointer for the output or NULL +- * \return the length of the DER encoded ECDSA_SIG object or a negative value +- * on error +- */ +-int i2d_ECDSA_SIG(const ECDSA_SIG *sig, unsigned char **pp); +- +-/** Decodes a DER encoded ECDSA signature (note: this function changes *pp +- * (*pp += len)). +- * \param sig pointer to ECDSA_SIG pointer (may be NULL) +- * \param pp memory buffer with the DER encoded signature +- * \param len length of the buffer +- * \return pointer to the decoded ECDSA_SIG structure (or NULL) +- */ +-ECDSA_SIG *d2i_ECDSA_SIG(ECDSA_SIG **sig, const unsigned char **pp, long len); +- +-/** Accessor for r and s fields of ECDSA_SIG +- * \param sig pointer to ECDSA_SIG structure +- * \param pr pointer to BIGNUM pointer for r (may be NULL) +- * \param ps pointer to BIGNUM pointer for s (may be NULL) +- */ +-void ECDSA_SIG_get0(const ECDSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps); +- +-/** Accessor for r field of ECDSA_SIG +- * \param sig pointer to ECDSA_SIG structure +- */ +-const BIGNUM *ECDSA_SIG_get0_r(const ECDSA_SIG *sig); +- +-/** Accessor for s field of ECDSA_SIG +- * \param sig pointer to ECDSA_SIG structure +- */ +-const BIGNUM *ECDSA_SIG_get0_s(const ECDSA_SIG *sig); +- +-/** Setter for r and s fields of ECDSA_SIG +- * \param sig pointer to ECDSA_SIG structure +- * \param r pointer to BIGNUM for r (may be NULL) +- * \param s pointer to BIGNUM for s (may be NULL) +- */ +-int ECDSA_SIG_set0(ECDSA_SIG *sig, BIGNUM *r, BIGNUM *s); +- +-/** Computes the ECDSA signature of the given hash value using +- * the supplied private key and returns the created signature. +- * \param dgst pointer to the hash value +- * \param dgst_len length of the hash value +- * \param eckey EC_KEY object containing a private EC key +- * \return pointer to a ECDSA_SIG structure or NULL if an error occurred +- */ +-ECDSA_SIG *ECDSA_do_sign(const unsigned char *dgst, int dgst_len, +- EC_KEY *eckey); +- +-/** Computes ECDSA signature of a given hash value using the supplied +- * private key (note: sig must point to ECDSA_size(eckey) bytes of memory). +- * \param dgst pointer to the hash value to sign +- * \param dgstlen length of the hash value +- * \param kinv BIGNUM with a pre-computed inverse k (optional) +- * \param rp BIGNUM with a pre-computed rp value (optional), +- * see ECDSA_sign_setup +- * \param eckey EC_KEY object containing a private EC key +- * \return pointer to a ECDSA_SIG structure or NULL if an error occurred +- */ +-ECDSA_SIG *ECDSA_do_sign_ex(const unsigned char *dgst, int dgstlen, +- const BIGNUM *kinv, const BIGNUM *rp, +- EC_KEY *eckey); +- +-/** Verifies that the supplied signature is a valid ECDSA +- * signature of the supplied hash value using the supplied public key. +- * \param dgst pointer to the hash value +- * \param dgst_len length of the hash value +- * \param sig ECDSA_SIG structure +- * \param eckey EC_KEY object containing a public EC key +- * \return 1 if the signature is valid, 0 if the signature is invalid +- * and -1 on error +- */ +-int ECDSA_do_verify(const unsigned char *dgst, int dgst_len, +- const ECDSA_SIG *sig, EC_KEY *eckey); +- +-/** Precompute parts of the signing operation +- * \param eckey EC_KEY object containing a private EC key +- * \param ctx BN_CTX object (optional) +- * \param kinv BIGNUM pointer for the inverse of k +- * \param rp BIGNUM pointer for x coordinate of k * generator +- * \return 1 on success and 0 otherwise +- */ +-int ECDSA_sign_setup(EC_KEY *eckey, BN_CTX *ctx, BIGNUM **kinv, BIGNUM **rp); +- +-/** Computes ECDSA signature of a given hash value using the supplied +- * private key (note: sig must point to ECDSA_size(eckey) bytes of memory). +- * \param type this parameter is ignored +- * \param dgst pointer to the hash value to sign +- * \param dgstlen length of the hash value +- * \param sig memory for the DER encoded created signature +- * \param siglen pointer to the length of the returned signature +- * \param eckey EC_KEY object containing a private EC key +- * \return 1 on success and 0 otherwise +- */ +-int ECDSA_sign(int type, const unsigned char *dgst, int dgstlen, +- unsigned char *sig, unsigned int *siglen, EC_KEY *eckey); +- +-/** Computes ECDSA signature of a given hash value using the supplied +- * private key (note: sig must point to ECDSA_size(eckey) bytes of memory). +- * \param type this parameter is ignored +- * \param dgst pointer to the hash value to sign +- * \param dgstlen length of the hash value +- * \param sig buffer to hold the DER encoded signature +- * \param siglen pointer to the length of the returned signature +- * \param kinv BIGNUM with a pre-computed inverse k (optional) +- * \param rp BIGNUM with a pre-computed rp value (optional), +- * see ECDSA_sign_setup +- * \param eckey EC_KEY object containing a private EC key +- * \return 1 on success and 0 otherwise +- */ +-int ECDSA_sign_ex(int type, const unsigned char *dgst, int dgstlen, +- unsigned char *sig, unsigned int *siglen, +- const BIGNUM *kinv, const BIGNUM *rp, EC_KEY *eckey); +- +-/** Verifies that the given signature is valid ECDSA signature +- * of the supplied hash value using the specified public key. +- * \param type this parameter is ignored +- * \param dgst pointer to the hash value +- * \param dgstlen length of the hash value +- * \param sig pointer to the DER encoded signature +- * \param siglen length of the DER encoded signature +- * \param eckey EC_KEY object containing a public EC key +- * \return 1 if the signature is valid, 0 if the signature is invalid +- * and -1 on error +- */ +-int ECDSA_verify(int type, const unsigned char *dgst, int dgstlen, +- const unsigned char *sig, int siglen, EC_KEY *eckey); +- +-/** Returns the maximum length of the DER encoded signature +- * \param eckey EC_KEY object +- * \return numbers of bytes required for the DER encoded signature +- */ +-int ECDSA_size(const EC_KEY *eckey); +- +-/********************************************************************/ +-/* EC_KEY_METHOD constructors, destructors, writers and accessors */ +-/********************************************************************/ +- +-EC_KEY_METHOD *EC_KEY_METHOD_new(const EC_KEY_METHOD *meth); +-void EC_KEY_METHOD_free(EC_KEY_METHOD *meth); +-void EC_KEY_METHOD_set_init(EC_KEY_METHOD *meth, +- int (*init)(EC_KEY *key), +- void (*finish)(EC_KEY *key), +- int (*copy)(EC_KEY *dest, const EC_KEY *src), +- int (*set_group)(EC_KEY *key, const EC_GROUP *grp), +- int (*set_private)(EC_KEY *key, +- const BIGNUM *priv_key), +- int (*set_public)(EC_KEY *key, +- const EC_POINT *pub_key)); +- +-void EC_KEY_METHOD_set_keygen(EC_KEY_METHOD *meth, +- int (*keygen)(EC_KEY *key)); +- +-void EC_KEY_METHOD_set_compute_key(EC_KEY_METHOD *meth, +- int (*ckey)(unsigned char **psec, +- size_t *pseclen, +- const EC_POINT *pub_key, +- const EC_KEY *ecdh)); +- +-void EC_KEY_METHOD_set_sign(EC_KEY_METHOD *meth, +- int (*sign)(int type, const unsigned char *dgst, +- int dlen, unsigned char *sig, +- unsigned int *siglen, +- const BIGNUM *kinv, const BIGNUM *r, +- EC_KEY *eckey), +- int (*sign_setup)(EC_KEY *eckey, BN_CTX *ctx_in, +- BIGNUM **kinvp, BIGNUM **rp), +- ECDSA_SIG *(*sign_sig)(const unsigned char *dgst, +- int dgst_len, +- const BIGNUM *in_kinv, +- const BIGNUM *in_r, +- EC_KEY *eckey)); +- +-void EC_KEY_METHOD_set_verify(EC_KEY_METHOD *meth, +- int (*verify)(int type, const unsigned +- char *dgst, int dgst_len, +- const unsigned char *sigbuf, +- int sig_len, EC_KEY *eckey), +- int (*verify_sig)(const unsigned char *dgst, +- int dgst_len, +- const ECDSA_SIG *sig, +- EC_KEY *eckey)); +- +-void EC_KEY_METHOD_get_init(const EC_KEY_METHOD *meth, +- int (**pinit)(EC_KEY *key), +- void (**pfinish)(EC_KEY *key), +- int (**pcopy)(EC_KEY *dest, const EC_KEY *src), +- int (**pset_group)(EC_KEY *key, +- const EC_GROUP *grp), +- int (**pset_private)(EC_KEY *key, +- const BIGNUM *priv_key), +- int (**pset_public)(EC_KEY *key, +- const EC_POINT *pub_key)); +- +-void EC_KEY_METHOD_get_keygen(const EC_KEY_METHOD *meth, +- int (**pkeygen)(EC_KEY *key)); +- +-void EC_KEY_METHOD_get_compute_key(const EC_KEY_METHOD *meth, +- int (**pck)(unsigned char **psec, +- size_t *pseclen, +- const EC_POINT *pub_key, +- const EC_KEY *ecdh)); +- +-void EC_KEY_METHOD_get_sign(const EC_KEY_METHOD *meth, +- int (**psign)(int type, const unsigned char *dgst, +- int dlen, unsigned char *sig, +- unsigned int *siglen, +- const BIGNUM *kinv, const BIGNUM *r, +- EC_KEY *eckey), +- int (**psign_setup)(EC_KEY *eckey, BN_CTX *ctx_in, +- BIGNUM **kinvp, BIGNUM **rp), +- ECDSA_SIG *(**psign_sig)(const unsigned char *dgst, +- int dgst_len, +- const BIGNUM *in_kinv, +- const BIGNUM *in_r, +- EC_KEY *eckey)); +- +-void EC_KEY_METHOD_get_verify(const EC_KEY_METHOD *meth, +- int (**pverify)(int type, const unsigned +- char *dgst, int dgst_len, +- const unsigned char *sigbuf, +- int sig_len, EC_KEY *eckey), +- int (**pverify_sig)(const unsigned char *dgst, +- int dgst_len, +- const ECDSA_SIG *sig, +- EC_KEY *eckey)); +- +-# define ECParameters_dup(x) ASN1_dup_of(EC_KEY,i2d_ECParameters,d2i_ECParameters,x) +- +-# ifndef __cplusplus +-# if defined(__SUNPRO_C) +-# if __SUNPRO_C >= 0x520 +-# pragma error_messages (default,E_ARRAY_OF_INCOMPLETE_NONAME,E_ARRAY_OF_INCOMPLETE) +-# endif +-# endif +-# endif +- +-# define EVP_PKEY_CTX_set_ec_paramgen_curve_nid(ctx, nid) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ +- EVP_PKEY_OP_PARAMGEN|EVP_PKEY_OP_KEYGEN, \ +- EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID, nid, NULL) +- +-# define EVP_PKEY_CTX_set_ec_param_enc(ctx, flag) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ +- EVP_PKEY_OP_PARAMGEN|EVP_PKEY_OP_KEYGEN, \ +- EVP_PKEY_CTRL_EC_PARAM_ENC, flag, NULL) +- +-# define EVP_PKEY_CTX_set_ecdh_cofactor_mode(ctx, flag) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ +- EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_EC_ECDH_COFACTOR, flag, NULL) +- +-# define EVP_PKEY_CTX_get_ecdh_cofactor_mode(ctx) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ +- EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_EC_ECDH_COFACTOR, -2, NULL) +- +-# define EVP_PKEY_CTX_set_ecdh_kdf_type(ctx, kdf) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ +- EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_EC_KDF_TYPE, kdf, NULL) +- +-# define EVP_PKEY_CTX_get_ecdh_kdf_type(ctx) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ +- EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_EC_KDF_TYPE, -2, NULL) +- +-# define EVP_PKEY_CTX_set_ecdh_kdf_md(ctx, md) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ +- EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_EC_KDF_MD, 0, (void *)(md)) +- +-# define EVP_PKEY_CTX_get_ecdh_kdf_md(ctx, pmd) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ +- EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_GET_EC_KDF_MD, 0, (void *)(pmd)) +- +-# define EVP_PKEY_CTX_set_ecdh_kdf_outlen(ctx, len) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ +- EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_EC_KDF_OUTLEN, len, NULL) +- +-# define EVP_PKEY_CTX_get_ecdh_kdf_outlen(ctx, plen) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ +- EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_GET_EC_KDF_OUTLEN, 0, \ +- (void *)(plen)) +- +-# define EVP_PKEY_CTX_set0_ecdh_kdf_ukm(ctx, p, plen) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ +- EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_EC_KDF_UKM, plen, (void *)(p)) +- +-# define EVP_PKEY_CTX_get0_ecdh_kdf_ukm(ctx, p) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ +- EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_GET_EC_KDF_UKM, 0, (void *)(p)) +- +-/* SM2 will skip the operation check so no need to pass operation here */ +-# define EVP_PKEY_CTX_set1_id(ctx, id, id_len) \ +- EVP_PKEY_CTX_ctrl(ctx, -1, -1, \ +- EVP_PKEY_CTRL_SET1_ID, (int)id_len, (void*)(id)) +- +-# define EVP_PKEY_CTX_get1_id(ctx, id) \ +- EVP_PKEY_CTX_ctrl(ctx, -1, -1, \ +- EVP_PKEY_CTRL_GET1_ID, 0, (void*)(id)) +- +-# define EVP_PKEY_CTX_get1_id_len(ctx, id_len) \ +- EVP_PKEY_CTX_ctrl(ctx, -1, -1, \ +- EVP_PKEY_CTRL_GET1_ID_LEN, 0, (void*)(id_len)) +- +-# define EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID (EVP_PKEY_ALG_CTRL + 1) +-# define EVP_PKEY_CTRL_EC_PARAM_ENC (EVP_PKEY_ALG_CTRL + 2) +-# define EVP_PKEY_CTRL_EC_ECDH_COFACTOR (EVP_PKEY_ALG_CTRL + 3) +-# define EVP_PKEY_CTRL_EC_KDF_TYPE (EVP_PKEY_ALG_CTRL + 4) +-# define EVP_PKEY_CTRL_EC_KDF_MD (EVP_PKEY_ALG_CTRL + 5) +-# define EVP_PKEY_CTRL_GET_EC_KDF_MD (EVP_PKEY_ALG_CTRL + 6) +-# define EVP_PKEY_CTRL_EC_KDF_OUTLEN (EVP_PKEY_ALG_CTRL + 7) +-# define EVP_PKEY_CTRL_GET_EC_KDF_OUTLEN (EVP_PKEY_ALG_CTRL + 8) +-# define EVP_PKEY_CTRL_EC_KDF_UKM (EVP_PKEY_ALG_CTRL + 9) +-# define EVP_PKEY_CTRL_GET_EC_KDF_UKM (EVP_PKEY_ALG_CTRL + 10) +-# define EVP_PKEY_CTRL_SET1_ID (EVP_PKEY_ALG_CTRL + 11) +-# define EVP_PKEY_CTRL_GET1_ID (EVP_PKEY_ALG_CTRL + 12) +-# define EVP_PKEY_CTRL_GET1_ID_LEN (EVP_PKEY_ALG_CTRL + 13) +-/* KDF types */ +-# define EVP_PKEY_ECDH_KDF_NONE 1 +-# define EVP_PKEY_ECDH_KDF_X9_63 2 +-/** The old name for EVP_PKEY_ECDH_KDF_X9_63 +- * The ECDH KDF specification has been mistakingly attributed to ANSI X9.62, +- * it is actually specified in ANSI X9.63. +- * This identifier is retained for backwards compatibility +- */ +-# define EVP_PKEY_ECDH_KDF_X9_62 EVP_PKEY_ECDH_KDF_X9_63 +- +- +-# ifdef __cplusplus +-} +-# endif +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/ecdh.h b/uadk_tool/include/openssl/ecdh.h +deleted file mode 100644 +index 681f3d5..0000000 +--- a/uadk_tool/include/openssl/ecdh.h ++++ /dev/null +@@ -1,10 +0,0 @@ +-/* +- * Copyright 2002-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#include +diff --git a/uadk_tool/include/openssl/ecdsa.h b/uadk_tool/include/openssl/ecdsa.h +deleted file mode 100644 +index 681f3d5..0000000 +--- a/uadk_tool/include/openssl/ecdsa.h ++++ /dev/null +@@ -1,10 +0,0 @@ +-/* +- * Copyright 2002-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#include +diff --git a/uadk_tool/include/openssl/ecerr.h b/uadk_tool/include/openssl/ecerr.h +deleted file mode 100644 +index 5173811..0000000 +--- a/uadk_tool/include/openssl/ecerr.h ++++ /dev/null +@@ -1,276 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_ECERR_H +-# define HEADER_ECERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# include +- +-# ifndef OPENSSL_NO_EC +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_EC_strings(void); +- +-/* +- * EC function codes. +- */ +-# define EC_F_BN_TO_FELEM 224 +-# define EC_F_D2I_ECPARAMETERS 144 +-# define EC_F_D2I_ECPKPARAMETERS 145 +-# define EC_F_D2I_ECPRIVATEKEY 146 +-# define EC_F_DO_EC_KEY_PRINT 221 +-# define EC_F_ECDH_CMS_DECRYPT 238 +-# define EC_F_ECDH_CMS_SET_SHARED_INFO 239 +-# define EC_F_ECDH_COMPUTE_KEY 246 +-# define EC_F_ECDH_SIMPLE_COMPUTE_KEY 257 +-# define EC_F_ECDSA_DO_SIGN_EX 251 +-# define EC_F_ECDSA_DO_VERIFY 252 +-# define EC_F_ECDSA_SIGN_EX 254 +-# define EC_F_ECDSA_SIGN_SETUP 248 +-# define EC_F_ECDSA_SIG_NEW 265 +-# define EC_F_ECDSA_VERIFY 253 +-# define EC_F_ECD_ITEM_VERIFY 270 +-# define EC_F_ECKEY_PARAM2TYPE 223 +-# define EC_F_ECKEY_PARAM_DECODE 212 +-# define EC_F_ECKEY_PRIV_DECODE 213 +-# define EC_F_ECKEY_PRIV_ENCODE 214 +-# define EC_F_ECKEY_PUB_DECODE 215 +-# define EC_F_ECKEY_PUB_ENCODE 216 +-# define EC_F_ECKEY_TYPE2PARAM 220 +-# define EC_F_ECPARAMETERS_PRINT 147 +-# define EC_F_ECPARAMETERS_PRINT_FP 148 +-# define EC_F_ECPKPARAMETERS_PRINT 149 +-# define EC_F_ECPKPARAMETERS_PRINT_FP 150 +-# define EC_F_ECP_NISTZ256_GET_AFFINE 240 +-# define EC_F_ECP_NISTZ256_INV_MOD_ORD 275 +-# define EC_F_ECP_NISTZ256_MULT_PRECOMPUTE 243 +-# define EC_F_ECP_NISTZ256_POINTS_MUL 241 +-# define EC_F_ECP_NISTZ256_PRE_COMP_NEW 244 +-# define EC_F_ECP_NISTZ256_WINDOWED_MUL 242 +-# define EC_F_ECX_KEY_OP 266 +-# define EC_F_ECX_PRIV_ENCODE 267 +-# define EC_F_ECX_PUB_ENCODE 268 +-# define EC_F_EC_ASN1_GROUP2CURVE 153 +-# define EC_F_EC_ASN1_GROUP2FIELDID 154 +-# define EC_F_EC_GF2M_MONTGOMERY_POINT_MULTIPLY 208 +-# define EC_F_EC_GF2M_SIMPLE_FIELD_INV 296 +-# define EC_F_EC_GF2M_SIMPLE_GROUP_CHECK_DISCRIMINANT 159 +-# define EC_F_EC_GF2M_SIMPLE_GROUP_SET_CURVE 195 +-# define EC_F_EC_GF2M_SIMPLE_LADDER_POST 285 +-# define EC_F_EC_GF2M_SIMPLE_LADDER_PRE 288 +-# define EC_F_EC_GF2M_SIMPLE_OCT2POINT 160 +-# define EC_F_EC_GF2M_SIMPLE_POINT2OCT 161 +-# define EC_F_EC_GF2M_SIMPLE_POINTS_MUL 289 +-# define EC_F_EC_GF2M_SIMPLE_POINT_GET_AFFINE_COORDINATES 162 +-# define EC_F_EC_GF2M_SIMPLE_POINT_SET_AFFINE_COORDINATES 163 +-# define EC_F_EC_GF2M_SIMPLE_SET_COMPRESSED_COORDINATES 164 +-# define EC_F_EC_GFP_MONT_FIELD_DECODE 133 +-# define EC_F_EC_GFP_MONT_FIELD_ENCODE 134 +-# define EC_F_EC_GFP_MONT_FIELD_INV 297 +-# define EC_F_EC_GFP_MONT_FIELD_MUL 131 +-# define EC_F_EC_GFP_MONT_FIELD_SET_TO_ONE 209 +-# define EC_F_EC_GFP_MONT_FIELD_SQR 132 +-# define EC_F_EC_GFP_MONT_GROUP_SET_CURVE 189 +-# define EC_F_EC_GFP_NISTP224_GROUP_SET_CURVE 225 +-# define EC_F_EC_GFP_NISTP224_POINTS_MUL 228 +-# define EC_F_EC_GFP_NISTP224_POINT_GET_AFFINE_COORDINATES 226 +-# define EC_F_EC_GFP_NISTP256_GROUP_SET_CURVE 230 +-# define EC_F_EC_GFP_NISTP256_POINTS_MUL 231 +-# define EC_F_EC_GFP_NISTP256_POINT_GET_AFFINE_COORDINATES 232 +-# define EC_F_EC_GFP_NISTP521_GROUP_SET_CURVE 233 +-# define EC_F_EC_GFP_NISTP521_POINTS_MUL 234 +-# define EC_F_EC_GFP_NISTP521_POINT_GET_AFFINE_COORDINATES 235 +-# define EC_F_EC_GFP_NIST_FIELD_MUL 200 +-# define EC_F_EC_GFP_NIST_FIELD_SQR 201 +-# define EC_F_EC_GFP_NIST_GROUP_SET_CURVE 202 +-# define EC_F_EC_GFP_SIMPLE_BLIND_COORDINATES 287 +-# define EC_F_EC_GFP_SIMPLE_FIELD_INV 298 +-# define EC_F_EC_GFP_SIMPLE_GROUP_CHECK_DISCRIMINANT 165 +-# define EC_F_EC_GFP_SIMPLE_GROUP_SET_CURVE 166 +-# define EC_F_EC_GFP_SIMPLE_MAKE_AFFINE 102 +-# define EC_F_EC_GFP_SIMPLE_OCT2POINT 103 +-# define EC_F_EC_GFP_SIMPLE_POINT2OCT 104 +-# define EC_F_EC_GFP_SIMPLE_POINTS_MAKE_AFFINE 137 +-# define EC_F_EC_GFP_SIMPLE_POINT_GET_AFFINE_COORDINATES 167 +-# define EC_F_EC_GFP_SIMPLE_POINT_SET_AFFINE_COORDINATES 168 +-# define EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES 169 +-# define EC_F_EC_GROUP_CHECK 170 +-# define EC_F_EC_GROUP_CHECK_DISCRIMINANT 171 +-# define EC_F_EC_GROUP_COPY 106 +-# define EC_F_EC_GROUP_GET_CURVE 291 +-# define EC_F_EC_GROUP_GET_CURVE_GF2M 172 +-# define EC_F_EC_GROUP_GET_CURVE_GFP 130 +-# define EC_F_EC_GROUP_GET_DEGREE 173 +-# define EC_F_EC_GROUP_GET_ECPARAMETERS 261 +-# define EC_F_EC_GROUP_GET_ECPKPARAMETERS 262 +-# define EC_F_EC_GROUP_GET_PENTANOMIAL_BASIS 193 +-# define EC_F_EC_GROUP_GET_TRINOMIAL_BASIS 194 +-# define EC_F_EC_GROUP_NEW 108 +-# define EC_F_EC_GROUP_NEW_BY_CURVE_NAME 174 +-# define EC_F_EC_GROUP_NEW_FROM_DATA 175 +-# define EC_F_EC_GROUP_NEW_FROM_ECPARAMETERS 263 +-# define EC_F_EC_GROUP_NEW_FROM_ECPKPARAMETERS 264 +-# define EC_F_EC_GROUP_SET_CURVE 292 +-# define EC_F_EC_GROUP_SET_CURVE_GF2M 176 +-# define EC_F_EC_GROUP_SET_CURVE_GFP 109 +-# define EC_F_EC_GROUP_SET_GENERATOR 111 +-# define EC_F_EC_GROUP_SET_SEED 286 +-# define EC_F_EC_KEY_CHECK_KEY 177 +-# define EC_F_EC_KEY_COPY 178 +-# define EC_F_EC_KEY_GENERATE_KEY 179 +-# define EC_F_EC_KEY_NEW 182 +-# define EC_F_EC_KEY_NEW_METHOD 245 +-# define EC_F_EC_KEY_OCT2PRIV 255 +-# define EC_F_EC_KEY_PRINT 180 +-# define EC_F_EC_KEY_PRINT_FP 181 +-# define EC_F_EC_KEY_PRIV2BUF 279 +-# define EC_F_EC_KEY_PRIV2OCT 256 +-# define EC_F_EC_KEY_SET_PUBLIC_KEY_AFFINE_COORDINATES 229 +-# define EC_F_EC_KEY_SIMPLE_CHECK_KEY 258 +-# define EC_F_EC_KEY_SIMPLE_OCT2PRIV 259 +-# define EC_F_EC_KEY_SIMPLE_PRIV2OCT 260 +-# define EC_F_EC_PKEY_CHECK 273 +-# define EC_F_EC_PKEY_PARAM_CHECK 274 +-# define EC_F_EC_POINTS_MAKE_AFFINE 136 +-# define EC_F_EC_POINTS_MUL 290 +-# define EC_F_EC_POINT_ADD 112 +-# define EC_F_EC_POINT_BN2POINT 280 +-# define EC_F_EC_POINT_CMP 113 +-# define EC_F_EC_POINT_COPY 114 +-# define EC_F_EC_POINT_DBL 115 +-# define EC_F_EC_POINT_GET_AFFINE_COORDINATES 293 +-# define EC_F_EC_POINT_GET_AFFINE_COORDINATES_GF2M 183 +-# define EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP 116 +-# define EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP 117 +-# define EC_F_EC_POINT_INVERT 210 +-# define EC_F_EC_POINT_IS_AT_INFINITY 118 +-# define EC_F_EC_POINT_IS_ON_CURVE 119 +-# define EC_F_EC_POINT_MAKE_AFFINE 120 +-# define EC_F_EC_POINT_NEW 121 +-# define EC_F_EC_POINT_OCT2POINT 122 +-# define EC_F_EC_POINT_POINT2BUF 281 +-# define EC_F_EC_POINT_POINT2OCT 123 +-# define EC_F_EC_POINT_SET_AFFINE_COORDINATES 294 +-# define EC_F_EC_POINT_SET_AFFINE_COORDINATES_GF2M 185 +-# define EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP 124 +-# define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES 295 +-# define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GF2M 186 +-# define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP 125 +-# define EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP 126 +-# define EC_F_EC_POINT_SET_TO_INFINITY 127 +-# define EC_F_EC_PRE_COMP_NEW 196 +-# define EC_F_EC_SCALAR_MUL_LADDER 284 +-# define EC_F_EC_WNAF_MUL 187 +-# define EC_F_EC_WNAF_PRECOMPUTE_MULT 188 +-# define EC_F_I2D_ECPARAMETERS 190 +-# define EC_F_I2D_ECPKPARAMETERS 191 +-# define EC_F_I2D_ECPRIVATEKEY 192 +-# define EC_F_I2O_ECPUBLICKEY 151 +-# define EC_F_NISTP224_PRE_COMP_NEW 227 +-# define EC_F_NISTP256_PRE_COMP_NEW 236 +-# define EC_F_NISTP521_PRE_COMP_NEW 237 +-# define EC_F_O2I_ECPUBLICKEY 152 +-# define EC_F_OLD_EC_PRIV_DECODE 222 +-# define EC_F_OSSL_ECDH_COMPUTE_KEY 247 +-# define EC_F_OSSL_ECDSA_SIGN_SIG 249 +-# define EC_F_OSSL_ECDSA_VERIFY_SIG 250 +-# define EC_F_PKEY_ECD_CTRL 271 +-# define EC_F_PKEY_ECD_DIGESTSIGN 272 +-# define EC_F_PKEY_ECD_DIGESTSIGN25519 276 +-# define EC_F_PKEY_ECD_DIGESTSIGN448 277 +-# define EC_F_PKEY_ECX_DERIVE 269 +-# define EC_F_PKEY_EC_CTRL 197 +-# define EC_F_PKEY_EC_CTRL_STR 198 +-# define EC_F_PKEY_EC_DERIVE 217 +-# define EC_F_PKEY_EC_INIT 282 +-# define EC_F_PKEY_EC_KDF_DERIVE 283 +-# define EC_F_PKEY_EC_KEYGEN 199 +-# define EC_F_PKEY_EC_PARAMGEN 219 +-# define EC_F_PKEY_EC_SIGN 218 +-# define EC_F_VALIDATE_ECX_DERIVE 278 +- +-/* +- * EC reason codes. +- */ +-# define EC_R_ASN1_ERROR 115 +-# define EC_R_BAD_SIGNATURE 156 +-# define EC_R_BIGNUM_OUT_OF_RANGE 144 +-# define EC_R_BUFFER_TOO_SMALL 100 +-# define EC_R_CANNOT_INVERT 165 +-# define EC_R_COORDINATES_OUT_OF_RANGE 146 +-# define EC_R_CURVE_DOES_NOT_SUPPORT_ECDH 160 +-# define EC_R_CURVE_DOES_NOT_SUPPORT_SIGNING 159 +-# define EC_R_D2I_ECPKPARAMETERS_FAILURE 117 +-# define EC_R_DECODE_ERROR 142 +-# define EC_R_DISCRIMINANT_IS_ZERO 118 +-# define EC_R_EC_GROUP_NEW_BY_NAME_FAILURE 119 +-# define EC_R_FIELD_TOO_LARGE 143 +-# define EC_R_GF2M_NOT_SUPPORTED 147 +-# define EC_R_GROUP2PKPARAMETERS_FAILURE 120 +-# define EC_R_I2D_ECPKPARAMETERS_FAILURE 121 +-# define EC_R_INCOMPATIBLE_OBJECTS 101 +-# define EC_R_INVALID_ARGUMENT 112 +-# define EC_R_INVALID_COMPRESSED_POINT 110 +-# define EC_R_INVALID_COMPRESSION_BIT 109 +-# define EC_R_INVALID_CURVE 141 +-# define EC_R_INVALID_DIGEST 151 +-# define EC_R_INVALID_DIGEST_TYPE 138 +-# define EC_R_INVALID_ENCODING 102 +-# define EC_R_INVALID_FIELD 103 +-# define EC_R_INVALID_FORM 104 +-# define EC_R_INVALID_GROUP_ORDER 122 +-# define EC_R_INVALID_KEY 116 +-# define EC_R_INVALID_OUTPUT_LENGTH 161 +-# define EC_R_INVALID_PEER_KEY 133 +-# define EC_R_INVALID_PENTANOMIAL_BASIS 132 +-# define EC_R_INVALID_PRIVATE_KEY 123 +-# define EC_R_INVALID_TRINOMIAL_BASIS 137 +-# define EC_R_KDF_PARAMETER_ERROR 148 +-# define EC_R_KEYS_NOT_SET 140 +-# define EC_R_LADDER_POST_FAILURE 136 +-# define EC_R_LADDER_PRE_FAILURE 153 +-# define EC_R_LADDER_STEP_FAILURE 162 +-# define EC_R_MISSING_OID 167 +-# define EC_R_MISSING_PARAMETERS 124 +-# define EC_R_MISSING_PRIVATE_KEY 125 +-# define EC_R_NEED_NEW_SETUP_VALUES 157 +-# define EC_R_NOT_A_NIST_PRIME 135 +-# define EC_R_NOT_IMPLEMENTED 126 +-# define EC_R_NOT_INITIALIZED 111 +-# define EC_R_NO_PARAMETERS_SET 139 +-# define EC_R_NO_PRIVATE_VALUE 154 +-# define EC_R_OPERATION_NOT_SUPPORTED 152 +-# define EC_R_PASSED_NULL_PARAMETER 134 +-# define EC_R_PEER_KEY_ERROR 149 +-# define EC_R_PKPARAMETERS2GROUP_FAILURE 127 +-# define EC_R_POINT_ARITHMETIC_FAILURE 155 +-# define EC_R_POINT_AT_INFINITY 106 +-# define EC_R_POINT_COORDINATES_BLIND_FAILURE 163 +-# define EC_R_POINT_IS_NOT_ON_CURVE 107 +-# define EC_R_RANDOM_NUMBER_GENERATION_FAILED 158 +-# define EC_R_SHARED_INFO_ERROR 150 +-# define EC_R_SLOT_FULL 108 +-# define EC_R_UNDEFINED_GENERATOR 113 +-# define EC_R_UNDEFINED_ORDER 128 +-# define EC_R_UNKNOWN_COFACTOR 164 +-# define EC_R_UNKNOWN_GROUP 129 +-# define EC_R_UNKNOWN_ORDER 114 +-# define EC_R_UNSUPPORTED_FIELD 131 +-# define EC_R_WRONG_CURVE_PARAMETERS 145 +-# define EC_R_WRONG_ORDER 130 +- +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/engine.h b/uadk_tool/include/openssl/engine.h +deleted file mode 100644 +index 0780f0f..0000000 +--- a/uadk_tool/include/openssl/engine.h ++++ /dev/null +@@ -1,751 +0,0 @@ +-/* +- * Copyright 2000-2018 The OpenSSL Project Authors. All Rights Reserved. +- * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_ENGINE_H +-# define HEADER_ENGINE_H +- +-# include +- +-# ifndef OPENSSL_NO_ENGINE +-# if OPENSSL_API_COMPAT < 0x10100000L +-# include +-# include +-# include +-# include +-# include +-# include +-# include +-# include +-# endif +-# include +-# include +-# include +-# include +-# ifdef __cplusplus +-extern "C" { +-# endif +- +-/* +- * These flags are used to control combinations of algorithm (methods) by +- * bitwise "OR"ing. +- */ +-# define ENGINE_METHOD_RSA (unsigned int)0x0001 +-# define ENGINE_METHOD_DSA (unsigned int)0x0002 +-# define ENGINE_METHOD_DH (unsigned int)0x0004 +-# define ENGINE_METHOD_RAND (unsigned int)0x0008 +-# define ENGINE_METHOD_CIPHERS (unsigned int)0x0040 +-# define ENGINE_METHOD_DIGESTS (unsigned int)0x0080 +-# define ENGINE_METHOD_PKEY_METHS (unsigned int)0x0200 +-# define ENGINE_METHOD_PKEY_ASN1_METHS (unsigned int)0x0400 +-# define ENGINE_METHOD_EC (unsigned int)0x0800 +-/* Obvious all-or-nothing cases. */ +-# define ENGINE_METHOD_ALL (unsigned int)0xFFFF +-# define ENGINE_METHOD_NONE (unsigned int)0x0000 +- +-/* +- * This(ese) flag(s) controls behaviour of the ENGINE_TABLE mechanism used +- * internally to control registration of ENGINE implementations, and can be +- * set by ENGINE_set_table_flags(). The "NOINIT" flag prevents attempts to +- * initialise registered ENGINEs if they are not already initialised. +- */ +-# define ENGINE_TABLE_FLAG_NOINIT (unsigned int)0x0001 +- +-/* ENGINE flags that can be set by ENGINE_set_flags(). */ +-/* Not used */ +-/* #define ENGINE_FLAGS_MALLOCED 0x0001 */ +- +-/* +- * This flag is for ENGINEs that wish to handle the various 'CMD'-related +- * control commands on their own. Without this flag, ENGINE_ctrl() handles +- * these control commands on behalf of the ENGINE using their "cmd_defns" +- * data. +- */ +-# define ENGINE_FLAGS_MANUAL_CMD_CTRL (int)0x0002 +- +-/* +- * This flag is for ENGINEs who return new duplicate structures when found +- * via "ENGINE_by_id()". When an ENGINE must store state (eg. if +- * ENGINE_ctrl() commands are called in sequence as part of some stateful +- * process like key-generation setup and execution), it can set this flag - +- * then each attempt to obtain the ENGINE will result in it being copied into +- * a new structure. Normally, ENGINEs don't declare this flag so +- * ENGINE_by_id() just increments the existing ENGINE's structural reference +- * count. +- */ +-# define ENGINE_FLAGS_BY_ID_COPY (int)0x0004 +- +-/* +- * This flag if for an ENGINE that does not want its methods registered as +- * part of ENGINE_register_all_complete() for example if the methods are not +- * usable as default methods. +- */ +- +-# define ENGINE_FLAGS_NO_REGISTER_ALL (int)0x0008 +- +-/* +- * ENGINEs can support their own command types, and these flags are used in +- * ENGINE_CTRL_GET_CMD_FLAGS to indicate to the caller what kind of input +- * each command expects. Currently only numeric and string input is +- * supported. If a control command supports none of the _NUMERIC, _STRING, or +- * _NO_INPUT options, then it is regarded as an "internal" control command - +- * and not for use in config setting situations. As such, they're not +- * available to the ENGINE_ctrl_cmd_string() function, only raw ENGINE_ctrl() +- * access. Changes to this list of 'command types' should be reflected +- * carefully in ENGINE_cmd_is_executable() and ENGINE_ctrl_cmd_string(). +- */ +- +-/* accepts a 'long' input value (3rd parameter to ENGINE_ctrl) */ +-# define ENGINE_CMD_FLAG_NUMERIC (unsigned int)0x0001 +-/* +- * accepts string input (cast from 'void*' to 'const char *', 4th parameter +- * to ENGINE_ctrl) +- */ +-# define ENGINE_CMD_FLAG_STRING (unsigned int)0x0002 +-/* +- * Indicates that the control command takes *no* input. Ie. the control +- * command is unparameterised. +- */ +-# define ENGINE_CMD_FLAG_NO_INPUT (unsigned int)0x0004 +-/* +- * Indicates that the control command is internal. This control command won't +- * be shown in any output, and is only usable through the ENGINE_ctrl_cmd() +- * function. +- */ +-# define ENGINE_CMD_FLAG_INTERNAL (unsigned int)0x0008 +- +-/* +- * NB: These 3 control commands are deprecated and should not be used. +- * ENGINEs relying on these commands should compile conditional support for +- * compatibility (eg. if these symbols are defined) but should also migrate +- * the same functionality to their own ENGINE-specific control functions that +- * can be "discovered" by calling applications. The fact these control +- * commands wouldn't be "executable" (ie. usable by text-based config) +- * doesn't change the fact that application code can find and use them +- * without requiring per-ENGINE hacking. +- */ +- +-/* +- * These flags are used to tell the ctrl function what should be done. All +- * command numbers are shared between all engines, even if some don't make +- * sense to some engines. In such a case, they do nothing but return the +- * error ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED. +- */ +-# define ENGINE_CTRL_SET_LOGSTREAM 1 +-# define ENGINE_CTRL_SET_PASSWORD_CALLBACK 2 +-# define ENGINE_CTRL_HUP 3/* Close and reinitialise +- * any handles/connections +- * etc. */ +-# define ENGINE_CTRL_SET_USER_INTERFACE 4/* Alternative to callback */ +-# define ENGINE_CTRL_SET_CALLBACK_DATA 5/* User-specific data, used +- * when calling the password +- * callback and the user +- * interface */ +-# define ENGINE_CTRL_LOAD_CONFIGURATION 6/* Load a configuration, +- * given a string that +- * represents a file name +- * or so */ +-# define ENGINE_CTRL_LOAD_SECTION 7/* Load data from a given +- * section in the already +- * loaded configuration */ +- +-/* +- * These control commands allow an application to deal with an arbitrary +- * engine in a dynamic way. Warn: Negative return values indicate errors FOR +- * THESE COMMANDS because zero is used to indicate 'end-of-list'. Other +- * commands, including ENGINE-specific command types, return zero for an +- * error. An ENGINE can choose to implement these ctrl functions, and can +- * internally manage things however it chooses - it does so by setting the +- * ENGINE_FLAGS_MANUAL_CMD_CTRL flag (using ENGINE_set_flags()). Otherwise +- * the ENGINE_ctrl() code handles this on the ENGINE's behalf using the +- * cmd_defns data (set using ENGINE_set_cmd_defns()). This means an ENGINE's +- * ctrl() handler need only implement its own commands - the above "meta" +- * commands will be taken care of. +- */ +- +-/* +- * Returns non-zero if the supplied ENGINE has a ctrl() handler. If "not", +- * then all the remaining control commands will return failure, so it is +- * worth checking this first if the caller is trying to "discover" the +- * engine's capabilities and doesn't want errors generated unnecessarily. +- */ +-# define ENGINE_CTRL_HAS_CTRL_FUNCTION 10 +-/* +- * Returns a positive command number for the first command supported by the +- * engine. Returns zero if no ctrl commands are supported. +- */ +-# define ENGINE_CTRL_GET_FIRST_CMD_TYPE 11 +-/* +- * The 'long' argument specifies a command implemented by the engine, and the +- * return value is the next command supported, or zero if there are no more. +- */ +-# define ENGINE_CTRL_GET_NEXT_CMD_TYPE 12 +-/* +- * The 'void*' argument is a command name (cast from 'const char *'), and the +- * return value is the command that corresponds to it. +- */ +-# define ENGINE_CTRL_GET_CMD_FROM_NAME 13 +-/* +- * The next two allow a command to be converted into its corresponding string +- * form. In each case, the 'long' argument supplies the command. In the +- * NAME_LEN case, the return value is the length of the command name (not +- * counting a trailing EOL). In the NAME case, the 'void*' argument must be a +- * string buffer large enough, and it will be populated with the name of the +- * command (WITH a trailing EOL). +- */ +-# define ENGINE_CTRL_GET_NAME_LEN_FROM_CMD 14 +-# define ENGINE_CTRL_GET_NAME_FROM_CMD 15 +-/* The next two are similar but give a "short description" of a command. */ +-# define ENGINE_CTRL_GET_DESC_LEN_FROM_CMD 16 +-# define ENGINE_CTRL_GET_DESC_FROM_CMD 17 +-/* +- * With this command, the return value is the OR'd combination of +- * ENGINE_CMD_FLAG_*** values that indicate what kind of input a given +- * engine-specific ctrl command expects. +- */ +-# define ENGINE_CTRL_GET_CMD_FLAGS 18 +- +-/* +- * ENGINE implementations should start the numbering of their own control +- * commands from this value. (ie. ENGINE_CMD_BASE, ENGINE_CMD_BASE + 1, etc). +- */ +-# define ENGINE_CMD_BASE 200 +- +-/* +- * NB: These 2 nCipher "chil" control commands are deprecated, and their +- * functionality is now available through ENGINE-specific control commands +- * (exposed through the above-mentioned 'CMD'-handling). Code using these 2 +- * commands should be migrated to the more general command handling before +- * these are removed. +- */ +- +-/* Flags specific to the nCipher "chil" engine */ +-# define ENGINE_CTRL_CHIL_SET_FORKCHECK 100 +- /* +- * Depending on the value of the (long)i argument, this sets or +- * unsets the SimpleForkCheck flag in the CHIL API to enable or +- * disable checking and workarounds for applications that fork(). +- */ +-# define ENGINE_CTRL_CHIL_NO_LOCKING 101 +- /* +- * This prevents the initialisation function from providing mutex +- * callbacks to the nCipher library. +- */ +- +-/* +- * If an ENGINE supports its own specific control commands and wishes the +- * framework to handle the above 'ENGINE_CMD_***'-manipulation commands on +- * its behalf, it should supply a null-terminated array of ENGINE_CMD_DEFN +- * entries to ENGINE_set_cmd_defns(). It should also implement a ctrl() +- * handler that supports the stated commands (ie. the "cmd_num" entries as +- * described by the array). NB: The array must be ordered in increasing order +- * of cmd_num. "null-terminated" means that the last ENGINE_CMD_DEFN element +- * has cmd_num set to zero and/or cmd_name set to NULL. +- */ +-typedef struct ENGINE_CMD_DEFN_st { +- unsigned int cmd_num; /* The command number */ +- const char *cmd_name; /* The command name itself */ +- const char *cmd_desc; /* A short description of the command */ +- unsigned int cmd_flags; /* The input the command expects */ +-} ENGINE_CMD_DEFN; +- +-/* Generic function pointer */ +-typedef int (*ENGINE_GEN_FUNC_PTR) (void); +-/* Generic function pointer taking no arguments */ +-typedef int (*ENGINE_GEN_INT_FUNC_PTR) (ENGINE *); +-/* Specific control function pointer */ +-typedef int (*ENGINE_CTRL_FUNC_PTR) (ENGINE *, int, long, void *, +- void (*f) (void)); +-/* Generic load_key function pointer */ +-typedef EVP_PKEY *(*ENGINE_LOAD_KEY_PTR)(ENGINE *, const char *, +- UI_METHOD *ui_method, +- void *callback_data); +-typedef int (*ENGINE_SSL_CLIENT_CERT_PTR) (ENGINE *, SSL *ssl, +- STACK_OF(X509_NAME) *ca_dn, +- X509 **pcert, EVP_PKEY **pkey, +- STACK_OF(X509) **pother, +- UI_METHOD *ui_method, +- void *callback_data); +-/*- +- * These callback types are for an ENGINE's handler for cipher and digest logic. +- * These handlers have these prototypes; +- * int foo(ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid); +- * int foo(ENGINE *e, const EVP_MD **digest, const int **nids, int nid); +- * Looking at how to implement these handlers in the case of cipher support, if +- * the framework wants the EVP_CIPHER for 'nid', it will call; +- * foo(e, &p_evp_cipher, NULL, nid); (return zero for failure) +- * If the framework wants a list of supported 'nid's, it will call; +- * foo(e, NULL, &p_nids, 0); (returns number of 'nids' or -1 for error) +- */ +-/* +- * Returns to a pointer to the array of supported cipher 'nid's. If the +- * second parameter is non-NULL it is set to the size of the returned array. +- */ +-typedef int (*ENGINE_CIPHERS_PTR) (ENGINE *, const EVP_CIPHER **, +- const int **, int); +-typedef int (*ENGINE_DIGESTS_PTR) (ENGINE *, const EVP_MD **, const int **, +- int); +-typedef int (*ENGINE_PKEY_METHS_PTR) (ENGINE *, EVP_PKEY_METHOD **, +- const int **, int); +-typedef int (*ENGINE_PKEY_ASN1_METHS_PTR) (ENGINE *, EVP_PKEY_ASN1_METHOD **, +- const int **, int); +-/* +- * STRUCTURE functions ... all of these functions deal with pointers to +- * ENGINE structures where the pointers have a "structural reference". This +- * means that their reference is to allowed access to the structure but it +- * does not imply that the structure is functional. To simply increment or +- * decrement the structural reference count, use ENGINE_by_id and +- * ENGINE_free. NB: This is not required when iterating using ENGINE_get_next +- * as it will automatically decrement the structural reference count of the +- * "current" ENGINE and increment the structural reference count of the +- * ENGINE it returns (unless it is NULL). +- */ +- +-/* Get the first/last "ENGINE" type available. */ +-ENGINE *ENGINE_get_first(void); +-ENGINE *ENGINE_get_last(void); +-/* Iterate to the next/previous "ENGINE" type (NULL = end of the list). */ +-ENGINE *ENGINE_get_next(ENGINE *e); +-ENGINE *ENGINE_get_prev(ENGINE *e); +-/* Add another "ENGINE" type into the array. */ +-int ENGINE_add(ENGINE *e); +-/* Remove an existing "ENGINE" type from the array. */ +-int ENGINE_remove(ENGINE *e); +-/* Retrieve an engine from the list by its unique "id" value. */ +-ENGINE *ENGINE_by_id(const char *id); +- +-#if OPENSSL_API_COMPAT < 0x10100000L +-# define ENGINE_load_openssl() \ +- OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_OPENSSL, NULL) +-# define ENGINE_load_dynamic() \ +- OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_DYNAMIC, NULL) +-# ifndef OPENSSL_NO_STATIC_ENGINE +-# define ENGINE_load_padlock() \ +- OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_PADLOCK, NULL) +-# define ENGINE_load_capi() \ +- OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_CAPI, NULL) +-# define ENGINE_load_afalg() \ +- OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_AFALG, NULL) +-# endif +-# define ENGINE_load_cryptodev() \ +- OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_CRYPTODEV, NULL) +-# define ENGINE_load_rdrand() \ +- OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_RDRAND, NULL) +-#endif +-void ENGINE_load_builtin_engines(void); +- +-/* +- * Get and set global flags (ENGINE_TABLE_FLAG_***) for the implementation +- * "registry" handling. +- */ +-unsigned int ENGINE_get_table_flags(void); +-void ENGINE_set_table_flags(unsigned int flags); +- +-/*- Manage registration of ENGINEs per "table". For each type, there are 3 +- * functions; +- * ENGINE_register_***(e) - registers the implementation from 'e' (if it has one) +- * ENGINE_unregister_***(e) - unregister the implementation from 'e' +- * ENGINE_register_all_***() - call ENGINE_register_***() for each 'e' in the list +- * Cleanup is automatically registered from each table when required. +- */ +- +-int ENGINE_register_RSA(ENGINE *e); +-void ENGINE_unregister_RSA(ENGINE *e); +-void ENGINE_register_all_RSA(void); +- +-int ENGINE_register_DSA(ENGINE *e); +-void ENGINE_unregister_DSA(ENGINE *e); +-void ENGINE_register_all_DSA(void); +- +-int ENGINE_register_EC(ENGINE *e); +-void ENGINE_unregister_EC(ENGINE *e); +-void ENGINE_register_all_EC(void); +- +-int ENGINE_register_DH(ENGINE *e); +-void ENGINE_unregister_DH(ENGINE *e); +-void ENGINE_register_all_DH(void); +- +-int ENGINE_register_RAND(ENGINE *e); +-void ENGINE_unregister_RAND(ENGINE *e); +-void ENGINE_register_all_RAND(void); +- +-int ENGINE_register_ciphers(ENGINE *e); +-void ENGINE_unregister_ciphers(ENGINE *e); +-void ENGINE_register_all_ciphers(void); +- +-int ENGINE_register_digests(ENGINE *e); +-void ENGINE_unregister_digests(ENGINE *e); +-void ENGINE_register_all_digests(void); +- +-int ENGINE_register_pkey_meths(ENGINE *e); +-void ENGINE_unregister_pkey_meths(ENGINE *e); +-void ENGINE_register_all_pkey_meths(void); +- +-int ENGINE_register_pkey_asn1_meths(ENGINE *e); +-void ENGINE_unregister_pkey_asn1_meths(ENGINE *e); +-void ENGINE_register_all_pkey_asn1_meths(void); +- +-/* +- * These functions register all support from the above categories. Note, use +- * of these functions can result in static linkage of code your application +- * may not need. If you only need a subset of functionality, consider using +- * more selective initialisation. +- */ +-int ENGINE_register_complete(ENGINE *e); +-int ENGINE_register_all_complete(void); +- +-/* +- * Send parameterised control commands to the engine. The possibilities to +- * send down an integer, a pointer to data or a function pointer are +- * provided. Any of the parameters may or may not be NULL, depending on the +- * command number. In actuality, this function only requires a structural +- * (rather than functional) reference to an engine, but many control commands +- * may require the engine be functional. The caller should be aware of trying +- * commands that require an operational ENGINE, and only use functional +- * references in such situations. +- */ +-int ENGINE_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) (void)); +- +-/* +- * This function tests if an ENGINE-specific command is usable as a +- * "setting". Eg. in an application's config file that gets processed through +- * ENGINE_ctrl_cmd_string(). If this returns zero, it is not available to +- * ENGINE_ctrl_cmd_string(), only ENGINE_ctrl(). +- */ +-int ENGINE_cmd_is_executable(ENGINE *e, int cmd); +- +-/* +- * This function works like ENGINE_ctrl() with the exception of taking a +- * command name instead of a command number, and can handle optional +- * commands. See the comment on ENGINE_ctrl_cmd_string() for an explanation +- * on how to use the cmd_name and cmd_optional. +- */ +-int ENGINE_ctrl_cmd(ENGINE *e, const char *cmd_name, +- long i, void *p, void (*f) (void), int cmd_optional); +- +-/* +- * This function passes a command-name and argument to an ENGINE. The +- * cmd_name is converted to a command number and the control command is +- * called using 'arg' as an argument (unless the ENGINE doesn't support such +- * a command, in which case no control command is called). The command is +- * checked for input flags, and if necessary the argument will be converted +- * to a numeric value. If cmd_optional is non-zero, then if the ENGINE +- * doesn't support the given cmd_name the return value will be success +- * anyway. This function is intended for applications to use so that users +- * (or config files) can supply engine-specific config data to the ENGINE at +- * run-time to control behaviour of specific engines. As such, it shouldn't +- * be used for calling ENGINE_ctrl() functions that return data, deal with +- * binary data, or that are otherwise supposed to be used directly through +- * ENGINE_ctrl() in application code. Any "return" data from an ENGINE_ctrl() +- * operation in this function will be lost - the return value is interpreted +- * as failure if the return value is zero, success otherwise, and this +- * function returns a boolean value as a result. In other words, vendors of +- * 'ENGINE'-enabled devices should write ENGINE implementations with +- * parameterisations that work in this scheme, so that compliant ENGINE-based +- * applications can work consistently with the same configuration for the +- * same ENGINE-enabled devices, across applications. +- */ +-int ENGINE_ctrl_cmd_string(ENGINE *e, const char *cmd_name, const char *arg, +- int cmd_optional); +- +-/* +- * These functions are useful for manufacturing new ENGINE structures. They +- * don't address reference counting at all - one uses them to populate an +- * ENGINE structure with personalised implementations of things prior to +- * using it directly or adding it to the builtin ENGINE list in OpenSSL. +- * These are also here so that the ENGINE structure doesn't have to be +- * exposed and break binary compatibility! +- */ +-ENGINE *ENGINE_new(void); +-int ENGINE_free(ENGINE *e); +-int ENGINE_up_ref(ENGINE *e); +-int ENGINE_set_id(ENGINE *e, const char *id); +-int ENGINE_set_name(ENGINE *e, const char *name); +-int ENGINE_set_RSA(ENGINE *e, const RSA_METHOD *rsa_meth); +-int ENGINE_set_DSA(ENGINE *e, const DSA_METHOD *dsa_meth); +-int ENGINE_set_EC(ENGINE *e, const EC_KEY_METHOD *ecdsa_meth); +-int ENGINE_set_DH(ENGINE *e, const DH_METHOD *dh_meth); +-int ENGINE_set_RAND(ENGINE *e, const RAND_METHOD *rand_meth); +-int ENGINE_set_destroy_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR destroy_f); +-int ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f); +-int ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f); +-int ENGINE_set_ctrl_function(ENGINE *e, ENGINE_CTRL_FUNC_PTR ctrl_f); +-int ENGINE_set_load_privkey_function(ENGINE *e, +- ENGINE_LOAD_KEY_PTR loadpriv_f); +-int ENGINE_set_load_pubkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpub_f); +-int ENGINE_set_load_ssl_client_cert_function(ENGINE *e, +- ENGINE_SSL_CLIENT_CERT_PTR +- loadssl_f); +-int ENGINE_set_ciphers(ENGINE *e, ENGINE_CIPHERS_PTR f); +-int ENGINE_set_digests(ENGINE *e, ENGINE_DIGESTS_PTR f); +-int ENGINE_set_pkey_meths(ENGINE *e, ENGINE_PKEY_METHS_PTR f); +-int ENGINE_set_pkey_asn1_meths(ENGINE *e, ENGINE_PKEY_ASN1_METHS_PTR f); +-int ENGINE_set_flags(ENGINE *e, int flags); +-int ENGINE_set_cmd_defns(ENGINE *e, const ENGINE_CMD_DEFN *defns); +-/* These functions allow control over any per-structure ENGINE data. */ +-#define ENGINE_get_ex_new_index(l, p, newf, dupf, freef) \ +- CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_ENGINE, l, p, newf, dupf, freef) +-int ENGINE_set_ex_data(ENGINE *e, int idx, void *arg); +-void *ENGINE_get_ex_data(const ENGINE *e, int idx); +- +-#if OPENSSL_API_COMPAT < 0x10100000L +-/* +- * This function previously cleaned up anything that needs it. Auto-deinit will +- * now take care of it so it is no longer required to call this function. +- */ +-# define ENGINE_cleanup() while(0) continue +-#endif +- +-/* +- * These return values from within the ENGINE structure. These can be useful +- * with functional references as well as structural references - it depends +- * which you obtained. Using the result for functional purposes if you only +- * obtained a structural reference may be problematic! +- */ +-const char *ENGINE_get_id(const ENGINE *e); +-const char *ENGINE_get_name(const ENGINE *e); +-const RSA_METHOD *ENGINE_get_RSA(const ENGINE *e); +-const DSA_METHOD *ENGINE_get_DSA(const ENGINE *e); +-const EC_KEY_METHOD *ENGINE_get_EC(const ENGINE *e); +-const DH_METHOD *ENGINE_get_DH(const ENGINE *e); +-const RAND_METHOD *ENGINE_get_RAND(const ENGINE *e); +-ENGINE_GEN_INT_FUNC_PTR ENGINE_get_destroy_function(const ENGINE *e); +-ENGINE_GEN_INT_FUNC_PTR ENGINE_get_init_function(const ENGINE *e); +-ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE *e); +-ENGINE_CTRL_FUNC_PTR ENGINE_get_ctrl_function(const ENGINE *e); +-ENGINE_LOAD_KEY_PTR ENGINE_get_load_privkey_function(const ENGINE *e); +-ENGINE_LOAD_KEY_PTR ENGINE_get_load_pubkey_function(const ENGINE *e); +-ENGINE_SSL_CLIENT_CERT_PTR ENGINE_get_ssl_client_cert_function(const ENGINE +- *e); +-ENGINE_CIPHERS_PTR ENGINE_get_ciphers(const ENGINE *e); +-ENGINE_DIGESTS_PTR ENGINE_get_digests(const ENGINE *e); +-ENGINE_PKEY_METHS_PTR ENGINE_get_pkey_meths(const ENGINE *e); +-ENGINE_PKEY_ASN1_METHS_PTR ENGINE_get_pkey_asn1_meths(const ENGINE *e); +-const EVP_CIPHER *ENGINE_get_cipher(ENGINE *e, int nid); +-const EVP_MD *ENGINE_get_digest(ENGINE *e, int nid); +-const EVP_PKEY_METHOD *ENGINE_get_pkey_meth(ENGINE *e, int nid); +-const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth(ENGINE *e, int nid); +-const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth_str(ENGINE *e, +- const char *str, +- int len); +-const EVP_PKEY_ASN1_METHOD *ENGINE_pkey_asn1_find_str(ENGINE **pe, +- const char *str, +- int len); +-const ENGINE_CMD_DEFN *ENGINE_get_cmd_defns(const ENGINE *e); +-int ENGINE_get_flags(const ENGINE *e); +- +-/* +- * FUNCTIONAL functions. These functions deal with ENGINE structures that +- * have (or will) be initialised for use. Broadly speaking, the structural +- * functions are useful for iterating the list of available engine types, +- * creating new engine types, and other "list" operations. These functions +- * actually deal with ENGINEs that are to be used. As such these functions +- * can fail (if applicable) when particular engines are unavailable - eg. if +- * a hardware accelerator is not attached or not functioning correctly. Each +- * ENGINE has 2 reference counts; structural and functional. Every time a +- * functional reference is obtained or released, a corresponding structural +- * reference is automatically obtained or released too. +- */ +- +-/* +- * Initialise a engine type for use (or up its reference count if it's +- * already in use). This will fail if the engine is not currently operational +- * and cannot initialise. +- */ +-int ENGINE_init(ENGINE *e); +-/* +- * Free a functional reference to a engine type. This does not require a +- * corresponding call to ENGINE_free as it also releases a structural +- * reference. +- */ +-int ENGINE_finish(ENGINE *e); +- +-/* +- * The following functions handle keys that are stored in some secondary +- * location, handled by the engine. The storage may be on a card or +- * whatever. +- */ +-EVP_PKEY *ENGINE_load_private_key(ENGINE *e, const char *key_id, +- UI_METHOD *ui_method, void *callback_data); +-EVP_PKEY *ENGINE_load_public_key(ENGINE *e, const char *key_id, +- UI_METHOD *ui_method, void *callback_data); +-int ENGINE_load_ssl_client_cert(ENGINE *e, SSL *s, +- STACK_OF(X509_NAME) *ca_dn, X509 **pcert, +- EVP_PKEY **ppkey, STACK_OF(X509) **pother, +- UI_METHOD *ui_method, void *callback_data); +- +-/* +- * This returns a pointer for the current ENGINE structure that is (by +- * default) performing any RSA operations. The value returned is an +- * incremented reference, so it should be free'd (ENGINE_finish) before it is +- * discarded. +- */ +-ENGINE *ENGINE_get_default_RSA(void); +-/* Same for the other "methods" */ +-ENGINE *ENGINE_get_default_DSA(void); +-ENGINE *ENGINE_get_default_EC(void); +-ENGINE *ENGINE_get_default_DH(void); +-ENGINE *ENGINE_get_default_RAND(void); +-/* +- * These functions can be used to get a functional reference to perform +- * ciphering or digesting corresponding to "nid". +- */ +-ENGINE *ENGINE_get_cipher_engine(int nid); +-ENGINE *ENGINE_get_digest_engine(int nid); +-ENGINE *ENGINE_get_pkey_meth_engine(int nid); +-ENGINE *ENGINE_get_pkey_asn1_meth_engine(int nid); +- +-/* +- * This sets a new default ENGINE structure for performing RSA operations. If +- * the result is non-zero (success) then the ENGINE structure will have had +- * its reference count up'd so the caller should still free their own +- * reference 'e'. +- */ +-int ENGINE_set_default_RSA(ENGINE *e); +-int ENGINE_set_default_string(ENGINE *e, const char *def_list); +-/* Same for the other "methods" */ +-int ENGINE_set_default_DSA(ENGINE *e); +-int ENGINE_set_default_EC(ENGINE *e); +-int ENGINE_set_default_DH(ENGINE *e); +-int ENGINE_set_default_RAND(ENGINE *e); +-int ENGINE_set_default_ciphers(ENGINE *e); +-int ENGINE_set_default_digests(ENGINE *e); +-int ENGINE_set_default_pkey_meths(ENGINE *e); +-int ENGINE_set_default_pkey_asn1_meths(ENGINE *e); +- +-/* +- * The combination "set" - the flags are bitwise "OR"d from the +- * ENGINE_METHOD_*** defines above. As with the "ENGINE_register_complete()" +- * function, this function can result in unnecessary static linkage. If your +- * application requires only specific functionality, consider using more +- * selective functions. +- */ +-int ENGINE_set_default(ENGINE *e, unsigned int flags); +- +-void ENGINE_add_conf_module(void); +- +-/* Deprecated functions ... */ +-/* int ENGINE_clear_defaults(void); */ +- +-/**************************/ +-/* DYNAMIC ENGINE SUPPORT */ +-/**************************/ +- +-/* Binary/behaviour compatibility levels */ +-# define OSSL_DYNAMIC_VERSION (unsigned long)0x00030000 +-/* +- * Binary versions older than this are too old for us (whether we're a loader +- * or a loadee) +- */ +-# define OSSL_DYNAMIC_OLDEST (unsigned long)0x00030000 +- +-/* +- * When compiling an ENGINE entirely as an external shared library, loadable +- * by the "dynamic" ENGINE, these types are needed. The 'dynamic_fns' +- * structure type provides the calling application's (or library's) error +- * functionality and memory management function pointers to the loaded +- * library. These should be used/set in the loaded library code so that the +- * loading application's 'state' will be used/changed in all operations. The +- * 'static_state' pointer allows the loaded library to know if it shares the +- * same static data as the calling application (or library), and thus whether +- * these callbacks need to be set or not. +- */ +-typedef void *(*dyn_MEM_malloc_fn) (size_t, const char *, int); +-typedef void *(*dyn_MEM_realloc_fn) (void *, size_t, const char *, int); +-typedef void (*dyn_MEM_free_fn) (void *, const char *, int); +-typedef struct st_dynamic_MEM_fns { +- dyn_MEM_malloc_fn malloc_fn; +- dyn_MEM_realloc_fn realloc_fn; +- dyn_MEM_free_fn free_fn; +-} dynamic_MEM_fns; +-/* +- * FIXME: Perhaps the memory and locking code (crypto.h) should declare and +- * use these types so we (and any other dependent code) can simplify a bit?? +- */ +-/* The top-level structure */ +-typedef struct st_dynamic_fns { +- void *static_state; +- dynamic_MEM_fns mem_fns; +-} dynamic_fns; +- +-/* +- * The version checking function should be of this prototype. NB: The +- * ossl_version value passed in is the OSSL_DYNAMIC_VERSION of the loading +- * code. If this function returns zero, it indicates a (potential) version +- * incompatibility and the loaded library doesn't believe it can proceed. +- * Otherwise, the returned value is the (latest) version supported by the +- * loading library. The loader may still decide that the loaded code's +- * version is unsatisfactory and could veto the load. The function is +- * expected to be implemented with the symbol name "v_check", and a default +- * implementation can be fully instantiated with +- * IMPLEMENT_DYNAMIC_CHECK_FN(). +- */ +-typedef unsigned long (*dynamic_v_check_fn) (unsigned long ossl_version); +-# define IMPLEMENT_DYNAMIC_CHECK_FN() \ +- OPENSSL_EXPORT unsigned long v_check(unsigned long v); \ +- OPENSSL_EXPORT unsigned long v_check(unsigned long v) { \ +- if (v >= OSSL_DYNAMIC_OLDEST) return OSSL_DYNAMIC_VERSION; \ +- return 0; } +- +-/* +- * This function is passed the ENGINE structure to initialise with its own +- * function and command settings. It should not adjust the structural or +- * functional reference counts. If this function returns zero, (a) the load +- * will be aborted, (b) the previous ENGINE state will be memcpy'd back onto +- * the structure, and (c) the shared library will be unloaded. So +- * implementations should do their own internal cleanup in failure +- * circumstances otherwise they could leak. The 'id' parameter, if non-NULL, +- * represents the ENGINE id that the loader is looking for. If this is NULL, +- * the shared library can choose to return failure or to initialise a +- * 'default' ENGINE. If non-NULL, the shared library must initialise only an +- * ENGINE matching the passed 'id'. The function is expected to be +- * implemented with the symbol name "bind_engine". A standard implementation +- * can be instantiated with IMPLEMENT_DYNAMIC_BIND_FN(fn) where the parameter +- * 'fn' is a callback function that populates the ENGINE structure and +- * returns an int value (zero for failure). 'fn' should have prototype; +- * [static] int fn(ENGINE *e, const char *id); +- */ +-typedef int (*dynamic_bind_engine) (ENGINE *e, const char *id, +- const dynamic_fns *fns); +-# define IMPLEMENT_DYNAMIC_BIND_FN(fn) \ +- OPENSSL_EXPORT \ +- int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns); \ +- OPENSSL_EXPORT \ +- int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns) { \ +- if (ENGINE_get_static_state() == fns->static_state) goto skip_cbs; \ +- CRYPTO_set_mem_functions(fns->mem_fns.malloc_fn, \ +- fns->mem_fns.realloc_fn, \ +- fns->mem_fns.free_fn); \ +- skip_cbs: \ +- if (!fn(e, id)) return 0; \ +- return 1; } +- +-/* +- * If the loading application (or library) and the loaded ENGINE library +- * share the same static data (eg. they're both dynamically linked to the +- * same libcrypto.so) we need a way to avoid trying to set system callbacks - +- * this would fail, and for the same reason that it's unnecessary to try. If +- * the loaded ENGINE has (or gets from through the loader) its own copy of +- * the libcrypto static data, we will need to set the callbacks. The easiest +- * way to detect this is to have a function that returns a pointer to some +- * static data and let the loading application and loaded ENGINE compare +- * their respective values. +- */ +-void *ENGINE_get_static_state(void); +- +-# if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__) +-DEPRECATEDIN_1_1_0(void ENGINE_setup_bsd_cryptodev(void)) +-# endif +- +- +-# ifdef __cplusplus +-} +-# endif +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/engineerr.h b/uadk_tool/include/openssl/engineerr.h +deleted file mode 100644 +index 05e84bd..0000000 +--- a/uadk_tool/include/openssl/engineerr.h ++++ /dev/null +@@ -1,111 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_ENGINEERR_H +-# define HEADER_ENGINEERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# include +- +-# ifndef OPENSSL_NO_ENGINE +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_ENGINE_strings(void); +- +-/* +- * ENGINE function codes. +- */ +-# define ENGINE_F_DIGEST_UPDATE 198 +-# define ENGINE_F_DYNAMIC_CTRL 180 +-# define ENGINE_F_DYNAMIC_GET_DATA_CTX 181 +-# define ENGINE_F_DYNAMIC_LOAD 182 +-# define ENGINE_F_DYNAMIC_SET_DATA_CTX 183 +-# define ENGINE_F_ENGINE_ADD 105 +-# define ENGINE_F_ENGINE_BY_ID 106 +-# define ENGINE_F_ENGINE_CMD_IS_EXECUTABLE 170 +-# define ENGINE_F_ENGINE_CTRL 142 +-# define ENGINE_F_ENGINE_CTRL_CMD 178 +-# define ENGINE_F_ENGINE_CTRL_CMD_STRING 171 +-# define ENGINE_F_ENGINE_FINISH 107 +-# define ENGINE_F_ENGINE_GET_CIPHER 185 +-# define ENGINE_F_ENGINE_GET_DIGEST 186 +-# define ENGINE_F_ENGINE_GET_FIRST 195 +-# define ENGINE_F_ENGINE_GET_LAST 196 +-# define ENGINE_F_ENGINE_GET_NEXT 115 +-# define ENGINE_F_ENGINE_GET_PKEY_ASN1_METH 193 +-# define ENGINE_F_ENGINE_GET_PKEY_METH 192 +-# define ENGINE_F_ENGINE_GET_PREV 116 +-# define ENGINE_F_ENGINE_INIT 119 +-# define ENGINE_F_ENGINE_LIST_ADD 120 +-# define ENGINE_F_ENGINE_LIST_REMOVE 121 +-# define ENGINE_F_ENGINE_LOAD_PRIVATE_KEY 150 +-# define ENGINE_F_ENGINE_LOAD_PUBLIC_KEY 151 +-# define ENGINE_F_ENGINE_LOAD_SSL_CLIENT_CERT 194 +-# define ENGINE_F_ENGINE_NEW 122 +-# define ENGINE_F_ENGINE_PKEY_ASN1_FIND_STR 197 +-# define ENGINE_F_ENGINE_REMOVE 123 +-# define ENGINE_F_ENGINE_SET_DEFAULT_STRING 189 +-# define ENGINE_F_ENGINE_SET_ID 129 +-# define ENGINE_F_ENGINE_SET_NAME 130 +-# define ENGINE_F_ENGINE_TABLE_REGISTER 184 +-# define ENGINE_F_ENGINE_UNLOCKED_FINISH 191 +-# define ENGINE_F_ENGINE_UP_REF 190 +-# define ENGINE_F_INT_CLEANUP_ITEM 199 +-# define ENGINE_F_INT_CTRL_HELPER 172 +-# define ENGINE_F_INT_ENGINE_CONFIGURE 188 +-# define ENGINE_F_INT_ENGINE_MODULE_INIT 187 +-# define ENGINE_F_OSSL_HMAC_INIT 200 +- +-/* +- * ENGINE reason codes. +- */ +-# define ENGINE_R_ALREADY_LOADED 100 +-# define ENGINE_R_ARGUMENT_IS_NOT_A_NUMBER 133 +-# define ENGINE_R_CMD_NOT_EXECUTABLE 134 +-# define ENGINE_R_COMMAND_TAKES_INPUT 135 +-# define ENGINE_R_COMMAND_TAKES_NO_INPUT 136 +-# define ENGINE_R_CONFLICTING_ENGINE_ID 103 +-# define ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED 119 +-# define ENGINE_R_DSO_FAILURE 104 +-# define ENGINE_R_DSO_NOT_FOUND 132 +-# define ENGINE_R_ENGINES_SECTION_ERROR 148 +-# define ENGINE_R_ENGINE_CONFIGURATION_ERROR 102 +-# define ENGINE_R_ENGINE_IS_NOT_IN_LIST 105 +-# define ENGINE_R_ENGINE_SECTION_ERROR 149 +-# define ENGINE_R_FAILED_LOADING_PRIVATE_KEY 128 +-# define ENGINE_R_FAILED_LOADING_PUBLIC_KEY 129 +-# define ENGINE_R_FINISH_FAILED 106 +-# define ENGINE_R_ID_OR_NAME_MISSING 108 +-# define ENGINE_R_INIT_FAILED 109 +-# define ENGINE_R_INTERNAL_LIST_ERROR 110 +-# define ENGINE_R_INVALID_ARGUMENT 143 +-# define ENGINE_R_INVALID_CMD_NAME 137 +-# define ENGINE_R_INVALID_CMD_NUMBER 138 +-# define ENGINE_R_INVALID_INIT_VALUE 151 +-# define ENGINE_R_INVALID_STRING 150 +-# define ENGINE_R_NOT_INITIALISED 117 +-# define ENGINE_R_NOT_LOADED 112 +-# define ENGINE_R_NO_CONTROL_FUNCTION 120 +-# define ENGINE_R_NO_INDEX 144 +-# define ENGINE_R_NO_LOAD_FUNCTION 125 +-# define ENGINE_R_NO_REFERENCE 130 +-# define ENGINE_R_NO_SUCH_ENGINE 116 +-# define ENGINE_R_UNIMPLEMENTED_CIPHER 146 +-# define ENGINE_R_UNIMPLEMENTED_DIGEST 147 +-# define ENGINE_R_UNIMPLEMENTED_PUBLIC_KEY_METHOD 101 +-# define ENGINE_R_VERSION_INCOMPATIBILITY 145 +- +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/err.h b/uadk_tool/include/openssl/err.h +deleted file mode 100644 +index b49f881..0000000 +--- a/uadk_tool/include/openssl/err.h ++++ /dev/null +@@ -1,274 +0,0 @@ +-/* +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_ERR_H +-# define HEADER_ERR_H +- +-# include +- +-# ifndef OPENSSL_NO_STDIO +-# include +-# include +-# endif +- +-# include +-# include +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-# ifndef OPENSSL_NO_ERR +-# define ERR_PUT_error(a,b,c,d,e) ERR_put_error(a,b,c,d,e) +-# else +-# define ERR_PUT_error(a,b,c,d,e) ERR_put_error(a,b,c,NULL,0) +-# endif +- +-# include +- +-# define ERR_TXT_MALLOCED 0x01 +-# define ERR_TXT_STRING 0x02 +- +-# define ERR_FLAG_MARK 0x01 +-# define ERR_FLAG_CLEAR 0x02 +- +-# define ERR_NUM_ERRORS 16 +-typedef struct err_state_st { +- int err_flags[ERR_NUM_ERRORS]; +- unsigned long err_buffer[ERR_NUM_ERRORS]; +- char *err_data[ERR_NUM_ERRORS]; +- int err_data_flags[ERR_NUM_ERRORS]; +- const char *err_file[ERR_NUM_ERRORS]; +- int err_line[ERR_NUM_ERRORS]; +- int top, bottom; +-} ERR_STATE; +- +-/* library */ +-# define ERR_LIB_NONE 1 +-# define ERR_LIB_SYS 2 +-# define ERR_LIB_BN 3 +-# define ERR_LIB_RSA 4 +-# define ERR_LIB_DH 5 +-# define ERR_LIB_EVP 6 +-# define ERR_LIB_BUF 7 +-# define ERR_LIB_OBJ 8 +-# define ERR_LIB_PEM 9 +-# define ERR_LIB_DSA 10 +-# define ERR_LIB_X509 11 +-/* #define ERR_LIB_METH 12 */ +-# define ERR_LIB_ASN1 13 +-# define ERR_LIB_CONF 14 +-# define ERR_LIB_CRYPTO 15 +-# define ERR_LIB_EC 16 +-# define ERR_LIB_SSL 20 +-/* #define ERR_LIB_SSL23 21 */ +-/* #define ERR_LIB_SSL2 22 */ +-/* #define ERR_LIB_SSL3 23 */ +-/* #define ERR_LIB_RSAREF 30 */ +-/* #define ERR_LIB_PROXY 31 */ +-# define ERR_LIB_BIO 32 +-# define ERR_LIB_PKCS7 33 +-# define ERR_LIB_X509V3 34 +-# define ERR_LIB_PKCS12 35 +-# define ERR_LIB_RAND 36 +-# define ERR_LIB_DSO 37 +-# define ERR_LIB_ENGINE 38 +-# define ERR_LIB_OCSP 39 +-# define ERR_LIB_UI 40 +-# define ERR_LIB_COMP 41 +-# define ERR_LIB_ECDSA 42 +-# define ERR_LIB_ECDH 43 +-# define ERR_LIB_OSSL_STORE 44 +-# define ERR_LIB_FIPS 45 +-# define ERR_LIB_CMS 46 +-# define ERR_LIB_TS 47 +-# define ERR_LIB_HMAC 48 +-/* # define ERR_LIB_JPAKE 49 */ +-# define ERR_LIB_CT 50 +-# define ERR_LIB_ASYNC 51 +-# define ERR_LIB_KDF 52 +-# define ERR_LIB_SM2 53 +- +-# define ERR_LIB_USER 128 +- +-# define SYSerr(f,r) ERR_PUT_error(ERR_LIB_SYS,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define BNerr(f,r) ERR_PUT_error(ERR_LIB_BN,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define RSAerr(f,r) ERR_PUT_error(ERR_LIB_RSA,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define DHerr(f,r) ERR_PUT_error(ERR_LIB_DH,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define EVPerr(f,r) ERR_PUT_error(ERR_LIB_EVP,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define BUFerr(f,r) ERR_PUT_error(ERR_LIB_BUF,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define OBJerr(f,r) ERR_PUT_error(ERR_LIB_OBJ,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define PEMerr(f,r) ERR_PUT_error(ERR_LIB_PEM,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define DSAerr(f,r) ERR_PUT_error(ERR_LIB_DSA,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define X509err(f,r) ERR_PUT_error(ERR_LIB_X509,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define ASN1err(f,r) ERR_PUT_error(ERR_LIB_ASN1,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define CONFerr(f,r) ERR_PUT_error(ERR_LIB_CONF,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define CRYPTOerr(f,r) ERR_PUT_error(ERR_LIB_CRYPTO,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define ECerr(f,r) ERR_PUT_error(ERR_LIB_EC,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define SSLerr(f,r) ERR_PUT_error(ERR_LIB_SSL,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define BIOerr(f,r) ERR_PUT_error(ERR_LIB_BIO,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define PKCS7err(f,r) ERR_PUT_error(ERR_LIB_PKCS7,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define X509V3err(f,r) ERR_PUT_error(ERR_LIB_X509V3,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define PKCS12err(f,r) ERR_PUT_error(ERR_LIB_PKCS12,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define RANDerr(f,r) ERR_PUT_error(ERR_LIB_RAND,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define DSOerr(f,r) ERR_PUT_error(ERR_LIB_DSO,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define ENGINEerr(f,r) ERR_PUT_error(ERR_LIB_ENGINE,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define OCSPerr(f,r) ERR_PUT_error(ERR_LIB_OCSP,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define UIerr(f,r) ERR_PUT_error(ERR_LIB_UI,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define COMPerr(f,r) ERR_PUT_error(ERR_LIB_COMP,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define ECDSAerr(f,r) ERR_PUT_error(ERR_LIB_ECDSA,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define ECDHerr(f,r) ERR_PUT_error(ERR_LIB_ECDH,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define OSSL_STOREerr(f,r) ERR_PUT_error(ERR_LIB_OSSL_STORE,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define FIPSerr(f,r) ERR_PUT_error(ERR_LIB_FIPS,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define CMSerr(f,r) ERR_PUT_error(ERR_LIB_CMS,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define TSerr(f,r) ERR_PUT_error(ERR_LIB_TS,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define HMACerr(f,r) ERR_PUT_error(ERR_LIB_HMAC,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define CTerr(f,r) ERR_PUT_error(ERR_LIB_CT,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define ASYNCerr(f,r) ERR_PUT_error(ERR_LIB_ASYNC,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define KDFerr(f,r) ERR_PUT_error(ERR_LIB_KDF,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +-# define SM2err(f,r) ERR_PUT_error(ERR_LIB_SM2,(f),(r),OPENSSL_FILE,OPENSSL_LINE) +- +-# define ERR_PACK(l,f,r) ( \ +- (((unsigned int)(l) & 0x0FF) << 24L) | \ +- (((unsigned int)(f) & 0xFFF) << 12L) | \ +- (((unsigned int)(r) & 0xFFF) ) ) +-# define ERR_GET_LIB(l) (int)(((l) >> 24L) & 0x0FFL) +-# define ERR_GET_FUNC(l) (int)(((l) >> 12L) & 0xFFFL) +-# define ERR_GET_REASON(l) (int)( (l) & 0xFFFL) +-# define ERR_FATAL_ERROR(l) (int)( (l) & ERR_R_FATAL) +- +-/* OS functions */ +-# define SYS_F_FOPEN 1 +-# define SYS_F_CONNECT 2 +-# define SYS_F_GETSERVBYNAME 3 +-# define SYS_F_SOCKET 4 +-# define SYS_F_IOCTLSOCKET 5 +-# define SYS_F_BIND 6 +-# define SYS_F_LISTEN 7 +-# define SYS_F_ACCEPT 8 +-# define SYS_F_WSASTARTUP 9/* Winsock stuff */ +-# define SYS_F_OPENDIR 10 +-# define SYS_F_FREAD 11 +-# define SYS_F_GETADDRINFO 12 +-# define SYS_F_GETNAMEINFO 13 +-# define SYS_F_SETSOCKOPT 14 +-# define SYS_F_GETSOCKOPT 15 +-# define SYS_F_GETSOCKNAME 16 +-# define SYS_F_GETHOSTBYNAME 17 +-# define SYS_F_FFLUSH 18 +-# define SYS_F_OPEN 19 +-# define SYS_F_CLOSE 20 +-# define SYS_F_IOCTL 21 +-# define SYS_F_STAT 22 +-# define SYS_F_FCNTL 23 +-# define SYS_F_FSTAT 24 +- +-/* reasons */ +-# define ERR_R_SYS_LIB ERR_LIB_SYS/* 2 */ +-# define ERR_R_BN_LIB ERR_LIB_BN/* 3 */ +-# define ERR_R_RSA_LIB ERR_LIB_RSA/* 4 */ +-# define ERR_R_DH_LIB ERR_LIB_DH/* 5 */ +-# define ERR_R_EVP_LIB ERR_LIB_EVP/* 6 */ +-# define ERR_R_BUF_LIB ERR_LIB_BUF/* 7 */ +-# define ERR_R_OBJ_LIB ERR_LIB_OBJ/* 8 */ +-# define ERR_R_PEM_LIB ERR_LIB_PEM/* 9 */ +-# define ERR_R_DSA_LIB ERR_LIB_DSA/* 10 */ +-# define ERR_R_X509_LIB ERR_LIB_X509/* 11 */ +-# define ERR_R_ASN1_LIB ERR_LIB_ASN1/* 13 */ +-# define ERR_R_EC_LIB ERR_LIB_EC/* 16 */ +-# define ERR_R_BIO_LIB ERR_LIB_BIO/* 32 */ +-# define ERR_R_PKCS7_LIB ERR_LIB_PKCS7/* 33 */ +-# define ERR_R_X509V3_LIB ERR_LIB_X509V3/* 34 */ +-# define ERR_R_ENGINE_LIB ERR_LIB_ENGINE/* 38 */ +-# define ERR_R_UI_LIB ERR_LIB_UI/* 40 */ +-# define ERR_R_ECDSA_LIB ERR_LIB_ECDSA/* 42 */ +-# define ERR_R_OSSL_STORE_LIB ERR_LIB_OSSL_STORE/* 44 */ +- +-# define ERR_R_NESTED_ASN1_ERROR 58 +-# define ERR_R_MISSING_ASN1_EOS 63 +- +-/* fatal error */ +-# define ERR_R_FATAL 64 +-# define ERR_R_MALLOC_FAILURE (1|ERR_R_FATAL) +-# define ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED (2|ERR_R_FATAL) +-# define ERR_R_PASSED_NULL_PARAMETER (3|ERR_R_FATAL) +-# define ERR_R_INTERNAL_ERROR (4|ERR_R_FATAL) +-# define ERR_R_DISABLED (5|ERR_R_FATAL) +-# define ERR_R_INIT_FAIL (6|ERR_R_FATAL) +-# define ERR_R_PASSED_INVALID_ARGUMENT (7) +-# define ERR_R_OPERATION_FAIL (8|ERR_R_FATAL) +- +-/* +- * 99 is the maximum possible ERR_R_... code, higher values are reserved for +- * the individual libraries +- */ +- +-typedef struct ERR_string_data_st { +- unsigned long error; +- const char *string; +-} ERR_STRING_DATA; +- +-DEFINE_LHASH_OF(ERR_STRING_DATA); +- +-void ERR_put_error(int lib, int func, int reason, const char *file, int line); +-void ERR_set_error_data(char *data, int flags); +- +-unsigned long ERR_get_error(void); +-unsigned long ERR_get_error_line(const char **file, int *line); +-unsigned long ERR_get_error_line_data(const char **file, int *line, +- const char **data, int *flags); +-unsigned long ERR_peek_error(void); +-unsigned long ERR_peek_error_line(const char **file, int *line); +-unsigned long ERR_peek_error_line_data(const char **file, int *line, +- const char **data, int *flags); +-unsigned long ERR_peek_last_error(void); +-unsigned long ERR_peek_last_error_line(const char **file, int *line); +-unsigned long ERR_peek_last_error_line_data(const char **file, int *line, +- const char **data, int *flags); +-void ERR_clear_error(void); +-char *ERR_error_string(unsigned long e, char *buf); +-void ERR_error_string_n(unsigned long e, char *buf, size_t len); +-const char *ERR_lib_error_string(unsigned long e); +-const char *ERR_func_error_string(unsigned long e); +-const char *ERR_reason_error_string(unsigned long e); +-void ERR_print_errors_cb(int (*cb) (const char *str, size_t len, void *u), +- void *u); +-# ifndef OPENSSL_NO_STDIO +-void ERR_print_errors_fp(FILE *fp); +-# endif +-void ERR_print_errors(BIO *bp); +-void ERR_add_error_data(int num, ...); +-void ERR_add_error_vdata(int num, va_list args); +-int ERR_load_strings(int lib, ERR_STRING_DATA *str); +-int ERR_load_strings_const(const ERR_STRING_DATA *str); +-int ERR_unload_strings(int lib, ERR_STRING_DATA *str); +-int ERR_load_ERR_strings(void); +- +-#if OPENSSL_API_COMPAT < 0x10100000L +-# define ERR_load_crypto_strings() \ +- OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL) +-# define ERR_free_strings() while(0) continue +-#endif +- +-DEPRECATEDIN_1_1_0(void ERR_remove_thread_state(void *)) +-DEPRECATEDIN_1_0_0(void ERR_remove_state(unsigned long pid)) +-ERR_STATE *ERR_get_state(void); +- +-int ERR_get_next_error_library(void); +- +-int ERR_set_mark(void); +-int ERR_pop_to_mark(void); +-int ERR_clear_last_mark(void); +- +-#ifdef __cplusplus +-} +-#endif +- +-#endif +diff --git a/uadk_tool/include/openssl/evp.h b/uadk_tool/include/openssl/evp.h +deleted file mode 100644 +index a411f3f..0000000 +--- a/uadk_tool/include/openssl/evp.h ++++ /dev/null +@@ -1,1666 +0,0 @@ +-/* +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_ENVELOPE_H +-# define HEADER_ENVELOPE_H +- +-# include +-# include +-# include +-# include +-# include +- +-# define EVP_MAX_MD_SIZE 64/* longest known is SHA512 */ +-# define EVP_MAX_KEY_LENGTH 64 +-# define EVP_MAX_IV_LENGTH 16 +-# define EVP_MAX_BLOCK_LENGTH 32 +- +-# define PKCS5_SALT_LEN 8 +-/* Default PKCS#5 iteration count */ +-# define PKCS5_DEFAULT_ITER 2048 +- +-# include +- +-# define EVP_PK_RSA 0x0001 +-# define EVP_PK_DSA 0x0002 +-# define EVP_PK_DH 0x0004 +-# define EVP_PK_EC 0x0008 +-# define EVP_PKT_SIGN 0x0010 +-# define EVP_PKT_ENC 0x0020 +-# define EVP_PKT_EXCH 0x0040 +-# define EVP_PKS_RSA 0x0100 +-# define EVP_PKS_DSA 0x0200 +-# define EVP_PKS_EC 0x0400 +- +-# define EVP_PKEY_NONE NID_undef +-# define EVP_PKEY_RSA NID_rsaEncryption +-# define EVP_PKEY_RSA2 NID_rsa +-# define EVP_PKEY_RSA_PSS NID_rsassaPss +-# define EVP_PKEY_DSA NID_dsa +-# define EVP_PKEY_DSA1 NID_dsa_2 +-# define EVP_PKEY_DSA2 NID_dsaWithSHA +-# define EVP_PKEY_DSA3 NID_dsaWithSHA1 +-# define EVP_PKEY_DSA4 NID_dsaWithSHA1_2 +-# define EVP_PKEY_DH NID_dhKeyAgreement +-# define EVP_PKEY_DHX NID_dhpublicnumber +-# define EVP_PKEY_EC NID_X9_62_id_ecPublicKey +-# define EVP_PKEY_SM2 NID_sm2 +-# define EVP_PKEY_HMAC NID_hmac +-# define EVP_PKEY_CMAC NID_cmac +-# define EVP_PKEY_SCRYPT NID_id_scrypt +-# define EVP_PKEY_TLS1_PRF NID_tls1_prf +-# define EVP_PKEY_HKDF NID_hkdf +-# define EVP_PKEY_POLY1305 NID_poly1305 +-# define EVP_PKEY_SIPHASH NID_siphash +-# define EVP_PKEY_X25519 NID_X25519 +-# define EVP_PKEY_ED25519 NID_ED25519 +-# define EVP_PKEY_X448 NID_X448 +-# define EVP_PKEY_ED448 NID_ED448 +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-# define EVP_PKEY_MO_SIGN 0x0001 +-# define EVP_PKEY_MO_VERIFY 0x0002 +-# define EVP_PKEY_MO_ENCRYPT 0x0004 +-# define EVP_PKEY_MO_DECRYPT 0x0008 +- +-# ifndef EVP_MD +-EVP_MD *EVP_MD_meth_new(int md_type, int pkey_type); +-EVP_MD *EVP_MD_meth_dup(const EVP_MD *md); +-void EVP_MD_meth_free(EVP_MD *md); +- +-int EVP_MD_meth_set_input_blocksize(EVP_MD *md, int blocksize); +-int EVP_MD_meth_set_result_size(EVP_MD *md, int resultsize); +-int EVP_MD_meth_set_app_datasize(EVP_MD *md, int datasize); +-int EVP_MD_meth_set_flags(EVP_MD *md, unsigned long flags); +-int EVP_MD_meth_set_init(EVP_MD *md, int (*init)(EVP_MD_CTX *ctx)); +-int EVP_MD_meth_set_update(EVP_MD *md, int (*update)(EVP_MD_CTX *ctx, +- const void *data, +- size_t count)); +-int EVP_MD_meth_set_final(EVP_MD *md, int (*final)(EVP_MD_CTX *ctx, +- unsigned char *md)); +-int EVP_MD_meth_set_copy(EVP_MD *md, int (*copy)(EVP_MD_CTX *to, +- const EVP_MD_CTX *from)); +-int EVP_MD_meth_set_cleanup(EVP_MD *md, int (*cleanup)(EVP_MD_CTX *ctx)); +-int EVP_MD_meth_set_ctrl(EVP_MD *md, int (*ctrl)(EVP_MD_CTX *ctx, int cmd, +- int p1, void *p2)); +- +-int EVP_MD_meth_get_input_blocksize(const EVP_MD *md); +-int EVP_MD_meth_get_result_size(const EVP_MD *md); +-int EVP_MD_meth_get_app_datasize(const EVP_MD *md); +-unsigned long EVP_MD_meth_get_flags(const EVP_MD *md); +-int (*EVP_MD_meth_get_init(const EVP_MD *md))(EVP_MD_CTX *ctx); +-int (*EVP_MD_meth_get_update(const EVP_MD *md))(EVP_MD_CTX *ctx, +- const void *data, +- size_t count); +-int (*EVP_MD_meth_get_final(const EVP_MD *md))(EVP_MD_CTX *ctx, +- unsigned char *md); +-int (*EVP_MD_meth_get_copy(const EVP_MD *md))(EVP_MD_CTX *to, +- const EVP_MD_CTX *from); +-int (*EVP_MD_meth_get_cleanup(const EVP_MD *md))(EVP_MD_CTX *ctx); +-int (*EVP_MD_meth_get_ctrl(const EVP_MD *md))(EVP_MD_CTX *ctx, int cmd, +- int p1, void *p2); +- +-/* digest can only handle a single block */ +-# define EVP_MD_FLAG_ONESHOT 0x0001 +- +-/* digest is extensible-output function, XOF */ +-# define EVP_MD_FLAG_XOF 0x0002 +- +-/* DigestAlgorithmIdentifier flags... */ +- +-# define EVP_MD_FLAG_DIGALGID_MASK 0x0018 +- +-/* NULL or absent parameter accepted. Use NULL */ +- +-# define EVP_MD_FLAG_DIGALGID_NULL 0x0000 +- +-/* NULL or absent parameter accepted. Use NULL for PKCS#1 otherwise absent */ +- +-# define EVP_MD_FLAG_DIGALGID_ABSENT 0x0008 +- +-/* Custom handling via ctrl */ +- +-# define EVP_MD_FLAG_DIGALGID_CUSTOM 0x0018 +- +-/* Note if suitable for use in FIPS mode */ +-# define EVP_MD_FLAG_FIPS 0x0400 +- +-/* Digest ctrls */ +- +-# define EVP_MD_CTRL_DIGALGID 0x1 +-# define EVP_MD_CTRL_MICALG 0x2 +-# define EVP_MD_CTRL_XOF_LEN 0x3 +- +-/* Minimum Algorithm specific ctrl value */ +- +-# define EVP_MD_CTRL_ALG_CTRL 0x1000 +- +-# endif /* !EVP_MD */ +- +-/* values for EVP_MD_CTX flags */ +- +-# define EVP_MD_CTX_FLAG_ONESHOT 0x0001/* digest update will be +- * called once only */ +-# define EVP_MD_CTX_FLAG_CLEANED 0x0002/* context has already been +- * cleaned */ +-# define EVP_MD_CTX_FLAG_REUSE 0x0004/* Don't free up ctx->md_data +- * in EVP_MD_CTX_reset */ +-/* +- * FIPS and pad options are ignored in 1.0.0, definitions are here so we +- * don't accidentally reuse the values for other purposes. +- */ +- +-# define EVP_MD_CTX_FLAG_NON_FIPS_ALLOW 0x0008/* Allow use of non FIPS +- * digest in FIPS mode */ +- +-/* +- * The following PAD options are also currently ignored in 1.0.0, digest +- * parameters are handled through EVP_DigestSign*() and EVP_DigestVerify*() +- * instead. +- */ +-# define EVP_MD_CTX_FLAG_PAD_MASK 0xF0/* RSA mode to use */ +-# define EVP_MD_CTX_FLAG_PAD_PKCS1 0x00/* PKCS#1 v1.5 mode */ +-# define EVP_MD_CTX_FLAG_PAD_X931 0x10/* X9.31 mode */ +-# define EVP_MD_CTX_FLAG_PAD_PSS 0x20/* PSS mode */ +- +-# define EVP_MD_CTX_FLAG_NO_INIT 0x0100/* Don't initialize md_data */ +-/* +- * Some functions such as EVP_DigestSign only finalise copies of internal +- * contexts so additional data can be included after the finalisation call. +- * This is inefficient if this functionality is not required: it is disabled +- * if the following flag is set. +- */ +-# define EVP_MD_CTX_FLAG_FINALISE 0x0200 +-/* NOTE: 0x0400 is reserved for internal usage */ +- +-EVP_CIPHER *EVP_CIPHER_meth_new(int cipher_type, int block_size, int key_len); +-EVP_CIPHER *EVP_CIPHER_meth_dup(const EVP_CIPHER *cipher); +-void EVP_CIPHER_meth_free(EVP_CIPHER *cipher); +- +-int EVP_CIPHER_meth_set_iv_length(EVP_CIPHER *cipher, int iv_len); +-int EVP_CIPHER_meth_set_flags(EVP_CIPHER *cipher, unsigned long flags); +-int EVP_CIPHER_meth_set_impl_ctx_size(EVP_CIPHER *cipher, int ctx_size); +-int EVP_CIPHER_meth_set_init(EVP_CIPHER *cipher, +- int (*init) (EVP_CIPHER_CTX *ctx, +- const unsigned char *key, +- const unsigned char *iv, +- int enc)); +-int EVP_CIPHER_meth_set_do_cipher(EVP_CIPHER *cipher, +- int (*do_cipher) (EVP_CIPHER_CTX *ctx, +- unsigned char *out, +- const unsigned char *in, +- size_t inl)); +-int EVP_CIPHER_meth_set_cleanup(EVP_CIPHER *cipher, +- int (*cleanup) (EVP_CIPHER_CTX *)); +-int EVP_CIPHER_meth_set_set_asn1_params(EVP_CIPHER *cipher, +- int (*set_asn1_parameters) (EVP_CIPHER_CTX *, +- ASN1_TYPE *)); +-int EVP_CIPHER_meth_set_get_asn1_params(EVP_CIPHER *cipher, +- int (*get_asn1_parameters) (EVP_CIPHER_CTX *, +- ASN1_TYPE *)); +-int EVP_CIPHER_meth_set_ctrl(EVP_CIPHER *cipher, +- int (*ctrl) (EVP_CIPHER_CTX *, int type, +- int arg, void *ptr)); +- +-int (*EVP_CIPHER_meth_get_init(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *ctx, +- const unsigned char *key, +- const unsigned char *iv, +- int enc); +-int (*EVP_CIPHER_meth_get_do_cipher(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *ctx, +- unsigned char *out, +- const unsigned char *in, +- size_t inl); +-int (*EVP_CIPHER_meth_get_cleanup(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *); +-int (*EVP_CIPHER_meth_get_set_asn1_params(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *, +- ASN1_TYPE *); +-int (*EVP_CIPHER_meth_get_get_asn1_params(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *, +- ASN1_TYPE *); +-int (*EVP_CIPHER_meth_get_ctrl(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *, +- int type, int arg, +- void *ptr); +- +-/* Values for cipher flags */ +- +-/* Modes for ciphers */ +- +-# define EVP_CIPH_STREAM_CIPHER 0x0 +-# define EVP_CIPH_ECB_MODE 0x1 +-# define EVP_CIPH_CBC_MODE 0x2 +-# define EVP_CIPH_CFB_MODE 0x3 +-# define EVP_CIPH_OFB_MODE 0x4 +-# define EVP_CIPH_CTR_MODE 0x5 +-# define EVP_CIPH_GCM_MODE 0x6 +-# define EVP_CIPH_CCM_MODE 0x7 +-# define EVP_CIPH_XTS_MODE 0x10001 +-# define EVP_CIPH_WRAP_MODE 0x10002 +-# define EVP_CIPH_OCB_MODE 0x10003 +-# define EVP_CIPH_MODE 0xF0007 +-/* Set if variable length cipher */ +-# define EVP_CIPH_VARIABLE_LENGTH 0x8 +-/* Set if the iv handling should be done by the cipher itself */ +-# define EVP_CIPH_CUSTOM_IV 0x10 +-/* Set if the cipher's init() function should be called if key is NULL */ +-# define EVP_CIPH_ALWAYS_CALL_INIT 0x20 +-/* Call ctrl() to init cipher parameters */ +-# define EVP_CIPH_CTRL_INIT 0x40 +-/* Don't use standard key length function */ +-# define EVP_CIPH_CUSTOM_KEY_LENGTH 0x80 +-/* Don't use standard block padding */ +-# define EVP_CIPH_NO_PADDING 0x100 +-/* cipher handles random key generation */ +-# define EVP_CIPH_RAND_KEY 0x200 +-/* cipher has its own additional copying logic */ +-# define EVP_CIPH_CUSTOM_COPY 0x400 +-/* Don't use standard iv length function */ +-# define EVP_CIPH_CUSTOM_IV_LENGTH 0x800 +-/* Allow use default ASN1 get/set iv */ +-# define EVP_CIPH_FLAG_DEFAULT_ASN1 0x1000 +-/* Buffer length in bits not bytes: CFB1 mode only */ +-# define EVP_CIPH_FLAG_LENGTH_BITS 0x2000 +-/* Note if suitable for use in FIPS mode */ +-# define EVP_CIPH_FLAG_FIPS 0x4000 +-/* Allow non FIPS cipher in FIPS mode */ +-# define EVP_CIPH_FLAG_NON_FIPS_ALLOW 0x8000 +-/* +- * Cipher handles any and all padding logic as well as finalisation. +- */ +-# define EVP_CIPH_FLAG_CUSTOM_CIPHER 0x100000 +-# define EVP_CIPH_FLAG_AEAD_CIPHER 0x200000 +-# define EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK 0x400000 +-/* Cipher can handle pipeline operations */ +-# define EVP_CIPH_FLAG_PIPELINE 0X800000 +- +-/* +- * Cipher context flag to indicate we can handle wrap mode: if allowed in +- * older applications it could overflow buffers. +- */ +- +-# define EVP_CIPHER_CTX_FLAG_WRAP_ALLOW 0x1 +- +-/* ctrl() values */ +- +-# define EVP_CTRL_INIT 0x0 +-# define EVP_CTRL_SET_KEY_LENGTH 0x1 +-# define EVP_CTRL_GET_RC2_KEY_BITS 0x2 +-# define EVP_CTRL_SET_RC2_KEY_BITS 0x3 +-# define EVP_CTRL_GET_RC5_ROUNDS 0x4 +-# define EVP_CTRL_SET_RC5_ROUNDS 0x5 +-# define EVP_CTRL_RAND_KEY 0x6 +-# define EVP_CTRL_PBE_PRF_NID 0x7 +-# define EVP_CTRL_COPY 0x8 +-# define EVP_CTRL_AEAD_SET_IVLEN 0x9 +-# define EVP_CTRL_AEAD_GET_TAG 0x10 +-# define EVP_CTRL_AEAD_SET_TAG 0x11 +-# define EVP_CTRL_AEAD_SET_IV_FIXED 0x12 +-# define EVP_CTRL_GCM_SET_IVLEN EVP_CTRL_AEAD_SET_IVLEN +-# define EVP_CTRL_GCM_GET_TAG EVP_CTRL_AEAD_GET_TAG +-# define EVP_CTRL_GCM_SET_TAG EVP_CTRL_AEAD_SET_TAG +-# define EVP_CTRL_GCM_SET_IV_FIXED EVP_CTRL_AEAD_SET_IV_FIXED +-# define EVP_CTRL_GCM_IV_GEN 0x13 +-# define EVP_CTRL_CCM_SET_IVLEN EVP_CTRL_AEAD_SET_IVLEN +-# define EVP_CTRL_CCM_GET_TAG EVP_CTRL_AEAD_GET_TAG +-# define EVP_CTRL_CCM_SET_TAG EVP_CTRL_AEAD_SET_TAG +-# define EVP_CTRL_CCM_SET_IV_FIXED EVP_CTRL_AEAD_SET_IV_FIXED +-# define EVP_CTRL_CCM_SET_L 0x14 +-# define EVP_CTRL_CCM_SET_MSGLEN 0x15 +-/* +- * AEAD cipher deduces payload length and returns number of bytes required to +- * store MAC and eventual padding. Subsequent call to EVP_Cipher even +- * appends/verifies MAC. +- */ +-# define EVP_CTRL_AEAD_TLS1_AAD 0x16 +-/* Used by composite AEAD ciphers, no-op in GCM, CCM... */ +-# define EVP_CTRL_AEAD_SET_MAC_KEY 0x17 +-/* Set the GCM invocation field, decrypt only */ +-# define EVP_CTRL_GCM_SET_IV_INV 0x18 +- +-# define EVP_CTRL_TLS1_1_MULTIBLOCK_AAD 0x19 +-# define EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT 0x1a +-# define EVP_CTRL_TLS1_1_MULTIBLOCK_DECRYPT 0x1b +-# define EVP_CTRL_TLS1_1_MULTIBLOCK_MAX_BUFSIZE 0x1c +- +-# define EVP_CTRL_SSL3_MASTER_SECRET 0x1d +- +-/* EVP_CTRL_SET_SBOX takes the char * specifying S-boxes */ +-# define EVP_CTRL_SET_SBOX 0x1e +-/* +- * EVP_CTRL_SBOX_USED takes a 'size_t' and 'char *', pointing at a +- * pre-allocated buffer with specified size +- */ +-# define EVP_CTRL_SBOX_USED 0x1f +-/* EVP_CTRL_KEY_MESH takes 'size_t' number of bytes to mesh the key after, +- * 0 switches meshing off +- */ +-# define EVP_CTRL_KEY_MESH 0x20 +-/* EVP_CTRL_BLOCK_PADDING_MODE takes the padding mode */ +-# define EVP_CTRL_BLOCK_PADDING_MODE 0x21 +- +-/* Set the output buffers to use for a pipelined operation */ +-# define EVP_CTRL_SET_PIPELINE_OUTPUT_BUFS 0x22 +-/* Set the input buffers to use for a pipelined operation */ +-# define EVP_CTRL_SET_PIPELINE_INPUT_BUFS 0x23 +-/* Set the input buffer lengths to use for a pipelined operation */ +-# define EVP_CTRL_SET_PIPELINE_INPUT_LENS 0x24 +- +-# define EVP_CTRL_GET_IVLEN 0x25 +- +-/* Padding modes */ +-#define EVP_PADDING_PKCS7 1 +-#define EVP_PADDING_ISO7816_4 2 +-#define EVP_PADDING_ANSI923 3 +-#define EVP_PADDING_ISO10126 4 +-#define EVP_PADDING_ZERO 5 +- +-/* RFC 5246 defines additional data to be 13 bytes in length */ +-# define EVP_AEAD_TLS1_AAD_LEN 13 +- +-typedef struct { +- unsigned char *out; +- const unsigned char *inp; +- size_t len; +- unsigned int interleave; +-} EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM; +- +-/* GCM TLS constants */ +-/* Length of fixed part of IV derived from PRF */ +-# define EVP_GCM_TLS_FIXED_IV_LEN 4 +-/* Length of explicit part of IV part of TLS records */ +-# define EVP_GCM_TLS_EXPLICIT_IV_LEN 8 +-/* Length of tag for TLS */ +-# define EVP_GCM_TLS_TAG_LEN 16 +- +-/* CCM TLS constants */ +-/* Length of fixed part of IV derived from PRF */ +-# define EVP_CCM_TLS_FIXED_IV_LEN 4 +-/* Length of explicit part of IV part of TLS records */ +-# define EVP_CCM_TLS_EXPLICIT_IV_LEN 8 +-/* Total length of CCM IV length for TLS */ +-# define EVP_CCM_TLS_IV_LEN 12 +-/* Length of tag for TLS */ +-# define EVP_CCM_TLS_TAG_LEN 16 +-/* Length of CCM8 tag for TLS */ +-# define EVP_CCM8_TLS_TAG_LEN 8 +- +-/* Length of tag for TLS */ +-# define EVP_CHACHAPOLY_TLS_TAG_LEN 16 +- +-typedef struct evp_cipher_info_st { +- const EVP_CIPHER *cipher; +- unsigned char iv[EVP_MAX_IV_LENGTH]; +-} EVP_CIPHER_INFO; +- +- +-/* Password based encryption function */ +-typedef int (EVP_PBE_KEYGEN) (EVP_CIPHER_CTX *ctx, const char *pass, +- int passlen, ASN1_TYPE *param, +- const EVP_CIPHER *cipher, const EVP_MD *md, +- int en_de); +- +-# ifndef OPENSSL_NO_RSA +-# define EVP_PKEY_assign_RSA(pkey,rsa) EVP_PKEY_assign((pkey),EVP_PKEY_RSA,\ +- (char *)(rsa)) +-# endif +- +-# ifndef OPENSSL_NO_DSA +-# define EVP_PKEY_assign_DSA(pkey,dsa) EVP_PKEY_assign((pkey),EVP_PKEY_DSA,\ +- (char *)(dsa)) +-# endif +- +-# ifndef OPENSSL_NO_DH +-# define EVP_PKEY_assign_DH(pkey,dh) EVP_PKEY_assign((pkey),EVP_PKEY_DH,\ +- (char *)(dh)) +-# endif +- +-# ifndef OPENSSL_NO_EC +-# define EVP_PKEY_assign_EC_KEY(pkey,eckey) EVP_PKEY_assign((pkey),EVP_PKEY_EC,\ +- (char *)(eckey)) +-# endif +-# ifndef OPENSSL_NO_SIPHASH +-# define EVP_PKEY_assign_SIPHASH(pkey,shkey) EVP_PKEY_assign((pkey),EVP_PKEY_SIPHASH,\ +- (char *)(shkey)) +-# endif +- +-# ifndef OPENSSL_NO_POLY1305 +-# define EVP_PKEY_assign_POLY1305(pkey,polykey) EVP_PKEY_assign((pkey),EVP_PKEY_POLY1305,\ +- (char *)(polykey)) +-# endif +- +-/* Add some extra combinations */ +-# define EVP_get_digestbynid(a) EVP_get_digestbyname(OBJ_nid2sn(a)) +-# define EVP_get_digestbyobj(a) EVP_get_digestbynid(OBJ_obj2nid(a)) +-# define EVP_get_cipherbynid(a) EVP_get_cipherbyname(OBJ_nid2sn(a)) +-# define EVP_get_cipherbyobj(a) EVP_get_cipherbynid(OBJ_obj2nid(a)) +- +-int EVP_MD_type(const EVP_MD *md); +-# define EVP_MD_nid(e) EVP_MD_type(e) +-# define EVP_MD_name(e) OBJ_nid2sn(EVP_MD_nid(e)) +-int EVP_MD_pkey_type(const EVP_MD *md); +-int EVP_MD_size(const EVP_MD *md); +-int EVP_MD_block_size(const EVP_MD *md); +-unsigned long EVP_MD_flags(const EVP_MD *md); +- +-const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx); +-int (*EVP_MD_CTX_update_fn(EVP_MD_CTX *ctx))(EVP_MD_CTX *ctx, +- const void *data, size_t count); +-void EVP_MD_CTX_set_update_fn(EVP_MD_CTX *ctx, +- int (*update) (EVP_MD_CTX *ctx, +- const void *data, size_t count)); +-# define EVP_MD_CTX_size(e) EVP_MD_size(EVP_MD_CTX_md(e)) +-# define EVP_MD_CTX_block_size(e) EVP_MD_block_size(EVP_MD_CTX_md(e)) +-# define EVP_MD_CTX_type(e) EVP_MD_type(EVP_MD_CTX_md(e)) +-EVP_PKEY_CTX *EVP_MD_CTX_pkey_ctx(const EVP_MD_CTX *ctx); +-void EVP_MD_CTX_set_pkey_ctx(EVP_MD_CTX *ctx, EVP_PKEY_CTX *pctx); +-void *EVP_MD_CTX_md_data(const EVP_MD_CTX *ctx); +- +-int EVP_CIPHER_nid(const EVP_CIPHER *cipher); +-# define EVP_CIPHER_name(e) OBJ_nid2sn(EVP_CIPHER_nid(e)) +-int EVP_CIPHER_block_size(const EVP_CIPHER *cipher); +-int EVP_CIPHER_impl_ctx_size(const EVP_CIPHER *cipher); +-int EVP_CIPHER_key_length(const EVP_CIPHER *cipher); +-int EVP_CIPHER_iv_length(const EVP_CIPHER *cipher); +-unsigned long EVP_CIPHER_flags(const EVP_CIPHER *cipher); +-# define EVP_CIPHER_mode(e) (EVP_CIPHER_flags(e) & EVP_CIPH_MODE) +- +-const EVP_CIPHER *EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX *ctx); +-int EVP_CIPHER_CTX_encrypting(const EVP_CIPHER_CTX *ctx); +-int EVP_CIPHER_CTX_nid(const EVP_CIPHER_CTX *ctx); +-int EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx); +-int EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx); +-int EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx); +-const unsigned char *EVP_CIPHER_CTX_iv(const EVP_CIPHER_CTX *ctx); +-const unsigned char *EVP_CIPHER_CTX_original_iv(const EVP_CIPHER_CTX *ctx); +-unsigned char *EVP_CIPHER_CTX_iv_noconst(EVP_CIPHER_CTX *ctx); +-unsigned char *EVP_CIPHER_CTX_buf_noconst(EVP_CIPHER_CTX *ctx); +-int EVP_CIPHER_CTX_num(const EVP_CIPHER_CTX *ctx); +-void EVP_CIPHER_CTX_set_num(EVP_CIPHER_CTX *ctx, int num); +-int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in); +-void *EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx); +-void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data); +-void *EVP_CIPHER_CTX_get_cipher_data(const EVP_CIPHER_CTX *ctx); +-void *EVP_CIPHER_CTX_set_cipher_data(EVP_CIPHER_CTX *ctx, void *cipher_data); +-# define EVP_CIPHER_CTX_type(c) EVP_CIPHER_type(EVP_CIPHER_CTX_cipher(c)) +-# if OPENSSL_API_COMPAT < 0x10100000L +-# define EVP_CIPHER_CTX_flags(c) EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(c)) +-# endif +-# define EVP_CIPHER_CTX_mode(c) EVP_CIPHER_mode(EVP_CIPHER_CTX_cipher(c)) +- +-# define EVP_ENCODE_LENGTH(l) ((((l)+2)/3*4)+((l)/48+1)*2+80) +-# define EVP_DECODE_LENGTH(l) (((l)+3)/4*3+80) +- +-# define EVP_SignInit_ex(a,b,c) EVP_DigestInit_ex(a,b,c) +-# define EVP_SignInit(a,b) EVP_DigestInit(a,b) +-# define EVP_SignUpdate(a,b,c) EVP_DigestUpdate(a,b,c) +-# define EVP_VerifyInit_ex(a,b,c) EVP_DigestInit_ex(a,b,c) +-# define EVP_VerifyInit(a,b) EVP_DigestInit(a,b) +-# define EVP_VerifyUpdate(a,b,c) EVP_DigestUpdate(a,b,c) +-# define EVP_OpenUpdate(a,b,c,d,e) EVP_DecryptUpdate(a,b,c,d,e) +-# define EVP_SealUpdate(a,b,c,d,e) EVP_EncryptUpdate(a,b,c,d,e) +-# define EVP_DigestSignUpdate(a,b,c) EVP_DigestUpdate(a,b,c) +-# define EVP_DigestVerifyUpdate(a,b,c) EVP_DigestUpdate(a,b,c) +- +-# ifdef CONST_STRICT +-void BIO_set_md(BIO *, const EVP_MD *md); +-# else +-# define BIO_set_md(b,md) BIO_ctrl(b,BIO_C_SET_MD,0,(char *)(md)) +-# endif +-# define BIO_get_md(b,mdp) BIO_ctrl(b,BIO_C_GET_MD,0,(char *)(mdp)) +-# define BIO_get_md_ctx(b,mdcp) BIO_ctrl(b,BIO_C_GET_MD_CTX,0, \ +- (char *)(mdcp)) +-# define BIO_set_md_ctx(b,mdcp) BIO_ctrl(b,BIO_C_SET_MD_CTX,0, \ +- (char *)(mdcp)) +-# define BIO_get_cipher_status(b) BIO_ctrl(b,BIO_C_GET_CIPHER_STATUS,0,NULL) +-# define BIO_get_cipher_ctx(b,c_pp) BIO_ctrl(b,BIO_C_GET_CIPHER_CTX,0, \ +- (char *)(c_pp)) +- +-/*__owur*/ int EVP_Cipher(EVP_CIPHER_CTX *c, +- unsigned char *out, +- const unsigned char *in, unsigned int inl); +- +-# define EVP_add_cipher_alias(n,alias) \ +- OBJ_NAME_add((alias),OBJ_NAME_TYPE_CIPHER_METH|OBJ_NAME_ALIAS,(n)) +-# define EVP_add_digest_alias(n,alias) \ +- OBJ_NAME_add((alias),OBJ_NAME_TYPE_MD_METH|OBJ_NAME_ALIAS,(n)) +-# define EVP_delete_cipher_alias(alias) \ +- OBJ_NAME_remove(alias,OBJ_NAME_TYPE_CIPHER_METH|OBJ_NAME_ALIAS); +-# define EVP_delete_digest_alias(alias) \ +- OBJ_NAME_remove(alias,OBJ_NAME_TYPE_MD_METH|OBJ_NAME_ALIAS); +- +-int EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int cmd, int p1, void *p2); +-EVP_MD_CTX *EVP_MD_CTX_new(void); +-int EVP_MD_CTX_reset(EVP_MD_CTX *ctx); +-void EVP_MD_CTX_free(EVP_MD_CTX *ctx); +-# define EVP_MD_CTX_create() EVP_MD_CTX_new() +-# define EVP_MD_CTX_init(ctx) EVP_MD_CTX_reset((ctx)) +-# define EVP_MD_CTX_destroy(ctx) EVP_MD_CTX_free((ctx)) +-__owur int EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in); +-void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags); +-void EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags); +-int EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx, int flags); +-__owur int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, +- ENGINE *impl); +-__owur int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *d, +- size_t cnt); +-__owur int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, +- unsigned int *s); +-__owur int EVP_Digest(const void *data, size_t count, +- unsigned char *md, unsigned int *size, +- const EVP_MD *type, ENGINE *impl); +- +-__owur int EVP_MD_CTX_copy(EVP_MD_CTX *out, const EVP_MD_CTX *in); +-__owur int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type); +-__owur int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md, +- unsigned int *s); +-__owur int EVP_DigestFinalXOF(EVP_MD_CTX *ctx, unsigned char *md, +- size_t len); +- +-int EVP_read_pw_string(char *buf, int length, const char *prompt, int verify); +-int EVP_read_pw_string_min(char *buf, int minlen, int maxlen, +- const char *prompt, int verify); +-void EVP_set_pw_prompt(const char *prompt); +-char *EVP_get_pw_prompt(void); +- +-__owur int EVP_BytesToKey(const EVP_CIPHER *type, const EVP_MD *md, +- const unsigned char *salt, +- const unsigned char *data, int datal, int count, +- unsigned char *key, unsigned char *iv); +- +-void EVP_CIPHER_CTX_set_flags(EVP_CIPHER_CTX *ctx, int flags); +-void EVP_CIPHER_CTX_clear_flags(EVP_CIPHER_CTX *ctx, int flags); +-int EVP_CIPHER_CTX_test_flags(const EVP_CIPHER_CTX *ctx, int flags); +- +-__owur int EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, +- const unsigned char *key, const unsigned char *iv); +-/*__owur*/ int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx, +- const EVP_CIPHER *cipher, ENGINE *impl, +- const unsigned char *key, +- const unsigned char *iv); +-/*__owur*/ int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, +- int *outl, const unsigned char *in, int inl); +-/*__owur*/ int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, +- int *outl); +-/*__owur*/ int EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, +- int *outl); +- +-__owur int EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, +- const unsigned char *key, const unsigned char *iv); +-/*__owur*/ int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx, +- const EVP_CIPHER *cipher, ENGINE *impl, +- const unsigned char *key, +- const unsigned char *iv); +-/*__owur*/ int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, +- int *outl, const unsigned char *in, int inl); +-__owur int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm, +- int *outl); +-/*__owur*/ int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm, +- int *outl); +- +-__owur int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, +- const unsigned char *key, const unsigned char *iv, +- int enc); +-/*__owur*/ int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, +- const EVP_CIPHER *cipher, ENGINE *impl, +- const unsigned char *key, +- const unsigned char *iv, int enc); +-__owur int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, +- int *outl, const unsigned char *in, int inl); +-__owur int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm, +- int *outl); +-__owur int EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm, +- int *outl); +- +-__owur int EVP_SignFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s, +- EVP_PKEY *pkey); +- +-__owur int EVP_DigestSign(EVP_MD_CTX *ctx, unsigned char *sigret, +- size_t *siglen, const unsigned char *tbs, +- size_t tbslen); +- +-__owur int EVP_VerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sigbuf, +- unsigned int siglen, EVP_PKEY *pkey); +- +-__owur int EVP_DigestVerify(EVP_MD_CTX *ctx, const unsigned char *sigret, +- size_t siglen, const unsigned char *tbs, +- size_t tbslen); +- +-/*__owur*/ int EVP_DigestSignInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, +- const EVP_MD *type, ENGINE *e, +- EVP_PKEY *pkey); +-__owur int EVP_DigestSignFinal(EVP_MD_CTX *ctx, unsigned char *sigret, +- size_t *siglen); +- +-__owur int EVP_DigestVerifyInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, +- const EVP_MD *type, ENGINE *e, +- EVP_PKEY *pkey); +-__owur int EVP_DigestVerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sig, +- size_t siglen); +- +-# ifndef OPENSSL_NO_RSA +-__owur int EVP_OpenInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type, +- const unsigned char *ek, int ekl, +- const unsigned char *iv, EVP_PKEY *priv); +-__owur int EVP_OpenFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl); +- +-__owur int EVP_SealInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type, +- unsigned char **ek, int *ekl, unsigned char *iv, +- EVP_PKEY **pubk, int npubk); +-__owur int EVP_SealFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl); +-# endif +- +-EVP_ENCODE_CTX *EVP_ENCODE_CTX_new(void); +-void EVP_ENCODE_CTX_free(EVP_ENCODE_CTX *ctx); +-int EVP_ENCODE_CTX_copy(EVP_ENCODE_CTX *dctx, EVP_ENCODE_CTX *sctx); +-int EVP_ENCODE_CTX_num(EVP_ENCODE_CTX *ctx); +-void EVP_EncodeInit(EVP_ENCODE_CTX *ctx); +-int EVP_EncodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl, +- const unsigned char *in, int inl); +-void EVP_EncodeFinal(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl); +-int EVP_EncodeBlock(unsigned char *t, const unsigned char *f, int n); +- +-void EVP_DecodeInit(EVP_ENCODE_CTX *ctx); +-int EVP_DecodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl, +- const unsigned char *in, int inl); +-int EVP_DecodeFinal(EVP_ENCODE_CTX *ctx, unsigned +- char *out, int *outl); +-int EVP_DecodeBlock(unsigned char *t, const unsigned char *f, int n); +- +-# if OPENSSL_API_COMPAT < 0x10100000L +-# define EVP_CIPHER_CTX_init(c) EVP_CIPHER_CTX_reset(c) +-# define EVP_CIPHER_CTX_cleanup(c) EVP_CIPHER_CTX_reset(c) +-# endif +-EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void); +-int EVP_CIPHER_CTX_reset(EVP_CIPHER_CTX *c); +-void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *c); +-int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *x, int keylen); +-int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *c, int pad); +-int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr); +-int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key); +- +-const BIO_METHOD *BIO_f_md(void); +-const BIO_METHOD *BIO_f_base64(void); +-const BIO_METHOD *BIO_f_cipher(void); +-const BIO_METHOD *BIO_f_reliable(void); +-__owur int BIO_set_cipher(BIO *b, const EVP_CIPHER *c, const unsigned char *k, +- const unsigned char *i, int enc); +- +-const EVP_MD *EVP_md_null(void); +-# ifndef OPENSSL_NO_MD2 +-const EVP_MD *EVP_md2(void); +-# endif +-# ifndef OPENSSL_NO_MD4 +-const EVP_MD *EVP_md4(void); +-# endif +-# ifndef OPENSSL_NO_MD5 +-const EVP_MD *EVP_md5(void); +-const EVP_MD *EVP_md5_sha1(void); +-# endif +-# ifndef OPENSSL_NO_BLAKE2 +-const EVP_MD *EVP_blake2b512(void); +-const EVP_MD *EVP_blake2s256(void); +-# endif +-const EVP_MD *EVP_sha1(void); +-const EVP_MD *EVP_sha224(void); +-const EVP_MD *EVP_sha256(void); +-const EVP_MD *EVP_sha384(void); +-const EVP_MD *EVP_sha512(void); +-const EVP_MD *EVP_sha512_224(void); +-const EVP_MD *EVP_sha512_256(void); +-const EVP_MD *EVP_sha3_224(void); +-const EVP_MD *EVP_sha3_256(void); +-const EVP_MD *EVP_sha3_384(void); +-const EVP_MD *EVP_sha3_512(void); +-const EVP_MD *EVP_shake128(void); +-const EVP_MD *EVP_shake256(void); +-# ifndef OPENSSL_NO_MDC2 +-const EVP_MD *EVP_mdc2(void); +-# endif +-# ifndef OPENSSL_NO_RMD160 +-const EVP_MD *EVP_ripemd160(void); +-# endif +-# ifndef OPENSSL_NO_WHIRLPOOL +-const EVP_MD *EVP_whirlpool(void); +-# endif +-# ifndef OPENSSL_NO_SM3 +-const EVP_MD *EVP_sm3(void); +-# endif +-const EVP_CIPHER *EVP_enc_null(void); /* does nothing :-) */ +-# ifndef OPENSSL_NO_DES +-const EVP_CIPHER *EVP_des_ecb(void); +-const EVP_CIPHER *EVP_des_ede(void); +-const EVP_CIPHER *EVP_des_ede3(void); +-const EVP_CIPHER *EVP_des_ede_ecb(void); +-const EVP_CIPHER *EVP_des_ede3_ecb(void); +-const EVP_CIPHER *EVP_des_cfb64(void); +-# define EVP_des_cfb EVP_des_cfb64 +-const EVP_CIPHER *EVP_des_cfb1(void); +-const EVP_CIPHER *EVP_des_cfb8(void); +-const EVP_CIPHER *EVP_des_ede_cfb64(void); +-# define EVP_des_ede_cfb EVP_des_ede_cfb64 +-const EVP_CIPHER *EVP_des_ede3_cfb64(void); +-# define EVP_des_ede3_cfb EVP_des_ede3_cfb64 +-const EVP_CIPHER *EVP_des_ede3_cfb1(void); +-const EVP_CIPHER *EVP_des_ede3_cfb8(void); +-const EVP_CIPHER *EVP_des_ofb(void); +-const EVP_CIPHER *EVP_des_ede_ofb(void); +-const EVP_CIPHER *EVP_des_ede3_ofb(void); +-const EVP_CIPHER *EVP_des_cbc(void); +-const EVP_CIPHER *EVP_des_ede_cbc(void); +-const EVP_CIPHER *EVP_des_ede3_cbc(void); +-const EVP_CIPHER *EVP_desx_cbc(void); +-const EVP_CIPHER *EVP_des_ede3_wrap(void); +-/* +- * This should now be supported through the dev_crypto ENGINE. But also, why +- * are rc4 and md5 declarations made here inside a "NO_DES" precompiler +- * branch? +- */ +-# endif +-# ifndef OPENSSL_NO_RC4 +-const EVP_CIPHER *EVP_rc4(void); +-const EVP_CIPHER *EVP_rc4_40(void); +-# ifndef OPENSSL_NO_MD5 +-const EVP_CIPHER *EVP_rc4_hmac_md5(void); +-# endif +-# endif +-# ifndef OPENSSL_NO_IDEA +-const EVP_CIPHER *EVP_idea_ecb(void); +-const EVP_CIPHER *EVP_idea_cfb64(void); +-# define EVP_idea_cfb EVP_idea_cfb64 +-const EVP_CIPHER *EVP_idea_ofb(void); +-const EVP_CIPHER *EVP_idea_cbc(void); +-# endif +-# ifndef OPENSSL_NO_RC2 +-const EVP_CIPHER *EVP_rc2_ecb(void); +-const EVP_CIPHER *EVP_rc2_cbc(void); +-const EVP_CIPHER *EVP_rc2_40_cbc(void); +-const EVP_CIPHER *EVP_rc2_64_cbc(void); +-const EVP_CIPHER *EVP_rc2_cfb64(void); +-# define EVP_rc2_cfb EVP_rc2_cfb64 +-const EVP_CIPHER *EVP_rc2_ofb(void); +-# endif +-# ifndef OPENSSL_NO_BF +-const EVP_CIPHER *EVP_bf_ecb(void); +-const EVP_CIPHER *EVP_bf_cbc(void); +-const EVP_CIPHER *EVP_bf_cfb64(void); +-# define EVP_bf_cfb EVP_bf_cfb64 +-const EVP_CIPHER *EVP_bf_ofb(void); +-# endif +-# ifndef OPENSSL_NO_CAST +-const EVP_CIPHER *EVP_cast5_ecb(void); +-const EVP_CIPHER *EVP_cast5_cbc(void); +-const EVP_CIPHER *EVP_cast5_cfb64(void); +-# define EVP_cast5_cfb EVP_cast5_cfb64 +-const EVP_CIPHER *EVP_cast5_ofb(void); +-# endif +-# ifndef OPENSSL_NO_RC5 +-const EVP_CIPHER *EVP_rc5_32_12_16_cbc(void); +-const EVP_CIPHER *EVP_rc5_32_12_16_ecb(void); +-const EVP_CIPHER *EVP_rc5_32_12_16_cfb64(void); +-# define EVP_rc5_32_12_16_cfb EVP_rc5_32_12_16_cfb64 +-const EVP_CIPHER *EVP_rc5_32_12_16_ofb(void); +-# endif +-const EVP_CIPHER *EVP_aes_128_ecb(void); +-const EVP_CIPHER *EVP_aes_128_cbc(void); +-const EVP_CIPHER *EVP_aes_128_cfb1(void); +-const EVP_CIPHER *EVP_aes_128_cfb8(void); +-const EVP_CIPHER *EVP_aes_128_cfb128(void); +-# define EVP_aes_128_cfb EVP_aes_128_cfb128 +-const EVP_CIPHER *EVP_aes_128_ofb(void); +-const EVP_CIPHER *EVP_aes_128_ctr(void); +-const EVP_CIPHER *EVP_aes_128_ccm(void); +-const EVP_CIPHER *EVP_aes_128_gcm(void); +-const EVP_CIPHER *EVP_aes_128_xts(void); +-const EVP_CIPHER *EVP_aes_128_wrap(void); +-const EVP_CIPHER *EVP_aes_128_wrap_pad(void); +-# ifndef OPENSSL_NO_OCB +-const EVP_CIPHER *EVP_aes_128_ocb(void); +-# endif +-const EVP_CIPHER *EVP_aes_192_ecb(void); +-const EVP_CIPHER *EVP_aes_192_cbc(void); +-const EVP_CIPHER *EVP_aes_192_cfb1(void); +-const EVP_CIPHER *EVP_aes_192_cfb8(void); +-const EVP_CIPHER *EVP_aes_192_cfb128(void); +-# define EVP_aes_192_cfb EVP_aes_192_cfb128 +-const EVP_CIPHER *EVP_aes_192_ofb(void); +-const EVP_CIPHER *EVP_aes_192_ctr(void); +-const EVP_CIPHER *EVP_aes_192_ccm(void); +-const EVP_CIPHER *EVP_aes_192_gcm(void); +-const EVP_CIPHER *EVP_aes_192_wrap(void); +-const EVP_CIPHER *EVP_aes_192_wrap_pad(void); +-# ifndef OPENSSL_NO_OCB +-const EVP_CIPHER *EVP_aes_192_ocb(void); +-# endif +-const EVP_CIPHER *EVP_aes_256_ecb(void); +-const EVP_CIPHER *EVP_aes_256_cbc(void); +-const EVP_CIPHER *EVP_aes_256_cfb1(void); +-const EVP_CIPHER *EVP_aes_256_cfb8(void); +-const EVP_CIPHER *EVP_aes_256_cfb128(void); +-# define EVP_aes_256_cfb EVP_aes_256_cfb128 +-const EVP_CIPHER *EVP_aes_256_ofb(void); +-const EVP_CIPHER *EVP_aes_256_ctr(void); +-const EVP_CIPHER *EVP_aes_256_ccm(void); +-const EVP_CIPHER *EVP_aes_256_gcm(void); +-const EVP_CIPHER *EVP_aes_256_xts(void); +-const EVP_CIPHER *EVP_aes_256_wrap(void); +-const EVP_CIPHER *EVP_aes_256_wrap_pad(void); +-# ifndef OPENSSL_NO_OCB +-const EVP_CIPHER *EVP_aes_256_ocb(void); +-# endif +-const EVP_CIPHER *EVP_aes_128_cbc_hmac_sha1(void); +-const EVP_CIPHER *EVP_aes_256_cbc_hmac_sha1(void); +-const EVP_CIPHER *EVP_aes_128_cbc_hmac_sha256(void); +-const EVP_CIPHER *EVP_aes_256_cbc_hmac_sha256(void); +-# ifndef OPENSSL_NO_ARIA +-const EVP_CIPHER *EVP_aria_128_ecb(void); +-const EVP_CIPHER *EVP_aria_128_cbc(void); +-const EVP_CIPHER *EVP_aria_128_cfb1(void); +-const EVP_CIPHER *EVP_aria_128_cfb8(void); +-const EVP_CIPHER *EVP_aria_128_cfb128(void); +-# define EVP_aria_128_cfb EVP_aria_128_cfb128 +-const EVP_CIPHER *EVP_aria_128_ctr(void); +-const EVP_CIPHER *EVP_aria_128_ofb(void); +-const EVP_CIPHER *EVP_aria_128_gcm(void); +-const EVP_CIPHER *EVP_aria_128_ccm(void); +-const EVP_CIPHER *EVP_aria_192_ecb(void); +-const EVP_CIPHER *EVP_aria_192_cbc(void); +-const EVP_CIPHER *EVP_aria_192_cfb1(void); +-const EVP_CIPHER *EVP_aria_192_cfb8(void); +-const EVP_CIPHER *EVP_aria_192_cfb128(void); +-# define EVP_aria_192_cfb EVP_aria_192_cfb128 +-const EVP_CIPHER *EVP_aria_192_ctr(void); +-const EVP_CIPHER *EVP_aria_192_ofb(void); +-const EVP_CIPHER *EVP_aria_192_gcm(void); +-const EVP_CIPHER *EVP_aria_192_ccm(void); +-const EVP_CIPHER *EVP_aria_256_ecb(void); +-const EVP_CIPHER *EVP_aria_256_cbc(void); +-const EVP_CIPHER *EVP_aria_256_cfb1(void); +-const EVP_CIPHER *EVP_aria_256_cfb8(void); +-const EVP_CIPHER *EVP_aria_256_cfb128(void); +-# define EVP_aria_256_cfb EVP_aria_256_cfb128 +-const EVP_CIPHER *EVP_aria_256_ctr(void); +-const EVP_CIPHER *EVP_aria_256_ofb(void); +-const EVP_CIPHER *EVP_aria_256_gcm(void); +-const EVP_CIPHER *EVP_aria_256_ccm(void); +-# endif +-# ifndef OPENSSL_NO_CAMELLIA +-const EVP_CIPHER *EVP_camellia_128_ecb(void); +-const EVP_CIPHER *EVP_camellia_128_cbc(void); +-const EVP_CIPHER *EVP_camellia_128_cfb1(void); +-const EVP_CIPHER *EVP_camellia_128_cfb8(void); +-const EVP_CIPHER *EVP_camellia_128_cfb128(void); +-# define EVP_camellia_128_cfb EVP_camellia_128_cfb128 +-const EVP_CIPHER *EVP_camellia_128_ofb(void); +-const EVP_CIPHER *EVP_camellia_128_ctr(void); +-const EVP_CIPHER *EVP_camellia_192_ecb(void); +-const EVP_CIPHER *EVP_camellia_192_cbc(void); +-const EVP_CIPHER *EVP_camellia_192_cfb1(void); +-const EVP_CIPHER *EVP_camellia_192_cfb8(void); +-const EVP_CIPHER *EVP_camellia_192_cfb128(void); +-# define EVP_camellia_192_cfb EVP_camellia_192_cfb128 +-const EVP_CIPHER *EVP_camellia_192_ofb(void); +-const EVP_CIPHER *EVP_camellia_192_ctr(void); +-const EVP_CIPHER *EVP_camellia_256_ecb(void); +-const EVP_CIPHER *EVP_camellia_256_cbc(void); +-const EVP_CIPHER *EVP_camellia_256_cfb1(void); +-const EVP_CIPHER *EVP_camellia_256_cfb8(void); +-const EVP_CIPHER *EVP_camellia_256_cfb128(void); +-# define EVP_camellia_256_cfb EVP_camellia_256_cfb128 +-const EVP_CIPHER *EVP_camellia_256_ofb(void); +-const EVP_CIPHER *EVP_camellia_256_ctr(void); +-# endif +-# ifndef OPENSSL_NO_CHACHA +-const EVP_CIPHER *EVP_chacha20(void); +-# ifndef OPENSSL_NO_POLY1305 +-const EVP_CIPHER *EVP_chacha20_poly1305(void); +-# endif +-# endif +- +-# ifndef OPENSSL_NO_SEED +-const EVP_CIPHER *EVP_seed_ecb(void); +-const EVP_CIPHER *EVP_seed_cbc(void); +-const EVP_CIPHER *EVP_seed_cfb128(void); +-# define EVP_seed_cfb EVP_seed_cfb128 +-const EVP_CIPHER *EVP_seed_ofb(void); +-# endif +- +-# ifndef OPENSSL_NO_SM4 +-const EVP_CIPHER *EVP_sm4_ecb(void); +-const EVP_CIPHER *EVP_sm4_cbc(void); +-const EVP_CIPHER *EVP_sm4_cfb128(void); +-# define EVP_sm4_cfb EVP_sm4_cfb128 +-const EVP_CIPHER *EVP_sm4_ofb(void); +-const EVP_CIPHER *EVP_sm4_ctr(void); +-# endif +- +-# if OPENSSL_API_COMPAT < 0x10100000L +-# define OPENSSL_add_all_algorithms_conf() \ +- OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS \ +- | OPENSSL_INIT_ADD_ALL_DIGESTS \ +- | OPENSSL_INIT_LOAD_CONFIG, NULL) +-# define OPENSSL_add_all_algorithms_noconf() \ +- OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS \ +- | OPENSSL_INIT_ADD_ALL_DIGESTS, NULL) +- +-# ifdef OPENSSL_LOAD_CONF +-# define OpenSSL_add_all_algorithms() OPENSSL_add_all_algorithms_conf() +-# else +-# define OpenSSL_add_all_algorithms() OPENSSL_add_all_algorithms_noconf() +-# endif +- +-# define OpenSSL_add_all_ciphers() \ +- OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS, NULL) +-# define OpenSSL_add_all_digests() \ +- OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_DIGESTS, NULL) +- +-# define EVP_cleanup() while(0) continue +-# endif +- +-int EVP_add_cipher(const EVP_CIPHER *cipher); +-int EVP_add_digest(const EVP_MD *digest); +- +-const EVP_CIPHER *EVP_get_cipherbyname(const char *name); +-const EVP_MD *EVP_get_digestbyname(const char *name); +- +-void EVP_CIPHER_do_all(void (*fn) (const EVP_CIPHER *ciph, +- const char *from, const char *to, void *x), +- void *arg); +-void EVP_CIPHER_do_all_sorted(void (*fn) +- (const EVP_CIPHER *ciph, const char *from, +- const char *to, void *x), void *arg); +- +-void EVP_MD_do_all(void (*fn) (const EVP_MD *ciph, +- const char *from, const char *to, void *x), +- void *arg); +-void EVP_MD_do_all_sorted(void (*fn) +- (const EVP_MD *ciph, const char *from, +- const char *to, void *x), void *arg); +- +-int EVP_PKEY_decrypt_old(unsigned char *dec_key, +- const unsigned char *enc_key, int enc_key_len, +- EVP_PKEY *private_key); +-int EVP_PKEY_encrypt_old(unsigned char *enc_key, +- const unsigned char *key, int key_len, +- EVP_PKEY *pub_key); +-int EVP_PKEY_type(int type); +-int EVP_PKEY_id(const EVP_PKEY *pkey); +-int EVP_PKEY_base_id(const EVP_PKEY *pkey); +-int EVP_PKEY_bits(const EVP_PKEY *pkey); +-int EVP_PKEY_security_bits(const EVP_PKEY *pkey); +-int EVP_PKEY_size(const EVP_PKEY *pkey); +-int EVP_PKEY_set_type(EVP_PKEY *pkey, int type); +-int EVP_PKEY_set_type_str(EVP_PKEY *pkey, const char *str, int len); +-int EVP_PKEY_set_alias_type(EVP_PKEY *pkey, int type); +-# ifndef OPENSSL_NO_ENGINE +-int EVP_PKEY_set1_engine(EVP_PKEY *pkey, ENGINE *e); +-ENGINE *EVP_PKEY_get0_engine(const EVP_PKEY *pkey); +-# endif +-int EVP_PKEY_assign(EVP_PKEY *pkey, int type, void *key); +-void *EVP_PKEY_get0(const EVP_PKEY *pkey); +-const unsigned char *EVP_PKEY_get0_hmac(const EVP_PKEY *pkey, size_t *len); +-# ifndef OPENSSL_NO_POLY1305 +-const unsigned char *EVP_PKEY_get0_poly1305(const EVP_PKEY *pkey, size_t *len); +-# endif +-# ifndef OPENSSL_NO_SIPHASH +-const unsigned char *EVP_PKEY_get0_siphash(const EVP_PKEY *pkey, size_t *len); +-# endif +- +-# ifndef OPENSSL_NO_RSA +-struct rsa_st; +-int EVP_PKEY_set1_RSA(EVP_PKEY *pkey, struct rsa_st *key); +-struct rsa_st *EVP_PKEY_get0_RSA(EVP_PKEY *pkey); +-struct rsa_st *EVP_PKEY_get1_RSA(EVP_PKEY *pkey); +-# endif +-# ifndef OPENSSL_NO_DSA +-struct dsa_st; +-int EVP_PKEY_set1_DSA(EVP_PKEY *pkey, struct dsa_st *key); +-struct dsa_st *EVP_PKEY_get0_DSA(EVP_PKEY *pkey); +-struct dsa_st *EVP_PKEY_get1_DSA(EVP_PKEY *pkey); +-# endif +-# ifndef OPENSSL_NO_DH +-struct dh_st; +-int EVP_PKEY_set1_DH(EVP_PKEY *pkey, struct dh_st *key); +-struct dh_st *EVP_PKEY_get0_DH(EVP_PKEY *pkey); +-struct dh_st *EVP_PKEY_get1_DH(EVP_PKEY *pkey); +-# endif +-# ifndef OPENSSL_NO_EC +-struct ec_key_st; +-int EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey, struct ec_key_st *key); +-struct ec_key_st *EVP_PKEY_get0_EC_KEY(EVP_PKEY *pkey); +-struct ec_key_st *EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey); +-# endif +- +-EVP_PKEY *EVP_PKEY_new(void); +-int EVP_PKEY_up_ref(EVP_PKEY *pkey); +-void EVP_PKEY_free(EVP_PKEY *pkey); +- +-EVP_PKEY *d2i_PublicKey(int type, EVP_PKEY **a, const unsigned char **pp, +- long length); +-int i2d_PublicKey(EVP_PKEY *a, unsigned char **pp); +- +-EVP_PKEY *d2i_PrivateKey(int type, EVP_PKEY **a, const unsigned char **pp, +- long length); +-EVP_PKEY *d2i_AutoPrivateKey(EVP_PKEY **a, const unsigned char **pp, +- long length); +-int i2d_PrivateKey(EVP_PKEY *a, unsigned char **pp); +- +-int EVP_PKEY_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from); +-int EVP_PKEY_missing_parameters(const EVP_PKEY *pkey); +-int EVP_PKEY_save_parameters(EVP_PKEY *pkey, int mode); +-int EVP_PKEY_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b); +- +-int EVP_PKEY_cmp(const EVP_PKEY *a, const EVP_PKEY *b); +- +-int EVP_PKEY_print_public(BIO *out, const EVP_PKEY *pkey, +- int indent, ASN1_PCTX *pctx); +-int EVP_PKEY_print_private(BIO *out, const EVP_PKEY *pkey, +- int indent, ASN1_PCTX *pctx); +-int EVP_PKEY_print_params(BIO *out, const EVP_PKEY *pkey, +- int indent, ASN1_PCTX *pctx); +- +-int EVP_PKEY_get_default_digest_nid(EVP_PKEY *pkey, int *pnid); +- +-int EVP_PKEY_set1_tls_encodedpoint(EVP_PKEY *pkey, +- const unsigned char *pt, size_t ptlen); +-size_t EVP_PKEY_get1_tls_encodedpoint(EVP_PKEY *pkey, unsigned char **ppt); +- +-int EVP_CIPHER_type(const EVP_CIPHER *ctx); +- +-/* calls methods */ +-int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type); +-int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type); +- +-/* These are used by EVP_CIPHER methods */ +-int EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type); +-int EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type); +- +-/* PKCS5 password based encryption */ +-int PKCS5_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen, +- ASN1_TYPE *param, const EVP_CIPHER *cipher, +- const EVP_MD *md, int en_de); +-int PKCS5_PBKDF2_HMAC_SHA1(const char *pass, int passlen, +- const unsigned char *salt, int saltlen, int iter, +- int keylen, unsigned char *out); +-int PKCS5_PBKDF2_HMAC(const char *pass, int passlen, +- const unsigned char *salt, int saltlen, int iter, +- const EVP_MD *digest, int keylen, unsigned char *out); +-int PKCS5_v2_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen, +- ASN1_TYPE *param, const EVP_CIPHER *cipher, +- const EVP_MD *md, int en_de); +- +-#ifndef OPENSSL_NO_SCRYPT +-int EVP_PBE_scrypt(const char *pass, size_t passlen, +- const unsigned char *salt, size_t saltlen, +- uint64_t N, uint64_t r, uint64_t p, uint64_t maxmem, +- unsigned char *key, size_t keylen); +- +-int PKCS5_v2_scrypt_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, +- int passlen, ASN1_TYPE *param, +- const EVP_CIPHER *c, const EVP_MD *md, int en_de); +-#endif +- +-void PKCS5_PBE_add(void); +- +-int EVP_PBE_CipherInit(ASN1_OBJECT *pbe_obj, const char *pass, int passlen, +- ASN1_TYPE *param, EVP_CIPHER_CTX *ctx, int en_de); +- +-/* PBE type */ +- +-/* Can appear as the outermost AlgorithmIdentifier */ +-# define EVP_PBE_TYPE_OUTER 0x0 +-/* Is an PRF type OID */ +-# define EVP_PBE_TYPE_PRF 0x1 +-/* Is a PKCS#5 v2.0 KDF */ +-# define EVP_PBE_TYPE_KDF 0x2 +- +-int EVP_PBE_alg_add_type(int pbe_type, int pbe_nid, int cipher_nid, +- int md_nid, EVP_PBE_KEYGEN *keygen); +-int EVP_PBE_alg_add(int nid, const EVP_CIPHER *cipher, const EVP_MD *md, +- EVP_PBE_KEYGEN *keygen); +-int EVP_PBE_find(int type, int pbe_nid, int *pcnid, int *pmnid, +- EVP_PBE_KEYGEN **pkeygen); +-void EVP_PBE_cleanup(void); +-int EVP_PBE_get(int *ptype, int *ppbe_nid, size_t num); +- +-# define ASN1_PKEY_ALIAS 0x1 +-# define ASN1_PKEY_DYNAMIC 0x2 +-# define ASN1_PKEY_SIGPARAM_NULL 0x4 +- +-# define ASN1_PKEY_CTRL_PKCS7_SIGN 0x1 +-# define ASN1_PKEY_CTRL_PKCS7_ENCRYPT 0x2 +-# define ASN1_PKEY_CTRL_DEFAULT_MD_NID 0x3 +-# define ASN1_PKEY_CTRL_CMS_SIGN 0x5 +-# define ASN1_PKEY_CTRL_CMS_ENVELOPE 0x7 +-# define ASN1_PKEY_CTRL_CMS_RI_TYPE 0x8 +- +-# define ASN1_PKEY_CTRL_SET1_TLS_ENCPT 0x9 +-# define ASN1_PKEY_CTRL_GET1_TLS_ENCPT 0xa +- +-int EVP_PKEY_asn1_get_count(void); +-const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_get0(int idx); +-const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find(ENGINE **pe, int type); +-const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find_str(ENGINE **pe, +- const char *str, int len); +-int EVP_PKEY_asn1_add0(const EVP_PKEY_ASN1_METHOD *ameth); +-int EVP_PKEY_asn1_add_alias(int to, int from); +-int EVP_PKEY_asn1_get0_info(int *ppkey_id, int *pkey_base_id, +- int *ppkey_flags, const char **pinfo, +- const char **ppem_str, +- const EVP_PKEY_ASN1_METHOD *ameth); +- +-const EVP_PKEY_ASN1_METHOD *EVP_PKEY_get0_asn1(const EVP_PKEY *pkey); +-EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_new(int id, int flags, +- const char *pem_str, +- const char *info); +-void EVP_PKEY_asn1_copy(EVP_PKEY_ASN1_METHOD *dst, +- const EVP_PKEY_ASN1_METHOD *src); +-void EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth); +-void EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth, +- int (*pub_decode) (EVP_PKEY *pk, +- X509_PUBKEY *pub), +- int (*pub_encode) (X509_PUBKEY *pub, +- const EVP_PKEY *pk), +- int (*pub_cmp) (const EVP_PKEY *a, +- const EVP_PKEY *b), +- int (*pub_print) (BIO *out, +- const EVP_PKEY *pkey, +- int indent, ASN1_PCTX *pctx), +- int (*pkey_size) (const EVP_PKEY *pk), +- int (*pkey_bits) (const EVP_PKEY *pk)); +-void EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth, +- int (*priv_decode) (EVP_PKEY *pk, +- const PKCS8_PRIV_KEY_INFO +- *p8inf), +- int (*priv_encode) (PKCS8_PRIV_KEY_INFO *p8, +- const EVP_PKEY *pk), +- int (*priv_print) (BIO *out, +- const EVP_PKEY *pkey, +- int indent, +- ASN1_PCTX *pctx)); +-void EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth, +- int (*param_decode) (EVP_PKEY *pkey, +- const unsigned char **pder, +- int derlen), +- int (*param_encode) (const EVP_PKEY *pkey, +- unsigned char **pder), +- int (*param_missing) (const EVP_PKEY *pk), +- int (*param_copy) (EVP_PKEY *to, +- const EVP_PKEY *from), +- int (*param_cmp) (const EVP_PKEY *a, +- const EVP_PKEY *b), +- int (*param_print) (BIO *out, +- const EVP_PKEY *pkey, +- int indent, +- ASN1_PCTX *pctx)); +- +-void EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth, +- void (*pkey_free) (EVP_PKEY *pkey)); +-void EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth, +- int (*pkey_ctrl) (EVP_PKEY *pkey, int op, +- long arg1, void *arg2)); +-void EVP_PKEY_asn1_set_item(EVP_PKEY_ASN1_METHOD *ameth, +- int (*item_verify) (EVP_MD_CTX *ctx, +- const ASN1_ITEM *it, +- void *asn, +- X509_ALGOR *a, +- ASN1_BIT_STRING *sig, +- EVP_PKEY *pkey), +- int (*item_sign) (EVP_MD_CTX *ctx, +- const ASN1_ITEM *it, +- void *asn, +- X509_ALGOR *alg1, +- X509_ALGOR *alg2, +- ASN1_BIT_STRING *sig)); +- +-void EVP_PKEY_asn1_set_siginf(EVP_PKEY_ASN1_METHOD *ameth, +- int (*siginf_set) (X509_SIG_INFO *siginf, +- const X509_ALGOR *alg, +- const ASN1_STRING *sig)); +- +-void EVP_PKEY_asn1_set_check(EVP_PKEY_ASN1_METHOD *ameth, +- int (*pkey_check) (const EVP_PKEY *pk)); +- +-void EVP_PKEY_asn1_set_public_check(EVP_PKEY_ASN1_METHOD *ameth, +- int (*pkey_pub_check) (const EVP_PKEY *pk)); +- +-void EVP_PKEY_asn1_set_param_check(EVP_PKEY_ASN1_METHOD *ameth, +- int (*pkey_param_check) (const EVP_PKEY *pk)); +- +-void EVP_PKEY_asn1_set_set_priv_key(EVP_PKEY_ASN1_METHOD *ameth, +- int (*set_priv_key) (EVP_PKEY *pk, +- const unsigned char +- *priv, +- size_t len)); +-void EVP_PKEY_asn1_set_set_pub_key(EVP_PKEY_ASN1_METHOD *ameth, +- int (*set_pub_key) (EVP_PKEY *pk, +- const unsigned char *pub, +- size_t len)); +-void EVP_PKEY_asn1_set_get_priv_key(EVP_PKEY_ASN1_METHOD *ameth, +- int (*get_priv_key) (const EVP_PKEY *pk, +- unsigned char *priv, +- size_t *len)); +-void EVP_PKEY_asn1_set_get_pub_key(EVP_PKEY_ASN1_METHOD *ameth, +- int (*get_pub_key) (const EVP_PKEY *pk, +- unsigned char *pub, +- size_t *len)); +- +-void EVP_PKEY_asn1_set_security_bits(EVP_PKEY_ASN1_METHOD *ameth, +- int (*pkey_security_bits) (const EVP_PKEY +- *pk)); +- +-# define EVP_PKEY_OP_UNDEFINED 0 +-# define EVP_PKEY_OP_PARAMGEN (1<<1) +-# define EVP_PKEY_OP_KEYGEN (1<<2) +-# define EVP_PKEY_OP_SIGN (1<<3) +-# define EVP_PKEY_OP_VERIFY (1<<4) +-# define EVP_PKEY_OP_VERIFYRECOVER (1<<5) +-# define EVP_PKEY_OP_SIGNCTX (1<<6) +-# define EVP_PKEY_OP_VERIFYCTX (1<<7) +-# define EVP_PKEY_OP_ENCRYPT (1<<8) +-# define EVP_PKEY_OP_DECRYPT (1<<9) +-# define EVP_PKEY_OP_DERIVE (1<<10) +- +-# define EVP_PKEY_OP_TYPE_SIG \ +- (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_VERIFY | EVP_PKEY_OP_VERIFYRECOVER \ +- | EVP_PKEY_OP_SIGNCTX | EVP_PKEY_OP_VERIFYCTX) +- +-# define EVP_PKEY_OP_TYPE_CRYPT \ +- (EVP_PKEY_OP_ENCRYPT | EVP_PKEY_OP_DECRYPT) +- +-# define EVP_PKEY_OP_TYPE_NOGEN \ +- (EVP_PKEY_OP_TYPE_SIG | EVP_PKEY_OP_TYPE_CRYPT | EVP_PKEY_OP_DERIVE) +- +-# define EVP_PKEY_OP_TYPE_GEN \ +- (EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN) +- +-# define EVP_PKEY_CTX_set_signature_md(ctx, md) \ +- EVP_PKEY_CTX_ctrl(ctx, -1, EVP_PKEY_OP_TYPE_SIG, \ +- EVP_PKEY_CTRL_MD, 0, (void *)(md)) +- +-# define EVP_PKEY_CTX_get_signature_md(ctx, pmd) \ +- EVP_PKEY_CTX_ctrl(ctx, -1, EVP_PKEY_OP_TYPE_SIG, \ +- EVP_PKEY_CTRL_GET_MD, 0, (void *)(pmd)) +- +-# define EVP_PKEY_CTX_set_mac_key(ctx, key, len) \ +- EVP_PKEY_CTX_ctrl(ctx, -1, EVP_PKEY_OP_KEYGEN, \ +- EVP_PKEY_CTRL_SET_MAC_KEY, len, (void *)(key)) +- +-# define EVP_PKEY_CTRL_MD 1 +-# define EVP_PKEY_CTRL_PEER_KEY 2 +- +-# define EVP_PKEY_CTRL_PKCS7_ENCRYPT 3 +-# define EVP_PKEY_CTRL_PKCS7_DECRYPT 4 +- +-# define EVP_PKEY_CTRL_PKCS7_SIGN 5 +- +-# define EVP_PKEY_CTRL_SET_MAC_KEY 6 +- +-# define EVP_PKEY_CTRL_DIGESTINIT 7 +- +-/* Used by GOST key encryption in TLS */ +-# define EVP_PKEY_CTRL_SET_IV 8 +- +-# define EVP_PKEY_CTRL_CMS_ENCRYPT 9 +-# define EVP_PKEY_CTRL_CMS_DECRYPT 10 +-# define EVP_PKEY_CTRL_CMS_SIGN 11 +- +-# define EVP_PKEY_CTRL_CIPHER 12 +- +-# define EVP_PKEY_CTRL_GET_MD 13 +- +-# define EVP_PKEY_CTRL_SET_DIGEST_SIZE 14 +- +-# define EVP_PKEY_ALG_CTRL 0x1000 +- +-# define EVP_PKEY_FLAG_AUTOARGLEN 2 +-/* +- * Method handles all operations: don't assume any digest related defaults. +- */ +-# define EVP_PKEY_FLAG_SIGCTX_CUSTOM 4 +- +-const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type); +-EVP_PKEY_METHOD *EVP_PKEY_meth_new(int id, int flags); +-void EVP_PKEY_meth_get0_info(int *ppkey_id, int *pflags, +- const EVP_PKEY_METHOD *meth); +-void EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst, const EVP_PKEY_METHOD *src); +-void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth); +-int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth); +-int EVP_PKEY_meth_remove(const EVP_PKEY_METHOD *pmeth); +-size_t EVP_PKEY_meth_get_count(void); +-const EVP_PKEY_METHOD *EVP_PKEY_meth_get0(size_t idx); +- +-EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e); +-EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int id, ENGINE *e); +-EVP_PKEY_CTX *EVP_PKEY_CTX_dup(EVP_PKEY_CTX *ctx); +-void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx); +- +-int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype, +- int cmd, int p1, void *p2); +-int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx, const char *type, +- const char *value); +-int EVP_PKEY_CTX_ctrl_uint64(EVP_PKEY_CTX *ctx, int keytype, int optype, +- int cmd, uint64_t value); +- +-int EVP_PKEY_CTX_str2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *str); +-int EVP_PKEY_CTX_hex2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *hex); +- +-int EVP_PKEY_CTX_md(EVP_PKEY_CTX *ctx, int optype, int cmd, const char *md); +- +-int EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx); +-void EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen); +- +-EVP_PKEY *EVP_PKEY_new_mac_key(int type, ENGINE *e, +- const unsigned char *key, int keylen); +-EVP_PKEY *EVP_PKEY_new_raw_private_key(int type, ENGINE *e, +- const unsigned char *priv, +- size_t len); +-EVP_PKEY *EVP_PKEY_new_raw_public_key(int type, ENGINE *e, +- const unsigned char *pub, +- size_t len); +-int EVP_PKEY_get_raw_private_key(const EVP_PKEY *pkey, unsigned char *priv, +- size_t *len); +-int EVP_PKEY_get_raw_public_key(const EVP_PKEY *pkey, unsigned char *pub, +- size_t *len); +- +-EVP_PKEY *EVP_PKEY_new_CMAC_key(ENGINE *e, const unsigned char *priv, +- size_t len, const EVP_CIPHER *cipher); +- +-void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data); +-void *EVP_PKEY_CTX_get_data(EVP_PKEY_CTX *ctx); +-EVP_PKEY *EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx); +- +-EVP_PKEY *EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx); +- +-void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data); +-void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx); +- +-int EVP_PKEY_sign_init(EVP_PKEY_CTX *ctx); +-int EVP_PKEY_sign(EVP_PKEY_CTX *ctx, +- unsigned char *sig, size_t *siglen, +- const unsigned char *tbs, size_t tbslen); +-int EVP_PKEY_verify_init(EVP_PKEY_CTX *ctx); +-int EVP_PKEY_verify(EVP_PKEY_CTX *ctx, +- const unsigned char *sig, size_t siglen, +- const unsigned char *tbs, size_t tbslen); +-int EVP_PKEY_verify_recover_init(EVP_PKEY_CTX *ctx); +-int EVP_PKEY_verify_recover(EVP_PKEY_CTX *ctx, +- unsigned char *rout, size_t *routlen, +- const unsigned char *sig, size_t siglen); +-int EVP_PKEY_encrypt_init(EVP_PKEY_CTX *ctx); +-int EVP_PKEY_encrypt(EVP_PKEY_CTX *ctx, +- unsigned char *out, size_t *outlen, +- const unsigned char *in, size_t inlen); +-int EVP_PKEY_decrypt_init(EVP_PKEY_CTX *ctx); +-int EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx, +- unsigned char *out, size_t *outlen, +- const unsigned char *in, size_t inlen); +- +-int EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx); +-int EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer); +-int EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen); +- +-typedef int EVP_PKEY_gen_cb(EVP_PKEY_CTX *ctx); +- +-int EVP_PKEY_paramgen_init(EVP_PKEY_CTX *ctx); +-int EVP_PKEY_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey); +-int EVP_PKEY_keygen_init(EVP_PKEY_CTX *ctx); +-int EVP_PKEY_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey); +-int EVP_PKEY_check(EVP_PKEY_CTX *ctx); +-int EVP_PKEY_public_check(EVP_PKEY_CTX *ctx); +-int EVP_PKEY_param_check(EVP_PKEY_CTX *ctx); +- +-void EVP_PKEY_CTX_set_cb(EVP_PKEY_CTX *ctx, EVP_PKEY_gen_cb *cb); +-EVP_PKEY_gen_cb *EVP_PKEY_CTX_get_cb(EVP_PKEY_CTX *ctx); +- +-int EVP_PKEY_CTX_get_keygen_info(EVP_PKEY_CTX *ctx, int idx); +- +-void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth, +- int (*init) (EVP_PKEY_CTX *ctx)); +- +-void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth, +- int (*copy) (EVP_PKEY_CTX *dst, +- EVP_PKEY_CTX *src)); +- +-void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth, +- void (*cleanup) (EVP_PKEY_CTX *ctx)); +- +-void EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth, +- int (*paramgen_init) (EVP_PKEY_CTX *ctx), +- int (*paramgen) (EVP_PKEY_CTX *ctx, +- EVP_PKEY *pkey)); +- +-void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth, +- int (*keygen_init) (EVP_PKEY_CTX *ctx), +- int (*keygen) (EVP_PKEY_CTX *ctx, +- EVP_PKEY *pkey)); +- +-void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth, +- int (*sign_init) (EVP_PKEY_CTX *ctx), +- int (*sign) (EVP_PKEY_CTX *ctx, +- unsigned char *sig, size_t *siglen, +- const unsigned char *tbs, +- size_t tbslen)); +- +-void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth, +- int (*verify_init) (EVP_PKEY_CTX *ctx), +- int (*verify) (EVP_PKEY_CTX *ctx, +- const unsigned char *sig, +- size_t siglen, +- const unsigned char *tbs, +- size_t tbslen)); +- +-void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth, +- int (*verify_recover_init) (EVP_PKEY_CTX +- *ctx), +- int (*verify_recover) (EVP_PKEY_CTX +- *ctx, +- unsigned char +- *sig, +- size_t *siglen, +- const unsigned +- char *tbs, +- size_t tbslen)); +- +-void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth, +- int (*signctx_init) (EVP_PKEY_CTX *ctx, +- EVP_MD_CTX *mctx), +- int (*signctx) (EVP_PKEY_CTX *ctx, +- unsigned char *sig, +- size_t *siglen, +- EVP_MD_CTX *mctx)); +- +-void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth, +- int (*verifyctx_init) (EVP_PKEY_CTX *ctx, +- EVP_MD_CTX *mctx), +- int (*verifyctx) (EVP_PKEY_CTX *ctx, +- const unsigned char *sig, +- int siglen, +- EVP_MD_CTX *mctx)); +- +-void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth, +- int (*encrypt_init) (EVP_PKEY_CTX *ctx), +- int (*encryptfn) (EVP_PKEY_CTX *ctx, +- unsigned char *out, +- size_t *outlen, +- const unsigned char *in, +- size_t inlen)); +- +-void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth, +- int (*decrypt_init) (EVP_PKEY_CTX *ctx), +- int (*decrypt) (EVP_PKEY_CTX *ctx, +- unsigned char *out, +- size_t *outlen, +- const unsigned char *in, +- size_t inlen)); +- +-void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth, +- int (*derive_init) (EVP_PKEY_CTX *ctx), +- int (*derive) (EVP_PKEY_CTX *ctx, +- unsigned char *key, +- size_t *keylen)); +- +-void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth, +- int (*ctrl) (EVP_PKEY_CTX *ctx, int type, int p1, +- void *p2), +- int (*ctrl_str) (EVP_PKEY_CTX *ctx, +- const char *type, +- const char *value)); +- +-void EVP_PKEY_meth_set_digestsign(EVP_PKEY_METHOD *pmeth, +- int (*digestsign) (EVP_MD_CTX *ctx, +- unsigned char *sig, +- size_t *siglen, +- const unsigned char *tbs, +- size_t tbslen)); +- +-void EVP_PKEY_meth_set_digestverify(EVP_PKEY_METHOD *pmeth, +- int (*digestverify) (EVP_MD_CTX *ctx, +- const unsigned char *sig, +- size_t siglen, +- const unsigned char *tbs, +- size_t tbslen)); +- +-void EVP_PKEY_meth_set_check(EVP_PKEY_METHOD *pmeth, +- int (*check) (EVP_PKEY *pkey)); +- +-void EVP_PKEY_meth_set_public_check(EVP_PKEY_METHOD *pmeth, +- int (*check) (EVP_PKEY *pkey)); +- +-void EVP_PKEY_meth_set_param_check(EVP_PKEY_METHOD *pmeth, +- int (*check) (EVP_PKEY *pkey)); +- +-void EVP_PKEY_meth_set_digest_custom(EVP_PKEY_METHOD *pmeth, +- int (*digest_custom) (EVP_PKEY_CTX *ctx, +- EVP_MD_CTX *mctx)); +- +-void EVP_PKEY_meth_get_init(const EVP_PKEY_METHOD *pmeth, +- int (**pinit) (EVP_PKEY_CTX *ctx)); +- +-void EVP_PKEY_meth_get_copy(const EVP_PKEY_METHOD *pmeth, +- int (**pcopy) (EVP_PKEY_CTX *dst, +- EVP_PKEY_CTX *src)); +- +-void EVP_PKEY_meth_get_cleanup(const EVP_PKEY_METHOD *pmeth, +- void (**pcleanup) (EVP_PKEY_CTX *ctx)); +- +-void EVP_PKEY_meth_get_paramgen(const EVP_PKEY_METHOD *pmeth, +- int (**pparamgen_init) (EVP_PKEY_CTX *ctx), +- int (**pparamgen) (EVP_PKEY_CTX *ctx, +- EVP_PKEY *pkey)); +- +-void EVP_PKEY_meth_get_keygen(const EVP_PKEY_METHOD *pmeth, +- int (**pkeygen_init) (EVP_PKEY_CTX *ctx), +- int (**pkeygen) (EVP_PKEY_CTX *ctx, +- EVP_PKEY *pkey)); +- +-void EVP_PKEY_meth_get_sign(const EVP_PKEY_METHOD *pmeth, +- int (**psign_init) (EVP_PKEY_CTX *ctx), +- int (**psign) (EVP_PKEY_CTX *ctx, +- unsigned char *sig, size_t *siglen, +- const unsigned char *tbs, +- size_t tbslen)); +- +-void EVP_PKEY_meth_get_verify(const EVP_PKEY_METHOD *pmeth, +- int (**pverify_init) (EVP_PKEY_CTX *ctx), +- int (**pverify) (EVP_PKEY_CTX *ctx, +- const unsigned char *sig, +- size_t siglen, +- const unsigned char *tbs, +- size_t tbslen)); +- +-void EVP_PKEY_meth_get_verify_recover(const EVP_PKEY_METHOD *pmeth, +- int (**pverify_recover_init) (EVP_PKEY_CTX +- *ctx), +- int (**pverify_recover) (EVP_PKEY_CTX +- *ctx, +- unsigned char +- *sig, +- size_t *siglen, +- const unsigned +- char *tbs, +- size_t tbslen)); +- +-void EVP_PKEY_meth_get_signctx(const EVP_PKEY_METHOD *pmeth, +- int (**psignctx_init) (EVP_PKEY_CTX *ctx, +- EVP_MD_CTX *mctx), +- int (**psignctx) (EVP_PKEY_CTX *ctx, +- unsigned char *sig, +- size_t *siglen, +- EVP_MD_CTX *mctx)); +- +-void EVP_PKEY_meth_get_verifyctx(const EVP_PKEY_METHOD *pmeth, +- int (**pverifyctx_init) (EVP_PKEY_CTX *ctx, +- EVP_MD_CTX *mctx), +- int (**pverifyctx) (EVP_PKEY_CTX *ctx, +- const unsigned char *sig, +- int siglen, +- EVP_MD_CTX *mctx)); +- +-void EVP_PKEY_meth_get_encrypt(const EVP_PKEY_METHOD *pmeth, +- int (**pencrypt_init) (EVP_PKEY_CTX *ctx), +- int (**pencryptfn) (EVP_PKEY_CTX *ctx, +- unsigned char *out, +- size_t *outlen, +- const unsigned char *in, +- size_t inlen)); +- +-void EVP_PKEY_meth_get_decrypt(const EVP_PKEY_METHOD *pmeth, +- int (**pdecrypt_init) (EVP_PKEY_CTX *ctx), +- int (**pdecrypt) (EVP_PKEY_CTX *ctx, +- unsigned char *out, +- size_t *outlen, +- const unsigned char *in, +- size_t inlen)); +- +-void EVP_PKEY_meth_get_derive(const EVP_PKEY_METHOD *pmeth, +- int (**pderive_init) (EVP_PKEY_CTX *ctx), +- int (**pderive) (EVP_PKEY_CTX *ctx, +- unsigned char *key, +- size_t *keylen)); +- +-void EVP_PKEY_meth_get_ctrl(const EVP_PKEY_METHOD *pmeth, +- int (**pctrl) (EVP_PKEY_CTX *ctx, int type, int p1, +- void *p2), +- int (**pctrl_str) (EVP_PKEY_CTX *ctx, +- const char *type, +- const char *value)); +- +-void EVP_PKEY_meth_get_digestsign(EVP_PKEY_METHOD *pmeth, +- int (**digestsign) (EVP_MD_CTX *ctx, +- unsigned char *sig, +- size_t *siglen, +- const unsigned char *tbs, +- size_t tbslen)); +- +-void EVP_PKEY_meth_get_digestverify(EVP_PKEY_METHOD *pmeth, +- int (**digestverify) (EVP_MD_CTX *ctx, +- const unsigned char *sig, +- size_t siglen, +- const unsigned char *tbs, +- size_t tbslen)); +- +-void EVP_PKEY_meth_get_check(const EVP_PKEY_METHOD *pmeth, +- int (**pcheck) (EVP_PKEY *pkey)); +- +-void EVP_PKEY_meth_get_public_check(const EVP_PKEY_METHOD *pmeth, +- int (**pcheck) (EVP_PKEY *pkey)); +- +-void EVP_PKEY_meth_get_param_check(const EVP_PKEY_METHOD *pmeth, +- int (**pcheck) (EVP_PKEY *pkey)); +- +-void EVP_PKEY_meth_get_digest_custom(EVP_PKEY_METHOD *pmeth, +- int (**pdigest_custom) (EVP_PKEY_CTX *ctx, +- EVP_MD_CTX *mctx)); +-void EVP_add_alg_module(void); +- +- +-# ifdef __cplusplus +-} +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/evperr.h b/uadk_tool/include/openssl/evperr.h +deleted file mode 100644 +index b4ea90a..0000000 +--- a/uadk_tool/include/openssl/evperr.h ++++ /dev/null +@@ -1,204 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_EVPERR_H +-# define HEADER_EVPERR_H +- +-# include +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_EVP_strings(void); +- +-/* +- * EVP function codes. +- */ +-# define EVP_F_AESNI_INIT_KEY 165 +-# define EVP_F_AESNI_XTS_INIT_KEY 207 +-# define EVP_F_AES_GCM_CTRL 196 +-# define EVP_F_AES_INIT_KEY 133 +-# define EVP_F_AES_OCB_CIPHER 169 +-# define EVP_F_AES_T4_INIT_KEY 178 +-# define EVP_F_AES_T4_XTS_INIT_KEY 208 +-# define EVP_F_AES_WRAP_CIPHER 170 +-# define EVP_F_AES_XTS_INIT_KEY 209 +-# define EVP_F_ALG_MODULE_INIT 177 +-# define EVP_F_ARIA_CCM_INIT_KEY 175 +-# define EVP_F_ARIA_GCM_CTRL 197 +-# define EVP_F_ARIA_GCM_INIT_KEY 176 +-# define EVP_F_ARIA_INIT_KEY 185 +-# define EVP_F_B64_NEW 198 +-# define EVP_F_CAMELLIA_INIT_KEY 159 +-# define EVP_F_CHACHA20_POLY1305_CTRL 182 +-# define EVP_F_CMLL_T4_INIT_KEY 179 +-# define EVP_F_DES_EDE3_WRAP_CIPHER 171 +-# define EVP_F_DO_SIGVER_INIT 161 +-# define EVP_F_ENC_NEW 199 +-# define EVP_F_EVP_CIPHERINIT_EX 123 +-# define EVP_F_EVP_CIPHER_ASN1_TO_PARAM 204 +-# define EVP_F_EVP_CIPHER_CTX_COPY 163 +-# define EVP_F_EVP_CIPHER_CTX_CTRL 124 +-# define EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH 122 +-# define EVP_F_EVP_CIPHER_PARAM_TO_ASN1 205 +-# define EVP_F_EVP_DECRYPTFINAL_EX 101 +-# define EVP_F_EVP_DECRYPTUPDATE 166 +-# define EVP_F_EVP_DIGESTFINALXOF 174 +-# define EVP_F_EVP_DIGESTINIT_EX 128 +-# define EVP_F_EVP_ENCRYPTDECRYPTUPDATE 219 +-# define EVP_F_EVP_ENCRYPTFINAL_EX 127 +-# define EVP_F_EVP_ENCRYPTUPDATE 167 +-# define EVP_F_EVP_MD_CTX_COPY_EX 110 +-# define EVP_F_EVP_MD_SIZE 162 +-# define EVP_F_EVP_OPENINIT 102 +-# define EVP_F_EVP_PBE_ALG_ADD 115 +-# define EVP_F_EVP_PBE_ALG_ADD_TYPE 160 +-# define EVP_F_EVP_PBE_CIPHERINIT 116 +-# define EVP_F_EVP_PBE_SCRYPT 181 +-# define EVP_F_EVP_PKCS82PKEY 111 +-# define EVP_F_EVP_PKEY2PKCS8 113 +-# define EVP_F_EVP_PKEY_ASN1_ADD0 188 +-# define EVP_F_EVP_PKEY_CHECK 186 +-# define EVP_F_EVP_PKEY_COPY_PARAMETERS 103 +-# define EVP_F_EVP_PKEY_CTX_CTRL 137 +-# define EVP_F_EVP_PKEY_CTX_CTRL_STR 150 +-# define EVP_F_EVP_PKEY_CTX_DUP 156 +-# define EVP_F_EVP_PKEY_CTX_MD 168 +-# define EVP_F_EVP_PKEY_DECRYPT 104 +-# define EVP_F_EVP_PKEY_DECRYPT_INIT 138 +-# define EVP_F_EVP_PKEY_DECRYPT_OLD 151 +-# define EVP_F_EVP_PKEY_DERIVE 153 +-# define EVP_F_EVP_PKEY_DERIVE_INIT 154 +-# define EVP_F_EVP_PKEY_DERIVE_SET_PEER 155 +-# define EVP_F_EVP_PKEY_ENCRYPT 105 +-# define EVP_F_EVP_PKEY_ENCRYPT_INIT 139 +-# define EVP_F_EVP_PKEY_ENCRYPT_OLD 152 +-# define EVP_F_EVP_PKEY_GET0_DH 119 +-# define EVP_F_EVP_PKEY_GET0_DSA 120 +-# define EVP_F_EVP_PKEY_GET0_EC_KEY 131 +-# define EVP_F_EVP_PKEY_GET0_HMAC 183 +-# define EVP_F_EVP_PKEY_GET0_POLY1305 184 +-# define EVP_F_EVP_PKEY_GET0_RSA 121 +-# define EVP_F_EVP_PKEY_GET0_SIPHASH 172 +-# define EVP_F_EVP_PKEY_GET_RAW_PRIVATE_KEY 202 +-# define EVP_F_EVP_PKEY_GET_RAW_PUBLIC_KEY 203 +-# define EVP_F_EVP_PKEY_KEYGEN 146 +-# define EVP_F_EVP_PKEY_KEYGEN_INIT 147 +-# define EVP_F_EVP_PKEY_METH_ADD0 194 +-# define EVP_F_EVP_PKEY_METH_NEW 195 +-# define EVP_F_EVP_PKEY_NEW 106 +-# define EVP_F_EVP_PKEY_NEW_CMAC_KEY 193 +-# define EVP_F_EVP_PKEY_NEW_RAW_PRIVATE_KEY 191 +-# define EVP_F_EVP_PKEY_NEW_RAW_PUBLIC_KEY 192 +-# define EVP_F_EVP_PKEY_PARAMGEN 148 +-# define EVP_F_EVP_PKEY_PARAMGEN_INIT 149 +-# define EVP_F_EVP_PKEY_PARAM_CHECK 189 +-# define EVP_F_EVP_PKEY_PUBLIC_CHECK 190 +-# define EVP_F_EVP_PKEY_SET1_ENGINE 187 +-# define EVP_F_EVP_PKEY_SET_ALIAS_TYPE 206 +-# define EVP_F_EVP_PKEY_SIGN 140 +-# define EVP_F_EVP_PKEY_SIGN_INIT 141 +-# define EVP_F_EVP_PKEY_VERIFY 142 +-# define EVP_F_EVP_PKEY_VERIFY_INIT 143 +-# define EVP_F_EVP_PKEY_VERIFY_RECOVER 144 +-# define EVP_F_EVP_PKEY_VERIFY_RECOVER_INIT 145 +-# define EVP_F_EVP_SIGNFINAL 107 +-# define EVP_F_EVP_VERIFYFINAL 108 +-# define EVP_F_INT_CTX_NEW 157 +-# define EVP_F_OK_NEW 200 +-# define EVP_F_PKCS5_PBE_KEYIVGEN 117 +-# define EVP_F_PKCS5_V2_PBE_KEYIVGEN 118 +-# define EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN 164 +-# define EVP_F_PKCS5_V2_SCRYPT_KEYIVGEN 180 +-# define EVP_F_PKEY_SET_TYPE 158 +-# define EVP_F_RC2_MAGIC_TO_METH 109 +-# define EVP_F_RC5_CTRL 125 +-# define EVP_F_R_32_12_16_INIT_KEY 242 +-# define EVP_F_S390X_AES_GCM_CTRL 201 +-# define EVP_F_UPDATE 173 +- +-/* +- * EVP reason codes. +- */ +-# define EVP_R_AES_KEY_SETUP_FAILED 143 +-# define EVP_R_ARIA_KEY_SETUP_FAILED 176 +-# define EVP_R_BAD_DECRYPT 100 +-# define EVP_R_BAD_KEY_LENGTH 195 +-# define EVP_R_BUFFER_TOO_SMALL 155 +-# define EVP_R_CAMELLIA_KEY_SETUP_FAILED 157 +-# define EVP_R_CIPHER_PARAMETER_ERROR 122 +-# define EVP_R_COMMAND_NOT_SUPPORTED 147 +-# define EVP_R_COPY_ERROR 173 +-# define EVP_R_CTRL_NOT_IMPLEMENTED 132 +-# define EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED 133 +-# define EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH 138 +-# define EVP_R_DECODE_ERROR 114 +-# define EVP_R_DIFFERENT_KEY_TYPES 101 +-# define EVP_R_DIFFERENT_PARAMETERS 153 +-# define EVP_R_ERROR_LOADING_SECTION 165 +-# define EVP_R_ERROR_SETTING_FIPS_MODE 166 +-# define EVP_R_EXPECTING_AN_HMAC_KEY 174 +-# define EVP_R_EXPECTING_AN_RSA_KEY 127 +-# define EVP_R_EXPECTING_A_DH_KEY 128 +-# define EVP_R_EXPECTING_A_DSA_KEY 129 +-# define EVP_R_EXPECTING_A_EC_KEY 142 +-# define EVP_R_EXPECTING_A_POLY1305_KEY 164 +-# define EVP_R_EXPECTING_A_SIPHASH_KEY 175 +-# define EVP_R_FIPS_MODE_NOT_SUPPORTED 167 +-# define EVP_R_GET_RAW_KEY_FAILED 182 +-# define EVP_R_ILLEGAL_SCRYPT_PARAMETERS 171 +-# define EVP_R_INITIALIZATION_ERROR 134 +-# define EVP_R_INPUT_NOT_INITIALIZED 111 +-# define EVP_R_INVALID_DIGEST 152 +-# define EVP_R_INVALID_FIPS_MODE 168 +-# define EVP_R_INVALID_IV_LENGTH 194 +-# define EVP_R_INVALID_KEY 163 +-# define EVP_R_INVALID_KEY_LENGTH 130 +-# define EVP_R_INVALID_OPERATION 148 +-# define EVP_R_KEYGEN_FAILURE 120 +-# define EVP_R_KEY_SETUP_FAILED 180 +-# define EVP_R_MEMORY_LIMIT_EXCEEDED 172 +-# define EVP_R_MESSAGE_DIGEST_IS_NULL 159 +-# define EVP_R_METHOD_NOT_SUPPORTED 144 +-# define EVP_R_MISSING_PARAMETERS 103 +-# define EVP_R_NOT_XOF_OR_INVALID_LENGTH 178 +-# define EVP_R_NO_CIPHER_SET 131 +-# define EVP_R_NO_DEFAULT_DIGEST 158 +-# define EVP_R_NO_DIGEST_SET 139 +-# define EVP_R_NO_KEY_SET 154 +-# define EVP_R_NO_OPERATION_SET 149 +-# define EVP_R_ONLY_ONESHOT_SUPPORTED 177 +-# define EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE 150 +-# define EVP_R_OPERATON_NOT_INITIALIZED 151 +-# define EVP_R_OUTPUT_WOULD_OVERFLOW 184 +-# define EVP_R_PARTIALLY_OVERLAPPING 162 +-# define EVP_R_PBKDF2_ERROR 181 +-# define EVP_R_PKEY_APPLICATION_ASN1_METHOD_ALREADY_REGISTERED 179 +-# define EVP_R_PRIVATE_KEY_DECODE_ERROR 145 +-# define EVP_R_PRIVATE_KEY_ENCODE_ERROR 146 +-# define EVP_R_PUBLIC_KEY_NOT_RSA 106 +-# define EVP_R_UNKNOWN_CIPHER 160 +-# define EVP_R_UNKNOWN_DIGEST 161 +-# define EVP_R_UNKNOWN_OPTION 169 +-# define EVP_R_UNKNOWN_PBE_ALGORITHM 121 +-# define EVP_R_UNSUPPORTED_ALGORITHM 156 +-# define EVP_R_UNSUPPORTED_CIPHER 107 +-# define EVP_R_UNSUPPORTED_KEYLENGTH 123 +-# define EVP_R_UNSUPPORTED_KEY_DERIVATION_FUNCTION 124 +-# define EVP_R_UNSUPPORTED_KEY_SIZE 108 +-# define EVP_R_UNSUPPORTED_NUMBER_OF_ROUNDS 135 +-# define EVP_R_UNSUPPORTED_PRF 125 +-# define EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM 118 +-# define EVP_R_UNSUPPORTED_SALT_TYPE 126 +-# define EVP_R_WRAP_MODE_NOT_ALLOWED 170 +-# define EVP_R_WRONG_FINAL_BLOCK_LENGTH 109 +-# define EVP_R_XTS_DUPLICATED_KEYS 183 +- +-#endif +diff --git a/uadk_tool/include/openssl/hmac.h b/uadk_tool/include/openssl/hmac.h +deleted file mode 100644 +index 458efc1..0000000 +--- a/uadk_tool/include/openssl/hmac.h ++++ /dev/null +@@ -1,51 +0,0 @@ +-/* +- * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_HMAC_H +-# define HEADER_HMAC_H +- +-# include +- +-# include +- +-# if OPENSSL_API_COMPAT < 0x10200000L +-# define HMAC_MAX_MD_CBLOCK 128 /* Deprecated */ +-# endif +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-size_t HMAC_size(const HMAC_CTX *e); +-HMAC_CTX *HMAC_CTX_new(void); +-int HMAC_CTX_reset(HMAC_CTX *ctx); +-void HMAC_CTX_free(HMAC_CTX *ctx); +- +-DEPRECATEDIN_1_1_0(__owur int HMAC_Init(HMAC_CTX *ctx, const void *key, int len, +- const EVP_MD *md)) +- +-/*__owur*/ int HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int len, +- const EVP_MD *md, ENGINE *impl); +-/*__owur*/ int HMAC_Update(HMAC_CTX *ctx, const unsigned char *data, +- size_t len); +-/*__owur*/ int HMAC_Final(HMAC_CTX *ctx, unsigned char *md, +- unsigned int *len); +-unsigned char *HMAC(const EVP_MD *evp_md, const void *key, int key_len, +- const unsigned char *d, size_t n, unsigned char *md, +- unsigned int *md_len); +-__owur int HMAC_CTX_copy(HMAC_CTX *dctx, HMAC_CTX *sctx); +- +-void HMAC_CTX_set_flags(HMAC_CTX *ctx, unsigned long flags); +-const EVP_MD *HMAC_CTX_get_md(const HMAC_CTX *ctx); +- +-#ifdef __cplusplus +-} +-#endif +- +-#endif +diff --git a/uadk_tool/include/openssl/idea.h b/uadk_tool/include/openssl/idea.h +deleted file mode 100644 +index 4334f3e..0000000 +--- a/uadk_tool/include/openssl/idea.h ++++ /dev/null +@@ -1,64 +0,0 @@ +-/* +- * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_IDEA_H +-# define HEADER_IDEA_H +- +-# include +- +-# ifndef OPENSSL_NO_IDEA +-# ifdef __cplusplus +-extern "C" { +-# endif +- +-typedef unsigned int IDEA_INT; +- +-# define IDEA_ENCRYPT 1 +-# define IDEA_DECRYPT 0 +- +-# define IDEA_BLOCK 8 +-# define IDEA_KEY_LENGTH 16 +- +-typedef struct idea_key_st { +- IDEA_INT data[9][6]; +-} IDEA_KEY_SCHEDULE; +- +-const char *IDEA_options(void); +-void IDEA_ecb_encrypt(const unsigned char *in, unsigned char *out, +- IDEA_KEY_SCHEDULE *ks); +-void IDEA_set_encrypt_key(const unsigned char *key, IDEA_KEY_SCHEDULE *ks); +-void IDEA_set_decrypt_key(IDEA_KEY_SCHEDULE *ek, IDEA_KEY_SCHEDULE *dk); +-void IDEA_cbc_encrypt(const unsigned char *in, unsigned char *out, +- long length, IDEA_KEY_SCHEDULE *ks, unsigned char *iv, +- int enc); +-void IDEA_cfb64_encrypt(const unsigned char *in, unsigned char *out, +- long length, IDEA_KEY_SCHEDULE *ks, unsigned char *iv, +- int *num, int enc); +-void IDEA_ofb64_encrypt(const unsigned char *in, unsigned char *out, +- long length, IDEA_KEY_SCHEDULE *ks, unsigned char *iv, +- int *num); +-void IDEA_encrypt(unsigned long *in, IDEA_KEY_SCHEDULE *ks); +- +-# if OPENSSL_API_COMPAT < 0x10100000L +-# define idea_options IDEA_options +-# define idea_ecb_encrypt IDEA_ecb_encrypt +-# define idea_set_encrypt_key IDEA_set_encrypt_key +-# define idea_set_decrypt_key IDEA_set_decrypt_key +-# define idea_cbc_encrypt IDEA_cbc_encrypt +-# define idea_cfb64_encrypt IDEA_cfb64_encrypt +-# define idea_ofb64_encrypt IDEA_ofb64_encrypt +-# define idea_encrypt IDEA_encrypt +-# endif +- +-# ifdef __cplusplus +-} +-# endif +-# endif +- +-#endif +diff --git a/uadk_tool/include/openssl/kdf.h b/uadk_tool/include/openssl/kdf.h +deleted file mode 100644 +index 5abd4c3..0000000 +--- a/uadk_tool/include/openssl/kdf.h ++++ /dev/null +@@ -1,97 +0,0 @@ +-/* +- * Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_KDF_H +-# define HEADER_KDF_H +- +-# include +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-# define EVP_PKEY_CTRL_TLS_MD (EVP_PKEY_ALG_CTRL) +-# define EVP_PKEY_CTRL_TLS_SECRET (EVP_PKEY_ALG_CTRL + 1) +-# define EVP_PKEY_CTRL_TLS_SEED (EVP_PKEY_ALG_CTRL + 2) +-# define EVP_PKEY_CTRL_HKDF_MD (EVP_PKEY_ALG_CTRL + 3) +-# define EVP_PKEY_CTRL_HKDF_SALT (EVP_PKEY_ALG_CTRL + 4) +-# define EVP_PKEY_CTRL_HKDF_KEY (EVP_PKEY_ALG_CTRL + 5) +-# define EVP_PKEY_CTRL_HKDF_INFO (EVP_PKEY_ALG_CTRL + 6) +-# define EVP_PKEY_CTRL_HKDF_MODE (EVP_PKEY_ALG_CTRL + 7) +-# define EVP_PKEY_CTRL_PASS (EVP_PKEY_ALG_CTRL + 8) +-# define EVP_PKEY_CTRL_SCRYPT_SALT (EVP_PKEY_ALG_CTRL + 9) +-# define EVP_PKEY_CTRL_SCRYPT_N (EVP_PKEY_ALG_CTRL + 10) +-# define EVP_PKEY_CTRL_SCRYPT_R (EVP_PKEY_ALG_CTRL + 11) +-# define EVP_PKEY_CTRL_SCRYPT_P (EVP_PKEY_ALG_CTRL + 12) +-# define EVP_PKEY_CTRL_SCRYPT_MAXMEM_BYTES (EVP_PKEY_ALG_CTRL + 13) +- +-# define EVP_PKEY_HKDEF_MODE_EXTRACT_AND_EXPAND 0 +-# define EVP_PKEY_HKDEF_MODE_EXTRACT_ONLY 1 +-# define EVP_PKEY_HKDEF_MODE_EXPAND_ONLY 2 +- +-# define EVP_PKEY_CTX_set_tls1_prf_md(pctx, md) \ +- EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_TLS_MD, 0, (void *)(md)) +- +-# define EVP_PKEY_CTX_set1_tls1_prf_secret(pctx, sec, seclen) \ +- EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_TLS_SECRET, seclen, (void *)(sec)) +- +-# define EVP_PKEY_CTX_add1_tls1_prf_seed(pctx, seed, seedlen) \ +- EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_TLS_SEED, seedlen, (void *)(seed)) +- +-# define EVP_PKEY_CTX_set_hkdf_md(pctx, md) \ +- EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_HKDF_MD, 0, (void *)(md)) +- +-# define EVP_PKEY_CTX_set1_hkdf_salt(pctx, salt, saltlen) \ +- EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_HKDF_SALT, saltlen, (void *)(salt)) +- +-# define EVP_PKEY_CTX_set1_hkdf_key(pctx, key, keylen) \ +- EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_HKDF_KEY, keylen, (void *)(key)) +- +-# define EVP_PKEY_CTX_add1_hkdf_info(pctx, info, infolen) \ +- EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_HKDF_INFO, infolen, (void *)(info)) +- +-# define EVP_PKEY_CTX_hkdf_mode(pctx, mode) \ +- EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_HKDF_MODE, mode, NULL) +- +-# define EVP_PKEY_CTX_set1_pbe_pass(pctx, pass, passlen) \ +- EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_PASS, passlen, (void *)(pass)) +- +-# define EVP_PKEY_CTX_set1_scrypt_salt(pctx, salt, saltlen) \ +- EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_SCRYPT_SALT, saltlen, (void *)(salt)) +- +-# define EVP_PKEY_CTX_set_scrypt_N(pctx, n) \ +- EVP_PKEY_CTX_ctrl_uint64(pctx, -1, EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_SCRYPT_N, n) +- +-# define EVP_PKEY_CTX_set_scrypt_r(pctx, r) \ +- EVP_PKEY_CTX_ctrl_uint64(pctx, -1, EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_SCRYPT_R, r) +- +-# define EVP_PKEY_CTX_set_scrypt_p(pctx, p) \ +- EVP_PKEY_CTX_ctrl_uint64(pctx, -1, EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_SCRYPT_P, p) +- +-# define EVP_PKEY_CTX_set_scrypt_maxmem_bytes(pctx, maxmem_bytes) \ +- EVP_PKEY_CTX_ctrl_uint64(pctx, -1, EVP_PKEY_OP_DERIVE, \ +- EVP_PKEY_CTRL_SCRYPT_MAXMEM_BYTES, maxmem_bytes) +- +- +-# ifdef __cplusplus +-} +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/kdferr.h b/uadk_tool/include/openssl/kdferr.h +deleted file mode 100644 +index 3f51bd0..0000000 +--- a/uadk_tool/include/openssl/kdferr.h ++++ /dev/null +@@ -1,55 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_KDFERR_H +-# define HEADER_KDFERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_KDF_strings(void); +- +-/* +- * KDF function codes. +- */ +-# define KDF_F_PKEY_HKDF_CTRL_STR 103 +-# define KDF_F_PKEY_HKDF_DERIVE 102 +-# define KDF_F_PKEY_HKDF_INIT 108 +-# define KDF_F_PKEY_SCRYPT_CTRL_STR 104 +-# define KDF_F_PKEY_SCRYPT_CTRL_UINT64 105 +-# define KDF_F_PKEY_SCRYPT_DERIVE 109 +-# define KDF_F_PKEY_SCRYPT_INIT 106 +-# define KDF_F_PKEY_SCRYPT_SET_MEMBUF 107 +-# define KDF_F_PKEY_TLS1_PRF_CTRL_STR 100 +-# define KDF_F_PKEY_TLS1_PRF_DERIVE 101 +-# define KDF_F_PKEY_TLS1_PRF_INIT 110 +-# define KDF_F_TLS1_PRF_ALG 111 +- +-/* +- * KDF reason codes. +- */ +-# define KDF_R_INVALID_DIGEST 100 +-# define KDF_R_MISSING_ITERATION_COUNT 109 +-# define KDF_R_MISSING_KEY 104 +-# define KDF_R_MISSING_MESSAGE_DIGEST 105 +-# define KDF_R_MISSING_PARAMETER 101 +-# define KDF_R_MISSING_PASS 110 +-# define KDF_R_MISSING_SALT 111 +-# define KDF_R_MISSING_SECRET 107 +-# define KDF_R_MISSING_SEED 106 +-# define KDF_R_UNKNOWN_PARAMETER_TYPE 103 +-# define KDF_R_VALUE_ERROR 108 +-# define KDF_R_VALUE_MISSING 102 +- +-#endif +diff --git a/uadk_tool/include/openssl/lhash.h b/uadk_tool/include/openssl/lhash.h +deleted file mode 100644 +index 2e42d72..0000000 +--- a/uadk_tool/include/openssl/lhash.h ++++ /dev/null +@@ -1,241 +0,0 @@ +-/* +- * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-/* +- * Header for dynamic hash table routines Author - Eric Young +- */ +- +-#ifndef HEADER_LHASH_H +-# define HEADER_LHASH_H +- +-# include +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-typedef struct lhash_node_st OPENSSL_LH_NODE; +-typedef int (*OPENSSL_LH_COMPFUNC) (const void *, const void *); +-typedef unsigned long (*OPENSSL_LH_HASHFUNC) (const void *); +-typedef void (*OPENSSL_LH_DOALL_FUNC) (void *); +-typedef void (*OPENSSL_LH_DOALL_FUNCARG) (void *, void *); +-typedef struct lhash_st OPENSSL_LHASH; +- +-/* +- * Macros for declaring and implementing type-safe wrappers for LHASH +- * callbacks. This way, callbacks can be provided to LHASH structures without +- * function pointer casting and the macro-defined callbacks provide +- * per-variable casting before deferring to the underlying type-specific +- * callbacks. NB: It is possible to place a "static" in front of both the +- * DECLARE and IMPLEMENT macros if the functions are strictly internal. +- */ +- +-/* First: "hash" functions */ +-# define DECLARE_LHASH_HASH_FN(name, o_type) \ +- unsigned long name##_LHASH_HASH(const void *); +-# define IMPLEMENT_LHASH_HASH_FN(name, o_type) \ +- unsigned long name##_LHASH_HASH(const void *arg) { \ +- const o_type *a = arg; \ +- return name##_hash(a); } +-# define LHASH_HASH_FN(name) name##_LHASH_HASH +- +-/* Second: "compare" functions */ +-# define DECLARE_LHASH_COMP_FN(name, o_type) \ +- int name##_LHASH_COMP(const void *, const void *); +-# define IMPLEMENT_LHASH_COMP_FN(name, o_type) \ +- int name##_LHASH_COMP(const void *arg1, const void *arg2) { \ +- const o_type *a = arg1; \ +- const o_type *b = arg2; \ +- return name##_cmp(a,b); } +-# define LHASH_COMP_FN(name) name##_LHASH_COMP +- +-/* Fourth: "doall_arg" functions */ +-# define DECLARE_LHASH_DOALL_ARG_FN(name, o_type, a_type) \ +- void name##_LHASH_DOALL_ARG(void *, void *); +-# define IMPLEMENT_LHASH_DOALL_ARG_FN(name, o_type, a_type) \ +- void name##_LHASH_DOALL_ARG(void *arg1, void *arg2) { \ +- o_type *a = arg1; \ +- a_type *b = arg2; \ +- name##_doall_arg(a, b); } +-# define LHASH_DOALL_ARG_FN(name) name##_LHASH_DOALL_ARG +- +- +-# define LH_LOAD_MULT 256 +- +-int OPENSSL_LH_error(OPENSSL_LHASH *lh); +-OPENSSL_LHASH *OPENSSL_LH_new(OPENSSL_LH_HASHFUNC h, OPENSSL_LH_COMPFUNC c); +-void OPENSSL_LH_free(OPENSSL_LHASH *lh); +-void *OPENSSL_LH_insert(OPENSSL_LHASH *lh, void *data); +-void *OPENSSL_LH_delete(OPENSSL_LHASH *lh, const void *data); +-void *OPENSSL_LH_retrieve(OPENSSL_LHASH *lh, const void *data); +-void OPENSSL_LH_doall(OPENSSL_LHASH *lh, OPENSSL_LH_DOALL_FUNC func); +-void OPENSSL_LH_doall_arg(OPENSSL_LHASH *lh, OPENSSL_LH_DOALL_FUNCARG func, void *arg); +-unsigned long OPENSSL_LH_strhash(const char *c); +-unsigned long OPENSSL_LH_num_items(const OPENSSL_LHASH *lh); +-unsigned long OPENSSL_LH_get_down_load(const OPENSSL_LHASH *lh); +-void OPENSSL_LH_set_down_load(OPENSSL_LHASH *lh, unsigned long down_load); +- +-# ifndef OPENSSL_NO_STDIO +-void OPENSSL_LH_stats(const OPENSSL_LHASH *lh, FILE *fp); +-void OPENSSL_LH_node_stats(const OPENSSL_LHASH *lh, FILE *fp); +-void OPENSSL_LH_node_usage_stats(const OPENSSL_LHASH *lh, FILE *fp); +-# endif +-void OPENSSL_LH_stats_bio(const OPENSSL_LHASH *lh, BIO *out); +-void OPENSSL_LH_node_stats_bio(const OPENSSL_LHASH *lh, BIO *out); +-void OPENSSL_LH_node_usage_stats_bio(const OPENSSL_LHASH *lh, BIO *out); +- +-# if OPENSSL_API_COMPAT < 0x10100000L +-# define _LHASH OPENSSL_LHASH +-# define LHASH_NODE OPENSSL_LH_NODE +-# define lh_error OPENSSL_LH_error +-# define lh_new OPENSSL_LH_new +-# define lh_free OPENSSL_LH_free +-# define lh_insert OPENSSL_LH_insert +-# define lh_delete OPENSSL_LH_delete +-# define lh_retrieve OPENSSL_LH_retrieve +-# define lh_doall OPENSSL_LH_doall +-# define lh_doall_arg OPENSSL_LH_doall_arg +-# define lh_strhash OPENSSL_LH_strhash +-# define lh_num_items OPENSSL_LH_num_items +-# ifndef OPENSSL_NO_STDIO +-# define lh_stats OPENSSL_LH_stats +-# define lh_node_stats OPENSSL_LH_node_stats +-# define lh_node_usage_stats OPENSSL_LH_node_usage_stats +-# endif +-# define lh_stats_bio OPENSSL_LH_stats_bio +-# define lh_node_stats_bio OPENSSL_LH_node_stats_bio +-# define lh_node_usage_stats_bio OPENSSL_LH_node_usage_stats_bio +-# endif +- +-/* Type checking... */ +- +-# define LHASH_OF(type) struct lhash_st_##type +- +-# define DEFINE_LHASH_OF(type) \ +- LHASH_OF(type) { union lh_##type##_dummy { void* d1; unsigned long d2; int d3; } dummy; }; \ +- static ossl_unused ossl_inline LHASH_OF(type) *lh_##type##_new(unsigned long (*hfn)(const type *), \ +- int (*cfn)(const type *, const type *)) \ +- { \ +- return (LHASH_OF(type) *) \ +- OPENSSL_LH_new((OPENSSL_LH_HASHFUNC)hfn, (OPENSSL_LH_COMPFUNC)cfn); \ +- } \ +- static ossl_unused ossl_inline void lh_##type##_free(LHASH_OF(type) *lh) \ +- { \ +- OPENSSL_LH_free((OPENSSL_LHASH *)lh); \ +- } \ +- static ossl_unused ossl_inline type *lh_##type##_insert(LHASH_OF(type) *lh, type *d) \ +- { \ +- return (type *)OPENSSL_LH_insert((OPENSSL_LHASH *)lh, d); \ +- } \ +- static ossl_unused ossl_inline type *lh_##type##_delete(LHASH_OF(type) *lh, const type *d) \ +- { \ +- return (type *)OPENSSL_LH_delete((OPENSSL_LHASH *)lh, d); \ +- } \ +- static ossl_unused ossl_inline type *lh_##type##_retrieve(LHASH_OF(type) *lh, const type *d) \ +- { \ +- return (type *)OPENSSL_LH_retrieve((OPENSSL_LHASH *)lh, d); \ +- } \ +- static ossl_unused ossl_inline int lh_##type##_error(LHASH_OF(type) *lh) \ +- { \ +- return OPENSSL_LH_error((OPENSSL_LHASH *)lh); \ +- } \ +- static ossl_unused ossl_inline unsigned long lh_##type##_num_items(LHASH_OF(type) *lh) \ +- { \ +- return OPENSSL_LH_num_items((OPENSSL_LHASH *)lh); \ +- } \ +- static ossl_unused ossl_inline void lh_##type##_node_stats_bio(const LHASH_OF(type) *lh, BIO *out) \ +- { \ +- OPENSSL_LH_node_stats_bio((const OPENSSL_LHASH *)lh, out); \ +- } \ +- static ossl_unused ossl_inline void lh_##type##_node_usage_stats_bio(const LHASH_OF(type) *lh, BIO *out) \ +- { \ +- OPENSSL_LH_node_usage_stats_bio((const OPENSSL_LHASH *)lh, out); \ +- } \ +- static ossl_unused ossl_inline void lh_##type##_stats_bio(const LHASH_OF(type) *lh, BIO *out) \ +- { \ +- OPENSSL_LH_stats_bio((const OPENSSL_LHASH *)lh, out); \ +- } \ +- static ossl_unused ossl_inline unsigned long lh_##type##_get_down_load(LHASH_OF(type) *lh) \ +- { \ +- return OPENSSL_LH_get_down_load((OPENSSL_LHASH *)lh); \ +- } \ +- static ossl_unused ossl_inline void lh_##type##_set_down_load(LHASH_OF(type) *lh, unsigned long dl) \ +- { \ +- OPENSSL_LH_set_down_load((OPENSSL_LHASH *)lh, dl); \ +- } \ +- static ossl_unused ossl_inline void lh_##type##_doall(LHASH_OF(type) *lh, \ +- void (*doall)(type *)) \ +- { \ +- OPENSSL_LH_doall((OPENSSL_LHASH *)lh, (OPENSSL_LH_DOALL_FUNC)doall); \ +- } \ +- LHASH_OF(type) +- +-#define IMPLEMENT_LHASH_DOALL_ARG_CONST(type, argtype) \ +- int_implement_lhash_doall(type, argtype, const type) +- +-#define IMPLEMENT_LHASH_DOALL_ARG(type, argtype) \ +- int_implement_lhash_doall(type, argtype, type) +- +-#define int_implement_lhash_doall(type, argtype, cbargtype) \ +- static ossl_unused ossl_inline void \ +- lh_##type##_doall_##argtype(LHASH_OF(type) *lh, \ +- void (*fn)(cbargtype *, argtype *), \ +- argtype *arg) \ +- { \ +- OPENSSL_LH_doall_arg((OPENSSL_LHASH *)lh, (OPENSSL_LH_DOALL_FUNCARG)fn, (void *)arg); \ +- } \ +- LHASH_OF(type) +- +-DEFINE_LHASH_OF(OPENSSL_STRING); +-# ifdef _MSC_VER +-/* +- * push and pop this warning: +- * warning C4090: 'function': different 'const' qualifiers +- */ +-# pragma warning (push) +-# pragma warning (disable: 4090) +-# endif +- +-DEFINE_LHASH_OF(OPENSSL_CSTRING); +- +-# ifdef _MSC_VER +-# pragma warning (pop) +-# endif +- +-/* +- * If called without higher optimization (min. -xO3) the Oracle Developer +- * Studio compiler generates code for the defined (static inline) functions +- * above. +- * This would later lead to the linker complaining about missing symbols when +- * this header file is included but the resulting object is not linked against +- * the Crypto library (openssl#6912). +- */ +-# ifdef __SUNPRO_C +-# pragma weak OPENSSL_LH_new +-# pragma weak OPENSSL_LH_free +-# pragma weak OPENSSL_LH_insert +-# pragma weak OPENSSL_LH_delete +-# pragma weak OPENSSL_LH_retrieve +-# pragma weak OPENSSL_LH_error +-# pragma weak OPENSSL_LH_num_items +-# pragma weak OPENSSL_LH_node_stats_bio +-# pragma weak OPENSSL_LH_node_usage_stats_bio +-# pragma weak OPENSSL_LH_stats_bio +-# pragma weak OPENSSL_LH_get_down_load +-# pragma weak OPENSSL_LH_set_down_load +-# pragma weak OPENSSL_LH_doall +-# pragma weak OPENSSL_LH_doall_arg +-# endif /* __SUNPRO_C */ +- +-#ifdef __cplusplus +-} +-#endif +- +-#endif +diff --git a/uadk_tool/include/openssl/md2.h b/uadk_tool/include/openssl/md2.h +deleted file mode 100644 +index 7faf8e3..0000000 +--- a/uadk_tool/include/openssl/md2.h ++++ /dev/null +@@ -1,44 +0,0 @@ +-/* +- * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_MD2_H +-# define HEADER_MD2_H +- +-# include +- +-# ifndef OPENSSL_NO_MD2 +-# include +-# ifdef __cplusplus +-extern "C" { +-# endif +- +-typedef unsigned char MD2_INT; +- +-# define MD2_DIGEST_LENGTH 16 +-# define MD2_BLOCK 16 +- +-typedef struct MD2state_st { +- unsigned int num; +- unsigned char data[MD2_BLOCK]; +- MD2_INT cksm[MD2_BLOCK]; +- MD2_INT state[MD2_BLOCK]; +-} MD2_CTX; +- +-const char *MD2_options(void); +-int MD2_Init(MD2_CTX *c); +-int MD2_Update(MD2_CTX *c, const unsigned char *data, size_t len); +-int MD2_Final(unsigned char *md, MD2_CTX *c); +-unsigned char *MD2(const unsigned char *d, size_t n, unsigned char *md); +- +-# ifdef __cplusplus +-} +-# endif +-# endif +- +-#endif +diff --git a/uadk_tool/include/openssl/md4.h b/uadk_tool/include/openssl/md4.h +deleted file mode 100644 +index 940e29d..0000000 +--- a/uadk_tool/include/openssl/md4.h ++++ /dev/null +@@ -1,51 +0,0 @@ +-/* +- * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_MD4_H +-# define HEADER_MD4_H +- +-# include +- +-# ifndef OPENSSL_NO_MD4 +-# include +-# include +-# ifdef __cplusplus +-extern "C" { +-# endif +- +-/*- +- * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +- * ! MD4_LONG has to be at least 32 bits wide. ! +- * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +- */ +-# define MD4_LONG unsigned int +- +-# define MD4_CBLOCK 64 +-# define MD4_LBLOCK (MD4_CBLOCK/4) +-# define MD4_DIGEST_LENGTH 16 +- +-typedef struct MD4state_st { +- MD4_LONG A, B, C, D; +- MD4_LONG Nl, Nh; +- MD4_LONG data[MD4_LBLOCK]; +- unsigned int num; +-} MD4_CTX; +- +-int MD4_Init(MD4_CTX *c); +-int MD4_Update(MD4_CTX *c, const void *data, size_t len); +-int MD4_Final(unsigned char *md, MD4_CTX *c); +-unsigned char *MD4(const unsigned char *d, size_t n, unsigned char *md); +-void MD4_Transform(MD4_CTX *c, const unsigned char *b); +- +-# ifdef __cplusplus +-} +-# endif +-# endif +- +-#endif +diff --git a/uadk_tool/include/openssl/md5.h b/uadk_tool/include/openssl/md5.h +deleted file mode 100644 +index 2deb772..0000000 +--- a/uadk_tool/include/openssl/md5.h ++++ /dev/null +@@ -1,50 +0,0 @@ +-/* +- * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_MD5_H +-# define HEADER_MD5_H +- +-# include +- +-# ifndef OPENSSL_NO_MD5 +-# include +-# include +-# ifdef __cplusplus +-extern "C" { +-# endif +- +-/* +- * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +- * ! MD5_LONG has to be at least 32 bits wide. ! +- * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +- */ +-# define MD5_LONG unsigned int +- +-# define MD5_CBLOCK 64 +-# define MD5_LBLOCK (MD5_CBLOCK/4) +-# define MD5_DIGEST_LENGTH 16 +- +-typedef struct MD5state_st { +- MD5_LONG A, B, C, D; +- MD5_LONG Nl, Nh; +- MD5_LONG data[MD5_LBLOCK]; +- unsigned int num; +-} MD5_CTX; +- +-int MD5_Init(MD5_CTX *c); +-int MD5_Update(MD5_CTX *c, const void *data, size_t len); +-int MD5_Final(unsigned char *md, MD5_CTX *c); +-unsigned char *MD5(const unsigned char *d, size_t n, unsigned char *md); +-void MD5_Transform(MD5_CTX *c, const unsigned char *b); +-# ifdef __cplusplus +-} +-# endif +-# endif +- +-#endif +diff --git a/uadk_tool/include/openssl/mdc2.h b/uadk_tool/include/openssl/mdc2.h +deleted file mode 100644 +index aabd2bf..0000000 +--- a/uadk_tool/include/openssl/mdc2.h ++++ /dev/null +@@ -1,42 +0,0 @@ +-/* +- * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_MDC2_H +-# define HEADER_MDC2_H +- +-# include +- +-#ifndef OPENSSL_NO_MDC2 +-# include +-# include +-# ifdef __cplusplus +-extern "C" { +-# endif +- +-# define MDC2_BLOCK 8 +-# define MDC2_DIGEST_LENGTH 16 +- +-typedef struct mdc2_ctx_st { +- unsigned int num; +- unsigned char data[MDC2_BLOCK]; +- DES_cblock h, hh; +- int pad_type; /* either 1 or 2, default 1 */ +-} MDC2_CTX; +- +-int MDC2_Init(MDC2_CTX *c); +-int MDC2_Update(MDC2_CTX *c, const unsigned char *data, size_t len); +-int MDC2_Final(unsigned char *md, MDC2_CTX *c); +-unsigned char *MDC2(const unsigned char *d, size_t n, unsigned char *md); +- +-# ifdef __cplusplus +-} +-# endif +-# endif +- +-#endif +diff --git a/uadk_tool/include/openssl/modes.h b/uadk_tool/include/openssl/modes.h +deleted file mode 100644 +index d544f98..0000000 +--- a/uadk_tool/include/openssl/modes.h ++++ /dev/null +@@ -1,208 +0,0 @@ +-/* +- * Copyright 2008-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_MODES_H +-# define HEADER_MODES_H +- +-# include +- +-# ifdef __cplusplus +-extern "C" { +-# endif +-typedef void (*block128_f) (const unsigned char in[16], +- unsigned char out[16], const void *key); +- +-typedef void (*cbc128_f) (const unsigned char *in, unsigned char *out, +- size_t len, const void *key, +- unsigned char ivec[16], int enc); +- +-typedef void (*ctr128_f) (const unsigned char *in, unsigned char *out, +- size_t blocks, const void *key, +- const unsigned char ivec[16]); +- +-typedef void (*ccm128_f) (const unsigned char *in, unsigned char *out, +- size_t blocks, const void *key, +- const unsigned char ivec[16], +- unsigned char cmac[16]); +- +-void CRYPTO_cbc128_encrypt(const unsigned char *in, unsigned char *out, +- size_t len, const void *key, +- unsigned char ivec[16], block128_f block); +-void CRYPTO_cbc128_decrypt(const unsigned char *in, unsigned char *out, +- size_t len, const void *key, +- unsigned char ivec[16], block128_f block); +- +-void CRYPTO_ctr128_encrypt(const unsigned char *in, unsigned char *out, +- size_t len, const void *key, +- unsigned char ivec[16], +- unsigned char ecount_buf[16], unsigned int *num, +- block128_f block); +- +-void CRYPTO_ctr128_encrypt_ctr32(const unsigned char *in, unsigned char *out, +- size_t len, const void *key, +- unsigned char ivec[16], +- unsigned char ecount_buf[16], +- unsigned int *num, ctr128_f ctr); +- +-void CRYPTO_ofb128_encrypt(const unsigned char *in, unsigned char *out, +- size_t len, const void *key, +- unsigned char ivec[16], int *num, +- block128_f block); +- +-void CRYPTO_cfb128_encrypt(const unsigned char *in, unsigned char *out, +- size_t len, const void *key, +- unsigned char ivec[16], int *num, +- int enc, block128_f block); +-void CRYPTO_cfb128_8_encrypt(const unsigned char *in, unsigned char *out, +- size_t length, const void *key, +- unsigned char ivec[16], int *num, +- int enc, block128_f block); +-void CRYPTO_cfb128_1_encrypt(const unsigned char *in, unsigned char *out, +- size_t bits, const void *key, +- unsigned char ivec[16], int *num, +- int enc, block128_f block); +- +-size_t CRYPTO_cts128_encrypt_block(const unsigned char *in, +- unsigned char *out, size_t len, +- const void *key, unsigned char ivec[16], +- block128_f block); +-size_t CRYPTO_cts128_encrypt(const unsigned char *in, unsigned char *out, +- size_t len, const void *key, +- unsigned char ivec[16], cbc128_f cbc); +-size_t CRYPTO_cts128_decrypt_block(const unsigned char *in, +- unsigned char *out, size_t len, +- const void *key, unsigned char ivec[16], +- block128_f block); +-size_t CRYPTO_cts128_decrypt(const unsigned char *in, unsigned char *out, +- size_t len, const void *key, +- unsigned char ivec[16], cbc128_f cbc); +- +-size_t CRYPTO_nistcts128_encrypt_block(const unsigned char *in, +- unsigned char *out, size_t len, +- const void *key, +- unsigned char ivec[16], +- block128_f block); +-size_t CRYPTO_nistcts128_encrypt(const unsigned char *in, unsigned char *out, +- size_t len, const void *key, +- unsigned char ivec[16], cbc128_f cbc); +-size_t CRYPTO_nistcts128_decrypt_block(const unsigned char *in, +- unsigned char *out, size_t len, +- const void *key, +- unsigned char ivec[16], +- block128_f block); +-size_t CRYPTO_nistcts128_decrypt(const unsigned char *in, unsigned char *out, +- size_t len, const void *key, +- unsigned char ivec[16], cbc128_f cbc); +- +-typedef struct gcm128_context GCM128_CONTEXT; +- +-GCM128_CONTEXT *CRYPTO_gcm128_new(void *key, block128_f block); +-void CRYPTO_gcm128_init(GCM128_CONTEXT *ctx, void *key, block128_f block); +-void CRYPTO_gcm128_setiv(GCM128_CONTEXT *ctx, const unsigned char *iv, +- size_t len); +-int CRYPTO_gcm128_aad(GCM128_CONTEXT *ctx, const unsigned char *aad, +- size_t len); +-int CRYPTO_gcm128_encrypt(GCM128_CONTEXT *ctx, +- const unsigned char *in, unsigned char *out, +- size_t len); +-int CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx, +- const unsigned char *in, unsigned char *out, +- size_t len); +-int CRYPTO_gcm128_encrypt_ctr32(GCM128_CONTEXT *ctx, +- const unsigned char *in, unsigned char *out, +- size_t len, ctr128_f stream); +-int CRYPTO_gcm128_decrypt_ctr32(GCM128_CONTEXT *ctx, +- const unsigned char *in, unsigned char *out, +- size_t len, ctr128_f stream); +-int CRYPTO_gcm128_finish(GCM128_CONTEXT *ctx, const unsigned char *tag, +- size_t len); +-void CRYPTO_gcm128_tag(GCM128_CONTEXT *ctx, unsigned char *tag, size_t len); +-void CRYPTO_gcm128_release(GCM128_CONTEXT *ctx); +- +-typedef struct ccm128_context CCM128_CONTEXT; +- +-void CRYPTO_ccm128_init(CCM128_CONTEXT *ctx, +- unsigned int M, unsigned int L, void *key, +- block128_f block); +-int CRYPTO_ccm128_setiv(CCM128_CONTEXT *ctx, const unsigned char *nonce, +- size_t nlen, size_t mlen); +-void CRYPTO_ccm128_aad(CCM128_CONTEXT *ctx, const unsigned char *aad, +- size_t alen); +-int CRYPTO_ccm128_encrypt(CCM128_CONTEXT *ctx, const unsigned char *inp, +- unsigned char *out, size_t len); +-int CRYPTO_ccm128_decrypt(CCM128_CONTEXT *ctx, const unsigned char *inp, +- unsigned char *out, size_t len); +-int CRYPTO_ccm128_encrypt_ccm64(CCM128_CONTEXT *ctx, const unsigned char *inp, +- unsigned char *out, size_t len, +- ccm128_f stream); +-int CRYPTO_ccm128_decrypt_ccm64(CCM128_CONTEXT *ctx, const unsigned char *inp, +- unsigned char *out, size_t len, +- ccm128_f stream); +-size_t CRYPTO_ccm128_tag(CCM128_CONTEXT *ctx, unsigned char *tag, size_t len); +- +-typedef struct xts128_context XTS128_CONTEXT; +- +-int CRYPTO_xts128_encrypt(const XTS128_CONTEXT *ctx, +- const unsigned char iv[16], +- const unsigned char *inp, unsigned char *out, +- size_t len, int enc); +- +-size_t CRYPTO_128_wrap(void *key, const unsigned char *iv, +- unsigned char *out, +- const unsigned char *in, size_t inlen, +- block128_f block); +- +-size_t CRYPTO_128_unwrap(void *key, const unsigned char *iv, +- unsigned char *out, +- const unsigned char *in, size_t inlen, +- block128_f block); +-size_t CRYPTO_128_wrap_pad(void *key, const unsigned char *icv, +- unsigned char *out, const unsigned char *in, +- size_t inlen, block128_f block); +-size_t CRYPTO_128_unwrap_pad(void *key, const unsigned char *icv, +- unsigned char *out, const unsigned char *in, +- size_t inlen, block128_f block); +- +-# ifndef OPENSSL_NO_OCB +-typedef struct ocb128_context OCB128_CONTEXT; +- +-typedef void (*ocb128_f) (const unsigned char *in, unsigned char *out, +- size_t blocks, const void *key, +- size_t start_block_num, +- unsigned char offset_i[16], +- const unsigned char L_[][16], +- unsigned char checksum[16]); +- +-OCB128_CONTEXT *CRYPTO_ocb128_new(void *keyenc, void *keydec, +- block128_f encrypt, block128_f decrypt, +- ocb128_f stream); +-int CRYPTO_ocb128_init(OCB128_CONTEXT *ctx, void *keyenc, void *keydec, +- block128_f encrypt, block128_f decrypt, +- ocb128_f stream); +-int CRYPTO_ocb128_copy_ctx(OCB128_CONTEXT *dest, OCB128_CONTEXT *src, +- void *keyenc, void *keydec); +-int CRYPTO_ocb128_setiv(OCB128_CONTEXT *ctx, const unsigned char *iv, +- size_t len, size_t taglen); +-int CRYPTO_ocb128_aad(OCB128_CONTEXT *ctx, const unsigned char *aad, +- size_t len); +-int CRYPTO_ocb128_encrypt(OCB128_CONTEXT *ctx, const unsigned char *in, +- unsigned char *out, size_t len); +-int CRYPTO_ocb128_decrypt(OCB128_CONTEXT *ctx, const unsigned char *in, +- unsigned char *out, size_t len); +-int CRYPTO_ocb128_finish(OCB128_CONTEXT *ctx, const unsigned char *tag, +- size_t len); +-int CRYPTO_ocb128_tag(OCB128_CONTEXT *ctx, unsigned char *tag, size_t len); +-void CRYPTO_ocb128_cleanup(OCB128_CONTEXT *ctx); +-# endif /* OPENSSL_NO_OCB */ +- +-# ifdef __cplusplus +-} +-# endif +- +-#endif +diff --git a/uadk_tool/include/openssl/obj_mac.h b/uadk_tool/include/openssl/obj_mac.h +deleted file mode 100644 +index eb812ed..0000000 +--- a/uadk_tool/include/openssl/obj_mac.h ++++ /dev/null +@@ -1,5198 +0,0 @@ +-/* +- * WARNING: do not edit! +- * Generated by crypto/objects/objects.pl +- * +- * Copyright 2000-2021 The OpenSSL Project Authors. All Rights Reserved. +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#define SN_undef "UNDEF" +-#define LN_undef "undefined" +-#define NID_undef 0 +-#define OBJ_undef 0L +- +-#define SN_itu_t "ITU-T" +-#define LN_itu_t "itu-t" +-#define NID_itu_t 645 +-#define OBJ_itu_t 0L +- +-#define NID_ccitt 404 +-#define OBJ_ccitt OBJ_itu_t +- +-#define SN_iso "ISO" +-#define LN_iso "iso" +-#define NID_iso 181 +-#define OBJ_iso 1L +- +-#define SN_joint_iso_itu_t "JOINT-ISO-ITU-T" +-#define LN_joint_iso_itu_t "joint-iso-itu-t" +-#define NID_joint_iso_itu_t 646 +-#define OBJ_joint_iso_itu_t 2L +- +-#define NID_joint_iso_ccitt 393 +-#define OBJ_joint_iso_ccitt OBJ_joint_iso_itu_t +- +-#define SN_member_body "member-body" +-#define LN_member_body "ISO Member Body" +-#define NID_member_body 182 +-#define OBJ_member_body OBJ_iso,2L +- +-#define SN_identified_organization "identified-organization" +-#define NID_identified_organization 676 +-#define OBJ_identified_organization OBJ_iso,3L +- +-#define SN_hmac_md5 "HMAC-MD5" +-#define LN_hmac_md5 "hmac-md5" +-#define NID_hmac_md5 780 +-#define OBJ_hmac_md5 OBJ_identified_organization,6L,1L,5L,5L,8L,1L,1L +- +-#define SN_hmac_sha1 "HMAC-SHA1" +-#define LN_hmac_sha1 "hmac-sha1" +-#define NID_hmac_sha1 781 +-#define OBJ_hmac_sha1 OBJ_identified_organization,6L,1L,5L,5L,8L,1L,2L +- +-#define SN_x509ExtAdmission "x509ExtAdmission" +-#define LN_x509ExtAdmission "Professional Information or basis for Admission" +-#define NID_x509ExtAdmission 1093 +-#define OBJ_x509ExtAdmission OBJ_identified_organization,36L,8L,3L,3L +- +-#define SN_certicom_arc "certicom-arc" +-#define NID_certicom_arc 677 +-#define OBJ_certicom_arc OBJ_identified_organization,132L +- +-#define SN_ieee "ieee" +-#define NID_ieee 1170 +-#define OBJ_ieee OBJ_identified_organization,111L +- +-#define SN_ieee_siswg "ieee-siswg" +-#define LN_ieee_siswg "IEEE Security in Storage Working Group" +-#define NID_ieee_siswg 1171 +-#define OBJ_ieee_siswg OBJ_ieee,2L,1619L +- +-#define SN_international_organizations "international-organizations" +-#define LN_international_organizations "International Organizations" +-#define NID_international_organizations 647 +-#define OBJ_international_organizations OBJ_joint_iso_itu_t,23L +- +-#define SN_wap "wap" +-#define NID_wap 678 +-#define OBJ_wap OBJ_international_organizations,43L +- +-#define SN_wap_wsg "wap-wsg" +-#define NID_wap_wsg 679 +-#define OBJ_wap_wsg OBJ_wap,1L +- +-#define SN_selected_attribute_types "selected-attribute-types" +-#define LN_selected_attribute_types "Selected Attribute Types" +-#define NID_selected_attribute_types 394 +-#define OBJ_selected_attribute_types OBJ_joint_iso_itu_t,5L,1L,5L +- +-#define SN_clearance "clearance" +-#define NID_clearance 395 +-#define OBJ_clearance OBJ_selected_attribute_types,55L +- +-#define SN_ISO_US "ISO-US" +-#define LN_ISO_US "ISO US Member Body" +-#define NID_ISO_US 183 +-#define OBJ_ISO_US OBJ_member_body,840L +- +-#define SN_X9_57 "X9-57" +-#define LN_X9_57 "X9.57" +-#define NID_X9_57 184 +-#define OBJ_X9_57 OBJ_ISO_US,10040L +- +-#define SN_X9cm "X9cm" +-#define LN_X9cm "X9.57 CM ?" +-#define NID_X9cm 185 +-#define OBJ_X9cm OBJ_X9_57,4L +- +-#define SN_ISO_CN "ISO-CN" +-#define LN_ISO_CN "ISO CN Member Body" +-#define NID_ISO_CN 1140 +-#define OBJ_ISO_CN OBJ_member_body,156L +- +-#define SN_oscca "oscca" +-#define NID_oscca 1141 +-#define OBJ_oscca OBJ_ISO_CN,10197L +- +-#define SN_sm_scheme "sm-scheme" +-#define NID_sm_scheme 1142 +-#define OBJ_sm_scheme OBJ_oscca,1L +- +-#define SN_dsa "DSA" +-#define LN_dsa "dsaEncryption" +-#define NID_dsa 116 +-#define OBJ_dsa OBJ_X9cm,1L +- +-#define SN_dsaWithSHA1 "DSA-SHA1" +-#define LN_dsaWithSHA1 "dsaWithSHA1" +-#define NID_dsaWithSHA1 113 +-#define OBJ_dsaWithSHA1 OBJ_X9cm,3L +- +-#define SN_ansi_X9_62 "ansi-X9-62" +-#define LN_ansi_X9_62 "ANSI X9.62" +-#define NID_ansi_X9_62 405 +-#define OBJ_ansi_X9_62 OBJ_ISO_US,10045L +- +-#define OBJ_X9_62_id_fieldType OBJ_ansi_X9_62,1L +- +-#define SN_X9_62_prime_field "prime-field" +-#define NID_X9_62_prime_field 406 +-#define OBJ_X9_62_prime_field OBJ_X9_62_id_fieldType,1L +- +-#define SN_X9_62_characteristic_two_field "characteristic-two-field" +-#define NID_X9_62_characteristic_two_field 407 +-#define OBJ_X9_62_characteristic_two_field OBJ_X9_62_id_fieldType,2L +- +-#define SN_X9_62_id_characteristic_two_basis "id-characteristic-two-basis" +-#define NID_X9_62_id_characteristic_two_basis 680 +-#define OBJ_X9_62_id_characteristic_two_basis OBJ_X9_62_characteristic_two_field,3L +- +-#define SN_X9_62_onBasis "onBasis" +-#define NID_X9_62_onBasis 681 +-#define OBJ_X9_62_onBasis OBJ_X9_62_id_characteristic_two_basis,1L +- +-#define SN_X9_62_tpBasis "tpBasis" +-#define NID_X9_62_tpBasis 682 +-#define OBJ_X9_62_tpBasis OBJ_X9_62_id_characteristic_two_basis,2L +- +-#define SN_X9_62_ppBasis "ppBasis" +-#define NID_X9_62_ppBasis 683 +-#define OBJ_X9_62_ppBasis OBJ_X9_62_id_characteristic_two_basis,3L +- +-#define OBJ_X9_62_id_publicKeyType OBJ_ansi_X9_62,2L +- +-#define SN_X9_62_id_ecPublicKey "id-ecPublicKey" +-#define NID_X9_62_id_ecPublicKey 408 +-#define OBJ_X9_62_id_ecPublicKey OBJ_X9_62_id_publicKeyType,1L +- +-#define OBJ_X9_62_ellipticCurve OBJ_ansi_X9_62,3L +- +-#define OBJ_X9_62_c_TwoCurve OBJ_X9_62_ellipticCurve,0L +- +-#define SN_X9_62_c2pnb163v1 "c2pnb163v1" +-#define NID_X9_62_c2pnb163v1 684 +-#define OBJ_X9_62_c2pnb163v1 OBJ_X9_62_c_TwoCurve,1L +- +-#define SN_X9_62_c2pnb163v2 "c2pnb163v2" +-#define NID_X9_62_c2pnb163v2 685 +-#define OBJ_X9_62_c2pnb163v2 OBJ_X9_62_c_TwoCurve,2L +- +-#define SN_X9_62_c2pnb163v3 "c2pnb163v3" +-#define NID_X9_62_c2pnb163v3 686 +-#define OBJ_X9_62_c2pnb163v3 OBJ_X9_62_c_TwoCurve,3L +- +-#define SN_X9_62_c2pnb176v1 "c2pnb176v1" +-#define NID_X9_62_c2pnb176v1 687 +-#define OBJ_X9_62_c2pnb176v1 OBJ_X9_62_c_TwoCurve,4L +- +-#define SN_X9_62_c2tnb191v1 "c2tnb191v1" +-#define NID_X9_62_c2tnb191v1 688 +-#define OBJ_X9_62_c2tnb191v1 OBJ_X9_62_c_TwoCurve,5L +- +-#define SN_X9_62_c2tnb191v2 "c2tnb191v2" +-#define NID_X9_62_c2tnb191v2 689 +-#define OBJ_X9_62_c2tnb191v2 OBJ_X9_62_c_TwoCurve,6L +- +-#define SN_X9_62_c2tnb191v3 "c2tnb191v3" +-#define NID_X9_62_c2tnb191v3 690 +-#define OBJ_X9_62_c2tnb191v3 OBJ_X9_62_c_TwoCurve,7L +- +-#define SN_X9_62_c2onb191v4 "c2onb191v4" +-#define NID_X9_62_c2onb191v4 691 +-#define OBJ_X9_62_c2onb191v4 OBJ_X9_62_c_TwoCurve,8L +- +-#define SN_X9_62_c2onb191v5 "c2onb191v5" +-#define NID_X9_62_c2onb191v5 692 +-#define OBJ_X9_62_c2onb191v5 OBJ_X9_62_c_TwoCurve,9L +- +-#define SN_X9_62_c2pnb208w1 "c2pnb208w1" +-#define NID_X9_62_c2pnb208w1 693 +-#define OBJ_X9_62_c2pnb208w1 OBJ_X9_62_c_TwoCurve,10L +- +-#define SN_X9_62_c2tnb239v1 "c2tnb239v1" +-#define NID_X9_62_c2tnb239v1 694 +-#define OBJ_X9_62_c2tnb239v1 OBJ_X9_62_c_TwoCurve,11L +- +-#define SN_X9_62_c2tnb239v2 "c2tnb239v2" +-#define NID_X9_62_c2tnb239v2 695 +-#define OBJ_X9_62_c2tnb239v2 OBJ_X9_62_c_TwoCurve,12L +- +-#define SN_X9_62_c2tnb239v3 "c2tnb239v3" +-#define NID_X9_62_c2tnb239v3 696 +-#define OBJ_X9_62_c2tnb239v3 OBJ_X9_62_c_TwoCurve,13L +- +-#define SN_X9_62_c2onb239v4 "c2onb239v4" +-#define NID_X9_62_c2onb239v4 697 +-#define OBJ_X9_62_c2onb239v4 OBJ_X9_62_c_TwoCurve,14L +- +-#define SN_X9_62_c2onb239v5 "c2onb239v5" +-#define NID_X9_62_c2onb239v5 698 +-#define OBJ_X9_62_c2onb239v5 OBJ_X9_62_c_TwoCurve,15L +- +-#define SN_X9_62_c2pnb272w1 "c2pnb272w1" +-#define NID_X9_62_c2pnb272w1 699 +-#define OBJ_X9_62_c2pnb272w1 OBJ_X9_62_c_TwoCurve,16L +- +-#define SN_X9_62_c2pnb304w1 "c2pnb304w1" +-#define NID_X9_62_c2pnb304w1 700 +-#define OBJ_X9_62_c2pnb304w1 OBJ_X9_62_c_TwoCurve,17L +- +-#define SN_X9_62_c2tnb359v1 "c2tnb359v1" +-#define NID_X9_62_c2tnb359v1 701 +-#define OBJ_X9_62_c2tnb359v1 OBJ_X9_62_c_TwoCurve,18L +- +-#define SN_X9_62_c2pnb368w1 "c2pnb368w1" +-#define NID_X9_62_c2pnb368w1 702 +-#define OBJ_X9_62_c2pnb368w1 OBJ_X9_62_c_TwoCurve,19L +- +-#define SN_X9_62_c2tnb431r1 "c2tnb431r1" +-#define NID_X9_62_c2tnb431r1 703 +-#define OBJ_X9_62_c2tnb431r1 OBJ_X9_62_c_TwoCurve,20L +- +-#define OBJ_X9_62_primeCurve OBJ_X9_62_ellipticCurve,1L +- +-#define SN_X9_62_prime192v1 "prime192v1" +-#define NID_X9_62_prime192v1 409 +-#define OBJ_X9_62_prime192v1 OBJ_X9_62_primeCurve,1L +- +-#define SN_X9_62_prime192v2 "prime192v2" +-#define NID_X9_62_prime192v2 410 +-#define OBJ_X9_62_prime192v2 OBJ_X9_62_primeCurve,2L +- +-#define SN_X9_62_prime192v3 "prime192v3" +-#define NID_X9_62_prime192v3 411 +-#define OBJ_X9_62_prime192v3 OBJ_X9_62_primeCurve,3L +- +-#define SN_X9_62_prime239v1 "prime239v1" +-#define NID_X9_62_prime239v1 412 +-#define OBJ_X9_62_prime239v1 OBJ_X9_62_primeCurve,4L +- +-#define SN_X9_62_prime239v2 "prime239v2" +-#define NID_X9_62_prime239v2 413 +-#define OBJ_X9_62_prime239v2 OBJ_X9_62_primeCurve,5L +- +-#define SN_X9_62_prime239v3 "prime239v3" +-#define NID_X9_62_prime239v3 414 +-#define OBJ_X9_62_prime239v3 OBJ_X9_62_primeCurve,6L +- +-#define SN_X9_62_prime256v1 "prime256v1" +-#define NID_X9_62_prime256v1 415 +-#define OBJ_X9_62_prime256v1 OBJ_X9_62_primeCurve,7L +- +-#define OBJ_X9_62_id_ecSigType OBJ_ansi_X9_62,4L +- +-#define SN_ecdsa_with_SHA1 "ecdsa-with-SHA1" +-#define NID_ecdsa_with_SHA1 416 +-#define OBJ_ecdsa_with_SHA1 OBJ_X9_62_id_ecSigType,1L +- +-#define SN_ecdsa_with_Recommended "ecdsa-with-Recommended" +-#define NID_ecdsa_with_Recommended 791 +-#define OBJ_ecdsa_with_Recommended OBJ_X9_62_id_ecSigType,2L +- +-#define SN_ecdsa_with_Specified "ecdsa-with-Specified" +-#define NID_ecdsa_with_Specified 792 +-#define OBJ_ecdsa_with_Specified OBJ_X9_62_id_ecSigType,3L +- +-#define SN_ecdsa_with_SHA224 "ecdsa-with-SHA224" +-#define NID_ecdsa_with_SHA224 793 +-#define OBJ_ecdsa_with_SHA224 OBJ_ecdsa_with_Specified,1L +- +-#define SN_ecdsa_with_SHA256 "ecdsa-with-SHA256" +-#define NID_ecdsa_with_SHA256 794 +-#define OBJ_ecdsa_with_SHA256 OBJ_ecdsa_with_Specified,2L +- +-#define SN_ecdsa_with_SHA384 "ecdsa-with-SHA384" +-#define NID_ecdsa_with_SHA384 795 +-#define OBJ_ecdsa_with_SHA384 OBJ_ecdsa_with_Specified,3L +- +-#define SN_ecdsa_with_SHA512 "ecdsa-with-SHA512" +-#define NID_ecdsa_with_SHA512 796 +-#define OBJ_ecdsa_with_SHA512 OBJ_ecdsa_with_Specified,4L +- +-#define OBJ_secg_ellipticCurve OBJ_certicom_arc,0L +- +-#define SN_secp112r1 "secp112r1" +-#define NID_secp112r1 704 +-#define OBJ_secp112r1 OBJ_secg_ellipticCurve,6L +- +-#define SN_secp112r2 "secp112r2" +-#define NID_secp112r2 705 +-#define OBJ_secp112r2 OBJ_secg_ellipticCurve,7L +- +-#define SN_secp128r1 "secp128r1" +-#define NID_secp128r1 706 +-#define OBJ_secp128r1 OBJ_secg_ellipticCurve,28L +- +-#define SN_secp128r2 "secp128r2" +-#define NID_secp128r2 707 +-#define OBJ_secp128r2 OBJ_secg_ellipticCurve,29L +- +-#define SN_secp160k1 "secp160k1" +-#define NID_secp160k1 708 +-#define OBJ_secp160k1 OBJ_secg_ellipticCurve,9L +- +-#define SN_secp160r1 "secp160r1" +-#define NID_secp160r1 709 +-#define OBJ_secp160r1 OBJ_secg_ellipticCurve,8L +- +-#define SN_secp160r2 "secp160r2" +-#define NID_secp160r2 710 +-#define OBJ_secp160r2 OBJ_secg_ellipticCurve,30L +- +-#define SN_secp192k1 "secp192k1" +-#define NID_secp192k1 711 +-#define OBJ_secp192k1 OBJ_secg_ellipticCurve,31L +- +-#define SN_secp224k1 "secp224k1" +-#define NID_secp224k1 712 +-#define OBJ_secp224k1 OBJ_secg_ellipticCurve,32L +- +-#define SN_secp224r1 "secp224r1" +-#define NID_secp224r1 713 +-#define OBJ_secp224r1 OBJ_secg_ellipticCurve,33L +- +-#define SN_secp256k1 "secp256k1" +-#define NID_secp256k1 714 +-#define OBJ_secp256k1 OBJ_secg_ellipticCurve,10L +- +-#define SN_secp384r1 "secp384r1" +-#define NID_secp384r1 715 +-#define OBJ_secp384r1 OBJ_secg_ellipticCurve,34L +- +-#define SN_secp521r1 "secp521r1" +-#define NID_secp521r1 716 +-#define OBJ_secp521r1 OBJ_secg_ellipticCurve,35L +- +-#define SN_sect113r1 "sect113r1" +-#define NID_sect113r1 717 +-#define OBJ_sect113r1 OBJ_secg_ellipticCurve,4L +- +-#define SN_sect113r2 "sect113r2" +-#define NID_sect113r2 718 +-#define OBJ_sect113r2 OBJ_secg_ellipticCurve,5L +- +-#define SN_sect131r1 "sect131r1" +-#define NID_sect131r1 719 +-#define OBJ_sect131r1 OBJ_secg_ellipticCurve,22L +- +-#define SN_sect131r2 "sect131r2" +-#define NID_sect131r2 720 +-#define OBJ_sect131r2 OBJ_secg_ellipticCurve,23L +- +-#define SN_sect163k1 "sect163k1" +-#define NID_sect163k1 721 +-#define OBJ_sect163k1 OBJ_secg_ellipticCurve,1L +- +-#define SN_sect163r1 "sect163r1" +-#define NID_sect163r1 722 +-#define OBJ_sect163r1 OBJ_secg_ellipticCurve,2L +- +-#define SN_sect163r2 "sect163r2" +-#define NID_sect163r2 723 +-#define OBJ_sect163r2 OBJ_secg_ellipticCurve,15L +- +-#define SN_sect193r1 "sect193r1" +-#define NID_sect193r1 724 +-#define OBJ_sect193r1 OBJ_secg_ellipticCurve,24L +- +-#define SN_sect193r2 "sect193r2" +-#define NID_sect193r2 725 +-#define OBJ_sect193r2 OBJ_secg_ellipticCurve,25L +- +-#define SN_sect233k1 "sect233k1" +-#define NID_sect233k1 726 +-#define OBJ_sect233k1 OBJ_secg_ellipticCurve,26L +- +-#define SN_sect233r1 "sect233r1" +-#define NID_sect233r1 727 +-#define OBJ_sect233r1 OBJ_secg_ellipticCurve,27L +- +-#define SN_sect239k1 "sect239k1" +-#define NID_sect239k1 728 +-#define OBJ_sect239k1 OBJ_secg_ellipticCurve,3L +- +-#define SN_sect283k1 "sect283k1" +-#define NID_sect283k1 729 +-#define OBJ_sect283k1 OBJ_secg_ellipticCurve,16L +- +-#define SN_sect283r1 "sect283r1" +-#define NID_sect283r1 730 +-#define OBJ_sect283r1 OBJ_secg_ellipticCurve,17L +- +-#define SN_sect409k1 "sect409k1" +-#define NID_sect409k1 731 +-#define OBJ_sect409k1 OBJ_secg_ellipticCurve,36L +- +-#define SN_sect409r1 "sect409r1" +-#define NID_sect409r1 732 +-#define OBJ_sect409r1 OBJ_secg_ellipticCurve,37L +- +-#define SN_sect571k1 "sect571k1" +-#define NID_sect571k1 733 +-#define OBJ_sect571k1 OBJ_secg_ellipticCurve,38L +- +-#define SN_sect571r1 "sect571r1" +-#define NID_sect571r1 734 +-#define OBJ_sect571r1 OBJ_secg_ellipticCurve,39L +- +-#define OBJ_wap_wsg_idm_ecid OBJ_wap_wsg,4L +- +-#define SN_wap_wsg_idm_ecid_wtls1 "wap-wsg-idm-ecid-wtls1" +-#define NID_wap_wsg_idm_ecid_wtls1 735 +-#define OBJ_wap_wsg_idm_ecid_wtls1 OBJ_wap_wsg_idm_ecid,1L +- +-#define SN_wap_wsg_idm_ecid_wtls3 "wap-wsg-idm-ecid-wtls3" +-#define NID_wap_wsg_idm_ecid_wtls3 736 +-#define OBJ_wap_wsg_idm_ecid_wtls3 OBJ_wap_wsg_idm_ecid,3L +- +-#define SN_wap_wsg_idm_ecid_wtls4 "wap-wsg-idm-ecid-wtls4" +-#define NID_wap_wsg_idm_ecid_wtls4 737 +-#define OBJ_wap_wsg_idm_ecid_wtls4 OBJ_wap_wsg_idm_ecid,4L +- +-#define SN_wap_wsg_idm_ecid_wtls5 "wap-wsg-idm-ecid-wtls5" +-#define NID_wap_wsg_idm_ecid_wtls5 738 +-#define OBJ_wap_wsg_idm_ecid_wtls5 OBJ_wap_wsg_idm_ecid,5L +- +-#define SN_wap_wsg_idm_ecid_wtls6 "wap-wsg-idm-ecid-wtls6" +-#define NID_wap_wsg_idm_ecid_wtls6 739 +-#define OBJ_wap_wsg_idm_ecid_wtls6 OBJ_wap_wsg_idm_ecid,6L +- +-#define SN_wap_wsg_idm_ecid_wtls7 "wap-wsg-idm-ecid-wtls7" +-#define NID_wap_wsg_idm_ecid_wtls7 740 +-#define OBJ_wap_wsg_idm_ecid_wtls7 OBJ_wap_wsg_idm_ecid,7L +- +-#define SN_wap_wsg_idm_ecid_wtls8 "wap-wsg-idm-ecid-wtls8" +-#define NID_wap_wsg_idm_ecid_wtls8 741 +-#define OBJ_wap_wsg_idm_ecid_wtls8 OBJ_wap_wsg_idm_ecid,8L +- +-#define SN_wap_wsg_idm_ecid_wtls9 "wap-wsg-idm-ecid-wtls9" +-#define NID_wap_wsg_idm_ecid_wtls9 742 +-#define OBJ_wap_wsg_idm_ecid_wtls9 OBJ_wap_wsg_idm_ecid,9L +- +-#define SN_wap_wsg_idm_ecid_wtls10 "wap-wsg-idm-ecid-wtls10" +-#define NID_wap_wsg_idm_ecid_wtls10 743 +-#define OBJ_wap_wsg_idm_ecid_wtls10 OBJ_wap_wsg_idm_ecid,10L +- +-#define SN_wap_wsg_idm_ecid_wtls11 "wap-wsg-idm-ecid-wtls11" +-#define NID_wap_wsg_idm_ecid_wtls11 744 +-#define OBJ_wap_wsg_idm_ecid_wtls11 OBJ_wap_wsg_idm_ecid,11L +- +-#define SN_wap_wsg_idm_ecid_wtls12 "wap-wsg-idm-ecid-wtls12" +-#define NID_wap_wsg_idm_ecid_wtls12 745 +-#define OBJ_wap_wsg_idm_ecid_wtls12 OBJ_wap_wsg_idm_ecid,12L +- +-#define SN_cast5_cbc "CAST5-CBC" +-#define LN_cast5_cbc "cast5-cbc" +-#define NID_cast5_cbc 108 +-#define OBJ_cast5_cbc OBJ_ISO_US,113533L,7L,66L,10L +- +-#define SN_cast5_ecb "CAST5-ECB" +-#define LN_cast5_ecb "cast5-ecb" +-#define NID_cast5_ecb 109 +- +-#define SN_cast5_cfb64 "CAST5-CFB" +-#define LN_cast5_cfb64 "cast5-cfb" +-#define NID_cast5_cfb64 110 +- +-#define SN_cast5_ofb64 "CAST5-OFB" +-#define LN_cast5_ofb64 "cast5-ofb" +-#define NID_cast5_ofb64 111 +- +-#define LN_pbeWithMD5AndCast5_CBC "pbeWithMD5AndCast5CBC" +-#define NID_pbeWithMD5AndCast5_CBC 112 +-#define OBJ_pbeWithMD5AndCast5_CBC OBJ_ISO_US,113533L,7L,66L,12L +- +-#define SN_id_PasswordBasedMAC "id-PasswordBasedMAC" +-#define LN_id_PasswordBasedMAC "password based MAC" +-#define NID_id_PasswordBasedMAC 782 +-#define OBJ_id_PasswordBasedMAC OBJ_ISO_US,113533L,7L,66L,13L +- +-#define SN_id_DHBasedMac "id-DHBasedMac" +-#define LN_id_DHBasedMac "Diffie-Hellman based MAC" +-#define NID_id_DHBasedMac 783 +-#define OBJ_id_DHBasedMac OBJ_ISO_US,113533L,7L,66L,30L +- +-#define SN_rsadsi "rsadsi" +-#define LN_rsadsi "RSA Data Security, Inc." +-#define NID_rsadsi 1 +-#define OBJ_rsadsi OBJ_ISO_US,113549L +- +-#define SN_pkcs "pkcs" +-#define LN_pkcs "RSA Data Security, Inc. PKCS" +-#define NID_pkcs 2 +-#define OBJ_pkcs OBJ_rsadsi,1L +- +-#define SN_pkcs1 "pkcs1" +-#define NID_pkcs1 186 +-#define OBJ_pkcs1 OBJ_pkcs,1L +- +-#define LN_rsaEncryption "rsaEncryption" +-#define NID_rsaEncryption 6 +-#define OBJ_rsaEncryption OBJ_pkcs1,1L +- +-#define SN_md2WithRSAEncryption "RSA-MD2" +-#define LN_md2WithRSAEncryption "md2WithRSAEncryption" +-#define NID_md2WithRSAEncryption 7 +-#define OBJ_md2WithRSAEncryption OBJ_pkcs1,2L +- +-#define SN_md4WithRSAEncryption "RSA-MD4" +-#define LN_md4WithRSAEncryption "md4WithRSAEncryption" +-#define NID_md4WithRSAEncryption 396 +-#define OBJ_md4WithRSAEncryption OBJ_pkcs1,3L +- +-#define SN_md5WithRSAEncryption "RSA-MD5" +-#define LN_md5WithRSAEncryption "md5WithRSAEncryption" +-#define NID_md5WithRSAEncryption 8 +-#define OBJ_md5WithRSAEncryption OBJ_pkcs1,4L +- +-#define SN_sha1WithRSAEncryption "RSA-SHA1" +-#define LN_sha1WithRSAEncryption "sha1WithRSAEncryption" +-#define NID_sha1WithRSAEncryption 65 +-#define OBJ_sha1WithRSAEncryption OBJ_pkcs1,5L +- +-#define SN_rsaesOaep "RSAES-OAEP" +-#define LN_rsaesOaep "rsaesOaep" +-#define NID_rsaesOaep 919 +-#define OBJ_rsaesOaep OBJ_pkcs1,7L +- +-#define SN_mgf1 "MGF1" +-#define LN_mgf1 "mgf1" +-#define NID_mgf1 911 +-#define OBJ_mgf1 OBJ_pkcs1,8L +- +-#define SN_pSpecified "PSPECIFIED" +-#define LN_pSpecified "pSpecified" +-#define NID_pSpecified 935 +-#define OBJ_pSpecified OBJ_pkcs1,9L +- +-#define SN_rsassaPss "RSASSA-PSS" +-#define LN_rsassaPss "rsassaPss" +-#define NID_rsassaPss 912 +-#define OBJ_rsassaPss OBJ_pkcs1,10L +- +-#define SN_sha256WithRSAEncryption "RSA-SHA256" +-#define LN_sha256WithRSAEncryption "sha256WithRSAEncryption" +-#define NID_sha256WithRSAEncryption 668 +-#define OBJ_sha256WithRSAEncryption OBJ_pkcs1,11L +- +-#define SN_sha384WithRSAEncryption "RSA-SHA384" +-#define LN_sha384WithRSAEncryption "sha384WithRSAEncryption" +-#define NID_sha384WithRSAEncryption 669 +-#define OBJ_sha384WithRSAEncryption OBJ_pkcs1,12L +- +-#define SN_sha512WithRSAEncryption "RSA-SHA512" +-#define LN_sha512WithRSAEncryption "sha512WithRSAEncryption" +-#define NID_sha512WithRSAEncryption 670 +-#define OBJ_sha512WithRSAEncryption OBJ_pkcs1,13L +- +-#define SN_sha224WithRSAEncryption "RSA-SHA224" +-#define LN_sha224WithRSAEncryption "sha224WithRSAEncryption" +-#define NID_sha224WithRSAEncryption 671 +-#define OBJ_sha224WithRSAEncryption OBJ_pkcs1,14L +- +-#define SN_sha512_224WithRSAEncryption "RSA-SHA512/224" +-#define LN_sha512_224WithRSAEncryption "sha512-224WithRSAEncryption" +-#define NID_sha512_224WithRSAEncryption 1145 +-#define OBJ_sha512_224WithRSAEncryption OBJ_pkcs1,15L +- +-#define SN_sha512_256WithRSAEncryption "RSA-SHA512/256" +-#define LN_sha512_256WithRSAEncryption "sha512-256WithRSAEncryption" +-#define NID_sha512_256WithRSAEncryption 1146 +-#define OBJ_sha512_256WithRSAEncryption OBJ_pkcs1,16L +- +-#define SN_pkcs3 "pkcs3" +-#define NID_pkcs3 27 +-#define OBJ_pkcs3 OBJ_pkcs,3L +- +-#define LN_dhKeyAgreement "dhKeyAgreement" +-#define NID_dhKeyAgreement 28 +-#define OBJ_dhKeyAgreement OBJ_pkcs3,1L +- +-#define SN_pkcs5 "pkcs5" +-#define NID_pkcs5 187 +-#define OBJ_pkcs5 OBJ_pkcs,5L +- +-#define SN_pbeWithMD2AndDES_CBC "PBE-MD2-DES" +-#define LN_pbeWithMD2AndDES_CBC "pbeWithMD2AndDES-CBC" +-#define NID_pbeWithMD2AndDES_CBC 9 +-#define OBJ_pbeWithMD2AndDES_CBC OBJ_pkcs5,1L +- +-#define SN_pbeWithMD5AndDES_CBC "PBE-MD5-DES" +-#define LN_pbeWithMD5AndDES_CBC "pbeWithMD5AndDES-CBC" +-#define NID_pbeWithMD5AndDES_CBC 10 +-#define OBJ_pbeWithMD5AndDES_CBC OBJ_pkcs5,3L +- +-#define SN_pbeWithMD2AndRC2_CBC "PBE-MD2-RC2-64" +-#define LN_pbeWithMD2AndRC2_CBC "pbeWithMD2AndRC2-CBC" +-#define NID_pbeWithMD2AndRC2_CBC 168 +-#define OBJ_pbeWithMD2AndRC2_CBC OBJ_pkcs5,4L +- +-#define SN_pbeWithMD5AndRC2_CBC "PBE-MD5-RC2-64" +-#define LN_pbeWithMD5AndRC2_CBC "pbeWithMD5AndRC2-CBC" +-#define NID_pbeWithMD5AndRC2_CBC 169 +-#define OBJ_pbeWithMD5AndRC2_CBC OBJ_pkcs5,6L +- +-#define SN_pbeWithSHA1AndDES_CBC "PBE-SHA1-DES" +-#define LN_pbeWithSHA1AndDES_CBC "pbeWithSHA1AndDES-CBC" +-#define NID_pbeWithSHA1AndDES_CBC 170 +-#define OBJ_pbeWithSHA1AndDES_CBC OBJ_pkcs5,10L +- +-#define SN_pbeWithSHA1AndRC2_CBC "PBE-SHA1-RC2-64" +-#define LN_pbeWithSHA1AndRC2_CBC "pbeWithSHA1AndRC2-CBC" +-#define NID_pbeWithSHA1AndRC2_CBC 68 +-#define OBJ_pbeWithSHA1AndRC2_CBC OBJ_pkcs5,11L +- +-#define LN_id_pbkdf2 "PBKDF2" +-#define NID_id_pbkdf2 69 +-#define OBJ_id_pbkdf2 OBJ_pkcs5,12L +- +-#define LN_pbes2 "PBES2" +-#define NID_pbes2 161 +-#define OBJ_pbes2 OBJ_pkcs5,13L +- +-#define LN_pbmac1 "PBMAC1" +-#define NID_pbmac1 162 +-#define OBJ_pbmac1 OBJ_pkcs5,14L +- +-#define SN_pkcs7 "pkcs7" +-#define NID_pkcs7 20 +-#define OBJ_pkcs7 OBJ_pkcs,7L +- +-#define LN_pkcs7_data "pkcs7-data" +-#define NID_pkcs7_data 21 +-#define OBJ_pkcs7_data OBJ_pkcs7,1L +- +-#define LN_pkcs7_signed "pkcs7-signedData" +-#define NID_pkcs7_signed 22 +-#define OBJ_pkcs7_signed OBJ_pkcs7,2L +- +-#define LN_pkcs7_enveloped "pkcs7-envelopedData" +-#define NID_pkcs7_enveloped 23 +-#define OBJ_pkcs7_enveloped OBJ_pkcs7,3L +- +-#define LN_pkcs7_signedAndEnveloped "pkcs7-signedAndEnvelopedData" +-#define NID_pkcs7_signedAndEnveloped 24 +-#define OBJ_pkcs7_signedAndEnveloped OBJ_pkcs7,4L +- +-#define LN_pkcs7_digest "pkcs7-digestData" +-#define NID_pkcs7_digest 25 +-#define OBJ_pkcs7_digest OBJ_pkcs7,5L +- +-#define LN_pkcs7_encrypted "pkcs7-encryptedData" +-#define NID_pkcs7_encrypted 26 +-#define OBJ_pkcs7_encrypted OBJ_pkcs7,6L +- +-#define SN_pkcs9 "pkcs9" +-#define NID_pkcs9 47 +-#define OBJ_pkcs9 OBJ_pkcs,9L +- +-#define LN_pkcs9_emailAddress "emailAddress" +-#define NID_pkcs9_emailAddress 48 +-#define OBJ_pkcs9_emailAddress OBJ_pkcs9,1L +- +-#define LN_pkcs9_unstructuredName "unstructuredName" +-#define NID_pkcs9_unstructuredName 49 +-#define OBJ_pkcs9_unstructuredName OBJ_pkcs9,2L +- +-#define LN_pkcs9_contentType "contentType" +-#define NID_pkcs9_contentType 50 +-#define OBJ_pkcs9_contentType OBJ_pkcs9,3L +- +-#define LN_pkcs9_messageDigest "messageDigest" +-#define NID_pkcs9_messageDigest 51 +-#define OBJ_pkcs9_messageDigest OBJ_pkcs9,4L +- +-#define LN_pkcs9_signingTime "signingTime" +-#define NID_pkcs9_signingTime 52 +-#define OBJ_pkcs9_signingTime OBJ_pkcs9,5L +- +-#define LN_pkcs9_countersignature "countersignature" +-#define NID_pkcs9_countersignature 53 +-#define OBJ_pkcs9_countersignature OBJ_pkcs9,6L +- +-#define LN_pkcs9_challengePassword "challengePassword" +-#define NID_pkcs9_challengePassword 54 +-#define OBJ_pkcs9_challengePassword OBJ_pkcs9,7L +- +-#define LN_pkcs9_unstructuredAddress "unstructuredAddress" +-#define NID_pkcs9_unstructuredAddress 55 +-#define OBJ_pkcs9_unstructuredAddress OBJ_pkcs9,8L +- +-#define LN_pkcs9_extCertAttributes "extendedCertificateAttributes" +-#define NID_pkcs9_extCertAttributes 56 +-#define OBJ_pkcs9_extCertAttributes OBJ_pkcs9,9L +- +-#define SN_ext_req "extReq" +-#define LN_ext_req "Extension Request" +-#define NID_ext_req 172 +-#define OBJ_ext_req OBJ_pkcs9,14L +- +-#define SN_SMIMECapabilities "SMIME-CAPS" +-#define LN_SMIMECapabilities "S/MIME Capabilities" +-#define NID_SMIMECapabilities 167 +-#define OBJ_SMIMECapabilities OBJ_pkcs9,15L +- +-#define SN_SMIME "SMIME" +-#define LN_SMIME "S/MIME" +-#define NID_SMIME 188 +-#define OBJ_SMIME OBJ_pkcs9,16L +- +-#define SN_id_smime_mod "id-smime-mod" +-#define NID_id_smime_mod 189 +-#define OBJ_id_smime_mod OBJ_SMIME,0L +- +-#define SN_id_smime_ct "id-smime-ct" +-#define NID_id_smime_ct 190 +-#define OBJ_id_smime_ct OBJ_SMIME,1L +- +-#define SN_id_smime_aa "id-smime-aa" +-#define NID_id_smime_aa 191 +-#define OBJ_id_smime_aa OBJ_SMIME,2L +- +-#define SN_id_smime_alg "id-smime-alg" +-#define NID_id_smime_alg 192 +-#define OBJ_id_smime_alg OBJ_SMIME,3L +- +-#define SN_id_smime_cd "id-smime-cd" +-#define NID_id_smime_cd 193 +-#define OBJ_id_smime_cd OBJ_SMIME,4L +- +-#define SN_id_smime_spq "id-smime-spq" +-#define NID_id_smime_spq 194 +-#define OBJ_id_smime_spq OBJ_SMIME,5L +- +-#define SN_id_smime_cti "id-smime-cti" +-#define NID_id_smime_cti 195 +-#define OBJ_id_smime_cti OBJ_SMIME,6L +- +-#define SN_id_smime_mod_cms "id-smime-mod-cms" +-#define NID_id_smime_mod_cms 196 +-#define OBJ_id_smime_mod_cms OBJ_id_smime_mod,1L +- +-#define SN_id_smime_mod_ess "id-smime-mod-ess" +-#define NID_id_smime_mod_ess 197 +-#define OBJ_id_smime_mod_ess OBJ_id_smime_mod,2L +- +-#define SN_id_smime_mod_oid "id-smime-mod-oid" +-#define NID_id_smime_mod_oid 198 +-#define OBJ_id_smime_mod_oid OBJ_id_smime_mod,3L +- +-#define SN_id_smime_mod_msg_v3 "id-smime-mod-msg-v3" +-#define NID_id_smime_mod_msg_v3 199 +-#define OBJ_id_smime_mod_msg_v3 OBJ_id_smime_mod,4L +- +-#define SN_id_smime_mod_ets_eSignature_88 "id-smime-mod-ets-eSignature-88" +-#define NID_id_smime_mod_ets_eSignature_88 200 +-#define OBJ_id_smime_mod_ets_eSignature_88 OBJ_id_smime_mod,5L +- +-#define SN_id_smime_mod_ets_eSignature_97 "id-smime-mod-ets-eSignature-97" +-#define NID_id_smime_mod_ets_eSignature_97 201 +-#define OBJ_id_smime_mod_ets_eSignature_97 OBJ_id_smime_mod,6L +- +-#define SN_id_smime_mod_ets_eSigPolicy_88 "id-smime-mod-ets-eSigPolicy-88" +-#define NID_id_smime_mod_ets_eSigPolicy_88 202 +-#define OBJ_id_smime_mod_ets_eSigPolicy_88 OBJ_id_smime_mod,7L +- +-#define SN_id_smime_mod_ets_eSigPolicy_97 "id-smime-mod-ets-eSigPolicy-97" +-#define NID_id_smime_mod_ets_eSigPolicy_97 203 +-#define OBJ_id_smime_mod_ets_eSigPolicy_97 OBJ_id_smime_mod,8L +- +-#define SN_id_smime_ct_receipt "id-smime-ct-receipt" +-#define NID_id_smime_ct_receipt 204 +-#define OBJ_id_smime_ct_receipt OBJ_id_smime_ct,1L +- +-#define SN_id_smime_ct_authData "id-smime-ct-authData" +-#define NID_id_smime_ct_authData 205 +-#define OBJ_id_smime_ct_authData OBJ_id_smime_ct,2L +- +-#define SN_id_smime_ct_publishCert "id-smime-ct-publishCert" +-#define NID_id_smime_ct_publishCert 206 +-#define OBJ_id_smime_ct_publishCert OBJ_id_smime_ct,3L +- +-#define SN_id_smime_ct_TSTInfo "id-smime-ct-TSTInfo" +-#define NID_id_smime_ct_TSTInfo 207 +-#define OBJ_id_smime_ct_TSTInfo OBJ_id_smime_ct,4L +- +-#define SN_id_smime_ct_TDTInfo "id-smime-ct-TDTInfo" +-#define NID_id_smime_ct_TDTInfo 208 +-#define OBJ_id_smime_ct_TDTInfo OBJ_id_smime_ct,5L +- +-#define SN_id_smime_ct_contentInfo "id-smime-ct-contentInfo" +-#define NID_id_smime_ct_contentInfo 209 +-#define OBJ_id_smime_ct_contentInfo OBJ_id_smime_ct,6L +- +-#define SN_id_smime_ct_DVCSRequestData "id-smime-ct-DVCSRequestData" +-#define NID_id_smime_ct_DVCSRequestData 210 +-#define OBJ_id_smime_ct_DVCSRequestData OBJ_id_smime_ct,7L +- +-#define SN_id_smime_ct_DVCSResponseData "id-smime-ct-DVCSResponseData" +-#define NID_id_smime_ct_DVCSResponseData 211 +-#define OBJ_id_smime_ct_DVCSResponseData OBJ_id_smime_ct,8L +- +-#define SN_id_smime_ct_compressedData "id-smime-ct-compressedData" +-#define NID_id_smime_ct_compressedData 786 +-#define OBJ_id_smime_ct_compressedData OBJ_id_smime_ct,9L +- +-#define SN_id_smime_ct_contentCollection "id-smime-ct-contentCollection" +-#define NID_id_smime_ct_contentCollection 1058 +-#define OBJ_id_smime_ct_contentCollection OBJ_id_smime_ct,19L +- +-#define SN_id_smime_ct_authEnvelopedData "id-smime-ct-authEnvelopedData" +-#define NID_id_smime_ct_authEnvelopedData 1059 +-#define OBJ_id_smime_ct_authEnvelopedData OBJ_id_smime_ct,23L +- +-#define SN_id_ct_asciiTextWithCRLF "id-ct-asciiTextWithCRLF" +-#define NID_id_ct_asciiTextWithCRLF 787 +-#define OBJ_id_ct_asciiTextWithCRLF OBJ_id_smime_ct,27L +- +-#define SN_id_ct_xml "id-ct-xml" +-#define NID_id_ct_xml 1060 +-#define OBJ_id_ct_xml OBJ_id_smime_ct,28L +- +-#define SN_id_smime_aa_receiptRequest "id-smime-aa-receiptRequest" +-#define NID_id_smime_aa_receiptRequest 212 +-#define OBJ_id_smime_aa_receiptRequest OBJ_id_smime_aa,1L +- +-#define SN_id_smime_aa_securityLabel "id-smime-aa-securityLabel" +-#define NID_id_smime_aa_securityLabel 213 +-#define OBJ_id_smime_aa_securityLabel OBJ_id_smime_aa,2L +- +-#define SN_id_smime_aa_mlExpandHistory "id-smime-aa-mlExpandHistory" +-#define NID_id_smime_aa_mlExpandHistory 214 +-#define OBJ_id_smime_aa_mlExpandHistory OBJ_id_smime_aa,3L +- +-#define SN_id_smime_aa_contentHint "id-smime-aa-contentHint" +-#define NID_id_smime_aa_contentHint 215 +-#define OBJ_id_smime_aa_contentHint OBJ_id_smime_aa,4L +- +-#define SN_id_smime_aa_msgSigDigest "id-smime-aa-msgSigDigest" +-#define NID_id_smime_aa_msgSigDigest 216 +-#define OBJ_id_smime_aa_msgSigDigest OBJ_id_smime_aa,5L +- +-#define SN_id_smime_aa_encapContentType "id-smime-aa-encapContentType" +-#define NID_id_smime_aa_encapContentType 217 +-#define OBJ_id_smime_aa_encapContentType OBJ_id_smime_aa,6L +- +-#define SN_id_smime_aa_contentIdentifier "id-smime-aa-contentIdentifier" +-#define NID_id_smime_aa_contentIdentifier 218 +-#define OBJ_id_smime_aa_contentIdentifier OBJ_id_smime_aa,7L +- +-#define SN_id_smime_aa_macValue "id-smime-aa-macValue" +-#define NID_id_smime_aa_macValue 219 +-#define OBJ_id_smime_aa_macValue OBJ_id_smime_aa,8L +- +-#define SN_id_smime_aa_equivalentLabels "id-smime-aa-equivalentLabels" +-#define NID_id_smime_aa_equivalentLabels 220 +-#define OBJ_id_smime_aa_equivalentLabels OBJ_id_smime_aa,9L +- +-#define SN_id_smime_aa_contentReference "id-smime-aa-contentReference" +-#define NID_id_smime_aa_contentReference 221 +-#define OBJ_id_smime_aa_contentReference OBJ_id_smime_aa,10L +- +-#define SN_id_smime_aa_encrypKeyPref "id-smime-aa-encrypKeyPref" +-#define NID_id_smime_aa_encrypKeyPref 222 +-#define OBJ_id_smime_aa_encrypKeyPref OBJ_id_smime_aa,11L +- +-#define SN_id_smime_aa_signingCertificate "id-smime-aa-signingCertificate" +-#define NID_id_smime_aa_signingCertificate 223 +-#define OBJ_id_smime_aa_signingCertificate OBJ_id_smime_aa,12L +- +-#define SN_id_smime_aa_smimeEncryptCerts "id-smime-aa-smimeEncryptCerts" +-#define NID_id_smime_aa_smimeEncryptCerts 224 +-#define OBJ_id_smime_aa_smimeEncryptCerts OBJ_id_smime_aa,13L +- +-#define SN_id_smime_aa_timeStampToken "id-smime-aa-timeStampToken" +-#define NID_id_smime_aa_timeStampToken 225 +-#define OBJ_id_smime_aa_timeStampToken OBJ_id_smime_aa,14L +- +-#define SN_id_smime_aa_ets_sigPolicyId "id-smime-aa-ets-sigPolicyId" +-#define NID_id_smime_aa_ets_sigPolicyId 226 +-#define OBJ_id_smime_aa_ets_sigPolicyId OBJ_id_smime_aa,15L +- +-#define SN_id_smime_aa_ets_commitmentType "id-smime-aa-ets-commitmentType" +-#define NID_id_smime_aa_ets_commitmentType 227 +-#define OBJ_id_smime_aa_ets_commitmentType OBJ_id_smime_aa,16L +- +-#define SN_id_smime_aa_ets_signerLocation "id-smime-aa-ets-signerLocation" +-#define NID_id_smime_aa_ets_signerLocation 228 +-#define OBJ_id_smime_aa_ets_signerLocation OBJ_id_smime_aa,17L +- +-#define SN_id_smime_aa_ets_signerAttr "id-smime-aa-ets-signerAttr" +-#define NID_id_smime_aa_ets_signerAttr 229 +-#define OBJ_id_smime_aa_ets_signerAttr OBJ_id_smime_aa,18L +- +-#define SN_id_smime_aa_ets_otherSigCert "id-smime-aa-ets-otherSigCert" +-#define NID_id_smime_aa_ets_otherSigCert 230 +-#define OBJ_id_smime_aa_ets_otherSigCert OBJ_id_smime_aa,19L +- +-#define SN_id_smime_aa_ets_contentTimestamp "id-smime-aa-ets-contentTimestamp" +-#define NID_id_smime_aa_ets_contentTimestamp 231 +-#define OBJ_id_smime_aa_ets_contentTimestamp OBJ_id_smime_aa,20L +- +-#define SN_id_smime_aa_ets_CertificateRefs "id-smime-aa-ets-CertificateRefs" +-#define NID_id_smime_aa_ets_CertificateRefs 232 +-#define OBJ_id_smime_aa_ets_CertificateRefs OBJ_id_smime_aa,21L +- +-#define SN_id_smime_aa_ets_RevocationRefs "id-smime-aa-ets-RevocationRefs" +-#define NID_id_smime_aa_ets_RevocationRefs 233 +-#define OBJ_id_smime_aa_ets_RevocationRefs OBJ_id_smime_aa,22L +- +-#define SN_id_smime_aa_ets_certValues "id-smime-aa-ets-certValues" +-#define NID_id_smime_aa_ets_certValues 234 +-#define OBJ_id_smime_aa_ets_certValues OBJ_id_smime_aa,23L +- +-#define SN_id_smime_aa_ets_revocationValues "id-smime-aa-ets-revocationValues" +-#define NID_id_smime_aa_ets_revocationValues 235 +-#define OBJ_id_smime_aa_ets_revocationValues OBJ_id_smime_aa,24L +- +-#define SN_id_smime_aa_ets_escTimeStamp "id-smime-aa-ets-escTimeStamp" +-#define NID_id_smime_aa_ets_escTimeStamp 236 +-#define OBJ_id_smime_aa_ets_escTimeStamp OBJ_id_smime_aa,25L +- +-#define SN_id_smime_aa_ets_certCRLTimestamp "id-smime-aa-ets-certCRLTimestamp" +-#define NID_id_smime_aa_ets_certCRLTimestamp 237 +-#define OBJ_id_smime_aa_ets_certCRLTimestamp OBJ_id_smime_aa,26L +- +-#define SN_id_smime_aa_ets_archiveTimeStamp "id-smime-aa-ets-archiveTimeStamp" +-#define NID_id_smime_aa_ets_archiveTimeStamp 238 +-#define OBJ_id_smime_aa_ets_archiveTimeStamp OBJ_id_smime_aa,27L +- +-#define SN_id_smime_aa_signatureType "id-smime-aa-signatureType" +-#define NID_id_smime_aa_signatureType 239 +-#define OBJ_id_smime_aa_signatureType OBJ_id_smime_aa,28L +- +-#define SN_id_smime_aa_dvcs_dvc "id-smime-aa-dvcs-dvc" +-#define NID_id_smime_aa_dvcs_dvc 240 +-#define OBJ_id_smime_aa_dvcs_dvc OBJ_id_smime_aa,29L +- +-#define SN_id_smime_aa_signingCertificateV2 "id-smime-aa-signingCertificateV2" +-#define NID_id_smime_aa_signingCertificateV2 1086 +-#define OBJ_id_smime_aa_signingCertificateV2 OBJ_id_smime_aa,47L +- +-#define SN_id_smime_alg_ESDHwith3DES "id-smime-alg-ESDHwith3DES" +-#define NID_id_smime_alg_ESDHwith3DES 241 +-#define OBJ_id_smime_alg_ESDHwith3DES OBJ_id_smime_alg,1L +- +-#define SN_id_smime_alg_ESDHwithRC2 "id-smime-alg-ESDHwithRC2" +-#define NID_id_smime_alg_ESDHwithRC2 242 +-#define OBJ_id_smime_alg_ESDHwithRC2 OBJ_id_smime_alg,2L +- +-#define SN_id_smime_alg_3DESwrap "id-smime-alg-3DESwrap" +-#define NID_id_smime_alg_3DESwrap 243 +-#define OBJ_id_smime_alg_3DESwrap OBJ_id_smime_alg,3L +- +-#define SN_id_smime_alg_RC2wrap "id-smime-alg-RC2wrap" +-#define NID_id_smime_alg_RC2wrap 244 +-#define OBJ_id_smime_alg_RC2wrap OBJ_id_smime_alg,4L +- +-#define SN_id_smime_alg_ESDH "id-smime-alg-ESDH" +-#define NID_id_smime_alg_ESDH 245 +-#define OBJ_id_smime_alg_ESDH OBJ_id_smime_alg,5L +- +-#define SN_id_smime_alg_CMS3DESwrap "id-smime-alg-CMS3DESwrap" +-#define NID_id_smime_alg_CMS3DESwrap 246 +-#define OBJ_id_smime_alg_CMS3DESwrap OBJ_id_smime_alg,6L +- +-#define SN_id_smime_alg_CMSRC2wrap "id-smime-alg-CMSRC2wrap" +-#define NID_id_smime_alg_CMSRC2wrap 247 +-#define OBJ_id_smime_alg_CMSRC2wrap OBJ_id_smime_alg,7L +- +-#define SN_id_alg_PWRI_KEK "id-alg-PWRI-KEK" +-#define NID_id_alg_PWRI_KEK 893 +-#define OBJ_id_alg_PWRI_KEK OBJ_id_smime_alg,9L +- +-#define SN_id_smime_cd_ldap "id-smime-cd-ldap" +-#define NID_id_smime_cd_ldap 248 +-#define OBJ_id_smime_cd_ldap OBJ_id_smime_cd,1L +- +-#define SN_id_smime_spq_ets_sqt_uri "id-smime-spq-ets-sqt-uri" +-#define NID_id_smime_spq_ets_sqt_uri 249 +-#define OBJ_id_smime_spq_ets_sqt_uri OBJ_id_smime_spq,1L +- +-#define SN_id_smime_spq_ets_sqt_unotice "id-smime-spq-ets-sqt-unotice" +-#define NID_id_smime_spq_ets_sqt_unotice 250 +-#define OBJ_id_smime_spq_ets_sqt_unotice OBJ_id_smime_spq,2L +- +-#define SN_id_smime_cti_ets_proofOfOrigin "id-smime-cti-ets-proofOfOrigin" +-#define NID_id_smime_cti_ets_proofOfOrigin 251 +-#define OBJ_id_smime_cti_ets_proofOfOrigin OBJ_id_smime_cti,1L +- +-#define SN_id_smime_cti_ets_proofOfReceipt "id-smime-cti-ets-proofOfReceipt" +-#define NID_id_smime_cti_ets_proofOfReceipt 252 +-#define OBJ_id_smime_cti_ets_proofOfReceipt OBJ_id_smime_cti,2L +- +-#define SN_id_smime_cti_ets_proofOfDelivery "id-smime-cti-ets-proofOfDelivery" +-#define NID_id_smime_cti_ets_proofOfDelivery 253 +-#define OBJ_id_smime_cti_ets_proofOfDelivery OBJ_id_smime_cti,3L +- +-#define SN_id_smime_cti_ets_proofOfSender "id-smime-cti-ets-proofOfSender" +-#define NID_id_smime_cti_ets_proofOfSender 254 +-#define OBJ_id_smime_cti_ets_proofOfSender OBJ_id_smime_cti,4L +- +-#define SN_id_smime_cti_ets_proofOfApproval "id-smime-cti-ets-proofOfApproval" +-#define NID_id_smime_cti_ets_proofOfApproval 255 +-#define OBJ_id_smime_cti_ets_proofOfApproval OBJ_id_smime_cti,5L +- +-#define SN_id_smime_cti_ets_proofOfCreation "id-smime-cti-ets-proofOfCreation" +-#define NID_id_smime_cti_ets_proofOfCreation 256 +-#define OBJ_id_smime_cti_ets_proofOfCreation OBJ_id_smime_cti,6L +- +-#define LN_friendlyName "friendlyName" +-#define NID_friendlyName 156 +-#define OBJ_friendlyName OBJ_pkcs9,20L +- +-#define LN_localKeyID "localKeyID" +-#define NID_localKeyID 157 +-#define OBJ_localKeyID OBJ_pkcs9,21L +- +-#define SN_ms_csp_name "CSPName" +-#define LN_ms_csp_name "Microsoft CSP Name" +-#define NID_ms_csp_name 417 +-#define OBJ_ms_csp_name 1L,3L,6L,1L,4L,1L,311L,17L,1L +- +-#define SN_LocalKeySet "LocalKeySet" +-#define LN_LocalKeySet "Microsoft Local Key set" +-#define NID_LocalKeySet 856 +-#define OBJ_LocalKeySet 1L,3L,6L,1L,4L,1L,311L,17L,2L +- +-#define OBJ_certTypes OBJ_pkcs9,22L +- +-#define LN_x509Certificate "x509Certificate" +-#define NID_x509Certificate 158 +-#define OBJ_x509Certificate OBJ_certTypes,1L +- +-#define LN_sdsiCertificate "sdsiCertificate" +-#define NID_sdsiCertificate 159 +-#define OBJ_sdsiCertificate OBJ_certTypes,2L +- +-#define OBJ_crlTypes OBJ_pkcs9,23L +- +-#define LN_x509Crl "x509Crl" +-#define NID_x509Crl 160 +-#define OBJ_x509Crl OBJ_crlTypes,1L +- +-#define OBJ_pkcs12 OBJ_pkcs,12L +- +-#define OBJ_pkcs12_pbeids OBJ_pkcs12,1L +- +-#define SN_pbe_WithSHA1And128BitRC4 "PBE-SHA1-RC4-128" +-#define LN_pbe_WithSHA1And128BitRC4 "pbeWithSHA1And128BitRC4" +-#define NID_pbe_WithSHA1And128BitRC4 144 +-#define OBJ_pbe_WithSHA1And128BitRC4 OBJ_pkcs12_pbeids,1L +- +-#define SN_pbe_WithSHA1And40BitRC4 "PBE-SHA1-RC4-40" +-#define LN_pbe_WithSHA1And40BitRC4 "pbeWithSHA1And40BitRC4" +-#define NID_pbe_WithSHA1And40BitRC4 145 +-#define OBJ_pbe_WithSHA1And40BitRC4 OBJ_pkcs12_pbeids,2L +- +-#define SN_pbe_WithSHA1And3_Key_TripleDES_CBC "PBE-SHA1-3DES" +-#define LN_pbe_WithSHA1And3_Key_TripleDES_CBC "pbeWithSHA1And3-KeyTripleDES-CBC" +-#define NID_pbe_WithSHA1And3_Key_TripleDES_CBC 146 +-#define OBJ_pbe_WithSHA1And3_Key_TripleDES_CBC OBJ_pkcs12_pbeids,3L +- +-#define SN_pbe_WithSHA1And2_Key_TripleDES_CBC "PBE-SHA1-2DES" +-#define LN_pbe_WithSHA1And2_Key_TripleDES_CBC "pbeWithSHA1And2-KeyTripleDES-CBC" +-#define NID_pbe_WithSHA1And2_Key_TripleDES_CBC 147 +-#define OBJ_pbe_WithSHA1And2_Key_TripleDES_CBC OBJ_pkcs12_pbeids,4L +- +-#define SN_pbe_WithSHA1And128BitRC2_CBC "PBE-SHA1-RC2-128" +-#define LN_pbe_WithSHA1And128BitRC2_CBC "pbeWithSHA1And128BitRC2-CBC" +-#define NID_pbe_WithSHA1And128BitRC2_CBC 148 +-#define OBJ_pbe_WithSHA1And128BitRC2_CBC OBJ_pkcs12_pbeids,5L +- +-#define SN_pbe_WithSHA1And40BitRC2_CBC "PBE-SHA1-RC2-40" +-#define LN_pbe_WithSHA1And40BitRC2_CBC "pbeWithSHA1And40BitRC2-CBC" +-#define NID_pbe_WithSHA1And40BitRC2_CBC 149 +-#define OBJ_pbe_WithSHA1And40BitRC2_CBC OBJ_pkcs12_pbeids,6L +- +-#define OBJ_pkcs12_Version1 OBJ_pkcs12,10L +- +-#define OBJ_pkcs12_BagIds OBJ_pkcs12_Version1,1L +- +-#define LN_keyBag "keyBag" +-#define NID_keyBag 150 +-#define OBJ_keyBag OBJ_pkcs12_BagIds,1L +- +-#define LN_pkcs8ShroudedKeyBag "pkcs8ShroudedKeyBag" +-#define NID_pkcs8ShroudedKeyBag 151 +-#define OBJ_pkcs8ShroudedKeyBag OBJ_pkcs12_BagIds,2L +- +-#define LN_certBag "certBag" +-#define NID_certBag 152 +-#define OBJ_certBag OBJ_pkcs12_BagIds,3L +- +-#define LN_crlBag "crlBag" +-#define NID_crlBag 153 +-#define OBJ_crlBag OBJ_pkcs12_BagIds,4L +- +-#define LN_secretBag "secretBag" +-#define NID_secretBag 154 +-#define OBJ_secretBag OBJ_pkcs12_BagIds,5L +- +-#define LN_safeContentsBag "safeContentsBag" +-#define NID_safeContentsBag 155 +-#define OBJ_safeContentsBag OBJ_pkcs12_BagIds,6L +- +-#define SN_md2 "MD2" +-#define LN_md2 "md2" +-#define NID_md2 3 +-#define OBJ_md2 OBJ_rsadsi,2L,2L +- +-#define SN_md4 "MD4" +-#define LN_md4 "md4" +-#define NID_md4 257 +-#define OBJ_md4 OBJ_rsadsi,2L,4L +- +-#define SN_md5 "MD5" +-#define LN_md5 "md5" +-#define NID_md5 4 +-#define OBJ_md5 OBJ_rsadsi,2L,5L +- +-#define SN_md5_sha1 "MD5-SHA1" +-#define LN_md5_sha1 "md5-sha1" +-#define NID_md5_sha1 114 +- +-#define LN_hmacWithMD5 "hmacWithMD5" +-#define NID_hmacWithMD5 797 +-#define OBJ_hmacWithMD5 OBJ_rsadsi,2L,6L +- +-#define LN_hmacWithSHA1 "hmacWithSHA1" +-#define NID_hmacWithSHA1 163 +-#define OBJ_hmacWithSHA1 OBJ_rsadsi,2L,7L +- +-#define SN_sm2 "SM2" +-#define LN_sm2 "sm2" +-#define NID_sm2 1172 +-#define OBJ_sm2 OBJ_sm_scheme,301L +- +-#define SN_sm3 "SM3" +-#define LN_sm3 "sm3" +-#define NID_sm3 1143 +-#define OBJ_sm3 OBJ_sm_scheme,401L +- +-#define SN_sm3WithRSAEncryption "RSA-SM3" +-#define LN_sm3WithRSAEncryption "sm3WithRSAEncryption" +-#define NID_sm3WithRSAEncryption 1144 +-#define OBJ_sm3WithRSAEncryption OBJ_sm_scheme,504L +- +-#define LN_hmacWithSHA224 "hmacWithSHA224" +-#define NID_hmacWithSHA224 798 +-#define OBJ_hmacWithSHA224 OBJ_rsadsi,2L,8L +- +-#define LN_hmacWithSHA256 "hmacWithSHA256" +-#define NID_hmacWithSHA256 799 +-#define OBJ_hmacWithSHA256 OBJ_rsadsi,2L,9L +- +-#define LN_hmacWithSHA384 "hmacWithSHA384" +-#define NID_hmacWithSHA384 800 +-#define OBJ_hmacWithSHA384 OBJ_rsadsi,2L,10L +- +-#define LN_hmacWithSHA512 "hmacWithSHA512" +-#define NID_hmacWithSHA512 801 +-#define OBJ_hmacWithSHA512 OBJ_rsadsi,2L,11L +- +-#define LN_hmacWithSHA512_224 "hmacWithSHA512-224" +-#define NID_hmacWithSHA512_224 1193 +-#define OBJ_hmacWithSHA512_224 OBJ_rsadsi,2L,12L +- +-#define LN_hmacWithSHA512_256 "hmacWithSHA512-256" +-#define NID_hmacWithSHA512_256 1194 +-#define OBJ_hmacWithSHA512_256 OBJ_rsadsi,2L,13L +- +-#define SN_rc2_cbc "RC2-CBC" +-#define LN_rc2_cbc "rc2-cbc" +-#define NID_rc2_cbc 37 +-#define OBJ_rc2_cbc OBJ_rsadsi,3L,2L +- +-#define SN_rc2_ecb "RC2-ECB" +-#define LN_rc2_ecb "rc2-ecb" +-#define NID_rc2_ecb 38 +- +-#define SN_rc2_cfb64 "RC2-CFB" +-#define LN_rc2_cfb64 "rc2-cfb" +-#define NID_rc2_cfb64 39 +- +-#define SN_rc2_ofb64 "RC2-OFB" +-#define LN_rc2_ofb64 "rc2-ofb" +-#define NID_rc2_ofb64 40 +- +-#define SN_rc2_40_cbc "RC2-40-CBC" +-#define LN_rc2_40_cbc "rc2-40-cbc" +-#define NID_rc2_40_cbc 98 +- +-#define SN_rc2_64_cbc "RC2-64-CBC" +-#define LN_rc2_64_cbc "rc2-64-cbc" +-#define NID_rc2_64_cbc 166 +- +-#define SN_rc4 "RC4" +-#define LN_rc4 "rc4" +-#define NID_rc4 5 +-#define OBJ_rc4 OBJ_rsadsi,3L,4L +- +-#define SN_rc4_40 "RC4-40" +-#define LN_rc4_40 "rc4-40" +-#define NID_rc4_40 97 +- +-#define SN_des_ede3_cbc "DES-EDE3-CBC" +-#define LN_des_ede3_cbc "des-ede3-cbc" +-#define NID_des_ede3_cbc 44 +-#define OBJ_des_ede3_cbc OBJ_rsadsi,3L,7L +- +-#define SN_rc5_cbc "RC5-CBC" +-#define LN_rc5_cbc "rc5-cbc" +-#define NID_rc5_cbc 120 +-#define OBJ_rc5_cbc OBJ_rsadsi,3L,8L +- +-#define SN_rc5_ecb "RC5-ECB" +-#define LN_rc5_ecb "rc5-ecb" +-#define NID_rc5_ecb 121 +- +-#define SN_rc5_cfb64 "RC5-CFB" +-#define LN_rc5_cfb64 "rc5-cfb" +-#define NID_rc5_cfb64 122 +- +-#define SN_rc5_ofb64 "RC5-OFB" +-#define LN_rc5_ofb64 "rc5-ofb" +-#define NID_rc5_ofb64 123 +- +-#define SN_ms_ext_req "msExtReq" +-#define LN_ms_ext_req "Microsoft Extension Request" +-#define NID_ms_ext_req 171 +-#define OBJ_ms_ext_req 1L,3L,6L,1L,4L,1L,311L,2L,1L,14L +- +-#define SN_ms_code_ind "msCodeInd" +-#define LN_ms_code_ind "Microsoft Individual Code Signing" +-#define NID_ms_code_ind 134 +-#define OBJ_ms_code_ind 1L,3L,6L,1L,4L,1L,311L,2L,1L,21L +- +-#define SN_ms_code_com "msCodeCom" +-#define LN_ms_code_com "Microsoft Commercial Code Signing" +-#define NID_ms_code_com 135 +-#define OBJ_ms_code_com 1L,3L,6L,1L,4L,1L,311L,2L,1L,22L +- +-#define SN_ms_ctl_sign "msCTLSign" +-#define LN_ms_ctl_sign "Microsoft Trust List Signing" +-#define NID_ms_ctl_sign 136 +-#define OBJ_ms_ctl_sign 1L,3L,6L,1L,4L,1L,311L,10L,3L,1L +- +-#define SN_ms_sgc "msSGC" +-#define LN_ms_sgc "Microsoft Server Gated Crypto" +-#define NID_ms_sgc 137 +-#define OBJ_ms_sgc 1L,3L,6L,1L,4L,1L,311L,10L,3L,3L +- +-#define SN_ms_efs "msEFS" +-#define LN_ms_efs "Microsoft Encrypted File System" +-#define NID_ms_efs 138 +-#define OBJ_ms_efs 1L,3L,6L,1L,4L,1L,311L,10L,3L,4L +- +-#define SN_ms_smartcard_login "msSmartcardLogin" +-#define LN_ms_smartcard_login "Microsoft Smartcard Login" +-#define NID_ms_smartcard_login 648 +-#define OBJ_ms_smartcard_login 1L,3L,6L,1L,4L,1L,311L,20L,2L,2L +- +-#define SN_ms_upn "msUPN" +-#define LN_ms_upn "Microsoft User Principal Name" +-#define NID_ms_upn 649 +-#define OBJ_ms_upn 1L,3L,6L,1L,4L,1L,311L,20L,2L,3L +- +-#define SN_idea_cbc "IDEA-CBC" +-#define LN_idea_cbc "idea-cbc" +-#define NID_idea_cbc 34 +-#define OBJ_idea_cbc 1L,3L,6L,1L,4L,1L,188L,7L,1L,1L,2L +- +-#define SN_idea_ecb "IDEA-ECB" +-#define LN_idea_ecb "idea-ecb" +-#define NID_idea_ecb 36 +- +-#define SN_idea_cfb64 "IDEA-CFB" +-#define LN_idea_cfb64 "idea-cfb" +-#define NID_idea_cfb64 35 +- +-#define SN_idea_ofb64 "IDEA-OFB" +-#define LN_idea_ofb64 "idea-ofb" +-#define NID_idea_ofb64 46 +- +-#define SN_bf_cbc "BF-CBC" +-#define LN_bf_cbc "bf-cbc" +-#define NID_bf_cbc 91 +-#define OBJ_bf_cbc 1L,3L,6L,1L,4L,1L,3029L,1L,2L +- +-#define SN_bf_ecb "BF-ECB" +-#define LN_bf_ecb "bf-ecb" +-#define NID_bf_ecb 92 +- +-#define SN_bf_cfb64 "BF-CFB" +-#define LN_bf_cfb64 "bf-cfb" +-#define NID_bf_cfb64 93 +- +-#define SN_bf_ofb64 "BF-OFB" +-#define LN_bf_ofb64 "bf-ofb" +-#define NID_bf_ofb64 94 +- +-#define SN_id_pkix "PKIX" +-#define NID_id_pkix 127 +-#define OBJ_id_pkix 1L,3L,6L,1L,5L,5L,7L +- +-#define SN_id_pkix_mod "id-pkix-mod" +-#define NID_id_pkix_mod 258 +-#define OBJ_id_pkix_mod OBJ_id_pkix,0L +- +-#define SN_id_pe "id-pe" +-#define NID_id_pe 175 +-#define OBJ_id_pe OBJ_id_pkix,1L +- +-#define SN_id_qt "id-qt" +-#define NID_id_qt 259 +-#define OBJ_id_qt OBJ_id_pkix,2L +- +-#define SN_id_kp "id-kp" +-#define NID_id_kp 128 +-#define OBJ_id_kp OBJ_id_pkix,3L +- +-#define SN_id_it "id-it" +-#define NID_id_it 260 +-#define OBJ_id_it OBJ_id_pkix,4L +- +-#define SN_id_pkip "id-pkip" +-#define NID_id_pkip 261 +-#define OBJ_id_pkip OBJ_id_pkix,5L +- +-#define SN_id_alg "id-alg" +-#define NID_id_alg 262 +-#define OBJ_id_alg OBJ_id_pkix,6L +- +-#define SN_id_cmc "id-cmc" +-#define NID_id_cmc 263 +-#define OBJ_id_cmc OBJ_id_pkix,7L +- +-#define SN_id_on "id-on" +-#define NID_id_on 264 +-#define OBJ_id_on OBJ_id_pkix,8L +- +-#define SN_id_pda "id-pda" +-#define NID_id_pda 265 +-#define OBJ_id_pda OBJ_id_pkix,9L +- +-#define SN_id_aca "id-aca" +-#define NID_id_aca 266 +-#define OBJ_id_aca OBJ_id_pkix,10L +- +-#define SN_id_qcs "id-qcs" +-#define NID_id_qcs 267 +-#define OBJ_id_qcs OBJ_id_pkix,11L +- +-#define SN_id_cct "id-cct" +-#define NID_id_cct 268 +-#define OBJ_id_cct OBJ_id_pkix,12L +- +-#define SN_id_ppl "id-ppl" +-#define NID_id_ppl 662 +-#define OBJ_id_ppl OBJ_id_pkix,21L +- +-#define SN_id_ad "id-ad" +-#define NID_id_ad 176 +-#define OBJ_id_ad OBJ_id_pkix,48L +- +-#define SN_id_pkix1_explicit_88 "id-pkix1-explicit-88" +-#define NID_id_pkix1_explicit_88 269 +-#define OBJ_id_pkix1_explicit_88 OBJ_id_pkix_mod,1L +- +-#define SN_id_pkix1_implicit_88 "id-pkix1-implicit-88" +-#define NID_id_pkix1_implicit_88 270 +-#define OBJ_id_pkix1_implicit_88 OBJ_id_pkix_mod,2L +- +-#define SN_id_pkix1_explicit_93 "id-pkix1-explicit-93" +-#define NID_id_pkix1_explicit_93 271 +-#define OBJ_id_pkix1_explicit_93 OBJ_id_pkix_mod,3L +- +-#define SN_id_pkix1_implicit_93 "id-pkix1-implicit-93" +-#define NID_id_pkix1_implicit_93 272 +-#define OBJ_id_pkix1_implicit_93 OBJ_id_pkix_mod,4L +- +-#define SN_id_mod_crmf "id-mod-crmf" +-#define NID_id_mod_crmf 273 +-#define OBJ_id_mod_crmf OBJ_id_pkix_mod,5L +- +-#define SN_id_mod_cmc "id-mod-cmc" +-#define NID_id_mod_cmc 274 +-#define OBJ_id_mod_cmc OBJ_id_pkix_mod,6L +- +-#define SN_id_mod_kea_profile_88 "id-mod-kea-profile-88" +-#define NID_id_mod_kea_profile_88 275 +-#define OBJ_id_mod_kea_profile_88 OBJ_id_pkix_mod,7L +- +-#define SN_id_mod_kea_profile_93 "id-mod-kea-profile-93" +-#define NID_id_mod_kea_profile_93 276 +-#define OBJ_id_mod_kea_profile_93 OBJ_id_pkix_mod,8L +- +-#define SN_id_mod_cmp "id-mod-cmp" +-#define NID_id_mod_cmp 277 +-#define OBJ_id_mod_cmp OBJ_id_pkix_mod,9L +- +-#define SN_id_mod_qualified_cert_88 "id-mod-qualified-cert-88" +-#define NID_id_mod_qualified_cert_88 278 +-#define OBJ_id_mod_qualified_cert_88 OBJ_id_pkix_mod,10L +- +-#define SN_id_mod_qualified_cert_93 "id-mod-qualified-cert-93" +-#define NID_id_mod_qualified_cert_93 279 +-#define OBJ_id_mod_qualified_cert_93 OBJ_id_pkix_mod,11L +- +-#define SN_id_mod_attribute_cert "id-mod-attribute-cert" +-#define NID_id_mod_attribute_cert 280 +-#define OBJ_id_mod_attribute_cert OBJ_id_pkix_mod,12L +- +-#define SN_id_mod_timestamp_protocol "id-mod-timestamp-protocol" +-#define NID_id_mod_timestamp_protocol 281 +-#define OBJ_id_mod_timestamp_protocol OBJ_id_pkix_mod,13L +- +-#define SN_id_mod_ocsp "id-mod-ocsp" +-#define NID_id_mod_ocsp 282 +-#define OBJ_id_mod_ocsp OBJ_id_pkix_mod,14L +- +-#define SN_id_mod_dvcs "id-mod-dvcs" +-#define NID_id_mod_dvcs 283 +-#define OBJ_id_mod_dvcs OBJ_id_pkix_mod,15L +- +-#define SN_id_mod_cmp2000 "id-mod-cmp2000" +-#define NID_id_mod_cmp2000 284 +-#define OBJ_id_mod_cmp2000 OBJ_id_pkix_mod,16L +- +-#define SN_info_access "authorityInfoAccess" +-#define LN_info_access "Authority Information Access" +-#define NID_info_access 177 +-#define OBJ_info_access OBJ_id_pe,1L +- +-#define SN_biometricInfo "biometricInfo" +-#define LN_biometricInfo "Biometric Info" +-#define NID_biometricInfo 285 +-#define OBJ_biometricInfo OBJ_id_pe,2L +- +-#define SN_qcStatements "qcStatements" +-#define NID_qcStatements 286 +-#define OBJ_qcStatements OBJ_id_pe,3L +- +-#define SN_ac_auditEntity "ac-auditEntity" +-#define NID_ac_auditEntity 287 +-#define OBJ_ac_auditEntity OBJ_id_pe,4L +- +-#define SN_ac_targeting "ac-targeting" +-#define NID_ac_targeting 288 +-#define OBJ_ac_targeting OBJ_id_pe,5L +- +-#define SN_aaControls "aaControls" +-#define NID_aaControls 289 +-#define OBJ_aaControls OBJ_id_pe,6L +- +-#define SN_sbgp_ipAddrBlock "sbgp-ipAddrBlock" +-#define NID_sbgp_ipAddrBlock 290 +-#define OBJ_sbgp_ipAddrBlock OBJ_id_pe,7L +- +-#define SN_sbgp_autonomousSysNum "sbgp-autonomousSysNum" +-#define NID_sbgp_autonomousSysNum 291 +-#define OBJ_sbgp_autonomousSysNum OBJ_id_pe,8L +- +-#define SN_sbgp_routerIdentifier "sbgp-routerIdentifier" +-#define NID_sbgp_routerIdentifier 292 +-#define OBJ_sbgp_routerIdentifier OBJ_id_pe,9L +- +-#define SN_ac_proxying "ac-proxying" +-#define NID_ac_proxying 397 +-#define OBJ_ac_proxying OBJ_id_pe,10L +- +-#define SN_sinfo_access "subjectInfoAccess" +-#define LN_sinfo_access "Subject Information Access" +-#define NID_sinfo_access 398 +-#define OBJ_sinfo_access OBJ_id_pe,11L +- +-#define SN_proxyCertInfo "proxyCertInfo" +-#define LN_proxyCertInfo "Proxy Certificate Information" +-#define NID_proxyCertInfo 663 +-#define OBJ_proxyCertInfo OBJ_id_pe,14L +- +-#define SN_tlsfeature "tlsfeature" +-#define LN_tlsfeature "TLS Feature" +-#define NID_tlsfeature 1020 +-#define OBJ_tlsfeature OBJ_id_pe,24L +- +-#define SN_id_qt_cps "id-qt-cps" +-#define LN_id_qt_cps "Policy Qualifier CPS" +-#define NID_id_qt_cps 164 +-#define OBJ_id_qt_cps OBJ_id_qt,1L +- +-#define SN_id_qt_unotice "id-qt-unotice" +-#define LN_id_qt_unotice "Policy Qualifier User Notice" +-#define NID_id_qt_unotice 165 +-#define OBJ_id_qt_unotice OBJ_id_qt,2L +- +-#define SN_textNotice "textNotice" +-#define NID_textNotice 293 +-#define OBJ_textNotice OBJ_id_qt,3L +- +-#define SN_server_auth "serverAuth" +-#define LN_server_auth "TLS Web Server Authentication" +-#define NID_server_auth 129 +-#define OBJ_server_auth OBJ_id_kp,1L +- +-#define SN_client_auth "clientAuth" +-#define LN_client_auth "TLS Web Client Authentication" +-#define NID_client_auth 130 +-#define OBJ_client_auth OBJ_id_kp,2L +- +-#define SN_code_sign "codeSigning" +-#define LN_code_sign "Code Signing" +-#define NID_code_sign 131 +-#define OBJ_code_sign OBJ_id_kp,3L +- +-#define SN_email_protect "emailProtection" +-#define LN_email_protect "E-mail Protection" +-#define NID_email_protect 132 +-#define OBJ_email_protect OBJ_id_kp,4L +- +-#define SN_ipsecEndSystem "ipsecEndSystem" +-#define LN_ipsecEndSystem "IPSec End System" +-#define NID_ipsecEndSystem 294 +-#define OBJ_ipsecEndSystem OBJ_id_kp,5L +- +-#define SN_ipsecTunnel "ipsecTunnel" +-#define LN_ipsecTunnel "IPSec Tunnel" +-#define NID_ipsecTunnel 295 +-#define OBJ_ipsecTunnel OBJ_id_kp,6L +- +-#define SN_ipsecUser "ipsecUser" +-#define LN_ipsecUser "IPSec User" +-#define NID_ipsecUser 296 +-#define OBJ_ipsecUser OBJ_id_kp,7L +- +-#define SN_time_stamp "timeStamping" +-#define LN_time_stamp "Time Stamping" +-#define NID_time_stamp 133 +-#define OBJ_time_stamp OBJ_id_kp,8L +- +-#define SN_OCSP_sign "OCSPSigning" +-#define LN_OCSP_sign "OCSP Signing" +-#define NID_OCSP_sign 180 +-#define OBJ_OCSP_sign OBJ_id_kp,9L +- +-#define SN_dvcs "DVCS" +-#define LN_dvcs "dvcs" +-#define NID_dvcs 297 +-#define OBJ_dvcs OBJ_id_kp,10L +- +-#define SN_ipsec_IKE "ipsecIKE" +-#define LN_ipsec_IKE "ipsec Internet Key Exchange" +-#define NID_ipsec_IKE 1022 +-#define OBJ_ipsec_IKE OBJ_id_kp,17L +- +-#define SN_capwapAC "capwapAC" +-#define LN_capwapAC "Ctrl/provision WAP Access" +-#define NID_capwapAC 1023 +-#define OBJ_capwapAC OBJ_id_kp,18L +- +-#define SN_capwapWTP "capwapWTP" +-#define LN_capwapWTP "Ctrl/Provision WAP Termination" +-#define NID_capwapWTP 1024 +-#define OBJ_capwapWTP OBJ_id_kp,19L +- +-#define SN_sshClient "secureShellClient" +-#define LN_sshClient "SSH Client" +-#define NID_sshClient 1025 +-#define OBJ_sshClient OBJ_id_kp,21L +- +-#define SN_sshServer "secureShellServer" +-#define LN_sshServer "SSH Server" +-#define NID_sshServer 1026 +-#define OBJ_sshServer OBJ_id_kp,22L +- +-#define SN_sendRouter "sendRouter" +-#define LN_sendRouter "Send Router" +-#define NID_sendRouter 1027 +-#define OBJ_sendRouter OBJ_id_kp,23L +- +-#define SN_sendProxiedRouter "sendProxiedRouter" +-#define LN_sendProxiedRouter "Send Proxied Router" +-#define NID_sendProxiedRouter 1028 +-#define OBJ_sendProxiedRouter OBJ_id_kp,24L +- +-#define SN_sendOwner "sendOwner" +-#define LN_sendOwner "Send Owner" +-#define NID_sendOwner 1029 +-#define OBJ_sendOwner OBJ_id_kp,25L +- +-#define SN_sendProxiedOwner "sendProxiedOwner" +-#define LN_sendProxiedOwner "Send Proxied Owner" +-#define NID_sendProxiedOwner 1030 +-#define OBJ_sendProxiedOwner OBJ_id_kp,26L +- +-#define SN_cmcCA "cmcCA" +-#define LN_cmcCA "CMC Certificate Authority" +-#define NID_cmcCA 1131 +-#define OBJ_cmcCA OBJ_id_kp,27L +- +-#define SN_cmcRA "cmcRA" +-#define LN_cmcRA "CMC Registration Authority" +-#define NID_cmcRA 1132 +-#define OBJ_cmcRA OBJ_id_kp,28L +- +-#define SN_id_it_caProtEncCert "id-it-caProtEncCert" +-#define NID_id_it_caProtEncCert 298 +-#define OBJ_id_it_caProtEncCert OBJ_id_it,1L +- +-#define SN_id_it_signKeyPairTypes "id-it-signKeyPairTypes" +-#define NID_id_it_signKeyPairTypes 299 +-#define OBJ_id_it_signKeyPairTypes OBJ_id_it,2L +- +-#define SN_id_it_encKeyPairTypes "id-it-encKeyPairTypes" +-#define NID_id_it_encKeyPairTypes 300 +-#define OBJ_id_it_encKeyPairTypes OBJ_id_it,3L +- +-#define SN_id_it_preferredSymmAlg "id-it-preferredSymmAlg" +-#define NID_id_it_preferredSymmAlg 301 +-#define OBJ_id_it_preferredSymmAlg OBJ_id_it,4L +- +-#define SN_id_it_caKeyUpdateInfo "id-it-caKeyUpdateInfo" +-#define NID_id_it_caKeyUpdateInfo 302 +-#define OBJ_id_it_caKeyUpdateInfo OBJ_id_it,5L +- +-#define SN_id_it_currentCRL "id-it-currentCRL" +-#define NID_id_it_currentCRL 303 +-#define OBJ_id_it_currentCRL OBJ_id_it,6L +- +-#define SN_id_it_unsupportedOIDs "id-it-unsupportedOIDs" +-#define NID_id_it_unsupportedOIDs 304 +-#define OBJ_id_it_unsupportedOIDs OBJ_id_it,7L +- +-#define SN_id_it_subscriptionRequest "id-it-subscriptionRequest" +-#define NID_id_it_subscriptionRequest 305 +-#define OBJ_id_it_subscriptionRequest OBJ_id_it,8L +- +-#define SN_id_it_subscriptionResponse "id-it-subscriptionResponse" +-#define NID_id_it_subscriptionResponse 306 +-#define OBJ_id_it_subscriptionResponse OBJ_id_it,9L +- +-#define SN_id_it_keyPairParamReq "id-it-keyPairParamReq" +-#define NID_id_it_keyPairParamReq 307 +-#define OBJ_id_it_keyPairParamReq OBJ_id_it,10L +- +-#define SN_id_it_keyPairParamRep "id-it-keyPairParamRep" +-#define NID_id_it_keyPairParamRep 308 +-#define OBJ_id_it_keyPairParamRep OBJ_id_it,11L +- +-#define SN_id_it_revPassphrase "id-it-revPassphrase" +-#define NID_id_it_revPassphrase 309 +-#define OBJ_id_it_revPassphrase OBJ_id_it,12L +- +-#define SN_id_it_implicitConfirm "id-it-implicitConfirm" +-#define NID_id_it_implicitConfirm 310 +-#define OBJ_id_it_implicitConfirm OBJ_id_it,13L +- +-#define SN_id_it_confirmWaitTime "id-it-confirmWaitTime" +-#define NID_id_it_confirmWaitTime 311 +-#define OBJ_id_it_confirmWaitTime OBJ_id_it,14L +- +-#define SN_id_it_origPKIMessage "id-it-origPKIMessage" +-#define NID_id_it_origPKIMessage 312 +-#define OBJ_id_it_origPKIMessage OBJ_id_it,15L +- +-#define SN_id_it_suppLangTags "id-it-suppLangTags" +-#define NID_id_it_suppLangTags 784 +-#define OBJ_id_it_suppLangTags OBJ_id_it,16L +- +-#define SN_id_regCtrl "id-regCtrl" +-#define NID_id_regCtrl 313 +-#define OBJ_id_regCtrl OBJ_id_pkip,1L +- +-#define SN_id_regInfo "id-regInfo" +-#define NID_id_regInfo 314 +-#define OBJ_id_regInfo OBJ_id_pkip,2L +- +-#define SN_id_regCtrl_regToken "id-regCtrl-regToken" +-#define NID_id_regCtrl_regToken 315 +-#define OBJ_id_regCtrl_regToken OBJ_id_regCtrl,1L +- +-#define SN_id_regCtrl_authenticator "id-regCtrl-authenticator" +-#define NID_id_regCtrl_authenticator 316 +-#define OBJ_id_regCtrl_authenticator OBJ_id_regCtrl,2L +- +-#define SN_id_regCtrl_pkiPublicationInfo "id-regCtrl-pkiPublicationInfo" +-#define NID_id_regCtrl_pkiPublicationInfo 317 +-#define OBJ_id_regCtrl_pkiPublicationInfo OBJ_id_regCtrl,3L +- +-#define SN_id_regCtrl_pkiArchiveOptions "id-regCtrl-pkiArchiveOptions" +-#define NID_id_regCtrl_pkiArchiveOptions 318 +-#define OBJ_id_regCtrl_pkiArchiveOptions OBJ_id_regCtrl,4L +- +-#define SN_id_regCtrl_oldCertID "id-regCtrl-oldCertID" +-#define NID_id_regCtrl_oldCertID 319 +-#define OBJ_id_regCtrl_oldCertID OBJ_id_regCtrl,5L +- +-#define SN_id_regCtrl_protocolEncrKey "id-regCtrl-protocolEncrKey" +-#define NID_id_regCtrl_protocolEncrKey 320 +-#define OBJ_id_regCtrl_protocolEncrKey OBJ_id_regCtrl,6L +- +-#define SN_id_regInfo_utf8Pairs "id-regInfo-utf8Pairs" +-#define NID_id_regInfo_utf8Pairs 321 +-#define OBJ_id_regInfo_utf8Pairs OBJ_id_regInfo,1L +- +-#define SN_id_regInfo_certReq "id-regInfo-certReq" +-#define NID_id_regInfo_certReq 322 +-#define OBJ_id_regInfo_certReq OBJ_id_regInfo,2L +- +-#define SN_id_alg_des40 "id-alg-des40" +-#define NID_id_alg_des40 323 +-#define OBJ_id_alg_des40 OBJ_id_alg,1L +- +-#define SN_id_alg_noSignature "id-alg-noSignature" +-#define NID_id_alg_noSignature 324 +-#define OBJ_id_alg_noSignature OBJ_id_alg,2L +- +-#define SN_id_alg_dh_sig_hmac_sha1 "id-alg-dh-sig-hmac-sha1" +-#define NID_id_alg_dh_sig_hmac_sha1 325 +-#define OBJ_id_alg_dh_sig_hmac_sha1 OBJ_id_alg,3L +- +-#define SN_id_alg_dh_pop "id-alg-dh-pop" +-#define NID_id_alg_dh_pop 326 +-#define OBJ_id_alg_dh_pop OBJ_id_alg,4L +- +-#define SN_id_cmc_statusInfo "id-cmc-statusInfo" +-#define NID_id_cmc_statusInfo 327 +-#define OBJ_id_cmc_statusInfo OBJ_id_cmc,1L +- +-#define SN_id_cmc_identification "id-cmc-identification" +-#define NID_id_cmc_identification 328 +-#define OBJ_id_cmc_identification OBJ_id_cmc,2L +- +-#define SN_id_cmc_identityProof "id-cmc-identityProof" +-#define NID_id_cmc_identityProof 329 +-#define OBJ_id_cmc_identityProof OBJ_id_cmc,3L +- +-#define SN_id_cmc_dataReturn "id-cmc-dataReturn" +-#define NID_id_cmc_dataReturn 330 +-#define OBJ_id_cmc_dataReturn OBJ_id_cmc,4L +- +-#define SN_id_cmc_transactionId "id-cmc-transactionId" +-#define NID_id_cmc_transactionId 331 +-#define OBJ_id_cmc_transactionId OBJ_id_cmc,5L +- +-#define SN_id_cmc_senderNonce "id-cmc-senderNonce" +-#define NID_id_cmc_senderNonce 332 +-#define OBJ_id_cmc_senderNonce OBJ_id_cmc,6L +- +-#define SN_id_cmc_recipientNonce "id-cmc-recipientNonce" +-#define NID_id_cmc_recipientNonce 333 +-#define OBJ_id_cmc_recipientNonce OBJ_id_cmc,7L +- +-#define SN_id_cmc_addExtensions "id-cmc-addExtensions" +-#define NID_id_cmc_addExtensions 334 +-#define OBJ_id_cmc_addExtensions OBJ_id_cmc,8L +- +-#define SN_id_cmc_encryptedPOP "id-cmc-encryptedPOP" +-#define NID_id_cmc_encryptedPOP 335 +-#define OBJ_id_cmc_encryptedPOP OBJ_id_cmc,9L +- +-#define SN_id_cmc_decryptedPOP "id-cmc-decryptedPOP" +-#define NID_id_cmc_decryptedPOP 336 +-#define OBJ_id_cmc_decryptedPOP OBJ_id_cmc,10L +- +-#define SN_id_cmc_lraPOPWitness "id-cmc-lraPOPWitness" +-#define NID_id_cmc_lraPOPWitness 337 +-#define OBJ_id_cmc_lraPOPWitness OBJ_id_cmc,11L +- +-#define SN_id_cmc_getCert "id-cmc-getCert" +-#define NID_id_cmc_getCert 338 +-#define OBJ_id_cmc_getCert OBJ_id_cmc,15L +- +-#define SN_id_cmc_getCRL "id-cmc-getCRL" +-#define NID_id_cmc_getCRL 339 +-#define OBJ_id_cmc_getCRL OBJ_id_cmc,16L +- +-#define SN_id_cmc_revokeRequest "id-cmc-revokeRequest" +-#define NID_id_cmc_revokeRequest 340 +-#define OBJ_id_cmc_revokeRequest OBJ_id_cmc,17L +- +-#define SN_id_cmc_regInfo "id-cmc-regInfo" +-#define NID_id_cmc_regInfo 341 +-#define OBJ_id_cmc_regInfo OBJ_id_cmc,18L +- +-#define SN_id_cmc_responseInfo "id-cmc-responseInfo" +-#define NID_id_cmc_responseInfo 342 +-#define OBJ_id_cmc_responseInfo OBJ_id_cmc,19L +- +-#define SN_id_cmc_queryPending "id-cmc-queryPending" +-#define NID_id_cmc_queryPending 343 +-#define OBJ_id_cmc_queryPending OBJ_id_cmc,21L +- +-#define SN_id_cmc_popLinkRandom "id-cmc-popLinkRandom" +-#define NID_id_cmc_popLinkRandom 344 +-#define OBJ_id_cmc_popLinkRandom OBJ_id_cmc,22L +- +-#define SN_id_cmc_popLinkWitness "id-cmc-popLinkWitness" +-#define NID_id_cmc_popLinkWitness 345 +-#define OBJ_id_cmc_popLinkWitness OBJ_id_cmc,23L +- +-#define SN_id_cmc_confirmCertAcceptance "id-cmc-confirmCertAcceptance" +-#define NID_id_cmc_confirmCertAcceptance 346 +-#define OBJ_id_cmc_confirmCertAcceptance OBJ_id_cmc,24L +- +-#define SN_id_on_personalData "id-on-personalData" +-#define NID_id_on_personalData 347 +-#define OBJ_id_on_personalData OBJ_id_on,1L +- +-#define SN_id_on_permanentIdentifier "id-on-permanentIdentifier" +-#define LN_id_on_permanentIdentifier "Permanent Identifier" +-#define NID_id_on_permanentIdentifier 858 +-#define OBJ_id_on_permanentIdentifier OBJ_id_on,3L +- +-#define SN_id_pda_dateOfBirth "id-pda-dateOfBirth" +-#define NID_id_pda_dateOfBirth 348 +-#define OBJ_id_pda_dateOfBirth OBJ_id_pda,1L +- +-#define SN_id_pda_placeOfBirth "id-pda-placeOfBirth" +-#define NID_id_pda_placeOfBirth 349 +-#define OBJ_id_pda_placeOfBirth OBJ_id_pda,2L +- +-#define SN_id_pda_gender "id-pda-gender" +-#define NID_id_pda_gender 351 +-#define OBJ_id_pda_gender OBJ_id_pda,3L +- +-#define SN_id_pda_countryOfCitizenship "id-pda-countryOfCitizenship" +-#define NID_id_pda_countryOfCitizenship 352 +-#define OBJ_id_pda_countryOfCitizenship OBJ_id_pda,4L +- +-#define SN_id_pda_countryOfResidence "id-pda-countryOfResidence" +-#define NID_id_pda_countryOfResidence 353 +-#define OBJ_id_pda_countryOfResidence OBJ_id_pda,5L +- +-#define SN_id_aca_authenticationInfo "id-aca-authenticationInfo" +-#define NID_id_aca_authenticationInfo 354 +-#define OBJ_id_aca_authenticationInfo OBJ_id_aca,1L +- +-#define SN_id_aca_accessIdentity "id-aca-accessIdentity" +-#define NID_id_aca_accessIdentity 355 +-#define OBJ_id_aca_accessIdentity OBJ_id_aca,2L +- +-#define SN_id_aca_chargingIdentity "id-aca-chargingIdentity" +-#define NID_id_aca_chargingIdentity 356 +-#define OBJ_id_aca_chargingIdentity OBJ_id_aca,3L +- +-#define SN_id_aca_group "id-aca-group" +-#define NID_id_aca_group 357 +-#define OBJ_id_aca_group OBJ_id_aca,4L +- +-#define SN_id_aca_role "id-aca-role" +-#define NID_id_aca_role 358 +-#define OBJ_id_aca_role OBJ_id_aca,5L +- +-#define SN_id_aca_encAttrs "id-aca-encAttrs" +-#define NID_id_aca_encAttrs 399 +-#define OBJ_id_aca_encAttrs OBJ_id_aca,6L +- +-#define SN_id_qcs_pkixQCSyntax_v1 "id-qcs-pkixQCSyntax-v1" +-#define NID_id_qcs_pkixQCSyntax_v1 359 +-#define OBJ_id_qcs_pkixQCSyntax_v1 OBJ_id_qcs,1L +- +-#define SN_id_cct_crs "id-cct-crs" +-#define NID_id_cct_crs 360 +-#define OBJ_id_cct_crs OBJ_id_cct,1L +- +-#define SN_id_cct_PKIData "id-cct-PKIData" +-#define NID_id_cct_PKIData 361 +-#define OBJ_id_cct_PKIData OBJ_id_cct,2L +- +-#define SN_id_cct_PKIResponse "id-cct-PKIResponse" +-#define NID_id_cct_PKIResponse 362 +-#define OBJ_id_cct_PKIResponse OBJ_id_cct,3L +- +-#define SN_id_ppl_anyLanguage "id-ppl-anyLanguage" +-#define LN_id_ppl_anyLanguage "Any language" +-#define NID_id_ppl_anyLanguage 664 +-#define OBJ_id_ppl_anyLanguage OBJ_id_ppl,0L +- +-#define SN_id_ppl_inheritAll "id-ppl-inheritAll" +-#define LN_id_ppl_inheritAll "Inherit all" +-#define NID_id_ppl_inheritAll 665 +-#define OBJ_id_ppl_inheritAll OBJ_id_ppl,1L +- +-#define SN_Independent "id-ppl-independent" +-#define LN_Independent "Independent" +-#define NID_Independent 667 +-#define OBJ_Independent OBJ_id_ppl,2L +- +-#define SN_ad_OCSP "OCSP" +-#define LN_ad_OCSP "OCSP" +-#define NID_ad_OCSP 178 +-#define OBJ_ad_OCSP OBJ_id_ad,1L +- +-#define SN_ad_ca_issuers "caIssuers" +-#define LN_ad_ca_issuers "CA Issuers" +-#define NID_ad_ca_issuers 179 +-#define OBJ_ad_ca_issuers OBJ_id_ad,2L +- +-#define SN_ad_timeStamping "ad_timestamping" +-#define LN_ad_timeStamping "AD Time Stamping" +-#define NID_ad_timeStamping 363 +-#define OBJ_ad_timeStamping OBJ_id_ad,3L +- +-#define SN_ad_dvcs "AD_DVCS" +-#define LN_ad_dvcs "ad dvcs" +-#define NID_ad_dvcs 364 +-#define OBJ_ad_dvcs OBJ_id_ad,4L +- +-#define SN_caRepository "caRepository" +-#define LN_caRepository "CA Repository" +-#define NID_caRepository 785 +-#define OBJ_caRepository OBJ_id_ad,5L +- +-#define OBJ_id_pkix_OCSP OBJ_ad_OCSP +- +-#define SN_id_pkix_OCSP_basic "basicOCSPResponse" +-#define LN_id_pkix_OCSP_basic "Basic OCSP Response" +-#define NID_id_pkix_OCSP_basic 365 +-#define OBJ_id_pkix_OCSP_basic OBJ_id_pkix_OCSP,1L +- +-#define SN_id_pkix_OCSP_Nonce "Nonce" +-#define LN_id_pkix_OCSP_Nonce "OCSP Nonce" +-#define NID_id_pkix_OCSP_Nonce 366 +-#define OBJ_id_pkix_OCSP_Nonce OBJ_id_pkix_OCSP,2L +- +-#define SN_id_pkix_OCSP_CrlID "CrlID" +-#define LN_id_pkix_OCSP_CrlID "OCSP CRL ID" +-#define NID_id_pkix_OCSP_CrlID 367 +-#define OBJ_id_pkix_OCSP_CrlID OBJ_id_pkix_OCSP,3L +- +-#define SN_id_pkix_OCSP_acceptableResponses "acceptableResponses" +-#define LN_id_pkix_OCSP_acceptableResponses "Acceptable OCSP Responses" +-#define NID_id_pkix_OCSP_acceptableResponses 368 +-#define OBJ_id_pkix_OCSP_acceptableResponses OBJ_id_pkix_OCSP,4L +- +-#define SN_id_pkix_OCSP_noCheck "noCheck" +-#define LN_id_pkix_OCSP_noCheck "OCSP No Check" +-#define NID_id_pkix_OCSP_noCheck 369 +-#define OBJ_id_pkix_OCSP_noCheck OBJ_id_pkix_OCSP,5L +- +-#define SN_id_pkix_OCSP_archiveCutoff "archiveCutoff" +-#define LN_id_pkix_OCSP_archiveCutoff "OCSP Archive Cutoff" +-#define NID_id_pkix_OCSP_archiveCutoff 370 +-#define OBJ_id_pkix_OCSP_archiveCutoff OBJ_id_pkix_OCSP,6L +- +-#define SN_id_pkix_OCSP_serviceLocator "serviceLocator" +-#define LN_id_pkix_OCSP_serviceLocator "OCSP Service Locator" +-#define NID_id_pkix_OCSP_serviceLocator 371 +-#define OBJ_id_pkix_OCSP_serviceLocator OBJ_id_pkix_OCSP,7L +- +-#define SN_id_pkix_OCSP_extendedStatus "extendedStatus" +-#define LN_id_pkix_OCSP_extendedStatus "Extended OCSP Status" +-#define NID_id_pkix_OCSP_extendedStatus 372 +-#define OBJ_id_pkix_OCSP_extendedStatus OBJ_id_pkix_OCSP,8L +- +-#define SN_id_pkix_OCSP_valid "valid" +-#define NID_id_pkix_OCSP_valid 373 +-#define OBJ_id_pkix_OCSP_valid OBJ_id_pkix_OCSP,9L +- +-#define SN_id_pkix_OCSP_path "path" +-#define NID_id_pkix_OCSP_path 374 +-#define OBJ_id_pkix_OCSP_path OBJ_id_pkix_OCSP,10L +- +-#define SN_id_pkix_OCSP_trustRoot "trustRoot" +-#define LN_id_pkix_OCSP_trustRoot "Trust Root" +-#define NID_id_pkix_OCSP_trustRoot 375 +-#define OBJ_id_pkix_OCSP_trustRoot OBJ_id_pkix_OCSP,11L +- +-#define SN_algorithm "algorithm" +-#define LN_algorithm "algorithm" +-#define NID_algorithm 376 +-#define OBJ_algorithm 1L,3L,14L,3L,2L +- +-#define SN_md5WithRSA "RSA-NP-MD5" +-#define LN_md5WithRSA "md5WithRSA" +-#define NID_md5WithRSA 104 +-#define OBJ_md5WithRSA OBJ_algorithm,3L +- +-#define SN_des_ecb "DES-ECB" +-#define LN_des_ecb "des-ecb" +-#define NID_des_ecb 29 +-#define OBJ_des_ecb OBJ_algorithm,6L +- +-#define SN_des_cbc "DES-CBC" +-#define LN_des_cbc "des-cbc" +-#define NID_des_cbc 31 +-#define OBJ_des_cbc OBJ_algorithm,7L +- +-#define SN_des_ofb64 "DES-OFB" +-#define LN_des_ofb64 "des-ofb" +-#define NID_des_ofb64 45 +-#define OBJ_des_ofb64 OBJ_algorithm,8L +- +-#define SN_des_cfb64 "DES-CFB" +-#define LN_des_cfb64 "des-cfb" +-#define NID_des_cfb64 30 +-#define OBJ_des_cfb64 OBJ_algorithm,9L +- +-#define SN_rsaSignature "rsaSignature" +-#define NID_rsaSignature 377 +-#define OBJ_rsaSignature OBJ_algorithm,11L +- +-#define SN_dsa_2 "DSA-old" +-#define LN_dsa_2 "dsaEncryption-old" +-#define NID_dsa_2 67 +-#define OBJ_dsa_2 OBJ_algorithm,12L +- +-#define SN_dsaWithSHA "DSA-SHA" +-#define LN_dsaWithSHA "dsaWithSHA" +-#define NID_dsaWithSHA 66 +-#define OBJ_dsaWithSHA OBJ_algorithm,13L +- +-#define SN_shaWithRSAEncryption "RSA-SHA" +-#define LN_shaWithRSAEncryption "shaWithRSAEncryption" +-#define NID_shaWithRSAEncryption 42 +-#define OBJ_shaWithRSAEncryption OBJ_algorithm,15L +- +-#define SN_des_ede_ecb "DES-EDE" +-#define LN_des_ede_ecb "des-ede" +-#define NID_des_ede_ecb 32 +-#define OBJ_des_ede_ecb OBJ_algorithm,17L +- +-#define SN_des_ede3_ecb "DES-EDE3" +-#define LN_des_ede3_ecb "des-ede3" +-#define NID_des_ede3_ecb 33 +- +-#define SN_des_ede_cbc "DES-EDE-CBC" +-#define LN_des_ede_cbc "des-ede-cbc" +-#define NID_des_ede_cbc 43 +- +-#define SN_des_ede_cfb64 "DES-EDE-CFB" +-#define LN_des_ede_cfb64 "des-ede-cfb" +-#define NID_des_ede_cfb64 60 +- +-#define SN_des_ede3_cfb64 "DES-EDE3-CFB" +-#define LN_des_ede3_cfb64 "des-ede3-cfb" +-#define NID_des_ede3_cfb64 61 +- +-#define SN_des_ede_ofb64 "DES-EDE-OFB" +-#define LN_des_ede_ofb64 "des-ede-ofb" +-#define NID_des_ede_ofb64 62 +- +-#define SN_des_ede3_ofb64 "DES-EDE3-OFB" +-#define LN_des_ede3_ofb64 "des-ede3-ofb" +-#define NID_des_ede3_ofb64 63 +- +-#define SN_desx_cbc "DESX-CBC" +-#define LN_desx_cbc "desx-cbc" +-#define NID_desx_cbc 80 +- +-#define SN_sha "SHA" +-#define LN_sha "sha" +-#define NID_sha 41 +-#define OBJ_sha OBJ_algorithm,18L +- +-#define SN_sha1 "SHA1" +-#define LN_sha1 "sha1" +-#define NID_sha1 64 +-#define OBJ_sha1 OBJ_algorithm,26L +- +-#define SN_dsaWithSHA1_2 "DSA-SHA1-old" +-#define LN_dsaWithSHA1_2 "dsaWithSHA1-old" +-#define NID_dsaWithSHA1_2 70 +-#define OBJ_dsaWithSHA1_2 OBJ_algorithm,27L +- +-#define SN_sha1WithRSA "RSA-SHA1-2" +-#define LN_sha1WithRSA "sha1WithRSA" +-#define NID_sha1WithRSA 115 +-#define OBJ_sha1WithRSA OBJ_algorithm,29L +- +-#define SN_ripemd160 "RIPEMD160" +-#define LN_ripemd160 "ripemd160" +-#define NID_ripemd160 117 +-#define OBJ_ripemd160 1L,3L,36L,3L,2L,1L +- +-#define SN_ripemd160WithRSA "RSA-RIPEMD160" +-#define LN_ripemd160WithRSA "ripemd160WithRSA" +-#define NID_ripemd160WithRSA 119 +-#define OBJ_ripemd160WithRSA 1L,3L,36L,3L,3L,1L,2L +- +-#define SN_blake2b512 "BLAKE2b512" +-#define LN_blake2b512 "blake2b512" +-#define NID_blake2b512 1056 +-#define OBJ_blake2b512 1L,3L,6L,1L,4L,1L,1722L,12L,2L,1L,16L +- +-#define SN_blake2s256 "BLAKE2s256" +-#define LN_blake2s256 "blake2s256" +-#define NID_blake2s256 1057 +-#define OBJ_blake2s256 1L,3L,6L,1L,4L,1L,1722L,12L,2L,2L,8L +- +-#define SN_sxnet "SXNetID" +-#define LN_sxnet "Strong Extranet ID" +-#define NID_sxnet 143 +-#define OBJ_sxnet 1L,3L,101L,1L,4L,1L +- +-#define SN_X500 "X500" +-#define LN_X500 "directory services (X.500)" +-#define NID_X500 11 +-#define OBJ_X500 2L,5L +- +-#define SN_X509 "X509" +-#define NID_X509 12 +-#define OBJ_X509 OBJ_X500,4L +- +-#define SN_commonName "CN" +-#define LN_commonName "commonName" +-#define NID_commonName 13 +-#define OBJ_commonName OBJ_X509,3L +- +-#define SN_surname "SN" +-#define LN_surname "surname" +-#define NID_surname 100 +-#define OBJ_surname OBJ_X509,4L +- +-#define LN_serialNumber "serialNumber" +-#define NID_serialNumber 105 +-#define OBJ_serialNumber OBJ_X509,5L +- +-#define SN_countryName "C" +-#define LN_countryName "countryName" +-#define NID_countryName 14 +-#define OBJ_countryName OBJ_X509,6L +- +-#define SN_localityName "L" +-#define LN_localityName "localityName" +-#define NID_localityName 15 +-#define OBJ_localityName OBJ_X509,7L +- +-#define SN_stateOrProvinceName "ST" +-#define LN_stateOrProvinceName "stateOrProvinceName" +-#define NID_stateOrProvinceName 16 +-#define OBJ_stateOrProvinceName OBJ_X509,8L +- +-#define SN_streetAddress "street" +-#define LN_streetAddress "streetAddress" +-#define NID_streetAddress 660 +-#define OBJ_streetAddress OBJ_X509,9L +- +-#define SN_organizationName "O" +-#define LN_organizationName "organizationName" +-#define NID_organizationName 17 +-#define OBJ_organizationName OBJ_X509,10L +- +-#define SN_organizationalUnitName "OU" +-#define LN_organizationalUnitName "organizationalUnitName" +-#define NID_organizationalUnitName 18 +-#define OBJ_organizationalUnitName OBJ_X509,11L +- +-#define SN_title "title" +-#define LN_title "title" +-#define NID_title 106 +-#define OBJ_title OBJ_X509,12L +- +-#define LN_description "description" +-#define NID_description 107 +-#define OBJ_description OBJ_X509,13L +- +-#define LN_searchGuide "searchGuide" +-#define NID_searchGuide 859 +-#define OBJ_searchGuide OBJ_X509,14L +- +-#define LN_businessCategory "businessCategory" +-#define NID_businessCategory 860 +-#define OBJ_businessCategory OBJ_X509,15L +- +-#define LN_postalAddress "postalAddress" +-#define NID_postalAddress 861 +-#define OBJ_postalAddress OBJ_X509,16L +- +-#define LN_postalCode "postalCode" +-#define NID_postalCode 661 +-#define OBJ_postalCode OBJ_X509,17L +- +-#define LN_postOfficeBox "postOfficeBox" +-#define NID_postOfficeBox 862 +-#define OBJ_postOfficeBox OBJ_X509,18L +- +-#define LN_physicalDeliveryOfficeName "physicalDeliveryOfficeName" +-#define NID_physicalDeliveryOfficeName 863 +-#define OBJ_physicalDeliveryOfficeName OBJ_X509,19L +- +-#define LN_telephoneNumber "telephoneNumber" +-#define NID_telephoneNumber 864 +-#define OBJ_telephoneNumber OBJ_X509,20L +- +-#define LN_telexNumber "telexNumber" +-#define NID_telexNumber 865 +-#define OBJ_telexNumber OBJ_X509,21L +- +-#define LN_teletexTerminalIdentifier "teletexTerminalIdentifier" +-#define NID_teletexTerminalIdentifier 866 +-#define OBJ_teletexTerminalIdentifier OBJ_X509,22L +- +-#define LN_facsimileTelephoneNumber "facsimileTelephoneNumber" +-#define NID_facsimileTelephoneNumber 867 +-#define OBJ_facsimileTelephoneNumber OBJ_X509,23L +- +-#define LN_x121Address "x121Address" +-#define NID_x121Address 868 +-#define OBJ_x121Address OBJ_X509,24L +- +-#define LN_internationaliSDNNumber "internationaliSDNNumber" +-#define NID_internationaliSDNNumber 869 +-#define OBJ_internationaliSDNNumber OBJ_X509,25L +- +-#define LN_registeredAddress "registeredAddress" +-#define NID_registeredAddress 870 +-#define OBJ_registeredAddress OBJ_X509,26L +- +-#define LN_destinationIndicator "destinationIndicator" +-#define NID_destinationIndicator 871 +-#define OBJ_destinationIndicator OBJ_X509,27L +- +-#define LN_preferredDeliveryMethod "preferredDeliveryMethod" +-#define NID_preferredDeliveryMethod 872 +-#define OBJ_preferredDeliveryMethod OBJ_X509,28L +- +-#define LN_presentationAddress "presentationAddress" +-#define NID_presentationAddress 873 +-#define OBJ_presentationAddress OBJ_X509,29L +- +-#define LN_supportedApplicationContext "supportedApplicationContext" +-#define NID_supportedApplicationContext 874 +-#define OBJ_supportedApplicationContext OBJ_X509,30L +- +-#define SN_member "member" +-#define NID_member 875 +-#define OBJ_member OBJ_X509,31L +- +-#define SN_owner "owner" +-#define NID_owner 876 +-#define OBJ_owner OBJ_X509,32L +- +-#define LN_roleOccupant "roleOccupant" +-#define NID_roleOccupant 877 +-#define OBJ_roleOccupant OBJ_X509,33L +- +-#define SN_seeAlso "seeAlso" +-#define NID_seeAlso 878 +-#define OBJ_seeAlso OBJ_X509,34L +- +-#define LN_userPassword "userPassword" +-#define NID_userPassword 879 +-#define OBJ_userPassword OBJ_X509,35L +- +-#define LN_userCertificate "userCertificate" +-#define NID_userCertificate 880 +-#define OBJ_userCertificate OBJ_X509,36L +- +-#define LN_cACertificate "cACertificate" +-#define NID_cACertificate 881 +-#define OBJ_cACertificate OBJ_X509,37L +- +-#define LN_authorityRevocationList "authorityRevocationList" +-#define NID_authorityRevocationList 882 +-#define OBJ_authorityRevocationList OBJ_X509,38L +- +-#define LN_certificateRevocationList "certificateRevocationList" +-#define NID_certificateRevocationList 883 +-#define OBJ_certificateRevocationList OBJ_X509,39L +- +-#define LN_crossCertificatePair "crossCertificatePair" +-#define NID_crossCertificatePair 884 +-#define OBJ_crossCertificatePair OBJ_X509,40L +- +-#define SN_name "name" +-#define LN_name "name" +-#define NID_name 173 +-#define OBJ_name OBJ_X509,41L +- +-#define SN_givenName "GN" +-#define LN_givenName "givenName" +-#define NID_givenName 99 +-#define OBJ_givenName OBJ_X509,42L +- +-#define SN_initials "initials" +-#define LN_initials "initials" +-#define NID_initials 101 +-#define OBJ_initials OBJ_X509,43L +- +-#define LN_generationQualifier "generationQualifier" +-#define NID_generationQualifier 509 +-#define OBJ_generationQualifier OBJ_X509,44L +- +-#define LN_x500UniqueIdentifier "x500UniqueIdentifier" +-#define NID_x500UniqueIdentifier 503 +-#define OBJ_x500UniqueIdentifier OBJ_X509,45L +- +-#define SN_dnQualifier "dnQualifier" +-#define LN_dnQualifier "dnQualifier" +-#define NID_dnQualifier 174 +-#define OBJ_dnQualifier OBJ_X509,46L +- +-#define LN_enhancedSearchGuide "enhancedSearchGuide" +-#define NID_enhancedSearchGuide 885 +-#define OBJ_enhancedSearchGuide OBJ_X509,47L +- +-#define LN_protocolInformation "protocolInformation" +-#define NID_protocolInformation 886 +-#define OBJ_protocolInformation OBJ_X509,48L +- +-#define LN_distinguishedName "distinguishedName" +-#define NID_distinguishedName 887 +-#define OBJ_distinguishedName OBJ_X509,49L +- +-#define LN_uniqueMember "uniqueMember" +-#define NID_uniqueMember 888 +-#define OBJ_uniqueMember OBJ_X509,50L +- +-#define LN_houseIdentifier "houseIdentifier" +-#define NID_houseIdentifier 889 +-#define OBJ_houseIdentifier OBJ_X509,51L +- +-#define LN_supportedAlgorithms "supportedAlgorithms" +-#define NID_supportedAlgorithms 890 +-#define OBJ_supportedAlgorithms OBJ_X509,52L +- +-#define LN_deltaRevocationList "deltaRevocationList" +-#define NID_deltaRevocationList 891 +-#define OBJ_deltaRevocationList OBJ_X509,53L +- +-#define SN_dmdName "dmdName" +-#define NID_dmdName 892 +-#define OBJ_dmdName OBJ_X509,54L +- +-#define LN_pseudonym "pseudonym" +-#define NID_pseudonym 510 +-#define OBJ_pseudonym OBJ_X509,65L +- +-#define SN_role "role" +-#define LN_role "role" +-#define NID_role 400 +-#define OBJ_role OBJ_X509,72L +- +-#define LN_organizationIdentifier "organizationIdentifier" +-#define NID_organizationIdentifier 1089 +-#define OBJ_organizationIdentifier OBJ_X509,97L +- +-#define SN_countryCode3c "c3" +-#define LN_countryCode3c "countryCode3c" +-#define NID_countryCode3c 1090 +-#define OBJ_countryCode3c OBJ_X509,98L +- +-#define SN_countryCode3n "n3" +-#define LN_countryCode3n "countryCode3n" +-#define NID_countryCode3n 1091 +-#define OBJ_countryCode3n OBJ_X509,99L +- +-#define LN_dnsName "dnsName" +-#define NID_dnsName 1092 +-#define OBJ_dnsName OBJ_X509,100L +- +-#define SN_X500algorithms "X500algorithms" +-#define LN_X500algorithms "directory services - algorithms" +-#define NID_X500algorithms 378 +-#define OBJ_X500algorithms OBJ_X500,8L +- +-#define SN_rsa "RSA" +-#define LN_rsa "rsa" +-#define NID_rsa 19 +-#define OBJ_rsa OBJ_X500algorithms,1L,1L +- +-#define SN_mdc2WithRSA "RSA-MDC2" +-#define LN_mdc2WithRSA "mdc2WithRSA" +-#define NID_mdc2WithRSA 96 +-#define OBJ_mdc2WithRSA OBJ_X500algorithms,3L,100L +- +-#define SN_mdc2 "MDC2" +-#define LN_mdc2 "mdc2" +-#define NID_mdc2 95 +-#define OBJ_mdc2 OBJ_X500algorithms,3L,101L +- +-#define SN_id_ce "id-ce" +-#define NID_id_ce 81 +-#define OBJ_id_ce OBJ_X500,29L +- +-#define SN_subject_directory_attributes "subjectDirectoryAttributes" +-#define LN_subject_directory_attributes "X509v3 Subject Directory Attributes" +-#define NID_subject_directory_attributes 769 +-#define OBJ_subject_directory_attributes OBJ_id_ce,9L +- +-#define SN_subject_key_identifier "subjectKeyIdentifier" +-#define LN_subject_key_identifier "X509v3 Subject Key Identifier" +-#define NID_subject_key_identifier 82 +-#define OBJ_subject_key_identifier OBJ_id_ce,14L +- +-#define SN_key_usage "keyUsage" +-#define LN_key_usage "X509v3 Key Usage" +-#define NID_key_usage 83 +-#define OBJ_key_usage OBJ_id_ce,15L +- +-#define SN_private_key_usage_period "privateKeyUsagePeriod" +-#define LN_private_key_usage_period "X509v3 Private Key Usage Period" +-#define NID_private_key_usage_period 84 +-#define OBJ_private_key_usage_period OBJ_id_ce,16L +- +-#define SN_subject_alt_name "subjectAltName" +-#define LN_subject_alt_name "X509v3 Subject Alternative Name" +-#define NID_subject_alt_name 85 +-#define OBJ_subject_alt_name OBJ_id_ce,17L +- +-#define SN_issuer_alt_name "issuerAltName" +-#define LN_issuer_alt_name "X509v3 Issuer Alternative Name" +-#define NID_issuer_alt_name 86 +-#define OBJ_issuer_alt_name OBJ_id_ce,18L +- +-#define SN_basic_constraints "basicConstraints" +-#define LN_basic_constraints "X509v3 Basic Constraints" +-#define NID_basic_constraints 87 +-#define OBJ_basic_constraints OBJ_id_ce,19L +- +-#define SN_crl_number "crlNumber" +-#define LN_crl_number "X509v3 CRL Number" +-#define NID_crl_number 88 +-#define OBJ_crl_number OBJ_id_ce,20L +- +-#define SN_crl_reason "CRLReason" +-#define LN_crl_reason "X509v3 CRL Reason Code" +-#define NID_crl_reason 141 +-#define OBJ_crl_reason OBJ_id_ce,21L +- +-#define SN_invalidity_date "invalidityDate" +-#define LN_invalidity_date "Invalidity Date" +-#define NID_invalidity_date 142 +-#define OBJ_invalidity_date OBJ_id_ce,24L +- +-#define SN_delta_crl "deltaCRL" +-#define LN_delta_crl "X509v3 Delta CRL Indicator" +-#define NID_delta_crl 140 +-#define OBJ_delta_crl OBJ_id_ce,27L +- +-#define SN_issuing_distribution_point "issuingDistributionPoint" +-#define LN_issuing_distribution_point "X509v3 Issuing Distribution Point" +-#define NID_issuing_distribution_point 770 +-#define OBJ_issuing_distribution_point OBJ_id_ce,28L +- +-#define SN_certificate_issuer "certificateIssuer" +-#define LN_certificate_issuer "X509v3 Certificate Issuer" +-#define NID_certificate_issuer 771 +-#define OBJ_certificate_issuer OBJ_id_ce,29L +- +-#define SN_name_constraints "nameConstraints" +-#define LN_name_constraints "X509v3 Name Constraints" +-#define NID_name_constraints 666 +-#define OBJ_name_constraints OBJ_id_ce,30L +- +-#define SN_crl_distribution_points "crlDistributionPoints" +-#define LN_crl_distribution_points "X509v3 CRL Distribution Points" +-#define NID_crl_distribution_points 103 +-#define OBJ_crl_distribution_points OBJ_id_ce,31L +- +-#define SN_certificate_policies "certificatePolicies" +-#define LN_certificate_policies "X509v3 Certificate Policies" +-#define NID_certificate_policies 89 +-#define OBJ_certificate_policies OBJ_id_ce,32L +- +-#define SN_any_policy "anyPolicy" +-#define LN_any_policy "X509v3 Any Policy" +-#define NID_any_policy 746 +-#define OBJ_any_policy OBJ_certificate_policies,0L +- +-#define SN_policy_mappings "policyMappings" +-#define LN_policy_mappings "X509v3 Policy Mappings" +-#define NID_policy_mappings 747 +-#define OBJ_policy_mappings OBJ_id_ce,33L +- +-#define SN_authority_key_identifier "authorityKeyIdentifier" +-#define LN_authority_key_identifier "X509v3 Authority Key Identifier" +-#define NID_authority_key_identifier 90 +-#define OBJ_authority_key_identifier OBJ_id_ce,35L +- +-#define SN_policy_constraints "policyConstraints" +-#define LN_policy_constraints "X509v3 Policy Constraints" +-#define NID_policy_constraints 401 +-#define OBJ_policy_constraints OBJ_id_ce,36L +- +-#define SN_ext_key_usage "extendedKeyUsage" +-#define LN_ext_key_usage "X509v3 Extended Key Usage" +-#define NID_ext_key_usage 126 +-#define OBJ_ext_key_usage OBJ_id_ce,37L +- +-#define SN_freshest_crl "freshestCRL" +-#define LN_freshest_crl "X509v3 Freshest CRL" +-#define NID_freshest_crl 857 +-#define OBJ_freshest_crl OBJ_id_ce,46L +- +-#define SN_inhibit_any_policy "inhibitAnyPolicy" +-#define LN_inhibit_any_policy "X509v3 Inhibit Any Policy" +-#define NID_inhibit_any_policy 748 +-#define OBJ_inhibit_any_policy OBJ_id_ce,54L +- +-#define SN_target_information "targetInformation" +-#define LN_target_information "X509v3 AC Targeting" +-#define NID_target_information 402 +-#define OBJ_target_information OBJ_id_ce,55L +- +-#define SN_no_rev_avail "noRevAvail" +-#define LN_no_rev_avail "X509v3 No Revocation Available" +-#define NID_no_rev_avail 403 +-#define OBJ_no_rev_avail OBJ_id_ce,56L +- +-#define SN_anyExtendedKeyUsage "anyExtendedKeyUsage" +-#define LN_anyExtendedKeyUsage "Any Extended Key Usage" +-#define NID_anyExtendedKeyUsage 910 +-#define OBJ_anyExtendedKeyUsage OBJ_ext_key_usage,0L +- +-#define SN_netscape "Netscape" +-#define LN_netscape "Netscape Communications Corp." +-#define NID_netscape 57 +-#define OBJ_netscape 2L,16L,840L,1L,113730L +- +-#define SN_netscape_cert_extension "nsCertExt" +-#define LN_netscape_cert_extension "Netscape Certificate Extension" +-#define NID_netscape_cert_extension 58 +-#define OBJ_netscape_cert_extension OBJ_netscape,1L +- +-#define SN_netscape_data_type "nsDataType" +-#define LN_netscape_data_type "Netscape Data Type" +-#define NID_netscape_data_type 59 +-#define OBJ_netscape_data_type OBJ_netscape,2L +- +-#define SN_netscape_cert_type "nsCertType" +-#define LN_netscape_cert_type "Netscape Cert Type" +-#define NID_netscape_cert_type 71 +-#define OBJ_netscape_cert_type OBJ_netscape_cert_extension,1L +- +-#define SN_netscape_base_url "nsBaseUrl" +-#define LN_netscape_base_url "Netscape Base Url" +-#define NID_netscape_base_url 72 +-#define OBJ_netscape_base_url OBJ_netscape_cert_extension,2L +- +-#define SN_netscape_revocation_url "nsRevocationUrl" +-#define LN_netscape_revocation_url "Netscape Revocation Url" +-#define NID_netscape_revocation_url 73 +-#define OBJ_netscape_revocation_url OBJ_netscape_cert_extension,3L +- +-#define SN_netscape_ca_revocation_url "nsCaRevocationUrl" +-#define LN_netscape_ca_revocation_url "Netscape CA Revocation Url" +-#define NID_netscape_ca_revocation_url 74 +-#define OBJ_netscape_ca_revocation_url OBJ_netscape_cert_extension,4L +- +-#define SN_netscape_renewal_url "nsRenewalUrl" +-#define LN_netscape_renewal_url "Netscape Renewal Url" +-#define NID_netscape_renewal_url 75 +-#define OBJ_netscape_renewal_url OBJ_netscape_cert_extension,7L +- +-#define SN_netscape_ca_policy_url "nsCaPolicyUrl" +-#define LN_netscape_ca_policy_url "Netscape CA Policy Url" +-#define NID_netscape_ca_policy_url 76 +-#define OBJ_netscape_ca_policy_url OBJ_netscape_cert_extension,8L +- +-#define SN_netscape_ssl_server_name "nsSslServerName" +-#define LN_netscape_ssl_server_name "Netscape SSL Server Name" +-#define NID_netscape_ssl_server_name 77 +-#define OBJ_netscape_ssl_server_name OBJ_netscape_cert_extension,12L +- +-#define SN_netscape_comment "nsComment" +-#define LN_netscape_comment "Netscape Comment" +-#define NID_netscape_comment 78 +-#define OBJ_netscape_comment OBJ_netscape_cert_extension,13L +- +-#define SN_netscape_cert_sequence "nsCertSequence" +-#define LN_netscape_cert_sequence "Netscape Certificate Sequence" +-#define NID_netscape_cert_sequence 79 +-#define OBJ_netscape_cert_sequence OBJ_netscape_data_type,5L +- +-#define SN_ns_sgc "nsSGC" +-#define LN_ns_sgc "Netscape Server Gated Crypto" +-#define NID_ns_sgc 139 +-#define OBJ_ns_sgc OBJ_netscape,4L,1L +- +-#define SN_org "ORG" +-#define LN_org "org" +-#define NID_org 379 +-#define OBJ_org OBJ_iso,3L +- +-#define SN_dod "DOD" +-#define LN_dod "dod" +-#define NID_dod 380 +-#define OBJ_dod OBJ_org,6L +- +-#define SN_iana "IANA" +-#define LN_iana "iana" +-#define NID_iana 381 +-#define OBJ_iana OBJ_dod,1L +- +-#define OBJ_internet OBJ_iana +- +-#define SN_Directory "directory" +-#define LN_Directory "Directory" +-#define NID_Directory 382 +-#define OBJ_Directory OBJ_internet,1L +- +-#define SN_Management "mgmt" +-#define LN_Management "Management" +-#define NID_Management 383 +-#define OBJ_Management OBJ_internet,2L +- +-#define SN_Experimental "experimental" +-#define LN_Experimental "Experimental" +-#define NID_Experimental 384 +-#define OBJ_Experimental OBJ_internet,3L +- +-#define SN_Private "private" +-#define LN_Private "Private" +-#define NID_Private 385 +-#define OBJ_Private OBJ_internet,4L +- +-#define SN_Security "security" +-#define LN_Security "Security" +-#define NID_Security 386 +-#define OBJ_Security OBJ_internet,5L +- +-#define SN_SNMPv2 "snmpv2" +-#define LN_SNMPv2 "SNMPv2" +-#define NID_SNMPv2 387 +-#define OBJ_SNMPv2 OBJ_internet,6L +- +-#define LN_Mail "Mail" +-#define NID_Mail 388 +-#define OBJ_Mail OBJ_internet,7L +- +-#define SN_Enterprises "enterprises" +-#define LN_Enterprises "Enterprises" +-#define NID_Enterprises 389 +-#define OBJ_Enterprises OBJ_Private,1L +- +-#define SN_dcObject "dcobject" +-#define LN_dcObject "dcObject" +-#define NID_dcObject 390 +-#define OBJ_dcObject OBJ_Enterprises,1466L,344L +- +-#define SN_mime_mhs "mime-mhs" +-#define LN_mime_mhs "MIME MHS" +-#define NID_mime_mhs 504 +-#define OBJ_mime_mhs OBJ_Mail,1L +- +-#define SN_mime_mhs_headings "mime-mhs-headings" +-#define LN_mime_mhs_headings "mime-mhs-headings" +-#define NID_mime_mhs_headings 505 +-#define OBJ_mime_mhs_headings OBJ_mime_mhs,1L +- +-#define SN_mime_mhs_bodies "mime-mhs-bodies" +-#define LN_mime_mhs_bodies "mime-mhs-bodies" +-#define NID_mime_mhs_bodies 506 +-#define OBJ_mime_mhs_bodies OBJ_mime_mhs,2L +- +-#define SN_id_hex_partial_message "id-hex-partial-message" +-#define LN_id_hex_partial_message "id-hex-partial-message" +-#define NID_id_hex_partial_message 507 +-#define OBJ_id_hex_partial_message OBJ_mime_mhs_headings,1L +- +-#define SN_id_hex_multipart_message "id-hex-multipart-message" +-#define LN_id_hex_multipart_message "id-hex-multipart-message" +-#define NID_id_hex_multipart_message 508 +-#define OBJ_id_hex_multipart_message OBJ_mime_mhs_headings,2L +- +-#define SN_zlib_compression "ZLIB" +-#define LN_zlib_compression "zlib compression" +-#define NID_zlib_compression 125 +-#define OBJ_zlib_compression OBJ_id_smime_alg,8L +- +-#define OBJ_csor 2L,16L,840L,1L,101L,3L +- +-#define OBJ_nistAlgorithms OBJ_csor,4L +- +-#define OBJ_aes OBJ_nistAlgorithms,1L +- +-#define SN_aes_128_ecb "AES-128-ECB" +-#define LN_aes_128_ecb "aes-128-ecb" +-#define NID_aes_128_ecb 418 +-#define OBJ_aes_128_ecb OBJ_aes,1L +- +-#define SN_aes_128_cbc "AES-128-CBC" +-#define LN_aes_128_cbc "aes-128-cbc" +-#define NID_aes_128_cbc 419 +-#define OBJ_aes_128_cbc OBJ_aes,2L +- +-#define SN_aes_128_ofb128 "AES-128-OFB" +-#define LN_aes_128_ofb128 "aes-128-ofb" +-#define NID_aes_128_ofb128 420 +-#define OBJ_aes_128_ofb128 OBJ_aes,3L +- +-#define SN_aes_128_cfb128 "AES-128-CFB" +-#define LN_aes_128_cfb128 "aes-128-cfb" +-#define NID_aes_128_cfb128 421 +-#define OBJ_aes_128_cfb128 OBJ_aes,4L +- +-#define SN_id_aes128_wrap "id-aes128-wrap" +-#define NID_id_aes128_wrap 788 +-#define OBJ_id_aes128_wrap OBJ_aes,5L +- +-#define SN_aes_128_gcm "id-aes128-GCM" +-#define LN_aes_128_gcm "aes-128-gcm" +-#define NID_aes_128_gcm 895 +-#define OBJ_aes_128_gcm OBJ_aes,6L +- +-#define SN_aes_128_ccm "id-aes128-CCM" +-#define LN_aes_128_ccm "aes-128-ccm" +-#define NID_aes_128_ccm 896 +-#define OBJ_aes_128_ccm OBJ_aes,7L +- +-#define SN_id_aes128_wrap_pad "id-aes128-wrap-pad" +-#define NID_id_aes128_wrap_pad 897 +-#define OBJ_id_aes128_wrap_pad OBJ_aes,8L +- +-#define SN_aes_192_ecb "AES-192-ECB" +-#define LN_aes_192_ecb "aes-192-ecb" +-#define NID_aes_192_ecb 422 +-#define OBJ_aes_192_ecb OBJ_aes,21L +- +-#define SN_aes_192_cbc "AES-192-CBC" +-#define LN_aes_192_cbc "aes-192-cbc" +-#define NID_aes_192_cbc 423 +-#define OBJ_aes_192_cbc OBJ_aes,22L +- +-#define SN_aes_192_ofb128 "AES-192-OFB" +-#define LN_aes_192_ofb128 "aes-192-ofb" +-#define NID_aes_192_ofb128 424 +-#define OBJ_aes_192_ofb128 OBJ_aes,23L +- +-#define SN_aes_192_cfb128 "AES-192-CFB" +-#define LN_aes_192_cfb128 "aes-192-cfb" +-#define NID_aes_192_cfb128 425 +-#define OBJ_aes_192_cfb128 OBJ_aes,24L +- +-#define SN_id_aes192_wrap "id-aes192-wrap" +-#define NID_id_aes192_wrap 789 +-#define OBJ_id_aes192_wrap OBJ_aes,25L +- +-#define SN_aes_192_gcm "id-aes192-GCM" +-#define LN_aes_192_gcm "aes-192-gcm" +-#define NID_aes_192_gcm 898 +-#define OBJ_aes_192_gcm OBJ_aes,26L +- +-#define SN_aes_192_ccm "id-aes192-CCM" +-#define LN_aes_192_ccm "aes-192-ccm" +-#define NID_aes_192_ccm 899 +-#define OBJ_aes_192_ccm OBJ_aes,27L +- +-#define SN_id_aes192_wrap_pad "id-aes192-wrap-pad" +-#define NID_id_aes192_wrap_pad 900 +-#define OBJ_id_aes192_wrap_pad OBJ_aes,28L +- +-#define SN_aes_256_ecb "AES-256-ECB" +-#define LN_aes_256_ecb "aes-256-ecb" +-#define NID_aes_256_ecb 426 +-#define OBJ_aes_256_ecb OBJ_aes,41L +- +-#define SN_aes_256_cbc "AES-256-CBC" +-#define LN_aes_256_cbc "aes-256-cbc" +-#define NID_aes_256_cbc 427 +-#define OBJ_aes_256_cbc OBJ_aes,42L +- +-#define SN_aes_256_ofb128 "AES-256-OFB" +-#define LN_aes_256_ofb128 "aes-256-ofb" +-#define NID_aes_256_ofb128 428 +-#define OBJ_aes_256_ofb128 OBJ_aes,43L +- +-#define SN_aes_256_cfb128 "AES-256-CFB" +-#define LN_aes_256_cfb128 "aes-256-cfb" +-#define NID_aes_256_cfb128 429 +-#define OBJ_aes_256_cfb128 OBJ_aes,44L +- +-#define SN_id_aes256_wrap "id-aes256-wrap" +-#define NID_id_aes256_wrap 790 +-#define OBJ_id_aes256_wrap OBJ_aes,45L +- +-#define SN_aes_256_gcm "id-aes256-GCM" +-#define LN_aes_256_gcm "aes-256-gcm" +-#define NID_aes_256_gcm 901 +-#define OBJ_aes_256_gcm OBJ_aes,46L +- +-#define SN_aes_256_ccm "id-aes256-CCM" +-#define LN_aes_256_ccm "aes-256-ccm" +-#define NID_aes_256_ccm 902 +-#define OBJ_aes_256_ccm OBJ_aes,47L +- +-#define SN_id_aes256_wrap_pad "id-aes256-wrap-pad" +-#define NID_id_aes256_wrap_pad 903 +-#define OBJ_id_aes256_wrap_pad OBJ_aes,48L +- +-#define SN_aes_128_xts "AES-128-XTS" +-#define LN_aes_128_xts "aes-128-xts" +-#define NID_aes_128_xts 913 +-#define OBJ_aes_128_xts OBJ_ieee_siswg,0L,1L,1L +- +-#define SN_aes_256_xts "AES-256-XTS" +-#define LN_aes_256_xts "aes-256-xts" +-#define NID_aes_256_xts 914 +-#define OBJ_aes_256_xts OBJ_ieee_siswg,0L,1L,2L +- +-#define SN_aes_128_cfb1 "AES-128-CFB1" +-#define LN_aes_128_cfb1 "aes-128-cfb1" +-#define NID_aes_128_cfb1 650 +- +-#define SN_aes_192_cfb1 "AES-192-CFB1" +-#define LN_aes_192_cfb1 "aes-192-cfb1" +-#define NID_aes_192_cfb1 651 +- +-#define SN_aes_256_cfb1 "AES-256-CFB1" +-#define LN_aes_256_cfb1 "aes-256-cfb1" +-#define NID_aes_256_cfb1 652 +- +-#define SN_aes_128_cfb8 "AES-128-CFB8" +-#define LN_aes_128_cfb8 "aes-128-cfb8" +-#define NID_aes_128_cfb8 653 +- +-#define SN_aes_192_cfb8 "AES-192-CFB8" +-#define LN_aes_192_cfb8 "aes-192-cfb8" +-#define NID_aes_192_cfb8 654 +- +-#define SN_aes_256_cfb8 "AES-256-CFB8" +-#define LN_aes_256_cfb8 "aes-256-cfb8" +-#define NID_aes_256_cfb8 655 +- +-#define SN_aes_128_ctr "AES-128-CTR" +-#define LN_aes_128_ctr "aes-128-ctr" +-#define NID_aes_128_ctr 904 +- +-#define SN_aes_192_ctr "AES-192-CTR" +-#define LN_aes_192_ctr "aes-192-ctr" +-#define NID_aes_192_ctr 905 +- +-#define SN_aes_256_ctr "AES-256-CTR" +-#define LN_aes_256_ctr "aes-256-ctr" +-#define NID_aes_256_ctr 906 +- +-#define SN_aes_128_ocb "AES-128-OCB" +-#define LN_aes_128_ocb "aes-128-ocb" +-#define NID_aes_128_ocb 958 +- +-#define SN_aes_192_ocb "AES-192-OCB" +-#define LN_aes_192_ocb "aes-192-ocb" +-#define NID_aes_192_ocb 959 +- +-#define SN_aes_256_ocb "AES-256-OCB" +-#define LN_aes_256_ocb "aes-256-ocb" +-#define NID_aes_256_ocb 960 +- +-#define SN_des_cfb1 "DES-CFB1" +-#define LN_des_cfb1 "des-cfb1" +-#define NID_des_cfb1 656 +- +-#define SN_des_cfb8 "DES-CFB8" +-#define LN_des_cfb8 "des-cfb8" +-#define NID_des_cfb8 657 +- +-#define SN_des_ede3_cfb1 "DES-EDE3-CFB1" +-#define LN_des_ede3_cfb1 "des-ede3-cfb1" +-#define NID_des_ede3_cfb1 658 +- +-#define SN_des_ede3_cfb8 "DES-EDE3-CFB8" +-#define LN_des_ede3_cfb8 "des-ede3-cfb8" +-#define NID_des_ede3_cfb8 659 +- +-#define OBJ_nist_hashalgs OBJ_nistAlgorithms,2L +- +-#define SN_sha256 "SHA256" +-#define LN_sha256 "sha256" +-#define NID_sha256 672 +-#define OBJ_sha256 OBJ_nist_hashalgs,1L +- +-#define SN_sha384 "SHA384" +-#define LN_sha384 "sha384" +-#define NID_sha384 673 +-#define OBJ_sha384 OBJ_nist_hashalgs,2L +- +-#define SN_sha512 "SHA512" +-#define LN_sha512 "sha512" +-#define NID_sha512 674 +-#define OBJ_sha512 OBJ_nist_hashalgs,3L +- +-#define SN_sha224 "SHA224" +-#define LN_sha224 "sha224" +-#define NID_sha224 675 +-#define OBJ_sha224 OBJ_nist_hashalgs,4L +- +-#define SN_sha512_224 "SHA512-224" +-#define LN_sha512_224 "sha512-224" +-#define NID_sha512_224 1094 +-#define OBJ_sha512_224 OBJ_nist_hashalgs,5L +- +-#define SN_sha512_256 "SHA512-256" +-#define LN_sha512_256 "sha512-256" +-#define NID_sha512_256 1095 +-#define OBJ_sha512_256 OBJ_nist_hashalgs,6L +- +-#define SN_sha3_224 "SHA3-224" +-#define LN_sha3_224 "sha3-224" +-#define NID_sha3_224 1096 +-#define OBJ_sha3_224 OBJ_nist_hashalgs,7L +- +-#define SN_sha3_256 "SHA3-256" +-#define LN_sha3_256 "sha3-256" +-#define NID_sha3_256 1097 +-#define OBJ_sha3_256 OBJ_nist_hashalgs,8L +- +-#define SN_sha3_384 "SHA3-384" +-#define LN_sha3_384 "sha3-384" +-#define NID_sha3_384 1098 +-#define OBJ_sha3_384 OBJ_nist_hashalgs,9L +- +-#define SN_sha3_512 "SHA3-512" +-#define LN_sha3_512 "sha3-512" +-#define NID_sha3_512 1099 +-#define OBJ_sha3_512 OBJ_nist_hashalgs,10L +- +-#define SN_shake128 "SHAKE128" +-#define LN_shake128 "shake128" +-#define NID_shake128 1100 +-#define OBJ_shake128 OBJ_nist_hashalgs,11L +- +-#define SN_shake256 "SHAKE256" +-#define LN_shake256 "shake256" +-#define NID_shake256 1101 +-#define OBJ_shake256 OBJ_nist_hashalgs,12L +- +-#define SN_hmac_sha3_224 "id-hmacWithSHA3-224" +-#define LN_hmac_sha3_224 "hmac-sha3-224" +-#define NID_hmac_sha3_224 1102 +-#define OBJ_hmac_sha3_224 OBJ_nist_hashalgs,13L +- +-#define SN_hmac_sha3_256 "id-hmacWithSHA3-256" +-#define LN_hmac_sha3_256 "hmac-sha3-256" +-#define NID_hmac_sha3_256 1103 +-#define OBJ_hmac_sha3_256 OBJ_nist_hashalgs,14L +- +-#define SN_hmac_sha3_384 "id-hmacWithSHA3-384" +-#define LN_hmac_sha3_384 "hmac-sha3-384" +-#define NID_hmac_sha3_384 1104 +-#define OBJ_hmac_sha3_384 OBJ_nist_hashalgs,15L +- +-#define SN_hmac_sha3_512 "id-hmacWithSHA3-512" +-#define LN_hmac_sha3_512 "hmac-sha3-512" +-#define NID_hmac_sha3_512 1105 +-#define OBJ_hmac_sha3_512 OBJ_nist_hashalgs,16L +- +-#define OBJ_dsa_with_sha2 OBJ_nistAlgorithms,3L +- +-#define SN_dsa_with_SHA224 "dsa_with_SHA224" +-#define NID_dsa_with_SHA224 802 +-#define OBJ_dsa_with_SHA224 OBJ_dsa_with_sha2,1L +- +-#define SN_dsa_with_SHA256 "dsa_with_SHA256" +-#define NID_dsa_with_SHA256 803 +-#define OBJ_dsa_with_SHA256 OBJ_dsa_with_sha2,2L +- +-#define OBJ_sigAlgs OBJ_nistAlgorithms,3L +- +-#define SN_dsa_with_SHA384 "id-dsa-with-sha384" +-#define LN_dsa_with_SHA384 "dsa_with_SHA384" +-#define NID_dsa_with_SHA384 1106 +-#define OBJ_dsa_with_SHA384 OBJ_sigAlgs,3L +- +-#define SN_dsa_with_SHA512 "id-dsa-with-sha512" +-#define LN_dsa_with_SHA512 "dsa_with_SHA512" +-#define NID_dsa_with_SHA512 1107 +-#define OBJ_dsa_with_SHA512 OBJ_sigAlgs,4L +- +-#define SN_dsa_with_SHA3_224 "id-dsa-with-sha3-224" +-#define LN_dsa_with_SHA3_224 "dsa_with_SHA3-224" +-#define NID_dsa_with_SHA3_224 1108 +-#define OBJ_dsa_with_SHA3_224 OBJ_sigAlgs,5L +- +-#define SN_dsa_with_SHA3_256 "id-dsa-with-sha3-256" +-#define LN_dsa_with_SHA3_256 "dsa_with_SHA3-256" +-#define NID_dsa_with_SHA3_256 1109 +-#define OBJ_dsa_with_SHA3_256 OBJ_sigAlgs,6L +- +-#define SN_dsa_with_SHA3_384 "id-dsa-with-sha3-384" +-#define LN_dsa_with_SHA3_384 "dsa_with_SHA3-384" +-#define NID_dsa_with_SHA3_384 1110 +-#define OBJ_dsa_with_SHA3_384 OBJ_sigAlgs,7L +- +-#define SN_dsa_with_SHA3_512 "id-dsa-with-sha3-512" +-#define LN_dsa_with_SHA3_512 "dsa_with_SHA3-512" +-#define NID_dsa_with_SHA3_512 1111 +-#define OBJ_dsa_with_SHA3_512 OBJ_sigAlgs,8L +- +-#define SN_ecdsa_with_SHA3_224 "id-ecdsa-with-sha3-224" +-#define LN_ecdsa_with_SHA3_224 "ecdsa_with_SHA3-224" +-#define NID_ecdsa_with_SHA3_224 1112 +-#define OBJ_ecdsa_with_SHA3_224 OBJ_sigAlgs,9L +- +-#define SN_ecdsa_with_SHA3_256 "id-ecdsa-with-sha3-256" +-#define LN_ecdsa_with_SHA3_256 "ecdsa_with_SHA3-256" +-#define NID_ecdsa_with_SHA3_256 1113 +-#define OBJ_ecdsa_with_SHA3_256 OBJ_sigAlgs,10L +- +-#define SN_ecdsa_with_SHA3_384 "id-ecdsa-with-sha3-384" +-#define LN_ecdsa_with_SHA3_384 "ecdsa_with_SHA3-384" +-#define NID_ecdsa_with_SHA3_384 1114 +-#define OBJ_ecdsa_with_SHA3_384 OBJ_sigAlgs,11L +- +-#define SN_ecdsa_with_SHA3_512 "id-ecdsa-with-sha3-512" +-#define LN_ecdsa_with_SHA3_512 "ecdsa_with_SHA3-512" +-#define NID_ecdsa_with_SHA3_512 1115 +-#define OBJ_ecdsa_with_SHA3_512 OBJ_sigAlgs,12L +- +-#define SN_RSA_SHA3_224 "id-rsassa-pkcs1-v1_5-with-sha3-224" +-#define LN_RSA_SHA3_224 "RSA-SHA3-224" +-#define NID_RSA_SHA3_224 1116 +-#define OBJ_RSA_SHA3_224 OBJ_sigAlgs,13L +- +-#define SN_RSA_SHA3_256 "id-rsassa-pkcs1-v1_5-with-sha3-256" +-#define LN_RSA_SHA3_256 "RSA-SHA3-256" +-#define NID_RSA_SHA3_256 1117 +-#define OBJ_RSA_SHA3_256 OBJ_sigAlgs,14L +- +-#define SN_RSA_SHA3_384 "id-rsassa-pkcs1-v1_5-with-sha3-384" +-#define LN_RSA_SHA3_384 "RSA-SHA3-384" +-#define NID_RSA_SHA3_384 1118 +-#define OBJ_RSA_SHA3_384 OBJ_sigAlgs,15L +- +-#define SN_RSA_SHA3_512 "id-rsassa-pkcs1-v1_5-with-sha3-512" +-#define LN_RSA_SHA3_512 "RSA-SHA3-512" +-#define NID_RSA_SHA3_512 1119 +-#define OBJ_RSA_SHA3_512 OBJ_sigAlgs,16L +- +-#define SN_hold_instruction_code "holdInstructionCode" +-#define LN_hold_instruction_code "Hold Instruction Code" +-#define NID_hold_instruction_code 430 +-#define OBJ_hold_instruction_code OBJ_id_ce,23L +- +-#define OBJ_holdInstruction OBJ_X9_57,2L +- +-#define SN_hold_instruction_none "holdInstructionNone" +-#define LN_hold_instruction_none "Hold Instruction None" +-#define NID_hold_instruction_none 431 +-#define OBJ_hold_instruction_none OBJ_holdInstruction,1L +- +-#define SN_hold_instruction_call_issuer "holdInstructionCallIssuer" +-#define LN_hold_instruction_call_issuer "Hold Instruction Call Issuer" +-#define NID_hold_instruction_call_issuer 432 +-#define OBJ_hold_instruction_call_issuer OBJ_holdInstruction,2L +- +-#define SN_hold_instruction_reject "holdInstructionReject" +-#define LN_hold_instruction_reject "Hold Instruction Reject" +-#define NID_hold_instruction_reject 433 +-#define OBJ_hold_instruction_reject OBJ_holdInstruction,3L +- +-#define SN_data "data" +-#define NID_data 434 +-#define OBJ_data OBJ_itu_t,9L +- +-#define SN_pss "pss" +-#define NID_pss 435 +-#define OBJ_pss OBJ_data,2342L +- +-#define SN_ucl "ucl" +-#define NID_ucl 436 +-#define OBJ_ucl OBJ_pss,19200300L +- +-#define SN_pilot "pilot" +-#define NID_pilot 437 +-#define OBJ_pilot OBJ_ucl,100L +- +-#define LN_pilotAttributeType "pilotAttributeType" +-#define NID_pilotAttributeType 438 +-#define OBJ_pilotAttributeType OBJ_pilot,1L +- +-#define LN_pilotAttributeSyntax "pilotAttributeSyntax" +-#define NID_pilotAttributeSyntax 439 +-#define OBJ_pilotAttributeSyntax OBJ_pilot,3L +- +-#define LN_pilotObjectClass "pilotObjectClass" +-#define NID_pilotObjectClass 440 +-#define OBJ_pilotObjectClass OBJ_pilot,4L +- +-#define LN_pilotGroups "pilotGroups" +-#define NID_pilotGroups 441 +-#define OBJ_pilotGroups OBJ_pilot,10L +- +-#define LN_iA5StringSyntax "iA5StringSyntax" +-#define NID_iA5StringSyntax 442 +-#define OBJ_iA5StringSyntax OBJ_pilotAttributeSyntax,4L +- +-#define LN_caseIgnoreIA5StringSyntax "caseIgnoreIA5StringSyntax" +-#define NID_caseIgnoreIA5StringSyntax 443 +-#define OBJ_caseIgnoreIA5StringSyntax OBJ_pilotAttributeSyntax,5L +- +-#define LN_pilotObject "pilotObject" +-#define NID_pilotObject 444 +-#define OBJ_pilotObject OBJ_pilotObjectClass,3L +- +-#define LN_pilotPerson "pilotPerson" +-#define NID_pilotPerson 445 +-#define OBJ_pilotPerson OBJ_pilotObjectClass,4L +- +-#define SN_account "account" +-#define NID_account 446 +-#define OBJ_account OBJ_pilotObjectClass,5L +- +-#define SN_document "document" +-#define NID_document 447 +-#define OBJ_document OBJ_pilotObjectClass,6L +- +-#define SN_room "room" +-#define NID_room 448 +-#define OBJ_room OBJ_pilotObjectClass,7L +- +-#define LN_documentSeries "documentSeries" +-#define NID_documentSeries 449 +-#define OBJ_documentSeries OBJ_pilotObjectClass,9L +- +-#define SN_Domain "domain" +-#define LN_Domain "Domain" +-#define NID_Domain 392 +-#define OBJ_Domain OBJ_pilotObjectClass,13L +- +-#define LN_rFC822localPart "rFC822localPart" +-#define NID_rFC822localPart 450 +-#define OBJ_rFC822localPart OBJ_pilotObjectClass,14L +- +-#define LN_dNSDomain "dNSDomain" +-#define NID_dNSDomain 451 +-#define OBJ_dNSDomain OBJ_pilotObjectClass,15L +- +-#define LN_domainRelatedObject "domainRelatedObject" +-#define NID_domainRelatedObject 452 +-#define OBJ_domainRelatedObject OBJ_pilotObjectClass,17L +- +-#define LN_friendlyCountry "friendlyCountry" +-#define NID_friendlyCountry 453 +-#define OBJ_friendlyCountry OBJ_pilotObjectClass,18L +- +-#define LN_simpleSecurityObject "simpleSecurityObject" +-#define NID_simpleSecurityObject 454 +-#define OBJ_simpleSecurityObject OBJ_pilotObjectClass,19L +- +-#define LN_pilotOrganization "pilotOrganization" +-#define NID_pilotOrganization 455 +-#define OBJ_pilotOrganization OBJ_pilotObjectClass,20L +- +-#define LN_pilotDSA "pilotDSA" +-#define NID_pilotDSA 456 +-#define OBJ_pilotDSA OBJ_pilotObjectClass,21L +- +-#define LN_qualityLabelledData "qualityLabelledData" +-#define NID_qualityLabelledData 457 +-#define OBJ_qualityLabelledData OBJ_pilotObjectClass,22L +- +-#define SN_userId "UID" +-#define LN_userId "userId" +-#define NID_userId 458 +-#define OBJ_userId OBJ_pilotAttributeType,1L +- +-#define LN_textEncodedORAddress "textEncodedORAddress" +-#define NID_textEncodedORAddress 459 +-#define OBJ_textEncodedORAddress OBJ_pilotAttributeType,2L +- +-#define SN_rfc822Mailbox "mail" +-#define LN_rfc822Mailbox "rfc822Mailbox" +-#define NID_rfc822Mailbox 460 +-#define OBJ_rfc822Mailbox OBJ_pilotAttributeType,3L +- +-#define SN_info "info" +-#define NID_info 461 +-#define OBJ_info OBJ_pilotAttributeType,4L +- +-#define LN_favouriteDrink "favouriteDrink" +-#define NID_favouriteDrink 462 +-#define OBJ_favouriteDrink OBJ_pilotAttributeType,5L +- +-#define LN_roomNumber "roomNumber" +-#define NID_roomNumber 463 +-#define OBJ_roomNumber OBJ_pilotAttributeType,6L +- +-#define SN_photo "photo" +-#define NID_photo 464 +-#define OBJ_photo OBJ_pilotAttributeType,7L +- +-#define LN_userClass "userClass" +-#define NID_userClass 465 +-#define OBJ_userClass OBJ_pilotAttributeType,8L +- +-#define SN_host "host" +-#define NID_host 466 +-#define OBJ_host OBJ_pilotAttributeType,9L +- +-#define SN_manager "manager" +-#define NID_manager 467 +-#define OBJ_manager OBJ_pilotAttributeType,10L +- +-#define LN_documentIdentifier "documentIdentifier" +-#define NID_documentIdentifier 468 +-#define OBJ_documentIdentifier OBJ_pilotAttributeType,11L +- +-#define LN_documentTitle "documentTitle" +-#define NID_documentTitle 469 +-#define OBJ_documentTitle OBJ_pilotAttributeType,12L +- +-#define LN_documentVersion "documentVersion" +-#define NID_documentVersion 470 +-#define OBJ_documentVersion OBJ_pilotAttributeType,13L +- +-#define LN_documentAuthor "documentAuthor" +-#define NID_documentAuthor 471 +-#define OBJ_documentAuthor OBJ_pilotAttributeType,14L +- +-#define LN_documentLocation "documentLocation" +-#define NID_documentLocation 472 +-#define OBJ_documentLocation OBJ_pilotAttributeType,15L +- +-#define LN_homeTelephoneNumber "homeTelephoneNumber" +-#define NID_homeTelephoneNumber 473 +-#define OBJ_homeTelephoneNumber OBJ_pilotAttributeType,20L +- +-#define SN_secretary "secretary" +-#define NID_secretary 474 +-#define OBJ_secretary OBJ_pilotAttributeType,21L +- +-#define LN_otherMailbox "otherMailbox" +-#define NID_otherMailbox 475 +-#define OBJ_otherMailbox OBJ_pilotAttributeType,22L +- +-#define LN_lastModifiedTime "lastModifiedTime" +-#define NID_lastModifiedTime 476 +-#define OBJ_lastModifiedTime OBJ_pilotAttributeType,23L +- +-#define LN_lastModifiedBy "lastModifiedBy" +-#define NID_lastModifiedBy 477 +-#define OBJ_lastModifiedBy OBJ_pilotAttributeType,24L +- +-#define SN_domainComponent "DC" +-#define LN_domainComponent "domainComponent" +-#define NID_domainComponent 391 +-#define OBJ_domainComponent OBJ_pilotAttributeType,25L +- +-#define LN_aRecord "aRecord" +-#define NID_aRecord 478 +-#define OBJ_aRecord OBJ_pilotAttributeType,26L +- +-#define LN_pilotAttributeType27 "pilotAttributeType27" +-#define NID_pilotAttributeType27 479 +-#define OBJ_pilotAttributeType27 OBJ_pilotAttributeType,27L +- +-#define LN_mXRecord "mXRecord" +-#define NID_mXRecord 480 +-#define OBJ_mXRecord OBJ_pilotAttributeType,28L +- +-#define LN_nSRecord "nSRecord" +-#define NID_nSRecord 481 +-#define OBJ_nSRecord OBJ_pilotAttributeType,29L +- +-#define LN_sOARecord "sOARecord" +-#define NID_sOARecord 482 +-#define OBJ_sOARecord OBJ_pilotAttributeType,30L +- +-#define LN_cNAMERecord "cNAMERecord" +-#define NID_cNAMERecord 483 +-#define OBJ_cNAMERecord OBJ_pilotAttributeType,31L +- +-#define LN_associatedDomain "associatedDomain" +-#define NID_associatedDomain 484 +-#define OBJ_associatedDomain OBJ_pilotAttributeType,37L +- +-#define LN_associatedName "associatedName" +-#define NID_associatedName 485 +-#define OBJ_associatedName OBJ_pilotAttributeType,38L +- +-#define LN_homePostalAddress "homePostalAddress" +-#define NID_homePostalAddress 486 +-#define OBJ_homePostalAddress OBJ_pilotAttributeType,39L +- +-#define LN_personalTitle "personalTitle" +-#define NID_personalTitle 487 +-#define OBJ_personalTitle OBJ_pilotAttributeType,40L +- +-#define LN_mobileTelephoneNumber "mobileTelephoneNumber" +-#define NID_mobileTelephoneNumber 488 +-#define OBJ_mobileTelephoneNumber OBJ_pilotAttributeType,41L +- +-#define LN_pagerTelephoneNumber "pagerTelephoneNumber" +-#define NID_pagerTelephoneNumber 489 +-#define OBJ_pagerTelephoneNumber OBJ_pilotAttributeType,42L +- +-#define LN_friendlyCountryName "friendlyCountryName" +-#define NID_friendlyCountryName 490 +-#define OBJ_friendlyCountryName OBJ_pilotAttributeType,43L +- +-#define SN_uniqueIdentifier "uid" +-#define LN_uniqueIdentifier "uniqueIdentifier" +-#define NID_uniqueIdentifier 102 +-#define OBJ_uniqueIdentifier OBJ_pilotAttributeType,44L +- +-#define LN_organizationalStatus "organizationalStatus" +-#define NID_organizationalStatus 491 +-#define OBJ_organizationalStatus OBJ_pilotAttributeType,45L +- +-#define LN_janetMailbox "janetMailbox" +-#define NID_janetMailbox 492 +-#define OBJ_janetMailbox OBJ_pilotAttributeType,46L +- +-#define LN_mailPreferenceOption "mailPreferenceOption" +-#define NID_mailPreferenceOption 493 +-#define OBJ_mailPreferenceOption OBJ_pilotAttributeType,47L +- +-#define LN_buildingName "buildingName" +-#define NID_buildingName 494 +-#define OBJ_buildingName OBJ_pilotAttributeType,48L +- +-#define LN_dSAQuality "dSAQuality" +-#define NID_dSAQuality 495 +-#define OBJ_dSAQuality OBJ_pilotAttributeType,49L +- +-#define LN_singleLevelQuality "singleLevelQuality" +-#define NID_singleLevelQuality 496 +-#define OBJ_singleLevelQuality OBJ_pilotAttributeType,50L +- +-#define LN_subtreeMinimumQuality "subtreeMinimumQuality" +-#define NID_subtreeMinimumQuality 497 +-#define OBJ_subtreeMinimumQuality OBJ_pilotAttributeType,51L +- +-#define LN_subtreeMaximumQuality "subtreeMaximumQuality" +-#define NID_subtreeMaximumQuality 498 +-#define OBJ_subtreeMaximumQuality OBJ_pilotAttributeType,52L +- +-#define LN_personalSignature "personalSignature" +-#define NID_personalSignature 499 +-#define OBJ_personalSignature OBJ_pilotAttributeType,53L +- +-#define LN_dITRedirect "dITRedirect" +-#define NID_dITRedirect 500 +-#define OBJ_dITRedirect OBJ_pilotAttributeType,54L +- +-#define SN_audio "audio" +-#define NID_audio 501 +-#define OBJ_audio OBJ_pilotAttributeType,55L +- +-#define LN_documentPublisher "documentPublisher" +-#define NID_documentPublisher 502 +-#define OBJ_documentPublisher OBJ_pilotAttributeType,56L +- +-#define SN_id_set "id-set" +-#define LN_id_set "Secure Electronic Transactions" +-#define NID_id_set 512 +-#define OBJ_id_set OBJ_international_organizations,42L +- +-#define SN_set_ctype "set-ctype" +-#define LN_set_ctype "content types" +-#define NID_set_ctype 513 +-#define OBJ_set_ctype OBJ_id_set,0L +- +-#define SN_set_msgExt "set-msgExt" +-#define LN_set_msgExt "message extensions" +-#define NID_set_msgExt 514 +-#define OBJ_set_msgExt OBJ_id_set,1L +- +-#define SN_set_attr "set-attr" +-#define NID_set_attr 515 +-#define OBJ_set_attr OBJ_id_set,3L +- +-#define SN_set_policy "set-policy" +-#define NID_set_policy 516 +-#define OBJ_set_policy OBJ_id_set,5L +- +-#define SN_set_certExt "set-certExt" +-#define LN_set_certExt "certificate extensions" +-#define NID_set_certExt 517 +-#define OBJ_set_certExt OBJ_id_set,7L +- +-#define SN_set_brand "set-brand" +-#define NID_set_brand 518 +-#define OBJ_set_brand OBJ_id_set,8L +- +-#define SN_setct_PANData "setct-PANData" +-#define NID_setct_PANData 519 +-#define OBJ_setct_PANData OBJ_set_ctype,0L +- +-#define SN_setct_PANToken "setct-PANToken" +-#define NID_setct_PANToken 520 +-#define OBJ_setct_PANToken OBJ_set_ctype,1L +- +-#define SN_setct_PANOnly "setct-PANOnly" +-#define NID_setct_PANOnly 521 +-#define OBJ_setct_PANOnly OBJ_set_ctype,2L +- +-#define SN_setct_OIData "setct-OIData" +-#define NID_setct_OIData 522 +-#define OBJ_setct_OIData OBJ_set_ctype,3L +- +-#define SN_setct_PI "setct-PI" +-#define NID_setct_PI 523 +-#define OBJ_setct_PI OBJ_set_ctype,4L +- +-#define SN_setct_PIData "setct-PIData" +-#define NID_setct_PIData 524 +-#define OBJ_setct_PIData OBJ_set_ctype,5L +- +-#define SN_setct_PIDataUnsigned "setct-PIDataUnsigned" +-#define NID_setct_PIDataUnsigned 525 +-#define OBJ_setct_PIDataUnsigned OBJ_set_ctype,6L +- +-#define SN_setct_HODInput "setct-HODInput" +-#define NID_setct_HODInput 526 +-#define OBJ_setct_HODInput OBJ_set_ctype,7L +- +-#define SN_setct_AuthResBaggage "setct-AuthResBaggage" +-#define NID_setct_AuthResBaggage 527 +-#define OBJ_setct_AuthResBaggage OBJ_set_ctype,8L +- +-#define SN_setct_AuthRevReqBaggage "setct-AuthRevReqBaggage" +-#define NID_setct_AuthRevReqBaggage 528 +-#define OBJ_setct_AuthRevReqBaggage OBJ_set_ctype,9L +- +-#define SN_setct_AuthRevResBaggage "setct-AuthRevResBaggage" +-#define NID_setct_AuthRevResBaggage 529 +-#define OBJ_setct_AuthRevResBaggage OBJ_set_ctype,10L +- +-#define SN_setct_CapTokenSeq "setct-CapTokenSeq" +-#define NID_setct_CapTokenSeq 530 +-#define OBJ_setct_CapTokenSeq OBJ_set_ctype,11L +- +-#define SN_setct_PInitResData "setct-PInitResData" +-#define NID_setct_PInitResData 531 +-#define OBJ_setct_PInitResData OBJ_set_ctype,12L +- +-#define SN_setct_PI_TBS "setct-PI-TBS" +-#define NID_setct_PI_TBS 532 +-#define OBJ_setct_PI_TBS OBJ_set_ctype,13L +- +-#define SN_setct_PResData "setct-PResData" +-#define NID_setct_PResData 533 +-#define OBJ_setct_PResData OBJ_set_ctype,14L +- +-#define SN_setct_AuthReqTBS "setct-AuthReqTBS" +-#define NID_setct_AuthReqTBS 534 +-#define OBJ_setct_AuthReqTBS OBJ_set_ctype,16L +- +-#define SN_setct_AuthResTBS "setct-AuthResTBS" +-#define NID_setct_AuthResTBS 535 +-#define OBJ_setct_AuthResTBS OBJ_set_ctype,17L +- +-#define SN_setct_AuthResTBSX "setct-AuthResTBSX" +-#define NID_setct_AuthResTBSX 536 +-#define OBJ_setct_AuthResTBSX OBJ_set_ctype,18L +- +-#define SN_setct_AuthTokenTBS "setct-AuthTokenTBS" +-#define NID_setct_AuthTokenTBS 537 +-#define OBJ_setct_AuthTokenTBS OBJ_set_ctype,19L +- +-#define SN_setct_CapTokenData "setct-CapTokenData" +-#define NID_setct_CapTokenData 538 +-#define OBJ_setct_CapTokenData OBJ_set_ctype,20L +- +-#define SN_setct_CapTokenTBS "setct-CapTokenTBS" +-#define NID_setct_CapTokenTBS 539 +-#define OBJ_setct_CapTokenTBS OBJ_set_ctype,21L +- +-#define SN_setct_AcqCardCodeMsg "setct-AcqCardCodeMsg" +-#define NID_setct_AcqCardCodeMsg 540 +-#define OBJ_setct_AcqCardCodeMsg OBJ_set_ctype,22L +- +-#define SN_setct_AuthRevReqTBS "setct-AuthRevReqTBS" +-#define NID_setct_AuthRevReqTBS 541 +-#define OBJ_setct_AuthRevReqTBS OBJ_set_ctype,23L +- +-#define SN_setct_AuthRevResData "setct-AuthRevResData" +-#define NID_setct_AuthRevResData 542 +-#define OBJ_setct_AuthRevResData OBJ_set_ctype,24L +- +-#define SN_setct_AuthRevResTBS "setct-AuthRevResTBS" +-#define NID_setct_AuthRevResTBS 543 +-#define OBJ_setct_AuthRevResTBS OBJ_set_ctype,25L +- +-#define SN_setct_CapReqTBS "setct-CapReqTBS" +-#define NID_setct_CapReqTBS 544 +-#define OBJ_setct_CapReqTBS OBJ_set_ctype,26L +- +-#define SN_setct_CapReqTBSX "setct-CapReqTBSX" +-#define NID_setct_CapReqTBSX 545 +-#define OBJ_setct_CapReqTBSX OBJ_set_ctype,27L +- +-#define SN_setct_CapResData "setct-CapResData" +-#define NID_setct_CapResData 546 +-#define OBJ_setct_CapResData OBJ_set_ctype,28L +- +-#define SN_setct_CapRevReqTBS "setct-CapRevReqTBS" +-#define NID_setct_CapRevReqTBS 547 +-#define OBJ_setct_CapRevReqTBS OBJ_set_ctype,29L +- +-#define SN_setct_CapRevReqTBSX "setct-CapRevReqTBSX" +-#define NID_setct_CapRevReqTBSX 548 +-#define OBJ_setct_CapRevReqTBSX OBJ_set_ctype,30L +- +-#define SN_setct_CapRevResData "setct-CapRevResData" +-#define NID_setct_CapRevResData 549 +-#define OBJ_setct_CapRevResData OBJ_set_ctype,31L +- +-#define SN_setct_CredReqTBS "setct-CredReqTBS" +-#define NID_setct_CredReqTBS 550 +-#define OBJ_setct_CredReqTBS OBJ_set_ctype,32L +- +-#define SN_setct_CredReqTBSX "setct-CredReqTBSX" +-#define NID_setct_CredReqTBSX 551 +-#define OBJ_setct_CredReqTBSX OBJ_set_ctype,33L +- +-#define SN_setct_CredResData "setct-CredResData" +-#define NID_setct_CredResData 552 +-#define OBJ_setct_CredResData OBJ_set_ctype,34L +- +-#define SN_setct_CredRevReqTBS "setct-CredRevReqTBS" +-#define NID_setct_CredRevReqTBS 553 +-#define OBJ_setct_CredRevReqTBS OBJ_set_ctype,35L +- +-#define SN_setct_CredRevReqTBSX "setct-CredRevReqTBSX" +-#define NID_setct_CredRevReqTBSX 554 +-#define OBJ_setct_CredRevReqTBSX OBJ_set_ctype,36L +- +-#define SN_setct_CredRevResData "setct-CredRevResData" +-#define NID_setct_CredRevResData 555 +-#define OBJ_setct_CredRevResData OBJ_set_ctype,37L +- +-#define SN_setct_PCertReqData "setct-PCertReqData" +-#define NID_setct_PCertReqData 556 +-#define OBJ_setct_PCertReqData OBJ_set_ctype,38L +- +-#define SN_setct_PCertResTBS "setct-PCertResTBS" +-#define NID_setct_PCertResTBS 557 +-#define OBJ_setct_PCertResTBS OBJ_set_ctype,39L +- +-#define SN_setct_BatchAdminReqData "setct-BatchAdminReqData" +-#define NID_setct_BatchAdminReqData 558 +-#define OBJ_setct_BatchAdminReqData OBJ_set_ctype,40L +- +-#define SN_setct_BatchAdminResData "setct-BatchAdminResData" +-#define NID_setct_BatchAdminResData 559 +-#define OBJ_setct_BatchAdminResData OBJ_set_ctype,41L +- +-#define SN_setct_CardCInitResTBS "setct-CardCInitResTBS" +-#define NID_setct_CardCInitResTBS 560 +-#define OBJ_setct_CardCInitResTBS OBJ_set_ctype,42L +- +-#define SN_setct_MeAqCInitResTBS "setct-MeAqCInitResTBS" +-#define NID_setct_MeAqCInitResTBS 561 +-#define OBJ_setct_MeAqCInitResTBS OBJ_set_ctype,43L +- +-#define SN_setct_RegFormResTBS "setct-RegFormResTBS" +-#define NID_setct_RegFormResTBS 562 +-#define OBJ_setct_RegFormResTBS OBJ_set_ctype,44L +- +-#define SN_setct_CertReqData "setct-CertReqData" +-#define NID_setct_CertReqData 563 +-#define OBJ_setct_CertReqData OBJ_set_ctype,45L +- +-#define SN_setct_CertReqTBS "setct-CertReqTBS" +-#define NID_setct_CertReqTBS 564 +-#define OBJ_setct_CertReqTBS OBJ_set_ctype,46L +- +-#define SN_setct_CertResData "setct-CertResData" +-#define NID_setct_CertResData 565 +-#define OBJ_setct_CertResData OBJ_set_ctype,47L +- +-#define SN_setct_CertInqReqTBS "setct-CertInqReqTBS" +-#define NID_setct_CertInqReqTBS 566 +-#define OBJ_setct_CertInqReqTBS OBJ_set_ctype,48L +- +-#define SN_setct_ErrorTBS "setct-ErrorTBS" +-#define NID_setct_ErrorTBS 567 +-#define OBJ_setct_ErrorTBS OBJ_set_ctype,49L +- +-#define SN_setct_PIDualSignedTBE "setct-PIDualSignedTBE" +-#define NID_setct_PIDualSignedTBE 568 +-#define OBJ_setct_PIDualSignedTBE OBJ_set_ctype,50L +- +-#define SN_setct_PIUnsignedTBE "setct-PIUnsignedTBE" +-#define NID_setct_PIUnsignedTBE 569 +-#define OBJ_setct_PIUnsignedTBE OBJ_set_ctype,51L +- +-#define SN_setct_AuthReqTBE "setct-AuthReqTBE" +-#define NID_setct_AuthReqTBE 570 +-#define OBJ_setct_AuthReqTBE OBJ_set_ctype,52L +- +-#define SN_setct_AuthResTBE "setct-AuthResTBE" +-#define NID_setct_AuthResTBE 571 +-#define OBJ_setct_AuthResTBE OBJ_set_ctype,53L +- +-#define SN_setct_AuthResTBEX "setct-AuthResTBEX" +-#define NID_setct_AuthResTBEX 572 +-#define OBJ_setct_AuthResTBEX OBJ_set_ctype,54L +- +-#define SN_setct_AuthTokenTBE "setct-AuthTokenTBE" +-#define NID_setct_AuthTokenTBE 573 +-#define OBJ_setct_AuthTokenTBE OBJ_set_ctype,55L +- +-#define SN_setct_CapTokenTBE "setct-CapTokenTBE" +-#define NID_setct_CapTokenTBE 574 +-#define OBJ_setct_CapTokenTBE OBJ_set_ctype,56L +- +-#define SN_setct_CapTokenTBEX "setct-CapTokenTBEX" +-#define NID_setct_CapTokenTBEX 575 +-#define OBJ_setct_CapTokenTBEX OBJ_set_ctype,57L +- +-#define SN_setct_AcqCardCodeMsgTBE "setct-AcqCardCodeMsgTBE" +-#define NID_setct_AcqCardCodeMsgTBE 576 +-#define OBJ_setct_AcqCardCodeMsgTBE OBJ_set_ctype,58L +- +-#define SN_setct_AuthRevReqTBE "setct-AuthRevReqTBE" +-#define NID_setct_AuthRevReqTBE 577 +-#define OBJ_setct_AuthRevReqTBE OBJ_set_ctype,59L +- +-#define SN_setct_AuthRevResTBE "setct-AuthRevResTBE" +-#define NID_setct_AuthRevResTBE 578 +-#define OBJ_setct_AuthRevResTBE OBJ_set_ctype,60L +- +-#define SN_setct_AuthRevResTBEB "setct-AuthRevResTBEB" +-#define NID_setct_AuthRevResTBEB 579 +-#define OBJ_setct_AuthRevResTBEB OBJ_set_ctype,61L +- +-#define SN_setct_CapReqTBE "setct-CapReqTBE" +-#define NID_setct_CapReqTBE 580 +-#define OBJ_setct_CapReqTBE OBJ_set_ctype,62L +- +-#define SN_setct_CapReqTBEX "setct-CapReqTBEX" +-#define NID_setct_CapReqTBEX 581 +-#define OBJ_setct_CapReqTBEX OBJ_set_ctype,63L +- +-#define SN_setct_CapResTBE "setct-CapResTBE" +-#define NID_setct_CapResTBE 582 +-#define OBJ_setct_CapResTBE OBJ_set_ctype,64L +- +-#define SN_setct_CapRevReqTBE "setct-CapRevReqTBE" +-#define NID_setct_CapRevReqTBE 583 +-#define OBJ_setct_CapRevReqTBE OBJ_set_ctype,65L +- +-#define SN_setct_CapRevReqTBEX "setct-CapRevReqTBEX" +-#define NID_setct_CapRevReqTBEX 584 +-#define OBJ_setct_CapRevReqTBEX OBJ_set_ctype,66L +- +-#define SN_setct_CapRevResTBE "setct-CapRevResTBE" +-#define NID_setct_CapRevResTBE 585 +-#define OBJ_setct_CapRevResTBE OBJ_set_ctype,67L +- +-#define SN_setct_CredReqTBE "setct-CredReqTBE" +-#define NID_setct_CredReqTBE 586 +-#define OBJ_setct_CredReqTBE OBJ_set_ctype,68L +- +-#define SN_setct_CredReqTBEX "setct-CredReqTBEX" +-#define NID_setct_CredReqTBEX 587 +-#define OBJ_setct_CredReqTBEX OBJ_set_ctype,69L +- +-#define SN_setct_CredResTBE "setct-CredResTBE" +-#define NID_setct_CredResTBE 588 +-#define OBJ_setct_CredResTBE OBJ_set_ctype,70L +- +-#define SN_setct_CredRevReqTBE "setct-CredRevReqTBE" +-#define NID_setct_CredRevReqTBE 589 +-#define OBJ_setct_CredRevReqTBE OBJ_set_ctype,71L +- +-#define SN_setct_CredRevReqTBEX "setct-CredRevReqTBEX" +-#define NID_setct_CredRevReqTBEX 590 +-#define OBJ_setct_CredRevReqTBEX OBJ_set_ctype,72L +- +-#define SN_setct_CredRevResTBE "setct-CredRevResTBE" +-#define NID_setct_CredRevResTBE 591 +-#define OBJ_setct_CredRevResTBE OBJ_set_ctype,73L +- +-#define SN_setct_BatchAdminReqTBE "setct-BatchAdminReqTBE" +-#define NID_setct_BatchAdminReqTBE 592 +-#define OBJ_setct_BatchAdminReqTBE OBJ_set_ctype,74L +- +-#define SN_setct_BatchAdminResTBE "setct-BatchAdminResTBE" +-#define NID_setct_BatchAdminResTBE 593 +-#define OBJ_setct_BatchAdminResTBE OBJ_set_ctype,75L +- +-#define SN_setct_RegFormReqTBE "setct-RegFormReqTBE" +-#define NID_setct_RegFormReqTBE 594 +-#define OBJ_setct_RegFormReqTBE OBJ_set_ctype,76L +- +-#define SN_setct_CertReqTBE "setct-CertReqTBE" +-#define NID_setct_CertReqTBE 595 +-#define OBJ_setct_CertReqTBE OBJ_set_ctype,77L +- +-#define SN_setct_CertReqTBEX "setct-CertReqTBEX" +-#define NID_setct_CertReqTBEX 596 +-#define OBJ_setct_CertReqTBEX OBJ_set_ctype,78L +- +-#define SN_setct_CertResTBE "setct-CertResTBE" +-#define NID_setct_CertResTBE 597 +-#define OBJ_setct_CertResTBE OBJ_set_ctype,79L +- +-#define SN_setct_CRLNotificationTBS "setct-CRLNotificationTBS" +-#define NID_setct_CRLNotificationTBS 598 +-#define OBJ_setct_CRLNotificationTBS OBJ_set_ctype,80L +- +-#define SN_setct_CRLNotificationResTBS "setct-CRLNotificationResTBS" +-#define NID_setct_CRLNotificationResTBS 599 +-#define OBJ_setct_CRLNotificationResTBS OBJ_set_ctype,81L +- +-#define SN_setct_BCIDistributionTBS "setct-BCIDistributionTBS" +-#define NID_setct_BCIDistributionTBS 600 +-#define OBJ_setct_BCIDistributionTBS OBJ_set_ctype,82L +- +-#define SN_setext_genCrypt "setext-genCrypt" +-#define LN_setext_genCrypt "generic cryptogram" +-#define NID_setext_genCrypt 601 +-#define OBJ_setext_genCrypt OBJ_set_msgExt,1L +- +-#define SN_setext_miAuth "setext-miAuth" +-#define LN_setext_miAuth "merchant initiated auth" +-#define NID_setext_miAuth 602 +-#define OBJ_setext_miAuth OBJ_set_msgExt,3L +- +-#define SN_setext_pinSecure "setext-pinSecure" +-#define NID_setext_pinSecure 603 +-#define OBJ_setext_pinSecure OBJ_set_msgExt,4L +- +-#define SN_setext_pinAny "setext-pinAny" +-#define NID_setext_pinAny 604 +-#define OBJ_setext_pinAny OBJ_set_msgExt,5L +- +-#define SN_setext_track2 "setext-track2" +-#define NID_setext_track2 605 +-#define OBJ_setext_track2 OBJ_set_msgExt,7L +- +-#define SN_setext_cv "setext-cv" +-#define LN_setext_cv "additional verification" +-#define NID_setext_cv 606 +-#define OBJ_setext_cv OBJ_set_msgExt,8L +- +-#define SN_set_policy_root "set-policy-root" +-#define NID_set_policy_root 607 +-#define OBJ_set_policy_root OBJ_set_policy,0L +- +-#define SN_setCext_hashedRoot "setCext-hashedRoot" +-#define NID_setCext_hashedRoot 608 +-#define OBJ_setCext_hashedRoot OBJ_set_certExt,0L +- +-#define SN_setCext_certType "setCext-certType" +-#define NID_setCext_certType 609 +-#define OBJ_setCext_certType OBJ_set_certExt,1L +- +-#define SN_setCext_merchData "setCext-merchData" +-#define NID_setCext_merchData 610 +-#define OBJ_setCext_merchData OBJ_set_certExt,2L +- +-#define SN_setCext_cCertRequired "setCext-cCertRequired" +-#define NID_setCext_cCertRequired 611 +-#define OBJ_setCext_cCertRequired OBJ_set_certExt,3L +- +-#define SN_setCext_tunneling "setCext-tunneling" +-#define NID_setCext_tunneling 612 +-#define OBJ_setCext_tunneling OBJ_set_certExt,4L +- +-#define SN_setCext_setExt "setCext-setExt" +-#define NID_setCext_setExt 613 +-#define OBJ_setCext_setExt OBJ_set_certExt,5L +- +-#define SN_setCext_setQualf "setCext-setQualf" +-#define NID_setCext_setQualf 614 +-#define OBJ_setCext_setQualf OBJ_set_certExt,6L +- +-#define SN_setCext_PGWYcapabilities "setCext-PGWYcapabilities" +-#define NID_setCext_PGWYcapabilities 615 +-#define OBJ_setCext_PGWYcapabilities OBJ_set_certExt,7L +- +-#define SN_setCext_TokenIdentifier "setCext-TokenIdentifier" +-#define NID_setCext_TokenIdentifier 616 +-#define OBJ_setCext_TokenIdentifier OBJ_set_certExt,8L +- +-#define SN_setCext_Track2Data "setCext-Track2Data" +-#define NID_setCext_Track2Data 617 +-#define OBJ_setCext_Track2Data OBJ_set_certExt,9L +- +-#define SN_setCext_TokenType "setCext-TokenType" +-#define NID_setCext_TokenType 618 +-#define OBJ_setCext_TokenType OBJ_set_certExt,10L +- +-#define SN_setCext_IssuerCapabilities "setCext-IssuerCapabilities" +-#define NID_setCext_IssuerCapabilities 619 +-#define OBJ_setCext_IssuerCapabilities OBJ_set_certExt,11L +- +-#define SN_setAttr_Cert "setAttr-Cert" +-#define NID_setAttr_Cert 620 +-#define OBJ_setAttr_Cert OBJ_set_attr,0L +- +-#define SN_setAttr_PGWYcap "setAttr-PGWYcap" +-#define LN_setAttr_PGWYcap "payment gateway capabilities" +-#define NID_setAttr_PGWYcap 621 +-#define OBJ_setAttr_PGWYcap OBJ_set_attr,1L +- +-#define SN_setAttr_TokenType "setAttr-TokenType" +-#define NID_setAttr_TokenType 622 +-#define OBJ_setAttr_TokenType OBJ_set_attr,2L +- +-#define SN_setAttr_IssCap "setAttr-IssCap" +-#define LN_setAttr_IssCap "issuer capabilities" +-#define NID_setAttr_IssCap 623 +-#define OBJ_setAttr_IssCap OBJ_set_attr,3L +- +-#define SN_set_rootKeyThumb "set-rootKeyThumb" +-#define NID_set_rootKeyThumb 624 +-#define OBJ_set_rootKeyThumb OBJ_setAttr_Cert,0L +- +-#define SN_set_addPolicy "set-addPolicy" +-#define NID_set_addPolicy 625 +-#define OBJ_set_addPolicy OBJ_setAttr_Cert,1L +- +-#define SN_setAttr_Token_EMV "setAttr-Token-EMV" +-#define NID_setAttr_Token_EMV 626 +-#define OBJ_setAttr_Token_EMV OBJ_setAttr_TokenType,1L +- +-#define SN_setAttr_Token_B0Prime "setAttr-Token-B0Prime" +-#define NID_setAttr_Token_B0Prime 627 +-#define OBJ_setAttr_Token_B0Prime OBJ_setAttr_TokenType,2L +- +-#define SN_setAttr_IssCap_CVM "setAttr-IssCap-CVM" +-#define NID_setAttr_IssCap_CVM 628 +-#define OBJ_setAttr_IssCap_CVM OBJ_setAttr_IssCap,3L +- +-#define SN_setAttr_IssCap_T2 "setAttr-IssCap-T2" +-#define NID_setAttr_IssCap_T2 629 +-#define OBJ_setAttr_IssCap_T2 OBJ_setAttr_IssCap,4L +- +-#define SN_setAttr_IssCap_Sig "setAttr-IssCap-Sig" +-#define NID_setAttr_IssCap_Sig 630 +-#define OBJ_setAttr_IssCap_Sig OBJ_setAttr_IssCap,5L +- +-#define SN_setAttr_GenCryptgrm "setAttr-GenCryptgrm" +-#define LN_setAttr_GenCryptgrm "generate cryptogram" +-#define NID_setAttr_GenCryptgrm 631 +-#define OBJ_setAttr_GenCryptgrm OBJ_setAttr_IssCap_CVM,1L +- +-#define SN_setAttr_T2Enc "setAttr-T2Enc" +-#define LN_setAttr_T2Enc "encrypted track 2" +-#define NID_setAttr_T2Enc 632 +-#define OBJ_setAttr_T2Enc OBJ_setAttr_IssCap_T2,1L +- +-#define SN_setAttr_T2cleartxt "setAttr-T2cleartxt" +-#define LN_setAttr_T2cleartxt "cleartext track 2" +-#define NID_setAttr_T2cleartxt 633 +-#define OBJ_setAttr_T2cleartxt OBJ_setAttr_IssCap_T2,2L +- +-#define SN_setAttr_TokICCsig "setAttr-TokICCsig" +-#define LN_setAttr_TokICCsig "ICC or token signature" +-#define NID_setAttr_TokICCsig 634 +-#define OBJ_setAttr_TokICCsig OBJ_setAttr_IssCap_Sig,1L +- +-#define SN_setAttr_SecDevSig "setAttr-SecDevSig" +-#define LN_setAttr_SecDevSig "secure device signature" +-#define NID_setAttr_SecDevSig 635 +-#define OBJ_setAttr_SecDevSig OBJ_setAttr_IssCap_Sig,2L +- +-#define SN_set_brand_IATA_ATA "set-brand-IATA-ATA" +-#define NID_set_brand_IATA_ATA 636 +-#define OBJ_set_brand_IATA_ATA OBJ_set_brand,1L +- +-#define SN_set_brand_Diners "set-brand-Diners" +-#define NID_set_brand_Diners 637 +-#define OBJ_set_brand_Diners OBJ_set_brand,30L +- +-#define SN_set_brand_AmericanExpress "set-brand-AmericanExpress" +-#define NID_set_brand_AmericanExpress 638 +-#define OBJ_set_brand_AmericanExpress OBJ_set_brand,34L +- +-#define SN_set_brand_JCB "set-brand-JCB" +-#define NID_set_brand_JCB 639 +-#define OBJ_set_brand_JCB OBJ_set_brand,35L +- +-#define SN_set_brand_Visa "set-brand-Visa" +-#define NID_set_brand_Visa 640 +-#define OBJ_set_brand_Visa OBJ_set_brand,4L +- +-#define SN_set_brand_MasterCard "set-brand-MasterCard" +-#define NID_set_brand_MasterCard 641 +-#define OBJ_set_brand_MasterCard OBJ_set_brand,5L +- +-#define SN_set_brand_Novus "set-brand-Novus" +-#define NID_set_brand_Novus 642 +-#define OBJ_set_brand_Novus OBJ_set_brand,6011L +- +-#define SN_des_cdmf "DES-CDMF" +-#define LN_des_cdmf "des-cdmf" +-#define NID_des_cdmf 643 +-#define OBJ_des_cdmf OBJ_rsadsi,3L,10L +- +-#define SN_rsaOAEPEncryptionSET "rsaOAEPEncryptionSET" +-#define NID_rsaOAEPEncryptionSET 644 +-#define OBJ_rsaOAEPEncryptionSET OBJ_rsadsi,1L,1L,6L +- +-#define SN_ipsec3 "Oakley-EC2N-3" +-#define LN_ipsec3 "ipsec3" +-#define NID_ipsec3 749 +- +-#define SN_ipsec4 "Oakley-EC2N-4" +-#define LN_ipsec4 "ipsec4" +-#define NID_ipsec4 750 +- +-#define SN_whirlpool "whirlpool" +-#define NID_whirlpool 804 +-#define OBJ_whirlpool OBJ_iso,0L,10118L,3L,0L,55L +- +-#define SN_cryptopro "cryptopro" +-#define NID_cryptopro 805 +-#define OBJ_cryptopro OBJ_member_body,643L,2L,2L +- +-#define SN_cryptocom "cryptocom" +-#define NID_cryptocom 806 +-#define OBJ_cryptocom OBJ_member_body,643L,2L,9L +- +-#define SN_id_tc26 "id-tc26" +-#define NID_id_tc26 974 +-#define OBJ_id_tc26 OBJ_member_body,643L,7L,1L +- +-#define SN_id_GostR3411_94_with_GostR3410_2001 "id-GostR3411-94-with-GostR3410-2001" +-#define LN_id_GostR3411_94_with_GostR3410_2001 "GOST R 34.11-94 with GOST R 34.10-2001" +-#define NID_id_GostR3411_94_with_GostR3410_2001 807 +-#define OBJ_id_GostR3411_94_with_GostR3410_2001 OBJ_cryptopro,3L +- +-#define SN_id_GostR3411_94_with_GostR3410_94 "id-GostR3411-94-with-GostR3410-94" +-#define LN_id_GostR3411_94_with_GostR3410_94 "GOST R 34.11-94 with GOST R 34.10-94" +-#define NID_id_GostR3411_94_with_GostR3410_94 808 +-#define OBJ_id_GostR3411_94_with_GostR3410_94 OBJ_cryptopro,4L +- +-#define SN_id_GostR3411_94 "md_gost94" +-#define LN_id_GostR3411_94 "GOST R 34.11-94" +-#define NID_id_GostR3411_94 809 +-#define OBJ_id_GostR3411_94 OBJ_cryptopro,9L +- +-#define SN_id_HMACGostR3411_94 "id-HMACGostR3411-94" +-#define LN_id_HMACGostR3411_94 "HMAC GOST 34.11-94" +-#define NID_id_HMACGostR3411_94 810 +-#define OBJ_id_HMACGostR3411_94 OBJ_cryptopro,10L +- +-#define SN_id_GostR3410_2001 "gost2001" +-#define LN_id_GostR3410_2001 "GOST R 34.10-2001" +-#define NID_id_GostR3410_2001 811 +-#define OBJ_id_GostR3410_2001 OBJ_cryptopro,19L +- +-#define SN_id_GostR3410_94 "gost94" +-#define LN_id_GostR3410_94 "GOST R 34.10-94" +-#define NID_id_GostR3410_94 812 +-#define OBJ_id_GostR3410_94 OBJ_cryptopro,20L +- +-#define SN_id_Gost28147_89 "gost89" +-#define LN_id_Gost28147_89 "GOST 28147-89" +-#define NID_id_Gost28147_89 813 +-#define OBJ_id_Gost28147_89 OBJ_cryptopro,21L +- +-#define SN_gost89_cnt "gost89-cnt" +-#define NID_gost89_cnt 814 +- +-#define SN_gost89_cnt_12 "gost89-cnt-12" +-#define NID_gost89_cnt_12 975 +- +-#define SN_gost89_cbc "gost89-cbc" +-#define NID_gost89_cbc 1009 +- +-#define SN_gost89_ecb "gost89-ecb" +-#define NID_gost89_ecb 1010 +- +-#define SN_gost89_ctr "gost89-ctr" +-#define NID_gost89_ctr 1011 +- +-#define SN_id_Gost28147_89_MAC "gost-mac" +-#define LN_id_Gost28147_89_MAC "GOST 28147-89 MAC" +-#define NID_id_Gost28147_89_MAC 815 +-#define OBJ_id_Gost28147_89_MAC OBJ_cryptopro,22L +- +-#define SN_gost_mac_12 "gost-mac-12" +-#define NID_gost_mac_12 976 +- +-#define SN_id_GostR3411_94_prf "prf-gostr3411-94" +-#define LN_id_GostR3411_94_prf "GOST R 34.11-94 PRF" +-#define NID_id_GostR3411_94_prf 816 +-#define OBJ_id_GostR3411_94_prf OBJ_cryptopro,23L +- +-#define SN_id_GostR3410_2001DH "id-GostR3410-2001DH" +-#define LN_id_GostR3410_2001DH "GOST R 34.10-2001 DH" +-#define NID_id_GostR3410_2001DH 817 +-#define OBJ_id_GostR3410_2001DH OBJ_cryptopro,98L +- +-#define SN_id_GostR3410_94DH "id-GostR3410-94DH" +-#define LN_id_GostR3410_94DH "GOST R 34.10-94 DH" +-#define NID_id_GostR3410_94DH 818 +-#define OBJ_id_GostR3410_94DH OBJ_cryptopro,99L +- +-#define SN_id_Gost28147_89_CryptoPro_KeyMeshing "id-Gost28147-89-CryptoPro-KeyMeshing" +-#define NID_id_Gost28147_89_CryptoPro_KeyMeshing 819 +-#define OBJ_id_Gost28147_89_CryptoPro_KeyMeshing OBJ_cryptopro,14L,1L +- +-#define SN_id_Gost28147_89_None_KeyMeshing "id-Gost28147-89-None-KeyMeshing" +-#define NID_id_Gost28147_89_None_KeyMeshing 820 +-#define OBJ_id_Gost28147_89_None_KeyMeshing OBJ_cryptopro,14L,0L +- +-#define SN_id_GostR3411_94_TestParamSet "id-GostR3411-94-TestParamSet" +-#define NID_id_GostR3411_94_TestParamSet 821 +-#define OBJ_id_GostR3411_94_TestParamSet OBJ_cryptopro,30L,0L +- +-#define SN_id_GostR3411_94_CryptoProParamSet "id-GostR3411-94-CryptoProParamSet" +-#define NID_id_GostR3411_94_CryptoProParamSet 822 +-#define OBJ_id_GostR3411_94_CryptoProParamSet OBJ_cryptopro,30L,1L +- +-#define SN_id_Gost28147_89_TestParamSet "id-Gost28147-89-TestParamSet" +-#define NID_id_Gost28147_89_TestParamSet 823 +-#define OBJ_id_Gost28147_89_TestParamSet OBJ_cryptopro,31L,0L +- +-#define SN_id_Gost28147_89_CryptoPro_A_ParamSet "id-Gost28147-89-CryptoPro-A-ParamSet" +-#define NID_id_Gost28147_89_CryptoPro_A_ParamSet 824 +-#define OBJ_id_Gost28147_89_CryptoPro_A_ParamSet OBJ_cryptopro,31L,1L +- +-#define SN_id_Gost28147_89_CryptoPro_B_ParamSet "id-Gost28147-89-CryptoPro-B-ParamSet" +-#define NID_id_Gost28147_89_CryptoPro_B_ParamSet 825 +-#define OBJ_id_Gost28147_89_CryptoPro_B_ParamSet OBJ_cryptopro,31L,2L +- +-#define SN_id_Gost28147_89_CryptoPro_C_ParamSet "id-Gost28147-89-CryptoPro-C-ParamSet" +-#define NID_id_Gost28147_89_CryptoPro_C_ParamSet 826 +-#define OBJ_id_Gost28147_89_CryptoPro_C_ParamSet OBJ_cryptopro,31L,3L +- +-#define SN_id_Gost28147_89_CryptoPro_D_ParamSet "id-Gost28147-89-CryptoPro-D-ParamSet" +-#define NID_id_Gost28147_89_CryptoPro_D_ParamSet 827 +-#define OBJ_id_Gost28147_89_CryptoPro_D_ParamSet OBJ_cryptopro,31L,4L +- +-#define SN_id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSet "id-Gost28147-89-CryptoPro-Oscar-1-1-ParamSet" +-#define NID_id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSet 828 +-#define OBJ_id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSet OBJ_cryptopro,31L,5L +- +-#define SN_id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSet "id-Gost28147-89-CryptoPro-Oscar-1-0-ParamSet" +-#define NID_id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSet 829 +-#define OBJ_id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSet OBJ_cryptopro,31L,6L +- +-#define SN_id_Gost28147_89_CryptoPro_RIC_1_ParamSet "id-Gost28147-89-CryptoPro-RIC-1-ParamSet" +-#define NID_id_Gost28147_89_CryptoPro_RIC_1_ParamSet 830 +-#define OBJ_id_Gost28147_89_CryptoPro_RIC_1_ParamSet OBJ_cryptopro,31L,7L +- +-#define SN_id_GostR3410_94_TestParamSet "id-GostR3410-94-TestParamSet" +-#define NID_id_GostR3410_94_TestParamSet 831 +-#define OBJ_id_GostR3410_94_TestParamSet OBJ_cryptopro,32L,0L +- +-#define SN_id_GostR3410_94_CryptoPro_A_ParamSet "id-GostR3410-94-CryptoPro-A-ParamSet" +-#define NID_id_GostR3410_94_CryptoPro_A_ParamSet 832 +-#define OBJ_id_GostR3410_94_CryptoPro_A_ParamSet OBJ_cryptopro,32L,2L +- +-#define SN_id_GostR3410_94_CryptoPro_B_ParamSet "id-GostR3410-94-CryptoPro-B-ParamSet" +-#define NID_id_GostR3410_94_CryptoPro_B_ParamSet 833 +-#define OBJ_id_GostR3410_94_CryptoPro_B_ParamSet OBJ_cryptopro,32L,3L +- +-#define SN_id_GostR3410_94_CryptoPro_C_ParamSet "id-GostR3410-94-CryptoPro-C-ParamSet" +-#define NID_id_GostR3410_94_CryptoPro_C_ParamSet 834 +-#define OBJ_id_GostR3410_94_CryptoPro_C_ParamSet OBJ_cryptopro,32L,4L +- +-#define SN_id_GostR3410_94_CryptoPro_D_ParamSet "id-GostR3410-94-CryptoPro-D-ParamSet" +-#define NID_id_GostR3410_94_CryptoPro_D_ParamSet 835 +-#define OBJ_id_GostR3410_94_CryptoPro_D_ParamSet OBJ_cryptopro,32L,5L +- +-#define SN_id_GostR3410_94_CryptoPro_XchA_ParamSet "id-GostR3410-94-CryptoPro-XchA-ParamSet" +-#define NID_id_GostR3410_94_CryptoPro_XchA_ParamSet 836 +-#define OBJ_id_GostR3410_94_CryptoPro_XchA_ParamSet OBJ_cryptopro,33L,1L +- +-#define SN_id_GostR3410_94_CryptoPro_XchB_ParamSet "id-GostR3410-94-CryptoPro-XchB-ParamSet" +-#define NID_id_GostR3410_94_CryptoPro_XchB_ParamSet 837 +-#define OBJ_id_GostR3410_94_CryptoPro_XchB_ParamSet OBJ_cryptopro,33L,2L +- +-#define SN_id_GostR3410_94_CryptoPro_XchC_ParamSet "id-GostR3410-94-CryptoPro-XchC-ParamSet" +-#define NID_id_GostR3410_94_CryptoPro_XchC_ParamSet 838 +-#define OBJ_id_GostR3410_94_CryptoPro_XchC_ParamSet OBJ_cryptopro,33L,3L +- +-#define SN_id_GostR3410_2001_TestParamSet "id-GostR3410-2001-TestParamSet" +-#define NID_id_GostR3410_2001_TestParamSet 839 +-#define OBJ_id_GostR3410_2001_TestParamSet OBJ_cryptopro,35L,0L +- +-#define SN_id_GostR3410_2001_CryptoPro_A_ParamSet "id-GostR3410-2001-CryptoPro-A-ParamSet" +-#define NID_id_GostR3410_2001_CryptoPro_A_ParamSet 840 +-#define OBJ_id_GostR3410_2001_CryptoPro_A_ParamSet OBJ_cryptopro,35L,1L +- +-#define SN_id_GostR3410_2001_CryptoPro_B_ParamSet "id-GostR3410-2001-CryptoPro-B-ParamSet" +-#define NID_id_GostR3410_2001_CryptoPro_B_ParamSet 841 +-#define OBJ_id_GostR3410_2001_CryptoPro_B_ParamSet OBJ_cryptopro,35L,2L +- +-#define SN_id_GostR3410_2001_CryptoPro_C_ParamSet "id-GostR3410-2001-CryptoPro-C-ParamSet" +-#define NID_id_GostR3410_2001_CryptoPro_C_ParamSet 842 +-#define OBJ_id_GostR3410_2001_CryptoPro_C_ParamSet OBJ_cryptopro,35L,3L +- +-#define SN_id_GostR3410_2001_CryptoPro_XchA_ParamSet "id-GostR3410-2001-CryptoPro-XchA-ParamSet" +-#define NID_id_GostR3410_2001_CryptoPro_XchA_ParamSet 843 +-#define OBJ_id_GostR3410_2001_CryptoPro_XchA_ParamSet OBJ_cryptopro,36L,0L +- +-#define SN_id_GostR3410_2001_CryptoPro_XchB_ParamSet "id-GostR3410-2001-CryptoPro-XchB-ParamSet" +-#define NID_id_GostR3410_2001_CryptoPro_XchB_ParamSet 844 +-#define OBJ_id_GostR3410_2001_CryptoPro_XchB_ParamSet OBJ_cryptopro,36L,1L +- +-#define SN_id_GostR3410_94_a "id-GostR3410-94-a" +-#define NID_id_GostR3410_94_a 845 +-#define OBJ_id_GostR3410_94_a OBJ_id_GostR3410_94,1L +- +-#define SN_id_GostR3410_94_aBis "id-GostR3410-94-aBis" +-#define NID_id_GostR3410_94_aBis 846 +-#define OBJ_id_GostR3410_94_aBis OBJ_id_GostR3410_94,2L +- +-#define SN_id_GostR3410_94_b "id-GostR3410-94-b" +-#define NID_id_GostR3410_94_b 847 +-#define OBJ_id_GostR3410_94_b OBJ_id_GostR3410_94,3L +- +-#define SN_id_GostR3410_94_bBis "id-GostR3410-94-bBis" +-#define NID_id_GostR3410_94_bBis 848 +-#define OBJ_id_GostR3410_94_bBis OBJ_id_GostR3410_94,4L +- +-#define SN_id_Gost28147_89_cc "id-Gost28147-89-cc" +-#define LN_id_Gost28147_89_cc "GOST 28147-89 Cryptocom ParamSet" +-#define NID_id_Gost28147_89_cc 849 +-#define OBJ_id_Gost28147_89_cc OBJ_cryptocom,1L,6L,1L +- +-#define SN_id_GostR3410_94_cc "gost94cc" +-#define LN_id_GostR3410_94_cc "GOST 34.10-94 Cryptocom" +-#define NID_id_GostR3410_94_cc 850 +-#define OBJ_id_GostR3410_94_cc OBJ_cryptocom,1L,5L,3L +- +-#define SN_id_GostR3410_2001_cc "gost2001cc" +-#define LN_id_GostR3410_2001_cc "GOST 34.10-2001 Cryptocom" +-#define NID_id_GostR3410_2001_cc 851 +-#define OBJ_id_GostR3410_2001_cc OBJ_cryptocom,1L,5L,4L +- +-#define SN_id_GostR3411_94_with_GostR3410_94_cc "id-GostR3411-94-with-GostR3410-94-cc" +-#define LN_id_GostR3411_94_with_GostR3410_94_cc "GOST R 34.11-94 with GOST R 34.10-94 Cryptocom" +-#define NID_id_GostR3411_94_with_GostR3410_94_cc 852 +-#define OBJ_id_GostR3411_94_with_GostR3410_94_cc OBJ_cryptocom,1L,3L,3L +- +-#define SN_id_GostR3411_94_with_GostR3410_2001_cc "id-GostR3411-94-with-GostR3410-2001-cc" +-#define LN_id_GostR3411_94_with_GostR3410_2001_cc "GOST R 34.11-94 with GOST R 34.10-2001 Cryptocom" +-#define NID_id_GostR3411_94_with_GostR3410_2001_cc 853 +-#define OBJ_id_GostR3411_94_with_GostR3410_2001_cc OBJ_cryptocom,1L,3L,4L +- +-#define SN_id_GostR3410_2001_ParamSet_cc "id-GostR3410-2001-ParamSet-cc" +-#define LN_id_GostR3410_2001_ParamSet_cc "GOST R 3410-2001 Parameter Set Cryptocom" +-#define NID_id_GostR3410_2001_ParamSet_cc 854 +-#define OBJ_id_GostR3410_2001_ParamSet_cc OBJ_cryptocom,1L,8L,1L +- +-#define SN_id_tc26_algorithms "id-tc26-algorithms" +-#define NID_id_tc26_algorithms 977 +-#define OBJ_id_tc26_algorithms OBJ_id_tc26,1L +- +-#define SN_id_tc26_sign "id-tc26-sign" +-#define NID_id_tc26_sign 978 +-#define OBJ_id_tc26_sign OBJ_id_tc26_algorithms,1L +- +-#define SN_id_GostR3410_2012_256 "gost2012_256" +-#define LN_id_GostR3410_2012_256 "GOST R 34.10-2012 with 256 bit modulus" +-#define NID_id_GostR3410_2012_256 979 +-#define OBJ_id_GostR3410_2012_256 OBJ_id_tc26_sign,1L +- +-#define SN_id_GostR3410_2012_512 "gost2012_512" +-#define LN_id_GostR3410_2012_512 "GOST R 34.10-2012 with 512 bit modulus" +-#define NID_id_GostR3410_2012_512 980 +-#define OBJ_id_GostR3410_2012_512 OBJ_id_tc26_sign,2L +- +-#define SN_id_tc26_digest "id-tc26-digest" +-#define NID_id_tc26_digest 981 +-#define OBJ_id_tc26_digest OBJ_id_tc26_algorithms,2L +- +-#define SN_id_GostR3411_2012_256 "md_gost12_256" +-#define LN_id_GostR3411_2012_256 "GOST R 34.11-2012 with 256 bit hash" +-#define NID_id_GostR3411_2012_256 982 +-#define OBJ_id_GostR3411_2012_256 OBJ_id_tc26_digest,2L +- +-#define SN_id_GostR3411_2012_512 "md_gost12_512" +-#define LN_id_GostR3411_2012_512 "GOST R 34.11-2012 with 512 bit hash" +-#define NID_id_GostR3411_2012_512 983 +-#define OBJ_id_GostR3411_2012_512 OBJ_id_tc26_digest,3L +- +-#define SN_id_tc26_signwithdigest "id-tc26-signwithdigest" +-#define NID_id_tc26_signwithdigest 984 +-#define OBJ_id_tc26_signwithdigest OBJ_id_tc26_algorithms,3L +- +-#define SN_id_tc26_signwithdigest_gost3410_2012_256 "id-tc26-signwithdigest-gost3410-2012-256" +-#define LN_id_tc26_signwithdigest_gost3410_2012_256 "GOST R 34.10-2012 with GOST R 34.11-2012 (256 bit)" +-#define NID_id_tc26_signwithdigest_gost3410_2012_256 985 +-#define OBJ_id_tc26_signwithdigest_gost3410_2012_256 OBJ_id_tc26_signwithdigest,2L +- +-#define SN_id_tc26_signwithdigest_gost3410_2012_512 "id-tc26-signwithdigest-gost3410-2012-512" +-#define LN_id_tc26_signwithdigest_gost3410_2012_512 "GOST R 34.10-2012 with GOST R 34.11-2012 (512 bit)" +-#define NID_id_tc26_signwithdigest_gost3410_2012_512 986 +-#define OBJ_id_tc26_signwithdigest_gost3410_2012_512 OBJ_id_tc26_signwithdigest,3L +- +-#define SN_id_tc26_mac "id-tc26-mac" +-#define NID_id_tc26_mac 987 +-#define OBJ_id_tc26_mac OBJ_id_tc26_algorithms,4L +- +-#define SN_id_tc26_hmac_gost_3411_2012_256 "id-tc26-hmac-gost-3411-2012-256" +-#define LN_id_tc26_hmac_gost_3411_2012_256 "HMAC GOST 34.11-2012 256 bit" +-#define NID_id_tc26_hmac_gost_3411_2012_256 988 +-#define OBJ_id_tc26_hmac_gost_3411_2012_256 OBJ_id_tc26_mac,1L +- +-#define SN_id_tc26_hmac_gost_3411_2012_512 "id-tc26-hmac-gost-3411-2012-512" +-#define LN_id_tc26_hmac_gost_3411_2012_512 "HMAC GOST 34.11-2012 512 bit" +-#define NID_id_tc26_hmac_gost_3411_2012_512 989 +-#define OBJ_id_tc26_hmac_gost_3411_2012_512 OBJ_id_tc26_mac,2L +- +-#define SN_id_tc26_cipher "id-tc26-cipher" +-#define NID_id_tc26_cipher 990 +-#define OBJ_id_tc26_cipher OBJ_id_tc26_algorithms,5L +- +-#define SN_id_tc26_cipher_gostr3412_2015_magma "id-tc26-cipher-gostr3412-2015-magma" +-#define NID_id_tc26_cipher_gostr3412_2015_magma 1173 +-#define OBJ_id_tc26_cipher_gostr3412_2015_magma OBJ_id_tc26_cipher,1L +- +-#define SN_id_tc26_cipher_gostr3412_2015_magma_ctracpkm "id-tc26-cipher-gostr3412-2015-magma-ctracpkm" +-#define NID_id_tc26_cipher_gostr3412_2015_magma_ctracpkm 1174 +-#define OBJ_id_tc26_cipher_gostr3412_2015_magma_ctracpkm OBJ_id_tc26_cipher_gostr3412_2015_magma,1L +- +-#define SN_id_tc26_cipher_gostr3412_2015_magma_ctracpkm_omac "id-tc26-cipher-gostr3412-2015-magma-ctracpkm-omac" +-#define NID_id_tc26_cipher_gostr3412_2015_magma_ctracpkm_omac 1175 +-#define OBJ_id_tc26_cipher_gostr3412_2015_magma_ctracpkm_omac OBJ_id_tc26_cipher_gostr3412_2015_magma,2L +- +-#define SN_id_tc26_cipher_gostr3412_2015_kuznyechik "id-tc26-cipher-gostr3412-2015-kuznyechik" +-#define NID_id_tc26_cipher_gostr3412_2015_kuznyechik 1176 +-#define OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik OBJ_id_tc26_cipher,2L +- +-#define SN_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm "id-tc26-cipher-gostr3412-2015-kuznyechik-ctracpkm" +-#define NID_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm 1177 +-#define OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik,1L +- +-#define SN_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm_omac "id-tc26-cipher-gostr3412-2015-kuznyechik-ctracpkm-omac" +-#define NID_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm_omac 1178 +-#define OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm_omac OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik,2L +- +-#define SN_id_tc26_agreement "id-tc26-agreement" +-#define NID_id_tc26_agreement 991 +-#define OBJ_id_tc26_agreement OBJ_id_tc26_algorithms,6L +- +-#define SN_id_tc26_agreement_gost_3410_2012_256 "id-tc26-agreement-gost-3410-2012-256" +-#define NID_id_tc26_agreement_gost_3410_2012_256 992 +-#define OBJ_id_tc26_agreement_gost_3410_2012_256 OBJ_id_tc26_agreement,1L +- +-#define SN_id_tc26_agreement_gost_3410_2012_512 "id-tc26-agreement-gost-3410-2012-512" +-#define NID_id_tc26_agreement_gost_3410_2012_512 993 +-#define OBJ_id_tc26_agreement_gost_3410_2012_512 OBJ_id_tc26_agreement,2L +- +-#define SN_id_tc26_wrap "id-tc26-wrap" +-#define NID_id_tc26_wrap 1179 +-#define OBJ_id_tc26_wrap OBJ_id_tc26_algorithms,7L +- +-#define SN_id_tc26_wrap_gostr3412_2015_magma "id-tc26-wrap-gostr3412-2015-magma" +-#define NID_id_tc26_wrap_gostr3412_2015_magma 1180 +-#define OBJ_id_tc26_wrap_gostr3412_2015_magma OBJ_id_tc26_wrap,1L +- +-#define SN_id_tc26_wrap_gostr3412_2015_magma_kexp15 "id-tc26-wrap-gostr3412-2015-magma-kexp15" +-#define NID_id_tc26_wrap_gostr3412_2015_magma_kexp15 1181 +-#define OBJ_id_tc26_wrap_gostr3412_2015_magma_kexp15 OBJ_id_tc26_wrap_gostr3412_2015_magma,1L +- +-#define SN_id_tc26_wrap_gostr3412_2015_kuznyechik "id-tc26-wrap-gostr3412-2015-kuznyechik" +-#define NID_id_tc26_wrap_gostr3412_2015_kuznyechik 1182 +-#define OBJ_id_tc26_wrap_gostr3412_2015_kuznyechik OBJ_id_tc26_wrap,2L +- +-#define SN_id_tc26_wrap_gostr3412_2015_kuznyechik_kexp15 "id-tc26-wrap-gostr3412-2015-kuznyechik-kexp15" +-#define NID_id_tc26_wrap_gostr3412_2015_kuznyechik_kexp15 1183 +-#define OBJ_id_tc26_wrap_gostr3412_2015_kuznyechik_kexp15 OBJ_id_tc26_wrap_gostr3412_2015_kuznyechik,1L +- +-#define SN_id_tc26_constants "id-tc26-constants" +-#define NID_id_tc26_constants 994 +-#define OBJ_id_tc26_constants OBJ_id_tc26,2L +- +-#define SN_id_tc26_sign_constants "id-tc26-sign-constants" +-#define NID_id_tc26_sign_constants 995 +-#define OBJ_id_tc26_sign_constants OBJ_id_tc26_constants,1L +- +-#define SN_id_tc26_gost_3410_2012_256_constants "id-tc26-gost-3410-2012-256-constants" +-#define NID_id_tc26_gost_3410_2012_256_constants 1147 +-#define OBJ_id_tc26_gost_3410_2012_256_constants OBJ_id_tc26_sign_constants,1L +- +-#define SN_id_tc26_gost_3410_2012_256_paramSetA "id-tc26-gost-3410-2012-256-paramSetA" +-#define LN_id_tc26_gost_3410_2012_256_paramSetA "GOST R 34.10-2012 (256 bit) ParamSet A" +-#define NID_id_tc26_gost_3410_2012_256_paramSetA 1148 +-#define OBJ_id_tc26_gost_3410_2012_256_paramSetA OBJ_id_tc26_gost_3410_2012_256_constants,1L +- +-#define SN_id_tc26_gost_3410_2012_256_paramSetB "id-tc26-gost-3410-2012-256-paramSetB" +-#define LN_id_tc26_gost_3410_2012_256_paramSetB "GOST R 34.10-2012 (256 bit) ParamSet B" +-#define NID_id_tc26_gost_3410_2012_256_paramSetB 1184 +-#define OBJ_id_tc26_gost_3410_2012_256_paramSetB OBJ_id_tc26_gost_3410_2012_256_constants,2L +- +-#define SN_id_tc26_gost_3410_2012_256_paramSetC "id-tc26-gost-3410-2012-256-paramSetC" +-#define LN_id_tc26_gost_3410_2012_256_paramSetC "GOST R 34.10-2012 (256 bit) ParamSet C" +-#define NID_id_tc26_gost_3410_2012_256_paramSetC 1185 +-#define OBJ_id_tc26_gost_3410_2012_256_paramSetC OBJ_id_tc26_gost_3410_2012_256_constants,3L +- +-#define SN_id_tc26_gost_3410_2012_256_paramSetD "id-tc26-gost-3410-2012-256-paramSetD" +-#define LN_id_tc26_gost_3410_2012_256_paramSetD "GOST R 34.10-2012 (256 bit) ParamSet D" +-#define NID_id_tc26_gost_3410_2012_256_paramSetD 1186 +-#define OBJ_id_tc26_gost_3410_2012_256_paramSetD OBJ_id_tc26_gost_3410_2012_256_constants,4L +- +-#define SN_id_tc26_gost_3410_2012_512_constants "id-tc26-gost-3410-2012-512-constants" +-#define NID_id_tc26_gost_3410_2012_512_constants 996 +-#define OBJ_id_tc26_gost_3410_2012_512_constants OBJ_id_tc26_sign_constants,2L +- +-#define SN_id_tc26_gost_3410_2012_512_paramSetTest "id-tc26-gost-3410-2012-512-paramSetTest" +-#define LN_id_tc26_gost_3410_2012_512_paramSetTest "GOST R 34.10-2012 (512 bit) testing parameter set" +-#define NID_id_tc26_gost_3410_2012_512_paramSetTest 997 +-#define OBJ_id_tc26_gost_3410_2012_512_paramSetTest OBJ_id_tc26_gost_3410_2012_512_constants,0L +- +-#define SN_id_tc26_gost_3410_2012_512_paramSetA "id-tc26-gost-3410-2012-512-paramSetA" +-#define LN_id_tc26_gost_3410_2012_512_paramSetA "GOST R 34.10-2012 (512 bit) ParamSet A" +-#define NID_id_tc26_gost_3410_2012_512_paramSetA 998 +-#define OBJ_id_tc26_gost_3410_2012_512_paramSetA OBJ_id_tc26_gost_3410_2012_512_constants,1L +- +-#define SN_id_tc26_gost_3410_2012_512_paramSetB "id-tc26-gost-3410-2012-512-paramSetB" +-#define LN_id_tc26_gost_3410_2012_512_paramSetB "GOST R 34.10-2012 (512 bit) ParamSet B" +-#define NID_id_tc26_gost_3410_2012_512_paramSetB 999 +-#define OBJ_id_tc26_gost_3410_2012_512_paramSetB OBJ_id_tc26_gost_3410_2012_512_constants,2L +- +-#define SN_id_tc26_gost_3410_2012_512_paramSetC "id-tc26-gost-3410-2012-512-paramSetC" +-#define LN_id_tc26_gost_3410_2012_512_paramSetC "GOST R 34.10-2012 (512 bit) ParamSet C" +-#define NID_id_tc26_gost_3410_2012_512_paramSetC 1149 +-#define OBJ_id_tc26_gost_3410_2012_512_paramSetC OBJ_id_tc26_gost_3410_2012_512_constants,3L +- +-#define SN_id_tc26_digest_constants "id-tc26-digest-constants" +-#define NID_id_tc26_digest_constants 1000 +-#define OBJ_id_tc26_digest_constants OBJ_id_tc26_constants,2L +- +-#define SN_id_tc26_cipher_constants "id-tc26-cipher-constants" +-#define NID_id_tc26_cipher_constants 1001 +-#define OBJ_id_tc26_cipher_constants OBJ_id_tc26_constants,5L +- +-#define SN_id_tc26_gost_28147_constants "id-tc26-gost-28147-constants" +-#define NID_id_tc26_gost_28147_constants 1002 +-#define OBJ_id_tc26_gost_28147_constants OBJ_id_tc26_cipher_constants,1L +- +-#define SN_id_tc26_gost_28147_param_Z "id-tc26-gost-28147-param-Z" +-#define LN_id_tc26_gost_28147_param_Z "GOST 28147-89 TC26 parameter set" +-#define NID_id_tc26_gost_28147_param_Z 1003 +-#define OBJ_id_tc26_gost_28147_param_Z OBJ_id_tc26_gost_28147_constants,1L +- +-#define SN_INN "INN" +-#define LN_INN "INN" +-#define NID_INN 1004 +-#define OBJ_INN OBJ_member_body,643L,3L,131L,1L,1L +- +-#define SN_OGRN "OGRN" +-#define LN_OGRN "OGRN" +-#define NID_OGRN 1005 +-#define OBJ_OGRN OBJ_member_body,643L,100L,1L +- +-#define SN_SNILS "SNILS" +-#define LN_SNILS "SNILS" +-#define NID_SNILS 1006 +-#define OBJ_SNILS OBJ_member_body,643L,100L,3L +- +-#define SN_subjectSignTool "subjectSignTool" +-#define LN_subjectSignTool "Signing Tool of Subject" +-#define NID_subjectSignTool 1007 +-#define OBJ_subjectSignTool OBJ_member_body,643L,100L,111L +- +-#define SN_issuerSignTool "issuerSignTool" +-#define LN_issuerSignTool "Signing Tool of Issuer" +-#define NID_issuerSignTool 1008 +-#define OBJ_issuerSignTool OBJ_member_body,643L,100L,112L +- +-#define SN_grasshopper_ecb "grasshopper-ecb" +-#define NID_grasshopper_ecb 1012 +- +-#define SN_grasshopper_ctr "grasshopper-ctr" +-#define NID_grasshopper_ctr 1013 +- +-#define SN_grasshopper_ofb "grasshopper-ofb" +-#define NID_grasshopper_ofb 1014 +- +-#define SN_grasshopper_cbc "grasshopper-cbc" +-#define NID_grasshopper_cbc 1015 +- +-#define SN_grasshopper_cfb "grasshopper-cfb" +-#define NID_grasshopper_cfb 1016 +- +-#define SN_grasshopper_mac "grasshopper-mac" +-#define NID_grasshopper_mac 1017 +- +-#define SN_magma_ecb "magma-ecb" +-#define NID_magma_ecb 1187 +- +-#define SN_magma_ctr "magma-ctr" +-#define NID_magma_ctr 1188 +- +-#define SN_magma_ofb "magma-ofb" +-#define NID_magma_ofb 1189 +- +-#define SN_magma_cbc "magma-cbc" +-#define NID_magma_cbc 1190 +- +-#define SN_magma_cfb "magma-cfb" +-#define NID_magma_cfb 1191 +- +-#define SN_magma_mac "magma-mac" +-#define NID_magma_mac 1192 +- +-#define SN_camellia_128_cbc "CAMELLIA-128-CBC" +-#define LN_camellia_128_cbc "camellia-128-cbc" +-#define NID_camellia_128_cbc 751 +-#define OBJ_camellia_128_cbc 1L,2L,392L,200011L,61L,1L,1L,1L,2L +- +-#define SN_camellia_192_cbc "CAMELLIA-192-CBC" +-#define LN_camellia_192_cbc "camellia-192-cbc" +-#define NID_camellia_192_cbc 752 +-#define OBJ_camellia_192_cbc 1L,2L,392L,200011L,61L,1L,1L,1L,3L +- +-#define SN_camellia_256_cbc "CAMELLIA-256-CBC" +-#define LN_camellia_256_cbc "camellia-256-cbc" +-#define NID_camellia_256_cbc 753 +-#define OBJ_camellia_256_cbc 1L,2L,392L,200011L,61L,1L,1L,1L,4L +- +-#define SN_id_camellia128_wrap "id-camellia128-wrap" +-#define NID_id_camellia128_wrap 907 +-#define OBJ_id_camellia128_wrap 1L,2L,392L,200011L,61L,1L,1L,3L,2L +- +-#define SN_id_camellia192_wrap "id-camellia192-wrap" +-#define NID_id_camellia192_wrap 908 +-#define OBJ_id_camellia192_wrap 1L,2L,392L,200011L,61L,1L,1L,3L,3L +- +-#define SN_id_camellia256_wrap "id-camellia256-wrap" +-#define NID_id_camellia256_wrap 909 +-#define OBJ_id_camellia256_wrap 1L,2L,392L,200011L,61L,1L,1L,3L,4L +- +-#define OBJ_ntt_ds 0L,3L,4401L,5L +- +-#define OBJ_camellia OBJ_ntt_ds,3L,1L,9L +- +-#define SN_camellia_128_ecb "CAMELLIA-128-ECB" +-#define LN_camellia_128_ecb "camellia-128-ecb" +-#define NID_camellia_128_ecb 754 +-#define OBJ_camellia_128_ecb OBJ_camellia,1L +- +-#define SN_camellia_128_ofb128 "CAMELLIA-128-OFB" +-#define LN_camellia_128_ofb128 "camellia-128-ofb" +-#define NID_camellia_128_ofb128 766 +-#define OBJ_camellia_128_ofb128 OBJ_camellia,3L +- +-#define SN_camellia_128_cfb128 "CAMELLIA-128-CFB" +-#define LN_camellia_128_cfb128 "camellia-128-cfb" +-#define NID_camellia_128_cfb128 757 +-#define OBJ_camellia_128_cfb128 OBJ_camellia,4L +- +-#define SN_camellia_128_gcm "CAMELLIA-128-GCM" +-#define LN_camellia_128_gcm "camellia-128-gcm" +-#define NID_camellia_128_gcm 961 +-#define OBJ_camellia_128_gcm OBJ_camellia,6L +- +-#define SN_camellia_128_ccm "CAMELLIA-128-CCM" +-#define LN_camellia_128_ccm "camellia-128-ccm" +-#define NID_camellia_128_ccm 962 +-#define OBJ_camellia_128_ccm OBJ_camellia,7L +- +-#define SN_camellia_128_ctr "CAMELLIA-128-CTR" +-#define LN_camellia_128_ctr "camellia-128-ctr" +-#define NID_camellia_128_ctr 963 +-#define OBJ_camellia_128_ctr OBJ_camellia,9L +- +-#define SN_camellia_128_cmac "CAMELLIA-128-CMAC" +-#define LN_camellia_128_cmac "camellia-128-cmac" +-#define NID_camellia_128_cmac 964 +-#define OBJ_camellia_128_cmac OBJ_camellia,10L +- +-#define SN_camellia_192_ecb "CAMELLIA-192-ECB" +-#define LN_camellia_192_ecb "camellia-192-ecb" +-#define NID_camellia_192_ecb 755 +-#define OBJ_camellia_192_ecb OBJ_camellia,21L +- +-#define SN_camellia_192_ofb128 "CAMELLIA-192-OFB" +-#define LN_camellia_192_ofb128 "camellia-192-ofb" +-#define NID_camellia_192_ofb128 767 +-#define OBJ_camellia_192_ofb128 OBJ_camellia,23L +- +-#define SN_camellia_192_cfb128 "CAMELLIA-192-CFB" +-#define LN_camellia_192_cfb128 "camellia-192-cfb" +-#define NID_camellia_192_cfb128 758 +-#define OBJ_camellia_192_cfb128 OBJ_camellia,24L +- +-#define SN_camellia_192_gcm "CAMELLIA-192-GCM" +-#define LN_camellia_192_gcm "camellia-192-gcm" +-#define NID_camellia_192_gcm 965 +-#define OBJ_camellia_192_gcm OBJ_camellia,26L +- +-#define SN_camellia_192_ccm "CAMELLIA-192-CCM" +-#define LN_camellia_192_ccm "camellia-192-ccm" +-#define NID_camellia_192_ccm 966 +-#define OBJ_camellia_192_ccm OBJ_camellia,27L +- +-#define SN_camellia_192_ctr "CAMELLIA-192-CTR" +-#define LN_camellia_192_ctr "camellia-192-ctr" +-#define NID_camellia_192_ctr 967 +-#define OBJ_camellia_192_ctr OBJ_camellia,29L +- +-#define SN_camellia_192_cmac "CAMELLIA-192-CMAC" +-#define LN_camellia_192_cmac "camellia-192-cmac" +-#define NID_camellia_192_cmac 968 +-#define OBJ_camellia_192_cmac OBJ_camellia,30L +- +-#define SN_camellia_256_ecb "CAMELLIA-256-ECB" +-#define LN_camellia_256_ecb "camellia-256-ecb" +-#define NID_camellia_256_ecb 756 +-#define OBJ_camellia_256_ecb OBJ_camellia,41L +- +-#define SN_camellia_256_ofb128 "CAMELLIA-256-OFB" +-#define LN_camellia_256_ofb128 "camellia-256-ofb" +-#define NID_camellia_256_ofb128 768 +-#define OBJ_camellia_256_ofb128 OBJ_camellia,43L +- +-#define SN_camellia_256_cfb128 "CAMELLIA-256-CFB" +-#define LN_camellia_256_cfb128 "camellia-256-cfb" +-#define NID_camellia_256_cfb128 759 +-#define OBJ_camellia_256_cfb128 OBJ_camellia,44L +- +-#define SN_camellia_256_gcm "CAMELLIA-256-GCM" +-#define LN_camellia_256_gcm "camellia-256-gcm" +-#define NID_camellia_256_gcm 969 +-#define OBJ_camellia_256_gcm OBJ_camellia,46L +- +-#define SN_camellia_256_ccm "CAMELLIA-256-CCM" +-#define LN_camellia_256_ccm "camellia-256-ccm" +-#define NID_camellia_256_ccm 970 +-#define OBJ_camellia_256_ccm OBJ_camellia,47L +- +-#define SN_camellia_256_ctr "CAMELLIA-256-CTR" +-#define LN_camellia_256_ctr "camellia-256-ctr" +-#define NID_camellia_256_ctr 971 +-#define OBJ_camellia_256_ctr OBJ_camellia,49L +- +-#define SN_camellia_256_cmac "CAMELLIA-256-CMAC" +-#define LN_camellia_256_cmac "camellia-256-cmac" +-#define NID_camellia_256_cmac 972 +-#define OBJ_camellia_256_cmac OBJ_camellia,50L +- +-#define SN_camellia_128_cfb1 "CAMELLIA-128-CFB1" +-#define LN_camellia_128_cfb1 "camellia-128-cfb1" +-#define NID_camellia_128_cfb1 760 +- +-#define SN_camellia_192_cfb1 "CAMELLIA-192-CFB1" +-#define LN_camellia_192_cfb1 "camellia-192-cfb1" +-#define NID_camellia_192_cfb1 761 +- +-#define SN_camellia_256_cfb1 "CAMELLIA-256-CFB1" +-#define LN_camellia_256_cfb1 "camellia-256-cfb1" +-#define NID_camellia_256_cfb1 762 +- +-#define SN_camellia_128_cfb8 "CAMELLIA-128-CFB8" +-#define LN_camellia_128_cfb8 "camellia-128-cfb8" +-#define NID_camellia_128_cfb8 763 +- +-#define SN_camellia_192_cfb8 "CAMELLIA-192-CFB8" +-#define LN_camellia_192_cfb8 "camellia-192-cfb8" +-#define NID_camellia_192_cfb8 764 +- +-#define SN_camellia_256_cfb8 "CAMELLIA-256-CFB8" +-#define LN_camellia_256_cfb8 "camellia-256-cfb8" +-#define NID_camellia_256_cfb8 765 +- +-#define OBJ_aria 1L,2L,410L,200046L,1L,1L +- +-#define SN_aria_128_ecb "ARIA-128-ECB" +-#define LN_aria_128_ecb "aria-128-ecb" +-#define NID_aria_128_ecb 1065 +-#define OBJ_aria_128_ecb OBJ_aria,1L +- +-#define SN_aria_128_cbc "ARIA-128-CBC" +-#define LN_aria_128_cbc "aria-128-cbc" +-#define NID_aria_128_cbc 1066 +-#define OBJ_aria_128_cbc OBJ_aria,2L +- +-#define SN_aria_128_cfb128 "ARIA-128-CFB" +-#define LN_aria_128_cfb128 "aria-128-cfb" +-#define NID_aria_128_cfb128 1067 +-#define OBJ_aria_128_cfb128 OBJ_aria,3L +- +-#define SN_aria_128_ofb128 "ARIA-128-OFB" +-#define LN_aria_128_ofb128 "aria-128-ofb" +-#define NID_aria_128_ofb128 1068 +-#define OBJ_aria_128_ofb128 OBJ_aria,4L +- +-#define SN_aria_128_ctr "ARIA-128-CTR" +-#define LN_aria_128_ctr "aria-128-ctr" +-#define NID_aria_128_ctr 1069 +-#define OBJ_aria_128_ctr OBJ_aria,5L +- +-#define SN_aria_192_ecb "ARIA-192-ECB" +-#define LN_aria_192_ecb "aria-192-ecb" +-#define NID_aria_192_ecb 1070 +-#define OBJ_aria_192_ecb OBJ_aria,6L +- +-#define SN_aria_192_cbc "ARIA-192-CBC" +-#define LN_aria_192_cbc "aria-192-cbc" +-#define NID_aria_192_cbc 1071 +-#define OBJ_aria_192_cbc OBJ_aria,7L +- +-#define SN_aria_192_cfb128 "ARIA-192-CFB" +-#define LN_aria_192_cfb128 "aria-192-cfb" +-#define NID_aria_192_cfb128 1072 +-#define OBJ_aria_192_cfb128 OBJ_aria,8L +- +-#define SN_aria_192_ofb128 "ARIA-192-OFB" +-#define LN_aria_192_ofb128 "aria-192-ofb" +-#define NID_aria_192_ofb128 1073 +-#define OBJ_aria_192_ofb128 OBJ_aria,9L +- +-#define SN_aria_192_ctr "ARIA-192-CTR" +-#define LN_aria_192_ctr "aria-192-ctr" +-#define NID_aria_192_ctr 1074 +-#define OBJ_aria_192_ctr OBJ_aria,10L +- +-#define SN_aria_256_ecb "ARIA-256-ECB" +-#define LN_aria_256_ecb "aria-256-ecb" +-#define NID_aria_256_ecb 1075 +-#define OBJ_aria_256_ecb OBJ_aria,11L +- +-#define SN_aria_256_cbc "ARIA-256-CBC" +-#define LN_aria_256_cbc "aria-256-cbc" +-#define NID_aria_256_cbc 1076 +-#define OBJ_aria_256_cbc OBJ_aria,12L +- +-#define SN_aria_256_cfb128 "ARIA-256-CFB" +-#define LN_aria_256_cfb128 "aria-256-cfb" +-#define NID_aria_256_cfb128 1077 +-#define OBJ_aria_256_cfb128 OBJ_aria,13L +- +-#define SN_aria_256_ofb128 "ARIA-256-OFB" +-#define LN_aria_256_ofb128 "aria-256-ofb" +-#define NID_aria_256_ofb128 1078 +-#define OBJ_aria_256_ofb128 OBJ_aria,14L +- +-#define SN_aria_256_ctr "ARIA-256-CTR" +-#define LN_aria_256_ctr "aria-256-ctr" +-#define NID_aria_256_ctr 1079 +-#define OBJ_aria_256_ctr OBJ_aria,15L +- +-#define SN_aria_128_cfb1 "ARIA-128-CFB1" +-#define LN_aria_128_cfb1 "aria-128-cfb1" +-#define NID_aria_128_cfb1 1080 +- +-#define SN_aria_192_cfb1 "ARIA-192-CFB1" +-#define LN_aria_192_cfb1 "aria-192-cfb1" +-#define NID_aria_192_cfb1 1081 +- +-#define SN_aria_256_cfb1 "ARIA-256-CFB1" +-#define LN_aria_256_cfb1 "aria-256-cfb1" +-#define NID_aria_256_cfb1 1082 +- +-#define SN_aria_128_cfb8 "ARIA-128-CFB8" +-#define LN_aria_128_cfb8 "aria-128-cfb8" +-#define NID_aria_128_cfb8 1083 +- +-#define SN_aria_192_cfb8 "ARIA-192-CFB8" +-#define LN_aria_192_cfb8 "aria-192-cfb8" +-#define NID_aria_192_cfb8 1084 +- +-#define SN_aria_256_cfb8 "ARIA-256-CFB8" +-#define LN_aria_256_cfb8 "aria-256-cfb8" +-#define NID_aria_256_cfb8 1085 +- +-#define SN_aria_128_ccm "ARIA-128-CCM" +-#define LN_aria_128_ccm "aria-128-ccm" +-#define NID_aria_128_ccm 1120 +-#define OBJ_aria_128_ccm OBJ_aria,37L +- +-#define SN_aria_192_ccm "ARIA-192-CCM" +-#define LN_aria_192_ccm "aria-192-ccm" +-#define NID_aria_192_ccm 1121 +-#define OBJ_aria_192_ccm OBJ_aria,38L +- +-#define SN_aria_256_ccm "ARIA-256-CCM" +-#define LN_aria_256_ccm "aria-256-ccm" +-#define NID_aria_256_ccm 1122 +-#define OBJ_aria_256_ccm OBJ_aria,39L +- +-#define SN_aria_128_gcm "ARIA-128-GCM" +-#define LN_aria_128_gcm "aria-128-gcm" +-#define NID_aria_128_gcm 1123 +-#define OBJ_aria_128_gcm OBJ_aria,34L +- +-#define SN_aria_192_gcm "ARIA-192-GCM" +-#define LN_aria_192_gcm "aria-192-gcm" +-#define NID_aria_192_gcm 1124 +-#define OBJ_aria_192_gcm OBJ_aria,35L +- +-#define SN_aria_256_gcm "ARIA-256-GCM" +-#define LN_aria_256_gcm "aria-256-gcm" +-#define NID_aria_256_gcm 1125 +-#define OBJ_aria_256_gcm OBJ_aria,36L +- +-#define SN_kisa "KISA" +-#define LN_kisa "kisa" +-#define NID_kisa 773 +-#define OBJ_kisa OBJ_member_body,410L,200004L +- +-#define SN_seed_ecb "SEED-ECB" +-#define LN_seed_ecb "seed-ecb" +-#define NID_seed_ecb 776 +-#define OBJ_seed_ecb OBJ_kisa,1L,3L +- +-#define SN_seed_cbc "SEED-CBC" +-#define LN_seed_cbc "seed-cbc" +-#define NID_seed_cbc 777 +-#define OBJ_seed_cbc OBJ_kisa,1L,4L +- +-#define SN_seed_cfb128 "SEED-CFB" +-#define LN_seed_cfb128 "seed-cfb" +-#define NID_seed_cfb128 779 +-#define OBJ_seed_cfb128 OBJ_kisa,1L,5L +- +-#define SN_seed_ofb128 "SEED-OFB" +-#define LN_seed_ofb128 "seed-ofb" +-#define NID_seed_ofb128 778 +-#define OBJ_seed_ofb128 OBJ_kisa,1L,6L +- +-#define SN_sm4_ecb "SM4-ECB" +-#define LN_sm4_ecb "sm4-ecb" +-#define NID_sm4_ecb 1133 +-#define OBJ_sm4_ecb OBJ_sm_scheme,104L,1L +- +-#define SN_sm4_cbc "SM4-CBC" +-#define LN_sm4_cbc "sm4-cbc" +-#define NID_sm4_cbc 1134 +-#define OBJ_sm4_cbc OBJ_sm_scheme,104L,2L +- +-#define SN_sm4_ofb128 "SM4-OFB" +-#define LN_sm4_ofb128 "sm4-ofb" +-#define NID_sm4_ofb128 1135 +-#define OBJ_sm4_ofb128 OBJ_sm_scheme,104L,3L +- +-#define SN_sm4_cfb128 "SM4-CFB" +-#define LN_sm4_cfb128 "sm4-cfb" +-#define NID_sm4_cfb128 1137 +-#define OBJ_sm4_cfb128 OBJ_sm_scheme,104L,4L +- +-#define SN_sm4_cfb1 "SM4-CFB1" +-#define LN_sm4_cfb1 "sm4-cfb1" +-#define NID_sm4_cfb1 1136 +-#define OBJ_sm4_cfb1 OBJ_sm_scheme,104L,5L +- +-#define SN_sm4_cfb8 "SM4-CFB8" +-#define LN_sm4_cfb8 "sm4-cfb8" +-#define NID_sm4_cfb8 1138 +-#define OBJ_sm4_cfb8 OBJ_sm_scheme,104L,6L +- +-#define SN_sm4_ctr "SM4-CTR" +-#define LN_sm4_ctr "sm4-ctr" +-#define NID_sm4_ctr 1139 +-#define OBJ_sm4_ctr OBJ_sm_scheme,104L,7L +- +-#define SN_hmac "HMAC" +-#define LN_hmac "hmac" +-#define NID_hmac 855 +- +-#define SN_cmac "CMAC" +-#define LN_cmac "cmac" +-#define NID_cmac 894 +- +-#define SN_rc4_hmac_md5 "RC4-HMAC-MD5" +-#define LN_rc4_hmac_md5 "rc4-hmac-md5" +-#define NID_rc4_hmac_md5 915 +- +-#define SN_aes_128_cbc_hmac_sha1 "AES-128-CBC-HMAC-SHA1" +-#define LN_aes_128_cbc_hmac_sha1 "aes-128-cbc-hmac-sha1" +-#define NID_aes_128_cbc_hmac_sha1 916 +- +-#define SN_aes_192_cbc_hmac_sha1 "AES-192-CBC-HMAC-SHA1" +-#define LN_aes_192_cbc_hmac_sha1 "aes-192-cbc-hmac-sha1" +-#define NID_aes_192_cbc_hmac_sha1 917 +- +-#define SN_aes_256_cbc_hmac_sha1 "AES-256-CBC-HMAC-SHA1" +-#define LN_aes_256_cbc_hmac_sha1 "aes-256-cbc-hmac-sha1" +-#define NID_aes_256_cbc_hmac_sha1 918 +- +-#define SN_aes_128_cbc_hmac_sha256 "AES-128-CBC-HMAC-SHA256" +-#define LN_aes_128_cbc_hmac_sha256 "aes-128-cbc-hmac-sha256" +-#define NID_aes_128_cbc_hmac_sha256 948 +- +-#define SN_aes_192_cbc_hmac_sha256 "AES-192-CBC-HMAC-SHA256" +-#define LN_aes_192_cbc_hmac_sha256 "aes-192-cbc-hmac-sha256" +-#define NID_aes_192_cbc_hmac_sha256 949 +- +-#define SN_aes_256_cbc_hmac_sha256 "AES-256-CBC-HMAC-SHA256" +-#define LN_aes_256_cbc_hmac_sha256 "aes-256-cbc-hmac-sha256" +-#define NID_aes_256_cbc_hmac_sha256 950 +- +-#define SN_chacha20_poly1305 "ChaCha20-Poly1305" +-#define LN_chacha20_poly1305 "chacha20-poly1305" +-#define NID_chacha20_poly1305 1018 +- +-#define SN_chacha20 "ChaCha20" +-#define LN_chacha20 "chacha20" +-#define NID_chacha20 1019 +- +-#define SN_dhpublicnumber "dhpublicnumber" +-#define LN_dhpublicnumber "X9.42 DH" +-#define NID_dhpublicnumber 920 +-#define OBJ_dhpublicnumber OBJ_ISO_US,10046L,2L,1L +- +-#define SN_brainpoolP160r1 "brainpoolP160r1" +-#define NID_brainpoolP160r1 921 +-#define OBJ_brainpoolP160r1 1L,3L,36L,3L,3L,2L,8L,1L,1L,1L +- +-#define SN_brainpoolP160t1 "brainpoolP160t1" +-#define NID_brainpoolP160t1 922 +-#define OBJ_brainpoolP160t1 1L,3L,36L,3L,3L,2L,8L,1L,1L,2L +- +-#define SN_brainpoolP192r1 "brainpoolP192r1" +-#define NID_brainpoolP192r1 923 +-#define OBJ_brainpoolP192r1 1L,3L,36L,3L,3L,2L,8L,1L,1L,3L +- +-#define SN_brainpoolP192t1 "brainpoolP192t1" +-#define NID_brainpoolP192t1 924 +-#define OBJ_brainpoolP192t1 1L,3L,36L,3L,3L,2L,8L,1L,1L,4L +- +-#define SN_brainpoolP224r1 "brainpoolP224r1" +-#define NID_brainpoolP224r1 925 +-#define OBJ_brainpoolP224r1 1L,3L,36L,3L,3L,2L,8L,1L,1L,5L +- +-#define SN_brainpoolP224t1 "brainpoolP224t1" +-#define NID_brainpoolP224t1 926 +-#define OBJ_brainpoolP224t1 1L,3L,36L,3L,3L,2L,8L,1L,1L,6L +- +-#define SN_brainpoolP256r1 "brainpoolP256r1" +-#define NID_brainpoolP256r1 927 +-#define OBJ_brainpoolP256r1 1L,3L,36L,3L,3L,2L,8L,1L,1L,7L +- +-#define SN_brainpoolP256t1 "brainpoolP256t1" +-#define NID_brainpoolP256t1 928 +-#define OBJ_brainpoolP256t1 1L,3L,36L,3L,3L,2L,8L,1L,1L,8L +- +-#define SN_brainpoolP320r1 "brainpoolP320r1" +-#define NID_brainpoolP320r1 929 +-#define OBJ_brainpoolP320r1 1L,3L,36L,3L,3L,2L,8L,1L,1L,9L +- +-#define SN_brainpoolP320t1 "brainpoolP320t1" +-#define NID_brainpoolP320t1 930 +-#define OBJ_brainpoolP320t1 1L,3L,36L,3L,3L,2L,8L,1L,1L,10L +- +-#define SN_brainpoolP384r1 "brainpoolP384r1" +-#define NID_brainpoolP384r1 931 +-#define OBJ_brainpoolP384r1 1L,3L,36L,3L,3L,2L,8L,1L,1L,11L +- +-#define SN_brainpoolP384t1 "brainpoolP384t1" +-#define NID_brainpoolP384t1 932 +-#define OBJ_brainpoolP384t1 1L,3L,36L,3L,3L,2L,8L,1L,1L,12L +- +-#define SN_brainpoolP512r1 "brainpoolP512r1" +-#define NID_brainpoolP512r1 933 +-#define OBJ_brainpoolP512r1 1L,3L,36L,3L,3L,2L,8L,1L,1L,13L +- +-#define SN_brainpoolP512t1 "brainpoolP512t1" +-#define NID_brainpoolP512t1 934 +-#define OBJ_brainpoolP512t1 1L,3L,36L,3L,3L,2L,8L,1L,1L,14L +- +-#define OBJ_x9_63_scheme 1L,3L,133L,16L,840L,63L,0L +- +-#define OBJ_secg_scheme OBJ_certicom_arc,1L +- +-#define SN_dhSinglePass_stdDH_sha1kdf_scheme "dhSinglePass-stdDH-sha1kdf-scheme" +-#define NID_dhSinglePass_stdDH_sha1kdf_scheme 936 +-#define OBJ_dhSinglePass_stdDH_sha1kdf_scheme OBJ_x9_63_scheme,2L +- +-#define SN_dhSinglePass_stdDH_sha224kdf_scheme "dhSinglePass-stdDH-sha224kdf-scheme" +-#define NID_dhSinglePass_stdDH_sha224kdf_scheme 937 +-#define OBJ_dhSinglePass_stdDH_sha224kdf_scheme OBJ_secg_scheme,11L,0L +- +-#define SN_dhSinglePass_stdDH_sha256kdf_scheme "dhSinglePass-stdDH-sha256kdf-scheme" +-#define NID_dhSinglePass_stdDH_sha256kdf_scheme 938 +-#define OBJ_dhSinglePass_stdDH_sha256kdf_scheme OBJ_secg_scheme,11L,1L +- +-#define SN_dhSinglePass_stdDH_sha384kdf_scheme "dhSinglePass-stdDH-sha384kdf-scheme" +-#define NID_dhSinglePass_stdDH_sha384kdf_scheme 939 +-#define OBJ_dhSinglePass_stdDH_sha384kdf_scheme OBJ_secg_scheme,11L,2L +- +-#define SN_dhSinglePass_stdDH_sha512kdf_scheme "dhSinglePass-stdDH-sha512kdf-scheme" +-#define NID_dhSinglePass_stdDH_sha512kdf_scheme 940 +-#define OBJ_dhSinglePass_stdDH_sha512kdf_scheme OBJ_secg_scheme,11L,3L +- +-#define SN_dhSinglePass_cofactorDH_sha1kdf_scheme "dhSinglePass-cofactorDH-sha1kdf-scheme" +-#define NID_dhSinglePass_cofactorDH_sha1kdf_scheme 941 +-#define OBJ_dhSinglePass_cofactorDH_sha1kdf_scheme OBJ_x9_63_scheme,3L +- +-#define SN_dhSinglePass_cofactorDH_sha224kdf_scheme "dhSinglePass-cofactorDH-sha224kdf-scheme" +-#define NID_dhSinglePass_cofactorDH_sha224kdf_scheme 942 +-#define OBJ_dhSinglePass_cofactorDH_sha224kdf_scheme OBJ_secg_scheme,14L,0L +- +-#define SN_dhSinglePass_cofactorDH_sha256kdf_scheme "dhSinglePass-cofactorDH-sha256kdf-scheme" +-#define NID_dhSinglePass_cofactorDH_sha256kdf_scheme 943 +-#define OBJ_dhSinglePass_cofactorDH_sha256kdf_scheme OBJ_secg_scheme,14L,1L +- +-#define SN_dhSinglePass_cofactorDH_sha384kdf_scheme "dhSinglePass-cofactorDH-sha384kdf-scheme" +-#define NID_dhSinglePass_cofactorDH_sha384kdf_scheme 944 +-#define OBJ_dhSinglePass_cofactorDH_sha384kdf_scheme OBJ_secg_scheme,14L,2L +- +-#define SN_dhSinglePass_cofactorDH_sha512kdf_scheme "dhSinglePass-cofactorDH-sha512kdf-scheme" +-#define NID_dhSinglePass_cofactorDH_sha512kdf_scheme 945 +-#define OBJ_dhSinglePass_cofactorDH_sha512kdf_scheme OBJ_secg_scheme,14L,3L +- +-#define SN_dh_std_kdf "dh-std-kdf" +-#define NID_dh_std_kdf 946 +- +-#define SN_dh_cofactor_kdf "dh-cofactor-kdf" +-#define NID_dh_cofactor_kdf 947 +- +-#define SN_ct_precert_scts "ct_precert_scts" +-#define LN_ct_precert_scts "CT Precertificate SCTs" +-#define NID_ct_precert_scts 951 +-#define OBJ_ct_precert_scts 1L,3L,6L,1L,4L,1L,11129L,2L,4L,2L +- +-#define SN_ct_precert_poison "ct_precert_poison" +-#define LN_ct_precert_poison "CT Precertificate Poison" +-#define NID_ct_precert_poison 952 +-#define OBJ_ct_precert_poison 1L,3L,6L,1L,4L,1L,11129L,2L,4L,3L +- +-#define SN_ct_precert_signer "ct_precert_signer" +-#define LN_ct_precert_signer "CT Precertificate Signer" +-#define NID_ct_precert_signer 953 +-#define OBJ_ct_precert_signer 1L,3L,6L,1L,4L,1L,11129L,2L,4L,4L +- +-#define SN_ct_cert_scts "ct_cert_scts" +-#define LN_ct_cert_scts "CT Certificate SCTs" +-#define NID_ct_cert_scts 954 +-#define OBJ_ct_cert_scts 1L,3L,6L,1L,4L,1L,11129L,2L,4L,5L +- +-#define SN_jurisdictionLocalityName "jurisdictionL" +-#define LN_jurisdictionLocalityName "jurisdictionLocalityName" +-#define NID_jurisdictionLocalityName 955 +-#define OBJ_jurisdictionLocalityName 1L,3L,6L,1L,4L,1L,311L,60L,2L,1L,1L +- +-#define SN_jurisdictionStateOrProvinceName "jurisdictionST" +-#define LN_jurisdictionStateOrProvinceName "jurisdictionStateOrProvinceName" +-#define NID_jurisdictionStateOrProvinceName 956 +-#define OBJ_jurisdictionStateOrProvinceName 1L,3L,6L,1L,4L,1L,311L,60L,2L,1L,2L +- +-#define SN_jurisdictionCountryName "jurisdictionC" +-#define LN_jurisdictionCountryName "jurisdictionCountryName" +-#define NID_jurisdictionCountryName 957 +-#define OBJ_jurisdictionCountryName 1L,3L,6L,1L,4L,1L,311L,60L,2L,1L,3L +- +-#define SN_id_scrypt "id-scrypt" +-#define LN_id_scrypt "scrypt" +-#define NID_id_scrypt 973 +-#define OBJ_id_scrypt 1L,3L,6L,1L,4L,1L,11591L,4L,11L +- +-#define SN_tls1_prf "TLS1-PRF" +-#define LN_tls1_prf "tls1-prf" +-#define NID_tls1_prf 1021 +- +-#define SN_hkdf "HKDF" +-#define LN_hkdf "hkdf" +-#define NID_hkdf 1036 +- +-#define SN_id_pkinit "id-pkinit" +-#define NID_id_pkinit 1031 +-#define OBJ_id_pkinit 1L,3L,6L,1L,5L,2L,3L +- +-#define SN_pkInitClientAuth "pkInitClientAuth" +-#define LN_pkInitClientAuth "PKINIT Client Auth" +-#define NID_pkInitClientAuth 1032 +-#define OBJ_pkInitClientAuth OBJ_id_pkinit,4L +- +-#define SN_pkInitKDC "pkInitKDC" +-#define LN_pkInitKDC "Signing KDC Response" +-#define NID_pkInitKDC 1033 +-#define OBJ_pkInitKDC OBJ_id_pkinit,5L +- +-#define SN_X25519 "X25519" +-#define NID_X25519 1034 +-#define OBJ_X25519 1L,3L,101L,110L +- +-#define SN_X448 "X448" +-#define NID_X448 1035 +-#define OBJ_X448 1L,3L,101L,111L +- +-#define SN_ED25519 "ED25519" +-#define NID_ED25519 1087 +-#define OBJ_ED25519 1L,3L,101L,112L +- +-#define SN_ED448 "ED448" +-#define NID_ED448 1088 +-#define OBJ_ED448 1L,3L,101L,113L +- +-#define SN_kx_rsa "KxRSA" +-#define LN_kx_rsa "kx-rsa" +-#define NID_kx_rsa 1037 +- +-#define SN_kx_ecdhe "KxECDHE" +-#define LN_kx_ecdhe "kx-ecdhe" +-#define NID_kx_ecdhe 1038 +- +-#define SN_kx_dhe "KxDHE" +-#define LN_kx_dhe "kx-dhe" +-#define NID_kx_dhe 1039 +- +-#define SN_kx_ecdhe_psk "KxECDHE-PSK" +-#define LN_kx_ecdhe_psk "kx-ecdhe-psk" +-#define NID_kx_ecdhe_psk 1040 +- +-#define SN_kx_dhe_psk "KxDHE-PSK" +-#define LN_kx_dhe_psk "kx-dhe-psk" +-#define NID_kx_dhe_psk 1041 +- +-#define SN_kx_rsa_psk "KxRSA_PSK" +-#define LN_kx_rsa_psk "kx-rsa-psk" +-#define NID_kx_rsa_psk 1042 +- +-#define SN_kx_psk "KxPSK" +-#define LN_kx_psk "kx-psk" +-#define NID_kx_psk 1043 +- +-#define SN_kx_srp "KxSRP" +-#define LN_kx_srp "kx-srp" +-#define NID_kx_srp 1044 +- +-#define SN_kx_gost "KxGOST" +-#define LN_kx_gost "kx-gost" +-#define NID_kx_gost 1045 +- +-#define SN_kx_any "KxANY" +-#define LN_kx_any "kx-any" +-#define NID_kx_any 1063 +- +-#define SN_auth_rsa "AuthRSA" +-#define LN_auth_rsa "auth-rsa" +-#define NID_auth_rsa 1046 +- +-#define SN_auth_ecdsa "AuthECDSA" +-#define LN_auth_ecdsa "auth-ecdsa" +-#define NID_auth_ecdsa 1047 +- +-#define SN_auth_psk "AuthPSK" +-#define LN_auth_psk "auth-psk" +-#define NID_auth_psk 1048 +- +-#define SN_auth_dss "AuthDSS" +-#define LN_auth_dss "auth-dss" +-#define NID_auth_dss 1049 +- +-#define SN_auth_gost01 "AuthGOST01" +-#define LN_auth_gost01 "auth-gost01" +-#define NID_auth_gost01 1050 +- +-#define SN_auth_gost12 "AuthGOST12" +-#define LN_auth_gost12 "auth-gost12" +-#define NID_auth_gost12 1051 +- +-#define SN_auth_srp "AuthSRP" +-#define LN_auth_srp "auth-srp" +-#define NID_auth_srp 1052 +- +-#define SN_auth_null "AuthNULL" +-#define LN_auth_null "auth-null" +-#define NID_auth_null 1053 +- +-#define SN_auth_any "AuthANY" +-#define LN_auth_any "auth-any" +-#define NID_auth_any 1064 +- +-#define SN_poly1305 "Poly1305" +-#define LN_poly1305 "poly1305" +-#define NID_poly1305 1061 +- +-#define SN_siphash "SipHash" +-#define LN_siphash "siphash" +-#define NID_siphash 1062 +- +-#define SN_ffdhe2048 "ffdhe2048" +-#define NID_ffdhe2048 1126 +- +-#define SN_ffdhe3072 "ffdhe3072" +-#define NID_ffdhe3072 1127 +- +-#define SN_ffdhe4096 "ffdhe4096" +-#define NID_ffdhe4096 1128 +- +-#define SN_ffdhe6144 "ffdhe6144" +-#define NID_ffdhe6144 1129 +- +-#define SN_ffdhe8192 "ffdhe8192" +-#define NID_ffdhe8192 1130 +- +-#define SN_ISO_UA "ISO-UA" +-#define NID_ISO_UA 1150 +-#define OBJ_ISO_UA OBJ_member_body,804L +- +-#define SN_ua_pki "ua-pki" +-#define NID_ua_pki 1151 +-#define OBJ_ua_pki OBJ_ISO_UA,2L,1L,1L,1L +- +-#define SN_dstu28147 "dstu28147" +-#define LN_dstu28147 "DSTU Gost 28147-2009" +-#define NID_dstu28147 1152 +-#define OBJ_dstu28147 OBJ_ua_pki,1L,1L,1L +- +-#define SN_dstu28147_ofb "dstu28147-ofb" +-#define LN_dstu28147_ofb "DSTU Gost 28147-2009 OFB mode" +-#define NID_dstu28147_ofb 1153 +-#define OBJ_dstu28147_ofb OBJ_dstu28147,2L +- +-#define SN_dstu28147_cfb "dstu28147-cfb" +-#define LN_dstu28147_cfb "DSTU Gost 28147-2009 CFB mode" +-#define NID_dstu28147_cfb 1154 +-#define OBJ_dstu28147_cfb OBJ_dstu28147,3L +- +-#define SN_dstu28147_wrap "dstu28147-wrap" +-#define LN_dstu28147_wrap "DSTU Gost 28147-2009 key wrap" +-#define NID_dstu28147_wrap 1155 +-#define OBJ_dstu28147_wrap OBJ_dstu28147,5L +- +-#define SN_hmacWithDstu34311 "hmacWithDstu34311" +-#define LN_hmacWithDstu34311 "HMAC DSTU Gost 34311-95" +-#define NID_hmacWithDstu34311 1156 +-#define OBJ_hmacWithDstu34311 OBJ_ua_pki,1L,1L,2L +- +-#define SN_dstu34311 "dstu34311" +-#define LN_dstu34311 "DSTU Gost 34311-95" +-#define NID_dstu34311 1157 +-#define OBJ_dstu34311 OBJ_ua_pki,1L,2L,1L +- +-#define SN_dstu4145le "dstu4145le" +-#define LN_dstu4145le "DSTU 4145-2002 little endian" +-#define NID_dstu4145le 1158 +-#define OBJ_dstu4145le OBJ_ua_pki,1L,3L,1L,1L +- +-#define SN_dstu4145be "dstu4145be" +-#define LN_dstu4145be "DSTU 4145-2002 big endian" +-#define NID_dstu4145be 1159 +-#define OBJ_dstu4145be OBJ_dstu4145le,1L,1L +- +-#define SN_uacurve0 "uacurve0" +-#define LN_uacurve0 "DSTU curve 0" +-#define NID_uacurve0 1160 +-#define OBJ_uacurve0 OBJ_dstu4145le,2L,0L +- +-#define SN_uacurve1 "uacurve1" +-#define LN_uacurve1 "DSTU curve 1" +-#define NID_uacurve1 1161 +-#define OBJ_uacurve1 OBJ_dstu4145le,2L,1L +- +-#define SN_uacurve2 "uacurve2" +-#define LN_uacurve2 "DSTU curve 2" +-#define NID_uacurve2 1162 +-#define OBJ_uacurve2 OBJ_dstu4145le,2L,2L +- +-#define SN_uacurve3 "uacurve3" +-#define LN_uacurve3 "DSTU curve 3" +-#define NID_uacurve3 1163 +-#define OBJ_uacurve3 OBJ_dstu4145le,2L,3L +- +-#define SN_uacurve4 "uacurve4" +-#define LN_uacurve4 "DSTU curve 4" +-#define NID_uacurve4 1164 +-#define OBJ_uacurve4 OBJ_dstu4145le,2L,4L +- +-#define SN_uacurve5 "uacurve5" +-#define LN_uacurve5 "DSTU curve 5" +-#define NID_uacurve5 1165 +-#define OBJ_uacurve5 OBJ_dstu4145le,2L,5L +- +-#define SN_uacurve6 "uacurve6" +-#define LN_uacurve6 "DSTU curve 6" +-#define NID_uacurve6 1166 +-#define OBJ_uacurve6 OBJ_dstu4145le,2L,6L +- +-#define SN_uacurve7 "uacurve7" +-#define LN_uacurve7 "DSTU curve 7" +-#define NID_uacurve7 1167 +-#define OBJ_uacurve7 OBJ_dstu4145le,2L,7L +- +-#define SN_uacurve8 "uacurve8" +-#define LN_uacurve8 "DSTU curve 8" +-#define NID_uacurve8 1168 +-#define OBJ_uacurve8 OBJ_dstu4145le,2L,8L +- +-#define SN_uacurve9 "uacurve9" +-#define LN_uacurve9 "DSTU curve 9" +-#define NID_uacurve9 1169 +-#define OBJ_uacurve9 OBJ_dstu4145le,2L,9L +diff --git a/uadk_tool/include/openssl/objects.h b/uadk_tool/include/openssl/objects.h +deleted file mode 100644 +index 5e8b576..0000000 +--- a/uadk_tool/include/openssl/objects.h ++++ /dev/null +@@ -1,175 +0,0 @@ +-/* +- * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_OBJECTS_H +-# define HEADER_OBJECTS_H +- +-# include +-# include +-# include +-# include +- +-# define OBJ_NAME_TYPE_UNDEF 0x00 +-# define OBJ_NAME_TYPE_MD_METH 0x01 +-# define OBJ_NAME_TYPE_CIPHER_METH 0x02 +-# define OBJ_NAME_TYPE_PKEY_METH 0x03 +-# define OBJ_NAME_TYPE_COMP_METH 0x04 +-# define OBJ_NAME_TYPE_NUM 0x05 +- +-# define OBJ_NAME_ALIAS 0x8000 +- +-# define OBJ_BSEARCH_VALUE_ON_NOMATCH 0x01 +-# define OBJ_BSEARCH_FIRST_VALUE_ON_MATCH 0x02 +- +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-typedef struct obj_name_st { +- int type; +- int alias; +- const char *name; +- const char *data; +-} OBJ_NAME; +- +-# define OBJ_create_and_add_object(a,b,c) OBJ_create(a,b,c) +- +-int OBJ_NAME_init(void); +-int OBJ_NAME_new_index(unsigned long (*hash_func) (const char *), +- int (*cmp_func) (const char *, const char *), +- void (*free_func) (const char *, int, const char *)); +-const char *OBJ_NAME_get(const char *name, int type); +-int OBJ_NAME_add(const char *name, int type, const char *data); +-int OBJ_NAME_remove(const char *name, int type); +-void OBJ_NAME_cleanup(int type); /* -1 for everything */ +-void OBJ_NAME_do_all(int type, void (*fn) (const OBJ_NAME *, void *arg), +- void *arg); +-void OBJ_NAME_do_all_sorted(int type, +- void (*fn) (const OBJ_NAME *, void *arg), +- void *arg); +- +-ASN1_OBJECT *OBJ_dup(const ASN1_OBJECT *o); +-ASN1_OBJECT *OBJ_nid2obj(int n); +-const char *OBJ_nid2ln(int n); +-const char *OBJ_nid2sn(int n); +-int OBJ_obj2nid(const ASN1_OBJECT *o); +-ASN1_OBJECT *OBJ_txt2obj(const char *s, int no_name); +-int OBJ_obj2txt(char *buf, int buf_len, const ASN1_OBJECT *a, int no_name); +-int OBJ_txt2nid(const char *s); +-int OBJ_ln2nid(const char *s); +-int OBJ_sn2nid(const char *s); +-int OBJ_cmp(const ASN1_OBJECT *a, const ASN1_OBJECT *b); +-const void *OBJ_bsearch_(const void *key, const void *base, int num, int size, +- int (*cmp) (const void *, const void *)); +-const void *OBJ_bsearch_ex_(const void *key, const void *base, int num, +- int size, +- int (*cmp) (const void *, const void *), +- int flags); +- +-# define _DECLARE_OBJ_BSEARCH_CMP_FN(scope, type1, type2, nm) \ +- static int nm##_cmp_BSEARCH_CMP_FN(const void *, const void *); \ +- static int nm##_cmp(type1 const *, type2 const *); \ +- scope type2 * OBJ_bsearch_##nm(type1 *key, type2 const *base, int num) +- +-# define DECLARE_OBJ_BSEARCH_CMP_FN(type1, type2, cmp) \ +- _DECLARE_OBJ_BSEARCH_CMP_FN(static, type1, type2, cmp) +-# define DECLARE_OBJ_BSEARCH_GLOBAL_CMP_FN(type1, type2, nm) \ +- type2 * OBJ_bsearch_##nm(type1 *key, type2 const *base, int num) +- +-/*- +- * Unsolved problem: if a type is actually a pointer type, like +- * nid_triple is, then its impossible to get a const where you need +- * it. Consider: +- * +- * typedef int nid_triple[3]; +- * const void *a_; +- * const nid_triple const *a = a_; +- * +- * The assignment discards a const because what you really want is: +- * +- * const int const * const *a = a_; +- * +- * But if you do that, you lose the fact that a is an array of 3 ints, +- * which breaks comparison functions. +- * +- * Thus we end up having to cast, sadly, or unpack the +- * declarations. Or, as I finally did in this case, declare nid_triple +- * to be a struct, which it should have been in the first place. +- * +- * Ben, August 2008. +- * +- * Also, strictly speaking not all types need be const, but handling +- * the non-constness means a lot of complication, and in practice +- * comparison routines do always not touch their arguments. +- */ +- +-# define IMPLEMENT_OBJ_BSEARCH_CMP_FN(type1, type2, nm) \ +- static int nm##_cmp_BSEARCH_CMP_FN(const void *a_, const void *b_) \ +- { \ +- type1 const *a = a_; \ +- type2 const *b = b_; \ +- return nm##_cmp(a,b); \ +- } \ +- static type2 *OBJ_bsearch_##nm(type1 *key, type2 const *base, int num) \ +- { \ +- return (type2 *)OBJ_bsearch_(key, base, num, sizeof(type2), \ +- nm##_cmp_BSEARCH_CMP_FN); \ +- } \ +- extern void dummy_prototype(void) +- +-# define IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(type1, type2, nm) \ +- static int nm##_cmp_BSEARCH_CMP_FN(const void *a_, const void *b_) \ +- { \ +- type1 const *a = a_; \ +- type2 const *b = b_; \ +- return nm##_cmp(a,b); \ +- } \ +- type2 *OBJ_bsearch_##nm(type1 *key, type2 const *base, int num) \ +- { \ +- return (type2 *)OBJ_bsearch_(key, base, num, sizeof(type2), \ +- nm##_cmp_BSEARCH_CMP_FN); \ +- } \ +- extern void dummy_prototype(void) +- +-# define OBJ_bsearch(type1,key,type2,base,num,cmp) \ +- ((type2 *)OBJ_bsearch_(CHECKED_PTR_OF(type1,key),CHECKED_PTR_OF(type2,base), \ +- num,sizeof(type2), \ +- ((void)CHECKED_PTR_OF(type1,cmp##_type_1), \ +- (void)CHECKED_PTR_OF(type2,cmp##_type_2), \ +- cmp##_BSEARCH_CMP_FN))) +- +-# define OBJ_bsearch_ex(type1,key,type2,base,num,cmp,flags) \ +- ((type2 *)OBJ_bsearch_ex_(CHECKED_PTR_OF(type1,key),CHECKED_PTR_OF(type2,base), \ +- num,sizeof(type2), \ +- ((void)CHECKED_PTR_OF(type1,cmp##_type_1), \ +- (void)type_2=CHECKED_PTR_OF(type2,cmp##_type_2), \ +- cmp##_BSEARCH_CMP_FN)),flags) +- +-int OBJ_new_nid(int num); +-int OBJ_add_object(const ASN1_OBJECT *obj); +-int OBJ_create(const char *oid, const char *sn, const char *ln); +-#if OPENSSL_API_COMPAT < 0x10100000L +-# define OBJ_cleanup() while(0) continue +-#endif +-int OBJ_create_objects(BIO *in); +- +-size_t OBJ_length(const ASN1_OBJECT *obj); +-const unsigned char *OBJ_get0_data(const ASN1_OBJECT *obj); +- +-int OBJ_find_sigid_algs(int signid, int *pdig_nid, int *ppkey_nid); +-int OBJ_find_sigid_by_algs(int *psignid, int dig_nid, int pkey_nid); +-int OBJ_add_sigid(int signid, int dig_id, int pkey_id); +-void OBJ_sigid_free(void); +- +- +-# ifdef __cplusplus +-} +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/objectserr.h b/uadk_tool/include/openssl/objectserr.h +deleted file mode 100644 +index 02e166f..0000000 +--- a/uadk_tool/include/openssl/objectserr.h ++++ /dev/null +@@ -1,42 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_OBJERR_H +-# define HEADER_OBJERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_OBJ_strings(void); +- +-/* +- * OBJ function codes. +- */ +-# define OBJ_F_OBJ_ADD_OBJECT 105 +-# define OBJ_F_OBJ_ADD_SIGID 107 +-# define OBJ_F_OBJ_CREATE 100 +-# define OBJ_F_OBJ_DUP 101 +-# define OBJ_F_OBJ_NAME_NEW_INDEX 106 +-# define OBJ_F_OBJ_NID2LN 102 +-# define OBJ_F_OBJ_NID2OBJ 103 +-# define OBJ_F_OBJ_NID2SN 104 +-# define OBJ_F_OBJ_TXT2OBJ 108 +- +-/* +- * OBJ reason codes. +- */ +-# define OBJ_R_OID_EXISTS 102 +-# define OBJ_R_UNKNOWN_NID 101 +- +-#endif +diff --git a/uadk_tool/include/openssl/ocsp.h b/uadk_tool/include/openssl/ocsp.h +deleted file mode 100644 +index 4d759a4..0000000 +--- a/uadk_tool/include/openssl/ocsp.h ++++ /dev/null +@@ -1,352 +0,0 @@ +-/* +- * Copyright 2000-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_OCSP_H +-# define HEADER_OCSP_H +- +-#include +- +-/* +- * These definitions are outside the OPENSSL_NO_OCSP guard because although for +- * historical reasons they have OCSP_* names, they can actually be used +- * independently of OCSP. E.g. see RFC5280 +- */ +-/*- +- * CRLReason ::= ENUMERATED { +- * unspecified (0), +- * keyCompromise (1), +- * cACompromise (2), +- * affiliationChanged (3), +- * superseded (4), +- * cessationOfOperation (5), +- * certificateHold (6), +- * removeFromCRL (8) } +- */ +-# define OCSP_REVOKED_STATUS_NOSTATUS -1 +-# define OCSP_REVOKED_STATUS_UNSPECIFIED 0 +-# define OCSP_REVOKED_STATUS_KEYCOMPROMISE 1 +-# define OCSP_REVOKED_STATUS_CACOMPROMISE 2 +-# define OCSP_REVOKED_STATUS_AFFILIATIONCHANGED 3 +-# define OCSP_REVOKED_STATUS_SUPERSEDED 4 +-# define OCSP_REVOKED_STATUS_CESSATIONOFOPERATION 5 +-# define OCSP_REVOKED_STATUS_CERTIFICATEHOLD 6 +-# define OCSP_REVOKED_STATUS_REMOVEFROMCRL 8 +- +- +-# ifndef OPENSSL_NO_OCSP +- +-# include +-# include +-# include +-# include +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-/* Various flags and values */ +- +-# define OCSP_DEFAULT_NONCE_LENGTH 16 +- +-# define OCSP_NOCERTS 0x1 +-# define OCSP_NOINTERN 0x2 +-# define OCSP_NOSIGS 0x4 +-# define OCSP_NOCHAIN 0x8 +-# define OCSP_NOVERIFY 0x10 +-# define OCSP_NOEXPLICIT 0x20 +-# define OCSP_NOCASIGN 0x40 +-# define OCSP_NODELEGATED 0x80 +-# define OCSP_NOCHECKS 0x100 +-# define OCSP_TRUSTOTHER 0x200 +-# define OCSP_RESPID_KEY 0x400 +-# define OCSP_NOTIME 0x800 +- +-typedef struct ocsp_cert_id_st OCSP_CERTID; +- +-DEFINE_STACK_OF(OCSP_CERTID) +- +-typedef struct ocsp_one_request_st OCSP_ONEREQ; +- +-DEFINE_STACK_OF(OCSP_ONEREQ) +- +-typedef struct ocsp_req_info_st OCSP_REQINFO; +-typedef struct ocsp_signature_st OCSP_SIGNATURE; +-typedef struct ocsp_request_st OCSP_REQUEST; +- +-# define OCSP_RESPONSE_STATUS_SUCCESSFUL 0 +-# define OCSP_RESPONSE_STATUS_MALFORMEDREQUEST 1 +-# define OCSP_RESPONSE_STATUS_INTERNALERROR 2 +-# define OCSP_RESPONSE_STATUS_TRYLATER 3 +-# define OCSP_RESPONSE_STATUS_SIGREQUIRED 5 +-# define OCSP_RESPONSE_STATUS_UNAUTHORIZED 6 +- +-typedef struct ocsp_resp_bytes_st OCSP_RESPBYTES; +- +-# define V_OCSP_RESPID_NAME 0 +-# define V_OCSP_RESPID_KEY 1 +- +-DEFINE_STACK_OF(OCSP_RESPID) +- +-typedef struct ocsp_revoked_info_st OCSP_REVOKEDINFO; +- +-# define V_OCSP_CERTSTATUS_GOOD 0 +-# define V_OCSP_CERTSTATUS_REVOKED 1 +-# define V_OCSP_CERTSTATUS_UNKNOWN 2 +- +-typedef struct ocsp_cert_status_st OCSP_CERTSTATUS; +-typedef struct ocsp_single_response_st OCSP_SINGLERESP; +- +-DEFINE_STACK_OF(OCSP_SINGLERESP) +- +-typedef struct ocsp_response_data_st OCSP_RESPDATA; +- +-typedef struct ocsp_basic_response_st OCSP_BASICRESP; +- +-typedef struct ocsp_crl_id_st OCSP_CRLID; +-typedef struct ocsp_service_locator_st OCSP_SERVICELOC; +- +-# define PEM_STRING_OCSP_REQUEST "OCSP REQUEST" +-# define PEM_STRING_OCSP_RESPONSE "OCSP RESPONSE" +- +-# define d2i_OCSP_REQUEST_bio(bp,p) ASN1_d2i_bio_of(OCSP_REQUEST,OCSP_REQUEST_new,d2i_OCSP_REQUEST,bp,p) +- +-# define d2i_OCSP_RESPONSE_bio(bp,p) ASN1_d2i_bio_of(OCSP_RESPONSE,OCSP_RESPONSE_new,d2i_OCSP_RESPONSE,bp,p) +- +-# define PEM_read_bio_OCSP_REQUEST(bp,x,cb) (OCSP_REQUEST *)PEM_ASN1_read_bio( \ +- (char *(*)())d2i_OCSP_REQUEST,PEM_STRING_OCSP_REQUEST, \ +- bp,(char **)(x),cb,NULL) +- +-# define PEM_read_bio_OCSP_RESPONSE(bp,x,cb) (OCSP_RESPONSE *)PEM_ASN1_read_bio(\ +- (char *(*)())d2i_OCSP_RESPONSE,PEM_STRING_OCSP_RESPONSE, \ +- bp,(char **)(x),cb,NULL) +- +-# define PEM_write_bio_OCSP_REQUEST(bp,o) \ +- PEM_ASN1_write_bio((int (*)())i2d_OCSP_REQUEST,PEM_STRING_OCSP_REQUEST,\ +- bp,(char *)(o), NULL,NULL,0,NULL,NULL) +- +-# define PEM_write_bio_OCSP_RESPONSE(bp,o) \ +- PEM_ASN1_write_bio((int (*)())i2d_OCSP_RESPONSE,PEM_STRING_OCSP_RESPONSE,\ +- bp,(char *)(o), NULL,NULL,0,NULL,NULL) +- +-# define i2d_OCSP_RESPONSE_bio(bp,o) ASN1_i2d_bio_of(OCSP_RESPONSE,i2d_OCSP_RESPONSE,bp,o) +- +-# define i2d_OCSP_REQUEST_bio(bp,o) ASN1_i2d_bio_of(OCSP_REQUEST,i2d_OCSP_REQUEST,bp,o) +- +-# define ASN1_BIT_STRING_digest(data,type,md,len) \ +- ASN1_item_digest(ASN1_ITEM_rptr(ASN1_BIT_STRING),type,data,md,len) +- +-# define OCSP_CERTSTATUS_dup(cs)\ +- (OCSP_CERTSTATUS*)ASN1_dup((int(*)())i2d_OCSP_CERTSTATUS,\ +- (char *(*)())d2i_OCSP_CERTSTATUS,(char *)(cs)) +- +-OCSP_CERTID *OCSP_CERTID_dup(OCSP_CERTID *id); +- +-OCSP_RESPONSE *OCSP_sendreq_bio(BIO *b, const char *path, OCSP_REQUEST *req); +-OCSP_REQ_CTX *OCSP_sendreq_new(BIO *io, const char *path, OCSP_REQUEST *req, +- int maxline); +-int OCSP_REQ_CTX_nbio(OCSP_REQ_CTX *rctx); +-int OCSP_sendreq_nbio(OCSP_RESPONSE **presp, OCSP_REQ_CTX *rctx); +-OCSP_REQ_CTX *OCSP_REQ_CTX_new(BIO *io, int maxline); +-void OCSP_REQ_CTX_free(OCSP_REQ_CTX *rctx); +-void OCSP_set_max_response_length(OCSP_REQ_CTX *rctx, unsigned long len); +-int OCSP_REQ_CTX_i2d(OCSP_REQ_CTX *rctx, const ASN1_ITEM *it, +- ASN1_VALUE *val); +-int OCSP_REQ_CTX_nbio_d2i(OCSP_REQ_CTX *rctx, ASN1_VALUE **pval, +- const ASN1_ITEM *it); +-BIO *OCSP_REQ_CTX_get0_mem_bio(OCSP_REQ_CTX *rctx); +-int OCSP_REQ_CTX_http(OCSP_REQ_CTX *rctx, const char *op, const char *path); +-int OCSP_REQ_CTX_set1_req(OCSP_REQ_CTX *rctx, OCSP_REQUEST *req); +-int OCSP_REQ_CTX_add1_header(OCSP_REQ_CTX *rctx, +- const char *name, const char *value); +- +-OCSP_CERTID *OCSP_cert_to_id(const EVP_MD *dgst, const X509 *subject, +- const X509 *issuer); +- +-OCSP_CERTID *OCSP_cert_id_new(const EVP_MD *dgst, +- const X509_NAME *issuerName, +- const ASN1_BIT_STRING *issuerKey, +- const ASN1_INTEGER *serialNumber); +- +-OCSP_ONEREQ *OCSP_request_add0_id(OCSP_REQUEST *req, OCSP_CERTID *cid); +- +-int OCSP_request_add1_nonce(OCSP_REQUEST *req, unsigned char *val, int len); +-int OCSP_basic_add1_nonce(OCSP_BASICRESP *resp, unsigned char *val, int len); +-int OCSP_check_nonce(OCSP_REQUEST *req, OCSP_BASICRESP *bs); +-int OCSP_copy_nonce(OCSP_BASICRESP *resp, OCSP_REQUEST *req); +- +-int OCSP_request_set1_name(OCSP_REQUEST *req, X509_NAME *nm); +-int OCSP_request_add1_cert(OCSP_REQUEST *req, X509 *cert); +- +-int OCSP_request_sign(OCSP_REQUEST *req, +- X509 *signer, +- EVP_PKEY *key, +- const EVP_MD *dgst, +- STACK_OF(X509) *certs, unsigned long flags); +- +-int OCSP_response_status(OCSP_RESPONSE *resp); +-OCSP_BASICRESP *OCSP_response_get1_basic(OCSP_RESPONSE *resp); +- +-const ASN1_OCTET_STRING *OCSP_resp_get0_signature(const OCSP_BASICRESP *bs); +-const X509_ALGOR *OCSP_resp_get0_tbs_sigalg(const OCSP_BASICRESP *bs); +-const OCSP_RESPDATA *OCSP_resp_get0_respdata(const OCSP_BASICRESP *bs); +-int OCSP_resp_get0_signer(OCSP_BASICRESP *bs, X509 **signer, +- STACK_OF(X509) *extra_certs); +- +-int OCSP_resp_count(OCSP_BASICRESP *bs); +-OCSP_SINGLERESP *OCSP_resp_get0(OCSP_BASICRESP *bs, int idx); +-const ASN1_GENERALIZEDTIME *OCSP_resp_get0_produced_at(const OCSP_BASICRESP* bs); +-const STACK_OF(X509) *OCSP_resp_get0_certs(const OCSP_BASICRESP *bs); +-int OCSP_resp_get0_id(const OCSP_BASICRESP *bs, +- const ASN1_OCTET_STRING **pid, +- const X509_NAME **pname); +-int OCSP_resp_get1_id(const OCSP_BASICRESP *bs, +- ASN1_OCTET_STRING **pid, +- X509_NAME **pname); +- +-int OCSP_resp_find(OCSP_BASICRESP *bs, OCSP_CERTID *id, int last); +-int OCSP_single_get0_status(OCSP_SINGLERESP *single, int *reason, +- ASN1_GENERALIZEDTIME **revtime, +- ASN1_GENERALIZEDTIME **thisupd, +- ASN1_GENERALIZEDTIME **nextupd); +-int OCSP_resp_find_status(OCSP_BASICRESP *bs, OCSP_CERTID *id, int *status, +- int *reason, +- ASN1_GENERALIZEDTIME **revtime, +- ASN1_GENERALIZEDTIME **thisupd, +- ASN1_GENERALIZEDTIME **nextupd); +-int OCSP_check_validity(ASN1_GENERALIZEDTIME *thisupd, +- ASN1_GENERALIZEDTIME *nextupd, long sec, long maxsec); +- +-int OCSP_request_verify(OCSP_REQUEST *req, STACK_OF(X509) *certs, +- X509_STORE *store, unsigned long flags); +- +-int OCSP_parse_url(const char *url, char **phost, char **pport, char **ppath, +- int *pssl); +- +-int OCSP_id_issuer_cmp(const OCSP_CERTID *a, const OCSP_CERTID *b); +-int OCSP_id_cmp(const OCSP_CERTID *a, const OCSP_CERTID *b); +- +-int OCSP_request_onereq_count(OCSP_REQUEST *req); +-OCSP_ONEREQ *OCSP_request_onereq_get0(OCSP_REQUEST *req, int i); +-OCSP_CERTID *OCSP_onereq_get0_id(OCSP_ONEREQ *one); +-int OCSP_id_get0_info(ASN1_OCTET_STRING **piNameHash, ASN1_OBJECT **pmd, +- ASN1_OCTET_STRING **pikeyHash, +- ASN1_INTEGER **pserial, OCSP_CERTID *cid); +-int OCSP_request_is_signed(OCSP_REQUEST *req); +-OCSP_RESPONSE *OCSP_response_create(int status, OCSP_BASICRESP *bs); +-OCSP_SINGLERESP *OCSP_basic_add1_status(OCSP_BASICRESP *rsp, +- OCSP_CERTID *cid, +- int status, int reason, +- ASN1_TIME *revtime, +- ASN1_TIME *thisupd, +- ASN1_TIME *nextupd); +-int OCSP_basic_add1_cert(OCSP_BASICRESP *resp, X509 *cert); +-int OCSP_basic_sign(OCSP_BASICRESP *brsp, +- X509 *signer, EVP_PKEY *key, const EVP_MD *dgst, +- STACK_OF(X509) *certs, unsigned long flags); +-int OCSP_basic_sign_ctx(OCSP_BASICRESP *brsp, +- X509 *signer, EVP_MD_CTX *ctx, +- STACK_OF(X509) *certs, unsigned long flags); +-int OCSP_RESPID_set_by_name(OCSP_RESPID *respid, X509 *cert); +-int OCSP_RESPID_set_by_key(OCSP_RESPID *respid, X509 *cert); +-int OCSP_RESPID_match(OCSP_RESPID *respid, X509 *cert); +- +-X509_EXTENSION *OCSP_crlID_new(const char *url, long *n, char *tim); +- +-X509_EXTENSION *OCSP_accept_responses_new(char **oids); +- +-X509_EXTENSION *OCSP_archive_cutoff_new(char *tim); +- +-X509_EXTENSION *OCSP_url_svcloc_new(X509_NAME *issuer, const char **urls); +- +-int OCSP_REQUEST_get_ext_count(OCSP_REQUEST *x); +-int OCSP_REQUEST_get_ext_by_NID(OCSP_REQUEST *x, int nid, int lastpos); +-int OCSP_REQUEST_get_ext_by_OBJ(OCSP_REQUEST *x, const ASN1_OBJECT *obj, +- int lastpos); +-int OCSP_REQUEST_get_ext_by_critical(OCSP_REQUEST *x, int crit, int lastpos); +-X509_EXTENSION *OCSP_REQUEST_get_ext(OCSP_REQUEST *x, int loc); +-X509_EXTENSION *OCSP_REQUEST_delete_ext(OCSP_REQUEST *x, int loc); +-void *OCSP_REQUEST_get1_ext_d2i(OCSP_REQUEST *x, int nid, int *crit, +- int *idx); +-int OCSP_REQUEST_add1_ext_i2d(OCSP_REQUEST *x, int nid, void *value, int crit, +- unsigned long flags); +-int OCSP_REQUEST_add_ext(OCSP_REQUEST *x, X509_EXTENSION *ex, int loc); +- +-int OCSP_ONEREQ_get_ext_count(OCSP_ONEREQ *x); +-int OCSP_ONEREQ_get_ext_by_NID(OCSP_ONEREQ *x, int nid, int lastpos); +-int OCSP_ONEREQ_get_ext_by_OBJ(OCSP_ONEREQ *x, const ASN1_OBJECT *obj, int lastpos); +-int OCSP_ONEREQ_get_ext_by_critical(OCSP_ONEREQ *x, int crit, int lastpos); +-X509_EXTENSION *OCSP_ONEREQ_get_ext(OCSP_ONEREQ *x, int loc); +-X509_EXTENSION *OCSP_ONEREQ_delete_ext(OCSP_ONEREQ *x, int loc); +-void *OCSP_ONEREQ_get1_ext_d2i(OCSP_ONEREQ *x, int nid, int *crit, int *idx); +-int OCSP_ONEREQ_add1_ext_i2d(OCSP_ONEREQ *x, int nid, void *value, int crit, +- unsigned long flags); +-int OCSP_ONEREQ_add_ext(OCSP_ONEREQ *x, X509_EXTENSION *ex, int loc); +- +-int OCSP_BASICRESP_get_ext_count(OCSP_BASICRESP *x); +-int OCSP_BASICRESP_get_ext_by_NID(OCSP_BASICRESP *x, int nid, int lastpos); +-int OCSP_BASICRESP_get_ext_by_OBJ(OCSP_BASICRESP *x, const ASN1_OBJECT *obj, +- int lastpos); +-int OCSP_BASICRESP_get_ext_by_critical(OCSP_BASICRESP *x, int crit, +- int lastpos); +-X509_EXTENSION *OCSP_BASICRESP_get_ext(OCSP_BASICRESP *x, int loc); +-X509_EXTENSION *OCSP_BASICRESP_delete_ext(OCSP_BASICRESP *x, int loc); +-void *OCSP_BASICRESP_get1_ext_d2i(OCSP_BASICRESP *x, int nid, int *crit, +- int *idx); +-int OCSP_BASICRESP_add1_ext_i2d(OCSP_BASICRESP *x, int nid, void *value, +- int crit, unsigned long flags); +-int OCSP_BASICRESP_add_ext(OCSP_BASICRESP *x, X509_EXTENSION *ex, int loc); +- +-int OCSP_SINGLERESP_get_ext_count(OCSP_SINGLERESP *x); +-int OCSP_SINGLERESP_get_ext_by_NID(OCSP_SINGLERESP *x, int nid, int lastpos); +-int OCSP_SINGLERESP_get_ext_by_OBJ(OCSP_SINGLERESP *x, const ASN1_OBJECT *obj, +- int lastpos); +-int OCSP_SINGLERESP_get_ext_by_critical(OCSP_SINGLERESP *x, int crit, +- int lastpos); +-X509_EXTENSION *OCSP_SINGLERESP_get_ext(OCSP_SINGLERESP *x, int loc); +-X509_EXTENSION *OCSP_SINGLERESP_delete_ext(OCSP_SINGLERESP *x, int loc); +-void *OCSP_SINGLERESP_get1_ext_d2i(OCSP_SINGLERESP *x, int nid, int *crit, +- int *idx); +-int OCSP_SINGLERESP_add1_ext_i2d(OCSP_SINGLERESP *x, int nid, void *value, +- int crit, unsigned long flags); +-int OCSP_SINGLERESP_add_ext(OCSP_SINGLERESP *x, X509_EXTENSION *ex, int loc); +-const OCSP_CERTID *OCSP_SINGLERESP_get0_id(const OCSP_SINGLERESP *x); +- +-DECLARE_ASN1_FUNCTIONS(OCSP_SINGLERESP) +-DECLARE_ASN1_FUNCTIONS(OCSP_CERTSTATUS) +-DECLARE_ASN1_FUNCTIONS(OCSP_REVOKEDINFO) +-DECLARE_ASN1_FUNCTIONS(OCSP_BASICRESP) +-DECLARE_ASN1_FUNCTIONS(OCSP_RESPDATA) +-DECLARE_ASN1_FUNCTIONS(OCSP_RESPID) +-DECLARE_ASN1_FUNCTIONS(OCSP_RESPONSE) +-DECLARE_ASN1_FUNCTIONS(OCSP_RESPBYTES) +-DECLARE_ASN1_FUNCTIONS(OCSP_ONEREQ) +-DECLARE_ASN1_FUNCTIONS(OCSP_CERTID) +-DECLARE_ASN1_FUNCTIONS(OCSP_REQUEST) +-DECLARE_ASN1_FUNCTIONS(OCSP_SIGNATURE) +-DECLARE_ASN1_FUNCTIONS(OCSP_REQINFO) +-DECLARE_ASN1_FUNCTIONS(OCSP_CRLID) +-DECLARE_ASN1_FUNCTIONS(OCSP_SERVICELOC) +- +-const char *OCSP_response_status_str(long s); +-const char *OCSP_cert_status_str(long s); +-const char *OCSP_crl_reason_str(long s); +- +-int OCSP_REQUEST_print(BIO *bp, OCSP_REQUEST *a, unsigned long flags); +-int OCSP_RESPONSE_print(BIO *bp, OCSP_RESPONSE *o, unsigned long flags); +- +-int OCSP_basic_verify(OCSP_BASICRESP *bs, STACK_OF(X509) *certs, +- X509_STORE *st, unsigned long flags); +- +- +-# ifdef __cplusplus +-} +-# endif +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/ocsperr.h b/uadk_tool/include/openssl/ocsperr.h +deleted file mode 100644 +index 8dd9e01..0000000 +--- a/uadk_tool/include/openssl/ocsperr.h ++++ /dev/null +@@ -1,78 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_OCSPERR_H +-# define HEADER_OCSPERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# include +- +-# ifndef OPENSSL_NO_OCSP +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_OCSP_strings(void); +- +-/* +- * OCSP function codes. +- */ +-# define OCSP_F_D2I_OCSP_NONCE 102 +-# define OCSP_F_OCSP_BASIC_ADD1_STATUS 103 +-# define OCSP_F_OCSP_BASIC_SIGN 104 +-# define OCSP_F_OCSP_BASIC_SIGN_CTX 119 +-# define OCSP_F_OCSP_BASIC_VERIFY 105 +-# define OCSP_F_OCSP_CERT_ID_NEW 101 +-# define OCSP_F_OCSP_CHECK_DELEGATED 106 +-# define OCSP_F_OCSP_CHECK_IDS 107 +-# define OCSP_F_OCSP_CHECK_ISSUER 108 +-# define OCSP_F_OCSP_CHECK_VALIDITY 115 +-# define OCSP_F_OCSP_MATCH_ISSUERID 109 +-# define OCSP_F_OCSP_PARSE_URL 114 +-# define OCSP_F_OCSP_REQUEST_SIGN 110 +-# define OCSP_F_OCSP_REQUEST_VERIFY 116 +-# define OCSP_F_OCSP_RESPONSE_GET1_BASIC 111 +-# define OCSP_F_PARSE_HTTP_LINE1 118 +- +-/* +- * OCSP reason codes. +- */ +-# define OCSP_R_CERTIFICATE_VERIFY_ERROR 101 +-# define OCSP_R_DIGEST_ERR 102 +-# define OCSP_R_ERROR_IN_NEXTUPDATE_FIELD 122 +-# define OCSP_R_ERROR_IN_THISUPDATE_FIELD 123 +-# define OCSP_R_ERROR_PARSING_URL 121 +-# define OCSP_R_MISSING_OCSPSIGNING_USAGE 103 +-# define OCSP_R_NEXTUPDATE_BEFORE_THISUPDATE 124 +-# define OCSP_R_NOT_BASIC_RESPONSE 104 +-# define OCSP_R_NO_CERTIFICATES_IN_CHAIN 105 +-# define OCSP_R_NO_RESPONSE_DATA 108 +-# define OCSP_R_NO_REVOKED_TIME 109 +-# define OCSP_R_NO_SIGNER_KEY 130 +-# define OCSP_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 110 +-# define OCSP_R_REQUEST_NOT_SIGNED 128 +-# define OCSP_R_RESPONSE_CONTAINS_NO_REVOCATION_DATA 111 +-# define OCSP_R_ROOT_CA_NOT_TRUSTED 112 +-# define OCSP_R_SERVER_RESPONSE_ERROR 114 +-# define OCSP_R_SERVER_RESPONSE_PARSE_ERROR 115 +-# define OCSP_R_SIGNATURE_FAILURE 117 +-# define OCSP_R_SIGNER_CERTIFICATE_NOT_FOUND 118 +-# define OCSP_R_STATUS_EXPIRED 125 +-# define OCSP_R_STATUS_NOT_YET_VALID 126 +-# define OCSP_R_STATUS_TOO_OLD 127 +-# define OCSP_R_UNKNOWN_MESSAGE_DIGEST 119 +-# define OCSP_R_UNKNOWN_NID 120 +-# define OCSP_R_UNSUPPORTED_REQUESTORNAME_TYPE 129 +- +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/opensslconf.h b/uadk_tool/include/openssl/opensslconf.h +deleted file mode 100644 +index 805d530..0000000 +--- a/uadk_tool/include/openssl/opensslconf.h ++++ /dev/null +@@ -1,197 +0,0 @@ +-/* +- * WARNING: do not edit! +- * Generated by Makefile from include/openssl/opensslconf.h.in +- * +- * Copyright 2016-2020 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-#ifdef OPENSSL_ALGORITHM_DEFINES +-# error OPENSSL_ALGORITHM_DEFINES no longer supported +-#endif +- +-/* +- * OpenSSL was configured with the following options: +- */ +- +-#ifndef OPENSSL_NO_MD2 +-# define OPENSSL_NO_MD2 +-#endif +-#ifndef OPENSSL_NO_RC5 +-# define OPENSSL_NO_RC5 +-#endif +-#ifndef OPENSSL_THREADS +-# define OPENSSL_THREADS +-#endif +-#ifndef OPENSSL_RAND_SEED_OS +-# define OPENSSL_RAND_SEED_OS +-#endif +-#ifndef OPENSSL_NO_ASAN +-# define OPENSSL_NO_ASAN +-#endif +-#ifndef OPENSSL_NO_CRYPTO_MDEBUG +-# define OPENSSL_NO_CRYPTO_MDEBUG +-#endif +-#ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE +-# define OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE +-#endif +-#ifndef OPENSSL_NO_DEVCRYPTOENG +-# define OPENSSL_NO_DEVCRYPTOENG +-#endif +-#ifndef OPENSSL_NO_EC_NISTP_64_GCC_128 +-# define OPENSSL_NO_EC_NISTP_64_GCC_128 +-#endif +-#ifndef OPENSSL_NO_EGD +-# define OPENSSL_NO_EGD +-#endif +-#ifndef OPENSSL_NO_EXTERNAL_TESTS +-# define OPENSSL_NO_EXTERNAL_TESTS +-#endif +-#ifndef OPENSSL_NO_FUZZ_AFL +-# define OPENSSL_NO_FUZZ_AFL +-#endif +-#ifndef OPENSSL_NO_FUZZ_LIBFUZZER +-# define OPENSSL_NO_FUZZ_LIBFUZZER +-#endif +-#ifndef OPENSSL_NO_HEARTBEATS +-# define OPENSSL_NO_HEARTBEATS +-#endif +-#ifndef OPENSSL_NO_MSAN +-# define OPENSSL_NO_MSAN +-#endif +-#ifndef OPENSSL_NO_SCTP +-# define OPENSSL_NO_SCTP +-#endif +-#ifndef OPENSSL_NO_SSL_TRACE +-# define OPENSSL_NO_SSL_TRACE +-#endif +-#ifndef OPENSSL_NO_SSL3 +-# define OPENSSL_NO_SSL3 +-#endif +-#ifndef OPENSSL_NO_SSL3_METHOD +-# define OPENSSL_NO_SSL3_METHOD +-#endif +-#ifndef OPENSSL_NO_UBSAN +-# define OPENSSL_NO_UBSAN +-#endif +-#ifndef OPENSSL_NO_UNIT_TEST +-# define OPENSSL_NO_UNIT_TEST +-#endif +-#ifndef OPENSSL_NO_WEAK_SSL_CIPHERS +-# define OPENSSL_NO_WEAK_SSL_CIPHERS +-#endif +-#ifndef OPENSSL_NO_STATIC_ENGINE +-# define OPENSSL_NO_STATIC_ENGINE +-#endif +- +- +-/* +- * Sometimes OPENSSSL_NO_xxx ends up with an empty file and some compilers +- * don't like that. This will hopefully silence them. +- */ +-#define NON_EMPTY_TRANSLATION_UNIT static void *dummy = &dummy; +- +-/* +- * Applications should use -DOPENSSL_API_COMPAT= to suppress the +- * declarations of functions deprecated in or before . Otherwise, they +- * still won't see them if the library has been built to disable deprecated +- * functions. +- */ +-#ifndef DECLARE_DEPRECATED +-# define DECLARE_DEPRECATED(f) f; +-# ifdef __GNUC__ +-# if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 0) +-# undef DECLARE_DEPRECATED +-# define DECLARE_DEPRECATED(f) f __attribute__ ((deprecated)); +-# endif +-# elif defined(__SUNPRO_C) +-# if (__SUNPRO_C >= 0x5130) +-# undef DECLARE_DEPRECATED +-# define DECLARE_DEPRECATED(f) f __attribute__ ((deprecated)); +-# endif +-# endif +-#endif +- +-#ifndef OPENSSL_FILE +-# ifdef OPENSSL_NO_FILENAMES +-# define OPENSSL_FILE "" +-# define OPENSSL_LINE 0 +-# else +-# define OPENSSL_FILE __FILE__ +-# define OPENSSL_LINE __LINE__ +-# endif +-#endif +- +-#ifndef OPENSSL_MIN_API +-# define OPENSSL_MIN_API 0 +-#endif +- +-#if !defined(OPENSSL_API_COMPAT) || OPENSSL_API_COMPAT < OPENSSL_MIN_API +-# undef OPENSSL_API_COMPAT +-# define OPENSSL_API_COMPAT OPENSSL_MIN_API +-#endif +- +-/* +- * Do not deprecate things to be deprecated in version 1.2.0 before the +- * OpenSSL version number matches. +- */ +-#if OPENSSL_VERSION_NUMBER < 0x10200000L +-# define DEPRECATEDIN_1_2_0(f) f; +-#elif OPENSSL_API_COMPAT < 0x10200000L +-# define DEPRECATEDIN_1_2_0(f) DECLARE_DEPRECATED(f) +-#else +-# define DEPRECATEDIN_1_2_0(f) +-#endif +- +-#if OPENSSL_API_COMPAT < 0x10100000L +-# define DEPRECATEDIN_1_1_0(f) DECLARE_DEPRECATED(f) +-#else +-# define DEPRECATEDIN_1_1_0(f) +-#endif +- +-#if OPENSSL_API_COMPAT < 0x10000000L +-# define DEPRECATEDIN_1_0_0(f) DECLARE_DEPRECATED(f) +-#else +-# define DEPRECATEDIN_1_0_0(f) +-#endif +- +-#if OPENSSL_API_COMPAT < 0x00908000L +-# define DEPRECATEDIN_0_9_8(f) DECLARE_DEPRECATED(f) +-#else +-# define DEPRECATEDIN_0_9_8(f) +-#endif +- +-/* Generate 80386 code? */ +-#undef I386_ONLY +- +-#undef OPENSSL_UNISTD +-#define OPENSSL_UNISTD +- +-#undef OPENSSL_EXPORT_VAR_AS_FUNCTION +- +-/* +- * The following are cipher-specific, but are part of the public API. +- */ +-#if !defined(OPENSSL_SYS_UEFI) +-# undef BN_LLONG +-/* Only one for the following should be defined */ +-# define SIXTY_FOUR_BIT_LONG +-# undef SIXTY_FOUR_BIT +-# undef THIRTY_TWO_BIT +-#endif +- +-#define RC4_INT unsigned char +- +-#ifdef __cplusplus +-} +-#endif +diff --git a/uadk_tool/include/openssl/opensslv.h b/uadk_tool/include/openssl/opensslv.h +deleted file mode 100644 +index 2a5fb9f..0000000 +--- a/uadk_tool/include/openssl/opensslv.h ++++ /dev/null +@@ -1,101 +0,0 @@ +-/* +- * Copyright 1999-2021 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_OPENSSLV_H +-# define HEADER_OPENSSLV_H +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-/*- +- * Numeric release version identifier: +- * MNNFFPPS: major minor fix patch status +- * The status nibble has one of the values 0 for development, 1 to e for betas +- * 1 to 14, and f for release. The patch level is exactly that. +- * For example: +- * 0.9.3-dev 0x00903000 +- * 0.9.3-beta1 0x00903001 +- * 0.9.3-beta2-dev 0x00903002 +- * 0.9.3-beta2 0x00903002 (same as ...beta2-dev) +- * 0.9.3 0x0090300f +- * 0.9.3a 0x0090301f +- * 0.9.4 0x0090400f +- * 1.2.3z 0x102031af +- * +- * For continuity reasons (because 0.9.5 is already out, and is coded +- * 0x00905100), between 0.9.5 and 0.9.6 the coding of the patch level +- * part is slightly different, by setting the highest bit. This means +- * that 0.9.5a looks like this: 0x0090581f. At 0.9.6, we can start +- * with 0x0090600S... +- * +- * (Prior to 0.9.3-dev a different scheme was used: 0.9.2b is 0x0922.) +- * (Prior to 0.9.5a beta1, a different scheme was used: MMNNFFRBB for +- * major minor fix final patch/beta) +- */ +-# define OPENSSL_VERSION_NUMBER 0x101010d0L +-# define OPENSSL_VERSION_TEXT "OpenSSL 1.1.1m-dev xx XXX xxxx" +- +-/*- +- * The macros below are to be used for shared library (.so, .dll, ...) +- * versioning. That kind of versioning works a bit differently between +- * operating systems. The most usual scheme is to set a major and a minor +- * number, and have the runtime loader check that the major number is equal +- * to what it was at application link time, while the minor number has to +- * be greater or equal to what it was at application link time. With this +- * scheme, the version number is usually part of the file name, like this: +- * +- * libcrypto.so.0.9 +- * +- * Some unixen also make a softlink with the major version number only: +- * +- * libcrypto.so.0 +- * +- * On Tru64 and IRIX 6.x it works a little bit differently. There, the +- * shared library version is stored in the file, and is actually a series +- * of versions, separated by colons. The rightmost version present in the +- * library when linking an application is stored in the application to be +- * matched at run time. When the application is run, a check is done to +- * see if the library version stored in the application matches any of the +- * versions in the version string of the library itself. +- * This version string can be constructed in any way, depending on what +- * kind of matching is desired. However, to implement the same scheme as +- * the one used in the other unixen, all compatible versions, from lowest +- * to highest, should be part of the string. Consecutive builds would +- * give the following versions strings: +- * +- * 3.0 +- * 3.0:3.1 +- * 3.0:3.1:3.2 +- * 4.0 +- * 4.0:4.1 +- * +- * Notice how version 4 is completely incompatible with version, and +- * therefore give the breach you can see. +- * +- * There may be other schemes as well that I haven't yet discovered. +- * +- * So, here's the way it works here: first of all, the library version +- * number doesn't need at all to match the overall OpenSSL version. +- * However, it's nice and more understandable if it actually does. +- * The current library version is stored in the macro SHLIB_VERSION_NUMBER, +- * which is just a piece of text in the format "M.m.e" (Major, minor, edit). +- * For the sake of Tru64, IRIX, and any other OS that behaves in similar ways, +- * we need to keep a history of version numbers, which is done in the +- * macro SHLIB_VERSION_HISTORY. The numbers are separated by colons and +- * should only keep the versions that are binary compatible with the current. +- */ +-# define SHLIB_VERSION_HISTORY "" +-# define SHLIB_VERSION_NUMBER "1.1" +- +- +-#ifdef __cplusplus +-} +-#endif +-#endif /* HEADER_OPENSSLV_H */ +diff --git a/uadk_tool/include/openssl/ossl_typ.h b/uadk_tool/include/openssl/ossl_typ.h +deleted file mode 100644 +index e0edfaa..0000000 +--- a/uadk_tool/include/openssl/ossl_typ.h ++++ /dev/null +@@ -1,197 +0,0 @@ +-/* +- * Copyright 2001-2018 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_OPENSSL_TYPES_H +-# define HEADER_OPENSSL_TYPES_H +- +-#include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-# include +- +-# ifdef NO_ASN1_TYPEDEFS +-# define ASN1_INTEGER ASN1_STRING +-# define ASN1_ENUMERATED ASN1_STRING +-# define ASN1_BIT_STRING ASN1_STRING +-# define ASN1_OCTET_STRING ASN1_STRING +-# define ASN1_PRINTABLESTRING ASN1_STRING +-# define ASN1_T61STRING ASN1_STRING +-# define ASN1_IA5STRING ASN1_STRING +-# define ASN1_UTCTIME ASN1_STRING +-# define ASN1_GENERALIZEDTIME ASN1_STRING +-# define ASN1_TIME ASN1_STRING +-# define ASN1_GENERALSTRING ASN1_STRING +-# define ASN1_UNIVERSALSTRING ASN1_STRING +-# define ASN1_BMPSTRING ASN1_STRING +-# define ASN1_VISIBLESTRING ASN1_STRING +-# define ASN1_UTF8STRING ASN1_STRING +-# define ASN1_BOOLEAN int +-# define ASN1_NULL int +-# else +-typedef struct asn1_string_st ASN1_INTEGER; +-typedef struct asn1_string_st ASN1_ENUMERATED; +-typedef struct asn1_string_st ASN1_BIT_STRING; +-typedef struct asn1_string_st ASN1_OCTET_STRING; +-typedef struct asn1_string_st ASN1_PRINTABLESTRING; +-typedef struct asn1_string_st ASN1_T61STRING; +-typedef struct asn1_string_st ASN1_IA5STRING; +-typedef struct asn1_string_st ASN1_GENERALSTRING; +-typedef struct asn1_string_st ASN1_UNIVERSALSTRING; +-typedef struct asn1_string_st ASN1_BMPSTRING; +-typedef struct asn1_string_st ASN1_UTCTIME; +-typedef struct asn1_string_st ASN1_TIME; +-typedef struct asn1_string_st ASN1_GENERALIZEDTIME; +-typedef struct asn1_string_st ASN1_VISIBLESTRING; +-typedef struct asn1_string_st ASN1_UTF8STRING; +-typedef struct asn1_string_st ASN1_STRING; +-typedef int ASN1_BOOLEAN; +-typedef int ASN1_NULL; +-# endif +- +-typedef struct asn1_object_st ASN1_OBJECT; +- +-typedef struct ASN1_ITEM_st ASN1_ITEM; +-typedef struct asn1_pctx_st ASN1_PCTX; +-typedef struct asn1_sctx_st ASN1_SCTX; +- +-# ifdef _WIN32 +-# undef X509_NAME +-# undef X509_EXTENSIONS +-# undef PKCS7_ISSUER_AND_SERIAL +-# undef PKCS7_SIGNER_INFO +-# undef OCSP_REQUEST +-# undef OCSP_RESPONSE +-# endif +- +-# ifdef BIGNUM +-# undef BIGNUM +-# endif +-struct dane_st; +-typedef struct bio_st BIO; +-typedef struct bignum_st BIGNUM; +-typedef struct bignum_ctx BN_CTX; +-typedef struct bn_blinding_st BN_BLINDING; +-typedef struct bn_mont_ctx_st BN_MONT_CTX; +-typedef struct bn_recp_ctx_st BN_RECP_CTX; +-typedef struct bn_gencb_st BN_GENCB; +- +-typedef struct buf_mem_st BUF_MEM; +- +-typedef struct evp_cipher_st EVP_CIPHER; +-typedef struct evp_cipher_ctx_st EVP_CIPHER_CTX; +-typedef struct evp_md_st EVP_MD; +-typedef struct evp_md_ctx_st EVP_MD_CTX; +-typedef struct evp_pkey_st EVP_PKEY; +- +-typedef struct evp_pkey_asn1_method_st EVP_PKEY_ASN1_METHOD; +- +-typedef struct evp_pkey_method_st EVP_PKEY_METHOD; +-typedef struct evp_pkey_ctx_st EVP_PKEY_CTX; +- +-typedef struct evp_Encode_Ctx_st EVP_ENCODE_CTX; +- +-typedef struct hmac_ctx_st HMAC_CTX; +- +-typedef struct dh_st DH; +-typedef struct dh_method DH_METHOD; +- +-typedef struct dsa_st DSA; +-typedef struct dsa_method DSA_METHOD; +- +-typedef struct rsa_st RSA; +-typedef struct rsa_meth_st RSA_METHOD; +-typedef struct rsa_pss_params_st RSA_PSS_PARAMS; +- +-typedef struct ec_key_st EC_KEY; +-typedef struct ec_key_method_st EC_KEY_METHOD; +- +-typedef struct rand_meth_st RAND_METHOD; +-typedef struct rand_drbg_st RAND_DRBG; +- +-typedef struct ssl_dane_st SSL_DANE; +-typedef struct x509_st X509; +-typedef struct X509_algor_st X509_ALGOR; +-typedef struct X509_crl_st X509_CRL; +-typedef struct x509_crl_method_st X509_CRL_METHOD; +-typedef struct x509_revoked_st X509_REVOKED; +-typedef struct X509_name_st X509_NAME; +-typedef struct X509_pubkey_st X509_PUBKEY; +-typedef struct x509_store_st X509_STORE; +-typedef struct x509_store_ctx_st X509_STORE_CTX; +- +-typedef struct x509_object_st X509_OBJECT; +-typedef struct x509_lookup_st X509_LOOKUP; +-typedef struct x509_lookup_method_st X509_LOOKUP_METHOD; +-typedef struct X509_VERIFY_PARAM_st X509_VERIFY_PARAM; +- +-typedef struct x509_sig_info_st X509_SIG_INFO; +- +-typedef struct pkcs8_priv_key_info_st PKCS8_PRIV_KEY_INFO; +- +-typedef struct v3_ext_ctx X509V3_CTX; +-typedef struct conf_st CONF; +-typedef struct ossl_init_settings_st OPENSSL_INIT_SETTINGS; +- +-typedef struct ui_st UI; +-typedef struct ui_method_st UI_METHOD; +- +-typedef struct engine_st ENGINE; +-typedef struct ssl_st SSL; +-typedef struct ssl_ctx_st SSL_CTX; +- +-typedef struct comp_ctx_st COMP_CTX; +-typedef struct comp_method_st COMP_METHOD; +- +-typedef struct X509_POLICY_NODE_st X509_POLICY_NODE; +-typedef struct X509_POLICY_LEVEL_st X509_POLICY_LEVEL; +-typedef struct X509_POLICY_TREE_st X509_POLICY_TREE; +-typedef struct X509_POLICY_CACHE_st X509_POLICY_CACHE; +- +-typedef struct AUTHORITY_KEYID_st AUTHORITY_KEYID; +-typedef struct DIST_POINT_st DIST_POINT; +-typedef struct ISSUING_DIST_POINT_st ISSUING_DIST_POINT; +-typedef struct NAME_CONSTRAINTS_st NAME_CONSTRAINTS; +- +-typedef struct crypto_ex_data_st CRYPTO_EX_DATA; +- +-typedef struct ocsp_req_ctx_st OCSP_REQ_CTX; +-typedef struct ocsp_response_st OCSP_RESPONSE; +-typedef struct ocsp_responder_id_st OCSP_RESPID; +- +-typedef struct sct_st SCT; +-typedef struct sct_ctx_st SCT_CTX; +-typedef struct ctlog_st CTLOG; +-typedef struct ctlog_store_st CTLOG_STORE; +-typedef struct ct_policy_eval_ctx_st CT_POLICY_EVAL_CTX; +- +-typedef struct ossl_store_info_st OSSL_STORE_INFO; +-typedef struct ossl_store_search_st OSSL_STORE_SEARCH; +- +-#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L && \ +- defined(INTMAX_MAX) && defined(UINTMAX_MAX) +-typedef intmax_t ossl_intmax_t; +-typedef uintmax_t ossl_uintmax_t; +-#else +-/* +- * Not long long, because the C-library can only be expected to provide +- * strtoll(), strtoull() at the same time as intmax_t and strtoimax(), +- * strtoumax(). Since we use these for parsing arguments, we need the +- * conversion functions, not just the sizes. +- */ +-typedef long ossl_intmax_t; +-typedef unsigned long ossl_uintmax_t; +-#endif +- +-#ifdef __cplusplus +-} +-#endif +-#endif /* def HEADER_OPENSSL_TYPES_H */ +diff --git a/uadk_tool/include/openssl/pem.h b/uadk_tool/include/openssl/pem.h +deleted file mode 100644 +index 2ef5b5d..0000000 +--- a/uadk_tool/include/openssl/pem.h ++++ /dev/null +@@ -1,378 +0,0 @@ +-/* +- * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_PEM_H +-# define HEADER_PEM_H +- +-# include +-# include +-# include +-# include +-# include +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-# define PEM_BUFSIZE 1024 +- +-# define PEM_STRING_X509_OLD "X509 CERTIFICATE" +-# define PEM_STRING_X509 "CERTIFICATE" +-# define PEM_STRING_X509_TRUSTED "TRUSTED CERTIFICATE" +-# define PEM_STRING_X509_REQ_OLD "NEW CERTIFICATE REQUEST" +-# define PEM_STRING_X509_REQ "CERTIFICATE REQUEST" +-# define PEM_STRING_X509_CRL "X509 CRL" +-# define PEM_STRING_EVP_PKEY "ANY PRIVATE KEY" +-# define PEM_STRING_PUBLIC "PUBLIC KEY" +-# define PEM_STRING_RSA "RSA PRIVATE KEY" +-# define PEM_STRING_RSA_PUBLIC "RSA PUBLIC KEY" +-# define PEM_STRING_DSA "DSA PRIVATE KEY" +-# define PEM_STRING_DSA_PUBLIC "DSA PUBLIC KEY" +-# define PEM_STRING_PKCS7 "PKCS7" +-# define PEM_STRING_PKCS7_SIGNED "PKCS #7 SIGNED DATA" +-# define PEM_STRING_PKCS8 "ENCRYPTED PRIVATE KEY" +-# define PEM_STRING_PKCS8INF "PRIVATE KEY" +-# define PEM_STRING_DHPARAMS "DH PARAMETERS" +-# define PEM_STRING_DHXPARAMS "X9.42 DH PARAMETERS" +-# define PEM_STRING_SSL_SESSION "SSL SESSION PARAMETERS" +-# define PEM_STRING_DSAPARAMS "DSA PARAMETERS" +-# define PEM_STRING_ECDSA_PUBLIC "ECDSA PUBLIC KEY" +-# define PEM_STRING_ECPARAMETERS "EC PARAMETERS" +-# define PEM_STRING_ECPRIVATEKEY "EC PRIVATE KEY" +-# define PEM_STRING_PARAMETERS "PARAMETERS" +-# define PEM_STRING_CMS "CMS" +- +-# define PEM_TYPE_ENCRYPTED 10 +-# define PEM_TYPE_MIC_ONLY 20 +-# define PEM_TYPE_MIC_CLEAR 30 +-# define PEM_TYPE_CLEAR 40 +- +-/* +- * These macros make the PEM_read/PEM_write functions easier to maintain and +- * write. Now they are all implemented with either: IMPLEMENT_PEM_rw(...) or +- * IMPLEMENT_PEM_rw_cb(...) +- */ +- +-# ifdef OPENSSL_NO_STDIO +- +-# define IMPLEMENT_PEM_read_fp(name, type, str, asn1) /**/ +-# define IMPLEMENT_PEM_write_fp(name, type, str, asn1) /**/ +-# define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) /**/ +-# define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) /**/ +-# define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) /**/ +-# else +- +-# define IMPLEMENT_PEM_read_fp(name, type, str, asn1) \ +-type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u)\ +-{ \ +-return PEM_ASN1_read((d2i_of_void *)d2i_##asn1, str,fp,(void **)x,cb,u); \ +-} +- +-# define IMPLEMENT_PEM_write_fp(name, type, str, asn1) \ +-int PEM_write_##name(FILE *fp, type *x) \ +-{ \ +-return PEM_ASN1_write((i2d_of_void *)i2d_##asn1,str,fp,x,NULL,NULL,0,NULL,NULL); \ +-} +- +-# define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) \ +-int PEM_write_##name(FILE *fp, const type *x) \ +-{ \ +-return PEM_ASN1_write((i2d_of_void *)i2d_##asn1,str,fp,(void *)x,NULL,NULL,0,NULL,NULL); \ +-} +- +-# define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) \ +-int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \ +- unsigned char *kstr, int klen, pem_password_cb *cb, \ +- void *u) \ +- { \ +- return PEM_ASN1_write((i2d_of_void *)i2d_##asn1,str,fp,x,enc,kstr,klen,cb,u); \ +- } +- +-# define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) \ +-int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \ +- unsigned char *kstr, int klen, pem_password_cb *cb, \ +- void *u) \ +- { \ +- return PEM_ASN1_write((i2d_of_void *)i2d_##asn1,str,fp,x,enc,kstr,klen,cb,u); \ +- } +- +-# endif +- +-# define IMPLEMENT_PEM_read_bio(name, type, str, asn1) \ +-type *PEM_read_bio_##name(BIO *bp, type **x, pem_password_cb *cb, void *u)\ +-{ \ +-return PEM_ASN1_read_bio((d2i_of_void *)d2i_##asn1, str,bp,(void **)x,cb,u); \ +-} +- +-# define IMPLEMENT_PEM_write_bio(name, type, str, asn1) \ +-int PEM_write_bio_##name(BIO *bp, type *x) \ +-{ \ +-return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1,str,bp,x,NULL,NULL,0,NULL,NULL); \ +-} +- +-# define IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \ +-int PEM_write_bio_##name(BIO *bp, const type *x) \ +-{ \ +-return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1,str,bp,(void *)x,NULL,NULL,0,NULL,NULL); \ +-} +- +-# define IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \ +-int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \ +- unsigned char *kstr, int klen, pem_password_cb *cb, void *u) \ +- { \ +- return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1,str,bp,x,enc,kstr,klen,cb,u); \ +- } +- +-# define IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \ +-int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \ +- unsigned char *kstr, int klen, pem_password_cb *cb, void *u) \ +- { \ +- return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1,str,bp,(void *)x,enc,kstr,klen,cb,u); \ +- } +- +-# define IMPLEMENT_PEM_write(name, type, str, asn1) \ +- IMPLEMENT_PEM_write_bio(name, type, str, asn1) \ +- IMPLEMENT_PEM_write_fp(name, type, str, asn1) +- +-# define IMPLEMENT_PEM_write_const(name, type, str, asn1) \ +- IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \ +- IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) +- +-# define IMPLEMENT_PEM_write_cb(name, type, str, asn1) \ +- IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \ +- IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) +- +-# define IMPLEMENT_PEM_write_cb_const(name, type, str, asn1) \ +- IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \ +- IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) +- +-# define IMPLEMENT_PEM_read(name, type, str, asn1) \ +- IMPLEMENT_PEM_read_bio(name, type, str, asn1) \ +- IMPLEMENT_PEM_read_fp(name, type, str, asn1) +- +-# define IMPLEMENT_PEM_rw(name, type, str, asn1) \ +- IMPLEMENT_PEM_read(name, type, str, asn1) \ +- IMPLEMENT_PEM_write(name, type, str, asn1) +- +-# define IMPLEMENT_PEM_rw_const(name, type, str, asn1) \ +- IMPLEMENT_PEM_read(name, type, str, asn1) \ +- IMPLEMENT_PEM_write_const(name, type, str, asn1) +- +-# define IMPLEMENT_PEM_rw_cb(name, type, str, asn1) \ +- IMPLEMENT_PEM_read(name, type, str, asn1) \ +- IMPLEMENT_PEM_write_cb(name, type, str, asn1) +- +-/* These are the same except they are for the declarations */ +- +-# if defined(OPENSSL_NO_STDIO) +- +-# define DECLARE_PEM_read_fp(name, type) /**/ +-# define DECLARE_PEM_write_fp(name, type) /**/ +-# define DECLARE_PEM_write_fp_const(name, type) /**/ +-# define DECLARE_PEM_write_cb_fp(name, type) /**/ +-# else +- +-# define DECLARE_PEM_read_fp(name, type) \ +- type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u); +- +-# define DECLARE_PEM_write_fp(name, type) \ +- int PEM_write_##name(FILE *fp, type *x); +- +-# define DECLARE_PEM_write_fp_const(name, type) \ +- int PEM_write_##name(FILE *fp, const type *x); +- +-# define DECLARE_PEM_write_cb_fp(name, type) \ +- int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \ +- unsigned char *kstr, int klen, pem_password_cb *cb, void *u); +- +-# endif +- +-# define DECLARE_PEM_read_bio(name, type) \ +- type *PEM_read_bio_##name(BIO *bp, type **x, pem_password_cb *cb, void *u); +- +-# define DECLARE_PEM_write_bio(name, type) \ +- int PEM_write_bio_##name(BIO *bp, type *x); +- +-# define DECLARE_PEM_write_bio_const(name, type) \ +- int PEM_write_bio_##name(BIO *bp, const type *x); +- +-# define DECLARE_PEM_write_cb_bio(name, type) \ +- int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \ +- unsigned char *kstr, int klen, pem_password_cb *cb, void *u); +- +-# define DECLARE_PEM_write(name, type) \ +- DECLARE_PEM_write_bio(name, type) \ +- DECLARE_PEM_write_fp(name, type) +-# define DECLARE_PEM_write_const(name, type) \ +- DECLARE_PEM_write_bio_const(name, type) \ +- DECLARE_PEM_write_fp_const(name, type) +-# define DECLARE_PEM_write_cb(name, type) \ +- DECLARE_PEM_write_cb_bio(name, type) \ +- DECLARE_PEM_write_cb_fp(name, type) +-# define DECLARE_PEM_read(name, type) \ +- DECLARE_PEM_read_bio(name, type) \ +- DECLARE_PEM_read_fp(name, type) +-# define DECLARE_PEM_rw(name, type) \ +- DECLARE_PEM_read(name, type) \ +- DECLARE_PEM_write(name, type) +-# define DECLARE_PEM_rw_const(name, type) \ +- DECLARE_PEM_read(name, type) \ +- DECLARE_PEM_write_const(name, type) +-# define DECLARE_PEM_rw_cb(name, type) \ +- DECLARE_PEM_read(name, type) \ +- DECLARE_PEM_write_cb(name, type) +-typedef int pem_password_cb (char *buf, int size, int rwflag, void *userdata); +- +-int PEM_get_EVP_CIPHER_INFO(char *header, EVP_CIPHER_INFO *cipher); +-int PEM_do_header(EVP_CIPHER_INFO *cipher, unsigned char *data, long *len, +- pem_password_cb *callback, void *u); +- +-int PEM_read_bio(BIO *bp, char **name, char **header, +- unsigned char **data, long *len); +-# define PEM_FLAG_SECURE 0x1 +-# define PEM_FLAG_EAY_COMPATIBLE 0x2 +-# define PEM_FLAG_ONLY_B64 0x4 +-int PEM_read_bio_ex(BIO *bp, char **name, char **header, +- unsigned char **data, long *len, unsigned int flags); +-int PEM_bytes_read_bio_secmem(unsigned char **pdata, long *plen, char **pnm, +- const char *name, BIO *bp, pem_password_cb *cb, +- void *u); +-int PEM_write_bio(BIO *bp, const char *name, const char *hdr, +- const unsigned char *data, long len); +-int PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm, +- const char *name, BIO *bp, pem_password_cb *cb, +- void *u); +-void *PEM_ASN1_read_bio(d2i_of_void *d2i, const char *name, BIO *bp, void **x, +- pem_password_cb *cb, void *u); +-int PEM_ASN1_write_bio(i2d_of_void *i2d, const char *name, BIO *bp, void *x, +- const EVP_CIPHER *enc, unsigned char *kstr, int klen, +- pem_password_cb *cb, void *u); +- +-STACK_OF(X509_INFO) *PEM_X509_INFO_read_bio(BIO *bp, STACK_OF(X509_INFO) *sk, +- pem_password_cb *cb, void *u); +-int PEM_X509_INFO_write_bio(BIO *bp, X509_INFO *xi, EVP_CIPHER *enc, +- unsigned char *kstr, int klen, +- pem_password_cb *cd, void *u); +- +-#ifndef OPENSSL_NO_STDIO +-int PEM_read(FILE *fp, char **name, char **header, +- unsigned char **data, long *len); +-int PEM_write(FILE *fp, const char *name, const char *hdr, +- const unsigned char *data, long len); +-void *PEM_ASN1_read(d2i_of_void *d2i, const char *name, FILE *fp, void **x, +- pem_password_cb *cb, void *u); +-int PEM_ASN1_write(i2d_of_void *i2d, const char *name, FILE *fp, +- void *x, const EVP_CIPHER *enc, unsigned char *kstr, +- int klen, pem_password_cb *callback, void *u); +-STACK_OF(X509_INFO) *PEM_X509_INFO_read(FILE *fp, STACK_OF(X509_INFO) *sk, +- pem_password_cb *cb, void *u); +-#endif +- +-int PEM_SignInit(EVP_MD_CTX *ctx, EVP_MD *type); +-int PEM_SignUpdate(EVP_MD_CTX *ctx, unsigned char *d, unsigned int cnt); +-int PEM_SignFinal(EVP_MD_CTX *ctx, unsigned char *sigret, +- unsigned int *siglen, EVP_PKEY *pkey); +- +-/* The default pem_password_cb that's used internally */ +-int PEM_def_callback(char *buf, int num, int rwflag, void *userdata); +-void PEM_proc_type(char *buf, int type); +-void PEM_dek_info(char *buf, const char *type, int len, char *str); +- +-# include +- +-DECLARE_PEM_rw(X509, X509) +-DECLARE_PEM_rw(X509_AUX, X509) +-DECLARE_PEM_rw(X509_REQ, X509_REQ) +-DECLARE_PEM_write(X509_REQ_NEW, X509_REQ) +-DECLARE_PEM_rw(X509_CRL, X509_CRL) +-DECLARE_PEM_rw(PKCS7, PKCS7) +-DECLARE_PEM_rw(NETSCAPE_CERT_SEQUENCE, NETSCAPE_CERT_SEQUENCE) +-DECLARE_PEM_rw(PKCS8, X509_SIG) +-DECLARE_PEM_rw(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO) +-# ifndef OPENSSL_NO_RSA +-DECLARE_PEM_rw_cb(RSAPrivateKey, RSA) +-DECLARE_PEM_rw_const(RSAPublicKey, RSA) +-DECLARE_PEM_rw(RSA_PUBKEY, RSA) +-# endif +-# ifndef OPENSSL_NO_DSA +-DECLARE_PEM_rw_cb(DSAPrivateKey, DSA) +-DECLARE_PEM_rw(DSA_PUBKEY, DSA) +-DECLARE_PEM_rw_const(DSAparams, DSA) +-# endif +-# ifndef OPENSSL_NO_EC +-DECLARE_PEM_rw_const(ECPKParameters, EC_GROUP) +-DECLARE_PEM_rw_cb(ECPrivateKey, EC_KEY) +-DECLARE_PEM_rw(EC_PUBKEY, EC_KEY) +-# endif +-# ifndef OPENSSL_NO_DH +-DECLARE_PEM_rw_const(DHparams, DH) +-DECLARE_PEM_write_const(DHxparams, DH) +-# endif +-DECLARE_PEM_rw_cb(PrivateKey, EVP_PKEY) +-DECLARE_PEM_rw(PUBKEY, EVP_PKEY) +- +-int PEM_write_bio_PrivateKey_traditional(BIO *bp, EVP_PKEY *x, +- const EVP_CIPHER *enc, +- unsigned char *kstr, int klen, +- pem_password_cb *cb, void *u); +- +-int PEM_write_bio_PKCS8PrivateKey_nid(BIO *bp, EVP_PKEY *x, int nid, +- char *kstr, int klen, +- pem_password_cb *cb, void *u); +-int PEM_write_bio_PKCS8PrivateKey(BIO *, EVP_PKEY *, const EVP_CIPHER *, +- char *, int, pem_password_cb *, void *); +-int i2d_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc, +- char *kstr, int klen, +- pem_password_cb *cb, void *u); +-int i2d_PKCS8PrivateKey_nid_bio(BIO *bp, EVP_PKEY *x, int nid, +- char *kstr, int klen, +- pem_password_cb *cb, void *u); +-EVP_PKEY *d2i_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY **x, pem_password_cb *cb, +- void *u); +- +-# ifndef OPENSSL_NO_STDIO +-int i2d_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc, +- char *kstr, int klen, +- pem_password_cb *cb, void *u); +-int i2d_PKCS8PrivateKey_nid_fp(FILE *fp, EVP_PKEY *x, int nid, +- char *kstr, int klen, +- pem_password_cb *cb, void *u); +-int PEM_write_PKCS8PrivateKey_nid(FILE *fp, EVP_PKEY *x, int nid, +- char *kstr, int klen, +- pem_password_cb *cb, void *u); +- +-EVP_PKEY *d2i_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY **x, pem_password_cb *cb, +- void *u); +- +-int PEM_write_PKCS8PrivateKey(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc, +- char *kstr, int klen, pem_password_cb *cd, +- void *u); +-# endif +-EVP_PKEY *PEM_read_bio_Parameters(BIO *bp, EVP_PKEY **x); +-int PEM_write_bio_Parameters(BIO *bp, EVP_PKEY *x); +- +-# ifndef OPENSSL_NO_DSA +-EVP_PKEY *b2i_PrivateKey(const unsigned char **in, long length); +-EVP_PKEY *b2i_PublicKey(const unsigned char **in, long length); +-EVP_PKEY *b2i_PrivateKey_bio(BIO *in); +-EVP_PKEY *b2i_PublicKey_bio(BIO *in); +-int i2b_PrivateKey_bio(BIO *out, EVP_PKEY *pk); +-int i2b_PublicKey_bio(BIO *out, EVP_PKEY *pk); +-# ifndef OPENSSL_NO_RC4 +-EVP_PKEY *b2i_PVK_bio(BIO *in, pem_password_cb *cb, void *u); +-int i2b_PVK_bio(BIO *out, EVP_PKEY *pk, int enclevel, +- pem_password_cb *cb, void *u); +-# endif +-# endif +- +-# ifdef __cplusplus +-} +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/pem2.h b/uadk_tool/include/openssl/pem2.h +deleted file mode 100644 +index 038fe79..0000000 +--- a/uadk_tool/include/openssl/pem2.h ++++ /dev/null +@@ -1,13 +0,0 @@ +-/* +- * Copyright 1999-2018 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_PEM2_H +-# define HEADER_PEM2_H +-# include +-#endif +diff --git a/uadk_tool/include/openssl/pemerr.h b/uadk_tool/include/openssl/pemerr.h +deleted file mode 100644 +index 4f7e357..0000000 +--- a/uadk_tool/include/openssl/pemerr.h ++++ /dev/null +@@ -1,105 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_PEMERR_H +-# define HEADER_PEMERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_PEM_strings(void); +- +-/* +- * PEM function codes. +- */ +-# define PEM_F_B2I_DSS 127 +-# define PEM_F_B2I_PVK_BIO 128 +-# define PEM_F_B2I_RSA 129 +-# define PEM_F_CHECK_BITLEN_DSA 130 +-# define PEM_F_CHECK_BITLEN_RSA 131 +-# define PEM_F_D2I_PKCS8PRIVATEKEY_BIO 120 +-# define PEM_F_D2I_PKCS8PRIVATEKEY_FP 121 +-# define PEM_F_DO_B2I 132 +-# define PEM_F_DO_B2I_BIO 133 +-# define PEM_F_DO_BLOB_HEADER 134 +-# define PEM_F_DO_I2B 146 +-# define PEM_F_DO_PK8PKEY 126 +-# define PEM_F_DO_PK8PKEY_FP 125 +-# define PEM_F_DO_PVK_BODY 135 +-# define PEM_F_DO_PVK_HEADER 136 +-# define PEM_F_GET_HEADER_AND_DATA 143 +-# define PEM_F_GET_NAME 144 +-# define PEM_F_I2B_PVK 137 +-# define PEM_F_I2B_PVK_BIO 138 +-# define PEM_F_LOAD_IV 101 +-# define PEM_F_PEM_ASN1_READ 102 +-# define PEM_F_PEM_ASN1_READ_BIO 103 +-# define PEM_F_PEM_ASN1_WRITE 104 +-# define PEM_F_PEM_ASN1_WRITE_BIO 105 +-# define PEM_F_PEM_DEF_CALLBACK 100 +-# define PEM_F_PEM_DO_HEADER 106 +-# define PEM_F_PEM_GET_EVP_CIPHER_INFO 107 +-# define PEM_F_PEM_READ 108 +-# define PEM_F_PEM_READ_BIO 109 +-# define PEM_F_PEM_READ_BIO_DHPARAMS 141 +-# define PEM_F_PEM_READ_BIO_EX 145 +-# define PEM_F_PEM_READ_BIO_PARAMETERS 140 +-# define PEM_F_PEM_READ_BIO_PRIVATEKEY 123 +-# define PEM_F_PEM_READ_DHPARAMS 142 +-# define PEM_F_PEM_READ_PRIVATEKEY 124 +-# define PEM_F_PEM_SIGNFINAL 112 +-# define PEM_F_PEM_WRITE 113 +-# define PEM_F_PEM_WRITE_BIO 114 +-# define PEM_F_PEM_WRITE_BIO_PRIVATEKEY_TRADITIONAL 147 +-# define PEM_F_PEM_WRITE_PRIVATEKEY 139 +-# define PEM_F_PEM_X509_INFO_READ 115 +-# define PEM_F_PEM_X509_INFO_READ_BIO 116 +-# define PEM_F_PEM_X509_INFO_WRITE_BIO 117 +- +-/* +- * PEM reason codes. +- */ +-# define PEM_R_BAD_BASE64_DECODE 100 +-# define PEM_R_BAD_DECRYPT 101 +-# define PEM_R_BAD_END_LINE 102 +-# define PEM_R_BAD_IV_CHARS 103 +-# define PEM_R_BAD_MAGIC_NUMBER 116 +-# define PEM_R_BAD_PASSWORD_READ 104 +-# define PEM_R_BAD_VERSION_NUMBER 117 +-# define PEM_R_BIO_WRITE_FAILURE 118 +-# define PEM_R_CIPHER_IS_NULL 127 +-# define PEM_R_ERROR_CONVERTING_PRIVATE_KEY 115 +-# define PEM_R_EXPECTING_PRIVATE_KEY_BLOB 119 +-# define PEM_R_EXPECTING_PUBLIC_KEY_BLOB 120 +-# define PEM_R_HEADER_TOO_LONG 128 +-# define PEM_R_INCONSISTENT_HEADER 121 +-# define PEM_R_KEYBLOB_HEADER_PARSE_ERROR 122 +-# define PEM_R_KEYBLOB_TOO_SHORT 123 +-# define PEM_R_MISSING_DEK_IV 129 +-# define PEM_R_NOT_DEK_INFO 105 +-# define PEM_R_NOT_ENCRYPTED 106 +-# define PEM_R_NOT_PROC_TYPE 107 +-# define PEM_R_NO_START_LINE 108 +-# define PEM_R_PROBLEMS_GETTING_PASSWORD 109 +-# define PEM_R_PVK_DATA_TOO_SHORT 124 +-# define PEM_R_PVK_TOO_SHORT 125 +-# define PEM_R_READ_KEY 111 +-# define PEM_R_SHORT_HEADER 112 +-# define PEM_R_UNEXPECTED_DEK_IV 130 +-# define PEM_R_UNSUPPORTED_CIPHER 113 +-# define PEM_R_UNSUPPORTED_ENCRYPTION 114 +-# define PEM_R_UNSUPPORTED_KEY_COMPONENTS 126 +-# define PEM_R_UNSUPPORTED_PUBLIC_KEY_TYPE 110 +- +-#endif +diff --git a/uadk_tool/include/openssl/pkcs12.h b/uadk_tool/include/openssl/pkcs12.h +deleted file mode 100644 +index 3f43dad..0000000 +--- a/uadk_tool/include/openssl/pkcs12.h ++++ /dev/null +@@ -1,223 +0,0 @@ +-/* +- * Copyright 1999-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_PKCS12_H +-# define HEADER_PKCS12_H +- +-# include +-# include +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-# define PKCS12_KEY_ID 1 +-# define PKCS12_IV_ID 2 +-# define PKCS12_MAC_ID 3 +- +-/* Default iteration count */ +-# ifndef PKCS12_DEFAULT_ITER +-# define PKCS12_DEFAULT_ITER PKCS5_DEFAULT_ITER +-# endif +- +-# define PKCS12_MAC_KEY_LENGTH 20 +- +-# define PKCS12_SALT_LEN 8 +- +-/* It's not clear if these are actually needed... */ +-# define PKCS12_key_gen PKCS12_key_gen_utf8 +-# define PKCS12_add_friendlyname PKCS12_add_friendlyname_utf8 +- +-/* MS key usage constants */ +- +-# define KEY_EX 0x10 +-# define KEY_SIG 0x80 +- +-typedef struct PKCS12_MAC_DATA_st PKCS12_MAC_DATA; +- +-typedef struct PKCS12_st PKCS12; +- +-typedef struct PKCS12_SAFEBAG_st PKCS12_SAFEBAG; +- +-DEFINE_STACK_OF(PKCS12_SAFEBAG) +- +-typedef struct pkcs12_bag_st PKCS12_BAGS; +- +-# define PKCS12_ERROR 0 +-# define PKCS12_OK 1 +- +-/* Compatibility macros */ +- +-#if OPENSSL_API_COMPAT < 0x10100000L +- +-# define M_PKCS12_bag_type PKCS12_bag_type +-# define M_PKCS12_cert_bag_type PKCS12_cert_bag_type +-# define M_PKCS12_crl_bag_type PKCS12_cert_bag_type +- +-# define PKCS12_certbag2x509 PKCS12_SAFEBAG_get1_cert +-# define PKCS12_certbag2scrl PKCS12_SAFEBAG_get1_crl +-# define PKCS12_bag_type PKCS12_SAFEBAG_get_nid +-# define PKCS12_cert_bag_type PKCS12_SAFEBAG_get_bag_nid +-# define PKCS12_x5092certbag PKCS12_SAFEBAG_create_cert +-# define PKCS12_x509crl2certbag PKCS12_SAFEBAG_create_crl +-# define PKCS12_MAKE_KEYBAG PKCS12_SAFEBAG_create0_p8inf +-# define PKCS12_MAKE_SHKEYBAG PKCS12_SAFEBAG_create_pkcs8_encrypt +- +-#endif +- +-DEPRECATEDIN_1_1_0(ASN1_TYPE *PKCS12_get_attr(const PKCS12_SAFEBAG *bag, int attr_nid)) +- +-ASN1_TYPE *PKCS8_get_attr(PKCS8_PRIV_KEY_INFO *p8, int attr_nid); +-int PKCS12_mac_present(const PKCS12 *p12); +-void PKCS12_get0_mac(const ASN1_OCTET_STRING **pmac, +- const X509_ALGOR **pmacalg, +- const ASN1_OCTET_STRING **psalt, +- const ASN1_INTEGER **piter, +- const PKCS12 *p12); +- +-const ASN1_TYPE *PKCS12_SAFEBAG_get0_attr(const PKCS12_SAFEBAG *bag, +- int attr_nid); +-const ASN1_OBJECT *PKCS12_SAFEBAG_get0_type(const PKCS12_SAFEBAG *bag); +-int PKCS12_SAFEBAG_get_nid(const PKCS12_SAFEBAG *bag); +-int PKCS12_SAFEBAG_get_bag_nid(const PKCS12_SAFEBAG *bag); +- +-X509 *PKCS12_SAFEBAG_get1_cert(const PKCS12_SAFEBAG *bag); +-X509_CRL *PKCS12_SAFEBAG_get1_crl(const PKCS12_SAFEBAG *bag); +-const STACK_OF(PKCS12_SAFEBAG) * +-PKCS12_SAFEBAG_get0_safes(const PKCS12_SAFEBAG *bag); +-const PKCS8_PRIV_KEY_INFO *PKCS12_SAFEBAG_get0_p8inf(const PKCS12_SAFEBAG *bag); +-const X509_SIG *PKCS12_SAFEBAG_get0_pkcs8(const PKCS12_SAFEBAG *bag); +- +-PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_cert(X509 *x509); +-PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_crl(X509_CRL *crl); +-PKCS12_SAFEBAG *PKCS12_SAFEBAG_create0_p8inf(PKCS8_PRIV_KEY_INFO *p8); +-PKCS12_SAFEBAG *PKCS12_SAFEBAG_create0_pkcs8(X509_SIG *p8); +-PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_pkcs8_encrypt(int pbe_nid, +- const char *pass, +- int passlen, +- unsigned char *salt, +- int saltlen, int iter, +- PKCS8_PRIV_KEY_INFO *p8inf); +- +-PKCS12_SAFEBAG *PKCS12_item_pack_safebag(void *obj, const ASN1_ITEM *it, +- int nid1, int nid2); +-PKCS8_PRIV_KEY_INFO *PKCS8_decrypt(const X509_SIG *p8, const char *pass, +- int passlen); +-PKCS8_PRIV_KEY_INFO *PKCS12_decrypt_skey(const PKCS12_SAFEBAG *bag, +- const char *pass, int passlen); +-X509_SIG *PKCS8_encrypt(int pbe_nid, const EVP_CIPHER *cipher, +- const char *pass, int passlen, unsigned char *salt, +- int saltlen, int iter, PKCS8_PRIV_KEY_INFO *p8); +-X509_SIG *PKCS8_set0_pbe(const char *pass, int passlen, +- PKCS8_PRIV_KEY_INFO *p8inf, X509_ALGOR *pbe); +-PKCS7 *PKCS12_pack_p7data(STACK_OF(PKCS12_SAFEBAG) *sk); +-STACK_OF(PKCS12_SAFEBAG) *PKCS12_unpack_p7data(PKCS7 *p7); +-PKCS7 *PKCS12_pack_p7encdata(int pbe_nid, const char *pass, int passlen, +- unsigned char *salt, int saltlen, int iter, +- STACK_OF(PKCS12_SAFEBAG) *bags); +-STACK_OF(PKCS12_SAFEBAG) *PKCS12_unpack_p7encdata(PKCS7 *p7, const char *pass, +- int passlen); +- +-int PKCS12_pack_authsafes(PKCS12 *p12, STACK_OF(PKCS7) *safes); +-STACK_OF(PKCS7) *PKCS12_unpack_authsafes(const PKCS12 *p12); +- +-int PKCS12_add_localkeyid(PKCS12_SAFEBAG *bag, unsigned char *name, +- int namelen); +-int PKCS12_add_friendlyname_asc(PKCS12_SAFEBAG *bag, const char *name, +- int namelen); +-int PKCS12_add_friendlyname_utf8(PKCS12_SAFEBAG *bag, const char *name, +- int namelen); +-int PKCS12_add_CSPName_asc(PKCS12_SAFEBAG *bag, const char *name, +- int namelen); +-int PKCS12_add_friendlyname_uni(PKCS12_SAFEBAG *bag, +- const unsigned char *name, int namelen); +-int PKCS8_add_keyusage(PKCS8_PRIV_KEY_INFO *p8, int usage); +-ASN1_TYPE *PKCS12_get_attr_gen(const STACK_OF(X509_ATTRIBUTE) *attrs, +- int attr_nid); +-char *PKCS12_get_friendlyname(PKCS12_SAFEBAG *bag); +-const STACK_OF(X509_ATTRIBUTE) * +-PKCS12_SAFEBAG_get0_attrs(const PKCS12_SAFEBAG *bag); +-unsigned char *PKCS12_pbe_crypt(const X509_ALGOR *algor, +- const char *pass, int passlen, +- const unsigned char *in, int inlen, +- unsigned char **data, int *datalen, +- int en_de); +-void *PKCS12_item_decrypt_d2i(const X509_ALGOR *algor, const ASN1_ITEM *it, +- const char *pass, int passlen, +- const ASN1_OCTET_STRING *oct, int zbuf); +-ASN1_OCTET_STRING *PKCS12_item_i2d_encrypt(X509_ALGOR *algor, +- const ASN1_ITEM *it, +- const char *pass, int passlen, +- void *obj, int zbuf); +-PKCS12 *PKCS12_init(int mode); +-int PKCS12_key_gen_asc(const char *pass, int passlen, unsigned char *salt, +- int saltlen, int id, int iter, int n, +- unsigned char *out, const EVP_MD *md_type); +-int PKCS12_key_gen_uni(unsigned char *pass, int passlen, unsigned char *salt, +- int saltlen, int id, int iter, int n, +- unsigned char *out, const EVP_MD *md_type); +-int PKCS12_key_gen_utf8(const char *pass, int passlen, unsigned char *salt, +- int saltlen, int id, int iter, int n, +- unsigned char *out, const EVP_MD *md_type); +-int PKCS12_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen, +- ASN1_TYPE *param, const EVP_CIPHER *cipher, +- const EVP_MD *md_type, int en_de); +-int PKCS12_gen_mac(PKCS12 *p12, const char *pass, int passlen, +- unsigned char *mac, unsigned int *maclen); +-int PKCS12_verify_mac(PKCS12 *p12, const char *pass, int passlen); +-int PKCS12_set_mac(PKCS12 *p12, const char *pass, int passlen, +- unsigned char *salt, int saltlen, int iter, +- const EVP_MD *md_type); +-int PKCS12_setup_mac(PKCS12 *p12, int iter, unsigned char *salt, +- int saltlen, const EVP_MD *md_type); +-unsigned char *OPENSSL_asc2uni(const char *asc, int asclen, +- unsigned char **uni, int *unilen); +-char *OPENSSL_uni2asc(const unsigned char *uni, int unilen); +-unsigned char *OPENSSL_utf82uni(const char *asc, int asclen, +- unsigned char **uni, int *unilen); +-char *OPENSSL_uni2utf8(const unsigned char *uni, int unilen); +- +-DECLARE_ASN1_FUNCTIONS(PKCS12) +-DECLARE_ASN1_FUNCTIONS(PKCS12_MAC_DATA) +-DECLARE_ASN1_FUNCTIONS(PKCS12_SAFEBAG) +-DECLARE_ASN1_FUNCTIONS(PKCS12_BAGS) +- +-DECLARE_ASN1_ITEM(PKCS12_SAFEBAGS) +-DECLARE_ASN1_ITEM(PKCS12_AUTHSAFES) +- +-void PKCS12_PBE_add(void); +-int PKCS12_parse(PKCS12 *p12, const char *pass, EVP_PKEY **pkey, X509 **cert, +- STACK_OF(X509) **ca); +-PKCS12 *PKCS12_create(const char *pass, const char *name, EVP_PKEY *pkey, +- X509 *cert, STACK_OF(X509) *ca, int nid_key, int nid_cert, +- int iter, int mac_iter, int keytype); +- +-PKCS12_SAFEBAG *PKCS12_add_cert(STACK_OF(PKCS12_SAFEBAG) **pbags, X509 *cert); +-PKCS12_SAFEBAG *PKCS12_add_key(STACK_OF(PKCS12_SAFEBAG) **pbags, +- EVP_PKEY *key, int key_usage, int iter, +- int key_nid, const char *pass); +-int PKCS12_add_safe(STACK_OF(PKCS7) **psafes, STACK_OF(PKCS12_SAFEBAG) *bags, +- int safe_nid, int iter, const char *pass); +-PKCS12 *PKCS12_add_safes(STACK_OF(PKCS7) *safes, int p7_nid); +- +-int i2d_PKCS12_bio(BIO *bp, PKCS12 *p12); +-# ifndef OPENSSL_NO_STDIO +-int i2d_PKCS12_fp(FILE *fp, PKCS12 *p12); +-# endif +-PKCS12 *d2i_PKCS12_bio(BIO *bp, PKCS12 **p12); +-# ifndef OPENSSL_NO_STDIO +-PKCS12 *d2i_PKCS12_fp(FILE *fp, PKCS12 **p12); +-# endif +-int PKCS12_newpass(PKCS12 *p12, const char *oldpass, const char *newpass); +- +-# ifdef __cplusplus +-} +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/pkcs12err.h b/uadk_tool/include/openssl/pkcs12err.h +deleted file mode 100644 +index eff5eb2..0000000 +--- a/uadk_tool/include/openssl/pkcs12err.h ++++ /dev/null +@@ -1,81 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_PKCS12ERR_H +-# define HEADER_PKCS12ERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_PKCS12_strings(void); +- +-/* +- * PKCS12 function codes. +- */ +-# define PKCS12_F_OPENSSL_ASC2UNI 121 +-# define PKCS12_F_OPENSSL_UNI2ASC 124 +-# define PKCS12_F_OPENSSL_UNI2UTF8 127 +-# define PKCS12_F_OPENSSL_UTF82UNI 129 +-# define PKCS12_F_PKCS12_CREATE 105 +-# define PKCS12_F_PKCS12_GEN_MAC 107 +-# define PKCS12_F_PKCS12_INIT 109 +-# define PKCS12_F_PKCS12_ITEM_DECRYPT_D2I 106 +-# define PKCS12_F_PKCS12_ITEM_I2D_ENCRYPT 108 +-# define PKCS12_F_PKCS12_ITEM_PACK_SAFEBAG 117 +-# define PKCS12_F_PKCS12_KEY_GEN_ASC 110 +-# define PKCS12_F_PKCS12_KEY_GEN_UNI 111 +-# define PKCS12_F_PKCS12_KEY_GEN_UTF8 116 +-# define PKCS12_F_PKCS12_NEWPASS 128 +-# define PKCS12_F_PKCS12_PACK_P7DATA 114 +-# define PKCS12_F_PKCS12_PACK_P7ENCDATA 115 +-# define PKCS12_F_PKCS12_PARSE 118 +-# define PKCS12_F_PKCS12_PBE_CRYPT 119 +-# define PKCS12_F_PKCS12_PBE_KEYIVGEN 120 +-# define PKCS12_F_PKCS12_SAFEBAG_CREATE0_P8INF 112 +-# define PKCS12_F_PKCS12_SAFEBAG_CREATE0_PKCS8 113 +-# define PKCS12_F_PKCS12_SAFEBAG_CREATE_PKCS8_ENCRYPT 133 +-# define PKCS12_F_PKCS12_SETUP_MAC 122 +-# define PKCS12_F_PKCS12_SET_MAC 123 +-# define PKCS12_F_PKCS12_UNPACK_AUTHSAFES 130 +-# define PKCS12_F_PKCS12_UNPACK_P7DATA 131 +-# define PKCS12_F_PKCS12_VERIFY_MAC 126 +-# define PKCS12_F_PKCS8_ENCRYPT 125 +-# define PKCS12_F_PKCS8_SET0_PBE 132 +- +-/* +- * PKCS12 reason codes. +- */ +-# define PKCS12_R_CANT_PACK_STRUCTURE 100 +-# define PKCS12_R_CONTENT_TYPE_NOT_DATA 121 +-# define PKCS12_R_DECODE_ERROR 101 +-# define PKCS12_R_ENCODE_ERROR 102 +-# define PKCS12_R_ENCRYPT_ERROR 103 +-# define PKCS12_R_ERROR_SETTING_ENCRYPTED_DATA_TYPE 120 +-# define PKCS12_R_INVALID_NULL_ARGUMENT 104 +-# define PKCS12_R_INVALID_NULL_PKCS12_POINTER 105 +-# define PKCS12_R_IV_GEN_ERROR 106 +-# define PKCS12_R_KEY_GEN_ERROR 107 +-# define PKCS12_R_MAC_ABSENT 108 +-# define PKCS12_R_MAC_GENERATION_ERROR 109 +-# define PKCS12_R_MAC_SETUP_ERROR 110 +-# define PKCS12_R_MAC_STRING_SET_ERROR 111 +-# define PKCS12_R_MAC_VERIFY_FAILURE 113 +-# define PKCS12_R_PARSE_ERROR 114 +-# define PKCS12_R_PKCS12_ALGOR_CIPHERINIT_ERROR 115 +-# define PKCS12_R_PKCS12_CIPHERFINAL_ERROR 116 +-# define PKCS12_R_PKCS12_PBE_CRYPT_ERROR 117 +-# define PKCS12_R_UNKNOWN_DIGEST_ALGORITHM 118 +-# define PKCS12_R_UNSUPPORTED_PKCS12_MODE 119 +- +-#endif +diff --git a/uadk_tool/include/openssl/pkcs7.h b/uadk_tool/include/openssl/pkcs7.h +deleted file mode 100644 +index 9b66e00..0000000 +--- a/uadk_tool/include/openssl/pkcs7.h ++++ /dev/null +@@ -1,319 +0,0 @@ +-/* +- * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_PKCS7_H +-# define HEADER_PKCS7_H +- +-# include +-# include +-# include +- +-# include +-# include +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-/*- +-Encryption_ID DES-CBC +-Digest_ID MD5 +-Digest_Encryption_ID rsaEncryption +-Key_Encryption_ID rsaEncryption +-*/ +- +-typedef struct pkcs7_issuer_and_serial_st { +- X509_NAME *issuer; +- ASN1_INTEGER *serial; +-} PKCS7_ISSUER_AND_SERIAL; +- +-typedef struct pkcs7_signer_info_st { +- ASN1_INTEGER *version; /* version 1 */ +- PKCS7_ISSUER_AND_SERIAL *issuer_and_serial; +- X509_ALGOR *digest_alg; +- STACK_OF(X509_ATTRIBUTE) *auth_attr; /* [ 0 ] */ +- X509_ALGOR *digest_enc_alg; +- ASN1_OCTET_STRING *enc_digest; +- STACK_OF(X509_ATTRIBUTE) *unauth_attr; /* [ 1 ] */ +- /* The private key to sign with */ +- EVP_PKEY *pkey; +-} PKCS7_SIGNER_INFO; +- +-DEFINE_STACK_OF(PKCS7_SIGNER_INFO) +- +-typedef struct pkcs7_recip_info_st { +- ASN1_INTEGER *version; /* version 0 */ +- PKCS7_ISSUER_AND_SERIAL *issuer_and_serial; +- X509_ALGOR *key_enc_algor; +- ASN1_OCTET_STRING *enc_key; +- X509 *cert; /* get the pub-key from this */ +-} PKCS7_RECIP_INFO; +- +-DEFINE_STACK_OF(PKCS7_RECIP_INFO) +- +-typedef struct pkcs7_signed_st { +- ASN1_INTEGER *version; /* version 1 */ +- STACK_OF(X509_ALGOR) *md_algs; /* md used */ +- STACK_OF(X509) *cert; /* [ 0 ] */ +- STACK_OF(X509_CRL) *crl; /* [ 1 ] */ +- STACK_OF(PKCS7_SIGNER_INFO) *signer_info; +- struct pkcs7_st *contents; +-} PKCS7_SIGNED; +-/* +- * The above structure is very very similar to PKCS7_SIGN_ENVELOPE. How about +- * merging the two +- */ +- +-typedef struct pkcs7_enc_content_st { +- ASN1_OBJECT *content_type; +- X509_ALGOR *algorithm; +- ASN1_OCTET_STRING *enc_data; /* [ 0 ] */ +- const EVP_CIPHER *cipher; +-} PKCS7_ENC_CONTENT; +- +-typedef struct pkcs7_enveloped_st { +- ASN1_INTEGER *version; /* version 0 */ +- STACK_OF(PKCS7_RECIP_INFO) *recipientinfo; +- PKCS7_ENC_CONTENT *enc_data; +-} PKCS7_ENVELOPE; +- +-typedef struct pkcs7_signedandenveloped_st { +- ASN1_INTEGER *version; /* version 1 */ +- STACK_OF(X509_ALGOR) *md_algs; /* md used */ +- STACK_OF(X509) *cert; /* [ 0 ] */ +- STACK_OF(X509_CRL) *crl; /* [ 1 ] */ +- STACK_OF(PKCS7_SIGNER_INFO) *signer_info; +- PKCS7_ENC_CONTENT *enc_data; +- STACK_OF(PKCS7_RECIP_INFO) *recipientinfo; +-} PKCS7_SIGN_ENVELOPE; +- +-typedef struct pkcs7_digest_st { +- ASN1_INTEGER *version; /* version 0 */ +- X509_ALGOR *md; /* md used */ +- struct pkcs7_st *contents; +- ASN1_OCTET_STRING *digest; +-} PKCS7_DIGEST; +- +-typedef struct pkcs7_encrypted_st { +- ASN1_INTEGER *version; /* version 0 */ +- PKCS7_ENC_CONTENT *enc_data; +-} PKCS7_ENCRYPT; +- +-typedef struct pkcs7_st { +- /* +- * The following is non NULL if it contains ASN1 encoding of this +- * structure +- */ +- unsigned char *asn1; +- long length; +-# define PKCS7_S_HEADER 0 +-# define PKCS7_S_BODY 1 +-# define PKCS7_S_TAIL 2 +- int state; /* used during processing */ +- int detached; +- ASN1_OBJECT *type; +- /* content as defined by the type */ +- /* +- * all encryption/message digests are applied to the 'contents', leaving +- * out the 'type' field. +- */ +- union { +- char *ptr; +- /* NID_pkcs7_data */ +- ASN1_OCTET_STRING *data; +- /* NID_pkcs7_signed */ +- PKCS7_SIGNED *sign; +- /* NID_pkcs7_enveloped */ +- PKCS7_ENVELOPE *enveloped; +- /* NID_pkcs7_signedAndEnveloped */ +- PKCS7_SIGN_ENVELOPE *signed_and_enveloped; +- /* NID_pkcs7_digest */ +- PKCS7_DIGEST *digest; +- /* NID_pkcs7_encrypted */ +- PKCS7_ENCRYPT *encrypted; +- /* Anything else */ +- ASN1_TYPE *other; +- } d; +-} PKCS7; +- +-DEFINE_STACK_OF(PKCS7) +- +-# define PKCS7_OP_SET_DETACHED_SIGNATURE 1 +-# define PKCS7_OP_GET_DETACHED_SIGNATURE 2 +- +-# define PKCS7_get_signed_attributes(si) ((si)->auth_attr) +-# define PKCS7_get_attributes(si) ((si)->unauth_attr) +- +-# define PKCS7_type_is_signed(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_signed) +-# define PKCS7_type_is_encrypted(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_encrypted) +-# define PKCS7_type_is_enveloped(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_enveloped) +-# define PKCS7_type_is_signedAndEnveloped(a) \ +- (OBJ_obj2nid((a)->type) == NID_pkcs7_signedAndEnveloped) +-# define PKCS7_type_is_data(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_data) +-# define PKCS7_type_is_digest(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_digest) +- +-# define PKCS7_set_detached(p,v) \ +- PKCS7_ctrl(p,PKCS7_OP_SET_DETACHED_SIGNATURE,v,NULL) +-# define PKCS7_get_detached(p) \ +- PKCS7_ctrl(p,PKCS7_OP_GET_DETACHED_SIGNATURE,0,NULL) +- +-# define PKCS7_is_detached(p7) (PKCS7_type_is_signed(p7) && PKCS7_get_detached(p7)) +- +-/* S/MIME related flags */ +- +-# define PKCS7_TEXT 0x1 +-# define PKCS7_NOCERTS 0x2 +-# define PKCS7_NOSIGS 0x4 +-# define PKCS7_NOCHAIN 0x8 +-# define PKCS7_NOINTERN 0x10 +-# define PKCS7_NOVERIFY 0x20 +-# define PKCS7_DETACHED 0x40 +-# define PKCS7_BINARY 0x80 +-# define PKCS7_NOATTR 0x100 +-# define PKCS7_NOSMIMECAP 0x200 +-# define PKCS7_NOOLDMIMETYPE 0x400 +-# define PKCS7_CRLFEOL 0x800 +-# define PKCS7_STREAM 0x1000 +-# define PKCS7_NOCRL 0x2000 +-# define PKCS7_PARTIAL 0x4000 +-# define PKCS7_REUSE_DIGEST 0x8000 +-# define PKCS7_NO_DUAL_CONTENT 0x10000 +- +-/* Flags: for compatibility with older code */ +- +-# define SMIME_TEXT PKCS7_TEXT +-# define SMIME_NOCERTS PKCS7_NOCERTS +-# define SMIME_NOSIGS PKCS7_NOSIGS +-# define SMIME_NOCHAIN PKCS7_NOCHAIN +-# define SMIME_NOINTERN PKCS7_NOINTERN +-# define SMIME_NOVERIFY PKCS7_NOVERIFY +-# define SMIME_DETACHED PKCS7_DETACHED +-# define SMIME_BINARY PKCS7_BINARY +-# define SMIME_NOATTR PKCS7_NOATTR +- +-/* CRLF ASCII canonicalisation */ +-# define SMIME_ASCIICRLF 0x80000 +- +-DECLARE_ASN1_FUNCTIONS(PKCS7_ISSUER_AND_SERIAL) +- +-int PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data, +- const EVP_MD *type, unsigned char *md, +- unsigned int *len); +-# ifndef OPENSSL_NO_STDIO +-PKCS7 *d2i_PKCS7_fp(FILE *fp, PKCS7 **p7); +-int i2d_PKCS7_fp(FILE *fp, PKCS7 *p7); +-# endif +-PKCS7 *PKCS7_dup(PKCS7 *p7); +-PKCS7 *d2i_PKCS7_bio(BIO *bp, PKCS7 **p7); +-int i2d_PKCS7_bio(BIO *bp, PKCS7 *p7); +-int i2d_PKCS7_bio_stream(BIO *out, PKCS7 *p7, BIO *in, int flags); +-int PEM_write_bio_PKCS7_stream(BIO *out, PKCS7 *p7, BIO *in, int flags); +- +-DECLARE_ASN1_FUNCTIONS(PKCS7_SIGNER_INFO) +-DECLARE_ASN1_FUNCTIONS(PKCS7_RECIP_INFO) +-DECLARE_ASN1_FUNCTIONS(PKCS7_SIGNED) +-DECLARE_ASN1_FUNCTIONS(PKCS7_ENC_CONTENT) +-DECLARE_ASN1_FUNCTIONS(PKCS7_ENVELOPE) +-DECLARE_ASN1_FUNCTIONS(PKCS7_SIGN_ENVELOPE) +-DECLARE_ASN1_FUNCTIONS(PKCS7_DIGEST) +-DECLARE_ASN1_FUNCTIONS(PKCS7_ENCRYPT) +-DECLARE_ASN1_FUNCTIONS(PKCS7) +- +-DECLARE_ASN1_ITEM(PKCS7_ATTR_SIGN) +-DECLARE_ASN1_ITEM(PKCS7_ATTR_VERIFY) +- +-DECLARE_ASN1_NDEF_FUNCTION(PKCS7) +-DECLARE_ASN1_PRINT_FUNCTION(PKCS7) +- +-long PKCS7_ctrl(PKCS7 *p7, int cmd, long larg, char *parg); +- +-int PKCS7_set_type(PKCS7 *p7, int type); +-int PKCS7_set0_type_other(PKCS7 *p7, int type, ASN1_TYPE *other); +-int PKCS7_set_content(PKCS7 *p7, PKCS7 *p7_data); +-int PKCS7_SIGNER_INFO_set(PKCS7_SIGNER_INFO *p7i, X509 *x509, EVP_PKEY *pkey, +- const EVP_MD *dgst); +-int PKCS7_SIGNER_INFO_sign(PKCS7_SIGNER_INFO *si); +-int PKCS7_add_signer(PKCS7 *p7, PKCS7_SIGNER_INFO *p7i); +-int PKCS7_add_certificate(PKCS7 *p7, X509 *x509); +-int PKCS7_add_crl(PKCS7 *p7, X509_CRL *x509); +-int PKCS7_content_new(PKCS7 *p7, int nid); +-int PKCS7_dataVerify(X509_STORE *cert_store, X509_STORE_CTX *ctx, +- BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si); +-int PKCS7_signatureVerify(BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si, +- X509 *x509); +- +-BIO *PKCS7_dataInit(PKCS7 *p7, BIO *bio); +-int PKCS7_dataFinal(PKCS7 *p7, BIO *bio); +-BIO *PKCS7_dataDecode(PKCS7 *p7, EVP_PKEY *pkey, BIO *in_bio, X509 *pcert); +- +-PKCS7_SIGNER_INFO *PKCS7_add_signature(PKCS7 *p7, X509 *x509, +- EVP_PKEY *pkey, const EVP_MD *dgst); +-X509 *PKCS7_cert_from_signer_info(PKCS7 *p7, PKCS7_SIGNER_INFO *si); +-int PKCS7_set_digest(PKCS7 *p7, const EVP_MD *md); +-STACK_OF(PKCS7_SIGNER_INFO) *PKCS7_get_signer_info(PKCS7 *p7); +- +-PKCS7_RECIP_INFO *PKCS7_add_recipient(PKCS7 *p7, X509 *x509); +-void PKCS7_SIGNER_INFO_get0_algs(PKCS7_SIGNER_INFO *si, EVP_PKEY **pk, +- X509_ALGOR **pdig, X509_ALGOR **psig); +-void PKCS7_RECIP_INFO_get0_alg(PKCS7_RECIP_INFO *ri, X509_ALGOR **penc); +-int PKCS7_add_recipient_info(PKCS7 *p7, PKCS7_RECIP_INFO *ri); +-int PKCS7_RECIP_INFO_set(PKCS7_RECIP_INFO *p7i, X509 *x509); +-int PKCS7_set_cipher(PKCS7 *p7, const EVP_CIPHER *cipher); +-int PKCS7_stream(unsigned char ***boundary, PKCS7 *p7); +- +-PKCS7_ISSUER_AND_SERIAL *PKCS7_get_issuer_and_serial(PKCS7 *p7, int idx); +-ASN1_OCTET_STRING *PKCS7_digest_from_attributes(STACK_OF(X509_ATTRIBUTE) *sk); +-int PKCS7_add_signed_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int type, +- void *data); +-int PKCS7_add_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int atrtype, +- void *value); +-ASN1_TYPE *PKCS7_get_attribute(PKCS7_SIGNER_INFO *si, int nid); +-ASN1_TYPE *PKCS7_get_signed_attribute(PKCS7_SIGNER_INFO *si, int nid); +-int PKCS7_set_signed_attributes(PKCS7_SIGNER_INFO *p7si, +- STACK_OF(X509_ATTRIBUTE) *sk); +-int PKCS7_set_attributes(PKCS7_SIGNER_INFO *p7si, +- STACK_OF(X509_ATTRIBUTE) *sk); +- +-PKCS7 *PKCS7_sign(X509 *signcert, EVP_PKEY *pkey, STACK_OF(X509) *certs, +- BIO *data, int flags); +- +-PKCS7_SIGNER_INFO *PKCS7_sign_add_signer(PKCS7 *p7, +- X509 *signcert, EVP_PKEY *pkey, +- const EVP_MD *md, int flags); +- +-int PKCS7_final(PKCS7 *p7, BIO *data, int flags); +-int PKCS7_verify(PKCS7 *p7, STACK_OF(X509) *certs, X509_STORE *store, +- BIO *indata, BIO *out, int flags); +-STACK_OF(X509) *PKCS7_get0_signers(PKCS7 *p7, STACK_OF(X509) *certs, +- int flags); +-PKCS7 *PKCS7_encrypt(STACK_OF(X509) *certs, BIO *in, const EVP_CIPHER *cipher, +- int flags); +-int PKCS7_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data, +- int flags); +- +-int PKCS7_add_attrib_smimecap(PKCS7_SIGNER_INFO *si, +- STACK_OF(X509_ALGOR) *cap); +-STACK_OF(X509_ALGOR) *PKCS7_get_smimecap(PKCS7_SIGNER_INFO *si); +-int PKCS7_simple_smimecap(STACK_OF(X509_ALGOR) *sk, int nid, int arg); +- +-int PKCS7_add_attrib_content_type(PKCS7_SIGNER_INFO *si, ASN1_OBJECT *coid); +-int PKCS7_add0_attrib_signing_time(PKCS7_SIGNER_INFO *si, ASN1_TIME *t); +-int PKCS7_add1_attrib_digest(PKCS7_SIGNER_INFO *si, +- const unsigned char *md, int mdlen); +- +-int SMIME_write_PKCS7(BIO *bio, PKCS7 *p7, BIO *data, int flags); +-PKCS7 *SMIME_read_PKCS7(BIO *bio, BIO **bcont); +- +-BIO *BIO_new_PKCS7(BIO *out, PKCS7 *p7); +- +-# ifdef __cplusplus +-} +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/pkcs7err.h b/uadk_tool/include/openssl/pkcs7err.h +deleted file mode 100644 +index 02e0299..0000000 +--- a/uadk_tool/include/openssl/pkcs7err.h ++++ /dev/null +@@ -1,103 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_PKCS7ERR_H +-# define HEADER_PKCS7ERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_PKCS7_strings(void); +- +-/* +- * PKCS7 function codes. +- */ +-# define PKCS7_F_DO_PKCS7_SIGNED_ATTRIB 136 +-# define PKCS7_F_PKCS7_ADD0_ATTRIB_SIGNING_TIME 135 +-# define PKCS7_F_PKCS7_ADD_ATTRIB_SMIMECAP 118 +-# define PKCS7_F_PKCS7_ADD_CERTIFICATE 100 +-# define PKCS7_F_PKCS7_ADD_CRL 101 +-# define PKCS7_F_PKCS7_ADD_RECIPIENT_INFO 102 +-# define PKCS7_F_PKCS7_ADD_SIGNATURE 131 +-# define PKCS7_F_PKCS7_ADD_SIGNER 103 +-# define PKCS7_F_PKCS7_BIO_ADD_DIGEST 125 +-# define PKCS7_F_PKCS7_COPY_EXISTING_DIGEST 138 +-# define PKCS7_F_PKCS7_CTRL 104 +-# define PKCS7_F_PKCS7_DATADECODE 112 +-# define PKCS7_F_PKCS7_DATAFINAL 128 +-# define PKCS7_F_PKCS7_DATAINIT 105 +-# define PKCS7_F_PKCS7_DATAVERIFY 107 +-# define PKCS7_F_PKCS7_DECRYPT 114 +-# define PKCS7_F_PKCS7_DECRYPT_RINFO 133 +-# define PKCS7_F_PKCS7_ENCODE_RINFO 132 +-# define PKCS7_F_PKCS7_ENCRYPT 115 +-# define PKCS7_F_PKCS7_FINAL 134 +-# define PKCS7_F_PKCS7_FIND_DIGEST 127 +-# define PKCS7_F_PKCS7_GET0_SIGNERS 124 +-# define PKCS7_F_PKCS7_RECIP_INFO_SET 130 +-# define PKCS7_F_PKCS7_SET_CIPHER 108 +-# define PKCS7_F_PKCS7_SET_CONTENT 109 +-# define PKCS7_F_PKCS7_SET_DIGEST 126 +-# define PKCS7_F_PKCS7_SET_TYPE 110 +-# define PKCS7_F_PKCS7_SIGN 116 +-# define PKCS7_F_PKCS7_SIGNATUREVERIFY 113 +-# define PKCS7_F_PKCS7_SIGNER_INFO_SET 129 +-# define PKCS7_F_PKCS7_SIGNER_INFO_SIGN 139 +-# define PKCS7_F_PKCS7_SIGN_ADD_SIGNER 137 +-# define PKCS7_F_PKCS7_SIMPLE_SMIMECAP 119 +-# define PKCS7_F_PKCS7_VERIFY 117 +- +-/* +- * PKCS7 reason codes. +- */ +-# define PKCS7_R_CERTIFICATE_VERIFY_ERROR 117 +-# define PKCS7_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER 144 +-# define PKCS7_R_CIPHER_NOT_INITIALIZED 116 +-# define PKCS7_R_CONTENT_AND_DATA_PRESENT 118 +-# define PKCS7_R_CTRL_ERROR 152 +-# define PKCS7_R_DECRYPT_ERROR 119 +-# define PKCS7_R_DIGEST_FAILURE 101 +-# define PKCS7_R_ENCRYPTION_CTRL_FAILURE 149 +-# define PKCS7_R_ENCRYPTION_NOT_SUPPORTED_FOR_THIS_KEY_TYPE 150 +-# define PKCS7_R_ERROR_ADDING_RECIPIENT 120 +-# define PKCS7_R_ERROR_SETTING_CIPHER 121 +-# define PKCS7_R_INVALID_NULL_POINTER 143 +-# define PKCS7_R_INVALID_SIGNED_DATA_TYPE 155 +-# define PKCS7_R_NO_CONTENT 122 +-# define PKCS7_R_NO_DEFAULT_DIGEST 151 +-# define PKCS7_R_NO_MATCHING_DIGEST_TYPE_FOUND 154 +-# define PKCS7_R_NO_RECIPIENT_MATCHES_CERTIFICATE 115 +-# define PKCS7_R_NO_SIGNATURES_ON_DATA 123 +-# define PKCS7_R_NO_SIGNERS 142 +-# define PKCS7_R_OPERATION_NOT_SUPPORTED_ON_THIS_TYPE 104 +-# define PKCS7_R_PKCS7_ADD_SIGNATURE_ERROR 124 +-# define PKCS7_R_PKCS7_ADD_SIGNER_ERROR 153 +-# define PKCS7_R_PKCS7_DATASIGN 145 +-# define PKCS7_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 127 +-# define PKCS7_R_SIGNATURE_FAILURE 105 +-# define PKCS7_R_SIGNER_CERTIFICATE_NOT_FOUND 128 +-# define PKCS7_R_SIGNING_CTRL_FAILURE 147 +-# define PKCS7_R_SIGNING_NOT_SUPPORTED_FOR_THIS_KEY_TYPE 148 +-# define PKCS7_R_SMIME_TEXT_ERROR 129 +-# define PKCS7_R_UNABLE_TO_FIND_CERTIFICATE 106 +-# define PKCS7_R_UNABLE_TO_FIND_MEM_BIO 107 +-# define PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST 108 +-# define PKCS7_R_UNKNOWN_DIGEST_TYPE 109 +-# define PKCS7_R_UNKNOWN_OPERATION 110 +-# define PKCS7_R_UNSUPPORTED_CIPHER_TYPE 111 +-# define PKCS7_R_UNSUPPORTED_CONTENT_TYPE 112 +-# define PKCS7_R_WRONG_CONTENT_TYPE 113 +-# define PKCS7_R_WRONG_PKCS7_TYPE 114 +- +-#endif +diff --git a/uadk_tool/include/openssl/rand.h b/uadk_tool/include/openssl/rand.h +deleted file mode 100644 +index 38a2a27..0000000 +--- a/uadk_tool/include/openssl/rand.h ++++ /dev/null +@@ -1,77 +0,0 @@ +-/* +- * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_RAND_H +-# define HEADER_RAND_H +- +-# include +-# include +-# include +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-struct rand_meth_st { +- int (*seed) (const void *buf, int num); +- int (*bytes) (unsigned char *buf, int num); +- void (*cleanup) (void); +- int (*add) (const void *buf, int num, double randomness); +- int (*pseudorand) (unsigned char *buf, int num); +- int (*status) (void); +-}; +- +-int RAND_set_rand_method(const RAND_METHOD *meth); +-const RAND_METHOD *RAND_get_rand_method(void); +-# ifndef OPENSSL_NO_ENGINE +-int RAND_set_rand_engine(ENGINE *engine); +-# endif +- +-RAND_METHOD *RAND_OpenSSL(void); +- +-# if OPENSSL_API_COMPAT < 0x10100000L +-# define RAND_cleanup() while(0) continue +-# endif +-int RAND_bytes(unsigned char *buf, int num); +-int RAND_priv_bytes(unsigned char *buf, int num); +-DEPRECATEDIN_1_1_0(int RAND_pseudo_bytes(unsigned char *buf, int num)) +- +-void RAND_seed(const void *buf, int num); +-void RAND_keep_random_devices_open(int keep); +- +-# if defined(__ANDROID__) && defined(__NDK_FPABI__) +-__NDK_FPABI__ /* __attribute__((pcs("aapcs"))) on ARM */ +-# endif +-void RAND_add(const void *buf, int num, double randomness); +-int RAND_load_file(const char *file, long max_bytes); +-int RAND_write_file(const char *file); +-const char *RAND_file_name(char *file, size_t num); +-int RAND_status(void); +- +-# ifndef OPENSSL_NO_EGD +-int RAND_query_egd_bytes(const char *path, unsigned char *buf, int bytes); +-int RAND_egd(const char *path); +-int RAND_egd_bytes(const char *path, int bytes); +-# endif +- +-int RAND_poll(void); +- +-# if defined(_WIN32) && (defined(BASETYPES) || defined(_WINDEF_H)) +-/* application has to include in order to use these */ +-DEPRECATEDIN_1_1_0(void RAND_screen(void)) +-DEPRECATEDIN_1_1_0(int RAND_event(UINT, WPARAM, LPARAM)) +-# endif +- +- +-#ifdef __cplusplus +-} +-#endif +- +-#endif +diff --git a/uadk_tool/include/openssl/rand_drbg.h b/uadk_tool/include/openssl/rand_drbg.h +deleted file mode 100644 +index 45b731b..0000000 +--- a/uadk_tool/include/openssl/rand_drbg.h ++++ /dev/null +@@ -1,130 +0,0 @@ +-/* +- * Copyright 2017-2018 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_DRBG_RAND_H +-# define HEADER_DRBG_RAND_H +- +-# include +-# include +-# include +- +-/* +- * RAND_DRBG flags +- * +- * Note: if new flags are added, the constant `rand_drbg_used_flags` +- * in drbg_lib.c needs to be updated accordingly. +- */ +- +-/* In CTR mode, disable derivation function ctr_df */ +-# define RAND_DRBG_FLAG_CTR_NO_DF 0x1 +- +- +-# if OPENSSL_API_COMPAT < 0x10200000L +-/* This #define was replaced by an internal constant and should not be used. */ +-# define RAND_DRBG_USED_FLAGS (RAND_DRBG_FLAG_CTR_NO_DF) +-# endif +- +-/* +- * Default security strength (in the sense of [NIST SP 800-90Ar1]) +- * +- * NIST SP 800-90Ar1 supports the strength of the DRBG being smaller than that +- * of the cipher by collecting less entropy. The current DRBG implementation +- * does not take RAND_DRBG_STRENGTH into account and sets the strength of the +- * DRBG to that of the cipher. +- * +- * RAND_DRBG_STRENGTH is currently only used for the legacy RAND +- * implementation. +- * +- * Currently supported ciphers are: NID_aes_128_ctr, NID_aes_192_ctr and +- * NID_aes_256_ctr +- */ +-# define RAND_DRBG_STRENGTH 256 +-/* Default drbg type */ +-# define RAND_DRBG_TYPE NID_aes_256_ctr +-/* Default drbg flags */ +-# define RAND_DRBG_FLAGS 0 +- +- +-# ifdef __cplusplus +-extern "C" { +-# endif +- +-/* +- * Object lifetime functions. +- */ +-RAND_DRBG *RAND_DRBG_new(int type, unsigned int flags, RAND_DRBG *parent); +-RAND_DRBG *RAND_DRBG_secure_new(int type, unsigned int flags, RAND_DRBG *parent); +-int RAND_DRBG_set(RAND_DRBG *drbg, int type, unsigned int flags); +-int RAND_DRBG_set_defaults(int type, unsigned int flags); +-int RAND_DRBG_instantiate(RAND_DRBG *drbg, +- const unsigned char *pers, size_t perslen); +-int RAND_DRBG_uninstantiate(RAND_DRBG *drbg); +-void RAND_DRBG_free(RAND_DRBG *drbg); +- +-/* +- * Object "use" functions. +- */ +-int RAND_DRBG_reseed(RAND_DRBG *drbg, +- const unsigned char *adin, size_t adinlen, +- int prediction_resistance); +-int RAND_DRBG_generate(RAND_DRBG *drbg, unsigned char *out, size_t outlen, +- int prediction_resistance, +- const unsigned char *adin, size_t adinlen); +-int RAND_DRBG_bytes(RAND_DRBG *drbg, unsigned char *out, size_t outlen); +- +-int RAND_DRBG_set_reseed_interval(RAND_DRBG *drbg, unsigned int interval); +-int RAND_DRBG_set_reseed_time_interval(RAND_DRBG *drbg, time_t interval); +- +-int RAND_DRBG_set_reseed_defaults( +- unsigned int master_reseed_interval, +- unsigned int slave_reseed_interval, +- time_t master_reseed_time_interval, +- time_t slave_reseed_time_interval +- ); +- +-RAND_DRBG *RAND_DRBG_get0_master(void); +-RAND_DRBG *RAND_DRBG_get0_public(void); +-RAND_DRBG *RAND_DRBG_get0_private(void); +- +-/* +- * EXDATA +- */ +-# define RAND_DRBG_get_ex_new_index(l, p, newf, dupf, freef) \ +- CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_DRBG, l, p, newf, dupf, freef) +-int RAND_DRBG_set_ex_data(RAND_DRBG *drbg, int idx, void *arg); +-void *RAND_DRBG_get_ex_data(const RAND_DRBG *drbg, int idx); +- +-/* +- * Callback function typedefs +- */ +-typedef size_t (*RAND_DRBG_get_entropy_fn)(RAND_DRBG *drbg, +- unsigned char **pout, +- int entropy, size_t min_len, +- size_t max_len, +- int prediction_resistance); +-typedef void (*RAND_DRBG_cleanup_entropy_fn)(RAND_DRBG *ctx, +- unsigned char *out, size_t outlen); +-typedef size_t (*RAND_DRBG_get_nonce_fn)(RAND_DRBG *drbg, unsigned char **pout, +- int entropy, size_t min_len, +- size_t max_len); +-typedef void (*RAND_DRBG_cleanup_nonce_fn)(RAND_DRBG *drbg, +- unsigned char *out, size_t outlen); +- +-int RAND_DRBG_set_callbacks(RAND_DRBG *drbg, +- RAND_DRBG_get_entropy_fn get_entropy, +- RAND_DRBG_cleanup_entropy_fn cleanup_entropy, +- RAND_DRBG_get_nonce_fn get_nonce, +- RAND_DRBG_cleanup_nonce_fn cleanup_nonce); +- +- +-# ifdef __cplusplus +-} +-# endif +- +-#endif +diff --git a/uadk_tool/include/openssl/randerr.h b/uadk_tool/include/openssl/randerr.h +deleted file mode 100644 +index 79d5790..0000000 +--- a/uadk_tool/include/openssl/randerr.h ++++ /dev/null +@@ -1,94 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_RANDERR_H +-# define HEADER_RANDERR_H +- +-# include +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_RAND_strings(void); +- +-/* +- * RAND function codes. +- */ +-# define RAND_F_DATA_COLLECT_METHOD 127 +-# define RAND_F_DRBG_BYTES 101 +-# define RAND_F_DRBG_GET_ENTROPY 105 +-# define RAND_F_DRBG_SETUP 117 +-# define RAND_F_GET_ENTROPY 106 +-# define RAND_F_RAND_BYTES 100 +-# define RAND_F_RAND_DRBG_ENABLE_LOCKING 119 +-# define RAND_F_RAND_DRBG_GENERATE 107 +-# define RAND_F_RAND_DRBG_GET_ENTROPY 120 +-# define RAND_F_RAND_DRBG_GET_NONCE 123 +-# define RAND_F_RAND_DRBG_INSTANTIATE 108 +-# define RAND_F_RAND_DRBG_NEW 109 +-# define RAND_F_RAND_DRBG_RESEED 110 +-# define RAND_F_RAND_DRBG_RESTART 102 +-# define RAND_F_RAND_DRBG_SET 104 +-# define RAND_F_RAND_DRBG_SET_DEFAULTS 121 +-# define RAND_F_RAND_DRBG_UNINSTANTIATE 118 +-# define RAND_F_RAND_LOAD_FILE 111 +-# define RAND_F_RAND_POOL_ACQUIRE_ENTROPY 122 +-# define RAND_F_RAND_POOL_ADD 103 +-# define RAND_F_RAND_POOL_ADD_BEGIN 113 +-# define RAND_F_RAND_POOL_ADD_END 114 +-# define RAND_F_RAND_POOL_ATTACH 124 +-# define RAND_F_RAND_POOL_BYTES_NEEDED 115 +-# define RAND_F_RAND_POOL_GROW 125 +-# define RAND_F_RAND_POOL_NEW 116 +-# define RAND_F_RAND_PSEUDO_BYTES 126 +-# define RAND_F_RAND_WRITE_FILE 112 +- +-/* +- * RAND reason codes. +- */ +-# define RAND_R_ADDITIONAL_INPUT_TOO_LONG 102 +-# define RAND_R_ALREADY_INSTANTIATED 103 +-# define RAND_R_ARGUMENT_OUT_OF_RANGE 105 +-# define RAND_R_CANNOT_OPEN_FILE 121 +-# define RAND_R_DRBG_ALREADY_INITIALIZED 129 +-# define RAND_R_DRBG_NOT_INITIALISED 104 +-# define RAND_R_ENTROPY_INPUT_TOO_LONG 106 +-# define RAND_R_ENTROPY_OUT_OF_RANGE 124 +-# define RAND_R_ERROR_ENTROPY_POOL_WAS_IGNORED 127 +-# define RAND_R_ERROR_INITIALISING_DRBG 107 +-# define RAND_R_ERROR_INSTANTIATING_DRBG 108 +-# define RAND_R_ERROR_RETRIEVING_ADDITIONAL_INPUT 109 +-# define RAND_R_ERROR_RETRIEVING_ENTROPY 110 +-# define RAND_R_ERROR_RETRIEVING_NONCE 111 +-# define RAND_R_FAILED_TO_CREATE_LOCK 126 +-# define RAND_R_FUNC_NOT_IMPLEMENTED 101 +-# define RAND_R_FWRITE_ERROR 123 +-# define RAND_R_GENERATE_ERROR 112 +-# define RAND_R_INTERNAL_ERROR 113 +-# define RAND_R_IN_ERROR_STATE 114 +-# define RAND_R_NOT_A_REGULAR_FILE 122 +-# define RAND_R_NOT_INSTANTIATED 115 +-# define RAND_R_NO_DRBG_IMPLEMENTATION_SELECTED 128 +-# define RAND_R_PARENT_LOCKING_NOT_ENABLED 130 +-# define RAND_R_PARENT_STRENGTH_TOO_WEAK 131 +-# define RAND_R_PERSONALISATION_STRING_TOO_LONG 116 +-# define RAND_R_PREDICTION_RESISTANCE_NOT_SUPPORTED 133 +-# define RAND_R_PRNG_NOT_SEEDED 100 +-# define RAND_R_RANDOM_POOL_OVERFLOW 125 +-# define RAND_R_RANDOM_POOL_UNDERFLOW 134 +-# define RAND_R_REQUEST_TOO_LARGE_FOR_DRBG 117 +-# define RAND_R_RESEED_ERROR 118 +-# define RAND_R_SELFTEST_FAILURE 119 +-# define RAND_R_TOO_LITTLE_NONCE_REQUESTED 135 +-# define RAND_R_TOO_MUCH_NONCE_REQUESTED 136 +-# define RAND_R_UNSUPPORTED_DRBG_FLAGS 132 +-# define RAND_R_UNSUPPORTED_DRBG_TYPE 120 +- +-#endif +diff --git a/uadk_tool/include/openssl/rc2.h b/uadk_tool/include/openssl/rc2.h +deleted file mode 100644 +index 585f9e4..0000000 +--- a/uadk_tool/include/openssl/rc2.h ++++ /dev/null +@@ -1,51 +0,0 @@ +-/* +- * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_RC2_H +-# define HEADER_RC2_H +- +-# include +- +-# ifndef OPENSSL_NO_RC2 +-# ifdef __cplusplus +-extern "C" { +-# endif +- +-typedef unsigned int RC2_INT; +- +-# define RC2_ENCRYPT 1 +-# define RC2_DECRYPT 0 +- +-# define RC2_BLOCK 8 +-# define RC2_KEY_LENGTH 16 +- +-typedef struct rc2_key_st { +- RC2_INT data[64]; +-} RC2_KEY; +- +-void RC2_set_key(RC2_KEY *key, int len, const unsigned char *data, int bits); +-void RC2_ecb_encrypt(const unsigned char *in, unsigned char *out, +- RC2_KEY *key, int enc); +-void RC2_encrypt(unsigned long *data, RC2_KEY *key); +-void RC2_decrypt(unsigned long *data, RC2_KEY *key); +-void RC2_cbc_encrypt(const unsigned char *in, unsigned char *out, long length, +- RC2_KEY *ks, unsigned char *iv, int enc); +-void RC2_cfb64_encrypt(const unsigned char *in, unsigned char *out, +- long length, RC2_KEY *schedule, unsigned char *ivec, +- int *num, int enc); +-void RC2_ofb64_encrypt(const unsigned char *in, unsigned char *out, +- long length, RC2_KEY *schedule, unsigned char *ivec, +- int *num); +- +-# ifdef __cplusplus +-} +-# endif +-# endif +- +-#endif +diff --git a/uadk_tool/include/openssl/rc4.h b/uadk_tool/include/openssl/rc4.h +deleted file mode 100644 +index 86803b3..0000000 +--- a/uadk_tool/include/openssl/rc4.h ++++ /dev/null +@@ -1,36 +0,0 @@ +-/* +- * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_RC4_H +-# define HEADER_RC4_H +- +-# include +- +-# ifndef OPENSSL_NO_RC4 +-# include +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-typedef struct rc4_key_st { +- RC4_INT x, y; +- RC4_INT data[256]; +-} RC4_KEY; +- +-const char *RC4_options(void); +-void RC4_set_key(RC4_KEY *key, int len, const unsigned char *data); +-void RC4(RC4_KEY *key, size_t len, const unsigned char *indata, +- unsigned char *outdata); +- +-# ifdef __cplusplus +-} +-# endif +-# endif +- +-#endif +diff --git a/uadk_tool/include/openssl/rc5.h b/uadk_tool/include/openssl/rc5.h +deleted file mode 100644 +index 793f88e..0000000 +--- a/uadk_tool/include/openssl/rc5.h ++++ /dev/null +@@ -1,63 +0,0 @@ +-/* +- * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_RC5_H +-# define HEADER_RC5_H +- +-# include +- +-# ifndef OPENSSL_NO_RC5 +-# ifdef __cplusplus +-extern "C" { +-# endif +- +-# define RC5_ENCRYPT 1 +-# define RC5_DECRYPT 0 +- +-# define RC5_32_INT unsigned int +- +-# define RC5_32_BLOCK 8 +-# define RC5_32_KEY_LENGTH 16/* This is a default, max is 255 */ +- +-/* +- * This are the only values supported. Tweak the code if you want more The +- * most supported modes will be RC5-32/12/16 RC5-32/16/8 +- */ +-# define RC5_8_ROUNDS 8 +-# define RC5_12_ROUNDS 12 +-# define RC5_16_ROUNDS 16 +- +-typedef struct rc5_key_st { +- /* Number of rounds */ +- int rounds; +- RC5_32_INT data[2 * (RC5_16_ROUNDS + 1)]; +-} RC5_32_KEY; +- +-void RC5_32_set_key(RC5_32_KEY *key, int len, const unsigned char *data, +- int rounds); +-void RC5_32_ecb_encrypt(const unsigned char *in, unsigned char *out, +- RC5_32_KEY *key, int enc); +-void RC5_32_encrypt(unsigned long *data, RC5_32_KEY *key); +-void RC5_32_decrypt(unsigned long *data, RC5_32_KEY *key); +-void RC5_32_cbc_encrypt(const unsigned char *in, unsigned char *out, +- long length, RC5_32_KEY *ks, unsigned char *iv, +- int enc); +-void RC5_32_cfb64_encrypt(const unsigned char *in, unsigned char *out, +- long length, RC5_32_KEY *schedule, +- unsigned char *ivec, int *num, int enc); +-void RC5_32_ofb64_encrypt(const unsigned char *in, unsigned char *out, +- long length, RC5_32_KEY *schedule, +- unsigned char *ivec, int *num); +- +-# ifdef __cplusplus +-} +-# endif +-# endif +- +-#endif +diff --git a/uadk_tool/include/openssl/ripemd.h b/uadk_tool/include/openssl/ripemd.h +deleted file mode 100644 +index c42026a..0000000 +--- a/uadk_tool/include/openssl/ripemd.h ++++ /dev/null +@@ -1,47 +0,0 @@ +-/* +- * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_RIPEMD_H +-# define HEADER_RIPEMD_H +- +-# include +- +-#ifndef OPENSSL_NO_RMD160 +-# include +-# include +-# ifdef __cplusplus +-extern "C" { +-# endif +- +-# define RIPEMD160_LONG unsigned int +- +-# define RIPEMD160_CBLOCK 64 +-# define RIPEMD160_LBLOCK (RIPEMD160_CBLOCK/4) +-# define RIPEMD160_DIGEST_LENGTH 20 +- +-typedef struct RIPEMD160state_st { +- RIPEMD160_LONG A, B, C, D, E; +- RIPEMD160_LONG Nl, Nh; +- RIPEMD160_LONG data[RIPEMD160_LBLOCK]; +- unsigned int num; +-} RIPEMD160_CTX; +- +-int RIPEMD160_Init(RIPEMD160_CTX *c); +-int RIPEMD160_Update(RIPEMD160_CTX *c, const void *data, size_t len); +-int RIPEMD160_Final(unsigned char *md, RIPEMD160_CTX *c); +-unsigned char *RIPEMD160(const unsigned char *d, size_t n, unsigned char *md); +-void RIPEMD160_Transform(RIPEMD160_CTX *c, const unsigned char *b); +- +-# ifdef __cplusplus +-} +-# endif +-# endif +- +- +-#endif +diff --git a/uadk_tool/include/openssl/rsa.h b/uadk_tool/include/openssl/rsa.h +deleted file mode 100644 +index 5e76365..0000000 +--- a/uadk_tool/include/openssl/rsa.h ++++ /dev/null +@@ -1,513 +0,0 @@ +-/* +- * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_RSA_H +-# define HEADER_RSA_H +- +-# include +- +-# ifndef OPENSSL_NO_RSA +-# include +-# include +-# include +-# include +-# if OPENSSL_API_COMPAT < 0x10100000L +-# include +-# endif +-# include +-# ifdef __cplusplus +-extern "C" { +-# endif +- +-/* The types RSA and RSA_METHOD are defined in ossl_typ.h */ +- +-# ifndef OPENSSL_RSA_MAX_MODULUS_BITS +-# define OPENSSL_RSA_MAX_MODULUS_BITS 16384 +-# endif +- +-# define OPENSSL_RSA_FIPS_MIN_MODULUS_BITS 1024 +- +-# ifndef OPENSSL_RSA_SMALL_MODULUS_BITS +-# define OPENSSL_RSA_SMALL_MODULUS_BITS 3072 +-# endif +-# ifndef OPENSSL_RSA_MAX_PUBEXP_BITS +- +-/* exponent limit enforced for "large" modulus only */ +-# define OPENSSL_RSA_MAX_PUBEXP_BITS 64 +-# endif +- +-# define RSA_3 0x3L +-# define RSA_F4 0x10001L +- +-/* based on RFC 8017 appendix A.1.2 */ +-# define RSA_ASN1_VERSION_DEFAULT 0 +-# define RSA_ASN1_VERSION_MULTI 1 +- +-# define RSA_DEFAULT_PRIME_NUM 2 +- +-# define RSA_METHOD_FLAG_NO_CHECK 0x0001/* don't check pub/private +- * match */ +- +-# define RSA_FLAG_CACHE_PUBLIC 0x0002 +-# define RSA_FLAG_CACHE_PRIVATE 0x0004 +-# define RSA_FLAG_BLINDING 0x0008 +-# define RSA_FLAG_THREAD_SAFE 0x0010 +-/* +- * This flag means the private key operations will be handled by rsa_mod_exp +- * and that they do not depend on the private key components being present: +- * for example a key stored in external hardware. Without this flag +- * bn_mod_exp gets called when private key components are absent. +- */ +-# define RSA_FLAG_EXT_PKEY 0x0020 +- +-/* +- * new with 0.9.6j and 0.9.7b; the built-in +- * RSA implementation now uses blinding by +- * default (ignoring RSA_FLAG_BLINDING), +- * but other engines might not need it +- */ +-# define RSA_FLAG_NO_BLINDING 0x0080 +-# if OPENSSL_API_COMPAT < 0x10100000L +-/* +- * Does nothing. Previously this switched off constant time behaviour. +- */ +-# define RSA_FLAG_NO_CONSTTIME 0x0000 +-# endif +-# if OPENSSL_API_COMPAT < 0x00908000L +-/* deprecated name for the flag*/ +-/* +- * new with 0.9.7h; the built-in RSA +- * implementation now uses constant time +- * modular exponentiation for secret exponents +- * by default. This flag causes the +- * faster variable sliding window method to +- * be used for all exponents. +- */ +-# define RSA_FLAG_NO_EXP_CONSTTIME RSA_FLAG_NO_CONSTTIME +-# endif +- +-# define EVP_PKEY_CTX_set_rsa_padding(ctx, pad) \ +- RSA_pkey_ctx_ctrl(ctx, -1, EVP_PKEY_CTRL_RSA_PADDING, pad, NULL) +- +-# define EVP_PKEY_CTX_get_rsa_padding(ctx, ppad) \ +- RSA_pkey_ctx_ctrl(ctx, -1, EVP_PKEY_CTRL_GET_RSA_PADDING, 0, ppad) +- +-# define EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, len) \ +- RSA_pkey_ctx_ctrl(ctx, (EVP_PKEY_OP_SIGN|EVP_PKEY_OP_VERIFY), \ +- EVP_PKEY_CTRL_RSA_PSS_SALTLEN, len, NULL) +-/* Salt length matches digest */ +-# define RSA_PSS_SALTLEN_DIGEST -1 +-/* Verify only: auto detect salt length */ +-# define RSA_PSS_SALTLEN_AUTO -2 +-/* Set salt length to maximum possible */ +-# define RSA_PSS_SALTLEN_MAX -3 +-/* Old compatible max salt length for sign only */ +-# define RSA_PSS_SALTLEN_MAX_SIGN -2 +- +-# define EVP_PKEY_CTX_set_rsa_pss_keygen_saltlen(ctx, len) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA_PSS, EVP_PKEY_OP_KEYGEN, \ +- EVP_PKEY_CTRL_RSA_PSS_SALTLEN, len, NULL) +- +-# define EVP_PKEY_CTX_get_rsa_pss_saltlen(ctx, plen) \ +- RSA_pkey_ctx_ctrl(ctx, (EVP_PKEY_OP_SIGN|EVP_PKEY_OP_VERIFY), \ +- EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN, 0, plen) +- +-# define EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, bits) \ +- RSA_pkey_ctx_ctrl(ctx, EVP_PKEY_OP_KEYGEN, \ +- EVP_PKEY_CTRL_RSA_KEYGEN_BITS, bits, NULL) +- +-# define EVP_PKEY_CTX_set_rsa_keygen_pubexp(ctx, pubexp) \ +- RSA_pkey_ctx_ctrl(ctx, EVP_PKEY_OP_KEYGEN, \ +- EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP, 0, pubexp) +- +-# define EVP_PKEY_CTX_set_rsa_keygen_primes(ctx, primes) \ +- RSA_pkey_ctx_ctrl(ctx, EVP_PKEY_OP_KEYGEN, \ +- EVP_PKEY_CTRL_RSA_KEYGEN_PRIMES, primes, NULL) +- +-# define EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, md) \ +- RSA_pkey_ctx_ctrl(ctx, EVP_PKEY_OP_TYPE_SIG | EVP_PKEY_OP_TYPE_CRYPT, \ +- EVP_PKEY_CTRL_RSA_MGF1_MD, 0, (void *)(md)) +- +-# define EVP_PKEY_CTX_set_rsa_pss_keygen_mgf1_md(ctx, md) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA_PSS, EVP_PKEY_OP_KEYGEN, \ +- EVP_PKEY_CTRL_RSA_MGF1_MD, 0, (void *)(md)) +- +-# define EVP_PKEY_CTX_set_rsa_oaep_md(ctx, md) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_TYPE_CRYPT, \ +- EVP_PKEY_CTRL_RSA_OAEP_MD, 0, (void *)(md)) +- +-# define EVP_PKEY_CTX_get_rsa_mgf1_md(ctx, pmd) \ +- RSA_pkey_ctx_ctrl(ctx, EVP_PKEY_OP_TYPE_SIG | EVP_PKEY_OP_TYPE_CRYPT, \ +- EVP_PKEY_CTRL_GET_RSA_MGF1_MD, 0, (void *)(pmd)) +- +-# define EVP_PKEY_CTX_get_rsa_oaep_md(ctx, pmd) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_TYPE_CRYPT, \ +- EVP_PKEY_CTRL_GET_RSA_OAEP_MD, 0, (void *)(pmd)) +- +-# define EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, l, llen) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_TYPE_CRYPT, \ +- EVP_PKEY_CTRL_RSA_OAEP_LABEL, llen, (void *)(l)) +- +-# define EVP_PKEY_CTX_get0_rsa_oaep_label(ctx, l) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_TYPE_CRYPT, \ +- EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL, 0, (void *)(l)) +- +-# define EVP_PKEY_CTX_set_rsa_pss_keygen_md(ctx, md) \ +- EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA_PSS, \ +- EVP_PKEY_OP_KEYGEN, EVP_PKEY_CTRL_MD, \ +- 0, (void *)(md)) +- +-# define EVP_PKEY_CTRL_RSA_PADDING (EVP_PKEY_ALG_CTRL + 1) +-# define EVP_PKEY_CTRL_RSA_PSS_SALTLEN (EVP_PKEY_ALG_CTRL + 2) +- +-# define EVP_PKEY_CTRL_RSA_KEYGEN_BITS (EVP_PKEY_ALG_CTRL + 3) +-# define EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP (EVP_PKEY_ALG_CTRL + 4) +-# define EVP_PKEY_CTRL_RSA_MGF1_MD (EVP_PKEY_ALG_CTRL + 5) +- +-# define EVP_PKEY_CTRL_GET_RSA_PADDING (EVP_PKEY_ALG_CTRL + 6) +-# define EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN (EVP_PKEY_ALG_CTRL + 7) +-# define EVP_PKEY_CTRL_GET_RSA_MGF1_MD (EVP_PKEY_ALG_CTRL + 8) +- +-# define EVP_PKEY_CTRL_RSA_OAEP_MD (EVP_PKEY_ALG_CTRL + 9) +-# define EVP_PKEY_CTRL_RSA_OAEP_LABEL (EVP_PKEY_ALG_CTRL + 10) +- +-# define EVP_PKEY_CTRL_GET_RSA_OAEP_MD (EVP_PKEY_ALG_CTRL + 11) +-# define EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL (EVP_PKEY_ALG_CTRL + 12) +- +-# define EVP_PKEY_CTRL_RSA_KEYGEN_PRIMES (EVP_PKEY_ALG_CTRL + 13) +- +-# define RSA_PKCS1_PADDING 1 +-# define RSA_SSLV23_PADDING 2 +-# define RSA_NO_PADDING 3 +-# define RSA_PKCS1_OAEP_PADDING 4 +-# define RSA_X931_PADDING 5 +-/* EVP_PKEY_ only */ +-# define RSA_PKCS1_PSS_PADDING 6 +- +-# define RSA_PKCS1_PADDING_SIZE 11 +- +-# define RSA_set_app_data(s,arg) RSA_set_ex_data(s,0,arg) +-# define RSA_get_app_data(s) RSA_get_ex_data(s,0) +- +-RSA *RSA_new(void); +-RSA *RSA_new_method(ENGINE *engine); +-int RSA_bits(const RSA *rsa); +-int RSA_size(const RSA *rsa); +-int RSA_security_bits(const RSA *rsa); +- +-int RSA_set0_key(RSA *r, BIGNUM *n, BIGNUM *e, BIGNUM *d); +-int RSA_set0_factors(RSA *r, BIGNUM *p, BIGNUM *q); +-int RSA_set0_crt_params(RSA *r,BIGNUM *dmp1, BIGNUM *dmq1, BIGNUM *iqmp); +-int RSA_set0_multi_prime_params(RSA *r, BIGNUM *primes[], BIGNUM *exps[], +- BIGNUM *coeffs[], int pnum); +-void RSA_get0_key(const RSA *r, +- const BIGNUM **n, const BIGNUM **e, const BIGNUM **d); +-void RSA_get0_factors(const RSA *r, const BIGNUM **p, const BIGNUM **q); +-int RSA_get_multi_prime_extra_count(const RSA *r); +-int RSA_get0_multi_prime_factors(const RSA *r, const BIGNUM *primes[]); +-void RSA_get0_crt_params(const RSA *r, +- const BIGNUM **dmp1, const BIGNUM **dmq1, +- const BIGNUM **iqmp); +-int RSA_get0_multi_prime_crt_params(const RSA *r, const BIGNUM *exps[], +- const BIGNUM *coeffs[]); +-const BIGNUM *RSA_get0_n(const RSA *d); +-const BIGNUM *RSA_get0_e(const RSA *d); +-const BIGNUM *RSA_get0_d(const RSA *d); +-const BIGNUM *RSA_get0_p(const RSA *d); +-const BIGNUM *RSA_get0_q(const RSA *d); +-const BIGNUM *RSA_get0_dmp1(const RSA *r); +-const BIGNUM *RSA_get0_dmq1(const RSA *r); +-const BIGNUM *RSA_get0_iqmp(const RSA *r); +-const RSA_PSS_PARAMS *RSA_get0_pss_params(const RSA *r); +-void RSA_clear_flags(RSA *r, int flags); +-int RSA_test_flags(const RSA *r, int flags); +-void RSA_set_flags(RSA *r, int flags); +-int RSA_get_version(RSA *r); +-ENGINE *RSA_get0_engine(const RSA *r); +- +-/* Deprecated version */ +-DEPRECATEDIN_0_9_8(RSA *RSA_generate_key(int bits, unsigned long e, void +- (*callback) (int, int, void *), +- void *cb_arg)) +- +-/* New version */ +-int RSA_generate_key_ex(RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb); +-/* Multi-prime version */ +-int RSA_generate_multi_prime_key(RSA *rsa, int bits, int primes, +- BIGNUM *e, BN_GENCB *cb); +- +-int RSA_X931_derive_ex(RSA *rsa, BIGNUM *p1, BIGNUM *p2, BIGNUM *q1, +- BIGNUM *q2, const BIGNUM *Xp1, const BIGNUM *Xp2, +- const BIGNUM *Xp, const BIGNUM *Xq1, const BIGNUM *Xq2, +- const BIGNUM *Xq, const BIGNUM *e, BN_GENCB *cb); +-int RSA_X931_generate_key_ex(RSA *rsa, int bits, const BIGNUM *e, +- BN_GENCB *cb); +- +-int RSA_check_key(const RSA *); +-int RSA_check_key_ex(const RSA *, BN_GENCB *cb); +- /* next 4 return -1 on error */ +-int RSA_public_encrypt(int flen, const unsigned char *from, +- unsigned char *to, RSA *rsa, int padding); +-int RSA_private_encrypt(int flen, const unsigned char *from, +- unsigned char *to, RSA *rsa, int padding); +-int RSA_public_decrypt(int flen, const unsigned char *from, +- unsigned char *to, RSA *rsa, int padding); +-int RSA_private_decrypt(int flen, const unsigned char *from, +- unsigned char *to, RSA *rsa, int padding); +-void RSA_free(RSA *r); +-/* "up" the RSA object's reference count */ +-int RSA_up_ref(RSA *r); +- +-int RSA_flags(const RSA *r); +- +-void RSA_set_default_method(const RSA_METHOD *meth); +-const RSA_METHOD *RSA_get_default_method(void); +-const RSA_METHOD *RSA_null_method(void); +-const RSA_METHOD *RSA_get_method(const RSA *rsa); +-int RSA_set_method(RSA *rsa, const RSA_METHOD *meth); +- +-/* these are the actual RSA functions */ +-const RSA_METHOD *RSA_PKCS1_OpenSSL(void); +- +-int RSA_pkey_ctx_ctrl(EVP_PKEY_CTX *ctx, int optype, int cmd, int p1, void *p2); +- +-DECLARE_ASN1_ENCODE_FUNCTIONS_const(RSA, RSAPublicKey) +-DECLARE_ASN1_ENCODE_FUNCTIONS_const(RSA, RSAPrivateKey) +- +-struct rsa_pss_params_st { +- X509_ALGOR *hashAlgorithm; +- X509_ALGOR *maskGenAlgorithm; +- ASN1_INTEGER *saltLength; +- ASN1_INTEGER *trailerField; +- /* Decoded hash algorithm from maskGenAlgorithm */ +- X509_ALGOR *maskHash; +-}; +- +-DECLARE_ASN1_FUNCTIONS(RSA_PSS_PARAMS) +- +-typedef struct rsa_oaep_params_st { +- X509_ALGOR *hashFunc; +- X509_ALGOR *maskGenFunc; +- X509_ALGOR *pSourceFunc; +- /* Decoded hash algorithm from maskGenFunc */ +- X509_ALGOR *maskHash; +-} RSA_OAEP_PARAMS; +- +-DECLARE_ASN1_FUNCTIONS(RSA_OAEP_PARAMS) +- +-# ifndef OPENSSL_NO_STDIO +-int RSA_print_fp(FILE *fp, const RSA *r, int offset); +-# endif +- +-int RSA_print(BIO *bp, const RSA *r, int offset); +- +-/* +- * The following 2 functions sign and verify a X509_SIG ASN1 object inside +- * PKCS#1 padded RSA encryption +- */ +-int RSA_sign(int type, const unsigned char *m, unsigned int m_length, +- unsigned char *sigret, unsigned int *siglen, RSA *rsa); +-int RSA_verify(int type, const unsigned char *m, unsigned int m_length, +- const unsigned char *sigbuf, unsigned int siglen, RSA *rsa); +- +-/* +- * The following 2 function sign and verify a ASN1_OCTET_STRING object inside +- * PKCS#1 padded RSA encryption +- */ +-int RSA_sign_ASN1_OCTET_STRING(int type, +- const unsigned char *m, unsigned int m_length, +- unsigned char *sigret, unsigned int *siglen, +- RSA *rsa); +-int RSA_verify_ASN1_OCTET_STRING(int type, const unsigned char *m, +- unsigned int m_length, unsigned char *sigbuf, +- unsigned int siglen, RSA *rsa); +- +-int RSA_blinding_on(RSA *rsa, BN_CTX *ctx); +-void RSA_blinding_off(RSA *rsa); +-BN_BLINDING *RSA_setup_blinding(RSA *rsa, BN_CTX *ctx); +- +-int RSA_padding_add_PKCS1_type_1(unsigned char *to, int tlen, +- const unsigned char *f, int fl); +-int RSA_padding_check_PKCS1_type_1(unsigned char *to, int tlen, +- const unsigned char *f, int fl, +- int rsa_len); +-int RSA_padding_add_PKCS1_type_2(unsigned char *to, int tlen, +- const unsigned char *f, int fl); +-int RSA_padding_check_PKCS1_type_2(unsigned char *to, int tlen, +- const unsigned char *f, int fl, +- int rsa_len); +-int PKCS1_MGF1(unsigned char *mask, long len, const unsigned char *seed, +- long seedlen, const EVP_MD *dgst); +-int RSA_padding_add_PKCS1_OAEP(unsigned char *to, int tlen, +- const unsigned char *f, int fl, +- const unsigned char *p, int pl); +-int RSA_padding_check_PKCS1_OAEP(unsigned char *to, int tlen, +- const unsigned char *f, int fl, int rsa_len, +- const unsigned char *p, int pl); +-int RSA_padding_add_PKCS1_OAEP_mgf1(unsigned char *to, int tlen, +- const unsigned char *from, int flen, +- const unsigned char *param, int plen, +- const EVP_MD *md, const EVP_MD *mgf1md); +-int RSA_padding_check_PKCS1_OAEP_mgf1(unsigned char *to, int tlen, +- const unsigned char *from, int flen, +- int num, const unsigned char *param, +- int plen, const EVP_MD *md, +- const EVP_MD *mgf1md); +-int RSA_padding_add_SSLv23(unsigned char *to, int tlen, +- const unsigned char *f, int fl); +-int RSA_padding_check_SSLv23(unsigned char *to, int tlen, +- const unsigned char *f, int fl, int rsa_len); +-int RSA_padding_add_none(unsigned char *to, int tlen, const unsigned char *f, +- int fl); +-int RSA_padding_check_none(unsigned char *to, int tlen, +- const unsigned char *f, int fl, int rsa_len); +-int RSA_padding_add_X931(unsigned char *to, int tlen, const unsigned char *f, +- int fl); +-int RSA_padding_check_X931(unsigned char *to, int tlen, +- const unsigned char *f, int fl, int rsa_len); +-int RSA_X931_hash_id(int nid); +- +-int RSA_verify_PKCS1_PSS(RSA *rsa, const unsigned char *mHash, +- const EVP_MD *Hash, const unsigned char *EM, +- int sLen); +-int RSA_padding_add_PKCS1_PSS(RSA *rsa, unsigned char *EM, +- const unsigned char *mHash, const EVP_MD *Hash, +- int sLen); +- +-int RSA_verify_PKCS1_PSS_mgf1(RSA *rsa, const unsigned char *mHash, +- const EVP_MD *Hash, const EVP_MD *mgf1Hash, +- const unsigned char *EM, int sLen); +- +-int RSA_padding_add_PKCS1_PSS_mgf1(RSA *rsa, unsigned char *EM, +- const unsigned char *mHash, +- const EVP_MD *Hash, const EVP_MD *mgf1Hash, +- int sLen); +- +-#define RSA_get_ex_new_index(l, p, newf, dupf, freef) \ +- CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_RSA, l, p, newf, dupf, freef) +-int RSA_set_ex_data(RSA *r, int idx, void *arg); +-void *RSA_get_ex_data(const RSA *r, int idx); +- +-RSA *RSAPublicKey_dup(RSA *rsa); +-RSA *RSAPrivateKey_dup(RSA *rsa); +- +-/* +- * If this flag is set the RSA method is FIPS compliant and can be used in +- * FIPS mode. This is set in the validated module method. If an application +- * sets this flag in its own methods it is its responsibility to ensure the +- * result is compliant. +- */ +- +-# define RSA_FLAG_FIPS_METHOD 0x0400 +- +-/* +- * If this flag is set the operations normally disabled in FIPS mode are +- * permitted it is then the applications responsibility to ensure that the +- * usage is compliant. +- */ +- +-# define RSA_FLAG_NON_FIPS_ALLOW 0x0400 +-/* +- * Application has decided PRNG is good enough to generate a key: don't +- * check. +- */ +-# define RSA_FLAG_CHECKED 0x0800 +- +-RSA_METHOD *RSA_meth_new(const char *name, int flags); +-void RSA_meth_free(RSA_METHOD *meth); +-RSA_METHOD *RSA_meth_dup(const RSA_METHOD *meth); +-const char *RSA_meth_get0_name(const RSA_METHOD *meth); +-int RSA_meth_set1_name(RSA_METHOD *meth, const char *name); +-int RSA_meth_get_flags(const RSA_METHOD *meth); +-int RSA_meth_set_flags(RSA_METHOD *meth, int flags); +-void *RSA_meth_get0_app_data(const RSA_METHOD *meth); +-int RSA_meth_set0_app_data(RSA_METHOD *meth, void *app_data); +-int (*RSA_meth_get_pub_enc(const RSA_METHOD *meth)) +- (int flen, const unsigned char *from, +- unsigned char *to, RSA *rsa, int padding); +-int RSA_meth_set_pub_enc(RSA_METHOD *rsa, +- int (*pub_enc) (int flen, const unsigned char *from, +- unsigned char *to, RSA *rsa, +- int padding)); +-int (*RSA_meth_get_pub_dec(const RSA_METHOD *meth)) +- (int flen, const unsigned char *from, +- unsigned char *to, RSA *rsa, int padding); +-int RSA_meth_set_pub_dec(RSA_METHOD *rsa, +- int (*pub_dec) (int flen, const unsigned char *from, +- unsigned char *to, RSA *rsa, +- int padding)); +-int (*RSA_meth_get_priv_enc(const RSA_METHOD *meth)) +- (int flen, const unsigned char *from, +- unsigned char *to, RSA *rsa, int padding); +-int RSA_meth_set_priv_enc(RSA_METHOD *rsa, +- int (*priv_enc) (int flen, const unsigned char *from, +- unsigned char *to, RSA *rsa, +- int padding)); +-int (*RSA_meth_get_priv_dec(const RSA_METHOD *meth)) +- (int flen, const unsigned char *from, +- unsigned char *to, RSA *rsa, int padding); +-int RSA_meth_set_priv_dec(RSA_METHOD *rsa, +- int (*priv_dec) (int flen, const unsigned char *from, +- unsigned char *to, RSA *rsa, +- int padding)); +-int (*RSA_meth_get_mod_exp(const RSA_METHOD *meth)) +- (BIGNUM *r0, const BIGNUM *i, RSA *rsa, BN_CTX *ctx); +-int RSA_meth_set_mod_exp(RSA_METHOD *rsa, +- int (*mod_exp) (BIGNUM *r0, const BIGNUM *i, RSA *rsa, +- BN_CTX *ctx)); +-int (*RSA_meth_get_bn_mod_exp(const RSA_METHOD *meth)) +- (BIGNUM *r, const BIGNUM *a, const BIGNUM *p, +- const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); +-int RSA_meth_set_bn_mod_exp(RSA_METHOD *rsa, +- int (*bn_mod_exp) (BIGNUM *r, +- const BIGNUM *a, +- const BIGNUM *p, +- const BIGNUM *m, +- BN_CTX *ctx, +- BN_MONT_CTX *m_ctx)); +-int (*RSA_meth_get_init(const RSA_METHOD *meth)) (RSA *rsa); +-int RSA_meth_set_init(RSA_METHOD *rsa, int (*init) (RSA *rsa)); +-int (*RSA_meth_get_finish(const RSA_METHOD *meth)) (RSA *rsa); +-int RSA_meth_set_finish(RSA_METHOD *rsa, int (*finish) (RSA *rsa)); +-int (*RSA_meth_get_sign(const RSA_METHOD *meth)) +- (int type, +- const unsigned char *m, unsigned int m_length, +- unsigned char *sigret, unsigned int *siglen, +- const RSA *rsa); +-int RSA_meth_set_sign(RSA_METHOD *rsa, +- int (*sign) (int type, const unsigned char *m, +- unsigned int m_length, +- unsigned char *sigret, unsigned int *siglen, +- const RSA *rsa)); +-int (*RSA_meth_get_verify(const RSA_METHOD *meth)) +- (int dtype, const unsigned char *m, +- unsigned int m_length, const unsigned char *sigbuf, +- unsigned int siglen, const RSA *rsa); +-int RSA_meth_set_verify(RSA_METHOD *rsa, +- int (*verify) (int dtype, const unsigned char *m, +- unsigned int m_length, +- const unsigned char *sigbuf, +- unsigned int siglen, const RSA *rsa)); +-int (*RSA_meth_get_keygen(const RSA_METHOD *meth)) +- (RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb); +-int RSA_meth_set_keygen(RSA_METHOD *rsa, +- int (*keygen) (RSA *rsa, int bits, BIGNUM *e, +- BN_GENCB *cb)); +-int (*RSA_meth_get_multi_prime_keygen(const RSA_METHOD *meth)) +- (RSA *rsa, int bits, int primes, BIGNUM *e, BN_GENCB *cb); +-int RSA_meth_set_multi_prime_keygen(RSA_METHOD *meth, +- int (*keygen) (RSA *rsa, int bits, +- int primes, BIGNUM *e, +- BN_GENCB *cb)); +- +-# ifdef __cplusplus +-} +-# endif +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/rsaerr.h b/uadk_tool/include/openssl/rsaerr.h +deleted file mode 100644 +index 59b15e1..0000000 +--- a/uadk_tool/include/openssl/rsaerr.h ++++ /dev/null +@@ -1,167 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_RSAERR_H +-# define HEADER_RSAERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_RSA_strings(void); +- +-/* +- * RSA function codes. +- */ +-# define RSA_F_CHECK_PADDING_MD 140 +-# define RSA_F_ENCODE_PKCS1 146 +-# define RSA_F_INT_RSA_VERIFY 145 +-# define RSA_F_OLD_RSA_PRIV_DECODE 147 +-# define RSA_F_PKEY_PSS_INIT 165 +-# define RSA_F_PKEY_RSA_CTRL 143 +-# define RSA_F_PKEY_RSA_CTRL_STR 144 +-# define RSA_F_PKEY_RSA_SIGN 142 +-# define RSA_F_PKEY_RSA_VERIFY 149 +-# define RSA_F_PKEY_RSA_VERIFYRECOVER 141 +-# define RSA_F_RSA_ALGOR_TO_MD 156 +-# define RSA_F_RSA_BUILTIN_KEYGEN 129 +-# define RSA_F_RSA_CHECK_KEY 123 +-# define RSA_F_RSA_CHECK_KEY_EX 160 +-# define RSA_F_RSA_CMS_DECRYPT 159 +-# define RSA_F_RSA_CMS_VERIFY 158 +-# define RSA_F_RSA_ITEM_VERIFY 148 +-# define RSA_F_RSA_METH_DUP 161 +-# define RSA_F_RSA_METH_NEW 162 +-# define RSA_F_RSA_METH_SET1_NAME 163 +-# define RSA_F_RSA_MGF1_TO_MD 157 +-# define RSA_F_RSA_MULTIP_INFO_NEW 166 +-# define RSA_F_RSA_NEW_METHOD 106 +-# define RSA_F_RSA_NULL 124 +-# define RSA_F_RSA_NULL_PRIVATE_DECRYPT 132 +-# define RSA_F_RSA_NULL_PRIVATE_ENCRYPT 133 +-# define RSA_F_RSA_NULL_PUBLIC_DECRYPT 134 +-# define RSA_F_RSA_NULL_PUBLIC_ENCRYPT 135 +-# define RSA_F_RSA_OSSL_PRIVATE_DECRYPT 101 +-# define RSA_F_RSA_OSSL_PRIVATE_ENCRYPT 102 +-# define RSA_F_RSA_OSSL_PUBLIC_DECRYPT 103 +-# define RSA_F_RSA_OSSL_PUBLIC_ENCRYPT 104 +-# define RSA_F_RSA_PADDING_ADD_NONE 107 +-# define RSA_F_RSA_PADDING_ADD_PKCS1_OAEP 121 +-# define RSA_F_RSA_PADDING_ADD_PKCS1_OAEP_MGF1 154 +-# define RSA_F_RSA_PADDING_ADD_PKCS1_PSS 125 +-# define RSA_F_RSA_PADDING_ADD_PKCS1_PSS_MGF1 152 +-# define RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_1 108 +-# define RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_2 109 +-# define RSA_F_RSA_PADDING_ADD_SSLV23 110 +-# define RSA_F_RSA_PADDING_ADD_X931 127 +-# define RSA_F_RSA_PADDING_CHECK_NONE 111 +-# define RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP 122 +-# define RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP_MGF1 153 +-# define RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_1 112 +-# define RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_2 113 +-# define RSA_F_RSA_PADDING_CHECK_SSLV23 114 +-# define RSA_F_RSA_PADDING_CHECK_X931 128 +-# define RSA_F_RSA_PARAM_DECODE 164 +-# define RSA_F_RSA_PRINT 115 +-# define RSA_F_RSA_PRINT_FP 116 +-# define RSA_F_RSA_PRIV_DECODE 150 +-# define RSA_F_RSA_PRIV_ENCODE 138 +-# define RSA_F_RSA_PSS_GET_PARAM 151 +-# define RSA_F_RSA_PSS_TO_CTX 155 +-# define RSA_F_RSA_PUB_DECODE 139 +-# define RSA_F_RSA_SETUP_BLINDING 136 +-# define RSA_F_RSA_SIGN 117 +-# define RSA_F_RSA_SIGN_ASN1_OCTET_STRING 118 +-# define RSA_F_RSA_VERIFY 119 +-# define RSA_F_RSA_VERIFY_ASN1_OCTET_STRING 120 +-# define RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1 126 +-# define RSA_F_SETUP_TBUF 167 +- +-/* +- * RSA reason codes. +- */ +-# define RSA_R_ALGORITHM_MISMATCH 100 +-# define RSA_R_BAD_E_VALUE 101 +-# define RSA_R_BAD_FIXED_HEADER_DECRYPT 102 +-# define RSA_R_BAD_PAD_BYTE_COUNT 103 +-# define RSA_R_BAD_SIGNATURE 104 +-# define RSA_R_BLOCK_TYPE_IS_NOT_01 106 +-# define RSA_R_BLOCK_TYPE_IS_NOT_02 107 +-# define RSA_R_DATA_GREATER_THAN_MOD_LEN 108 +-# define RSA_R_DATA_TOO_LARGE 109 +-# define RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE 110 +-# define RSA_R_DATA_TOO_LARGE_FOR_MODULUS 132 +-# define RSA_R_DATA_TOO_SMALL 111 +-# define RSA_R_DATA_TOO_SMALL_FOR_KEY_SIZE 122 +-# define RSA_R_DIGEST_DOES_NOT_MATCH 158 +-# define RSA_R_DIGEST_NOT_ALLOWED 145 +-# define RSA_R_DIGEST_TOO_BIG_FOR_RSA_KEY 112 +-# define RSA_R_DMP1_NOT_CONGRUENT_TO_D 124 +-# define RSA_R_DMQ1_NOT_CONGRUENT_TO_D 125 +-# define RSA_R_D_E_NOT_CONGRUENT_TO_1 123 +-# define RSA_R_FIRST_OCTET_INVALID 133 +-# define RSA_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE 144 +-# define RSA_R_INVALID_DIGEST 157 +-# define RSA_R_INVALID_DIGEST_LENGTH 143 +-# define RSA_R_INVALID_HEADER 137 +-# define RSA_R_INVALID_LABEL 160 +-# define RSA_R_INVALID_MESSAGE_LENGTH 131 +-# define RSA_R_INVALID_MGF1_MD 156 +-# define RSA_R_INVALID_MULTI_PRIME_KEY 167 +-# define RSA_R_INVALID_OAEP_PARAMETERS 161 +-# define RSA_R_INVALID_PADDING 138 +-# define RSA_R_INVALID_PADDING_MODE 141 +-# define RSA_R_INVALID_PSS_PARAMETERS 149 +-# define RSA_R_INVALID_PSS_SALTLEN 146 +-# define RSA_R_INVALID_SALT_LENGTH 150 +-# define RSA_R_INVALID_TRAILER 139 +-# define RSA_R_INVALID_X931_DIGEST 142 +-# define RSA_R_IQMP_NOT_INVERSE_OF_Q 126 +-# define RSA_R_KEY_PRIME_NUM_INVALID 165 +-# define RSA_R_KEY_SIZE_TOO_SMALL 120 +-# define RSA_R_LAST_OCTET_INVALID 134 +-# define RSA_R_MISSING_PRIVATE_KEY 179 +-# define RSA_R_MGF1_DIGEST_NOT_ALLOWED 152 +-# define RSA_R_MODULUS_TOO_LARGE 105 +-# define RSA_R_MP_COEFFICIENT_NOT_INVERSE_OF_R 168 +-# define RSA_R_MP_EXPONENT_NOT_CONGRUENT_TO_D 169 +-# define RSA_R_MP_R_NOT_PRIME 170 +-# define RSA_R_NO_PUBLIC_EXPONENT 140 +-# define RSA_R_NULL_BEFORE_BLOCK_MISSING 113 +-# define RSA_R_N_DOES_NOT_EQUAL_PRODUCT_OF_PRIMES 172 +-# define RSA_R_N_DOES_NOT_EQUAL_P_Q 127 +-# define RSA_R_OAEP_DECODING_ERROR 121 +-# define RSA_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE 148 +-# define RSA_R_PADDING_CHECK_FAILED 114 +-# define RSA_R_PKCS_DECODING_ERROR 159 +-# define RSA_R_PSS_SALTLEN_TOO_SMALL 164 +-# define RSA_R_P_NOT_PRIME 128 +-# define RSA_R_Q_NOT_PRIME 129 +-# define RSA_R_RSA_OPERATIONS_NOT_SUPPORTED 130 +-# define RSA_R_SLEN_CHECK_FAILED 136 +-# define RSA_R_SLEN_RECOVERY_FAILED 135 +-# define RSA_R_SSLV3_ROLLBACK_ATTACK 115 +-# define RSA_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD 116 +-# define RSA_R_UNKNOWN_ALGORITHM_TYPE 117 +-# define RSA_R_UNKNOWN_DIGEST 166 +-# define RSA_R_UNKNOWN_MASK_DIGEST 151 +-# define RSA_R_UNKNOWN_PADDING_TYPE 118 +-# define RSA_R_UNSUPPORTED_ENCRYPTION_TYPE 162 +-# define RSA_R_UNSUPPORTED_LABEL_SOURCE 163 +-# define RSA_R_UNSUPPORTED_MASK_ALGORITHM 153 +-# define RSA_R_UNSUPPORTED_MASK_PARAMETER 154 +-# define RSA_R_UNSUPPORTED_SIGNATURE_TYPE 155 +-# define RSA_R_VALUE_MISSING 147 +-# define RSA_R_WRONG_SIGNATURE_LENGTH 119 +- +-#endif +diff --git a/uadk_tool/include/openssl/safestack.h b/uadk_tool/include/openssl/safestack.h +deleted file mode 100644 +index 38b5578..0000000 +--- a/uadk_tool/include/openssl/safestack.h ++++ /dev/null +@@ -1,207 +0,0 @@ +-/* +- * Copyright 1999-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_SAFESTACK_H +-# define HEADER_SAFESTACK_H +- +-# include +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-# define STACK_OF(type) struct stack_st_##type +- +-# define SKM_DEFINE_STACK_OF(t1, t2, t3) \ +- STACK_OF(t1); \ +- typedef int (*sk_##t1##_compfunc)(const t3 * const *a, const t3 *const *b); \ +- typedef void (*sk_##t1##_freefunc)(t3 *a); \ +- typedef t3 * (*sk_##t1##_copyfunc)(const t3 *a); \ +- static ossl_unused ossl_inline int sk_##t1##_num(const STACK_OF(t1) *sk) \ +- { \ +- return OPENSSL_sk_num((const OPENSSL_STACK *)sk); \ +- } \ +- static ossl_unused ossl_inline t2 *sk_##t1##_value(const STACK_OF(t1) *sk, int idx) \ +- { \ +- return (t2 *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); \ +- } \ +- static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new(sk_##t1##_compfunc compare) \ +- { \ +- return (STACK_OF(t1) *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); \ +- } \ +- static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new_null(void) \ +- { \ +- return (STACK_OF(t1) *)OPENSSL_sk_new_null(); \ +- } \ +- static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new_reserve(sk_##t1##_compfunc compare, int n) \ +- { \ +- return (STACK_OF(t1) *)OPENSSL_sk_new_reserve((OPENSSL_sk_compfunc)compare, n); \ +- } \ +- static ossl_unused ossl_inline int sk_##t1##_reserve(STACK_OF(t1) *sk, int n) \ +- { \ +- return OPENSSL_sk_reserve((OPENSSL_STACK *)sk, n); \ +- } \ +- static ossl_unused ossl_inline void sk_##t1##_free(STACK_OF(t1) *sk) \ +- { \ +- OPENSSL_sk_free((OPENSSL_STACK *)sk); \ +- } \ +- static ossl_unused ossl_inline void sk_##t1##_zero(STACK_OF(t1) *sk) \ +- { \ +- OPENSSL_sk_zero((OPENSSL_STACK *)sk); \ +- } \ +- static ossl_unused ossl_inline t2 *sk_##t1##_delete(STACK_OF(t1) *sk, int i) \ +- { \ +- return (t2 *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); \ +- } \ +- static ossl_unused ossl_inline t2 *sk_##t1##_delete_ptr(STACK_OF(t1) *sk, t2 *ptr) \ +- { \ +- return (t2 *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, \ +- (const void *)ptr); \ +- } \ +- static ossl_unused ossl_inline int sk_##t1##_push(STACK_OF(t1) *sk, t2 *ptr) \ +- { \ +- return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); \ +- } \ +- static ossl_unused ossl_inline int sk_##t1##_unshift(STACK_OF(t1) *sk, t2 *ptr) \ +- { \ +- return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); \ +- } \ +- static ossl_unused ossl_inline t2 *sk_##t1##_pop(STACK_OF(t1) *sk) \ +- { \ +- return (t2 *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); \ +- } \ +- static ossl_unused ossl_inline t2 *sk_##t1##_shift(STACK_OF(t1) *sk) \ +- { \ +- return (t2 *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); \ +- } \ +- static ossl_unused ossl_inline void sk_##t1##_pop_free(STACK_OF(t1) *sk, sk_##t1##_freefunc freefunc) \ +- { \ +- OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); \ +- } \ +- static ossl_unused ossl_inline int sk_##t1##_insert(STACK_OF(t1) *sk, t2 *ptr, int idx) \ +- { \ +- return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); \ +- } \ +- static ossl_unused ossl_inline t2 *sk_##t1##_set(STACK_OF(t1) *sk, int idx, t2 *ptr) \ +- { \ +- return (t2 *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); \ +- } \ +- static ossl_unused ossl_inline int sk_##t1##_find(STACK_OF(t1) *sk, t2 *ptr) \ +- { \ +- return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); \ +- } \ +- static ossl_unused ossl_inline int sk_##t1##_find_ex(STACK_OF(t1) *sk, t2 *ptr) \ +- { \ +- return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); \ +- } \ +- static ossl_unused ossl_inline void sk_##t1##_sort(STACK_OF(t1) *sk) \ +- { \ +- OPENSSL_sk_sort((OPENSSL_STACK *)sk); \ +- } \ +- static ossl_unused ossl_inline int sk_##t1##_is_sorted(const STACK_OF(t1) *sk) \ +- { \ +- return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); \ +- } \ +- static ossl_unused ossl_inline STACK_OF(t1) * sk_##t1##_dup(const STACK_OF(t1) *sk) \ +- { \ +- return (STACK_OF(t1) *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); \ +- } \ +- static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_deep_copy(const STACK_OF(t1) *sk, \ +- sk_##t1##_copyfunc copyfunc, \ +- sk_##t1##_freefunc freefunc) \ +- { \ +- return (STACK_OF(t1) *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, \ +- (OPENSSL_sk_copyfunc)copyfunc, \ +- (OPENSSL_sk_freefunc)freefunc); \ +- } \ +- static ossl_unused ossl_inline sk_##t1##_compfunc sk_##t1##_set_cmp_func(STACK_OF(t1) *sk, sk_##t1##_compfunc compare) \ +- { \ +- return (sk_##t1##_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); \ +- } +- +-# define DEFINE_SPECIAL_STACK_OF(t1, t2) SKM_DEFINE_STACK_OF(t1, t2, t2) +-# define DEFINE_STACK_OF(t) SKM_DEFINE_STACK_OF(t, t, t) +-# define DEFINE_SPECIAL_STACK_OF_CONST(t1, t2) \ +- SKM_DEFINE_STACK_OF(t1, const t2, t2) +-# define DEFINE_STACK_OF_CONST(t) SKM_DEFINE_STACK_OF(t, const t, t) +- +-/*- +- * Strings are special: normally an lhash entry will point to a single +- * (somewhat) mutable object. In the case of strings: +- * +- * a) Instead of a single char, there is an array of chars, NUL-terminated. +- * b) The string may have be immutable. +- * +- * So, they need their own declarations. Especially important for +- * type-checking tools, such as Deputy. +- * +- * In practice, however, it appears to be hard to have a const +- * string. For now, I'm settling for dealing with the fact it is a +- * string at all. +- */ +-typedef char *OPENSSL_STRING; +-typedef const char *OPENSSL_CSTRING; +- +-/*- +- * Confusingly, LHASH_OF(STRING) deals with char ** throughout, but +- * STACK_OF(STRING) is really more like STACK_OF(char), only, as mentioned +- * above, instead of a single char each entry is a NUL-terminated array of +- * chars. So, we have to implement STRING specially for STACK_OF. This is +- * dealt with in the autogenerated macros below. +- */ +-DEFINE_SPECIAL_STACK_OF(OPENSSL_STRING, char) +-DEFINE_SPECIAL_STACK_OF_CONST(OPENSSL_CSTRING, char) +- +-/* +- * Similarly, we sometimes use a block of characters, NOT nul-terminated. +- * These should also be distinguished from "normal" stacks. +- */ +-typedef void *OPENSSL_BLOCK; +-DEFINE_SPECIAL_STACK_OF(OPENSSL_BLOCK, void) +- +-/* +- * If called without higher optimization (min. -xO3) the Oracle Developer +- * Studio compiler generates code for the defined (static inline) functions +- * above. +- * This would later lead to the linker complaining about missing symbols when +- * this header file is included but the resulting object is not linked against +- * the Crypto library (openssl#6912). +- */ +-# ifdef __SUNPRO_C +-# pragma weak OPENSSL_sk_num +-# pragma weak OPENSSL_sk_value +-# pragma weak OPENSSL_sk_new +-# pragma weak OPENSSL_sk_new_null +-# pragma weak OPENSSL_sk_new_reserve +-# pragma weak OPENSSL_sk_reserve +-# pragma weak OPENSSL_sk_free +-# pragma weak OPENSSL_sk_zero +-# pragma weak OPENSSL_sk_delete +-# pragma weak OPENSSL_sk_delete_ptr +-# pragma weak OPENSSL_sk_push +-# pragma weak OPENSSL_sk_unshift +-# pragma weak OPENSSL_sk_pop +-# pragma weak OPENSSL_sk_shift +-# pragma weak OPENSSL_sk_pop_free +-# pragma weak OPENSSL_sk_insert +-# pragma weak OPENSSL_sk_set +-# pragma weak OPENSSL_sk_find +-# pragma weak OPENSSL_sk_find_ex +-# pragma weak OPENSSL_sk_sort +-# pragma weak OPENSSL_sk_is_sorted +-# pragma weak OPENSSL_sk_dup +-# pragma weak OPENSSL_sk_deep_copy +-# pragma weak OPENSSL_sk_set_cmp_func +-# endif /* __SUNPRO_C */ +- +-# ifdef __cplusplus +-} +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/seed.h b/uadk_tool/include/openssl/seed.h +deleted file mode 100644 +index de10b08..0000000 +--- a/uadk_tool/include/openssl/seed.h ++++ /dev/null +@@ -1,96 +0,0 @@ +-/* +- * Copyright 2007-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-/* +- * Copyright (c) 2007 KISA(Korea Information Security Agency). All rights reserved. +- * +- * Redistribution and use in source and binary forms, with or without +- * modification, are permitted provided that the following conditions +- * are met: +- * 1. Redistributions of source code must retain the above copyright +- * notice, this list of conditions and the following disclaimer. +- * 2. Neither the name of author nor the names of its contributors may +- * be used to endorse or promote products derived from this software +- * without specific prior written permission. +- * +- * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND +- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +- * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE +- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +- * SUCH DAMAGE. +- */ +- +-#ifndef HEADER_SEED_H +-# define HEADER_SEED_H +- +-# include +- +-# ifndef OPENSSL_NO_SEED +-# include +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-/* look whether we need 'long' to get 32 bits */ +-# ifdef AES_LONG +-# ifndef SEED_LONG +-# define SEED_LONG 1 +-# endif +-# endif +- +-# include +- +-# define SEED_BLOCK_SIZE 16 +-# define SEED_KEY_LENGTH 16 +- +-typedef struct seed_key_st { +-# ifdef SEED_LONG +- unsigned long data[32]; +-# else +- unsigned int data[32]; +-# endif +-} SEED_KEY_SCHEDULE; +- +-void SEED_set_key(const unsigned char rawkey[SEED_KEY_LENGTH], +- SEED_KEY_SCHEDULE *ks); +- +-void SEED_encrypt(const unsigned char s[SEED_BLOCK_SIZE], +- unsigned char d[SEED_BLOCK_SIZE], +- const SEED_KEY_SCHEDULE *ks); +-void SEED_decrypt(const unsigned char s[SEED_BLOCK_SIZE], +- unsigned char d[SEED_BLOCK_SIZE], +- const SEED_KEY_SCHEDULE *ks); +- +-void SEED_ecb_encrypt(const unsigned char *in, unsigned char *out, +- const SEED_KEY_SCHEDULE *ks, int enc); +-void SEED_cbc_encrypt(const unsigned char *in, unsigned char *out, size_t len, +- const SEED_KEY_SCHEDULE *ks, +- unsigned char ivec[SEED_BLOCK_SIZE], int enc); +-void SEED_cfb128_encrypt(const unsigned char *in, unsigned char *out, +- size_t len, const SEED_KEY_SCHEDULE *ks, +- unsigned char ivec[SEED_BLOCK_SIZE], int *num, +- int enc); +-void SEED_ofb128_encrypt(const unsigned char *in, unsigned char *out, +- size_t len, const SEED_KEY_SCHEDULE *ks, +- unsigned char ivec[SEED_BLOCK_SIZE], int *num); +- +-# ifdef __cplusplus +-} +-# endif +-# endif +- +-#endif +diff --git a/uadk_tool/include/openssl/sha.h b/uadk_tool/include/openssl/sha.h +deleted file mode 100644 +index 6a1eb0d..0000000 +--- a/uadk_tool/include/openssl/sha.h ++++ /dev/null +@@ -1,119 +0,0 @@ +-/* +- * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_SHA_H +-# define HEADER_SHA_H +- +-# include +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-/*- +- * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +- * ! SHA_LONG has to be at least 32 bits wide. ! +- * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +- */ +-# define SHA_LONG unsigned int +- +-# define SHA_LBLOCK 16 +-# define SHA_CBLOCK (SHA_LBLOCK*4)/* SHA treats input data as a +- * contiguous array of 32 bit wide +- * big-endian values. */ +-# define SHA_LAST_BLOCK (SHA_CBLOCK-8) +-# define SHA_DIGEST_LENGTH 20 +- +-typedef struct SHAstate_st { +- SHA_LONG h0, h1, h2, h3, h4; +- SHA_LONG Nl, Nh; +- SHA_LONG data[SHA_LBLOCK]; +- unsigned int num; +-} SHA_CTX; +- +-int SHA1_Init(SHA_CTX *c); +-int SHA1_Update(SHA_CTX *c, const void *data, size_t len); +-int SHA1_Final(unsigned char *md, SHA_CTX *c); +-unsigned char *SHA1(const unsigned char *d, size_t n, unsigned char *md); +-void SHA1_Transform(SHA_CTX *c, const unsigned char *data); +- +-# define SHA256_CBLOCK (SHA_LBLOCK*4)/* SHA-256 treats input data as a +- * contiguous array of 32 bit wide +- * big-endian values. */ +- +-typedef struct SHA256state_st { +- SHA_LONG h[8]; +- SHA_LONG Nl, Nh; +- SHA_LONG data[SHA_LBLOCK]; +- unsigned int num, md_len; +-} SHA256_CTX; +- +-int SHA224_Init(SHA256_CTX *c); +-int SHA224_Update(SHA256_CTX *c, const void *data, size_t len); +-int SHA224_Final(unsigned char *md, SHA256_CTX *c); +-unsigned char *SHA224(const unsigned char *d, size_t n, unsigned char *md); +-int SHA256_Init(SHA256_CTX *c); +-int SHA256_Update(SHA256_CTX *c, const void *data, size_t len); +-int SHA256_Final(unsigned char *md, SHA256_CTX *c); +-unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md); +-void SHA256_Transform(SHA256_CTX *c, const unsigned char *data); +- +-# define SHA224_DIGEST_LENGTH 28 +-# define SHA256_DIGEST_LENGTH 32 +-# define SHA384_DIGEST_LENGTH 48 +-# define SHA512_DIGEST_LENGTH 64 +- +-/* +- * Unlike 32-bit digest algorithms, SHA-512 *relies* on SHA_LONG64 +- * being exactly 64-bit wide. See Implementation Notes in sha512.c +- * for further details. +- */ +-/* +- * SHA-512 treats input data as a +- * contiguous array of 64 bit +- * wide big-endian values. +- */ +-# define SHA512_CBLOCK (SHA_LBLOCK*8) +-# if (defined(_WIN32) || defined(_WIN64)) && !defined(__MINGW32__) +-# define SHA_LONG64 unsigned __int64 +-# define U64(C) C##UI64 +-# elif defined(__arch64__) +-# define SHA_LONG64 unsigned long +-# define U64(C) C##UL +-# else +-# define SHA_LONG64 unsigned long long +-# define U64(C) C##ULL +-# endif +- +-typedef struct SHA512state_st { +- SHA_LONG64 h[8]; +- SHA_LONG64 Nl, Nh; +- union { +- SHA_LONG64 d[SHA_LBLOCK]; +- unsigned char p[SHA512_CBLOCK]; +- } u; +- unsigned int num, md_len; +-} SHA512_CTX; +- +-int SHA384_Init(SHA512_CTX *c); +-int SHA384_Update(SHA512_CTX *c, const void *data, size_t len); +-int SHA384_Final(unsigned char *md, SHA512_CTX *c); +-unsigned char *SHA384(const unsigned char *d, size_t n, unsigned char *md); +-int SHA512_Init(SHA512_CTX *c); +-int SHA512_Update(SHA512_CTX *c, const void *data, size_t len); +-int SHA512_Final(unsigned char *md, SHA512_CTX *c); +-unsigned char *SHA512(const unsigned char *d, size_t n, unsigned char *md); +-void SHA512_Transform(SHA512_CTX *c, const unsigned char *data); +- +-#ifdef __cplusplus +-} +-#endif +- +-#endif +diff --git a/uadk_tool/include/openssl/srp.h b/uadk_tool/include/openssl/srp.h +deleted file mode 100644 +index aaf1355..0000000 +--- a/uadk_tool/include/openssl/srp.h ++++ /dev/null +@@ -1,135 +0,0 @@ +-/* +- * Copyright 2004-2018 The OpenSSL Project Authors. All Rights Reserved. +- * Copyright (c) 2004, EdelKey Project. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- * +- * Originally written by Christophe Renou and Peter Sylvester, +- * for the EdelKey project. +- */ +- +-#ifndef HEADER_SRP_H +-# define HEADER_SRP_H +- +-#include +- +-#ifndef OPENSSL_NO_SRP +-# include +-# include +-# include +-# include +-# include +- +-# ifdef __cplusplus +-extern "C" { +-# endif +- +-typedef struct SRP_gN_cache_st { +- char *b64_bn; +- BIGNUM *bn; +-} SRP_gN_cache; +- +- +-DEFINE_STACK_OF(SRP_gN_cache) +- +-typedef struct SRP_user_pwd_st { +- /* Owned by us. */ +- char *id; +- BIGNUM *s; +- BIGNUM *v; +- /* Not owned by us. */ +- const BIGNUM *g; +- const BIGNUM *N; +- /* Owned by us. */ +- char *info; +-} SRP_user_pwd; +- +-void SRP_user_pwd_free(SRP_user_pwd *user_pwd); +- +-DEFINE_STACK_OF(SRP_user_pwd) +- +-typedef struct SRP_VBASE_st { +- STACK_OF(SRP_user_pwd) *users_pwd; +- STACK_OF(SRP_gN_cache) *gN_cache; +-/* to simulate a user */ +- char *seed_key; +- const BIGNUM *default_g; +- const BIGNUM *default_N; +-} SRP_VBASE; +- +-/* +- * Internal structure storing N and g pair +- */ +-typedef struct SRP_gN_st { +- char *id; +- const BIGNUM *g; +- const BIGNUM *N; +-} SRP_gN; +- +-DEFINE_STACK_OF(SRP_gN) +- +-SRP_VBASE *SRP_VBASE_new(char *seed_key); +-void SRP_VBASE_free(SRP_VBASE *vb); +-int SRP_VBASE_init(SRP_VBASE *vb, char *verifier_file); +- +-/* This method ignores the configured seed and fails for an unknown user. */ +-DEPRECATEDIN_1_1_0(SRP_user_pwd *SRP_VBASE_get_by_user(SRP_VBASE *vb, char *username)) +-/* NOTE: unlike in SRP_VBASE_get_by_user, caller owns the returned pointer.*/ +-SRP_user_pwd *SRP_VBASE_get1_by_user(SRP_VBASE *vb, char *username); +- +-char *SRP_create_verifier(const char *user, const char *pass, char **salt, +- char **verifier, const char *N, const char *g); +-int SRP_create_verifier_BN(const char *user, const char *pass, BIGNUM **salt, +- BIGNUM **verifier, const BIGNUM *N, +- const BIGNUM *g); +- +-# define SRP_NO_ERROR 0 +-# define SRP_ERR_VBASE_INCOMPLETE_FILE 1 +-# define SRP_ERR_VBASE_BN_LIB 2 +-# define SRP_ERR_OPEN_FILE 3 +-# define SRP_ERR_MEMORY 4 +- +-# define DB_srptype 0 +-# define DB_srpverifier 1 +-# define DB_srpsalt 2 +-# define DB_srpid 3 +-# define DB_srpgN 4 +-# define DB_srpinfo 5 +-# undef DB_NUMBER +-# define DB_NUMBER 6 +- +-# define DB_SRP_INDEX 'I' +-# define DB_SRP_VALID 'V' +-# define DB_SRP_REVOKED 'R' +-# define DB_SRP_MODIF 'v' +- +-/* see srp.c */ +-char *SRP_check_known_gN_param(const BIGNUM *g, const BIGNUM *N); +-SRP_gN *SRP_get_default_gN(const char *id); +- +-/* server side .... */ +-BIGNUM *SRP_Calc_server_key(const BIGNUM *A, const BIGNUM *v, const BIGNUM *u, +- const BIGNUM *b, const BIGNUM *N); +-BIGNUM *SRP_Calc_B(const BIGNUM *b, const BIGNUM *N, const BIGNUM *g, +- const BIGNUM *v); +-int SRP_Verify_A_mod_N(const BIGNUM *A, const BIGNUM *N); +-BIGNUM *SRP_Calc_u(const BIGNUM *A, const BIGNUM *B, const BIGNUM *N); +- +-/* client side .... */ +-BIGNUM *SRP_Calc_x(const BIGNUM *s, const char *user, const char *pass); +-BIGNUM *SRP_Calc_A(const BIGNUM *a, const BIGNUM *N, const BIGNUM *g); +-BIGNUM *SRP_Calc_client_key(const BIGNUM *N, const BIGNUM *B, const BIGNUM *g, +- const BIGNUM *x, const BIGNUM *a, const BIGNUM *u); +-int SRP_Verify_B_mod_N(const BIGNUM *B, const BIGNUM *N); +- +-# define SRP_MINIMAL_N 1024 +- +-# ifdef __cplusplus +-} +-# endif +-# endif +- +-#endif +diff --git a/uadk_tool/include/openssl/srtp.h b/uadk_tool/include/openssl/srtp.h +deleted file mode 100644 +index 0b57c23..0000000 +--- a/uadk_tool/include/openssl/srtp.h ++++ /dev/null +@@ -1,50 +0,0 @@ +-/* +- * Copyright 2011-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-/* +- * DTLS code by Eric Rescorla +- * +- * Copyright (C) 2006, Network Resonance, Inc. Copyright (C) 2011, RTFM, Inc. +- */ +- +-#ifndef HEADER_D1_SRTP_H +-# define HEADER_D1_SRTP_H +- +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-# define SRTP_AES128_CM_SHA1_80 0x0001 +-# define SRTP_AES128_CM_SHA1_32 0x0002 +-# define SRTP_AES128_F8_SHA1_80 0x0003 +-# define SRTP_AES128_F8_SHA1_32 0x0004 +-# define SRTP_NULL_SHA1_80 0x0005 +-# define SRTP_NULL_SHA1_32 0x0006 +- +-/* AEAD SRTP protection profiles from RFC 7714 */ +-# define SRTP_AEAD_AES_128_GCM 0x0007 +-# define SRTP_AEAD_AES_256_GCM 0x0008 +- +-# ifndef OPENSSL_NO_SRTP +- +-__owur int SSL_CTX_set_tlsext_use_srtp(SSL_CTX *ctx, const char *profiles); +-__owur int SSL_set_tlsext_use_srtp(SSL *ssl, const char *profiles); +- +-__owur STACK_OF(SRTP_PROTECTION_PROFILE) *SSL_get_srtp_profiles(SSL *ssl); +-__owur SRTP_PROTECTION_PROFILE *SSL_get_selected_srtp_profile(SSL *s); +- +-# endif +- +-#ifdef __cplusplus +-} +-#endif +- +-#endif +diff --git a/uadk_tool/include/openssl/ssl.h b/uadk_tool/include/openssl/ssl.h +deleted file mode 100644 +index fd0c5a9..0000000 +--- a/uadk_tool/include/openssl/ssl.h ++++ /dev/null +@@ -1,2438 +0,0 @@ +-/* +- * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. +- * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved +- * Copyright 2005 Nokia. All rights reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_SSL_H +-# define HEADER_SSL_H +- +-# include +-# include +-# include +-# include +-# if OPENSSL_API_COMPAT < 0x10100000L +-# include +-# include +-# include +-# endif +-# include +-# include +-# include +-# include +- +-# include +-# include +-# include +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-/* OpenSSL version number for ASN.1 encoding of the session information */ +-/*- +- * Version 0 - initial version +- * Version 1 - added the optional peer certificate +- */ +-# define SSL_SESSION_ASN1_VERSION 0x0001 +- +-# define SSL_MAX_SSL_SESSION_ID_LENGTH 32 +-# define SSL_MAX_SID_CTX_LENGTH 32 +- +-# define SSL_MIN_RSA_MODULUS_LENGTH_IN_BYTES (512/8) +-# define SSL_MAX_KEY_ARG_LENGTH 8 +-# define SSL_MAX_MASTER_KEY_LENGTH 48 +- +-/* The maximum number of encrypt/decrypt pipelines we can support */ +-# define SSL_MAX_PIPELINES 32 +- +-/* text strings for the ciphers */ +- +-/* These are used to specify which ciphers to use and not to use */ +- +-# define SSL_TXT_LOW "LOW" +-# define SSL_TXT_MEDIUM "MEDIUM" +-# define SSL_TXT_HIGH "HIGH" +-# define SSL_TXT_FIPS "FIPS" +- +-# define SSL_TXT_aNULL "aNULL" +-# define SSL_TXT_eNULL "eNULL" +-# define SSL_TXT_NULL "NULL" +- +-# define SSL_TXT_kRSA "kRSA" +-# define SSL_TXT_kDHr "kDHr"/* this cipher class has been removed */ +-# define SSL_TXT_kDHd "kDHd"/* this cipher class has been removed */ +-# define SSL_TXT_kDH "kDH"/* this cipher class has been removed */ +-# define SSL_TXT_kEDH "kEDH"/* alias for kDHE */ +-# define SSL_TXT_kDHE "kDHE" +-# define SSL_TXT_kECDHr "kECDHr"/* this cipher class has been removed */ +-# define SSL_TXT_kECDHe "kECDHe"/* this cipher class has been removed */ +-# define SSL_TXT_kECDH "kECDH"/* this cipher class has been removed */ +-# define SSL_TXT_kEECDH "kEECDH"/* alias for kECDHE */ +-# define SSL_TXT_kECDHE "kECDHE" +-# define SSL_TXT_kPSK "kPSK" +-# define SSL_TXT_kRSAPSK "kRSAPSK" +-# define SSL_TXT_kECDHEPSK "kECDHEPSK" +-# define SSL_TXT_kDHEPSK "kDHEPSK" +-# define SSL_TXT_kGOST "kGOST" +-# define SSL_TXT_kSRP "kSRP" +- +-# define SSL_TXT_aRSA "aRSA" +-# define SSL_TXT_aDSS "aDSS" +-# define SSL_TXT_aDH "aDH"/* this cipher class has been removed */ +-# define SSL_TXT_aECDH "aECDH"/* this cipher class has been removed */ +-# define SSL_TXT_aECDSA "aECDSA" +-# define SSL_TXT_aPSK "aPSK" +-# define SSL_TXT_aGOST94 "aGOST94" +-# define SSL_TXT_aGOST01 "aGOST01" +-# define SSL_TXT_aGOST12 "aGOST12" +-# define SSL_TXT_aGOST "aGOST" +-# define SSL_TXT_aSRP "aSRP" +- +-# define SSL_TXT_DSS "DSS" +-# define SSL_TXT_DH "DH" +-# define SSL_TXT_DHE "DHE"/* same as "kDHE:-ADH" */ +-# define SSL_TXT_EDH "EDH"/* alias for DHE */ +-# define SSL_TXT_ADH "ADH" +-# define SSL_TXT_RSA "RSA" +-# define SSL_TXT_ECDH "ECDH" +-# define SSL_TXT_EECDH "EECDH"/* alias for ECDHE" */ +-# define SSL_TXT_ECDHE "ECDHE"/* same as "kECDHE:-AECDH" */ +-# define SSL_TXT_AECDH "AECDH" +-# define SSL_TXT_ECDSA "ECDSA" +-# define SSL_TXT_PSK "PSK" +-# define SSL_TXT_SRP "SRP" +- +-# define SSL_TXT_DES "DES" +-# define SSL_TXT_3DES "3DES" +-# define SSL_TXT_RC4 "RC4" +-# define SSL_TXT_RC2 "RC2" +-# define SSL_TXT_IDEA "IDEA" +-# define SSL_TXT_SEED "SEED" +-# define SSL_TXT_AES128 "AES128" +-# define SSL_TXT_AES256 "AES256" +-# define SSL_TXT_AES "AES" +-# define SSL_TXT_AES_GCM "AESGCM" +-# define SSL_TXT_AES_CCM "AESCCM" +-# define SSL_TXT_AES_CCM_8 "AESCCM8" +-# define SSL_TXT_CAMELLIA128 "CAMELLIA128" +-# define SSL_TXT_CAMELLIA256 "CAMELLIA256" +-# define SSL_TXT_CAMELLIA "CAMELLIA" +-# define SSL_TXT_CHACHA20 "CHACHA20" +-# define SSL_TXT_GOST "GOST89" +-# define SSL_TXT_ARIA "ARIA" +-# define SSL_TXT_ARIA_GCM "ARIAGCM" +-# define SSL_TXT_ARIA128 "ARIA128" +-# define SSL_TXT_ARIA256 "ARIA256" +- +-# define SSL_TXT_MD5 "MD5" +-# define SSL_TXT_SHA1 "SHA1" +-# define SSL_TXT_SHA "SHA"/* same as "SHA1" */ +-# define SSL_TXT_GOST94 "GOST94" +-# define SSL_TXT_GOST89MAC "GOST89MAC" +-# define SSL_TXT_GOST12 "GOST12" +-# define SSL_TXT_GOST89MAC12 "GOST89MAC12" +-# define SSL_TXT_SHA256 "SHA256" +-# define SSL_TXT_SHA384 "SHA384" +- +-# define SSL_TXT_SSLV3 "SSLv3" +-# define SSL_TXT_TLSV1 "TLSv1" +-# define SSL_TXT_TLSV1_1 "TLSv1.1" +-# define SSL_TXT_TLSV1_2 "TLSv1.2" +- +-# define SSL_TXT_ALL "ALL" +- +-/*- +- * COMPLEMENTOF* definitions. These identifiers are used to (de-select) +- * ciphers normally not being used. +- * Example: "RC4" will activate all ciphers using RC4 including ciphers +- * without authentication, which would normally disabled by DEFAULT (due +- * the "!ADH" being part of default). Therefore "RC4:!COMPLEMENTOFDEFAULT" +- * will make sure that it is also disabled in the specific selection. +- * COMPLEMENTOF* identifiers are portable between version, as adjustments +- * to the default cipher setup will also be included here. +- * +- * COMPLEMENTOFDEFAULT does not experience the same special treatment that +- * DEFAULT gets, as only selection is being done and no sorting as needed +- * for DEFAULT. +- */ +-# define SSL_TXT_CMPALL "COMPLEMENTOFALL" +-# define SSL_TXT_CMPDEF "COMPLEMENTOFDEFAULT" +- +-/* +- * The following cipher list is used by default. It also is substituted when +- * an application-defined cipher list string starts with 'DEFAULT'. +- * This applies to ciphersuites for TLSv1.2 and below. +- */ +-# define SSL_DEFAULT_CIPHER_LIST "ALL:!COMPLEMENTOFDEFAULT:!eNULL" +-/* This is the default set of TLSv1.3 ciphersuites */ +-# if !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305) +-# define TLS_DEFAULT_CIPHERSUITES "TLS_AES_256_GCM_SHA384:" \ +- "TLS_CHACHA20_POLY1305_SHA256:" \ +- "TLS_AES_128_GCM_SHA256" +-# else +-# define TLS_DEFAULT_CIPHERSUITES "TLS_AES_256_GCM_SHA384:" \ +- "TLS_AES_128_GCM_SHA256" +-#endif +-/* +- * As of OpenSSL 1.0.0, ssl_create_cipher_list() in ssl/ssl_ciph.c always +- * starts with a reasonable order, and all we have to do for DEFAULT is +- * throwing out anonymous and unencrypted ciphersuites! (The latter are not +- * actually enabled by ALL, but "ALL:RSA" would enable some of them.) +- */ +- +-/* Used in SSL_set_shutdown()/SSL_get_shutdown(); */ +-# define SSL_SENT_SHUTDOWN 1 +-# define SSL_RECEIVED_SHUTDOWN 2 +- +-#ifdef __cplusplus +-} +-#endif +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-# define SSL_FILETYPE_ASN1 X509_FILETYPE_ASN1 +-# define SSL_FILETYPE_PEM X509_FILETYPE_PEM +- +-/* +- * This is needed to stop compilers complaining about the 'struct ssl_st *' +- * function parameters used to prototype callbacks in SSL_CTX. +- */ +-typedef struct ssl_st *ssl_crock_st; +-typedef struct tls_session_ticket_ext_st TLS_SESSION_TICKET_EXT; +-typedef struct ssl_method_st SSL_METHOD; +-typedef struct ssl_cipher_st SSL_CIPHER; +-typedef struct ssl_session_st SSL_SESSION; +-typedef struct tls_sigalgs_st TLS_SIGALGS; +-typedef struct ssl_conf_ctx_st SSL_CONF_CTX; +-typedef struct ssl_comp_st SSL_COMP; +- +-STACK_OF(SSL_CIPHER); +-STACK_OF(SSL_COMP); +- +-/* SRTP protection profiles for use with the use_srtp extension (RFC 5764)*/ +-typedef struct srtp_protection_profile_st { +- const char *name; +- unsigned long id; +-} SRTP_PROTECTION_PROFILE; +- +-DEFINE_STACK_OF(SRTP_PROTECTION_PROFILE) +- +-typedef int (*tls_session_ticket_ext_cb_fn)(SSL *s, const unsigned char *data, +- int len, void *arg); +-typedef int (*tls_session_secret_cb_fn)(SSL *s, void *secret, int *secret_len, +- STACK_OF(SSL_CIPHER) *peer_ciphers, +- const SSL_CIPHER **cipher, void *arg); +- +-/* Extension context codes */ +-/* This extension is only allowed in TLS */ +-#define SSL_EXT_TLS_ONLY 0x0001 +-/* This extension is only allowed in DTLS */ +-#define SSL_EXT_DTLS_ONLY 0x0002 +-/* Some extensions may be allowed in DTLS but we don't implement them for it */ +-#define SSL_EXT_TLS_IMPLEMENTATION_ONLY 0x0004 +-/* Most extensions are not defined for SSLv3 but EXT_TYPE_renegotiate is */ +-#define SSL_EXT_SSL3_ALLOWED 0x0008 +-/* Extension is only defined for TLS1.2 and below */ +-#define SSL_EXT_TLS1_2_AND_BELOW_ONLY 0x0010 +-/* Extension is only defined for TLS1.3 and above */ +-#define SSL_EXT_TLS1_3_ONLY 0x0020 +-/* Ignore this extension during parsing if we are resuming */ +-#define SSL_EXT_IGNORE_ON_RESUMPTION 0x0040 +-#define SSL_EXT_CLIENT_HELLO 0x0080 +-/* Really means TLS1.2 or below */ +-#define SSL_EXT_TLS1_2_SERVER_HELLO 0x0100 +-#define SSL_EXT_TLS1_3_SERVER_HELLO 0x0200 +-#define SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS 0x0400 +-#define SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST 0x0800 +-#define SSL_EXT_TLS1_3_CERTIFICATE 0x1000 +-#define SSL_EXT_TLS1_3_NEW_SESSION_TICKET 0x2000 +-#define SSL_EXT_TLS1_3_CERTIFICATE_REQUEST 0x4000 +- +-/* Typedefs for handling custom extensions */ +- +-typedef int (*custom_ext_add_cb)(SSL *s, unsigned int ext_type, +- const unsigned char **out, size_t *outlen, +- int *al, void *add_arg); +- +-typedef void (*custom_ext_free_cb)(SSL *s, unsigned int ext_type, +- const unsigned char *out, void *add_arg); +- +-typedef int (*custom_ext_parse_cb)(SSL *s, unsigned int ext_type, +- const unsigned char *in, size_t inlen, +- int *al, void *parse_arg); +- +- +-typedef int (*SSL_custom_ext_add_cb_ex)(SSL *s, unsigned int ext_type, +- unsigned int context, +- const unsigned char **out, +- size_t *outlen, X509 *x, +- size_t chainidx, +- int *al, void *add_arg); +- +-typedef void (*SSL_custom_ext_free_cb_ex)(SSL *s, unsigned int ext_type, +- unsigned int context, +- const unsigned char *out, +- void *add_arg); +- +-typedef int (*SSL_custom_ext_parse_cb_ex)(SSL *s, unsigned int ext_type, +- unsigned int context, +- const unsigned char *in, +- size_t inlen, X509 *x, +- size_t chainidx, +- int *al, void *parse_arg); +- +-/* Typedef for verification callback */ +-typedef int (*SSL_verify_cb)(int preverify_ok, X509_STORE_CTX *x509_ctx); +- +-/* +- * Some values are reserved until OpenSSL 1.2.0 because they were previously +- * included in SSL_OP_ALL in a 1.1.x release. +- * +- * Reserved value (until OpenSSL 1.2.0) 0x00000001U +- * Reserved value (until OpenSSL 1.2.0) 0x00000002U +- */ +-/* Allow initial connection to servers that don't support RI */ +-# define SSL_OP_LEGACY_SERVER_CONNECT 0x00000004U +- +-/* Reserved value (until OpenSSL 1.2.0) 0x00000008U */ +-# define SSL_OP_TLSEXT_PADDING 0x00000010U +-/* Reserved value (until OpenSSL 1.2.0) 0x00000020U */ +-# define SSL_OP_SAFARI_ECDHE_ECDSA_BUG 0x00000040U +-/* +- * Reserved value (until OpenSSL 1.2.0) 0x00000080U +- * Reserved value (until OpenSSL 1.2.0) 0x00000100U +- * Reserved value (until OpenSSL 1.2.0) 0x00000200U +- */ +- +-/* In TLSv1.3 allow a non-(ec)dhe based kex_mode */ +-# define SSL_OP_ALLOW_NO_DHE_KEX 0x00000400U +- +-/* +- * Disable SSL 3.0/TLS 1.0 CBC vulnerability workaround that was added in +- * OpenSSL 0.9.6d. Usually (depending on the application protocol) the +- * workaround is not needed. Unfortunately some broken SSL/TLS +- * implementations cannot handle it at all, which is why we include it in +- * SSL_OP_ALL. Added in 0.9.6e +- */ +-# define SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS 0x00000800U +- +-/* DTLS options */ +-# define SSL_OP_NO_QUERY_MTU 0x00001000U +-/* Turn on Cookie Exchange (on relevant for servers) */ +-# define SSL_OP_COOKIE_EXCHANGE 0x00002000U +-/* Don't use RFC4507 ticket extension */ +-# define SSL_OP_NO_TICKET 0x00004000U +-# ifndef OPENSSL_NO_DTLS1_METHOD +-/* Use Cisco's "speshul" version of DTLS_BAD_VER +- * (only with deprecated DTLSv1_client_method()) */ +-# define SSL_OP_CISCO_ANYCONNECT 0x00008000U +-# endif +- +-/* As server, disallow session resumption on renegotiation */ +-# define SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION 0x00010000U +-/* Don't use compression even if supported */ +-# define SSL_OP_NO_COMPRESSION 0x00020000U +-/* Permit unsafe legacy renegotiation */ +-# define SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION 0x00040000U +-/* Disable encrypt-then-mac */ +-# define SSL_OP_NO_ENCRYPT_THEN_MAC 0x00080000U +- +-/* +- * Enable TLSv1.3 Compatibility mode. This is on by default. A future version +- * of OpenSSL may have this disabled by default. +- */ +-# define SSL_OP_ENABLE_MIDDLEBOX_COMPAT 0x00100000U +- +-/* Prioritize Chacha20Poly1305 when client does. +- * Modifies SSL_OP_CIPHER_SERVER_PREFERENCE */ +-# define SSL_OP_PRIORITIZE_CHACHA 0x00200000U +- +-/* +- * Set on servers to choose the cipher according to the server's preferences +- */ +-# define SSL_OP_CIPHER_SERVER_PREFERENCE 0x00400000U +-/* +- * If set, a server will allow a client to issue a SSLv3.0 version number as +- * latest version supported in the premaster secret, even when TLSv1.0 +- * (version 3.1) was announced in the client hello. Normally this is +- * forbidden to prevent version rollback attacks. +- */ +-# define SSL_OP_TLS_ROLLBACK_BUG 0x00800000U +- +-/* +- * Switches off automatic TLSv1.3 anti-replay protection for early data. This +- * is a server-side option only (no effect on the client). +- */ +-# define SSL_OP_NO_ANTI_REPLAY 0x01000000U +- +-# define SSL_OP_NO_SSLv3 0x02000000U +-# define SSL_OP_NO_TLSv1 0x04000000U +-# define SSL_OP_NO_TLSv1_2 0x08000000U +-# define SSL_OP_NO_TLSv1_1 0x10000000U +-# define SSL_OP_NO_TLSv1_3 0x20000000U +- +-# define SSL_OP_NO_DTLSv1 0x04000000U +-# define SSL_OP_NO_DTLSv1_2 0x08000000U +- +-# define SSL_OP_NO_SSL_MASK (SSL_OP_NO_SSLv3|\ +- SSL_OP_NO_TLSv1|SSL_OP_NO_TLSv1_1|SSL_OP_NO_TLSv1_2|SSL_OP_NO_TLSv1_3) +-# define SSL_OP_NO_DTLS_MASK (SSL_OP_NO_DTLSv1|SSL_OP_NO_DTLSv1_2) +- +-/* Disallow all renegotiation */ +-# define SSL_OP_NO_RENEGOTIATION 0x40000000U +- +-/* +- * Make server add server-hello extension from early version of cryptopro +- * draft, when GOST ciphersuite is negotiated. Required for interoperability +- * with CryptoPro CSP 3.x +- */ +-# define SSL_OP_CRYPTOPRO_TLSEXT_BUG 0x80000000U +- +-/* +- * SSL_OP_ALL: various bug workarounds that should be rather harmless. +- * This used to be 0x000FFFFFL before 0.9.7. +- * This used to be 0x80000BFFU before 1.1.1. +- */ +-# define SSL_OP_ALL (SSL_OP_CRYPTOPRO_TLSEXT_BUG|\ +- SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS|\ +- SSL_OP_LEGACY_SERVER_CONNECT|\ +- SSL_OP_TLSEXT_PADDING|\ +- SSL_OP_SAFARI_ECDHE_ECDSA_BUG) +- +-/* OBSOLETE OPTIONS: retained for compatibility */ +- +-/* Removed from OpenSSL 1.1.0. Was 0x00000001L */ +-/* Related to removed SSLv2. */ +-# define SSL_OP_MICROSOFT_SESS_ID_BUG 0x0 +-/* Removed from OpenSSL 1.1.0. Was 0x00000002L */ +-/* Related to removed SSLv2. */ +-# define SSL_OP_NETSCAPE_CHALLENGE_BUG 0x0 +-/* Removed from OpenSSL 0.9.8q and 1.0.0c. Was 0x00000008L */ +-/* Dead forever, see CVE-2010-4180 */ +-# define SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG 0x0 +-/* Removed from OpenSSL 1.0.1h and 1.0.2. Was 0x00000010L */ +-/* Refers to ancient SSLREF and SSLv2. */ +-# define SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG 0x0 +-/* Removed from OpenSSL 1.1.0. Was 0x00000020 */ +-# define SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER 0x0 +-/* Removed from OpenSSL 0.9.7h and 0.9.8b. Was 0x00000040L */ +-# define SSL_OP_MSIE_SSLV2_RSA_PADDING 0x0 +-/* Removed from OpenSSL 1.1.0. Was 0x00000080 */ +-/* Ancient SSLeay version. */ +-# define SSL_OP_SSLEAY_080_CLIENT_DH_BUG 0x0 +-/* Removed from OpenSSL 1.1.0. Was 0x00000100L */ +-# define SSL_OP_TLS_D5_BUG 0x0 +-/* Removed from OpenSSL 1.1.0. Was 0x00000200L */ +-# define SSL_OP_TLS_BLOCK_PADDING_BUG 0x0 +-/* Removed from OpenSSL 1.1.0. Was 0x00080000L */ +-# define SSL_OP_SINGLE_ECDH_USE 0x0 +-/* Removed from OpenSSL 1.1.0. Was 0x00100000L */ +-# define SSL_OP_SINGLE_DH_USE 0x0 +-/* Removed from OpenSSL 1.0.1k and 1.0.2. Was 0x00200000L */ +-# define SSL_OP_EPHEMERAL_RSA 0x0 +-/* Removed from OpenSSL 1.1.0. Was 0x01000000L */ +-# define SSL_OP_NO_SSLv2 0x0 +-/* Removed from OpenSSL 1.0.1. Was 0x08000000L */ +-# define SSL_OP_PKCS1_CHECK_1 0x0 +-/* Removed from OpenSSL 1.0.1. Was 0x10000000L */ +-# define SSL_OP_PKCS1_CHECK_2 0x0 +-/* Removed from OpenSSL 1.1.0. Was 0x20000000L */ +-# define SSL_OP_NETSCAPE_CA_DN_BUG 0x0 +-/* Removed from OpenSSL 1.1.0. Was 0x40000000L */ +-# define SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG 0x0 +- +-/* +- * Allow SSL_write(..., n) to return r with 0 < r < n (i.e. report success +- * when just a single record has been written): +- */ +-# define SSL_MODE_ENABLE_PARTIAL_WRITE 0x00000001U +-/* +- * Make it possible to retry SSL_write() with changed buffer location (buffer +- * contents must stay the same!); this is not the default to avoid the +- * misconception that non-blocking SSL_write() behaves like non-blocking +- * write(): +- */ +-# define SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER 0x00000002U +-/* +- * Never bother the application with retries if the transport is blocking: +- */ +-# define SSL_MODE_AUTO_RETRY 0x00000004U +-/* Don't attempt to automatically build certificate chain */ +-# define SSL_MODE_NO_AUTO_CHAIN 0x00000008U +-/* +- * Save RAM by releasing read and write buffers when they're empty. (SSL3 and +- * TLS only.) Released buffers are freed. +- */ +-# define SSL_MODE_RELEASE_BUFFERS 0x00000010U +-/* +- * Send the current time in the Random fields of the ClientHello and +- * ServerHello records for compatibility with hypothetical implementations +- * that require it. +- */ +-# define SSL_MODE_SEND_CLIENTHELLO_TIME 0x00000020U +-# define SSL_MODE_SEND_SERVERHELLO_TIME 0x00000040U +-/* +- * Send TLS_FALLBACK_SCSV in the ClientHello. To be set only by applications +- * that reconnect with a downgraded protocol version; see +- * draft-ietf-tls-downgrade-scsv-00 for details. DO NOT ENABLE THIS if your +- * application attempts a normal handshake. Only use this in explicit +- * fallback retries, following the guidance in +- * draft-ietf-tls-downgrade-scsv-00. +- */ +-# define SSL_MODE_SEND_FALLBACK_SCSV 0x00000080U +-/* +- * Support Asynchronous operation +- */ +-# define SSL_MODE_ASYNC 0x00000100U +- +-/* +- * When using DTLS/SCTP, include the terminating zero in the label +- * used for computing the endpoint-pair shared secret. Required for +- * interoperability with implementations having this bug like these +- * older version of OpenSSL: +- * - OpenSSL 1.0.0 series +- * - OpenSSL 1.0.1 series +- * - OpenSSL 1.0.2 series +- * - OpenSSL 1.1.0 series +- * - OpenSSL 1.1.1 and 1.1.1a +- */ +-# define SSL_MODE_DTLS_SCTP_LABEL_LENGTH_BUG 0x00000400U +- +-/* Cert related flags */ +-/* +- * Many implementations ignore some aspects of the TLS standards such as +- * enforcing certificate chain algorithms. When this is set we enforce them. +- */ +-# define SSL_CERT_FLAG_TLS_STRICT 0x00000001U +- +-/* Suite B modes, takes same values as certificate verify flags */ +-# define SSL_CERT_FLAG_SUITEB_128_LOS_ONLY 0x10000 +-/* Suite B 192 bit only mode */ +-# define SSL_CERT_FLAG_SUITEB_192_LOS 0x20000 +-/* Suite B 128 bit mode allowing 192 bit algorithms */ +-# define SSL_CERT_FLAG_SUITEB_128_LOS 0x30000 +- +-/* Perform all sorts of protocol violations for testing purposes */ +-# define SSL_CERT_FLAG_BROKEN_PROTOCOL 0x10000000 +- +-/* Flags for building certificate chains */ +-/* Treat any existing certificates as untrusted CAs */ +-# define SSL_BUILD_CHAIN_FLAG_UNTRUSTED 0x1 +-/* Don't include root CA in chain */ +-# define SSL_BUILD_CHAIN_FLAG_NO_ROOT 0x2 +-/* Just check certificates already there */ +-# define SSL_BUILD_CHAIN_FLAG_CHECK 0x4 +-/* Ignore verification errors */ +-# define SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR 0x8 +-/* Clear verification errors from queue */ +-# define SSL_BUILD_CHAIN_FLAG_CLEAR_ERROR 0x10 +- +-/* Flags returned by SSL_check_chain */ +-/* Certificate can be used with this session */ +-# define CERT_PKEY_VALID 0x1 +-/* Certificate can also be used for signing */ +-# define CERT_PKEY_SIGN 0x2 +-/* EE certificate signing algorithm OK */ +-# define CERT_PKEY_EE_SIGNATURE 0x10 +-/* CA signature algorithms OK */ +-# define CERT_PKEY_CA_SIGNATURE 0x20 +-/* EE certificate parameters OK */ +-# define CERT_PKEY_EE_PARAM 0x40 +-/* CA certificate parameters OK */ +-# define CERT_PKEY_CA_PARAM 0x80 +-/* Signing explicitly allowed as opposed to SHA1 fallback */ +-# define CERT_PKEY_EXPLICIT_SIGN 0x100 +-/* Client CA issuer names match (always set for server cert) */ +-# define CERT_PKEY_ISSUER_NAME 0x200 +-/* Cert type matches client types (always set for server cert) */ +-# define CERT_PKEY_CERT_TYPE 0x400 +-/* Cert chain suitable to Suite B */ +-# define CERT_PKEY_SUITEB 0x800 +- +-# define SSL_CONF_FLAG_CMDLINE 0x1 +-# define SSL_CONF_FLAG_FILE 0x2 +-# define SSL_CONF_FLAG_CLIENT 0x4 +-# define SSL_CONF_FLAG_SERVER 0x8 +-# define SSL_CONF_FLAG_SHOW_ERRORS 0x10 +-# define SSL_CONF_FLAG_CERTIFICATE 0x20 +-# define SSL_CONF_FLAG_REQUIRE_PRIVATE 0x40 +-/* Configuration value types */ +-# define SSL_CONF_TYPE_UNKNOWN 0x0 +-# define SSL_CONF_TYPE_STRING 0x1 +-# define SSL_CONF_TYPE_FILE 0x2 +-# define SSL_CONF_TYPE_DIR 0x3 +-# define SSL_CONF_TYPE_NONE 0x4 +- +-/* Maximum length of the application-controlled segment of a a TLSv1.3 cookie */ +-# define SSL_COOKIE_LENGTH 4096 +- +-/* +- * Note: SSL[_CTX]_set_{options,mode} use |= op on the previous value, they +- * cannot be used to clear bits. +- */ +- +-unsigned long SSL_CTX_get_options(const SSL_CTX *ctx); +-unsigned long SSL_get_options(const SSL *s); +-unsigned long SSL_CTX_clear_options(SSL_CTX *ctx, unsigned long op); +-unsigned long SSL_clear_options(SSL *s, unsigned long op); +-unsigned long SSL_CTX_set_options(SSL_CTX *ctx, unsigned long op); +-unsigned long SSL_set_options(SSL *s, unsigned long op); +- +-# define SSL_CTX_set_mode(ctx,op) \ +- SSL_CTX_ctrl((ctx),SSL_CTRL_MODE,(op),NULL) +-# define SSL_CTX_clear_mode(ctx,op) \ +- SSL_CTX_ctrl((ctx),SSL_CTRL_CLEAR_MODE,(op),NULL) +-# define SSL_CTX_get_mode(ctx) \ +- SSL_CTX_ctrl((ctx),SSL_CTRL_MODE,0,NULL) +-# define SSL_clear_mode(ssl,op) \ +- SSL_ctrl((ssl),SSL_CTRL_CLEAR_MODE,(op),NULL) +-# define SSL_set_mode(ssl,op) \ +- SSL_ctrl((ssl),SSL_CTRL_MODE,(op),NULL) +-# define SSL_get_mode(ssl) \ +- SSL_ctrl((ssl),SSL_CTRL_MODE,0,NULL) +-# define SSL_set_mtu(ssl, mtu) \ +- SSL_ctrl((ssl),SSL_CTRL_SET_MTU,(mtu),NULL) +-# define DTLS_set_link_mtu(ssl, mtu) \ +- SSL_ctrl((ssl),DTLS_CTRL_SET_LINK_MTU,(mtu),NULL) +-# define DTLS_get_link_min_mtu(ssl) \ +- SSL_ctrl((ssl),DTLS_CTRL_GET_LINK_MIN_MTU,0,NULL) +- +-# define SSL_get_secure_renegotiation_support(ssl) \ +- SSL_ctrl((ssl), SSL_CTRL_GET_RI_SUPPORT, 0, NULL) +- +-# ifndef OPENSSL_NO_HEARTBEATS +-# define SSL_heartbeat(ssl) \ +- SSL_ctrl((ssl),SSL_CTRL_DTLS_EXT_SEND_HEARTBEAT,0,NULL) +-# endif +- +-# define SSL_CTX_set_cert_flags(ctx,op) \ +- SSL_CTX_ctrl((ctx),SSL_CTRL_CERT_FLAGS,(op),NULL) +-# define SSL_set_cert_flags(s,op) \ +- SSL_ctrl((s),SSL_CTRL_CERT_FLAGS,(op),NULL) +-# define SSL_CTX_clear_cert_flags(ctx,op) \ +- SSL_CTX_ctrl((ctx),SSL_CTRL_CLEAR_CERT_FLAGS,(op),NULL) +-# define SSL_clear_cert_flags(s,op) \ +- SSL_ctrl((s),SSL_CTRL_CLEAR_CERT_FLAGS,(op),NULL) +- +-void SSL_CTX_set_msg_callback(SSL_CTX *ctx, +- void (*cb) (int write_p, int version, +- int content_type, const void *buf, +- size_t len, SSL *ssl, void *arg)); +-void SSL_set_msg_callback(SSL *ssl, +- void (*cb) (int write_p, int version, +- int content_type, const void *buf, +- size_t len, SSL *ssl, void *arg)); +-# define SSL_CTX_set_msg_callback_arg(ctx, arg) SSL_CTX_ctrl((ctx), SSL_CTRL_SET_MSG_CALLBACK_ARG, 0, (arg)) +-# define SSL_set_msg_callback_arg(ssl, arg) SSL_ctrl((ssl), SSL_CTRL_SET_MSG_CALLBACK_ARG, 0, (arg)) +- +-# define SSL_get_extms_support(s) \ +- SSL_ctrl((s),SSL_CTRL_GET_EXTMS_SUPPORT,0,NULL) +- +-# ifndef OPENSSL_NO_SRP +- +-/* see tls_srp.c */ +-__owur int SSL_SRP_CTX_init(SSL *s); +-__owur int SSL_CTX_SRP_CTX_init(SSL_CTX *ctx); +-int SSL_SRP_CTX_free(SSL *ctx); +-int SSL_CTX_SRP_CTX_free(SSL_CTX *ctx); +-__owur int SSL_srp_server_param_with_username(SSL *s, int *ad); +-__owur int SRP_Calc_A_param(SSL *s); +- +-# endif +- +-/* 100k max cert list */ +-# define SSL_MAX_CERT_LIST_DEFAULT 1024*100 +- +-# define SSL_SESSION_CACHE_MAX_SIZE_DEFAULT (1024*20) +- +-/* +- * This callback type is used inside SSL_CTX, SSL, and in the functions that +- * set them. It is used to override the generation of SSL/TLS session IDs in +- * a server. Return value should be zero on an error, non-zero to proceed. +- * Also, callbacks should themselves check if the id they generate is unique +- * otherwise the SSL handshake will fail with an error - callbacks can do +- * this using the 'ssl' value they're passed by; +- * SSL_has_matching_session_id(ssl, id, *id_len) The length value passed in +- * is set at the maximum size the session ID can be. In SSLv3/TLSv1 it is 32 +- * bytes. The callback can alter this length to be less if desired. It is +- * also an error for the callback to set the size to zero. +- */ +-typedef int (*GEN_SESSION_CB) (SSL *ssl, unsigned char *id, +- unsigned int *id_len); +- +-# define SSL_SESS_CACHE_OFF 0x0000 +-# define SSL_SESS_CACHE_CLIENT 0x0001 +-# define SSL_SESS_CACHE_SERVER 0x0002 +-# define SSL_SESS_CACHE_BOTH (SSL_SESS_CACHE_CLIENT|SSL_SESS_CACHE_SERVER) +-# define SSL_SESS_CACHE_NO_AUTO_CLEAR 0x0080 +-/* enough comments already ... see SSL_CTX_set_session_cache_mode(3) */ +-# define SSL_SESS_CACHE_NO_INTERNAL_LOOKUP 0x0100 +-# define SSL_SESS_CACHE_NO_INTERNAL_STORE 0x0200 +-# define SSL_SESS_CACHE_NO_INTERNAL \ +- (SSL_SESS_CACHE_NO_INTERNAL_LOOKUP|SSL_SESS_CACHE_NO_INTERNAL_STORE) +- +-LHASH_OF(SSL_SESSION) *SSL_CTX_sessions(SSL_CTX *ctx); +-# define SSL_CTX_sess_number(ctx) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_NUMBER,0,NULL) +-# define SSL_CTX_sess_connect(ctx) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT,0,NULL) +-# define SSL_CTX_sess_connect_good(ctx) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT_GOOD,0,NULL) +-# define SSL_CTX_sess_connect_renegotiate(ctx) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT_RENEGOTIATE,0,NULL) +-# define SSL_CTX_sess_accept(ctx) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT,0,NULL) +-# define SSL_CTX_sess_accept_renegotiate(ctx) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT_RENEGOTIATE,0,NULL) +-# define SSL_CTX_sess_accept_good(ctx) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT_GOOD,0,NULL) +-# define SSL_CTX_sess_hits(ctx) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_HIT,0,NULL) +-# define SSL_CTX_sess_cb_hits(ctx) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CB_HIT,0,NULL) +-# define SSL_CTX_sess_misses(ctx) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_MISSES,0,NULL) +-# define SSL_CTX_sess_timeouts(ctx) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_TIMEOUTS,0,NULL) +-# define SSL_CTX_sess_cache_full(ctx) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CACHE_FULL,0,NULL) +- +-void SSL_CTX_sess_set_new_cb(SSL_CTX *ctx, +- int (*new_session_cb) (struct ssl_st *ssl, +- SSL_SESSION *sess)); +-int (*SSL_CTX_sess_get_new_cb(SSL_CTX *ctx)) (struct ssl_st *ssl, +- SSL_SESSION *sess); +-void SSL_CTX_sess_set_remove_cb(SSL_CTX *ctx, +- void (*remove_session_cb) (struct ssl_ctx_st +- *ctx, +- SSL_SESSION *sess)); +-void (*SSL_CTX_sess_get_remove_cb(SSL_CTX *ctx)) (struct ssl_ctx_st *ctx, +- SSL_SESSION *sess); +-void SSL_CTX_sess_set_get_cb(SSL_CTX *ctx, +- SSL_SESSION *(*get_session_cb) (struct ssl_st +- *ssl, +- const unsigned char +- *data, int len, +- int *copy)); +-SSL_SESSION *(*SSL_CTX_sess_get_get_cb(SSL_CTX *ctx)) (struct ssl_st *ssl, +- const unsigned char *data, +- int len, int *copy); +-void SSL_CTX_set_info_callback(SSL_CTX *ctx, +- void (*cb) (const SSL *ssl, int type, int val)); +-void (*SSL_CTX_get_info_callback(SSL_CTX *ctx)) (const SSL *ssl, int type, +- int val); +-void SSL_CTX_set_client_cert_cb(SSL_CTX *ctx, +- int (*client_cert_cb) (SSL *ssl, X509 **x509, +- EVP_PKEY **pkey)); +-int (*SSL_CTX_get_client_cert_cb(SSL_CTX *ctx)) (SSL *ssl, X509 **x509, +- EVP_PKEY **pkey); +-# ifndef OPENSSL_NO_ENGINE +-__owur int SSL_CTX_set_client_cert_engine(SSL_CTX *ctx, ENGINE *e); +-# endif +-void SSL_CTX_set_cookie_generate_cb(SSL_CTX *ctx, +- int (*app_gen_cookie_cb) (SSL *ssl, +- unsigned char +- *cookie, +- unsigned int +- *cookie_len)); +-void SSL_CTX_set_cookie_verify_cb(SSL_CTX *ctx, +- int (*app_verify_cookie_cb) (SSL *ssl, +- const unsigned +- char *cookie, +- unsigned int +- cookie_len)); +- +-void SSL_CTX_set_stateless_cookie_generate_cb( +- SSL_CTX *ctx, +- int (*gen_stateless_cookie_cb) (SSL *ssl, +- unsigned char *cookie, +- size_t *cookie_len)); +-void SSL_CTX_set_stateless_cookie_verify_cb( +- SSL_CTX *ctx, +- int (*verify_stateless_cookie_cb) (SSL *ssl, +- const unsigned char *cookie, +- size_t cookie_len)); +-# ifndef OPENSSL_NO_NEXTPROTONEG +- +-typedef int (*SSL_CTX_npn_advertised_cb_func)(SSL *ssl, +- const unsigned char **out, +- unsigned int *outlen, +- void *arg); +-void SSL_CTX_set_next_protos_advertised_cb(SSL_CTX *s, +- SSL_CTX_npn_advertised_cb_func cb, +- void *arg); +-# define SSL_CTX_set_npn_advertised_cb SSL_CTX_set_next_protos_advertised_cb +- +-typedef int (*SSL_CTX_npn_select_cb_func)(SSL *s, +- unsigned char **out, +- unsigned char *outlen, +- const unsigned char *in, +- unsigned int inlen, +- void *arg); +-void SSL_CTX_set_next_proto_select_cb(SSL_CTX *s, +- SSL_CTX_npn_select_cb_func cb, +- void *arg); +-# define SSL_CTX_set_npn_select_cb SSL_CTX_set_next_proto_select_cb +- +-void SSL_get0_next_proto_negotiated(const SSL *s, const unsigned char **data, +- unsigned *len); +-# define SSL_get0_npn_negotiated SSL_get0_next_proto_negotiated +-# endif +- +-__owur int SSL_select_next_proto(unsigned char **out, unsigned char *outlen, +- const unsigned char *in, unsigned int inlen, +- const unsigned char *client, +- unsigned int client_len); +- +-# define OPENSSL_NPN_UNSUPPORTED 0 +-# define OPENSSL_NPN_NEGOTIATED 1 +-# define OPENSSL_NPN_NO_OVERLAP 2 +- +-__owur int SSL_CTX_set_alpn_protos(SSL_CTX *ctx, const unsigned char *protos, +- unsigned int protos_len); +-__owur int SSL_set_alpn_protos(SSL *ssl, const unsigned char *protos, +- unsigned int protos_len); +-typedef int (*SSL_CTX_alpn_select_cb_func)(SSL *ssl, +- const unsigned char **out, +- unsigned char *outlen, +- const unsigned char *in, +- unsigned int inlen, +- void *arg); +-void SSL_CTX_set_alpn_select_cb(SSL_CTX *ctx, +- SSL_CTX_alpn_select_cb_func cb, +- void *arg); +-void SSL_get0_alpn_selected(const SSL *ssl, const unsigned char **data, +- unsigned int *len); +- +-# ifndef OPENSSL_NO_PSK +-/* +- * the maximum length of the buffer given to callbacks containing the +- * resulting identity/psk +- */ +-# define PSK_MAX_IDENTITY_LEN 128 +-# define PSK_MAX_PSK_LEN 256 +-typedef unsigned int (*SSL_psk_client_cb_func)(SSL *ssl, +- const char *hint, +- char *identity, +- unsigned int max_identity_len, +- unsigned char *psk, +- unsigned int max_psk_len); +-void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx, SSL_psk_client_cb_func cb); +-void SSL_set_psk_client_callback(SSL *ssl, SSL_psk_client_cb_func cb); +- +-typedef unsigned int (*SSL_psk_server_cb_func)(SSL *ssl, +- const char *identity, +- unsigned char *psk, +- unsigned int max_psk_len); +-void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx, SSL_psk_server_cb_func cb); +-void SSL_set_psk_server_callback(SSL *ssl, SSL_psk_server_cb_func cb); +- +-__owur int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *identity_hint); +-__owur int SSL_use_psk_identity_hint(SSL *s, const char *identity_hint); +-const char *SSL_get_psk_identity_hint(const SSL *s); +-const char *SSL_get_psk_identity(const SSL *s); +-# endif +- +-typedef int (*SSL_psk_find_session_cb_func)(SSL *ssl, +- const unsigned char *identity, +- size_t identity_len, +- SSL_SESSION **sess); +-typedef int (*SSL_psk_use_session_cb_func)(SSL *ssl, const EVP_MD *md, +- const unsigned char **id, +- size_t *idlen, +- SSL_SESSION **sess); +- +-void SSL_set_psk_find_session_callback(SSL *s, SSL_psk_find_session_cb_func cb); +-void SSL_CTX_set_psk_find_session_callback(SSL_CTX *ctx, +- SSL_psk_find_session_cb_func cb); +-void SSL_set_psk_use_session_callback(SSL *s, SSL_psk_use_session_cb_func cb); +-void SSL_CTX_set_psk_use_session_callback(SSL_CTX *ctx, +- SSL_psk_use_session_cb_func cb); +- +-/* Register callbacks to handle custom TLS Extensions for client or server. */ +- +-__owur int SSL_CTX_has_client_custom_ext(const SSL_CTX *ctx, +- unsigned int ext_type); +- +-__owur int SSL_CTX_add_client_custom_ext(SSL_CTX *ctx, +- unsigned int ext_type, +- custom_ext_add_cb add_cb, +- custom_ext_free_cb free_cb, +- void *add_arg, +- custom_ext_parse_cb parse_cb, +- void *parse_arg); +- +-__owur int SSL_CTX_add_server_custom_ext(SSL_CTX *ctx, +- unsigned int ext_type, +- custom_ext_add_cb add_cb, +- custom_ext_free_cb free_cb, +- void *add_arg, +- custom_ext_parse_cb parse_cb, +- void *parse_arg); +- +-__owur int SSL_CTX_add_custom_ext(SSL_CTX *ctx, unsigned int ext_type, +- unsigned int context, +- SSL_custom_ext_add_cb_ex add_cb, +- SSL_custom_ext_free_cb_ex free_cb, +- void *add_arg, +- SSL_custom_ext_parse_cb_ex parse_cb, +- void *parse_arg); +- +-__owur int SSL_extension_supported(unsigned int ext_type); +- +-# define SSL_NOTHING 1 +-# define SSL_WRITING 2 +-# define SSL_READING 3 +-# define SSL_X509_LOOKUP 4 +-# define SSL_ASYNC_PAUSED 5 +-# define SSL_ASYNC_NO_JOBS 6 +-# define SSL_CLIENT_HELLO_CB 7 +- +-/* These will only be used when doing non-blocking IO */ +-# define SSL_want_nothing(s) (SSL_want(s) == SSL_NOTHING) +-# define SSL_want_read(s) (SSL_want(s) == SSL_READING) +-# define SSL_want_write(s) (SSL_want(s) == SSL_WRITING) +-# define SSL_want_x509_lookup(s) (SSL_want(s) == SSL_X509_LOOKUP) +-# define SSL_want_async(s) (SSL_want(s) == SSL_ASYNC_PAUSED) +-# define SSL_want_async_job(s) (SSL_want(s) == SSL_ASYNC_NO_JOBS) +-# define SSL_want_client_hello_cb(s) (SSL_want(s) == SSL_CLIENT_HELLO_CB) +- +-# define SSL_MAC_FLAG_READ_MAC_STREAM 1 +-# define SSL_MAC_FLAG_WRITE_MAC_STREAM 2 +- +-/* +- * A callback for logging out TLS key material. This callback should log out +- * |line| followed by a newline. +- */ +-typedef void (*SSL_CTX_keylog_cb_func)(const SSL *ssl, const char *line); +- +-/* +- * SSL_CTX_set_keylog_callback configures a callback to log key material. This +- * is intended for debugging use with tools like Wireshark. The cb function +- * should log line followed by a newline. +- */ +-void SSL_CTX_set_keylog_callback(SSL_CTX *ctx, SSL_CTX_keylog_cb_func cb); +- +-/* +- * SSL_CTX_get_keylog_callback returns the callback configured by +- * SSL_CTX_set_keylog_callback. +- */ +-SSL_CTX_keylog_cb_func SSL_CTX_get_keylog_callback(const SSL_CTX *ctx); +- +-int SSL_CTX_set_max_early_data(SSL_CTX *ctx, uint32_t max_early_data); +-uint32_t SSL_CTX_get_max_early_data(const SSL_CTX *ctx); +-int SSL_set_max_early_data(SSL *s, uint32_t max_early_data); +-uint32_t SSL_get_max_early_data(const SSL *s); +-int SSL_CTX_set_recv_max_early_data(SSL_CTX *ctx, uint32_t recv_max_early_data); +-uint32_t SSL_CTX_get_recv_max_early_data(const SSL_CTX *ctx); +-int SSL_set_recv_max_early_data(SSL *s, uint32_t recv_max_early_data); +-uint32_t SSL_get_recv_max_early_data(const SSL *s); +- +-#ifdef __cplusplus +-} +-#endif +- +-# include +-# include +-# include /* This is mostly sslv3 with a few tweaks */ +-# include /* Datagram TLS */ +-# include /* Support for the use_srtp extension */ +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-/* +- * These need to be after the above set of includes due to a compiler bug +- * in VisualStudio 2015 +- */ +-DEFINE_STACK_OF_CONST(SSL_CIPHER) +-DEFINE_STACK_OF(SSL_COMP) +- +-/* compatibility */ +-# define SSL_set_app_data(s,arg) (SSL_set_ex_data(s,0,(char *)(arg))) +-# define SSL_get_app_data(s) (SSL_get_ex_data(s,0)) +-# define SSL_SESSION_set_app_data(s,a) (SSL_SESSION_set_ex_data(s,0, \ +- (char *)(a))) +-# define SSL_SESSION_get_app_data(s) (SSL_SESSION_get_ex_data(s,0)) +-# define SSL_CTX_get_app_data(ctx) (SSL_CTX_get_ex_data(ctx,0)) +-# define SSL_CTX_set_app_data(ctx,arg) (SSL_CTX_set_ex_data(ctx,0, \ +- (char *)(arg))) +-DEPRECATEDIN_1_1_0(void SSL_set_debug(SSL *s, int debug)) +- +-/* TLSv1.3 KeyUpdate message types */ +-/* -1 used so that this is an invalid value for the on-the-wire protocol */ +-#define SSL_KEY_UPDATE_NONE -1 +-/* Values as defined for the on-the-wire protocol */ +-#define SSL_KEY_UPDATE_NOT_REQUESTED 0 +-#define SSL_KEY_UPDATE_REQUESTED 1 +- +-/* +- * The valid handshake states (one for each type message sent and one for each +- * type of message received). There are also two "special" states: +- * TLS = TLS or DTLS state +- * DTLS = DTLS specific state +- * CR/SR = Client Read/Server Read +- * CW/SW = Client Write/Server Write +- * +- * The "special" states are: +- * TLS_ST_BEFORE = No handshake has been initiated yet +- * TLS_ST_OK = A handshake has been successfully completed +- */ +-typedef enum { +- TLS_ST_BEFORE, +- TLS_ST_OK, +- DTLS_ST_CR_HELLO_VERIFY_REQUEST, +- TLS_ST_CR_SRVR_HELLO, +- TLS_ST_CR_CERT, +- TLS_ST_CR_CERT_STATUS, +- TLS_ST_CR_KEY_EXCH, +- TLS_ST_CR_CERT_REQ, +- TLS_ST_CR_SRVR_DONE, +- TLS_ST_CR_SESSION_TICKET, +- TLS_ST_CR_CHANGE, +- TLS_ST_CR_FINISHED, +- TLS_ST_CW_CLNT_HELLO, +- TLS_ST_CW_CERT, +- TLS_ST_CW_KEY_EXCH, +- TLS_ST_CW_CERT_VRFY, +- TLS_ST_CW_CHANGE, +- TLS_ST_CW_NEXT_PROTO, +- TLS_ST_CW_FINISHED, +- TLS_ST_SW_HELLO_REQ, +- TLS_ST_SR_CLNT_HELLO, +- DTLS_ST_SW_HELLO_VERIFY_REQUEST, +- TLS_ST_SW_SRVR_HELLO, +- TLS_ST_SW_CERT, +- TLS_ST_SW_KEY_EXCH, +- TLS_ST_SW_CERT_REQ, +- TLS_ST_SW_SRVR_DONE, +- TLS_ST_SR_CERT, +- TLS_ST_SR_KEY_EXCH, +- TLS_ST_SR_CERT_VRFY, +- TLS_ST_SR_NEXT_PROTO, +- TLS_ST_SR_CHANGE, +- TLS_ST_SR_FINISHED, +- TLS_ST_SW_SESSION_TICKET, +- TLS_ST_SW_CERT_STATUS, +- TLS_ST_SW_CHANGE, +- TLS_ST_SW_FINISHED, +- TLS_ST_SW_ENCRYPTED_EXTENSIONS, +- TLS_ST_CR_ENCRYPTED_EXTENSIONS, +- TLS_ST_CR_CERT_VRFY, +- TLS_ST_SW_CERT_VRFY, +- TLS_ST_CR_HELLO_REQ, +- TLS_ST_SW_KEY_UPDATE, +- TLS_ST_CW_KEY_UPDATE, +- TLS_ST_SR_KEY_UPDATE, +- TLS_ST_CR_KEY_UPDATE, +- TLS_ST_EARLY_DATA, +- TLS_ST_PENDING_EARLY_DATA_END, +- TLS_ST_CW_END_OF_EARLY_DATA, +- TLS_ST_SR_END_OF_EARLY_DATA +-} OSSL_HANDSHAKE_STATE; +- +-/* +- * Most of the following state values are no longer used and are defined to be +- * the closest equivalent value in the current state machine code. Not all +- * defines have an equivalent and are set to a dummy value (-1). SSL_ST_CONNECT +- * and SSL_ST_ACCEPT are still in use in the definition of SSL_CB_ACCEPT_LOOP, +- * SSL_CB_ACCEPT_EXIT, SSL_CB_CONNECT_LOOP and SSL_CB_CONNECT_EXIT. +- */ +- +-# define SSL_ST_CONNECT 0x1000 +-# define SSL_ST_ACCEPT 0x2000 +- +-# define SSL_ST_MASK 0x0FFF +- +-# define SSL_CB_LOOP 0x01 +-# define SSL_CB_EXIT 0x02 +-# define SSL_CB_READ 0x04 +-# define SSL_CB_WRITE 0x08 +-# define SSL_CB_ALERT 0x4000/* used in callback */ +-# define SSL_CB_READ_ALERT (SSL_CB_ALERT|SSL_CB_READ) +-# define SSL_CB_WRITE_ALERT (SSL_CB_ALERT|SSL_CB_WRITE) +-# define SSL_CB_ACCEPT_LOOP (SSL_ST_ACCEPT|SSL_CB_LOOP) +-# define SSL_CB_ACCEPT_EXIT (SSL_ST_ACCEPT|SSL_CB_EXIT) +-# define SSL_CB_CONNECT_LOOP (SSL_ST_CONNECT|SSL_CB_LOOP) +-# define SSL_CB_CONNECT_EXIT (SSL_ST_CONNECT|SSL_CB_EXIT) +-# define SSL_CB_HANDSHAKE_START 0x10 +-# define SSL_CB_HANDSHAKE_DONE 0x20 +- +-/* Is the SSL_connection established? */ +-# define SSL_in_connect_init(a) (SSL_in_init(a) && !SSL_is_server(a)) +-# define SSL_in_accept_init(a) (SSL_in_init(a) && SSL_is_server(a)) +-int SSL_in_init(const SSL *s); +-int SSL_in_before(const SSL *s); +-int SSL_is_init_finished(const SSL *s); +- +-/* +- * The following 3 states are kept in ssl->rlayer.rstate when reads fail, you +- * should not need these +- */ +-# define SSL_ST_READ_HEADER 0xF0 +-# define SSL_ST_READ_BODY 0xF1 +-# define SSL_ST_READ_DONE 0xF2 +- +-/*- +- * Obtain latest Finished message +- * -- that we sent (SSL_get_finished) +- * -- that we expected from peer (SSL_get_peer_finished). +- * Returns length (0 == no Finished so far), copies up to 'count' bytes. +- */ +-size_t SSL_get_finished(const SSL *s, void *buf, size_t count); +-size_t SSL_get_peer_finished(const SSL *s, void *buf, size_t count); +- +-/* +- * use either SSL_VERIFY_NONE or SSL_VERIFY_PEER, the last 3 options are +- * 'ored' with SSL_VERIFY_PEER if they are desired +- */ +-# define SSL_VERIFY_NONE 0x00 +-# define SSL_VERIFY_PEER 0x01 +-# define SSL_VERIFY_FAIL_IF_NO_PEER_CERT 0x02 +-# define SSL_VERIFY_CLIENT_ONCE 0x04 +-# define SSL_VERIFY_POST_HANDSHAKE 0x08 +- +-# if OPENSSL_API_COMPAT < 0x10100000L +-# define OpenSSL_add_ssl_algorithms() SSL_library_init() +-# define SSLeay_add_ssl_algorithms() SSL_library_init() +-# endif +- +-/* More backward compatibility */ +-# define SSL_get_cipher(s) \ +- SSL_CIPHER_get_name(SSL_get_current_cipher(s)) +-# define SSL_get_cipher_bits(s,np) \ +- SSL_CIPHER_get_bits(SSL_get_current_cipher(s),np) +-# define SSL_get_cipher_version(s) \ +- SSL_CIPHER_get_version(SSL_get_current_cipher(s)) +-# define SSL_get_cipher_name(s) \ +- SSL_CIPHER_get_name(SSL_get_current_cipher(s)) +-# define SSL_get_time(a) SSL_SESSION_get_time(a) +-# define SSL_set_time(a,b) SSL_SESSION_set_time((a),(b)) +-# define SSL_get_timeout(a) SSL_SESSION_get_timeout(a) +-# define SSL_set_timeout(a,b) SSL_SESSION_set_timeout((a),(b)) +- +-# define d2i_SSL_SESSION_bio(bp,s_id) ASN1_d2i_bio_of(SSL_SESSION,SSL_SESSION_new,d2i_SSL_SESSION,bp,s_id) +-# define i2d_SSL_SESSION_bio(bp,s_id) ASN1_i2d_bio_of(SSL_SESSION,i2d_SSL_SESSION,bp,s_id) +- +-DECLARE_PEM_rw(SSL_SESSION, SSL_SESSION) +-# define SSL_AD_REASON_OFFSET 1000/* offset to get SSL_R_... value +- * from SSL_AD_... */ +-/* These alert types are for SSLv3 and TLSv1 */ +-# define SSL_AD_CLOSE_NOTIFY SSL3_AD_CLOSE_NOTIFY +-/* fatal */ +-# define SSL_AD_UNEXPECTED_MESSAGE SSL3_AD_UNEXPECTED_MESSAGE +-/* fatal */ +-# define SSL_AD_BAD_RECORD_MAC SSL3_AD_BAD_RECORD_MAC +-# define SSL_AD_DECRYPTION_FAILED TLS1_AD_DECRYPTION_FAILED +-# define SSL_AD_RECORD_OVERFLOW TLS1_AD_RECORD_OVERFLOW +-/* fatal */ +-# define SSL_AD_DECOMPRESSION_FAILURE SSL3_AD_DECOMPRESSION_FAILURE +-/* fatal */ +-# define SSL_AD_HANDSHAKE_FAILURE SSL3_AD_HANDSHAKE_FAILURE +-/* Not for TLS */ +-# define SSL_AD_NO_CERTIFICATE SSL3_AD_NO_CERTIFICATE +-# define SSL_AD_BAD_CERTIFICATE SSL3_AD_BAD_CERTIFICATE +-# define SSL_AD_UNSUPPORTED_CERTIFICATE SSL3_AD_UNSUPPORTED_CERTIFICATE +-# define SSL_AD_CERTIFICATE_REVOKED SSL3_AD_CERTIFICATE_REVOKED +-# define SSL_AD_CERTIFICATE_EXPIRED SSL3_AD_CERTIFICATE_EXPIRED +-# define SSL_AD_CERTIFICATE_UNKNOWN SSL3_AD_CERTIFICATE_UNKNOWN +-/* fatal */ +-# define SSL_AD_ILLEGAL_PARAMETER SSL3_AD_ILLEGAL_PARAMETER +-/* fatal */ +-# define SSL_AD_UNKNOWN_CA TLS1_AD_UNKNOWN_CA +-/* fatal */ +-# define SSL_AD_ACCESS_DENIED TLS1_AD_ACCESS_DENIED +-/* fatal */ +-# define SSL_AD_DECODE_ERROR TLS1_AD_DECODE_ERROR +-# define SSL_AD_DECRYPT_ERROR TLS1_AD_DECRYPT_ERROR +-/* fatal */ +-# define SSL_AD_EXPORT_RESTRICTION TLS1_AD_EXPORT_RESTRICTION +-/* fatal */ +-# define SSL_AD_PROTOCOL_VERSION TLS1_AD_PROTOCOL_VERSION +-/* fatal */ +-# define SSL_AD_INSUFFICIENT_SECURITY TLS1_AD_INSUFFICIENT_SECURITY +-/* fatal */ +-# define SSL_AD_INTERNAL_ERROR TLS1_AD_INTERNAL_ERROR +-# define SSL_AD_USER_CANCELLED TLS1_AD_USER_CANCELLED +-# define SSL_AD_NO_RENEGOTIATION TLS1_AD_NO_RENEGOTIATION +-# define SSL_AD_MISSING_EXTENSION TLS13_AD_MISSING_EXTENSION +-# define SSL_AD_CERTIFICATE_REQUIRED TLS13_AD_CERTIFICATE_REQUIRED +-# define SSL_AD_UNSUPPORTED_EXTENSION TLS1_AD_UNSUPPORTED_EXTENSION +-# define SSL_AD_CERTIFICATE_UNOBTAINABLE TLS1_AD_CERTIFICATE_UNOBTAINABLE +-# define SSL_AD_UNRECOGNIZED_NAME TLS1_AD_UNRECOGNIZED_NAME +-# define SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE +-# define SSL_AD_BAD_CERTIFICATE_HASH_VALUE TLS1_AD_BAD_CERTIFICATE_HASH_VALUE +-/* fatal */ +-# define SSL_AD_UNKNOWN_PSK_IDENTITY TLS1_AD_UNKNOWN_PSK_IDENTITY +-/* fatal */ +-# define SSL_AD_INAPPROPRIATE_FALLBACK TLS1_AD_INAPPROPRIATE_FALLBACK +-# define SSL_AD_NO_APPLICATION_PROTOCOL TLS1_AD_NO_APPLICATION_PROTOCOL +-# define SSL_ERROR_NONE 0 +-# define SSL_ERROR_SSL 1 +-# define SSL_ERROR_WANT_READ 2 +-# define SSL_ERROR_WANT_WRITE 3 +-# define SSL_ERROR_WANT_X509_LOOKUP 4 +-# define SSL_ERROR_SYSCALL 5/* look at error stack/return +- * value/errno */ +-# define SSL_ERROR_ZERO_RETURN 6 +-# define SSL_ERROR_WANT_CONNECT 7 +-# define SSL_ERROR_WANT_ACCEPT 8 +-# define SSL_ERROR_WANT_ASYNC 9 +-# define SSL_ERROR_WANT_ASYNC_JOB 10 +-# define SSL_ERROR_WANT_CLIENT_HELLO_CB 11 +-# define SSL_CTRL_SET_TMP_DH 3 +-# define SSL_CTRL_SET_TMP_ECDH 4 +-# define SSL_CTRL_SET_TMP_DH_CB 6 +-# define SSL_CTRL_GET_CLIENT_CERT_REQUEST 9 +-# define SSL_CTRL_GET_NUM_RENEGOTIATIONS 10 +-# define SSL_CTRL_CLEAR_NUM_RENEGOTIATIONS 11 +-# define SSL_CTRL_GET_TOTAL_RENEGOTIATIONS 12 +-# define SSL_CTRL_GET_FLAGS 13 +-# define SSL_CTRL_EXTRA_CHAIN_CERT 14 +-# define SSL_CTRL_SET_MSG_CALLBACK 15 +-# define SSL_CTRL_SET_MSG_CALLBACK_ARG 16 +-/* only applies to datagram connections */ +-# define SSL_CTRL_SET_MTU 17 +-/* Stats */ +-# define SSL_CTRL_SESS_NUMBER 20 +-# define SSL_CTRL_SESS_CONNECT 21 +-# define SSL_CTRL_SESS_CONNECT_GOOD 22 +-# define SSL_CTRL_SESS_CONNECT_RENEGOTIATE 23 +-# define SSL_CTRL_SESS_ACCEPT 24 +-# define SSL_CTRL_SESS_ACCEPT_GOOD 25 +-# define SSL_CTRL_SESS_ACCEPT_RENEGOTIATE 26 +-# define SSL_CTRL_SESS_HIT 27 +-# define SSL_CTRL_SESS_CB_HIT 28 +-# define SSL_CTRL_SESS_MISSES 29 +-# define SSL_CTRL_SESS_TIMEOUTS 30 +-# define SSL_CTRL_SESS_CACHE_FULL 31 +-# define SSL_CTRL_MODE 33 +-# define SSL_CTRL_GET_READ_AHEAD 40 +-# define SSL_CTRL_SET_READ_AHEAD 41 +-# define SSL_CTRL_SET_SESS_CACHE_SIZE 42 +-# define SSL_CTRL_GET_SESS_CACHE_SIZE 43 +-# define SSL_CTRL_SET_SESS_CACHE_MODE 44 +-# define SSL_CTRL_GET_SESS_CACHE_MODE 45 +-# define SSL_CTRL_GET_MAX_CERT_LIST 50 +-# define SSL_CTRL_SET_MAX_CERT_LIST 51 +-# define SSL_CTRL_SET_MAX_SEND_FRAGMENT 52 +-/* see tls1.h for macros based on these */ +-# define SSL_CTRL_SET_TLSEXT_SERVERNAME_CB 53 +-# define SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG 54 +-# define SSL_CTRL_SET_TLSEXT_HOSTNAME 55 +-# define SSL_CTRL_SET_TLSEXT_DEBUG_CB 56 +-# define SSL_CTRL_SET_TLSEXT_DEBUG_ARG 57 +-# define SSL_CTRL_GET_TLSEXT_TICKET_KEYS 58 +-# define SSL_CTRL_SET_TLSEXT_TICKET_KEYS 59 +-/*# define SSL_CTRL_SET_TLSEXT_OPAQUE_PRF_INPUT 60 */ +-/*# define SSL_CTRL_SET_TLSEXT_OPAQUE_PRF_INPUT_CB 61 */ +-/*# define SSL_CTRL_SET_TLSEXT_OPAQUE_PRF_INPUT_CB_ARG 62 */ +-# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB 63 +-# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB_ARG 64 +-# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE 65 +-# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_EXTS 66 +-# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_EXTS 67 +-# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_IDS 68 +-# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_IDS 69 +-# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_OCSP_RESP 70 +-# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_OCSP_RESP 71 +-# define SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB 72 +-# define SSL_CTRL_SET_TLS_EXT_SRP_USERNAME_CB 75 +-# define SSL_CTRL_SET_SRP_VERIFY_PARAM_CB 76 +-# define SSL_CTRL_SET_SRP_GIVE_CLIENT_PWD_CB 77 +-# define SSL_CTRL_SET_SRP_ARG 78 +-# define SSL_CTRL_SET_TLS_EXT_SRP_USERNAME 79 +-# define SSL_CTRL_SET_TLS_EXT_SRP_STRENGTH 80 +-# define SSL_CTRL_SET_TLS_EXT_SRP_PASSWORD 81 +-# ifndef OPENSSL_NO_HEARTBEATS +-# define SSL_CTRL_DTLS_EXT_SEND_HEARTBEAT 85 +-# define SSL_CTRL_GET_DTLS_EXT_HEARTBEAT_PENDING 86 +-# define SSL_CTRL_SET_DTLS_EXT_HEARTBEAT_NO_REQUESTS 87 +-# endif +-# define DTLS_CTRL_GET_TIMEOUT 73 +-# define DTLS_CTRL_HANDLE_TIMEOUT 74 +-# define SSL_CTRL_GET_RI_SUPPORT 76 +-# define SSL_CTRL_CLEAR_MODE 78 +-# define SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB 79 +-# define SSL_CTRL_GET_EXTRA_CHAIN_CERTS 82 +-# define SSL_CTRL_CLEAR_EXTRA_CHAIN_CERTS 83 +-# define SSL_CTRL_CHAIN 88 +-# define SSL_CTRL_CHAIN_CERT 89 +-# define SSL_CTRL_GET_GROUPS 90 +-# define SSL_CTRL_SET_GROUPS 91 +-# define SSL_CTRL_SET_GROUPS_LIST 92 +-# define SSL_CTRL_GET_SHARED_GROUP 93 +-# define SSL_CTRL_SET_SIGALGS 97 +-# define SSL_CTRL_SET_SIGALGS_LIST 98 +-# define SSL_CTRL_CERT_FLAGS 99 +-# define SSL_CTRL_CLEAR_CERT_FLAGS 100 +-# define SSL_CTRL_SET_CLIENT_SIGALGS 101 +-# define SSL_CTRL_SET_CLIENT_SIGALGS_LIST 102 +-# define SSL_CTRL_GET_CLIENT_CERT_TYPES 103 +-# define SSL_CTRL_SET_CLIENT_CERT_TYPES 104 +-# define SSL_CTRL_BUILD_CERT_CHAIN 105 +-# define SSL_CTRL_SET_VERIFY_CERT_STORE 106 +-# define SSL_CTRL_SET_CHAIN_CERT_STORE 107 +-# define SSL_CTRL_GET_PEER_SIGNATURE_NID 108 +-# define SSL_CTRL_GET_PEER_TMP_KEY 109 +-# define SSL_CTRL_GET_RAW_CIPHERLIST 110 +-# define SSL_CTRL_GET_EC_POINT_FORMATS 111 +-# define SSL_CTRL_GET_CHAIN_CERTS 115 +-# define SSL_CTRL_SELECT_CURRENT_CERT 116 +-# define SSL_CTRL_SET_CURRENT_CERT 117 +-# define SSL_CTRL_SET_DH_AUTO 118 +-# define DTLS_CTRL_SET_LINK_MTU 120 +-# define DTLS_CTRL_GET_LINK_MIN_MTU 121 +-# define SSL_CTRL_GET_EXTMS_SUPPORT 122 +-# define SSL_CTRL_SET_MIN_PROTO_VERSION 123 +-# define SSL_CTRL_SET_MAX_PROTO_VERSION 124 +-# define SSL_CTRL_SET_SPLIT_SEND_FRAGMENT 125 +-# define SSL_CTRL_SET_MAX_PIPELINES 126 +-# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_TYPE 127 +-# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB 128 +-# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB_ARG 129 +-# define SSL_CTRL_GET_MIN_PROTO_VERSION 130 +-# define SSL_CTRL_GET_MAX_PROTO_VERSION 131 +-# define SSL_CTRL_GET_SIGNATURE_NID 132 +-# define SSL_CTRL_GET_TMP_KEY 133 +-# define SSL_CERT_SET_FIRST 1 +-# define SSL_CERT_SET_NEXT 2 +-# define SSL_CERT_SET_SERVER 3 +-# define DTLSv1_get_timeout(ssl, arg) \ +- SSL_ctrl(ssl,DTLS_CTRL_GET_TIMEOUT,0, (void *)(arg)) +-# define DTLSv1_handle_timeout(ssl) \ +- SSL_ctrl(ssl,DTLS_CTRL_HANDLE_TIMEOUT,0, NULL) +-# define SSL_num_renegotiations(ssl) \ +- SSL_ctrl((ssl),SSL_CTRL_GET_NUM_RENEGOTIATIONS,0,NULL) +-# define SSL_clear_num_renegotiations(ssl) \ +- SSL_ctrl((ssl),SSL_CTRL_CLEAR_NUM_RENEGOTIATIONS,0,NULL) +-# define SSL_total_renegotiations(ssl) \ +- SSL_ctrl((ssl),SSL_CTRL_GET_TOTAL_RENEGOTIATIONS,0,NULL) +-# define SSL_CTX_set_tmp_dh(ctx,dh) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TMP_DH,0,(char *)(dh)) +-# define SSL_CTX_set_tmp_ecdh(ctx,ecdh) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TMP_ECDH,0,(char *)(ecdh)) +-# define SSL_CTX_set_dh_auto(ctx, onoff) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_DH_AUTO,onoff,NULL) +-# define SSL_set_dh_auto(s, onoff) \ +- SSL_ctrl(s,SSL_CTRL_SET_DH_AUTO,onoff,NULL) +-# define SSL_set_tmp_dh(ssl,dh) \ +- SSL_ctrl(ssl,SSL_CTRL_SET_TMP_DH,0,(char *)(dh)) +-# define SSL_set_tmp_ecdh(ssl,ecdh) \ +- SSL_ctrl(ssl,SSL_CTRL_SET_TMP_ECDH,0,(char *)(ecdh)) +-# define SSL_CTX_add_extra_chain_cert(ctx,x509) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_EXTRA_CHAIN_CERT,0,(char *)(x509)) +-# define SSL_CTX_get_extra_chain_certs(ctx,px509) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_GET_EXTRA_CHAIN_CERTS,0,px509) +-# define SSL_CTX_get_extra_chain_certs_only(ctx,px509) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_GET_EXTRA_CHAIN_CERTS,1,px509) +-# define SSL_CTX_clear_extra_chain_certs(ctx) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_CLEAR_EXTRA_CHAIN_CERTS,0,NULL) +-# define SSL_CTX_set0_chain(ctx,sk) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_CHAIN,0,(char *)(sk)) +-# define SSL_CTX_set1_chain(ctx,sk) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_CHAIN,1,(char *)(sk)) +-# define SSL_CTX_add0_chain_cert(ctx,x509) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_CHAIN_CERT,0,(char *)(x509)) +-# define SSL_CTX_add1_chain_cert(ctx,x509) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_CHAIN_CERT,1,(char *)(x509)) +-# define SSL_CTX_get0_chain_certs(ctx,px509) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_GET_CHAIN_CERTS,0,px509) +-# define SSL_CTX_clear_chain_certs(ctx) \ +- SSL_CTX_set0_chain(ctx,NULL) +-# define SSL_CTX_build_cert_chain(ctx, flags) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_BUILD_CERT_CHAIN, flags, NULL) +-# define SSL_CTX_select_current_cert(ctx,x509) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SELECT_CURRENT_CERT,0,(char *)(x509)) +-# define SSL_CTX_set_current_cert(ctx, op) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CURRENT_CERT, op, NULL) +-# define SSL_CTX_set0_verify_cert_store(ctx,st) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_VERIFY_CERT_STORE,0,(char *)(st)) +-# define SSL_CTX_set1_verify_cert_store(ctx,st) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_VERIFY_CERT_STORE,1,(char *)(st)) +-# define SSL_CTX_set0_chain_cert_store(ctx,st) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CHAIN_CERT_STORE,0,(char *)(st)) +-# define SSL_CTX_set1_chain_cert_store(ctx,st) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CHAIN_CERT_STORE,1,(char *)(st)) +-# define SSL_set0_chain(s,sk) \ +- SSL_ctrl(s,SSL_CTRL_CHAIN,0,(char *)(sk)) +-# define SSL_set1_chain(s,sk) \ +- SSL_ctrl(s,SSL_CTRL_CHAIN,1,(char *)(sk)) +-# define SSL_add0_chain_cert(s,x509) \ +- SSL_ctrl(s,SSL_CTRL_CHAIN_CERT,0,(char *)(x509)) +-# define SSL_add1_chain_cert(s,x509) \ +- SSL_ctrl(s,SSL_CTRL_CHAIN_CERT,1,(char *)(x509)) +-# define SSL_get0_chain_certs(s,px509) \ +- SSL_ctrl(s,SSL_CTRL_GET_CHAIN_CERTS,0,px509) +-# define SSL_clear_chain_certs(s) \ +- SSL_set0_chain(s,NULL) +-# define SSL_build_cert_chain(s, flags) \ +- SSL_ctrl(s,SSL_CTRL_BUILD_CERT_CHAIN, flags, NULL) +-# define SSL_select_current_cert(s,x509) \ +- SSL_ctrl(s,SSL_CTRL_SELECT_CURRENT_CERT,0,(char *)(x509)) +-# define SSL_set_current_cert(s,op) \ +- SSL_ctrl(s,SSL_CTRL_SET_CURRENT_CERT, op, NULL) +-# define SSL_set0_verify_cert_store(s,st) \ +- SSL_ctrl(s,SSL_CTRL_SET_VERIFY_CERT_STORE,0,(char *)(st)) +-# define SSL_set1_verify_cert_store(s,st) \ +- SSL_ctrl(s,SSL_CTRL_SET_VERIFY_CERT_STORE,1,(char *)(st)) +-# define SSL_set0_chain_cert_store(s,st) \ +- SSL_ctrl(s,SSL_CTRL_SET_CHAIN_CERT_STORE,0,(char *)(st)) +-# define SSL_set1_chain_cert_store(s,st) \ +- SSL_ctrl(s,SSL_CTRL_SET_CHAIN_CERT_STORE,1,(char *)(st)) +-# define SSL_get1_groups(s, glist) \ +- SSL_ctrl(s,SSL_CTRL_GET_GROUPS,0,(int*)(glist)) +-# define SSL_CTX_set1_groups(ctx, glist, glistlen) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_GROUPS,glistlen,(int *)(glist)) +-# define SSL_CTX_set1_groups_list(ctx, s) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_GROUPS_LIST,0,(char *)(s)) +-# define SSL_set1_groups(s, glist, glistlen) \ +- SSL_ctrl(s,SSL_CTRL_SET_GROUPS,glistlen,(char *)(glist)) +-# define SSL_set1_groups_list(s, str) \ +- SSL_ctrl(s,SSL_CTRL_SET_GROUPS_LIST,0,(char *)(str)) +-# define SSL_get_shared_group(s, n) \ +- SSL_ctrl(s,SSL_CTRL_GET_SHARED_GROUP,n,NULL) +-# define SSL_CTX_set1_sigalgs(ctx, slist, slistlen) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SIGALGS,slistlen,(int *)(slist)) +-# define SSL_CTX_set1_sigalgs_list(ctx, s) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SIGALGS_LIST,0,(char *)(s)) +-# define SSL_set1_sigalgs(s, slist, slistlen) \ +- SSL_ctrl(s,SSL_CTRL_SET_SIGALGS,slistlen,(int *)(slist)) +-# define SSL_set1_sigalgs_list(s, str) \ +- SSL_ctrl(s,SSL_CTRL_SET_SIGALGS_LIST,0,(char *)(str)) +-# define SSL_CTX_set1_client_sigalgs(ctx, slist, slistlen) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CLIENT_SIGALGS,slistlen,(int *)(slist)) +-# define SSL_CTX_set1_client_sigalgs_list(ctx, s) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CLIENT_SIGALGS_LIST,0,(char *)(s)) +-# define SSL_set1_client_sigalgs(s, slist, slistlen) \ +- SSL_ctrl(s,SSL_CTRL_SET_CLIENT_SIGALGS,slistlen,(int *)(slist)) +-# define SSL_set1_client_sigalgs_list(s, str) \ +- SSL_ctrl(s,SSL_CTRL_SET_CLIENT_SIGALGS_LIST,0,(char *)(str)) +-# define SSL_get0_certificate_types(s, clist) \ +- SSL_ctrl(s, SSL_CTRL_GET_CLIENT_CERT_TYPES, 0, (char *)(clist)) +-# define SSL_CTX_set1_client_certificate_types(ctx, clist, clistlen) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CLIENT_CERT_TYPES,clistlen, \ +- (char *)(clist)) +-# define SSL_set1_client_certificate_types(s, clist, clistlen) \ +- SSL_ctrl(s,SSL_CTRL_SET_CLIENT_CERT_TYPES,clistlen,(char *)(clist)) +-# define SSL_get_signature_nid(s, pn) \ +- SSL_ctrl(s,SSL_CTRL_GET_SIGNATURE_NID,0,pn) +-# define SSL_get_peer_signature_nid(s, pn) \ +- SSL_ctrl(s,SSL_CTRL_GET_PEER_SIGNATURE_NID,0,pn) +-# define SSL_get_peer_tmp_key(s, pk) \ +- SSL_ctrl(s,SSL_CTRL_GET_PEER_TMP_KEY,0,pk) +-# define SSL_get_tmp_key(s, pk) \ +- SSL_ctrl(s,SSL_CTRL_GET_TMP_KEY,0,pk) +-# define SSL_get0_raw_cipherlist(s, plst) \ +- SSL_ctrl(s,SSL_CTRL_GET_RAW_CIPHERLIST,0,plst) +-# define SSL_get0_ec_point_formats(s, plst) \ +- SSL_ctrl(s,SSL_CTRL_GET_EC_POINT_FORMATS,0,plst) +-# define SSL_CTX_set_min_proto_version(ctx, version) \ +- SSL_CTX_ctrl(ctx, SSL_CTRL_SET_MIN_PROTO_VERSION, version, NULL) +-# define SSL_CTX_set_max_proto_version(ctx, version) \ +- SSL_CTX_ctrl(ctx, SSL_CTRL_SET_MAX_PROTO_VERSION, version, NULL) +-# define SSL_CTX_get_min_proto_version(ctx) \ +- SSL_CTX_ctrl(ctx, SSL_CTRL_GET_MIN_PROTO_VERSION, 0, NULL) +-# define SSL_CTX_get_max_proto_version(ctx) \ +- SSL_CTX_ctrl(ctx, SSL_CTRL_GET_MAX_PROTO_VERSION, 0, NULL) +-# define SSL_set_min_proto_version(s, version) \ +- SSL_ctrl(s, SSL_CTRL_SET_MIN_PROTO_VERSION, version, NULL) +-# define SSL_set_max_proto_version(s, version) \ +- SSL_ctrl(s, SSL_CTRL_SET_MAX_PROTO_VERSION, version, NULL) +-# define SSL_get_min_proto_version(s) \ +- SSL_ctrl(s, SSL_CTRL_GET_MIN_PROTO_VERSION, 0, NULL) +-# define SSL_get_max_proto_version(s) \ +- SSL_ctrl(s, SSL_CTRL_GET_MAX_PROTO_VERSION, 0, NULL) +- +-/* Backwards compatibility, original 1.1.0 names */ +-# define SSL_CTRL_GET_SERVER_TMP_KEY \ +- SSL_CTRL_GET_PEER_TMP_KEY +-# define SSL_get_server_tmp_key(s, pk) \ +- SSL_get_peer_tmp_key(s, pk) +- +-/* +- * The following symbol names are old and obsolete. They are kept +- * for compatibility reasons only and should not be used anymore. +- */ +-# define SSL_CTRL_GET_CURVES SSL_CTRL_GET_GROUPS +-# define SSL_CTRL_SET_CURVES SSL_CTRL_SET_GROUPS +-# define SSL_CTRL_SET_CURVES_LIST SSL_CTRL_SET_GROUPS_LIST +-# define SSL_CTRL_GET_SHARED_CURVE SSL_CTRL_GET_SHARED_GROUP +- +-# define SSL_get1_curves SSL_get1_groups +-# define SSL_CTX_set1_curves SSL_CTX_set1_groups +-# define SSL_CTX_set1_curves_list SSL_CTX_set1_groups_list +-# define SSL_set1_curves SSL_set1_groups +-# define SSL_set1_curves_list SSL_set1_groups_list +-# define SSL_get_shared_curve SSL_get_shared_group +- +- +-# if OPENSSL_API_COMPAT < 0x10100000L +-/* Provide some compatibility macros for removed functionality. */ +-# define SSL_CTX_need_tmp_RSA(ctx) 0 +-# define SSL_CTX_set_tmp_rsa(ctx,rsa) 1 +-# define SSL_need_tmp_RSA(ssl) 0 +-# define SSL_set_tmp_rsa(ssl,rsa) 1 +-# define SSL_CTX_set_ecdh_auto(dummy, onoff) ((onoff) != 0) +-# define SSL_set_ecdh_auto(dummy, onoff) ((onoff) != 0) +-/* +- * We "pretend" to call the callback to avoid warnings about unused static +- * functions. +- */ +-# define SSL_CTX_set_tmp_rsa_callback(ctx, cb) while(0) (cb)(NULL, 0, 0) +-# define SSL_set_tmp_rsa_callback(ssl, cb) while(0) (cb)(NULL, 0, 0) +-# endif +-__owur const BIO_METHOD *BIO_f_ssl(void); +-__owur BIO *BIO_new_ssl(SSL_CTX *ctx, int client); +-__owur BIO *BIO_new_ssl_connect(SSL_CTX *ctx); +-__owur BIO *BIO_new_buffer_ssl_connect(SSL_CTX *ctx); +-__owur int BIO_ssl_copy_session_id(BIO *to, BIO *from); +-void BIO_ssl_shutdown(BIO *ssl_bio); +- +-__owur int SSL_CTX_set_cipher_list(SSL_CTX *, const char *str); +-__owur SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth); +-int SSL_CTX_up_ref(SSL_CTX *ctx); +-void SSL_CTX_free(SSL_CTX *); +-__owur long SSL_CTX_set_timeout(SSL_CTX *ctx, long t); +-__owur long SSL_CTX_get_timeout(const SSL_CTX *ctx); +-__owur X509_STORE *SSL_CTX_get_cert_store(const SSL_CTX *); +-void SSL_CTX_set_cert_store(SSL_CTX *, X509_STORE *); +-void SSL_CTX_set1_cert_store(SSL_CTX *, X509_STORE *); +-__owur int SSL_want(const SSL *s); +-__owur int SSL_clear(SSL *s); +- +-void SSL_CTX_flush_sessions(SSL_CTX *ctx, long tm); +- +-__owur const SSL_CIPHER *SSL_get_current_cipher(const SSL *s); +-__owur const SSL_CIPHER *SSL_get_pending_cipher(const SSL *s); +-__owur int SSL_CIPHER_get_bits(const SSL_CIPHER *c, int *alg_bits); +-__owur const char *SSL_CIPHER_get_version(const SSL_CIPHER *c); +-__owur const char *SSL_CIPHER_get_name(const SSL_CIPHER *c); +-__owur const char *SSL_CIPHER_standard_name(const SSL_CIPHER *c); +-__owur const char *OPENSSL_cipher_name(const char *rfc_name); +-__owur uint32_t SSL_CIPHER_get_id(const SSL_CIPHER *c); +-__owur uint16_t SSL_CIPHER_get_protocol_id(const SSL_CIPHER *c); +-__owur int SSL_CIPHER_get_kx_nid(const SSL_CIPHER *c); +-__owur int SSL_CIPHER_get_auth_nid(const SSL_CIPHER *c); +-__owur const EVP_MD *SSL_CIPHER_get_handshake_digest(const SSL_CIPHER *c); +-__owur int SSL_CIPHER_is_aead(const SSL_CIPHER *c); +- +-__owur int SSL_get_fd(const SSL *s); +-__owur int SSL_get_rfd(const SSL *s); +-__owur int SSL_get_wfd(const SSL *s); +-__owur const char *SSL_get_cipher_list(const SSL *s, int n); +-__owur char *SSL_get_shared_ciphers(const SSL *s, char *buf, int size); +-__owur int SSL_get_read_ahead(const SSL *s); +-__owur int SSL_pending(const SSL *s); +-__owur int SSL_has_pending(const SSL *s); +-# ifndef OPENSSL_NO_SOCK +-__owur int SSL_set_fd(SSL *s, int fd); +-__owur int SSL_set_rfd(SSL *s, int fd); +-__owur int SSL_set_wfd(SSL *s, int fd); +-# endif +-void SSL_set0_rbio(SSL *s, BIO *rbio); +-void SSL_set0_wbio(SSL *s, BIO *wbio); +-void SSL_set_bio(SSL *s, BIO *rbio, BIO *wbio); +-__owur BIO *SSL_get_rbio(const SSL *s); +-__owur BIO *SSL_get_wbio(const SSL *s); +-__owur int SSL_set_cipher_list(SSL *s, const char *str); +-__owur int SSL_CTX_set_ciphersuites(SSL_CTX *ctx, const char *str); +-__owur int SSL_set_ciphersuites(SSL *s, const char *str); +-void SSL_set_read_ahead(SSL *s, int yes); +-__owur int SSL_get_verify_mode(const SSL *s); +-__owur int SSL_get_verify_depth(const SSL *s); +-__owur SSL_verify_cb SSL_get_verify_callback(const SSL *s); +-void SSL_set_verify(SSL *s, int mode, SSL_verify_cb callback); +-void SSL_set_verify_depth(SSL *s, int depth); +-void SSL_set_cert_cb(SSL *s, int (*cb) (SSL *ssl, void *arg), void *arg); +-# ifndef OPENSSL_NO_RSA +-__owur int SSL_use_RSAPrivateKey(SSL *ssl, RSA *rsa); +-__owur int SSL_use_RSAPrivateKey_ASN1(SSL *ssl, const unsigned char *d, +- long len); +-# endif +-__owur int SSL_use_PrivateKey(SSL *ssl, EVP_PKEY *pkey); +-__owur int SSL_use_PrivateKey_ASN1(int pk, SSL *ssl, const unsigned char *d, +- long len); +-__owur int SSL_use_certificate(SSL *ssl, X509 *x); +-__owur int SSL_use_certificate_ASN1(SSL *ssl, const unsigned char *d, int len); +-__owur int SSL_use_cert_and_key(SSL *ssl, X509 *x509, EVP_PKEY *privatekey, +- STACK_OF(X509) *chain, int override); +- +- +-/* serverinfo file format versions */ +-# define SSL_SERVERINFOV1 1 +-# define SSL_SERVERINFOV2 2 +- +-/* Set serverinfo data for the current active cert. */ +-__owur int SSL_CTX_use_serverinfo(SSL_CTX *ctx, const unsigned char *serverinfo, +- size_t serverinfo_length); +-__owur int SSL_CTX_use_serverinfo_ex(SSL_CTX *ctx, unsigned int version, +- const unsigned char *serverinfo, +- size_t serverinfo_length); +-__owur int SSL_CTX_use_serverinfo_file(SSL_CTX *ctx, const char *file); +- +-#ifndef OPENSSL_NO_RSA +-__owur int SSL_use_RSAPrivateKey_file(SSL *ssl, const char *file, int type); +-#endif +- +-__owur int SSL_use_PrivateKey_file(SSL *ssl, const char *file, int type); +-__owur int SSL_use_certificate_file(SSL *ssl, const char *file, int type); +- +-#ifndef OPENSSL_NO_RSA +-__owur int SSL_CTX_use_RSAPrivateKey_file(SSL_CTX *ctx, const char *file, +- int type); +-#endif +-__owur int SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, const char *file, +- int type); +-__owur int SSL_CTX_use_certificate_file(SSL_CTX *ctx, const char *file, +- int type); +-/* PEM type */ +-__owur int SSL_CTX_use_certificate_chain_file(SSL_CTX *ctx, const char *file); +-__owur int SSL_use_certificate_chain_file(SSL *ssl, const char *file); +-__owur STACK_OF(X509_NAME) *SSL_load_client_CA_file(const char *file); +-__owur int SSL_add_file_cert_subjects_to_stack(STACK_OF(X509_NAME) *stackCAs, +- const char *file); +-int SSL_add_dir_cert_subjects_to_stack(STACK_OF(X509_NAME) *stackCAs, +- const char *dir); +- +-# if OPENSSL_API_COMPAT < 0x10100000L +-# define SSL_load_error_strings() \ +- OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS \ +- | OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL) +-# endif +- +-__owur const char *SSL_state_string(const SSL *s); +-__owur const char *SSL_rstate_string(const SSL *s); +-__owur const char *SSL_state_string_long(const SSL *s); +-__owur const char *SSL_rstate_string_long(const SSL *s); +-__owur long SSL_SESSION_get_time(const SSL_SESSION *s); +-__owur long SSL_SESSION_set_time(SSL_SESSION *s, long t); +-__owur long SSL_SESSION_get_timeout(const SSL_SESSION *s); +-__owur long SSL_SESSION_set_timeout(SSL_SESSION *s, long t); +-__owur int SSL_SESSION_get_protocol_version(const SSL_SESSION *s); +-__owur int SSL_SESSION_set_protocol_version(SSL_SESSION *s, int version); +- +-__owur const char *SSL_SESSION_get0_hostname(const SSL_SESSION *s); +-__owur int SSL_SESSION_set1_hostname(SSL_SESSION *s, const char *hostname); +-void SSL_SESSION_get0_alpn_selected(const SSL_SESSION *s, +- const unsigned char **alpn, +- size_t *len); +-__owur int SSL_SESSION_set1_alpn_selected(SSL_SESSION *s, +- const unsigned char *alpn, +- size_t len); +-__owur const SSL_CIPHER *SSL_SESSION_get0_cipher(const SSL_SESSION *s); +-__owur int SSL_SESSION_set_cipher(SSL_SESSION *s, const SSL_CIPHER *cipher); +-__owur int SSL_SESSION_has_ticket(const SSL_SESSION *s); +-__owur unsigned long SSL_SESSION_get_ticket_lifetime_hint(const SSL_SESSION *s); +-void SSL_SESSION_get0_ticket(const SSL_SESSION *s, const unsigned char **tick, +- size_t *len); +-__owur uint32_t SSL_SESSION_get_max_early_data(const SSL_SESSION *s); +-__owur int SSL_SESSION_set_max_early_data(SSL_SESSION *s, +- uint32_t max_early_data); +-__owur int SSL_copy_session_id(SSL *to, const SSL *from); +-__owur X509 *SSL_SESSION_get0_peer(SSL_SESSION *s); +-__owur int SSL_SESSION_set1_id_context(SSL_SESSION *s, +- const unsigned char *sid_ctx, +- unsigned int sid_ctx_len); +-__owur int SSL_SESSION_set1_id(SSL_SESSION *s, const unsigned char *sid, +- unsigned int sid_len); +-__owur int SSL_SESSION_is_resumable(const SSL_SESSION *s); +- +-__owur SSL_SESSION *SSL_SESSION_new(void); +-__owur SSL_SESSION *SSL_SESSION_dup(SSL_SESSION *src); +-const unsigned char *SSL_SESSION_get_id(const SSL_SESSION *s, +- unsigned int *len); +-const unsigned char *SSL_SESSION_get0_id_context(const SSL_SESSION *s, +- unsigned int *len); +-__owur unsigned int SSL_SESSION_get_compress_id(const SSL_SESSION *s); +-# ifndef OPENSSL_NO_STDIO +-int SSL_SESSION_print_fp(FILE *fp, const SSL_SESSION *ses); +-# endif +-int SSL_SESSION_print(BIO *fp, const SSL_SESSION *ses); +-int SSL_SESSION_print_keylog(BIO *bp, const SSL_SESSION *x); +-int SSL_SESSION_up_ref(SSL_SESSION *ses); +-void SSL_SESSION_free(SSL_SESSION *ses); +-__owur int i2d_SSL_SESSION(SSL_SESSION *in, unsigned char **pp); +-__owur int SSL_set_session(SSL *to, SSL_SESSION *session); +-int SSL_CTX_add_session(SSL_CTX *ctx, SSL_SESSION *session); +-int SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *session); +-__owur int SSL_CTX_set_generate_session_id(SSL_CTX *ctx, GEN_SESSION_CB cb); +-__owur int SSL_set_generate_session_id(SSL *s, GEN_SESSION_CB cb); +-__owur int SSL_has_matching_session_id(const SSL *s, +- const unsigned char *id, +- unsigned int id_len); +-SSL_SESSION *d2i_SSL_SESSION(SSL_SESSION **a, const unsigned char **pp, +- long length); +- +-# ifdef HEADER_X509_H +-__owur X509 *SSL_get_peer_certificate(const SSL *s); +-# endif +- +-__owur STACK_OF(X509) *SSL_get_peer_cert_chain(const SSL *s); +- +-__owur int SSL_CTX_get_verify_mode(const SSL_CTX *ctx); +-__owur int SSL_CTX_get_verify_depth(const SSL_CTX *ctx); +-__owur SSL_verify_cb SSL_CTX_get_verify_callback(const SSL_CTX *ctx); +-void SSL_CTX_set_verify(SSL_CTX *ctx, int mode, SSL_verify_cb callback); +-void SSL_CTX_set_verify_depth(SSL_CTX *ctx, int depth); +-void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx, +- int (*cb) (X509_STORE_CTX *, void *), +- void *arg); +-void SSL_CTX_set_cert_cb(SSL_CTX *c, int (*cb) (SSL *ssl, void *arg), +- void *arg); +-# ifndef OPENSSL_NO_RSA +-__owur int SSL_CTX_use_RSAPrivateKey(SSL_CTX *ctx, RSA *rsa); +-__owur int SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX *ctx, const unsigned char *d, +- long len); +-# endif +-__owur int SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey); +-__owur int SSL_CTX_use_PrivateKey_ASN1(int pk, SSL_CTX *ctx, +- const unsigned char *d, long len); +-__owur int SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x); +-__owur int SSL_CTX_use_certificate_ASN1(SSL_CTX *ctx, int len, +- const unsigned char *d); +-__owur int SSL_CTX_use_cert_and_key(SSL_CTX *ctx, X509 *x509, EVP_PKEY *privatekey, +- STACK_OF(X509) *chain, int override); +- +-void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb); +-void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx, void *u); +-pem_password_cb *SSL_CTX_get_default_passwd_cb(SSL_CTX *ctx); +-void *SSL_CTX_get_default_passwd_cb_userdata(SSL_CTX *ctx); +-void SSL_set_default_passwd_cb(SSL *s, pem_password_cb *cb); +-void SSL_set_default_passwd_cb_userdata(SSL *s, void *u); +-pem_password_cb *SSL_get_default_passwd_cb(SSL *s); +-void *SSL_get_default_passwd_cb_userdata(SSL *s); +- +-__owur int SSL_CTX_check_private_key(const SSL_CTX *ctx); +-__owur int SSL_check_private_key(const SSL *ctx); +- +-__owur int SSL_CTX_set_session_id_context(SSL_CTX *ctx, +- const unsigned char *sid_ctx, +- unsigned int sid_ctx_len); +- +-SSL *SSL_new(SSL_CTX *ctx); +-int SSL_up_ref(SSL *s); +-int SSL_is_dtls(const SSL *s); +-__owur int SSL_set_session_id_context(SSL *ssl, const unsigned char *sid_ctx, +- unsigned int sid_ctx_len); +- +-__owur int SSL_CTX_set_purpose(SSL_CTX *ctx, int purpose); +-__owur int SSL_set_purpose(SSL *ssl, int purpose); +-__owur int SSL_CTX_set_trust(SSL_CTX *ctx, int trust); +-__owur int SSL_set_trust(SSL *ssl, int trust); +- +-__owur int SSL_set1_host(SSL *s, const char *hostname); +-__owur int SSL_add1_host(SSL *s, const char *hostname); +-__owur const char *SSL_get0_peername(SSL *s); +-void SSL_set_hostflags(SSL *s, unsigned int flags); +- +-__owur int SSL_CTX_dane_enable(SSL_CTX *ctx); +-__owur int SSL_CTX_dane_mtype_set(SSL_CTX *ctx, const EVP_MD *md, +- uint8_t mtype, uint8_t ord); +-__owur int SSL_dane_enable(SSL *s, const char *basedomain); +-__owur int SSL_dane_tlsa_add(SSL *s, uint8_t usage, uint8_t selector, +- uint8_t mtype, unsigned const char *data, size_t dlen); +-__owur int SSL_get0_dane_authority(SSL *s, X509 **mcert, EVP_PKEY **mspki); +-__owur int SSL_get0_dane_tlsa(SSL *s, uint8_t *usage, uint8_t *selector, +- uint8_t *mtype, unsigned const char **data, +- size_t *dlen); +-/* +- * Bridge opacity barrier between libcrypt and libssl, also needed to support +- * offline testing in test/danetest.c +- */ +-SSL_DANE *SSL_get0_dane(SSL *ssl); +-/* +- * DANE flags +- */ +-unsigned long SSL_CTX_dane_set_flags(SSL_CTX *ctx, unsigned long flags); +-unsigned long SSL_CTX_dane_clear_flags(SSL_CTX *ctx, unsigned long flags); +-unsigned long SSL_dane_set_flags(SSL *ssl, unsigned long flags); +-unsigned long SSL_dane_clear_flags(SSL *ssl, unsigned long flags); +- +-__owur int SSL_CTX_set1_param(SSL_CTX *ctx, X509_VERIFY_PARAM *vpm); +-__owur int SSL_set1_param(SSL *ssl, X509_VERIFY_PARAM *vpm); +- +-__owur X509_VERIFY_PARAM *SSL_CTX_get0_param(SSL_CTX *ctx); +-__owur X509_VERIFY_PARAM *SSL_get0_param(SSL *ssl); +- +-# ifndef OPENSSL_NO_SRP +-int SSL_CTX_set_srp_username(SSL_CTX *ctx, char *name); +-int SSL_CTX_set_srp_password(SSL_CTX *ctx, char *password); +-int SSL_CTX_set_srp_strength(SSL_CTX *ctx, int strength); +-int SSL_CTX_set_srp_client_pwd_callback(SSL_CTX *ctx, +- char *(*cb) (SSL *, void *)); +-int SSL_CTX_set_srp_verify_param_callback(SSL_CTX *ctx, +- int (*cb) (SSL *, void *)); +-int SSL_CTX_set_srp_username_callback(SSL_CTX *ctx, +- int (*cb) (SSL *, int *, void *)); +-int SSL_CTX_set_srp_cb_arg(SSL_CTX *ctx, void *arg); +- +-int SSL_set_srp_server_param(SSL *s, const BIGNUM *N, const BIGNUM *g, +- BIGNUM *sa, BIGNUM *v, char *info); +-int SSL_set_srp_server_param_pw(SSL *s, const char *user, const char *pass, +- const char *grp); +- +-__owur BIGNUM *SSL_get_srp_g(SSL *s); +-__owur BIGNUM *SSL_get_srp_N(SSL *s); +- +-__owur char *SSL_get_srp_username(SSL *s); +-__owur char *SSL_get_srp_userinfo(SSL *s); +-# endif +- +-/* +- * ClientHello callback and helpers. +- */ +- +-# define SSL_CLIENT_HELLO_SUCCESS 1 +-# define SSL_CLIENT_HELLO_ERROR 0 +-# define SSL_CLIENT_HELLO_RETRY (-1) +- +-typedef int (*SSL_client_hello_cb_fn) (SSL *s, int *al, void *arg); +-void SSL_CTX_set_client_hello_cb(SSL_CTX *c, SSL_client_hello_cb_fn cb, +- void *arg); +-int SSL_client_hello_isv2(SSL *s); +-unsigned int SSL_client_hello_get0_legacy_version(SSL *s); +-size_t SSL_client_hello_get0_random(SSL *s, const unsigned char **out); +-size_t SSL_client_hello_get0_session_id(SSL *s, const unsigned char **out); +-size_t SSL_client_hello_get0_ciphers(SSL *s, const unsigned char **out); +-size_t SSL_client_hello_get0_compression_methods(SSL *s, +- const unsigned char **out); +-int SSL_client_hello_get1_extensions_present(SSL *s, int **out, size_t *outlen); +-int SSL_client_hello_get0_ext(SSL *s, unsigned int type, +- const unsigned char **out, size_t *outlen); +- +-void SSL_certs_clear(SSL *s); +-void SSL_free(SSL *ssl); +-# ifdef OSSL_ASYNC_FD +-/* +- * Windows application developer has to include windows.h to use these. +- */ +-__owur int SSL_waiting_for_async(SSL *s); +-__owur int SSL_get_all_async_fds(SSL *s, OSSL_ASYNC_FD *fds, size_t *numfds); +-__owur int SSL_get_changed_async_fds(SSL *s, OSSL_ASYNC_FD *addfd, +- size_t *numaddfds, OSSL_ASYNC_FD *delfd, +- size_t *numdelfds); +-# endif +-__owur int SSL_accept(SSL *ssl); +-__owur int SSL_stateless(SSL *s); +-__owur int SSL_connect(SSL *ssl); +-__owur int SSL_read(SSL *ssl, void *buf, int num); +-__owur int SSL_read_ex(SSL *ssl, void *buf, size_t num, size_t *readbytes); +- +-# define SSL_READ_EARLY_DATA_ERROR 0 +-# define SSL_READ_EARLY_DATA_SUCCESS 1 +-# define SSL_READ_EARLY_DATA_FINISH 2 +- +-__owur int SSL_read_early_data(SSL *s, void *buf, size_t num, +- size_t *readbytes); +-__owur int SSL_peek(SSL *ssl, void *buf, int num); +-__owur int SSL_peek_ex(SSL *ssl, void *buf, size_t num, size_t *readbytes); +-__owur int SSL_write(SSL *ssl, const void *buf, int num); +-__owur int SSL_write_ex(SSL *s, const void *buf, size_t num, size_t *written); +-__owur int SSL_write_early_data(SSL *s, const void *buf, size_t num, +- size_t *written); +-long SSL_ctrl(SSL *ssl, int cmd, long larg, void *parg); +-long SSL_callback_ctrl(SSL *, int, void (*)(void)); +-long SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg); +-long SSL_CTX_callback_ctrl(SSL_CTX *, int, void (*)(void)); +- +-# define SSL_EARLY_DATA_NOT_SENT 0 +-# define SSL_EARLY_DATA_REJECTED 1 +-# define SSL_EARLY_DATA_ACCEPTED 2 +- +-__owur int SSL_get_early_data_status(const SSL *s); +- +-__owur int SSL_get_error(const SSL *s, int ret_code); +-__owur const char *SSL_get_version(const SSL *s); +- +-/* This sets the 'default' SSL version that SSL_new() will create */ +-__owur int SSL_CTX_set_ssl_version(SSL_CTX *ctx, const SSL_METHOD *meth); +- +-# ifndef OPENSSL_NO_SSL3_METHOD +-DEPRECATEDIN_1_1_0(__owur const SSL_METHOD *SSLv3_method(void)) /* SSLv3 */ +-DEPRECATEDIN_1_1_0(__owur const SSL_METHOD *SSLv3_server_method(void)) +-DEPRECATEDIN_1_1_0(__owur const SSL_METHOD *SSLv3_client_method(void)) +-# endif +- +-#define SSLv23_method TLS_method +-#define SSLv23_server_method TLS_server_method +-#define SSLv23_client_method TLS_client_method +- +-/* Negotiate highest available SSL/TLS version */ +-__owur const SSL_METHOD *TLS_method(void); +-__owur const SSL_METHOD *TLS_server_method(void); +-__owur const SSL_METHOD *TLS_client_method(void); +- +-# ifndef OPENSSL_NO_TLS1_METHOD +-DEPRECATEDIN_1_1_0(__owur const SSL_METHOD *TLSv1_method(void)) /* TLSv1.0 */ +-DEPRECATEDIN_1_1_0(__owur const SSL_METHOD *TLSv1_server_method(void)) +-DEPRECATEDIN_1_1_0(__owur const SSL_METHOD *TLSv1_client_method(void)) +-# endif +- +-# ifndef OPENSSL_NO_TLS1_1_METHOD +-DEPRECATEDIN_1_1_0(__owur const SSL_METHOD *TLSv1_1_method(void)) /* TLSv1.1 */ +-DEPRECATEDIN_1_1_0(__owur const SSL_METHOD *TLSv1_1_server_method(void)) +-DEPRECATEDIN_1_1_0(__owur const SSL_METHOD *TLSv1_1_client_method(void)) +-# endif +- +-# ifndef OPENSSL_NO_TLS1_2_METHOD +-DEPRECATEDIN_1_1_0(__owur const SSL_METHOD *TLSv1_2_method(void)) /* TLSv1.2 */ +-DEPRECATEDIN_1_1_0(__owur const SSL_METHOD *TLSv1_2_server_method(void)) +-DEPRECATEDIN_1_1_0(__owur const SSL_METHOD *TLSv1_2_client_method(void)) +-# endif +- +-# ifndef OPENSSL_NO_DTLS1_METHOD +-DEPRECATEDIN_1_1_0(__owur const SSL_METHOD *DTLSv1_method(void)) /* DTLSv1.0 */ +-DEPRECATEDIN_1_1_0(__owur const SSL_METHOD *DTLSv1_server_method(void)) +-DEPRECATEDIN_1_1_0(__owur const SSL_METHOD *DTLSv1_client_method(void)) +-# endif +- +-# ifndef OPENSSL_NO_DTLS1_2_METHOD +-/* DTLSv1.2 */ +-DEPRECATEDIN_1_1_0(__owur const SSL_METHOD *DTLSv1_2_method(void)) +-DEPRECATEDIN_1_1_0(__owur const SSL_METHOD *DTLSv1_2_server_method(void)) +-DEPRECATEDIN_1_1_0(__owur const SSL_METHOD *DTLSv1_2_client_method(void)) +-# endif +- +-__owur const SSL_METHOD *DTLS_method(void); /* DTLS 1.0 and 1.2 */ +-__owur const SSL_METHOD *DTLS_server_method(void); /* DTLS 1.0 and 1.2 */ +-__owur const SSL_METHOD *DTLS_client_method(void); /* DTLS 1.0 and 1.2 */ +- +-__owur size_t DTLS_get_data_mtu(const SSL *s); +- +-__owur STACK_OF(SSL_CIPHER) *SSL_get_ciphers(const SSL *s); +-__owur STACK_OF(SSL_CIPHER) *SSL_CTX_get_ciphers(const SSL_CTX *ctx); +-__owur STACK_OF(SSL_CIPHER) *SSL_get_client_ciphers(const SSL *s); +-__owur STACK_OF(SSL_CIPHER) *SSL_get1_supported_ciphers(SSL *s); +- +-__owur int SSL_do_handshake(SSL *s); +-int SSL_key_update(SSL *s, int updatetype); +-int SSL_get_key_update_type(const SSL *s); +-int SSL_renegotiate(SSL *s); +-int SSL_renegotiate_abbreviated(SSL *s); +-__owur int SSL_renegotiate_pending(const SSL *s); +-int SSL_shutdown(SSL *s); +-__owur int SSL_verify_client_post_handshake(SSL *s); +-void SSL_CTX_set_post_handshake_auth(SSL_CTX *ctx, int val); +-void SSL_set_post_handshake_auth(SSL *s, int val); +- +-__owur const SSL_METHOD *SSL_CTX_get_ssl_method(const SSL_CTX *ctx); +-__owur const SSL_METHOD *SSL_get_ssl_method(const SSL *s); +-__owur int SSL_set_ssl_method(SSL *s, const SSL_METHOD *method); +-__owur const char *SSL_alert_type_string_long(int value); +-__owur const char *SSL_alert_type_string(int value); +-__owur const char *SSL_alert_desc_string_long(int value); +-__owur const char *SSL_alert_desc_string(int value); +- +-void SSL_set0_CA_list(SSL *s, STACK_OF(X509_NAME) *name_list); +-void SSL_CTX_set0_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *name_list); +-__owur const STACK_OF(X509_NAME) *SSL_get0_CA_list(const SSL *s); +-__owur const STACK_OF(X509_NAME) *SSL_CTX_get0_CA_list(const SSL_CTX *ctx); +-__owur int SSL_add1_to_CA_list(SSL *ssl, const X509 *x); +-__owur int SSL_CTX_add1_to_CA_list(SSL_CTX *ctx, const X509 *x); +-__owur const STACK_OF(X509_NAME) *SSL_get0_peer_CA_list(const SSL *s); +- +-void SSL_set_client_CA_list(SSL *s, STACK_OF(X509_NAME) *name_list); +-void SSL_CTX_set_client_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *name_list); +-__owur STACK_OF(X509_NAME) *SSL_get_client_CA_list(const SSL *s); +-__owur STACK_OF(X509_NAME) *SSL_CTX_get_client_CA_list(const SSL_CTX *s); +-__owur int SSL_add_client_CA(SSL *ssl, X509 *x); +-__owur int SSL_CTX_add_client_CA(SSL_CTX *ctx, X509 *x); +- +-void SSL_set_connect_state(SSL *s); +-void SSL_set_accept_state(SSL *s); +- +-__owur long SSL_get_default_timeout(const SSL *s); +- +-# if OPENSSL_API_COMPAT < 0x10100000L +-# define SSL_library_init() OPENSSL_init_ssl(0, NULL) +-# endif +- +-__owur char *SSL_CIPHER_description(const SSL_CIPHER *, char *buf, int size); +-__owur STACK_OF(X509_NAME) *SSL_dup_CA_list(const STACK_OF(X509_NAME) *sk); +- +-__owur SSL *SSL_dup(SSL *ssl); +- +-__owur X509 *SSL_get_certificate(const SSL *ssl); +-/* +- * EVP_PKEY +- */ +-struct evp_pkey_st *SSL_get_privatekey(const SSL *ssl); +- +-__owur X509 *SSL_CTX_get0_certificate(const SSL_CTX *ctx); +-__owur EVP_PKEY *SSL_CTX_get0_privatekey(const SSL_CTX *ctx); +- +-void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx, int mode); +-__owur int SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx); +-void SSL_set_quiet_shutdown(SSL *ssl, int mode); +-__owur int SSL_get_quiet_shutdown(const SSL *ssl); +-void SSL_set_shutdown(SSL *ssl, int mode); +-__owur int SSL_get_shutdown(const SSL *ssl); +-__owur int SSL_version(const SSL *ssl); +-__owur int SSL_client_version(const SSL *s); +-__owur int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx); +-__owur int SSL_CTX_set_default_verify_dir(SSL_CTX *ctx); +-__owur int SSL_CTX_set_default_verify_file(SSL_CTX *ctx); +-__owur int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile, +- const char *CApath); +-# define SSL_get0_session SSL_get_session/* just peek at pointer */ +-__owur SSL_SESSION *SSL_get_session(const SSL *ssl); +-__owur SSL_SESSION *SSL_get1_session(SSL *ssl); /* obtain a reference count */ +-__owur SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl); +-SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX *ctx); +-void SSL_set_info_callback(SSL *ssl, +- void (*cb) (const SSL *ssl, int type, int val)); +-void (*SSL_get_info_callback(const SSL *ssl)) (const SSL *ssl, int type, +- int val); +-__owur OSSL_HANDSHAKE_STATE SSL_get_state(const SSL *ssl); +- +-void SSL_set_verify_result(SSL *ssl, long v); +-__owur long SSL_get_verify_result(const SSL *ssl); +-__owur STACK_OF(X509) *SSL_get0_verified_chain(const SSL *s); +- +-__owur size_t SSL_get_client_random(const SSL *ssl, unsigned char *out, +- size_t outlen); +-__owur size_t SSL_get_server_random(const SSL *ssl, unsigned char *out, +- size_t outlen); +-__owur size_t SSL_SESSION_get_master_key(const SSL_SESSION *sess, +- unsigned char *out, size_t outlen); +-__owur int SSL_SESSION_set1_master_key(SSL_SESSION *sess, +- const unsigned char *in, size_t len); +-uint8_t SSL_SESSION_get_max_fragment_length(const SSL_SESSION *sess); +- +-#define SSL_get_ex_new_index(l, p, newf, dupf, freef) \ +- CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL, l, p, newf, dupf, freef) +-__owur int SSL_set_ex_data(SSL *ssl, int idx, void *data); +-void *SSL_get_ex_data(const SSL *ssl, int idx); +-#define SSL_SESSION_get_ex_new_index(l, p, newf, dupf, freef) \ +- CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL_SESSION, l, p, newf, dupf, freef) +-__owur int SSL_SESSION_set_ex_data(SSL_SESSION *ss, int idx, void *data); +-void *SSL_SESSION_get_ex_data(const SSL_SESSION *ss, int idx); +-#define SSL_CTX_get_ex_new_index(l, p, newf, dupf, freef) \ +- CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL_CTX, l, p, newf, dupf, freef) +-__owur int SSL_CTX_set_ex_data(SSL_CTX *ssl, int idx, void *data); +-void *SSL_CTX_get_ex_data(const SSL_CTX *ssl, int idx); +- +-__owur int SSL_get_ex_data_X509_STORE_CTX_idx(void); +- +-# define SSL_CTX_sess_set_cache_size(ctx,t) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SESS_CACHE_SIZE,t,NULL) +-# define SSL_CTX_sess_get_cache_size(ctx) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_GET_SESS_CACHE_SIZE,0,NULL) +-# define SSL_CTX_set_session_cache_mode(ctx,m) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SESS_CACHE_MODE,m,NULL) +-# define SSL_CTX_get_session_cache_mode(ctx) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_GET_SESS_CACHE_MODE,0,NULL) +- +-# define SSL_CTX_get_default_read_ahead(ctx) SSL_CTX_get_read_ahead(ctx) +-# define SSL_CTX_set_default_read_ahead(ctx,m) SSL_CTX_set_read_ahead(ctx,m) +-# define SSL_CTX_get_read_ahead(ctx) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_GET_READ_AHEAD,0,NULL) +-# define SSL_CTX_set_read_ahead(ctx,m) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_READ_AHEAD,m,NULL) +-# define SSL_CTX_get_max_cert_list(ctx) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_GET_MAX_CERT_LIST,0,NULL) +-# define SSL_CTX_set_max_cert_list(ctx,m) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_MAX_CERT_LIST,m,NULL) +-# define SSL_get_max_cert_list(ssl) \ +- SSL_ctrl(ssl,SSL_CTRL_GET_MAX_CERT_LIST,0,NULL) +-# define SSL_set_max_cert_list(ssl,m) \ +- SSL_ctrl(ssl,SSL_CTRL_SET_MAX_CERT_LIST,m,NULL) +- +-# define SSL_CTX_set_max_send_fragment(ctx,m) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_MAX_SEND_FRAGMENT,m,NULL) +-# define SSL_set_max_send_fragment(ssl,m) \ +- SSL_ctrl(ssl,SSL_CTRL_SET_MAX_SEND_FRAGMENT,m,NULL) +-# define SSL_CTX_set_split_send_fragment(ctx,m) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SPLIT_SEND_FRAGMENT,m,NULL) +-# define SSL_set_split_send_fragment(ssl,m) \ +- SSL_ctrl(ssl,SSL_CTRL_SET_SPLIT_SEND_FRAGMENT,m,NULL) +-# define SSL_CTX_set_max_pipelines(ctx,m) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_MAX_PIPELINES,m,NULL) +-# define SSL_set_max_pipelines(ssl,m) \ +- SSL_ctrl(ssl,SSL_CTRL_SET_MAX_PIPELINES,m,NULL) +- +-void SSL_CTX_set_default_read_buffer_len(SSL_CTX *ctx, size_t len); +-void SSL_set_default_read_buffer_len(SSL *s, size_t len); +- +-# ifndef OPENSSL_NO_DH +-/* NB: the |keylength| is only applicable when is_export is true */ +-void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx, +- DH *(*dh) (SSL *ssl, int is_export, +- int keylength)); +-void SSL_set_tmp_dh_callback(SSL *ssl, +- DH *(*dh) (SSL *ssl, int is_export, +- int keylength)); +-# endif +- +-__owur const COMP_METHOD *SSL_get_current_compression(const SSL *s); +-__owur const COMP_METHOD *SSL_get_current_expansion(const SSL *s); +-__owur const char *SSL_COMP_get_name(const COMP_METHOD *comp); +-__owur const char *SSL_COMP_get0_name(const SSL_COMP *comp); +-__owur int SSL_COMP_get_id(const SSL_COMP *comp); +-STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void); +-__owur STACK_OF(SSL_COMP) *SSL_COMP_set0_compression_methods(STACK_OF(SSL_COMP) +- *meths); +-# if OPENSSL_API_COMPAT < 0x10100000L +-# define SSL_COMP_free_compression_methods() while(0) continue +-# endif +-__owur int SSL_COMP_add_compression_method(int id, COMP_METHOD *cm); +- +-const SSL_CIPHER *SSL_CIPHER_find(SSL *ssl, const unsigned char *ptr); +-int SSL_CIPHER_get_cipher_nid(const SSL_CIPHER *c); +-int SSL_CIPHER_get_digest_nid(const SSL_CIPHER *c); +-int SSL_bytes_to_cipher_list(SSL *s, const unsigned char *bytes, size_t len, +- int isv2format, STACK_OF(SSL_CIPHER) **sk, +- STACK_OF(SSL_CIPHER) **scsvs); +- +-/* TLS extensions functions */ +-__owur int SSL_set_session_ticket_ext(SSL *s, void *ext_data, int ext_len); +- +-__owur int SSL_set_session_ticket_ext_cb(SSL *s, +- tls_session_ticket_ext_cb_fn cb, +- void *arg); +- +-/* Pre-shared secret session resumption functions */ +-__owur int SSL_set_session_secret_cb(SSL *s, +- tls_session_secret_cb_fn session_secret_cb, +- void *arg); +- +-void SSL_CTX_set_not_resumable_session_callback(SSL_CTX *ctx, +- int (*cb) (SSL *ssl, +- int +- is_forward_secure)); +- +-void SSL_set_not_resumable_session_callback(SSL *ssl, +- int (*cb) (SSL *ssl, +- int is_forward_secure)); +- +-void SSL_CTX_set_record_padding_callback(SSL_CTX *ctx, +- size_t (*cb) (SSL *ssl, int type, +- size_t len, void *arg)); +-void SSL_CTX_set_record_padding_callback_arg(SSL_CTX *ctx, void *arg); +-void *SSL_CTX_get_record_padding_callback_arg(const SSL_CTX *ctx); +-int SSL_CTX_set_block_padding(SSL_CTX *ctx, size_t block_size); +- +-void SSL_set_record_padding_callback(SSL *ssl, +- size_t (*cb) (SSL *ssl, int type, +- size_t len, void *arg)); +-void SSL_set_record_padding_callback_arg(SSL *ssl, void *arg); +-void *SSL_get_record_padding_callback_arg(const SSL *ssl); +-int SSL_set_block_padding(SSL *ssl, size_t block_size); +- +-int SSL_set_num_tickets(SSL *s, size_t num_tickets); +-size_t SSL_get_num_tickets(const SSL *s); +-int SSL_CTX_set_num_tickets(SSL_CTX *ctx, size_t num_tickets); +-size_t SSL_CTX_get_num_tickets(const SSL_CTX *ctx); +- +-# if OPENSSL_API_COMPAT < 0x10100000L +-# define SSL_cache_hit(s) SSL_session_reused(s) +-# endif +- +-__owur int SSL_session_reused(const SSL *s); +-__owur int SSL_is_server(const SSL *s); +- +-__owur __owur SSL_CONF_CTX *SSL_CONF_CTX_new(void); +-int SSL_CONF_CTX_finish(SSL_CONF_CTX *cctx); +-void SSL_CONF_CTX_free(SSL_CONF_CTX *cctx); +-unsigned int SSL_CONF_CTX_set_flags(SSL_CONF_CTX *cctx, unsigned int flags); +-__owur unsigned int SSL_CONF_CTX_clear_flags(SSL_CONF_CTX *cctx, +- unsigned int flags); +-__owur int SSL_CONF_CTX_set1_prefix(SSL_CONF_CTX *cctx, const char *pre); +- +-void SSL_CONF_CTX_set_ssl(SSL_CONF_CTX *cctx, SSL *ssl); +-void SSL_CONF_CTX_set_ssl_ctx(SSL_CONF_CTX *cctx, SSL_CTX *ctx); +- +-__owur int SSL_CONF_cmd(SSL_CONF_CTX *cctx, const char *cmd, const char *value); +-__owur int SSL_CONF_cmd_argv(SSL_CONF_CTX *cctx, int *pargc, char ***pargv); +-__owur int SSL_CONF_cmd_value_type(SSL_CONF_CTX *cctx, const char *cmd); +- +-void SSL_add_ssl_module(void); +-int SSL_config(SSL *s, const char *name); +-int SSL_CTX_config(SSL_CTX *ctx, const char *name); +- +-# ifndef OPENSSL_NO_SSL_TRACE +-void SSL_trace(int write_p, int version, int content_type, +- const void *buf, size_t len, SSL *ssl, void *arg); +-# endif +- +-# ifndef OPENSSL_NO_SOCK +-int DTLSv1_listen(SSL *s, BIO_ADDR *client); +-# endif +- +-# ifndef OPENSSL_NO_CT +- +-/* +- * A callback for verifying that the received SCTs are sufficient. +- * Expected to return 1 if they are sufficient, otherwise 0. +- * May return a negative integer if an error occurs. +- * A connection should be aborted if the SCTs are deemed insufficient. +- */ +-typedef int (*ssl_ct_validation_cb)(const CT_POLICY_EVAL_CTX *ctx, +- const STACK_OF(SCT) *scts, void *arg); +- +-/* +- * Sets a |callback| that is invoked upon receipt of ServerHelloDone to validate +- * the received SCTs. +- * If the callback returns a non-positive result, the connection is terminated. +- * Call this function before beginning a handshake. +- * If a NULL |callback| is provided, SCT validation is disabled. +- * |arg| is arbitrary userdata that will be passed to the callback whenever it +- * is invoked. Ownership of |arg| remains with the caller. +- * +- * NOTE: A side-effect of setting a CT callback is that an OCSP stapled response +- * will be requested. +- */ +-int SSL_set_ct_validation_callback(SSL *s, ssl_ct_validation_cb callback, +- void *arg); +-int SSL_CTX_set_ct_validation_callback(SSL_CTX *ctx, +- ssl_ct_validation_cb callback, +- void *arg); +-#define SSL_disable_ct(s) \ +- ((void) SSL_set_validation_callback((s), NULL, NULL)) +-#define SSL_CTX_disable_ct(ctx) \ +- ((void) SSL_CTX_set_validation_callback((ctx), NULL, NULL)) +- +-/* +- * The validation type enumerates the available behaviours of the built-in SSL +- * CT validation callback selected via SSL_enable_ct() and SSL_CTX_enable_ct(). +- * The underlying callback is a static function in libssl. +- */ +-enum { +- SSL_CT_VALIDATION_PERMISSIVE = 0, +- SSL_CT_VALIDATION_STRICT +-}; +- +-/* +- * Enable CT by setting up a callback that implements one of the built-in +- * validation variants. The SSL_CT_VALIDATION_PERMISSIVE variant always +- * continues the handshake, the application can make appropriate decisions at +- * handshake completion. The SSL_CT_VALIDATION_STRICT variant requires at +- * least one valid SCT, or else handshake termination will be requested. The +- * handshake may continue anyway if SSL_VERIFY_NONE is in effect. +- */ +-int SSL_enable_ct(SSL *s, int validation_mode); +-int SSL_CTX_enable_ct(SSL_CTX *ctx, int validation_mode); +- +-/* +- * Report whether a non-NULL callback is enabled. +- */ +-int SSL_ct_is_enabled(const SSL *s); +-int SSL_CTX_ct_is_enabled(const SSL_CTX *ctx); +- +-/* Gets the SCTs received from a connection */ +-const STACK_OF(SCT) *SSL_get0_peer_scts(SSL *s); +- +-/* +- * Loads the CT log list from the default location. +- * If a CTLOG_STORE has previously been set using SSL_CTX_set_ctlog_store, +- * the log information loaded from this file will be appended to the +- * CTLOG_STORE. +- * Returns 1 on success, 0 otherwise. +- */ +-int SSL_CTX_set_default_ctlog_list_file(SSL_CTX *ctx); +- +-/* +- * Loads the CT log list from the specified file path. +- * If a CTLOG_STORE has previously been set using SSL_CTX_set_ctlog_store, +- * the log information loaded from this file will be appended to the +- * CTLOG_STORE. +- * Returns 1 on success, 0 otherwise. +- */ +-int SSL_CTX_set_ctlog_list_file(SSL_CTX *ctx, const char *path); +- +-/* +- * Sets the CT log list used by all SSL connections created from this SSL_CTX. +- * Ownership of the CTLOG_STORE is transferred to the SSL_CTX. +- */ +-void SSL_CTX_set0_ctlog_store(SSL_CTX *ctx, CTLOG_STORE *logs); +- +-/* +- * Gets the CT log list used by all SSL connections created from this SSL_CTX. +- * This will be NULL unless one of the following functions has been called: +- * - SSL_CTX_set_default_ctlog_list_file +- * - SSL_CTX_set_ctlog_list_file +- * - SSL_CTX_set_ctlog_store +- */ +-const CTLOG_STORE *SSL_CTX_get0_ctlog_store(const SSL_CTX *ctx); +- +-# endif /* OPENSSL_NO_CT */ +- +-/* What the "other" parameter contains in security callback */ +-/* Mask for type */ +-# define SSL_SECOP_OTHER_TYPE 0xffff0000 +-# define SSL_SECOP_OTHER_NONE 0 +-# define SSL_SECOP_OTHER_CIPHER (1 << 16) +-# define SSL_SECOP_OTHER_CURVE (2 << 16) +-# define SSL_SECOP_OTHER_DH (3 << 16) +-# define SSL_SECOP_OTHER_PKEY (4 << 16) +-# define SSL_SECOP_OTHER_SIGALG (5 << 16) +-# define SSL_SECOP_OTHER_CERT (6 << 16) +- +-/* Indicated operation refers to peer key or certificate */ +-# define SSL_SECOP_PEER 0x1000 +- +-/* Values for "op" parameter in security callback */ +- +-/* Called to filter ciphers */ +-/* Ciphers client supports */ +-# define SSL_SECOP_CIPHER_SUPPORTED (1 | SSL_SECOP_OTHER_CIPHER) +-/* Cipher shared by client/server */ +-# define SSL_SECOP_CIPHER_SHARED (2 | SSL_SECOP_OTHER_CIPHER) +-/* Sanity check of cipher server selects */ +-# define SSL_SECOP_CIPHER_CHECK (3 | SSL_SECOP_OTHER_CIPHER) +-/* Curves supported by client */ +-# define SSL_SECOP_CURVE_SUPPORTED (4 | SSL_SECOP_OTHER_CURVE) +-/* Curves shared by client/server */ +-# define SSL_SECOP_CURVE_SHARED (5 | SSL_SECOP_OTHER_CURVE) +-/* Sanity check of curve server selects */ +-# define SSL_SECOP_CURVE_CHECK (6 | SSL_SECOP_OTHER_CURVE) +-/* Temporary DH key */ +-# define SSL_SECOP_TMP_DH (7 | SSL_SECOP_OTHER_PKEY) +-/* SSL/TLS version */ +-# define SSL_SECOP_VERSION (9 | SSL_SECOP_OTHER_NONE) +-/* Session tickets */ +-# define SSL_SECOP_TICKET (10 | SSL_SECOP_OTHER_NONE) +-/* Supported signature algorithms sent to peer */ +-# define SSL_SECOP_SIGALG_SUPPORTED (11 | SSL_SECOP_OTHER_SIGALG) +-/* Shared signature algorithm */ +-# define SSL_SECOP_SIGALG_SHARED (12 | SSL_SECOP_OTHER_SIGALG) +-/* Sanity check signature algorithm allowed */ +-# define SSL_SECOP_SIGALG_CHECK (13 | SSL_SECOP_OTHER_SIGALG) +-/* Used to get mask of supported public key signature algorithms */ +-# define SSL_SECOP_SIGALG_MASK (14 | SSL_SECOP_OTHER_SIGALG) +-/* Use to see if compression is allowed */ +-# define SSL_SECOP_COMPRESSION (15 | SSL_SECOP_OTHER_NONE) +-/* EE key in certificate */ +-# define SSL_SECOP_EE_KEY (16 | SSL_SECOP_OTHER_CERT) +-/* CA key in certificate */ +-# define SSL_SECOP_CA_KEY (17 | SSL_SECOP_OTHER_CERT) +-/* CA digest algorithm in certificate */ +-# define SSL_SECOP_CA_MD (18 | SSL_SECOP_OTHER_CERT) +-/* Peer EE key in certificate */ +-# define SSL_SECOP_PEER_EE_KEY (SSL_SECOP_EE_KEY | SSL_SECOP_PEER) +-/* Peer CA key in certificate */ +-# define SSL_SECOP_PEER_CA_KEY (SSL_SECOP_CA_KEY | SSL_SECOP_PEER) +-/* Peer CA digest algorithm in certificate */ +-# define SSL_SECOP_PEER_CA_MD (SSL_SECOP_CA_MD | SSL_SECOP_PEER) +- +-void SSL_set_security_level(SSL *s, int level); +-__owur int SSL_get_security_level(const SSL *s); +-void SSL_set_security_callback(SSL *s, +- int (*cb) (const SSL *s, const SSL_CTX *ctx, +- int op, int bits, int nid, +- void *other, void *ex)); +-int (*SSL_get_security_callback(const SSL *s)) (const SSL *s, +- const SSL_CTX *ctx, int op, +- int bits, int nid, void *other, +- void *ex); +-void SSL_set0_security_ex_data(SSL *s, void *ex); +-__owur void *SSL_get0_security_ex_data(const SSL *s); +- +-void SSL_CTX_set_security_level(SSL_CTX *ctx, int level); +-__owur int SSL_CTX_get_security_level(const SSL_CTX *ctx); +-void SSL_CTX_set_security_callback(SSL_CTX *ctx, +- int (*cb) (const SSL *s, const SSL_CTX *ctx, +- int op, int bits, int nid, +- void *other, void *ex)); +-int (*SSL_CTX_get_security_callback(const SSL_CTX *ctx)) (const SSL *s, +- const SSL_CTX *ctx, +- int op, int bits, +- int nid, +- void *other, +- void *ex); +-void SSL_CTX_set0_security_ex_data(SSL_CTX *ctx, void *ex); +-__owur void *SSL_CTX_get0_security_ex_data(const SSL_CTX *ctx); +- +-/* OPENSSL_INIT flag 0x010000 reserved for internal use */ +-# define OPENSSL_INIT_NO_LOAD_SSL_STRINGS 0x00100000L +-# define OPENSSL_INIT_LOAD_SSL_STRINGS 0x00200000L +- +-# define OPENSSL_INIT_SSL_DEFAULT \ +- (OPENSSL_INIT_LOAD_SSL_STRINGS | OPENSSL_INIT_LOAD_CRYPTO_STRINGS) +- +-int OPENSSL_init_ssl(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings); +- +-# ifndef OPENSSL_NO_UNIT_TEST +-__owur const struct openssl_ssl_test_functions *SSL_test_functions(void); +-# endif +- +-__owur int SSL_free_buffers(SSL *ssl); +-__owur int SSL_alloc_buffers(SSL *ssl); +- +-/* Status codes passed to the decrypt session ticket callback. Some of these +- * are for internal use only and are never passed to the callback. */ +-typedef int SSL_TICKET_STATUS; +- +-/* Support for ticket appdata */ +-/* fatal error, malloc failure */ +-# define SSL_TICKET_FATAL_ERR_MALLOC 0 +-/* fatal error, either from parsing or decrypting the ticket */ +-# define SSL_TICKET_FATAL_ERR_OTHER 1 +-/* No ticket present */ +-# define SSL_TICKET_NONE 2 +-/* Empty ticket present */ +-# define SSL_TICKET_EMPTY 3 +-/* the ticket couldn't be decrypted */ +-# define SSL_TICKET_NO_DECRYPT 4 +-/* a ticket was successfully decrypted */ +-# define SSL_TICKET_SUCCESS 5 +-/* same as above but the ticket needs to be renewed */ +-# define SSL_TICKET_SUCCESS_RENEW 6 +- +-/* Return codes for the decrypt session ticket callback */ +-typedef int SSL_TICKET_RETURN; +- +-/* An error occurred */ +-#define SSL_TICKET_RETURN_ABORT 0 +-/* Do not use the ticket, do not send a renewed ticket to the client */ +-#define SSL_TICKET_RETURN_IGNORE 1 +-/* Do not use the ticket, send a renewed ticket to the client */ +-#define SSL_TICKET_RETURN_IGNORE_RENEW 2 +-/* Use the ticket, do not send a renewed ticket to the client */ +-#define SSL_TICKET_RETURN_USE 3 +-/* Use the ticket, send a renewed ticket to the client */ +-#define SSL_TICKET_RETURN_USE_RENEW 4 +- +-typedef int (*SSL_CTX_generate_session_ticket_fn)(SSL *s, void *arg); +-typedef SSL_TICKET_RETURN (*SSL_CTX_decrypt_session_ticket_fn)(SSL *s, SSL_SESSION *ss, +- const unsigned char *keyname, +- size_t keyname_length, +- SSL_TICKET_STATUS status, +- void *arg); +-int SSL_CTX_set_session_ticket_cb(SSL_CTX *ctx, +- SSL_CTX_generate_session_ticket_fn gen_cb, +- SSL_CTX_decrypt_session_ticket_fn dec_cb, +- void *arg); +-int SSL_SESSION_set1_ticket_appdata(SSL_SESSION *ss, const void *data, size_t len); +-int SSL_SESSION_get0_ticket_appdata(SSL_SESSION *ss, void **data, size_t *len); +- +-extern const char SSL_version_str[]; +- +-typedef unsigned int (*DTLS_timer_cb)(SSL *s, unsigned int timer_us); +- +-void DTLS_set_timer_cb(SSL *s, DTLS_timer_cb cb); +- +- +-typedef int (*SSL_allow_early_data_cb_fn)(SSL *s, void *arg); +-void SSL_CTX_set_allow_early_data_cb(SSL_CTX *ctx, +- SSL_allow_early_data_cb_fn cb, +- void *arg); +-void SSL_set_allow_early_data_cb(SSL *s, +- SSL_allow_early_data_cb_fn cb, +- void *arg); +- +-# ifdef __cplusplus +-} +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/ssl2.h b/uadk_tool/include/openssl/ssl2.h +deleted file mode 100644 +index 5321bd2..0000000 +--- a/uadk_tool/include/openssl/ssl2.h ++++ /dev/null +@@ -1,24 +0,0 @@ +-/* +- * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_SSL2_H +-# define HEADER_SSL2_H +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-# define SSL2_VERSION 0x0002 +- +-# define SSL2_MT_CLIENT_HELLO 1 +- +-#ifdef __cplusplus +-} +-#endif +-#endif +diff --git a/uadk_tool/include/openssl/ssl3.h b/uadk_tool/include/openssl/ssl3.h +deleted file mode 100644 +index 07effba..0000000 +--- a/uadk_tool/include/openssl/ssl3.h ++++ /dev/null +@@ -1,342 +0,0 @@ +-/* +- * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. +- * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_SSL3_H +-# define HEADER_SSL3_H +- +-# include +-# include +-# include +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-/* +- * Signalling cipher suite value from RFC 5746 +- * (TLS_EMPTY_RENEGOTIATION_INFO_SCSV) +- */ +-# define SSL3_CK_SCSV 0x030000FF +- +-/* +- * Signalling cipher suite value from draft-ietf-tls-downgrade-scsv-00 +- * (TLS_FALLBACK_SCSV) +- */ +-# define SSL3_CK_FALLBACK_SCSV 0x03005600 +- +-# define SSL3_CK_RSA_NULL_MD5 0x03000001 +-# define SSL3_CK_RSA_NULL_SHA 0x03000002 +-# define SSL3_CK_RSA_RC4_40_MD5 0x03000003 +-# define SSL3_CK_RSA_RC4_128_MD5 0x03000004 +-# define SSL3_CK_RSA_RC4_128_SHA 0x03000005 +-# define SSL3_CK_RSA_RC2_40_MD5 0x03000006 +-# define SSL3_CK_RSA_IDEA_128_SHA 0x03000007 +-# define SSL3_CK_RSA_DES_40_CBC_SHA 0x03000008 +-# define SSL3_CK_RSA_DES_64_CBC_SHA 0x03000009 +-# define SSL3_CK_RSA_DES_192_CBC3_SHA 0x0300000A +- +-# define SSL3_CK_DH_DSS_DES_40_CBC_SHA 0x0300000B +-# define SSL3_CK_DH_DSS_DES_64_CBC_SHA 0x0300000C +-# define SSL3_CK_DH_DSS_DES_192_CBC3_SHA 0x0300000D +-# define SSL3_CK_DH_RSA_DES_40_CBC_SHA 0x0300000E +-# define SSL3_CK_DH_RSA_DES_64_CBC_SHA 0x0300000F +-# define SSL3_CK_DH_RSA_DES_192_CBC3_SHA 0x03000010 +- +-# define SSL3_CK_DHE_DSS_DES_40_CBC_SHA 0x03000011 +-# define SSL3_CK_EDH_DSS_DES_40_CBC_SHA SSL3_CK_DHE_DSS_DES_40_CBC_SHA +-# define SSL3_CK_DHE_DSS_DES_64_CBC_SHA 0x03000012 +-# define SSL3_CK_EDH_DSS_DES_64_CBC_SHA SSL3_CK_DHE_DSS_DES_64_CBC_SHA +-# define SSL3_CK_DHE_DSS_DES_192_CBC3_SHA 0x03000013 +-# define SSL3_CK_EDH_DSS_DES_192_CBC3_SHA SSL3_CK_DHE_DSS_DES_192_CBC3_SHA +-# define SSL3_CK_DHE_RSA_DES_40_CBC_SHA 0x03000014 +-# define SSL3_CK_EDH_RSA_DES_40_CBC_SHA SSL3_CK_DHE_RSA_DES_40_CBC_SHA +-# define SSL3_CK_DHE_RSA_DES_64_CBC_SHA 0x03000015 +-# define SSL3_CK_EDH_RSA_DES_64_CBC_SHA SSL3_CK_DHE_RSA_DES_64_CBC_SHA +-# define SSL3_CK_DHE_RSA_DES_192_CBC3_SHA 0x03000016 +-# define SSL3_CK_EDH_RSA_DES_192_CBC3_SHA SSL3_CK_DHE_RSA_DES_192_CBC3_SHA +- +-# define SSL3_CK_ADH_RC4_40_MD5 0x03000017 +-# define SSL3_CK_ADH_RC4_128_MD5 0x03000018 +-# define SSL3_CK_ADH_DES_40_CBC_SHA 0x03000019 +-# define SSL3_CK_ADH_DES_64_CBC_SHA 0x0300001A +-# define SSL3_CK_ADH_DES_192_CBC_SHA 0x0300001B +- +-/* a bundle of RFC standard cipher names, generated from ssl3_ciphers[] */ +-# define SSL3_RFC_RSA_NULL_MD5 "TLS_RSA_WITH_NULL_MD5" +-# define SSL3_RFC_RSA_NULL_SHA "TLS_RSA_WITH_NULL_SHA" +-# define SSL3_RFC_RSA_DES_192_CBC3_SHA "TLS_RSA_WITH_3DES_EDE_CBC_SHA" +-# define SSL3_RFC_DHE_DSS_DES_192_CBC3_SHA "TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA" +-# define SSL3_RFC_DHE_RSA_DES_192_CBC3_SHA "TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA" +-# define SSL3_RFC_ADH_DES_192_CBC_SHA "TLS_DH_anon_WITH_3DES_EDE_CBC_SHA" +-# define SSL3_RFC_RSA_IDEA_128_SHA "TLS_RSA_WITH_IDEA_CBC_SHA" +-# define SSL3_RFC_RSA_RC4_128_MD5 "TLS_RSA_WITH_RC4_128_MD5" +-# define SSL3_RFC_RSA_RC4_128_SHA "TLS_RSA_WITH_RC4_128_SHA" +-# define SSL3_RFC_ADH_RC4_128_MD5 "TLS_DH_anon_WITH_RC4_128_MD5" +- +-# define SSL3_TXT_RSA_NULL_MD5 "NULL-MD5" +-# define SSL3_TXT_RSA_NULL_SHA "NULL-SHA" +-# define SSL3_TXT_RSA_RC4_40_MD5 "EXP-RC4-MD5" +-# define SSL3_TXT_RSA_RC4_128_MD5 "RC4-MD5" +-# define SSL3_TXT_RSA_RC4_128_SHA "RC4-SHA" +-# define SSL3_TXT_RSA_RC2_40_MD5 "EXP-RC2-CBC-MD5" +-# define SSL3_TXT_RSA_IDEA_128_SHA "IDEA-CBC-SHA" +-# define SSL3_TXT_RSA_DES_40_CBC_SHA "EXP-DES-CBC-SHA" +-# define SSL3_TXT_RSA_DES_64_CBC_SHA "DES-CBC-SHA" +-# define SSL3_TXT_RSA_DES_192_CBC3_SHA "DES-CBC3-SHA" +- +-# define SSL3_TXT_DH_DSS_DES_40_CBC_SHA "EXP-DH-DSS-DES-CBC-SHA" +-# define SSL3_TXT_DH_DSS_DES_64_CBC_SHA "DH-DSS-DES-CBC-SHA" +-# define SSL3_TXT_DH_DSS_DES_192_CBC3_SHA "DH-DSS-DES-CBC3-SHA" +-# define SSL3_TXT_DH_RSA_DES_40_CBC_SHA "EXP-DH-RSA-DES-CBC-SHA" +-# define SSL3_TXT_DH_RSA_DES_64_CBC_SHA "DH-RSA-DES-CBC-SHA" +-# define SSL3_TXT_DH_RSA_DES_192_CBC3_SHA "DH-RSA-DES-CBC3-SHA" +- +-# define SSL3_TXT_DHE_DSS_DES_40_CBC_SHA "EXP-DHE-DSS-DES-CBC-SHA" +-# define SSL3_TXT_DHE_DSS_DES_64_CBC_SHA "DHE-DSS-DES-CBC-SHA" +-# define SSL3_TXT_DHE_DSS_DES_192_CBC3_SHA "DHE-DSS-DES-CBC3-SHA" +-# define SSL3_TXT_DHE_RSA_DES_40_CBC_SHA "EXP-DHE-RSA-DES-CBC-SHA" +-# define SSL3_TXT_DHE_RSA_DES_64_CBC_SHA "DHE-RSA-DES-CBC-SHA" +-# define SSL3_TXT_DHE_RSA_DES_192_CBC3_SHA "DHE-RSA-DES-CBC3-SHA" +- +-/* +- * This next block of six "EDH" labels is for backward compatibility with +- * older versions of OpenSSL. New code should use the six "DHE" labels above +- * instead: +- */ +-# define SSL3_TXT_EDH_DSS_DES_40_CBC_SHA "EXP-EDH-DSS-DES-CBC-SHA" +-# define SSL3_TXT_EDH_DSS_DES_64_CBC_SHA "EDH-DSS-DES-CBC-SHA" +-# define SSL3_TXT_EDH_DSS_DES_192_CBC3_SHA "EDH-DSS-DES-CBC3-SHA" +-# define SSL3_TXT_EDH_RSA_DES_40_CBC_SHA "EXP-EDH-RSA-DES-CBC-SHA" +-# define SSL3_TXT_EDH_RSA_DES_64_CBC_SHA "EDH-RSA-DES-CBC-SHA" +-# define SSL3_TXT_EDH_RSA_DES_192_CBC3_SHA "EDH-RSA-DES-CBC3-SHA" +- +-# define SSL3_TXT_ADH_RC4_40_MD5 "EXP-ADH-RC4-MD5" +-# define SSL3_TXT_ADH_RC4_128_MD5 "ADH-RC4-MD5" +-# define SSL3_TXT_ADH_DES_40_CBC_SHA "EXP-ADH-DES-CBC-SHA" +-# define SSL3_TXT_ADH_DES_64_CBC_SHA "ADH-DES-CBC-SHA" +-# define SSL3_TXT_ADH_DES_192_CBC_SHA "ADH-DES-CBC3-SHA" +- +-# define SSL3_SSL_SESSION_ID_LENGTH 32 +-# define SSL3_MAX_SSL_SESSION_ID_LENGTH 32 +- +-# define SSL3_MASTER_SECRET_SIZE 48 +-# define SSL3_RANDOM_SIZE 32 +-# define SSL3_SESSION_ID_SIZE 32 +-# define SSL3_RT_HEADER_LENGTH 5 +- +-# define SSL3_HM_HEADER_LENGTH 4 +- +-# ifndef SSL3_ALIGN_PAYLOAD +- /* +- * Some will argue that this increases memory footprint, but it's not +- * actually true. Point is that malloc has to return at least 64-bit aligned +- * pointers, meaning that allocating 5 bytes wastes 3 bytes in either case. +- * Suggested pre-gaping simply moves these wasted bytes from the end of +- * allocated region to its front, but makes data payload aligned, which +- * improves performance:-) +- */ +-# define SSL3_ALIGN_PAYLOAD 8 +-# else +-# if (SSL3_ALIGN_PAYLOAD&(SSL3_ALIGN_PAYLOAD-1))!=0 +-# error "insane SSL3_ALIGN_PAYLOAD" +-# undef SSL3_ALIGN_PAYLOAD +-# endif +-# endif +- +-/* +- * This is the maximum MAC (digest) size used by the SSL library. Currently +- * maximum of 20 is used by SHA1, but we reserve for future extension for +- * 512-bit hashes. +- */ +- +-# define SSL3_RT_MAX_MD_SIZE 64 +- +-/* +- * Maximum block size used in all ciphersuites. Currently 16 for AES. +- */ +- +-# define SSL_RT_MAX_CIPHER_BLOCK_SIZE 16 +- +-# define SSL3_RT_MAX_EXTRA (16384) +- +-/* Maximum plaintext length: defined by SSL/TLS standards */ +-# define SSL3_RT_MAX_PLAIN_LENGTH 16384 +-/* Maximum compression overhead: defined by SSL/TLS standards */ +-# define SSL3_RT_MAX_COMPRESSED_OVERHEAD 1024 +- +-/* +- * The standards give a maximum encryption overhead of 1024 bytes. In +- * practice the value is lower than this. The overhead is the maximum number +- * of padding bytes (256) plus the mac size. +- */ +-# define SSL3_RT_MAX_ENCRYPTED_OVERHEAD (256 + SSL3_RT_MAX_MD_SIZE) +-# define SSL3_RT_MAX_TLS13_ENCRYPTED_OVERHEAD 256 +- +-/* +- * OpenSSL currently only uses a padding length of at most one block so the +- * send overhead is smaller. +- */ +- +-# define SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD \ +- (SSL_RT_MAX_CIPHER_BLOCK_SIZE + SSL3_RT_MAX_MD_SIZE) +- +-/* If compression isn't used don't include the compression overhead */ +- +-# ifdef OPENSSL_NO_COMP +-# define SSL3_RT_MAX_COMPRESSED_LENGTH SSL3_RT_MAX_PLAIN_LENGTH +-# else +-# define SSL3_RT_MAX_COMPRESSED_LENGTH \ +- (SSL3_RT_MAX_PLAIN_LENGTH+SSL3_RT_MAX_COMPRESSED_OVERHEAD) +-# endif +-# define SSL3_RT_MAX_ENCRYPTED_LENGTH \ +- (SSL3_RT_MAX_ENCRYPTED_OVERHEAD+SSL3_RT_MAX_COMPRESSED_LENGTH) +-# define SSL3_RT_MAX_TLS13_ENCRYPTED_LENGTH \ +- (SSL3_RT_MAX_PLAIN_LENGTH + SSL3_RT_MAX_TLS13_ENCRYPTED_OVERHEAD) +-# define SSL3_RT_MAX_PACKET_SIZE \ +- (SSL3_RT_MAX_ENCRYPTED_LENGTH+SSL3_RT_HEADER_LENGTH) +- +-# define SSL3_MD_CLIENT_FINISHED_CONST "\x43\x4C\x4E\x54" +-# define SSL3_MD_SERVER_FINISHED_CONST "\x53\x52\x56\x52" +- +-# define SSL3_VERSION 0x0300 +-# define SSL3_VERSION_MAJOR 0x03 +-# define SSL3_VERSION_MINOR 0x00 +- +-# define SSL3_RT_CHANGE_CIPHER_SPEC 20 +-# define SSL3_RT_ALERT 21 +-# define SSL3_RT_HANDSHAKE 22 +-# define SSL3_RT_APPLICATION_DATA 23 +-# define DTLS1_RT_HEARTBEAT 24 +- +-/* Pseudo content types to indicate additional parameters */ +-# define TLS1_RT_CRYPTO 0x1000 +-# define TLS1_RT_CRYPTO_PREMASTER (TLS1_RT_CRYPTO | 0x1) +-# define TLS1_RT_CRYPTO_CLIENT_RANDOM (TLS1_RT_CRYPTO | 0x2) +-# define TLS1_RT_CRYPTO_SERVER_RANDOM (TLS1_RT_CRYPTO | 0x3) +-# define TLS1_RT_CRYPTO_MASTER (TLS1_RT_CRYPTO | 0x4) +- +-# define TLS1_RT_CRYPTO_READ 0x0000 +-# define TLS1_RT_CRYPTO_WRITE 0x0100 +-# define TLS1_RT_CRYPTO_MAC (TLS1_RT_CRYPTO | 0x5) +-# define TLS1_RT_CRYPTO_KEY (TLS1_RT_CRYPTO | 0x6) +-# define TLS1_RT_CRYPTO_IV (TLS1_RT_CRYPTO | 0x7) +-# define TLS1_RT_CRYPTO_FIXED_IV (TLS1_RT_CRYPTO | 0x8) +- +-/* Pseudo content types for SSL/TLS header info */ +-# define SSL3_RT_HEADER 0x100 +-# define SSL3_RT_INNER_CONTENT_TYPE 0x101 +- +-# define SSL3_AL_WARNING 1 +-# define SSL3_AL_FATAL 2 +- +-# define SSL3_AD_CLOSE_NOTIFY 0 +-# define SSL3_AD_UNEXPECTED_MESSAGE 10/* fatal */ +-# define SSL3_AD_BAD_RECORD_MAC 20/* fatal */ +-# define SSL3_AD_DECOMPRESSION_FAILURE 30/* fatal */ +-# define SSL3_AD_HANDSHAKE_FAILURE 40/* fatal */ +-# define SSL3_AD_NO_CERTIFICATE 41 +-# define SSL3_AD_BAD_CERTIFICATE 42 +-# define SSL3_AD_UNSUPPORTED_CERTIFICATE 43 +-# define SSL3_AD_CERTIFICATE_REVOKED 44 +-# define SSL3_AD_CERTIFICATE_EXPIRED 45 +-# define SSL3_AD_CERTIFICATE_UNKNOWN 46 +-# define SSL3_AD_ILLEGAL_PARAMETER 47/* fatal */ +- +-# define TLS1_HB_REQUEST 1 +-# define TLS1_HB_RESPONSE 2 +- +- +-# define SSL3_CT_RSA_SIGN 1 +-# define SSL3_CT_DSS_SIGN 2 +-# define SSL3_CT_RSA_FIXED_DH 3 +-# define SSL3_CT_DSS_FIXED_DH 4 +-# define SSL3_CT_RSA_EPHEMERAL_DH 5 +-# define SSL3_CT_DSS_EPHEMERAL_DH 6 +-# define SSL3_CT_FORTEZZA_DMS 20 +-/* +- * SSL3_CT_NUMBER is used to size arrays and it must be large enough to +- * contain all of the cert types defined for *either* SSLv3 and TLSv1. +- */ +-# define SSL3_CT_NUMBER 10 +- +-# if defined(TLS_CT_NUMBER) +-# if TLS_CT_NUMBER != SSL3_CT_NUMBER +-# error "SSL/TLS CT_NUMBER values do not match" +-# endif +-# endif +- +-/* No longer used as of OpenSSL 1.1.1 */ +-# define SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS 0x0001 +- +-/* Removed from OpenSSL 1.1.0 */ +-# define TLS1_FLAGS_TLS_PADDING_BUG 0x0 +- +-# define TLS1_FLAGS_SKIP_CERT_VERIFY 0x0010 +- +-/* Set if we encrypt then mac instead of usual mac then encrypt */ +-# define TLS1_FLAGS_ENCRYPT_THEN_MAC_READ 0x0100 +-# define TLS1_FLAGS_ENCRYPT_THEN_MAC TLS1_FLAGS_ENCRYPT_THEN_MAC_READ +- +-/* Set if extended master secret extension received from peer */ +-# define TLS1_FLAGS_RECEIVED_EXTMS 0x0200 +- +-# define TLS1_FLAGS_ENCRYPT_THEN_MAC_WRITE 0x0400 +- +-# define TLS1_FLAGS_STATELESS 0x0800 +- +-/* Set if extended master secret extension required on renegotiation */ +-# define TLS1_FLAGS_REQUIRED_EXTMS 0x1000 +- +-# define SSL3_MT_HELLO_REQUEST 0 +-# define SSL3_MT_CLIENT_HELLO 1 +-# define SSL3_MT_SERVER_HELLO 2 +-# define SSL3_MT_NEWSESSION_TICKET 4 +-# define SSL3_MT_END_OF_EARLY_DATA 5 +-# define SSL3_MT_ENCRYPTED_EXTENSIONS 8 +-# define SSL3_MT_CERTIFICATE 11 +-# define SSL3_MT_SERVER_KEY_EXCHANGE 12 +-# define SSL3_MT_CERTIFICATE_REQUEST 13 +-# define SSL3_MT_SERVER_DONE 14 +-# define SSL3_MT_CERTIFICATE_VERIFY 15 +-# define SSL3_MT_CLIENT_KEY_EXCHANGE 16 +-# define SSL3_MT_FINISHED 20 +-# define SSL3_MT_CERTIFICATE_URL 21 +-# define SSL3_MT_CERTIFICATE_STATUS 22 +-# define SSL3_MT_SUPPLEMENTAL_DATA 23 +-# define SSL3_MT_KEY_UPDATE 24 +-# ifndef OPENSSL_NO_NEXTPROTONEG +-# define SSL3_MT_NEXT_PROTO 67 +-# endif +-# define SSL3_MT_MESSAGE_HASH 254 +-# define DTLS1_MT_HELLO_VERIFY_REQUEST 3 +- +-/* Dummy message type for handling CCS like a normal handshake message */ +-# define SSL3_MT_CHANGE_CIPHER_SPEC 0x0101 +- +-# define SSL3_MT_CCS 1 +- +-/* These are used when changing over to a new cipher */ +-# define SSL3_CC_READ 0x001 +-# define SSL3_CC_WRITE 0x002 +-# define SSL3_CC_CLIENT 0x010 +-# define SSL3_CC_SERVER 0x020 +-# define SSL3_CC_EARLY 0x040 +-# define SSL3_CC_HANDSHAKE 0x080 +-# define SSL3_CC_APPLICATION 0x100 +-# define SSL3_CHANGE_CIPHER_CLIENT_WRITE (SSL3_CC_CLIENT|SSL3_CC_WRITE) +-# define SSL3_CHANGE_CIPHER_SERVER_READ (SSL3_CC_SERVER|SSL3_CC_READ) +-# define SSL3_CHANGE_CIPHER_CLIENT_READ (SSL3_CC_CLIENT|SSL3_CC_READ) +-# define SSL3_CHANGE_CIPHER_SERVER_WRITE (SSL3_CC_SERVER|SSL3_CC_WRITE) +- +-#ifdef __cplusplus +-} +-#endif +-#endif +diff --git a/uadk_tool/include/openssl/sslerr.h b/uadk_tool/include/openssl/sslerr.h +deleted file mode 100644 +index 701d61c..0000000 +--- a/uadk_tool/include/openssl/sslerr.h ++++ /dev/null +@@ -1,776 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_SSLERR_H +-# define HEADER_SSLERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_SSL_strings(void); +- +-/* +- * SSL function codes. +- */ +-# define SSL_F_ADD_CLIENT_KEY_SHARE_EXT 438 +-# define SSL_F_ADD_KEY_SHARE 512 +-# define SSL_F_BYTES_TO_CIPHER_LIST 519 +-# define SSL_F_CHECK_SUITEB_CIPHER_LIST 331 +-# define SSL_F_CIPHERSUITE_CB 622 +-# define SSL_F_CONSTRUCT_CA_NAMES 552 +-# define SSL_F_CONSTRUCT_KEY_EXCHANGE_TBS 553 +-# define SSL_F_CONSTRUCT_STATEFUL_TICKET 636 +-# define SSL_F_CONSTRUCT_STATELESS_TICKET 637 +-# define SSL_F_CREATE_SYNTHETIC_MESSAGE_HASH 539 +-# define SSL_F_CREATE_TICKET_PREQUEL 638 +-# define SSL_F_CT_MOVE_SCTS 345 +-# define SSL_F_CT_STRICT 349 +-# define SSL_F_CUSTOM_EXT_ADD 554 +-# define SSL_F_CUSTOM_EXT_PARSE 555 +-# define SSL_F_D2I_SSL_SESSION 103 +-# define SSL_F_DANE_CTX_ENABLE 347 +-# define SSL_F_DANE_MTYPE_SET 393 +-# define SSL_F_DANE_TLSA_ADD 394 +-# define SSL_F_DERIVE_SECRET_KEY_AND_IV 514 +-# define SSL_F_DO_DTLS1_WRITE 245 +-# define SSL_F_DO_SSL3_WRITE 104 +-# define SSL_F_DTLS1_BUFFER_RECORD 247 +-# define SSL_F_DTLS1_CHECK_TIMEOUT_NUM 318 +-# define SSL_F_DTLS1_HEARTBEAT 305 +-# define SSL_F_DTLS1_HM_FRAGMENT_NEW 623 +-# define SSL_F_DTLS1_PREPROCESS_FRAGMENT 288 +-# define SSL_F_DTLS1_PROCESS_BUFFERED_RECORDS 424 +-# define SSL_F_DTLS1_PROCESS_RECORD 257 +-# define SSL_F_DTLS1_READ_BYTES 258 +-# define SSL_F_DTLS1_READ_FAILED 339 +-# define SSL_F_DTLS1_RETRANSMIT_MESSAGE 390 +-# define SSL_F_DTLS1_WRITE_APP_DATA_BYTES 268 +-# define SSL_F_DTLS1_WRITE_BYTES 545 +-# define SSL_F_DTLSV1_LISTEN 350 +-# define SSL_F_DTLS_CONSTRUCT_CHANGE_CIPHER_SPEC 371 +-# define SSL_F_DTLS_CONSTRUCT_HELLO_VERIFY_REQUEST 385 +-# define SSL_F_DTLS_GET_REASSEMBLED_MESSAGE 370 +-# define SSL_F_DTLS_PROCESS_HELLO_VERIFY 386 +-# define SSL_F_DTLS_RECORD_LAYER_NEW 635 +-# define SSL_F_DTLS_WAIT_FOR_DRY 592 +-# define SSL_F_EARLY_DATA_COUNT_OK 532 +-# define SSL_F_FINAL_EARLY_DATA 556 +-# define SSL_F_FINAL_EC_PT_FORMATS 485 +-# define SSL_F_FINAL_EMS 486 +-# define SSL_F_FINAL_KEY_SHARE 503 +-# define SSL_F_FINAL_MAXFRAGMENTLEN 557 +-# define SSL_F_FINAL_PSK 639 +-# define SSL_F_FINAL_RENEGOTIATE 483 +-# define SSL_F_FINAL_SERVER_NAME 558 +-# define SSL_F_FINAL_SIG_ALGS 497 +-# define SSL_F_GET_CERT_VERIFY_TBS_DATA 588 +-# define SSL_F_NSS_KEYLOG_INT 500 +-# define SSL_F_OPENSSL_INIT_SSL 342 +-# define SSL_F_OSSL_STATEM_CLIENT13_READ_TRANSITION 436 +-# define SSL_F_OSSL_STATEM_CLIENT13_WRITE_TRANSITION 598 +-# define SSL_F_OSSL_STATEM_CLIENT_CONSTRUCT_MESSAGE 430 +-# define SSL_F_OSSL_STATEM_CLIENT_POST_PROCESS_MESSAGE 593 +-# define SSL_F_OSSL_STATEM_CLIENT_PROCESS_MESSAGE 594 +-# define SSL_F_OSSL_STATEM_CLIENT_READ_TRANSITION 417 +-# define SSL_F_OSSL_STATEM_CLIENT_WRITE_TRANSITION 599 +-# define SSL_F_OSSL_STATEM_SERVER13_READ_TRANSITION 437 +-# define SSL_F_OSSL_STATEM_SERVER13_WRITE_TRANSITION 600 +-# define SSL_F_OSSL_STATEM_SERVER_CONSTRUCT_MESSAGE 431 +-# define SSL_F_OSSL_STATEM_SERVER_POST_PROCESS_MESSAGE 601 +-# define SSL_F_OSSL_STATEM_SERVER_POST_WORK 602 +-# define SSL_F_OSSL_STATEM_SERVER_PRE_WORK 640 +-# define SSL_F_OSSL_STATEM_SERVER_PROCESS_MESSAGE 603 +-# define SSL_F_OSSL_STATEM_SERVER_READ_TRANSITION 418 +-# define SSL_F_OSSL_STATEM_SERVER_WRITE_TRANSITION 604 +-# define SSL_F_PARSE_CA_NAMES 541 +-# define SSL_F_PITEM_NEW 624 +-# define SSL_F_PQUEUE_NEW 625 +-# define SSL_F_PROCESS_KEY_SHARE_EXT 439 +-# define SSL_F_READ_STATE_MACHINE 352 +-# define SSL_F_SET_CLIENT_CIPHERSUITE 540 +-# define SSL_F_SRP_GENERATE_CLIENT_MASTER_SECRET 595 +-# define SSL_F_SRP_GENERATE_SERVER_MASTER_SECRET 589 +-# define SSL_F_SRP_VERIFY_SERVER_PARAM 596 +-# define SSL_F_SSL3_CHANGE_CIPHER_STATE 129 +-# define SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM 130 +-# define SSL_F_SSL3_CTRL 213 +-# define SSL_F_SSL3_CTX_CTRL 133 +-# define SSL_F_SSL3_DIGEST_CACHED_RECORDS 293 +-# define SSL_F_SSL3_DO_CHANGE_CIPHER_SPEC 292 +-# define SSL_F_SSL3_ENC 608 +-# define SSL_F_SSL3_FINAL_FINISH_MAC 285 +-# define SSL_F_SSL3_FINISH_MAC 587 +-# define SSL_F_SSL3_GENERATE_KEY_BLOCK 238 +-# define SSL_F_SSL3_GENERATE_MASTER_SECRET 388 +-# define SSL_F_SSL3_GET_RECORD 143 +-# define SSL_F_SSL3_INIT_FINISHED_MAC 397 +-# define SSL_F_SSL3_OUTPUT_CERT_CHAIN 147 +-# define SSL_F_SSL3_READ_BYTES 148 +-# define SSL_F_SSL3_READ_N 149 +-# define SSL_F_SSL3_SETUP_KEY_BLOCK 157 +-# define SSL_F_SSL3_SETUP_READ_BUFFER 156 +-# define SSL_F_SSL3_SETUP_WRITE_BUFFER 291 +-# define SSL_F_SSL3_WRITE_BYTES 158 +-# define SSL_F_SSL3_WRITE_PENDING 159 +-# define SSL_F_SSL_ADD_CERT_CHAIN 316 +-# define SSL_F_SSL_ADD_CERT_TO_BUF 319 +-# define SSL_F_SSL_ADD_CERT_TO_WPACKET 493 +-# define SSL_F_SSL_ADD_CLIENTHELLO_RENEGOTIATE_EXT 298 +-# define SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT 277 +-# define SSL_F_SSL_ADD_CLIENTHELLO_USE_SRTP_EXT 307 +-# define SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK 215 +-# define SSL_F_SSL_ADD_FILE_CERT_SUBJECTS_TO_STACK 216 +-# define SSL_F_SSL_ADD_SERVERHELLO_RENEGOTIATE_EXT 299 +-# define SSL_F_SSL_ADD_SERVERHELLO_TLSEXT 278 +-# define SSL_F_SSL_ADD_SERVERHELLO_USE_SRTP_EXT 308 +-# define SSL_F_SSL_BAD_METHOD 160 +-# define SSL_F_SSL_BUILD_CERT_CHAIN 332 +-# define SSL_F_SSL_BYTES_TO_CIPHER_LIST 161 +-# define SSL_F_SSL_CACHE_CIPHERLIST 520 +-# define SSL_F_SSL_CERT_ADD0_CHAIN_CERT 346 +-# define SSL_F_SSL_CERT_DUP 221 +-# define SSL_F_SSL_CERT_NEW 162 +-# define SSL_F_SSL_CERT_SET0_CHAIN 340 +-# define SSL_F_SSL_CHECK_PRIVATE_KEY 163 +-# define SSL_F_SSL_CHECK_SERVERHELLO_TLSEXT 280 +-# define SSL_F_SSL_CHECK_SRP_EXT_CLIENTHELLO 606 +-# define SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG 279 +-# define SSL_F_SSL_CHOOSE_CLIENT_VERSION 607 +-# define SSL_F_SSL_CIPHER_DESCRIPTION 626 +-# define SSL_F_SSL_CIPHER_LIST_TO_BYTES 425 +-# define SSL_F_SSL_CIPHER_PROCESS_RULESTR 230 +-# define SSL_F_SSL_CIPHER_STRENGTH_SORT 231 +-# define SSL_F_SSL_CLEAR 164 +-# define SSL_F_SSL_CLIENT_HELLO_GET1_EXTENSIONS_PRESENT 627 +-# define SSL_F_SSL_COMP_ADD_COMPRESSION_METHOD 165 +-# define SSL_F_SSL_CONF_CMD 334 +-# define SSL_F_SSL_CREATE_CIPHER_LIST 166 +-# define SSL_F_SSL_CTRL 232 +-# define SSL_F_SSL_CTX_CHECK_PRIVATE_KEY 168 +-# define SSL_F_SSL_CTX_ENABLE_CT 398 +-# define SSL_F_SSL_CTX_MAKE_PROFILES 309 +-# define SSL_F_SSL_CTX_NEW 169 +-# define SSL_F_SSL_CTX_SET_ALPN_PROTOS 343 +-# define SSL_F_SSL_CTX_SET_CIPHER_LIST 269 +-# define SSL_F_SSL_CTX_SET_CLIENT_CERT_ENGINE 290 +-# define SSL_F_SSL_CTX_SET_CT_VALIDATION_CALLBACK 396 +-# define SSL_F_SSL_CTX_SET_SESSION_ID_CONTEXT 219 +-# define SSL_F_SSL_CTX_SET_SSL_VERSION 170 +-# define SSL_F_SSL_CTX_SET_TLSEXT_MAX_FRAGMENT_LENGTH 551 +-# define SSL_F_SSL_CTX_USE_CERTIFICATE 171 +-# define SSL_F_SSL_CTX_USE_CERTIFICATE_ASN1 172 +-# define SSL_F_SSL_CTX_USE_CERTIFICATE_FILE 173 +-# define SSL_F_SSL_CTX_USE_PRIVATEKEY 174 +-# define SSL_F_SSL_CTX_USE_PRIVATEKEY_ASN1 175 +-# define SSL_F_SSL_CTX_USE_PRIVATEKEY_FILE 176 +-# define SSL_F_SSL_CTX_USE_PSK_IDENTITY_HINT 272 +-# define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY 177 +-# define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_ASN1 178 +-# define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_FILE 179 +-# define SSL_F_SSL_CTX_USE_SERVERINFO 336 +-# define SSL_F_SSL_CTX_USE_SERVERINFO_EX 543 +-# define SSL_F_SSL_CTX_USE_SERVERINFO_FILE 337 +-# define SSL_F_SSL_DANE_DUP 403 +-# define SSL_F_SSL_DANE_ENABLE 395 +-# define SSL_F_SSL_DERIVE 590 +-# define SSL_F_SSL_DO_CONFIG 391 +-# define SSL_F_SSL_DO_HANDSHAKE 180 +-# define SSL_F_SSL_DUP_CA_LIST 408 +-# define SSL_F_SSL_ENABLE_CT 402 +-# define SSL_F_SSL_GENERATE_PKEY_GROUP 559 +-# define SSL_F_SSL_GENERATE_SESSION_ID 547 +-# define SSL_F_SSL_GET_NEW_SESSION 181 +-# define SSL_F_SSL_GET_PREV_SESSION 217 +-# define SSL_F_SSL_GET_SERVER_CERT_INDEX 322 +-# define SSL_F_SSL_GET_SIGN_PKEY 183 +-# define SSL_F_SSL_HANDSHAKE_HASH 560 +-# define SSL_F_SSL_INIT_WBIO_BUFFER 184 +-# define SSL_F_SSL_KEY_UPDATE 515 +-# define SSL_F_SSL_LOAD_CLIENT_CA_FILE 185 +-# define SSL_F_SSL_LOG_MASTER_SECRET 498 +-# define SSL_F_SSL_LOG_RSA_CLIENT_KEY_EXCHANGE 499 +-# define SSL_F_SSL_MODULE_INIT 392 +-# define SSL_F_SSL_NEW 186 +-# define SSL_F_SSL_NEXT_PROTO_VALIDATE 565 +-# define SSL_F_SSL_PARSE_CLIENTHELLO_RENEGOTIATE_EXT 300 +-# define SSL_F_SSL_PARSE_CLIENTHELLO_TLSEXT 302 +-# define SSL_F_SSL_PARSE_CLIENTHELLO_USE_SRTP_EXT 310 +-# define SSL_F_SSL_PARSE_SERVERHELLO_RENEGOTIATE_EXT 301 +-# define SSL_F_SSL_PARSE_SERVERHELLO_TLSEXT 303 +-# define SSL_F_SSL_PARSE_SERVERHELLO_USE_SRTP_EXT 311 +-# define SSL_F_SSL_PEEK 270 +-# define SSL_F_SSL_PEEK_EX 432 +-# define SSL_F_SSL_PEEK_INTERNAL 522 +-# define SSL_F_SSL_READ 223 +-# define SSL_F_SSL_READ_EARLY_DATA 529 +-# define SSL_F_SSL_READ_EX 434 +-# define SSL_F_SSL_READ_INTERNAL 523 +-# define SSL_F_SSL_RENEGOTIATE 516 +-# define SSL_F_SSL_RENEGOTIATE_ABBREVIATED 546 +-# define SSL_F_SSL_SCAN_CLIENTHELLO_TLSEXT 320 +-# define SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT 321 +-# define SSL_F_SSL_SESSION_DUP 348 +-# define SSL_F_SSL_SESSION_NEW 189 +-# define SSL_F_SSL_SESSION_PRINT_FP 190 +-# define SSL_F_SSL_SESSION_SET1_ID 423 +-# define SSL_F_SSL_SESSION_SET1_ID_CONTEXT 312 +-# define SSL_F_SSL_SET_ALPN_PROTOS 344 +-# define SSL_F_SSL_SET_CERT 191 +-# define SSL_F_SSL_SET_CERT_AND_KEY 621 +-# define SSL_F_SSL_SET_CIPHER_LIST 271 +-# define SSL_F_SSL_SET_CT_VALIDATION_CALLBACK 399 +-# define SSL_F_SSL_SET_FD 192 +-# define SSL_F_SSL_SET_PKEY 193 +-# define SSL_F_SSL_SET_RFD 194 +-# define SSL_F_SSL_SET_SESSION 195 +-# define SSL_F_SSL_SET_SESSION_ID_CONTEXT 218 +-# define SSL_F_SSL_SET_SESSION_TICKET_EXT 294 +-# define SSL_F_SSL_SET_TLSEXT_MAX_FRAGMENT_LENGTH 550 +-# define SSL_F_SSL_SET_WFD 196 +-# define SSL_F_SSL_SHUTDOWN 224 +-# define SSL_F_SSL_SRP_CTX_INIT 313 +-# define SSL_F_SSL_START_ASYNC_JOB 389 +-# define SSL_F_SSL_UNDEFINED_FUNCTION 197 +-# define SSL_F_SSL_UNDEFINED_VOID_FUNCTION 244 +-# define SSL_F_SSL_USE_CERTIFICATE 198 +-# define SSL_F_SSL_USE_CERTIFICATE_ASN1 199 +-# define SSL_F_SSL_USE_CERTIFICATE_FILE 200 +-# define SSL_F_SSL_USE_PRIVATEKEY 201 +-# define SSL_F_SSL_USE_PRIVATEKEY_ASN1 202 +-# define SSL_F_SSL_USE_PRIVATEKEY_FILE 203 +-# define SSL_F_SSL_USE_PSK_IDENTITY_HINT 273 +-# define SSL_F_SSL_USE_RSAPRIVATEKEY 204 +-# define SSL_F_SSL_USE_RSAPRIVATEKEY_ASN1 205 +-# define SSL_F_SSL_USE_RSAPRIVATEKEY_FILE 206 +-# define SSL_F_SSL_VALIDATE_CT 400 +-# define SSL_F_SSL_VERIFY_CERT_CHAIN 207 +-# define SSL_F_SSL_VERIFY_CLIENT_POST_HANDSHAKE 616 +-# define SSL_F_SSL_WRITE 208 +-# define SSL_F_SSL_WRITE_EARLY_DATA 526 +-# define SSL_F_SSL_WRITE_EARLY_FINISH 527 +-# define SSL_F_SSL_WRITE_EX 433 +-# define SSL_F_SSL_WRITE_INTERNAL 524 +-# define SSL_F_STATE_MACHINE 353 +-# define SSL_F_TLS12_CHECK_PEER_SIGALG 333 +-# define SSL_F_TLS12_COPY_SIGALGS 533 +-# define SSL_F_TLS13_CHANGE_CIPHER_STATE 440 +-# define SSL_F_TLS13_ENC 609 +-# define SSL_F_TLS13_FINAL_FINISH_MAC 605 +-# define SSL_F_TLS13_GENERATE_SECRET 591 +-# define SSL_F_TLS13_HKDF_EXPAND 561 +-# define SSL_F_TLS13_RESTORE_HANDSHAKE_DIGEST_FOR_PHA 617 +-# define SSL_F_TLS13_SAVE_HANDSHAKE_DIGEST_FOR_PHA 618 +-# define SSL_F_TLS13_SETUP_KEY_BLOCK 441 +-# define SSL_F_TLS1_CHANGE_CIPHER_STATE 209 +-# define SSL_F_TLS1_CHECK_DUPLICATE_EXTENSIONS 341 +-# define SSL_F_TLS1_ENC 401 +-# define SSL_F_TLS1_EXPORT_KEYING_MATERIAL 314 +-# define SSL_F_TLS1_GET_CURVELIST 338 +-# define SSL_F_TLS1_PRF 284 +-# define SSL_F_TLS1_SAVE_U16 628 +-# define SSL_F_TLS1_SETUP_KEY_BLOCK 211 +-# define SSL_F_TLS1_SET_GROUPS 629 +-# define SSL_F_TLS1_SET_RAW_SIGALGS 630 +-# define SSL_F_TLS1_SET_SERVER_SIGALGS 335 +-# define SSL_F_TLS1_SET_SHARED_SIGALGS 631 +-# define SSL_F_TLS1_SET_SIGALGS 632 +-# define SSL_F_TLS_CHOOSE_SIGALG 513 +-# define SSL_F_TLS_CLIENT_KEY_EXCHANGE_POST_WORK 354 +-# define SSL_F_TLS_COLLECT_EXTENSIONS 435 +-# define SSL_F_TLS_CONSTRUCT_CERTIFICATE_AUTHORITIES 542 +-# define SSL_F_TLS_CONSTRUCT_CERTIFICATE_REQUEST 372 +-# define SSL_F_TLS_CONSTRUCT_CERT_STATUS 429 +-# define SSL_F_TLS_CONSTRUCT_CERT_STATUS_BODY 494 +-# define SSL_F_TLS_CONSTRUCT_CERT_VERIFY 496 +-# define SSL_F_TLS_CONSTRUCT_CHANGE_CIPHER_SPEC 427 +-# define SSL_F_TLS_CONSTRUCT_CKE_DHE 404 +-# define SSL_F_TLS_CONSTRUCT_CKE_ECDHE 405 +-# define SSL_F_TLS_CONSTRUCT_CKE_GOST 406 +-# define SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE 407 +-# define SSL_F_TLS_CONSTRUCT_CKE_RSA 409 +-# define SSL_F_TLS_CONSTRUCT_CKE_SRP 410 +-# define SSL_F_TLS_CONSTRUCT_CLIENT_CERTIFICATE 484 +-# define SSL_F_TLS_CONSTRUCT_CLIENT_HELLO 487 +-# define SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE 488 +-# define SSL_F_TLS_CONSTRUCT_CLIENT_VERIFY 489 +-# define SSL_F_TLS_CONSTRUCT_CTOS_ALPN 466 +-# define SSL_F_TLS_CONSTRUCT_CTOS_CERTIFICATE 355 +-# define SSL_F_TLS_CONSTRUCT_CTOS_COOKIE 535 +-# define SSL_F_TLS_CONSTRUCT_CTOS_EARLY_DATA 530 +-# define SSL_F_TLS_CONSTRUCT_CTOS_EC_PT_FORMATS 467 +-# define SSL_F_TLS_CONSTRUCT_CTOS_EMS 468 +-# define SSL_F_TLS_CONSTRUCT_CTOS_ETM 469 +-# define SSL_F_TLS_CONSTRUCT_CTOS_HELLO 356 +-# define SSL_F_TLS_CONSTRUCT_CTOS_KEY_EXCHANGE 357 +-# define SSL_F_TLS_CONSTRUCT_CTOS_KEY_SHARE 470 +-# define SSL_F_TLS_CONSTRUCT_CTOS_MAXFRAGMENTLEN 549 +-# define SSL_F_TLS_CONSTRUCT_CTOS_NPN 471 +-# define SSL_F_TLS_CONSTRUCT_CTOS_PADDING 472 +-# define SSL_F_TLS_CONSTRUCT_CTOS_POST_HANDSHAKE_AUTH 619 +-# define SSL_F_TLS_CONSTRUCT_CTOS_PSK 501 +-# define SSL_F_TLS_CONSTRUCT_CTOS_PSK_KEX_MODES 509 +-# define SSL_F_TLS_CONSTRUCT_CTOS_RENEGOTIATE 473 +-# define SSL_F_TLS_CONSTRUCT_CTOS_SCT 474 +-# define SSL_F_TLS_CONSTRUCT_CTOS_SERVER_NAME 475 +-# define SSL_F_TLS_CONSTRUCT_CTOS_SESSION_TICKET 476 +-# define SSL_F_TLS_CONSTRUCT_CTOS_SIG_ALGS 477 +-# define SSL_F_TLS_CONSTRUCT_CTOS_SRP 478 +-# define SSL_F_TLS_CONSTRUCT_CTOS_STATUS_REQUEST 479 +-# define SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_GROUPS 480 +-# define SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_VERSIONS 481 +-# define SSL_F_TLS_CONSTRUCT_CTOS_USE_SRTP 482 +-# define SSL_F_TLS_CONSTRUCT_CTOS_VERIFY 358 +-# define SSL_F_TLS_CONSTRUCT_ENCRYPTED_EXTENSIONS 443 +-# define SSL_F_TLS_CONSTRUCT_END_OF_EARLY_DATA 536 +-# define SSL_F_TLS_CONSTRUCT_EXTENSIONS 447 +-# define SSL_F_TLS_CONSTRUCT_FINISHED 359 +-# define SSL_F_TLS_CONSTRUCT_HELLO_REQUEST 373 +-# define SSL_F_TLS_CONSTRUCT_HELLO_RETRY_REQUEST 510 +-# define SSL_F_TLS_CONSTRUCT_KEY_UPDATE 517 +-# define SSL_F_TLS_CONSTRUCT_NEW_SESSION_TICKET 428 +-# define SSL_F_TLS_CONSTRUCT_NEXT_PROTO 426 +-# define SSL_F_TLS_CONSTRUCT_SERVER_CERTIFICATE 490 +-# define SSL_F_TLS_CONSTRUCT_SERVER_HELLO 491 +-# define SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE 492 +-# define SSL_F_TLS_CONSTRUCT_STOC_ALPN 451 +-# define SSL_F_TLS_CONSTRUCT_STOC_CERTIFICATE 374 +-# define SSL_F_TLS_CONSTRUCT_STOC_COOKIE 613 +-# define SSL_F_TLS_CONSTRUCT_STOC_CRYPTOPRO_BUG 452 +-# define SSL_F_TLS_CONSTRUCT_STOC_DONE 375 +-# define SSL_F_TLS_CONSTRUCT_STOC_EARLY_DATA 531 +-# define SSL_F_TLS_CONSTRUCT_STOC_EARLY_DATA_INFO 525 +-# define SSL_F_TLS_CONSTRUCT_STOC_EC_PT_FORMATS 453 +-# define SSL_F_TLS_CONSTRUCT_STOC_EMS 454 +-# define SSL_F_TLS_CONSTRUCT_STOC_ETM 455 +-# define SSL_F_TLS_CONSTRUCT_STOC_HELLO 376 +-# define SSL_F_TLS_CONSTRUCT_STOC_KEY_EXCHANGE 377 +-# define SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE 456 +-# define SSL_F_TLS_CONSTRUCT_STOC_MAXFRAGMENTLEN 548 +-# define SSL_F_TLS_CONSTRUCT_STOC_NEXT_PROTO_NEG 457 +-# define SSL_F_TLS_CONSTRUCT_STOC_PSK 504 +-# define SSL_F_TLS_CONSTRUCT_STOC_RENEGOTIATE 458 +-# define SSL_F_TLS_CONSTRUCT_STOC_SERVER_NAME 459 +-# define SSL_F_TLS_CONSTRUCT_STOC_SESSION_TICKET 460 +-# define SSL_F_TLS_CONSTRUCT_STOC_STATUS_REQUEST 461 +-# define SSL_F_TLS_CONSTRUCT_STOC_SUPPORTED_GROUPS 544 +-# define SSL_F_TLS_CONSTRUCT_STOC_SUPPORTED_VERSIONS 611 +-# define SSL_F_TLS_CONSTRUCT_STOC_USE_SRTP 462 +-# define SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO 521 +-# define SSL_F_TLS_FINISH_HANDSHAKE 597 +-# define SSL_F_TLS_GET_MESSAGE_BODY 351 +-# define SSL_F_TLS_GET_MESSAGE_HEADER 387 +-# define SSL_F_TLS_HANDLE_ALPN 562 +-# define SSL_F_TLS_HANDLE_STATUS_REQUEST 563 +-# define SSL_F_TLS_PARSE_CERTIFICATE_AUTHORITIES 566 +-# define SSL_F_TLS_PARSE_CLIENTHELLO_TLSEXT 449 +-# define SSL_F_TLS_PARSE_CTOS_ALPN 567 +-# define SSL_F_TLS_PARSE_CTOS_COOKIE 614 +-# define SSL_F_TLS_PARSE_CTOS_EARLY_DATA 568 +-# define SSL_F_TLS_PARSE_CTOS_EC_PT_FORMATS 569 +-# define SSL_F_TLS_PARSE_CTOS_EMS 570 +-# define SSL_F_TLS_PARSE_CTOS_KEY_SHARE 463 +-# define SSL_F_TLS_PARSE_CTOS_MAXFRAGMENTLEN 571 +-# define SSL_F_TLS_PARSE_CTOS_POST_HANDSHAKE_AUTH 620 +-# define SSL_F_TLS_PARSE_CTOS_PSK 505 +-# define SSL_F_TLS_PARSE_CTOS_PSK_KEX_MODES 572 +-# define SSL_F_TLS_PARSE_CTOS_RENEGOTIATE 464 +-# define SSL_F_TLS_PARSE_CTOS_SERVER_NAME 573 +-# define SSL_F_TLS_PARSE_CTOS_SESSION_TICKET 574 +-# define SSL_F_TLS_PARSE_CTOS_SIG_ALGS 575 +-# define SSL_F_TLS_PARSE_CTOS_SIG_ALGS_CERT 615 +-# define SSL_F_TLS_PARSE_CTOS_SRP 576 +-# define SSL_F_TLS_PARSE_CTOS_STATUS_REQUEST 577 +-# define SSL_F_TLS_PARSE_CTOS_SUPPORTED_GROUPS 578 +-# define SSL_F_TLS_PARSE_CTOS_USE_SRTP 465 +-# define SSL_F_TLS_PARSE_STOC_ALPN 579 +-# define SSL_F_TLS_PARSE_STOC_COOKIE 534 +-# define SSL_F_TLS_PARSE_STOC_EARLY_DATA 538 +-# define SSL_F_TLS_PARSE_STOC_EARLY_DATA_INFO 528 +-# define SSL_F_TLS_PARSE_STOC_EC_PT_FORMATS 580 +-# define SSL_F_TLS_PARSE_STOC_KEY_SHARE 445 +-# define SSL_F_TLS_PARSE_STOC_MAXFRAGMENTLEN 581 +-# define SSL_F_TLS_PARSE_STOC_NPN 582 +-# define SSL_F_TLS_PARSE_STOC_PSK 502 +-# define SSL_F_TLS_PARSE_STOC_RENEGOTIATE 448 +-# define SSL_F_TLS_PARSE_STOC_SCT 564 +-# define SSL_F_TLS_PARSE_STOC_SERVER_NAME 583 +-# define SSL_F_TLS_PARSE_STOC_SESSION_TICKET 584 +-# define SSL_F_TLS_PARSE_STOC_STATUS_REQUEST 585 +-# define SSL_F_TLS_PARSE_STOC_SUPPORTED_VERSIONS 612 +-# define SSL_F_TLS_PARSE_STOC_USE_SRTP 446 +-# define SSL_F_TLS_POST_PROCESS_CLIENT_HELLO 378 +-# define SSL_F_TLS_POST_PROCESS_CLIENT_KEY_EXCHANGE 384 +-# define SSL_F_TLS_PREPARE_CLIENT_CERTIFICATE 360 +-# define SSL_F_TLS_PROCESS_AS_HELLO_RETRY_REQUEST 610 +-# define SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST 361 +-# define SSL_F_TLS_PROCESS_CERT_STATUS 362 +-# define SSL_F_TLS_PROCESS_CERT_STATUS_BODY 495 +-# define SSL_F_TLS_PROCESS_CERT_VERIFY 379 +-# define SSL_F_TLS_PROCESS_CHANGE_CIPHER_SPEC 363 +-# define SSL_F_TLS_PROCESS_CKE_DHE 411 +-# define SSL_F_TLS_PROCESS_CKE_ECDHE 412 +-# define SSL_F_TLS_PROCESS_CKE_GOST 413 +-# define SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE 414 +-# define SSL_F_TLS_PROCESS_CKE_RSA 415 +-# define SSL_F_TLS_PROCESS_CKE_SRP 416 +-# define SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE 380 +-# define SSL_F_TLS_PROCESS_CLIENT_HELLO 381 +-# define SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE 382 +-# define SSL_F_TLS_PROCESS_ENCRYPTED_EXTENSIONS 444 +-# define SSL_F_TLS_PROCESS_END_OF_EARLY_DATA 537 +-# define SSL_F_TLS_PROCESS_FINISHED 364 +-# define SSL_F_TLS_PROCESS_HELLO_REQ 507 +-# define SSL_F_TLS_PROCESS_HELLO_RETRY_REQUEST 511 +-# define SSL_F_TLS_PROCESS_INITIAL_SERVER_FLIGHT 442 +-# define SSL_F_TLS_PROCESS_KEY_EXCHANGE 365 +-# define SSL_F_TLS_PROCESS_KEY_UPDATE 518 +-# define SSL_F_TLS_PROCESS_NEW_SESSION_TICKET 366 +-# define SSL_F_TLS_PROCESS_NEXT_PROTO 383 +-# define SSL_F_TLS_PROCESS_SERVER_CERTIFICATE 367 +-# define SSL_F_TLS_PROCESS_SERVER_DONE 368 +-# define SSL_F_TLS_PROCESS_SERVER_HELLO 369 +-# define SSL_F_TLS_PROCESS_SKE_DHE 419 +-# define SSL_F_TLS_PROCESS_SKE_ECDHE 420 +-# define SSL_F_TLS_PROCESS_SKE_PSK_PREAMBLE 421 +-# define SSL_F_TLS_PROCESS_SKE_SRP 422 +-# define SSL_F_TLS_PSK_DO_BINDER 506 +-# define SSL_F_TLS_SCAN_CLIENTHELLO_TLSEXT 450 +-# define SSL_F_TLS_SETUP_HANDSHAKE 508 +-# define SSL_F_USE_CERTIFICATE_CHAIN_FILE 220 +-# define SSL_F_WPACKET_INTERN_INIT_LEN 633 +-# define SSL_F_WPACKET_START_SUB_PACKET_LEN__ 634 +-# define SSL_F_WRITE_STATE_MACHINE 586 +- +-/* +- * SSL reason codes. +- */ +-# define SSL_R_APPLICATION_DATA_AFTER_CLOSE_NOTIFY 291 +-# define SSL_R_APP_DATA_IN_HANDSHAKE 100 +-# define SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT 272 +-# define SSL_R_AT_LEAST_TLS_1_0_NEEDED_IN_FIPS_MODE 143 +-# define SSL_R_AT_LEAST_TLS_1_2_NEEDED_IN_SUITEB_MODE 158 +-# define SSL_R_BAD_CHANGE_CIPHER_SPEC 103 +-# define SSL_R_BAD_CIPHER 186 +-# define SSL_R_BAD_DATA 390 +-# define SSL_R_BAD_DATA_RETURNED_BY_CALLBACK 106 +-# define SSL_R_BAD_DECOMPRESSION 107 +-# define SSL_R_BAD_DH_VALUE 102 +-# define SSL_R_BAD_DIGEST_LENGTH 111 +-# define SSL_R_BAD_EARLY_DATA 233 +-# define SSL_R_BAD_ECC_CERT 304 +-# define SSL_R_BAD_ECPOINT 306 +-# define SSL_R_BAD_EXTENSION 110 +-# define SSL_R_BAD_HANDSHAKE_LENGTH 332 +-# define SSL_R_BAD_HANDSHAKE_STATE 236 +-# define SSL_R_BAD_HELLO_REQUEST 105 +-# define SSL_R_BAD_HRR_VERSION 263 +-# define SSL_R_BAD_KEY_SHARE 108 +-# define SSL_R_BAD_KEY_UPDATE 122 +-# define SSL_R_BAD_LEGACY_VERSION 292 +-# define SSL_R_BAD_LENGTH 271 +-# define SSL_R_BAD_PACKET 240 +-# define SSL_R_BAD_PACKET_LENGTH 115 +-# define SSL_R_BAD_PROTOCOL_VERSION_NUMBER 116 +-# define SSL_R_BAD_PSK 219 +-# define SSL_R_BAD_PSK_IDENTITY 114 +-# define SSL_R_BAD_RECORD_TYPE 443 +-# define SSL_R_BAD_RSA_ENCRYPT 119 +-# define SSL_R_BAD_SIGNATURE 123 +-# define SSL_R_BAD_SRP_A_LENGTH 347 +-# define SSL_R_BAD_SRP_PARAMETERS 371 +-# define SSL_R_BAD_SRTP_MKI_VALUE 352 +-# define SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST 353 +-# define SSL_R_BAD_SSL_FILETYPE 124 +-# define SSL_R_BAD_VALUE 384 +-# define SSL_R_BAD_WRITE_RETRY 127 +-# define SSL_R_BINDER_DOES_NOT_VERIFY 253 +-# define SSL_R_BIO_NOT_SET 128 +-# define SSL_R_BLOCK_CIPHER_PAD_IS_WRONG 129 +-# define SSL_R_BN_LIB 130 +-# define SSL_R_CALLBACK_FAILED 234 +-# define SSL_R_CANNOT_CHANGE_CIPHER 109 +-# define SSL_R_CA_DN_LENGTH_MISMATCH 131 +-# define SSL_R_CA_KEY_TOO_SMALL 397 +-# define SSL_R_CA_MD_TOO_WEAK 398 +-# define SSL_R_CCS_RECEIVED_EARLY 133 +-# define SSL_R_CERTIFICATE_VERIFY_FAILED 134 +-# define SSL_R_CERT_CB_ERROR 377 +-# define SSL_R_CERT_LENGTH_MISMATCH 135 +-# define SSL_R_CIPHERSUITE_DIGEST_HAS_CHANGED 218 +-# define SSL_R_CIPHER_CODE_WRONG_LENGTH 137 +-# define SSL_R_CIPHER_OR_HASH_UNAVAILABLE 138 +-# define SSL_R_CLIENTHELLO_TLSEXT 226 +-# define SSL_R_COMPRESSED_LENGTH_TOO_LONG 140 +-# define SSL_R_COMPRESSION_DISABLED 343 +-# define SSL_R_COMPRESSION_FAILURE 141 +-# define SSL_R_COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE 307 +-# define SSL_R_COMPRESSION_LIBRARY_ERROR 142 +-# define SSL_R_CONNECTION_TYPE_NOT_SET 144 +-# define SSL_R_CONTEXT_NOT_DANE_ENABLED 167 +-# define SSL_R_COOKIE_GEN_CALLBACK_FAILURE 400 +-# define SSL_R_COOKIE_MISMATCH 308 +-# define SSL_R_CUSTOM_EXT_HANDLER_ALREADY_INSTALLED 206 +-# define SSL_R_DANE_ALREADY_ENABLED 172 +-# define SSL_R_DANE_CANNOT_OVERRIDE_MTYPE_FULL 173 +-# define SSL_R_DANE_NOT_ENABLED 175 +-# define SSL_R_DANE_TLSA_BAD_CERTIFICATE 180 +-# define SSL_R_DANE_TLSA_BAD_CERTIFICATE_USAGE 184 +-# define SSL_R_DANE_TLSA_BAD_DATA_LENGTH 189 +-# define SSL_R_DANE_TLSA_BAD_DIGEST_LENGTH 192 +-# define SSL_R_DANE_TLSA_BAD_MATCHING_TYPE 200 +-# define SSL_R_DANE_TLSA_BAD_PUBLIC_KEY 201 +-# define SSL_R_DANE_TLSA_BAD_SELECTOR 202 +-# define SSL_R_DANE_TLSA_NULL_DATA 203 +-# define SSL_R_DATA_BETWEEN_CCS_AND_FINISHED 145 +-# define SSL_R_DATA_LENGTH_TOO_LONG 146 +-# define SSL_R_DECRYPTION_FAILED 147 +-# define SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC 281 +-# define SSL_R_DH_KEY_TOO_SMALL 394 +-# define SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG 148 +-# define SSL_R_DIGEST_CHECK_FAILED 149 +-# define SSL_R_DTLS_MESSAGE_TOO_BIG 334 +-# define SSL_R_DUPLICATE_COMPRESSION_ID 309 +-# define SSL_R_ECC_CERT_NOT_FOR_SIGNING 318 +-# define SSL_R_ECDH_REQUIRED_FOR_SUITEB_MODE 374 +-# define SSL_R_EE_KEY_TOO_SMALL 399 +-# define SSL_R_EMPTY_SRTP_PROTECTION_PROFILE_LIST 354 +-# define SSL_R_ENCRYPTED_LENGTH_TOO_LONG 150 +-# define SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST 151 +-# define SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN 204 +-# define SSL_R_EXCEEDS_MAX_FRAGMENT_SIZE 194 +-# define SSL_R_EXCESSIVE_MESSAGE_SIZE 152 +-# define SSL_R_EXTENSION_NOT_RECEIVED 279 +-# define SSL_R_EXTRA_DATA_IN_MESSAGE 153 +-# define SSL_R_EXT_LENGTH_MISMATCH 163 +-# define SSL_R_FAILED_TO_INIT_ASYNC 405 +-# define SSL_R_FRAGMENTED_CLIENT_HELLO 401 +-# define SSL_R_GOT_A_FIN_BEFORE_A_CCS 154 +-# define SSL_R_HTTPS_PROXY_REQUEST 155 +-# define SSL_R_HTTP_REQUEST 156 +-# define SSL_R_ILLEGAL_POINT_COMPRESSION 162 +-# define SSL_R_ILLEGAL_SUITEB_DIGEST 380 +-# define SSL_R_INAPPROPRIATE_FALLBACK 373 +-# define SSL_R_INCONSISTENT_COMPRESSION 340 +-# define SSL_R_INCONSISTENT_EARLY_DATA_ALPN 222 +-# define SSL_R_INCONSISTENT_EARLY_DATA_SNI 231 +-# define SSL_R_INCONSISTENT_EXTMS 104 +-# define SSL_R_INSUFFICIENT_SECURITY 241 +-# define SSL_R_INVALID_ALERT 205 +-# define SSL_R_INVALID_CCS_MESSAGE 260 +-# define SSL_R_INVALID_CERTIFICATE_OR_ALG 238 +-# define SSL_R_INVALID_COMMAND 280 +-# define SSL_R_INVALID_COMPRESSION_ALGORITHM 341 +-# define SSL_R_INVALID_CONFIG 283 +-# define SSL_R_INVALID_CONFIGURATION_NAME 113 +-# define SSL_R_INVALID_CONTEXT 282 +-# define SSL_R_INVALID_CT_VALIDATION_TYPE 212 +-# define SSL_R_INVALID_KEY_UPDATE_TYPE 120 +-# define SSL_R_INVALID_MAX_EARLY_DATA 174 +-# define SSL_R_INVALID_NULL_CMD_NAME 385 +-# define SSL_R_INVALID_SEQUENCE_NUMBER 402 +-# define SSL_R_INVALID_SERVERINFO_DATA 388 +-# define SSL_R_INVALID_SESSION_ID 999 +-# define SSL_R_INVALID_SRP_USERNAME 357 +-# define SSL_R_INVALID_STATUS_RESPONSE 328 +-# define SSL_R_INVALID_TICKET_KEYS_LENGTH 325 +-# define SSL_R_LENGTH_MISMATCH 159 +-# define SSL_R_LENGTH_TOO_LONG 404 +-# define SSL_R_LENGTH_TOO_SHORT 160 +-# define SSL_R_LIBRARY_BUG 274 +-# define SSL_R_LIBRARY_HAS_NO_CIPHERS 161 +-# define SSL_R_MISSING_DSA_SIGNING_CERT 165 +-# define SSL_R_MISSING_ECDSA_SIGNING_CERT 381 +-# define SSL_R_MISSING_FATAL 256 +-# define SSL_R_MISSING_PARAMETERS 290 +-# define SSL_R_MISSING_PSK_KEX_MODES_EXTENSION 310 +-# define SSL_R_MISSING_RSA_CERTIFICATE 168 +-# define SSL_R_MISSING_RSA_ENCRYPTING_CERT 169 +-# define SSL_R_MISSING_RSA_SIGNING_CERT 170 +-# define SSL_R_MISSING_SIGALGS_EXTENSION 112 +-# define SSL_R_MISSING_SIGNING_CERT 221 +-# define SSL_R_MISSING_SRP_PARAM 358 +-# define SSL_R_MISSING_SUPPORTED_GROUPS_EXTENSION 209 +-# define SSL_R_MISSING_TMP_DH_KEY 171 +-# define SSL_R_MISSING_TMP_ECDH_KEY 311 +-# define SSL_R_MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA 293 +-# define SSL_R_NOT_ON_RECORD_BOUNDARY 182 +-# define SSL_R_NOT_REPLACING_CERTIFICATE 289 +-# define SSL_R_NOT_SERVER 284 +-# define SSL_R_NO_APPLICATION_PROTOCOL 235 +-# define SSL_R_NO_CERTIFICATES_RETURNED 176 +-# define SSL_R_NO_CERTIFICATE_ASSIGNED 177 +-# define SSL_R_NO_CERTIFICATE_SET 179 +-# define SSL_R_NO_CHANGE_FOLLOWING_HRR 214 +-# define SSL_R_NO_CIPHERS_AVAILABLE 181 +-# define SSL_R_NO_CIPHERS_SPECIFIED 183 +-# define SSL_R_NO_CIPHER_MATCH 185 +-# define SSL_R_NO_CLIENT_CERT_METHOD 331 +-# define SSL_R_NO_COMPRESSION_SPECIFIED 187 +-# define SSL_R_NO_COOKIE_CALLBACK_SET 287 +-# define SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER 330 +-# define SSL_R_NO_METHOD_SPECIFIED 188 +-# define SSL_R_NO_PEM_EXTENSIONS 389 +-# define SSL_R_NO_PRIVATE_KEY_ASSIGNED 190 +-# define SSL_R_NO_PROTOCOLS_AVAILABLE 191 +-# define SSL_R_NO_RENEGOTIATION 339 +-# define SSL_R_NO_REQUIRED_DIGEST 324 +-# define SSL_R_NO_SHARED_CIPHER 193 +-# define SSL_R_NO_SHARED_GROUPS 410 +-# define SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS 376 +-# define SSL_R_NO_SRTP_PROFILES 359 +-# define SSL_R_NO_SUITABLE_KEY_SHARE 101 +-# define SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM 118 +-# define SSL_R_NO_VALID_SCTS 216 +-# define SSL_R_NO_VERIFY_COOKIE_CALLBACK 403 +-# define SSL_R_NULL_SSL_CTX 195 +-# define SSL_R_NULL_SSL_METHOD_PASSED 196 +-# define SSL_R_OCSP_CALLBACK_FAILURE 294 +-# define SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED 197 +-# define SSL_R_OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED 344 +-# define SSL_R_OVERFLOW_ERROR 237 +-# define SSL_R_PACKET_LENGTH_TOO_LONG 198 +-# define SSL_R_PARSE_TLSEXT 227 +-# define SSL_R_PATH_TOO_LONG 270 +-# define SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE 199 +-# define SSL_R_PEM_NAME_BAD_PREFIX 391 +-# define SSL_R_PEM_NAME_TOO_SHORT 392 +-# define SSL_R_PIPELINE_FAILURE 406 +-# define SSL_R_POST_HANDSHAKE_AUTH_ENCODING_ERR 278 +-# define SSL_R_PRIVATE_KEY_MISMATCH 288 +-# define SSL_R_PROTOCOL_IS_SHUTDOWN 207 +-# define SSL_R_PSK_IDENTITY_NOT_FOUND 223 +-# define SSL_R_PSK_NO_CLIENT_CB 224 +-# define SSL_R_PSK_NO_SERVER_CB 225 +-# define SSL_R_READ_BIO_NOT_SET 211 +-# define SSL_R_READ_TIMEOUT_EXPIRED 312 +-# define SSL_R_RECORD_LENGTH_MISMATCH 213 +-# define SSL_R_RECORD_TOO_SMALL 298 +-# define SSL_R_RENEGOTIATE_EXT_TOO_LONG 335 +-# define SSL_R_RENEGOTIATION_ENCODING_ERR 336 +-# define SSL_R_RENEGOTIATION_MISMATCH 337 +-# define SSL_R_REQUEST_PENDING 285 +-# define SSL_R_REQUEST_SENT 286 +-# define SSL_R_REQUIRED_CIPHER_MISSING 215 +-# define SSL_R_REQUIRED_COMPRESSION_ALGORITHM_MISSING 342 +-# define SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING 345 +-# define SSL_R_SCT_VERIFICATION_FAILED 208 +-# define SSL_R_SERVERHELLO_TLSEXT 275 +-# define SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED 277 +-# define SSL_R_SHUTDOWN_WHILE_IN_INIT 407 +-# define SSL_R_SIGNATURE_ALGORITHMS_ERROR 360 +-# define SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE 220 +-# define SSL_R_SRP_A_CALC 361 +-# define SSL_R_SRTP_COULD_NOT_ALLOCATE_PROFILES 362 +-# define SSL_R_SRTP_PROTECTION_PROFILE_LIST_TOO_LONG 363 +-# define SSL_R_SRTP_UNKNOWN_PROTECTION_PROFILE 364 +-# define SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH 232 +-# define SSL_R_SSL3_EXT_INVALID_SERVERNAME 319 +-# define SSL_R_SSL3_EXT_INVALID_SERVERNAME_TYPE 320 +-# define SSL_R_SSL3_SESSION_ID_TOO_LONG 300 +-# define SSL_R_SSLV3_ALERT_BAD_CERTIFICATE 1042 +-# define SSL_R_SSLV3_ALERT_BAD_RECORD_MAC 1020 +-# define SSL_R_SSLV3_ALERT_CERTIFICATE_EXPIRED 1045 +-# define SSL_R_SSLV3_ALERT_CERTIFICATE_REVOKED 1044 +-# define SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN 1046 +-# define SSL_R_SSLV3_ALERT_DECOMPRESSION_FAILURE 1030 +-# define SSL_R_SSLV3_ALERT_HANDSHAKE_FAILURE 1040 +-# define SSL_R_SSLV3_ALERT_ILLEGAL_PARAMETER 1047 +-# define SSL_R_SSLV3_ALERT_NO_CERTIFICATE 1041 +-# define SSL_R_SSLV3_ALERT_UNEXPECTED_MESSAGE 1010 +-# define SSL_R_SSLV3_ALERT_UNSUPPORTED_CERTIFICATE 1043 +-# define SSL_R_SSL_COMMAND_SECTION_EMPTY 117 +-# define SSL_R_SSL_COMMAND_SECTION_NOT_FOUND 125 +-# define SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION 228 +-# define SSL_R_SSL_HANDSHAKE_FAILURE 229 +-# define SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS 230 +-# define SSL_R_SSL_NEGATIVE_LENGTH 372 +-# define SSL_R_SSL_SECTION_EMPTY 126 +-# define SSL_R_SSL_SECTION_NOT_FOUND 136 +-# define SSL_R_SSL_SESSION_ID_CALLBACK_FAILED 301 +-# define SSL_R_SSL_SESSION_ID_CONFLICT 302 +-# define SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG 273 +-# define SSL_R_SSL_SESSION_ID_HAS_BAD_LENGTH 303 +-# define SSL_R_SSL_SESSION_ID_TOO_LONG 408 +-# define SSL_R_SSL_SESSION_VERSION_MISMATCH 210 +-# define SSL_R_STILL_IN_INIT 121 +-# define SSL_R_TLSV13_ALERT_CERTIFICATE_REQUIRED 1116 +-# define SSL_R_TLSV13_ALERT_MISSING_EXTENSION 1109 +-# define SSL_R_TLSV1_ALERT_ACCESS_DENIED 1049 +-# define SSL_R_TLSV1_ALERT_DECODE_ERROR 1050 +-# define SSL_R_TLSV1_ALERT_DECRYPTION_FAILED 1021 +-# define SSL_R_TLSV1_ALERT_DECRYPT_ERROR 1051 +-# define SSL_R_TLSV1_ALERT_EXPORT_RESTRICTION 1060 +-# define SSL_R_TLSV1_ALERT_INAPPROPRIATE_FALLBACK 1086 +-# define SSL_R_TLSV1_ALERT_INSUFFICIENT_SECURITY 1071 +-# define SSL_R_TLSV1_ALERT_INTERNAL_ERROR 1080 +-# define SSL_R_TLSV1_ALERT_NO_RENEGOTIATION 1100 +-# define SSL_R_TLSV1_ALERT_PROTOCOL_VERSION 1070 +-# define SSL_R_TLSV1_ALERT_RECORD_OVERFLOW 1022 +-# define SSL_R_TLSV1_ALERT_UNKNOWN_CA 1048 +-# define SSL_R_TLSV1_ALERT_USER_CANCELLED 1090 +-# define SSL_R_TLSV1_BAD_CERTIFICATE_HASH_VALUE 1114 +-# define SSL_R_TLSV1_BAD_CERTIFICATE_STATUS_RESPONSE 1113 +-# define SSL_R_TLSV1_CERTIFICATE_UNOBTAINABLE 1111 +-# define SSL_R_TLSV1_UNRECOGNIZED_NAME 1112 +-# define SSL_R_TLSV1_UNSUPPORTED_EXTENSION 1110 +-# define SSL_R_TLS_HEARTBEAT_PEER_DOESNT_ACCEPT 365 +-# define SSL_R_TLS_HEARTBEAT_PENDING 366 +-# define SSL_R_TLS_ILLEGAL_EXPORTER_LABEL 367 +-# define SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST 157 +-# define SSL_R_TOO_MANY_KEY_UPDATES 132 +-# define SSL_R_TOO_MANY_WARN_ALERTS 409 +-# define SSL_R_TOO_MUCH_EARLY_DATA 164 +-# define SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS 314 +-# define SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS 239 +-# define SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES 242 +-# define SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES 243 +-# define SSL_R_UNEXPECTED_CCS_MESSAGE 262 +-# define SSL_R_UNEXPECTED_END_OF_EARLY_DATA 178 +-# define SSL_R_UNEXPECTED_MESSAGE 244 +-# define SSL_R_UNEXPECTED_RECORD 245 +-# define SSL_R_UNINITIALIZED 276 +-# define SSL_R_UNKNOWN_ALERT_TYPE 246 +-# define SSL_R_UNKNOWN_CERTIFICATE_TYPE 247 +-# define SSL_R_UNKNOWN_CIPHER_RETURNED 248 +-# define SSL_R_UNKNOWN_CIPHER_TYPE 249 +-# define SSL_R_UNKNOWN_CMD_NAME 386 +-# define SSL_R_UNKNOWN_COMMAND 139 +-# define SSL_R_UNKNOWN_DIGEST 368 +-# define SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE 250 +-# define SSL_R_UNKNOWN_PKEY_TYPE 251 +-# define SSL_R_UNKNOWN_PROTOCOL 252 +-# define SSL_R_UNKNOWN_SSL_VERSION 254 +-# define SSL_R_UNKNOWN_STATE 255 +-# define SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED 338 +-# define SSL_R_UNSOLICITED_EXTENSION 217 +-# define SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM 257 +-# define SSL_R_UNSUPPORTED_ELLIPTIC_CURVE 315 +-# define SSL_R_UNSUPPORTED_PROTOCOL 258 +-# define SSL_R_UNSUPPORTED_SSL_VERSION 259 +-# define SSL_R_UNSUPPORTED_STATUS_TYPE 329 +-# define SSL_R_USE_SRTP_NOT_NEGOTIATED 369 +-# define SSL_R_VERSION_TOO_HIGH 166 +-# define SSL_R_VERSION_TOO_LOW 396 +-# define SSL_R_WRONG_CERTIFICATE_TYPE 383 +-# define SSL_R_WRONG_CIPHER_RETURNED 261 +-# define SSL_R_WRONG_CURVE 378 +-# define SSL_R_WRONG_SIGNATURE_LENGTH 264 +-# define SSL_R_WRONG_SIGNATURE_SIZE 265 +-# define SSL_R_WRONG_SIGNATURE_TYPE 370 +-# define SSL_R_WRONG_SSL_VERSION 266 +-# define SSL_R_WRONG_VERSION_NUMBER 267 +-# define SSL_R_X509_LIB 268 +-# define SSL_R_X509_VERIFICATION_SETUP_PROBLEMS 269 +- +-#endif +diff --git a/uadk_tool/include/openssl/stack.h b/uadk_tool/include/openssl/stack.h +deleted file mode 100644 +index cfc0750..0000000 +--- a/uadk_tool/include/openssl/stack.h ++++ /dev/null +@@ -1,83 +0,0 @@ +-/* +- * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_STACK_H +-# define HEADER_STACK_H +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-typedef struct stack_st OPENSSL_STACK; /* Use STACK_OF(...) instead */ +- +-typedef int (*OPENSSL_sk_compfunc)(const void *, const void *); +-typedef void (*OPENSSL_sk_freefunc)(void *); +-typedef void *(*OPENSSL_sk_copyfunc)(const void *); +- +-int OPENSSL_sk_num(const OPENSSL_STACK *); +-void *OPENSSL_sk_value(const OPENSSL_STACK *, int); +- +-void *OPENSSL_sk_set(OPENSSL_STACK *st, int i, const void *data); +- +-OPENSSL_STACK *OPENSSL_sk_new(OPENSSL_sk_compfunc cmp); +-OPENSSL_STACK *OPENSSL_sk_new_null(void); +-OPENSSL_STACK *OPENSSL_sk_new_reserve(OPENSSL_sk_compfunc c, int n); +-int OPENSSL_sk_reserve(OPENSSL_STACK *st, int n); +-void OPENSSL_sk_free(OPENSSL_STACK *); +-void OPENSSL_sk_pop_free(OPENSSL_STACK *st, void (*func) (void *)); +-OPENSSL_STACK *OPENSSL_sk_deep_copy(const OPENSSL_STACK *, +- OPENSSL_sk_copyfunc c, +- OPENSSL_sk_freefunc f); +-int OPENSSL_sk_insert(OPENSSL_STACK *sk, const void *data, int where); +-void *OPENSSL_sk_delete(OPENSSL_STACK *st, int loc); +-void *OPENSSL_sk_delete_ptr(OPENSSL_STACK *st, const void *p); +-int OPENSSL_sk_find(OPENSSL_STACK *st, const void *data); +-int OPENSSL_sk_find_ex(OPENSSL_STACK *st, const void *data); +-int OPENSSL_sk_push(OPENSSL_STACK *st, const void *data); +-int OPENSSL_sk_unshift(OPENSSL_STACK *st, const void *data); +-void *OPENSSL_sk_shift(OPENSSL_STACK *st); +-void *OPENSSL_sk_pop(OPENSSL_STACK *st); +-void OPENSSL_sk_zero(OPENSSL_STACK *st); +-OPENSSL_sk_compfunc OPENSSL_sk_set_cmp_func(OPENSSL_STACK *sk, +- OPENSSL_sk_compfunc cmp); +-OPENSSL_STACK *OPENSSL_sk_dup(const OPENSSL_STACK *st); +-void OPENSSL_sk_sort(OPENSSL_STACK *st); +-int OPENSSL_sk_is_sorted(const OPENSSL_STACK *st); +- +-# if OPENSSL_API_COMPAT < 0x10100000L +-# define _STACK OPENSSL_STACK +-# define sk_num OPENSSL_sk_num +-# define sk_value OPENSSL_sk_value +-# define sk_set OPENSSL_sk_set +-# define sk_new OPENSSL_sk_new +-# define sk_new_null OPENSSL_sk_new_null +-# define sk_free OPENSSL_sk_free +-# define sk_pop_free OPENSSL_sk_pop_free +-# define sk_deep_copy OPENSSL_sk_deep_copy +-# define sk_insert OPENSSL_sk_insert +-# define sk_delete OPENSSL_sk_delete +-# define sk_delete_ptr OPENSSL_sk_delete_ptr +-# define sk_find OPENSSL_sk_find +-# define sk_find_ex OPENSSL_sk_find_ex +-# define sk_push OPENSSL_sk_push +-# define sk_unshift OPENSSL_sk_unshift +-# define sk_shift OPENSSL_sk_shift +-# define sk_pop OPENSSL_sk_pop +-# define sk_zero OPENSSL_sk_zero +-# define sk_set_cmp_func OPENSSL_sk_set_cmp_func +-# define sk_dup OPENSSL_sk_dup +-# define sk_sort OPENSSL_sk_sort +-# define sk_is_sorted OPENSSL_sk_is_sorted +-# endif +- +-#ifdef __cplusplus +-} +-#endif +- +-#endif +diff --git a/uadk_tool/include/openssl/store.h b/uadk_tool/include/openssl/store.h +deleted file mode 100644 +index a40a733..0000000 +--- a/uadk_tool/include/openssl/store.h ++++ /dev/null +@@ -1,266 +0,0 @@ +-/* +- * Copyright 2016-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_OSSL_STORE_H +-# define HEADER_OSSL_STORE_H +- +-# include +-# include +-# include +-# include +- +-# ifdef __cplusplus +-extern "C" { +-# endif +- +-/*- +- * The main OSSL_STORE functions. +- * ------------------------------ +- * +- * These allow applications to open a channel to a resource with supported +- * data (keys, certs, crls, ...), read the data a piece at a time and decide +- * what to do with it, and finally close. +- */ +- +-typedef struct ossl_store_ctx_st OSSL_STORE_CTX; +- +-/* +- * Typedef for the OSSL_STORE_INFO post processing callback. This can be used +- * to massage the given OSSL_STORE_INFO, or to drop it entirely (by returning +- * NULL). +- */ +-typedef OSSL_STORE_INFO *(*OSSL_STORE_post_process_info_fn)(OSSL_STORE_INFO *, +- void *); +- +-/* +- * Open a channel given a URI. The given UI method will be used any time the +- * loader needs extra input, for example when a password or pin is needed, and +- * will be passed the same user data every time it's needed in this context. +- * +- * Returns a context reference which represents the channel to communicate +- * through. +- */ +-OSSL_STORE_CTX *OSSL_STORE_open(const char *uri, const UI_METHOD *ui_method, +- void *ui_data, +- OSSL_STORE_post_process_info_fn post_process, +- void *post_process_data); +- +-/* +- * Control / fine tune the OSSL_STORE channel. |cmd| determines what is to be +- * done, and depends on the underlying loader (use OSSL_STORE_get0_scheme to +- * determine which loader is used), except for common commands (see below). +- * Each command takes different arguments. +- */ +-int OSSL_STORE_ctrl(OSSL_STORE_CTX *ctx, int cmd, ... /* args */); +-int OSSL_STORE_vctrl(OSSL_STORE_CTX *ctx, int cmd, va_list args); +- +-/* +- * Common ctrl commands that different loaders may choose to support. +- */ +-/* int on = 0 or 1; STORE_ctrl(ctx, STORE_C_USE_SECMEM, &on); */ +-# define OSSL_STORE_C_USE_SECMEM 1 +-/* Where custom commands start */ +-# define OSSL_STORE_C_CUSTOM_START 100 +- +-/* +- * Read one data item (a key, a cert, a CRL) that is supported by the OSSL_STORE +- * functionality, given a context. +- * Returns a OSSL_STORE_INFO pointer, from which OpenSSL typed data can be +- * extracted with OSSL_STORE_INFO_get0_PKEY(), OSSL_STORE_INFO_get0_CERT(), ... +- * NULL is returned on error, which may include that the data found at the URI +- * can't be figured out for certain or is ambiguous. +- */ +-OSSL_STORE_INFO *OSSL_STORE_load(OSSL_STORE_CTX *ctx); +- +-/* +- * Check if end of data (end of file) is reached +- * Returns 1 on end, 0 otherwise. +- */ +-int OSSL_STORE_eof(OSSL_STORE_CTX *ctx); +- +-/* +- * Check if an error occurred +- * Returns 1 if it did, 0 otherwise. +- */ +-int OSSL_STORE_error(OSSL_STORE_CTX *ctx); +- +-/* +- * Close the channel +- * Returns 1 on success, 0 on error. +- */ +-int OSSL_STORE_close(OSSL_STORE_CTX *ctx); +- +- +-/*- +- * Extracting OpenSSL types from and creating new OSSL_STORE_INFOs +- * --------------------------------------------------------------- +- */ +- +-/* +- * Types of data that can be ossl_stored in a OSSL_STORE_INFO. +- * OSSL_STORE_INFO_NAME is typically found when getting a listing of +- * available "files" / "tokens" / what have you. +- */ +-# define OSSL_STORE_INFO_NAME 1 /* char * */ +-# define OSSL_STORE_INFO_PARAMS 2 /* EVP_PKEY * */ +-# define OSSL_STORE_INFO_PKEY 3 /* EVP_PKEY * */ +-# define OSSL_STORE_INFO_CERT 4 /* X509 * */ +-# define OSSL_STORE_INFO_CRL 5 /* X509_CRL * */ +- +-/* +- * Functions to generate OSSL_STORE_INFOs, one function for each type we +- * support having in them, as well as a generic constructor. +- * +- * In all cases, ownership of the object is transferred to the OSSL_STORE_INFO +- * and will therefore be freed when the OSSL_STORE_INFO is freed. +- */ +-OSSL_STORE_INFO *OSSL_STORE_INFO_new_NAME(char *name); +-int OSSL_STORE_INFO_set0_NAME_description(OSSL_STORE_INFO *info, char *desc); +-OSSL_STORE_INFO *OSSL_STORE_INFO_new_PARAMS(EVP_PKEY *params); +-OSSL_STORE_INFO *OSSL_STORE_INFO_new_PKEY(EVP_PKEY *pkey); +-OSSL_STORE_INFO *OSSL_STORE_INFO_new_CERT(X509 *x509); +-OSSL_STORE_INFO *OSSL_STORE_INFO_new_CRL(X509_CRL *crl); +- +-/* +- * Functions to try to extract data from a OSSL_STORE_INFO. +- */ +-int OSSL_STORE_INFO_get_type(const OSSL_STORE_INFO *info); +-const char *OSSL_STORE_INFO_get0_NAME(const OSSL_STORE_INFO *info); +-char *OSSL_STORE_INFO_get1_NAME(const OSSL_STORE_INFO *info); +-const char *OSSL_STORE_INFO_get0_NAME_description(const OSSL_STORE_INFO *info); +-char *OSSL_STORE_INFO_get1_NAME_description(const OSSL_STORE_INFO *info); +-EVP_PKEY *OSSL_STORE_INFO_get0_PARAMS(const OSSL_STORE_INFO *info); +-EVP_PKEY *OSSL_STORE_INFO_get1_PARAMS(const OSSL_STORE_INFO *info); +-EVP_PKEY *OSSL_STORE_INFO_get0_PKEY(const OSSL_STORE_INFO *info); +-EVP_PKEY *OSSL_STORE_INFO_get1_PKEY(const OSSL_STORE_INFO *info); +-X509 *OSSL_STORE_INFO_get0_CERT(const OSSL_STORE_INFO *info); +-X509 *OSSL_STORE_INFO_get1_CERT(const OSSL_STORE_INFO *info); +-X509_CRL *OSSL_STORE_INFO_get0_CRL(const OSSL_STORE_INFO *info); +-X509_CRL *OSSL_STORE_INFO_get1_CRL(const OSSL_STORE_INFO *info); +- +-const char *OSSL_STORE_INFO_type_string(int type); +- +-/* +- * Free the OSSL_STORE_INFO +- */ +-void OSSL_STORE_INFO_free(OSSL_STORE_INFO *info); +- +- +-/*- +- * Functions to construct a search URI from a base URI and search criteria +- * ----------------------------------------------------------------------- +- */ +- +-/* OSSL_STORE search types */ +-# define OSSL_STORE_SEARCH_BY_NAME 1 /* subject in certs, issuer in CRLs */ +-# define OSSL_STORE_SEARCH_BY_ISSUER_SERIAL 2 +-# define OSSL_STORE_SEARCH_BY_KEY_FINGERPRINT 3 +-# define OSSL_STORE_SEARCH_BY_ALIAS 4 +- +-/* To check what search types the scheme handler supports */ +-int OSSL_STORE_supports_search(OSSL_STORE_CTX *ctx, int search_type); +- +-/* Search term constructors */ +-/* +- * The input is considered to be owned by the caller, and must therefore +- * remain present throughout the lifetime of the returned OSSL_STORE_SEARCH +- */ +-OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_name(X509_NAME *name); +-OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_issuer_serial(X509_NAME *name, +- const ASN1_INTEGER +- *serial); +-OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_key_fingerprint(const EVP_MD *digest, +- const unsigned char +- *bytes, size_t len); +-OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_alias(const char *alias); +- +-/* Search term destructor */ +-void OSSL_STORE_SEARCH_free(OSSL_STORE_SEARCH *search); +- +-/* Search term accessors */ +-int OSSL_STORE_SEARCH_get_type(const OSSL_STORE_SEARCH *criterion); +-X509_NAME *OSSL_STORE_SEARCH_get0_name(OSSL_STORE_SEARCH *criterion); +-const ASN1_INTEGER *OSSL_STORE_SEARCH_get0_serial(const OSSL_STORE_SEARCH +- *criterion); +-const unsigned char *OSSL_STORE_SEARCH_get0_bytes(const OSSL_STORE_SEARCH +- *criterion, size_t *length); +-const char *OSSL_STORE_SEARCH_get0_string(const OSSL_STORE_SEARCH *criterion); +-const EVP_MD *OSSL_STORE_SEARCH_get0_digest(const OSSL_STORE_SEARCH *criterion); +- +-/* +- * Add search criterion and expected return type (which can be unspecified) +- * to the loading channel. This MUST happen before the first OSSL_STORE_load(). +- */ +-int OSSL_STORE_expect(OSSL_STORE_CTX *ctx, int expected_type); +-int OSSL_STORE_find(OSSL_STORE_CTX *ctx, OSSL_STORE_SEARCH *search); +- +- +-/*- +- * Function to register a loader for the given URI scheme. +- * ------------------------------------------------------- +- * +- * The loader receives all the main components of an URI except for the +- * scheme. +- */ +- +-typedef struct ossl_store_loader_st OSSL_STORE_LOADER; +-OSSL_STORE_LOADER *OSSL_STORE_LOADER_new(ENGINE *e, const char *scheme); +-const ENGINE *OSSL_STORE_LOADER_get0_engine(const OSSL_STORE_LOADER *loader); +-const char *OSSL_STORE_LOADER_get0_scheme(const OSSL_STORE_LOADER *loader); +-/* struct ossl_store_loader_ctx_st is defined differently by each loader */ +-typedef struct ossl_store_loader_ctx_st OSSL_STORE_LOADER_CTX; +-typedef OSSL_STORE_LOADER_CTX *(*OSSL_STORE_open_fn)(const OSSL_STORE_LOADER +- *loader, +- const char *uri, +- const UI_METHOD *ui_method, +- void *ui_data); +-int OSSL_STORE_LOADER_set_open(OSSL_STORE_LOADER *loader, +- OSSL_STORE_open_fn open_function); +-typedef int (*OSSL_STORE_ctrl_fn)(OSSL_STORE_LOADER_CTX *ctx, int cmd, +- va_list args); +-int OSSL_STORE_LOADER_set_ctrl(OSSL_STORE_LOADER *loader, +- OSSL_STORE_ctrl_fn ctrl_function); +-typedef int (*OSSL_STORE_expect_fn)(OSSL_STORE_LOADER_CTX *ctx, int expected); +-int OSSL_STORE_LOADER_set_expect(OSSL_STORE_LOADER *loader, +- OSSL_STORE_expect_fn expect_function); +-typedef int (*OSSL_STORE_find_fn)(OSSL_STORE_LOADER_CTX *ctx, +- OSSL_STORE_SEARCH *criteria); +-int OSSL_STORE_LOADER_set_find(OSSL_STORE_LOADER *loader, +- OSSL_STORE_find_fn find_function); +-typedef OSSL_STORE_INFO *(*OSSL_STORE_load_fn)(OSSL_STORE_LOADER_CTX *ctx, +- const UI_METHOD *ui_method, +- void *ui_data); +-int OSSL_STORE_LOADER_set_load(OSSL_STORE_LOADER *loader, +- OSSL_STORE_load_fn load_function); +-typedef int (*OSSL_STORE_eof_fn)(OSSL_STORE_LOADER_CTX *ctx); +-int OSSL_STORE_LOADER_set_eof(OSSL_STORE_LOADER *loader, +- OSSL_STORE_eof_fn eof_function); +-typedef int (*OSSL_STORE_error_fn)(OSSL_STORE_LOADER_CTX *ctx); +-int OSSL_STORE_LOADER_set_error(OSSL_STORE_LOADER *loader, +- OSSL_STORE_error_fn error_function); +-typedef int (*OSSL_STORE_close_fn)(OSSL_STORE_LOADER_CTX *ctx); +-int OSSL_STORE_LOADER_set_close(OSSL_STORE_LOADER *loader, +- OSSL_STORE_close_fn close_function); +-void OSSL_STORE_LOADER_free(OSSL_STORE_LOADER *loader); +- +-int OSSL_STORE_register_loader(OSSL_STORE_LOADER *loader); +-OSSL_STORE_LOADER *OSSL_STORE_unregister_loader(const char *scheme); +- +-/*- +- * Functions to list STORE loaders +- * ------------------------------- +- */ +-int OSSL_STORE_do_all_loaders(void (*do_function) (const OSSL_STORE_LOADER +- *loader, void *do_arg), +- void *do_arg); +- +-# ifdef __cplusplus +-} +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/storeerr.h b/uadk_tool/include/openssl/storeerr.h +deleted file mode 100644 +index 190eab0..0000000 +--- a/uadk_tool/include/openssl/storeerr.h ++++ /dev/null +@@ -1,91 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_OSSL_STOREERR_H +-# define HEADER_OSSL_STOREERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_OSSL_STORE_strings(void); +- +-/* +- * OSSL_STORE function codes. +- */ +-# define OSSL_STORE_F_FILE_CTRL 129 +-# define OSSL_STORE_F_FILE_FIND 138 +-# define OSSL_STORE_F_FILE_GET_PASS 118 +-# define OSSL_STORE_F_FILE_LOAD 119 +-# define OSSL_STORE_F_FILE_LOAD_TRY_DECODE 124 +-# define OSSL_STORE_F_FILE_NAME_TO_URI 126 +-# define OSSL_STORE_F_FILE_OPEN 120 +-# define OSSL_STORE_F_OSSL_STORE_ATTACH_PEM_BIO 127 +-# define OSSL_STORE_F_OSSL_STORE_EXPECT 130 +-# define OSSL_STORE_F_OSSL_STORE_FILE_ATTACH_PEM_BIO_INT 128 +-# define OSSL_STORE_F_OSSL_STORE_FIND 131 +-# define OSSL_STORE_F_OSSL_STORE_GET0_LOADER_INT 100 +-# define OSSL_STORE_F_OSSL_STORE_INFO_GET1_CERT 101 +-# define OSSL_STORE_F_OSSL_STORE_INFO_GET1_CRL 102 +-# define OSSL_STORE_F_OSSL_STORE_INFO_GET1_NAME 103 +-# define OSSL_STORE_F_OSSL_STORE_INFO_GET1_NAME_DESCRIPTION 135 +-# define OSSL_STORE_F_OSSL_STORE_INFO_GET1_PARAMS 104 +-# define OSSL_STORE_F_OSSL_STORE_INFO_GET1_PKEY 105 +-# define OSSL_STORE_F_OSSL_STORE_INFO_NEW_CERT 106 +-# define OSSL_STORE_F_OSSL_STORE_INFO_NEW_CRL 107 +-# define OSSL_STORE_F_OSSL_STORE_INFO_NEW_EMBEDDED 123 +-# define OSSL_STORE_F_OSSL_STORE_INFO_NEW_NAME 109 +-# define OSSL_STORE_F_OSSL_STORE_INFO_NEW_PARAMS 110 +-# define OSSL_STORE_F_OSSL_STORE_INFO_NEW_PKEY 111 +-# define OSSL_STORE_F_OSSL_STORE_INFO_SET0_NAME_DESCRIPTION 134 +-# define OSSL_STORE_F_OSSL_STORE_INIT_ONCE 112 +-# define OSSL_STORE_F_OSSL_STORE_LOADER_NEW 113 +-# define OSSL_STORE_F_OSSL_STORE_OPEN 114 +-# define OSSL_STORE_F_OSSL_STORE_OPEN_INT 115 +-# define OSSL_STORE_F_OSSL_STORE_REGISTER_LOADER_INT 117 +-# define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_ALIAS 132 +-# define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_ISSUER_SERIAL 133 +-# define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_KEY_FINGERPRINT 136 +-# define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_NAME 137 +-# define OSSL_STORE_F_OSSL_STORE_UNREGISTER_LOADER_INT 116 +-# define OSSL_STORE_F_TRY_DECODE_PARAMS 121 +-# define OSSL_STORE_F_TRY_DECODE_PKCS12 122 +-# define OSSL_STORE_F_TRY_DECODE_PKCS8ENCRYPTED 125 +- +-/* +- * OSSL_STORE reason codes. +- */ +-# define OSSL_STORE_R_AMBIGUOUS_CONTENT_TYPE 107 +-# define OSSL_STORE_R_BAD_PASSWORD_READ 115 +-# define OSSL_STORE_R_ERROR_VERIFYING_PKCS12_MAC 113 +-# define OSSL_STORE_R_FINGERPRINT_SIZE_DOES_NOT_MATCH_DIGEST 121 +-# define OSSL_STORE_R_INVALID_SCHEME 106 +-# define OSSL_STORE_R_IS_NOT_A 112 +-# define OSSL_STORE_R_LOADER_INCOMPLETE 116 +-# define OSSL_STORE_R_LOADING_STARTED 117 +-# define OSSL_STORE_R_NOT_A_CERTIFICATE 100 +-# define OSSL_STORE_R_NOT_A_CRL 101 +-# define OSSL_STORE_R_NOT_A_KEY 102 +-# define OSSL_STORE_R_NOT_A_NAME 103 +-# define OSSL_STORE_R_NOT_PARAMETERS 104 +-# define OSSL_STORE_R_PASSPHRASE_CALLBACK_ERROR 114 +-# define OSSL_STORE_R_PATH_MUST_BE_ABSOLUTE 108 +-# define OSSL_STORE_R_SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES 119 +-# define OSSL_STORE_R_UI_PROCESS_INTERRUPTED_OR_CANCELLED 109 +-# define OSSL_STORE_R_UNREGISTERED_SCHEME 105 +-# define OSSL_STORE_R_UNSUPPORTED_CONTENT_TYPE 110 +-# define OSSL_STORE_R_UNSUPPORTED_OPERATION 118 +-# define OSSL_STORE_R_UNSUPPORTED_SEARCH_TYPE 120 +-# define OSSL_STORE_R_URI_AUTHORITY_UNSUPPORTED 111 +- +-#endif +diff --git a/uadk_tool/include/openssl/symhacks.h b/uadk_tool/include/openssl/symhacks.h +deleted file mode 100644 +index 156ea6e..0000000 +--- a/uadk_tool/include/openssl/symhacks.h ++++ /dev/null +@@ -1,37 +0,0 @@ +-/* +- * Copyright 1999-2018 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_SYMHACKS_H +-# define HEADER_SYMHACKS_H +- +-# include +- +-/* Case insensitive linking causes problems.... */ +-# if defined(OPENSSL_SYS_VMS) +-# undef ERR_load_CRYPTO_strings +-# define ERR_load_CRYPTO_strings ERR_load_CRYPTOlib_strings +-# undef OCSP_crlID_new +-# define OCSP_crlID_new OCSP_crlID2_new +- +-# undef d2i_ECPARAMETERS +-# define d2i_ECPARAMETERS d2i_UC_ECPARAMETERS +-# undef i2d_ECPARAMETERS +-# define i2d_ECPARAMETERS i2d_UC_ECPARAMETERS +-# undef d2i_ECPKPARAMETERS +-# define d2i_ECPKPARAMETERS d2i_UC_ECPKPARAMETERS +-# undef i2d_ECPKPARAMETERS +-# define i2d_ECPKPARAMETERS i2d_UC_ECPKPARAMETERS +- +-/* This one clashes with CMS_data_create */ +-# undef cms_Data_create +-# define cms_Data_create priv_cms_Data_create +- +-# endif +- +-#endif /* ! defined HEADER_VMS_IDHACKS_H */ +diff --git a/uadk_tool/include/openssl/tls1.h b/uadk_tool/include/openssl/tls1.h +deleted file mode 100644 +index 76d9fda..0000000 +--- a/uadk_tool/include/openssl/tls1.h ++++ /dev/null +@@ -1,1237 +0,0 @@ +-/* +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved +- * Copyright 2005 Nokia. All rights reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_TLS1_H +-# define HEADER_TLS1_H +- +-# include +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-/* Default security level if not overridden at config time */ +-# ifndef OPENSSL_TLS_SECURITY_LEVEL +-# define OPENSSL_TLS_SECURITY_LEVEL 1 +-# endif +- +-# define TLS1_VERSION 0x0301 +-# define TLS1_1_VERSION 0x0302 +-# define TLS1_2_VERSION 0x0303 +-# define TLS1_3_VERSION 0x0304 +-# define TLS_MAX_VERSION TLS1_3_VERSION +- +-/* Special value for method supporting multiple versions */ +-# define TLS_ANY_VERSION 0x10000 +- +-# define TLS1_VERSION_MAJOR 0x03 +-# define TLS1_VERSION_MINOR 0x01 +- +-# define TLS1_1_VERSION_MAJOR 0x03 +-# define TLS1_1_VERSION_MINOR 0x02 +- +-# define TLS1_2_VERSION_MAJOR 0x03 +-# define TLS1_2_VERSION_MINOR 0x03 +- +-# define TLS1_get_version(s) \ +- ((SSL_version(s) >> 8) == TLS1_VERSION_MAJOR ? SSL_version(s) : 0) +- +-# define TLS1_get_client_version(s) \ +- ((SSL_client_version(s) >> 8) == TLS1_VERSION_MAJOR ? SSL_client_version(s) : 0) +- +-# define TLS1_AD_DECRYPTION_FAILED 21 +-# define TLS1_AD_RECORD_OVERFLOW 22 +-# define TLS1_AD_UNKNOWN_CA 48/* fatal */ +-# define TLS1_AD_ACCESS_DENIED 49/* fatal */ +-# define TLS1_AD_DECODE_ERROR 50/* fatal */ +-# define TLS1_AD_DECRYPT_ERROR 51 +-# define TLS1_AD_EXPORT_RESTRICTION 60/* fatal */ +-# define TLS1_AD_PROTOCOL_VERSION 70/* fatal */ +-# define TLS1_AD_INSUFFICIENT_SECURITY 71/* fatal */ +-# define TLS1_AD_INTERNAL_ERROR 80/* fatal */ +-# define TLS1_AD_INAPPROPRIATE_FALLBACK 86/* fatal */ +-# define TLS1_AD_USER_CANCELLED 90 +-# define TLS1_AD_NO_RENEGOTIATION 100 +-/* TLSv1.3 alerts */ +-# define TLS13_AD_MISSING_EXTENSION 109 /* fatal */ +-# define TLS13_AD_CERTIFICATE_REQUIRED 116 /* fatal */ +-/* codes 110-114 are from RFC3546 */ +-# define TLS1_AD_UNSUPPORTED_EXTENSION 110 +-# define TLS1_AD_CERTIFICATE_UNOBTAINABLE 111 +-# define TLS1_AD_UNRECOGNIZED_NAME 112 +-# define TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE 113 +-# define TLS1_AD_BAD_CERTIFICATE_HASH_VALUE 114 +-# define TLS1_AD_UNKNOWN_PSK_IDENTITY 115/* fatal */ +-# define TLS1_AD_NO_APPLICATION_PROTOCOL 120 /* fatal */ +- +-/* ExtensionType values from RFC3546 / RFC4366 / RFC6066 */ +-# define TLSEXT_TYPE_server_name 0 +-# define TLSEXT_TYPE_max_fragment_length 1 +-# define TLSEXT_TYPE_client_certificate_url 2 +-# define TLSEXT_TYPE_trusted_ca_keys 3 +-# define TLSEXT_TYPE_truncated_hmac 4 +-# define TLSEXT_TYPE_status_request 5 +-/* ExtensionType values from RFC4681 */ +-# define TLSEXT_TYPE_user_mapping 6 +-/* ExtensionType values from RFC5878 */ +-# define TLSEXT_TYPE_client_authz 7 +-# define TLSEXT_TYPE_server_authz 8 +-/* ExtensionType values from RFC6091 */ +-# define TLSEXT_TYPE_cert_type 9 +- +-/* ExtensionType values from RFC4492 */ +-/* +- * Prior to TLSv1.3 the supported_groups extension was known as +- * elliptic_curves +- */ +-# define TLSEXT_TYPE_supported_groups 10 +-# define TLSEXT_TYPE_elliptic_curves TLSEXT_TYPE_supported_groups +-# define TLSEXT_TYPE_ec_point_formats 11 +- +- +-/* ExtensionType value from RFC5054 */ +-# define TLSEXT_TYPE_srp 12 +- +-/* ExtensionType values from RFC5246 */ +-# define TLSEXT_TYPE_signature_algorithms 13 +- +-/* ExtensionType value from RFC5764 */ +-# define TLSEXT_TYPE_use_srtp 14 +- +-/* ExtensionType value from RFC5620 */ +-# define TLSEXT_TYPE_heartbeat 15 +- +-/* ExtensionType value from RFC7301 */ +-# define TLSEXT_TYPE_application_layer_protocol_negotiation 16 +- +-/* +- * Extension type for Certificate Transparency +- * https://tools.ietf.org/html/rfc6962#section-3.3.1 +- */ +-# define TLSEXT_TYPE_signed_certificate_timestamp 18 +- +-/* +- * ExtensionType value for TLS padding extension. +- * http://tools.ietf.org/html/draft-agl-tls-padding +- */ +-# define TLSEXT_TYPE_padding 21 +- +-/* ExtensionType value from RFC7366 */ +-# define TLSEXT_TYPE_encrypt_then_mac 22 +- +-/* ExtensionType value from RFC7627 */ +-# define TLSEXT_TYPE_extended_master_secret 23 +- +-/* ExtensionType value from RFC4507 */ +-# define TLSEXT_TYPE_session_ticket 35 +- +-/* As defined for TLS1.3 */ +-# define TLSEXT_TYPE_psk 41 +-# define TLSEXT_TYPE_early_data 42 +-# define TLSEXT_TYPE_supported_versions 43 +-# define TLSEXT_TYPE_cookie 44 +-# define TLSEXT_TYPE_psk_kex_modes 45 +-# define TLSEXT_TYPE_certificate_authorities 47 +-# define TLSEXT_TYPE_post_handshake_auth 49 +-# define TLSEXT_TYPE_signature_algorithms_cert 50 +-# define TLSEXT_TYPE_key_share 51 +- +-/* Temporary extension type */ +-# define TLSEXT_TYPE_renegotiate 0xff01 +- +-# ifndef OPENSSL_NO_NEXTPROTONEG +-/* This is not an IANA defined extension number */ +-# define TLSEXT_TYPE_next_proto_neg 13172 +-# endif +- +-/* NameType value from RFC3546 */ +-# define TLSEXT_NAMETYPE_host_name 0 +-/* status request value from RFC3546 */ +-# define TLSEXT_STATUSTYPE_ocsp 1 +- +-/* ECPointFormat values from RFC4492 */ +-# define TLSEXT_ECPOINTFORMAT_first 0 +-# define TLSEXT_ECPOINTFORMAT_uncompressed 0 +-# define TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime 1 +-# define TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2 2 +-# define TLSEXT_ECPOINTFORMAT_last 2 +- +-/* Signature and hash algorithms from RFC5246 */ +-# define TLSEXT_signature_anonymous 0 +-# define TLSEXT_signature_rsa 1 +-# define TLSEXT_signature_dsa 2 +-# define TLSEXT_signature_ecdsa 3 +-# define TLSEXT_signature_gostr34102001 237 +-# define TLSEXT_signature_gostr34102012_256 238 +-# define TLSEXT_signature_gostr34102012_512 239 +- +-/* Total number of different signature algorithms */ +-# define TLSEXT_signature_num 7 +- +-# define TLSEXT_hash_none 0 +-# define TLSEXT_hash_md5 1 +-# define TLSEXT_hash_sha1 2 +-# define TLSEXT_hash_sha224 3 +-# define TLSEXT_hash_sha256 4 +-# define TLSEXT_hash_sha384 5 +-# define TLSEXT_hash_sha512 6 +-# define TLSEXT_hash_gostr3411 237 +-# define TLSEXT_hash_gostr34112012_256 238 +-# define TLSEXT_hash_gostr34112012_512 239 +- +-/* Total number of different digest algorithms */ +- +-# define TLSEXT_hash_num 10 +- +-/* Flag set for unrecognised algorithms */ +-# define TLSEXT_nid_unknown 0x1000000 +- +-/* ECC curves */ +- +-# define TLSEXT_curve_P_256 23 +-# define TLSEXT_curve_P_384 24 +- +-/* OpenSSL value to disable maximum fragment length extension */ +-# define TLSEXT_max_fragment_length_DISABLED 0 +-/* Allowed values for max fragment length extension */ +-# define TLSEXT_max_fragment_length_512 1 +-# define TLSEXT_max_fragment_length_1024 2 +-# define TLSEXT_max_fragment_length_2048 3 +-# define TLSEXT_max_fragment_length_4096 4 +- +-int SSL_CTX_set_tlsext_max_fragment_length(SSL_CTX *ctx, uint8_t mode); +-int SSL_set_tlsext_max_fragment_length(SSL *ssl, uint8_t mode); +- +-# define TLSEXT_MAXLEN_host_name 255 +- +-__owur const char *SSL_get_servername(const SSL *s, const int type); +-__owur int SSL_get_servername_type(const SSL *s); +-/* +- * SSL_export_keying_material exports a value derived from the master secret, +- * as specified in RFC 5705. It writes |olen| bytes to |out| given a label and +- * optional context. (Since a zero length context is allowed, the |use_context| +- * flag controls whether a context is included.) It returns 1 on success and +- * 0 or -1 otherwise. +- */ +-__owur int SSL_export_keying_material(SSL *s, unsigned char *out, size_t olen, +- const char *label, size_t llen, +- const unsigned char *context, +- size_t contextlen, int use_context); +- +-/* +- * SSL_export_keying_material_early exports a value derived from the +- * early exporter master secret, as specified in +- * https://tools.ietf.org/html/draft-ietf-tls-tls13-23. It writes +- * |olen| bytes to |out| given a label and optional context. It +- * returns 1 on success and 0 otherwise. +- */ +-__owur int SSL_export_keying_material_early(SSL *s, unsigned char *out, +- size_t olen, const char *label, +- size_t llen, +- const unsigned char *context, +- size_t contextlen); +- +-int SSL_get_peer_signature_type_nid(const SSL *s, int *pnid); +-int SSL_get_signature_type_nid(const SSL *s, int *pnid); +- +-int SSL_get_sigalgs(SSL *s, int idx, +- int *psign, int *phash, int *psignandhash, +- unsigned char *rsig, unsigned char *rhash); +- +-int SSL_get_shared_sigalgs(SSL *s, int idx, +- int *psign, int *phash, int *psignandhash, +- unsigned char *rsig, unsigned char *rhash); +- +-__owur int SSL_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain); +- +-# define SSL_set_tlsext_host_name(s,name) \ +- SSL_ctrl(s,SSL_CTRL_SET_TLSEXT_HOSTNAME,TLSEXT_NAMETYPE_host_name,\ +- (void *)name) +- +-# define SSL_set_tlsext_debug_callback(ssl, cb) \ +- SSL_callback_ctrl(ssl,SSL_CTRL_SET_TLSEXT_DEBUG_CB,\ +- (void (*)(void))cb) +- +-# define SSL_set_tlsext_debug_arg(ssl, arg) \ +- SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_DEBUG_ARG,0,arg) +- +-# define SSL_get_tlsext_status_type(ssl) \ +- SSL_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_TYPE,0,NULL) +- +-# define SSL_set_tlsext_status_type(ssl, type) \ +- SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE,type,NULL) +- +-# define SSL_get_tlsext_status_exts(ssl, arg) \ +- SSL_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_EXTS,0,arg) +- +-# define SSL_set_tlsext_status_exts(ssl, arg) \ +- SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_EXTS,0,arg) +- +-# define SSL_get_tlsext_status_ids(ssl, arg) \ +- SSL_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_IDS,0,arg) +- +-# define SSL_set_tlsext_status_ids(ssl, arg) \ +- SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_IDS,0,arg) +- +-# define SSL_get_tlsext_status_ocsp_resp(ssl, arg) \ +- SSL_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_OCSP_RESP,0,arg) +- +-# define SSL_set_tlsext_status_ocsp_resp(ssl, arg, arglen) \ +- SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_OCSP_RESP,arglen,arg) +- +-# define SSL_CTX_set_tlsext_servername_callback(ctx, cb) \ +- SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TLSEXT_SERVERNAME_CB,\ +- (void (*)(void))cb) +- +-# define SSL_TLSEXT_ERR_OK 0 +-# define SSL_TLSEXT_ERR_ALERT_WARNING 1 +-# define SSL_TLSEXT_ERR_ALERT_FATAL 2 +-# define SSL_TLSEXT_ERR_NOACK 3 +- +-# define SSL_CTX_set_tlsext_servername_arg(ctx, arg) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG,0,arg) +- +-# define SSL_CTX_get_tlsext_ticket_keys(ctx, keys, keylen) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_GET_TLSEXT_TICKET_KEYS,keylen,keys) +-# define SSL_CTX_set_tlsext_ticket_keys(ctx, keys, keylen) \ +- SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TLSEXT_TICKET_KEYS,keylen,keys) +- +-# define SSL_CTX_get_tlsext_status_cb(ssl, cb) \ +- SSL_CTX_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB,0,(void *)cb) +-# define SSL_CTX_set_tlsext_status_cb(ssl, cb) \ +- SSL_CTX_callback_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB,\ +- (void (*)(void))cb) +- +-# define SSL_CTX_get_tlsext_status_arg(ssl, arg) \ +- SSL_CTX_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB_ARG,0,arg) +-# define SSL_CTX_set_tlsext_status_arg(ssl, arg) \ +- SSL_CTX_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB_ARG,0,arg) +- +-# define SSL_CTX_set_tlsext_status_type(ssl, type) \ +- SSL_CTX_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE,type,NULL) +- +-# define SSL_CTX_get_tlsext_status_type(ssl) \ +- SSL_CTX_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_TYPE,0,NULL) +- +-# define SSL_CTX_set_tlsext_ticket_key_cb(ssl, cb) \ +- SSL_CTX_callback_ctrl(ssl,SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB,\ +- (void (*)(void))cb) +- +-# ifndef OPENSSL_NO_HEARTBEATS +-# define SSL_DTLSEXT_HB_ENABLED 0x01 +-# define SSL_DTLSEXT_HB_DONT_SEND_REQUESTS 0x02 +-# define SSL_DTLSEXT_HB_DONT_RECV_REQUESTS 0x04 +-# define SSL_get_dtlsext_heartbeat_pending(ssl) \ +- SSL_ctrl(ssl,SSL_CTRL_GET_DTLS_EXT_HEARTBEAT_PENDING,0,NULL) +-# define SSL_set_dtlsext_heartbeat_no_requests(ssl, arg) \ +- SSL_ctrl(ssl,SSL_CTRL_SET_DTLS_EXT_HEARTBEAT_NO_REQUESTS,arg,NULL) +- +-# if OPENSSL_API_COMPAT < 0x10100000L +-# define SSL_CTRL_TLS_EXT_SEND_HEARTBEAT \ +- SSL_CTRL_DTLS_EXT_SEND_HEARTBEAT +-# define SSL_CTRL_GET_TLS_EXT_HEARTBEAT_PENDING \ +- SSL_CTRL_GET_DTLS_EXT_HEARTBEAT_PENDING +-# define SSL_CTRL_SET_TLS_EXT_HEARTBEAT_NO_REQUESTS \ +- SSL_CTRL_SET_DTLS_EXT_HEARTBEAT_NO_REQUESTS +-# define SSL_TLSEXT_HB_ENABLED \ +- SSL_DTLSEXT_HB_ENABLED +-# define SSL_TLSEXT_HB_DONT_SEND_REQUESTS \ +- SSL_DTLSEXT_HB_DONT_SEND_REQUESTS +-# define SSL_TLSEXT_HB_DONT_RECV_REQUESTS \ +- SSL_DTLSEXT_HB_DONT_RECV_REQUESTS +-# define SSL_get_tlsext_heartbeat_pending(ssl) \ +- SSL_get_dtlsext_heartbeat_pending(ssl) +-# define SSL_set_tlsext_heartbeat_no_requests(ssl, arg) \ +- SSL_set_dtlsext_heartbeat_no_requests(ssl,arg) +-# endif +-# endif +- +-/* PSK ciphersuites from 4279 */ +-# define TLS1_CK_PSK_WITH_RC4_128_SHA 0x0300008A +-# define TLS1_CK_PSK_WITH_3DES_EDE_CBC_SHA 0x0300008B +-# define TLS1_CK_PSK_WITH_AES_128_CBC_SHA 0x0300008C +-# define TLS1_CK_PSK_WITH_AES_256_CBC_SHA 0x0300008D +-# define TLS1_CK_DHE_PSK_WITH_RC4_128_SHA 0x0300008E +-# define TLS1_CK_DHE_PSK_WITH_3DES_EDE_CBC_SHA 0x0300008F +-# define TLS1_CK_DHE_PSK_WITH_AES_128_CBC_SHA 0x03000090 +-# define TLS1_CK_DHE_PSK_WITH_AES_256_CBC_SHA 0x03000091 +-# define TLS1_CK_RSA_PSK_WITH_RC4_128_SHA 0x03000092 +-# define TLS1_CK_RSA_PSK_WITH_3DES_EDE_CBC_SHA 0x03000093 +-# define TLS1_CK_RSA_PSK_WITH_AES_128_CBC_SHA 0x03000094 +-# define TLS1_CK_RSA_PSK_WITH_AES_256_CBC_SHA 0x03000095 +- +-/* PSK ciphersuites from 5487 */ +-# define TLS1_CK_PSK_WITH_AES_128_GCM_SHA256 0x030000A8 +-# define TLS1_CK_PSK_WITH_AES_256_GCM_SHA384 0x030000A9 +-# define TLS1_CK_DHE_PSK_WITH_AES_128_GCM_SHA256 0x030000AA +-# define TLS1_CK_DHE_PSK_WITH_AES_256_GCM_SHA384 0x030000AB +-# define TLS1_CK_RSA_PSK_WITH_AES_128_GCM_SHA256 0x030000AC +-# define TLS1_CK_RSA_PSK_WITH_AES_256_GCM_SHA384 0x030000AD +-# define TLS1_CK_PSK_WITH_AES_128_CBC_SHA256 0x030000AE +-# define TLS1_CK_PSK_WITH_AES_256_CBC_SHA384 0x030000AF +-# define TLS1_CK_PSK_WITH_NULL_SHA256 0x030000B0 +-# define TLS1_CK_PSK_WITH_NULL_SHA384 0x030000B1 +-# define TLS1_CK_DHE_PSK_WITH_AES_128_CBC_SHA256 0x030000B2 +-# define TLS1_CK_DHE_PSK_WITH_AES_256_CBC_SHA384 0x030000B3 +-# define TLS1_CK_DHE_PSK_WITH_NULL_SHA256 0x030000B4 +-# define TLS1_CK_DHE_PSK_WITH_NULL_SHA384 0x030000B5 +-# define TLS1_CK_RSA_PSK_WITH_AES_128_CBC_SHA256 0x030000B6 +-# define TLS1_CK_RSA_PSK_WITH_AES_256_CBC_SHA384 0x030000B7 +-# define TLS1_CK_RSA_PSK_WITH_NULL_SHA256 0x030000B8 +-# define TLS1_CK_RSA_PSK_WITH_NULL_SHA384 0x030000B9 +- +-/* NULL PSK ciphersuites from RFC4785 */ +-# define TLS1_CK_PSK_WITH_NULL_SHA 0x0300002C +-# define TLS1_CK_DHE_PSK_WITH_NULL_SHA 0x0300002D +-# define TLS1_CK_RSA_PSK_WITH_NULL_SHA 0x0300002E +- +-/* AES ciphersuites from RFC3268 */ +-# define TLS1_CK_RSA_WITH_AES_128_SHA 0x0300002F +-# define TLS1_CK_DH_DSS_WITH_AES_128_SHA 0x03000030 +-# define TLS1_CK_DH_RSA_WITH_AES_128_SHA 0x03000031 +-# define TLS1_CK_DHE_DSS_WITH_AES_128_SHA 0x03000032 +-# define TLS1_CK_DHE_RSA_WITH_AES_128_SHA 0x03000033 +-# define TLS1_CK_ADH_WITH_AES_128_SHA 0x03000034 +-# define TLS1_CK_RSA_WITH_AES_256_SHA 0x03000035 +-# define TLS1_CK_DH_DSS_WITH_AES_256_SHA 0x03000036 +-# define TLS1_CK_DH_RSA_WITH_AES_256_SHA 0x03000037 +-# define TLS1_CK_DHE_DSS_WITH_AES_256_SHA 0x03000038 +-# define TLS1_CK_DHE_RSA_WITH_AES_256_SHA 0x03000039 +-# define TLS1_CK_ADH_WITH_AES_256_SHA 0x0300003A +- +-/* TLS v1.2 ciphersuites */ +-# define TLS1_CK_RSA_WITH_NULL_SHA256 0x0300003B +-# define TLS1_CK_RSA_WITH_AES_128_SHA256 0x0300003C +-# define TLS1_CK_RSA_WITH_AES_256_SHA256 0x0300003D +-# define TLS1_CK_DH_DSS_WITH_AES_128_SHA256 0x0300003E +-# define TLS1_CK_DH_RSA_WITH_AES_128_SHA256 0x0300003F +-# define TLS1_CK_DHE_DSS_WITH_AES_128_SHA256 0x03000040 +- +-/* Camellia ciphersuites from RFC4132 */ +-# define TLS1_CK_RSA_WITH_CAMELLIA_128_CBC_SHA 0x03000041 +-# define TLS1_CK_DH_DSS_WITH_CAMELLIA_128_CBC_SHA 0x03000042 +-# define TLS1_CK_DH_RSA_WITH_CAMELLIA_128_CBC_SHA 0x03000043 +-# define TLS1_CK_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA 0x03000044 +-# define TLS1_CK_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA 0x03000045 +-# define TLS1_CK_ADH_WITH_CAMELLIA_128_CBC_SHA 0x03000046 +- +-/* TLS v1.2 ciphersuites */ +-# define TLS1_CK_DHE_RSA_WITH_AES_128_SHA256 0x03000067 +-# define TLS1_CK_DH_DSS_WITH_AES_256_SHA256 0x03000068 +-# define TLS1_CK_DH_RSA_WITH_AES_256_SHA256 0x03000069 +-# define TLS1_CK_DHE_DSS_WITH_AES_256_SHA256 0x0300006A +-# define TLS1_CK_DHE_RSA_WITH_AES_256_SHA256 0x0300006B +-# define TLS1_CK_ADH_WITH_AES_128_SHA256 0x0300006C +-# define TLS1_CK_ADH_WITH_AES_256_SHA256 0x0300006D +- +-/* Camellia ciphersuites from RFC4132 */ +-# define TLS1_CK_RSA_WITH_CAMELLIA_256_CBC_SHA 0x03000084 +-# define TLS1_CK_DH_DSS_WITH_CAMELLIA_256_CBC_SHA 0x03000085 +-# define TLS1_CK_DH_RSA_WITH_CAMELLIA_256_CBC_SHA 0x03000086 +-# define TLS1_CK_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA 0x03000087 +-# define TLS1_CK_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA 0x03000088 +-# define TLS1_CK_ADH_WITH_CAMELLIA_256_CBC_SHA 0x03000089 +- +-/* SEED ciphersuites from RFC4162 */ +-# define TLS1_CK_RSA_WITH_SEED_SHA 0x03000096 +-# define TLS1_CK_DH_DSS_WITH_SEED_SHA 0x03000097 +-# define TLS1_CK_DH_RSA_WITH_SEED_SHA 0x03000098 +-# define TLS1_CK_DHE_DSS_WITH_SEED_SHA 0x03000099 +-# define TLS1_CK_DHE_RSA_WITH_SEED_SHA 0x0300009A +-# define TLS1_CK_ADH_WITH_SEED_SHA 0x0300009B +- +-/* TLS v1.2 GCM ciphersuites from RFC5288 */ +-# define TLS1_CK_RSA_WITH_AES_128_GCM_SHA256 0x0300009C +-# define TLS1_CK_RSA_WITH_AES_256_GCM_SHA384 0x0300009D +-# define TLS1_CK_DHE_RSA_WITH_AES_128_GCM_SHA256 0x0300009E +-# define TLS1_CK_DHE_RSA_WITH_AES_256_GCM_SHA384 0x0300009F +-# define TLS1_CK_DH_RSA_WITH_AES_128_GCM_SHA256 0x030000A0 +-# define TLS1_CK_DH_RSA_WITH_AES_256_GCM_SHA384 0x030000A1 +-# define TLS1_CK_DHE_DSS_WITH_AES_128_GCM_SHA256 0x030000A2 +-# define TLS1_CK_DHE_DSS_WITH_AES_256_GCM_SHA384 0x030000A3 +-# define TLS1_CK_DH_DSS_WITH_AES_128_GCM_SHA256 0x030000A4 +-# define TLS1_CK_DH_DSS_WITH_AES_256_GCM_SHA384 0x030000A5 +-# define TLS1_CK_ADH_WITH_AES_128_GCM_SHA256 0x030000A6 +-# define TLS1_CK_ADH_WITH_AES_256_GCM_SHA384 0x030000A7 +- +-/* CCM ciphersuites from RFC6655 */ +-# define TLS1_CK_RSA_WITH_AES_128_CCM 0x0300C09C +-# define TLS1_CK_RSA_WITH_AES_256_CCM 0x0300C09D +-# define TLS1_CK_DHE_RSA_WITH_AES_128_CCM 0x0300C09E +-# define TLS1_CK_DHE_RSA_WITH_AES_256_CCM 0x0300C09F +-# define TLS1_CK_RSA_WITH_AES_128_CCM_8 0x0300C0A0 +-# define TLS1_CK_RSA_WITH_AES_256_CCM_8 0x0300C0A1 +-# define TLS1_CK_DHE_RSA_WITH_AES_128_CCM_8 0x0300C0A2 +-# define TLS1_CK_DHE_RSA_WITH_AES_256_CCM_8 0x0300C0A3 +-# define TLS1_CK_PSK_WITH_AES_128_CCM 0x0300C0A4 +-# define TLS1_CK_PSK_WITH_AES_256_CCM 0x0300C0A5 +-# define TLS1_CK_DHE_PSK_WITH_AES_128_CCM 0x0300C0A6 +-# define TLS1_CK_DHE_PSK_WITH_AES_256_CCM 0x0300C0A7 +-# define TLS1_CK_PSK_WITH_AES_128_CCM_8 0x0300C0A8 +-# define TLS1_CK_PSK_WITH_AES_256_CCM_8 0x0300C0A9 +-# define TLS1_CK_DHE_PSK_WITH_AES_128_CCM_8 0x0300C0AA +-# define TLS1_CK_DHE_PSK_WITH_AES_256_CCM_8 0x0300C0AB +- +-/* CCM ciphersuites from RFC7251 */ +-# define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CCM 0x0300C0AC +-# define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CCM 0x0300C0AD +-# define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CCM_8 0x0300C0AE +-# define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CCM_8 0x0300C0AF +- +-/* TLS 1.2 Camellia SHA-256 ciphersuites from RFC5932 */ +-# define TLS1_CK_RSA_WITH_CAMELLIA_128_CBC_SHA256 0x030000BA +-# define TLS1_CK_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256 0x030000BB +-# define TLS1_CK_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256 0x030000BC +-# define TLS1_CK_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256 0x030000BD +-# define TLS1_CK_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 0x030000BE +-# define TLS1_CK_ADH_WITH_CAMELLIA_128_CBC_SHA256 0x030000BF +- +-# define TLS1_CK_RSA_WITH_CAMELLIA_256_CBC_SHA256 0x030000C0 +-# define TLS1_CK_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256 0x030000C1 +-# define TLS1_CK_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256 0x030000C2 +-# define TLS1_CK_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256 0x030000C3 +-# define TLS1_CK_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256 0x030000C4 +-# define TLS1_CK_ADH_WITH_CAMELLIA_256_CBC_SHA256 0x030000C5 +- +-/* ECC ciphersuites from RFC4492 */ +-# define TLS1_CK_ECDH_ECDSA_WITH_NULL_SHA 0x0300C001 +-# define TLS1_CK_ECDH_ECDSA_WITH_RC4_128_SHA 0x0300C002 +-# define TLS1_CK_ECDH_ECDSA_WITH_DES_192_CBC3_SHA 0x0300C003 +-# define TLS1_CK_ECDH_ECDSA_WITH_AES_128_CBC_SHA 0x0300C004 +-# define TLS1_CK_ECDH_ECDSA_WITH_AES_256_CBC_SHA 0x0300C005 +- +-# define TLS1_CK_ECDHE_ECDSA_WITH_NULL_SHA 0x0300C006 +-# define TLS1_CK_ECDHE_ECDSA_WITH_RC4_128_SHA 0x0300C007 +-# define TLS1_CK_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA 0x0300C008 +-# define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CBC_SHA 0x0300C009 +-# define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CBC_SHA 0x0300C00A +- +-# define TLS1_CK_ECDH_RSA_WITH_NULL_SHA 0x0300C00B +-# define TLS1_CK_ECDH_RSA_WITH_RC4_128_SHA 0x0300C00C +-# define TLS1_CK_ECDH_RSA_WITH_DES_192_CBC3_SHA 0x0300C00D +-# define TLS1_CK_ECDH_RSA_WITH_AES_128_CBC_SHA 0x0300C00E +-# define TLS1_CK_ECDH_RSA_WITH_AES_256_CBC_SHA 0x0300C00F +- +-# define TLS1_CK_ECDHE_RSA_WITH_NULL_SHA 0x0300C010 +-# define TLS1_CK_ECDHE_RSA_WITH_RC4_128_SHA 0x0300C011 +-# define TLS1_CK_ECDHE_RSA_WITH_DES_192_CBC3_SHA 0x0300C012 +-# define TLS1_CK_ECDHE_RSA_WITH_AES_128_CBC_SHA 0x0300C013 +-# define TLS1_CK_ECDHE_RSA_WITH_AES_256_CBC_SHA 0x0300C014 +- +-# define TLS1_CK_ECDH_anon_WITH_NULL_SHA 0x0300C015 +-# define TLS1_CK_ECDH_anon_WITH_RC4_128_SHA 0x0300C016 +-# define TLS1_CK_ECDH_anon_WITH_DES_192_CBC3_SHA 0x0300C017 +-# define TLS1_CK_ECDH_anon_WITH_AES_128_CBC_SHA 0x0300C018 +-# define TLS1_CK_ECDH_anon_WITH_AES_256_CBC_SHA 0x0300C019 +- +-/* SRP ciphersuites from RFC 5054 */ +-# define TLS1_CK_SRP_SHA_WITH_3DES_EDE_CBC_SHA 0x0300C01A +-# define TLS1_CK_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA 0x0300C01B +-# define TLS1_CK_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA 0x0300C01C +-# define TLS1_CK_SRP_SHA_WITH_AES_128_CBC_SHA 0x0300C01D +-# define TLS1_CK_SRP_SHA_RSA_WITH_AES_128_CBC_SHA 0x0300C01E +-# define TLS1_CK_SRP_SHA_DSS_WITH_AES_128_CBC_SHA 0x0300C01F +-# define TLS1_CK_SRP_SHA_WITH_AES_256_CBC_SHA 0x0300C020 +-# define TLS1_CK_SRP_SHA_RSA_WITH_AES_256_CBC_SHA 0x0300C021 +-# define TLS1_CK_SRP_SHA_DSS_WITH_AES_256_CBC_SHA 0x0300C022 +- +-/* ECDH HMAC based ciphersuites from RFC5289 */ +-# define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_SHA256 0x0300C023 +-# define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_SHA384 0x0300C024 +-# define TLS1_CK_ECDH_ECDSA_WITH_AES_128_SHA256 0x0300C025 +-# define TLS1_CK_ECDH_ECDSA_WITH_AES_256_SHA384 0x0300C026 +-# define TLS1_CK_ECDHE_RSA_WITH_AES_128_SHA256 0x0300C027 +-# define TLS1_CK_ECDHE_RSA_WITH_AES_256_SHA384 0x0300C028 +-# define TLS1_CK_ECDH_RSA_WITH_AES_128_SHA256 0x0300C029 +-# define TLS1_CK_ECDH_RSA_WITH_AES_256_SHA384 0x0300C02A +- +-/* ECDH GCM based ciphersuites from RFC5289 */ +-# define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 0x0300C02B +-# define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 0x0300C02C +-# define TLS1_CK_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 0x0300C02D +-# define TLS1_CK_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 0x0300C02E +-# define TLS1_CK_ECDHE_RSA_WITH_AES_128_GCM_SHA256 0x0300C02F +-# define TLS1_CK_ECDHE_RSA_WITH_AES_256_GCM_SHA384 0x0300C030 +-# define TLS1_CK_ECDH_RSA_WITH_AES_128_GCM_SHA256 0x0300C031 +-# define TLS1_CK_ECDH_RSA_WITH_AES_256_GCM_SHA384 0x0300C032 +- +-/* ECDHE PSK ciphersuites from RFC5489 */ +-# define TLS1_CK_ECDHE_PSK_WITH_RC4_128_SHA 0x0300C033 +-# define TLS1_CK_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA 0x0300C034 +-# define TLS1_CK_ECDHE_PSK_WITH_AES_128_CBC_SHA 0x0300C035 +-# define TLS1_CK_ECDHE_PSK_WITH_AES_256_CBC_SHA 0x0300C036 +- +-# define TLS1_CK_ECDHE_PSK_WITH_AES_128_CBC_SHA256 0x0300C037 +-# define TLS1_CK_ECDHE_PSK_WITH_AES_256_CBC_SHA384 0x0300C038 +- +-/* NULL PSK ciphersuites from RFC4785 */ +-# define TLS1_CK_ECDHE_PSK_WITH_NULL_SHA 0x0300C039 +-# define TLS1_CK_ECDHE_PSK_WITH_NULL_SHA256 0x0300C03A +-# define TLS1_CK_ECDHE_PSK_WITH_NULL_SHA384 0x0300C03B +- +-/* Camellia-CBC ciphersuites from RFC6367 */ +-# define TLS1_CK_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 0x0300C072 +-# define TLS1_CK_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 0x0300C073 +-# define TLS1_CK_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 0x0300C074 +-# define TLS1_CK_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 0x0300C075 +-# define TLS1_CK_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 0x0300C076 +-# define TLS1_CK_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384 0x0300C077 +-# define TLS1_CK_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256 0x0300C078 +-# define TLS1_CK_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384 0x0300C079 +- +-# define TLS1_CK_PSK_WITH_CAMELLIA_128_CBC_SHA256 0x0300C094 +-# define TLS1_CK_PSK_WITH_CAMELLIA_256_CBC_SHA384 0x0300C095 +-# define TLS1_CK_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 0x0300C096 +-# define TLS1_CK_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 0x0300C097 +-# define TLS1_CK_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256 0x0300C098 +-# define TLS1_CK_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384 0x0300C099 +-# define TLS1_CK_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 0x0300C09A +-# define TLS1_CK_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 0x0300C09B +- +-/* draft-ietf-tls-chacha20-poly1305-03 */ +-# define TLS1_CK_ECDHE_RSA_WITH_CHACHA20_POLY1305 0x0300CCA8 +-# define TLS1_CK_ECDHE_ECDSA_WITH_CHACHA20_POLY1305 0x0300CCA9 +-# define TLS1_CK_DHE_RSA_WITH_CHACHA20_POLY1305 0x0300CCAA +-# define TLS1_CK_PSK_WITH_CHACHA20_POLY1305 0x0300CCAB +-# define TLS1_CK_ECDHE_PSK_WITH_CHACHA20_POLY1305 0x0300CCAC +-# define TLS1_CK_DHE_PSK_WITH_CHACHA20_POLY1305 0x0300CCAD +-# define TLS1_CK_RSA_PSK_WITH_CHACHA20_POLY1305 0x0300CCAE +- +-/* TLS v1.3 ciphersuites */ +-# define TLS1_3_CK_AES_128_GCM_SHA256 0x03001301 +-# define TLS1_3_CK_AES_256_GCM_SHA384 0x03001302 +-# define TLS1_3_CK_CHACHA20_POLY1305_SHA256 0x03001303 +-# define TLS1_3_CK_AES_128_CCM_SHA256 0x03001304 +-# define TLS1_3_CK_AES_128_CCM_8_SHA256 0x03001305 +- +-/* Aria ciphersuites from RFC6209 */ +-# define TLS1_CK_RSA_WITH_ARIA_128_GCM_SHA256 0x0300C050 +-# define TLS1_CK_RSA_WITH_ARIA_256_GCM_SHA384 0x0300C051 +-# define TLS1_CK_DHE_RSA_WITH_ARIA_128_GCM_SHA256 0x0300C052 +-# define TLS1_CK_DHE_RSA_WITH_ARIA_256_GCM_SHA384 0x0300C053 +-# define TLS1_CK_DH_RSA_WITH_ARIA_128_GCM_SHA256 0x0300C054 +-# define TLS1_CK_DH_RSA_WITH_ARIA_256_GCM_SHA384 0x0300C055 +-# define TLS1_CK_DHE_DSS_WITH_ARIA_128_GCM_SHA256 0x0300C056 +-# define TLS1_CK_DHE_DSS_WITH_ARIA_256_GCM_SHA384 0x0300C057 +-# define TLS1_CK_DH_DSS_WITH_ARIA_128_GCM_SHA256 0x0300C058 +-# define TLS1_CK_DH_DSS_WITH_ARIA_256_GCM_SHA384 0x0300C059 +-# define TLS1_CK_DH_anon_WITH_ARIA_128_GCM_SHA256 0x0300C05A +-# define TLS1_CK_DH_anon_WITH_ARIA_256_GCM_SHA384 0x0300C05B +-# define TLS1_CK_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256 0x0300C05C +-# define TLS1_CK_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384 0x0300C05D +-# define TLS1_CK_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256 0x0300C05E +-# define TLS1_CK_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384 0x0300C05F +-# define TLS1_CK_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256 0x0300C060 +-# define TLS1_CK_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384 0x0300C061 +-# define TLS1_CK_ECDH_RSA_WITH_ARIA_128_GCM_SHA256 0x0300C062 +-# define TLS1_CK_ECDH_RSA_WITH_ARIA_256_GCM_SHA384 0x0300C063 +-# define TLS1_CK_PSK_WITH_ARIA_128_GCM_SHA256 0x0300C06A +-# define TLS1_CK_PSK_WITH_ARIA_256_GCM_SHA384 0x0300C06B +-# define TLS1_CK_DHE_PSK_WITH_ARIA_128_GCM_SHA256 0x0300C06C +-# define TLS1_CK_DHE_PSK_WITH_ARIA_256_GCM_SHA384 0x0300C06D +-# define TLS1_CK_RSA_PSK_WITH_ARIA_128_GCM_SHA256 0x0300C06E +-# define TLS1_CK_RSA_PSK_WITH_ARIA_256_GCM_SHA384 0x0300C06F +- +-/* a bundle of RFC standard cipher names, generated from ssl3_ciphers[] */ +-# define TLS1_RFC_RSA_WITH_AES_128_SHA "TLS_RSA_WITH_AES_128_CBC_SHA" +-# define TLS1_RFC_DHE_DSS_WITH_AES_128_SHA "TLS_DHE_DSS_WITH_AES_128_CBC_SHA" +-# define TLS1_RFC_DHE_RSA_WITH_AES_128_SHA "TLS_DHE_RSA_WITH_AES_128_CBC_SHA" +-# define TLS1_RFC_ADH_WITH_AES_128_SHA "TLS_DH_anon_WITH_AES_128_CBC_SHA" +-# define TLS1_RFC_RSA_WITH_AES_256_SHA "TLS_RSA_WITH_AES_256_CBC_SHA" +-# define TLS1_RFC_DHE_DSS_WITH_AES_256_SHA "TLS_DHE_DSS_WITH_AES_256_CBC_SHA" +-# define TLS1_RFC_DHE_RSA_WITH_AES_256_SHA "TLS_DHE_RSA_WITH_AES_256_CBC_SHA" +-# define TLS1_RFC_ADH_WITH_AES_256_SHA "TLS_DH_anon_WITH_AES_256_CBC_SHA" +-# define TLS1_RFC_RSA_WITH_NULL_SHA256 "TLS_RSA_WITH_NULL_SHA256" +-# define TLS1_RFC_RSA_WITH_AES_128_SHA256 "TLS_RSA_WITH_AES_128_CBC_SHA256" +-# define TLS1_RFC_RSA_WITH_AES_256_SHA256 "TLS_RSA_WITH_AES_256_CBC_SHA256" +-# define TLS1_RFC_DHE_DSS_WITH_AES_128_SHA256 "TLS_DHE_DSS_WITH_AES_128_CBC_SHA256" +-# define TLS1_RFC_DHE_RSA_WITH_AES_128_SHA256 "TLS_DHE_RSA_WITH_AES_128_CBC_SHA256" +-# define TLS1_RFC_DHE_DSS_WITH_AES_256_SHA256 "TLS_DHE_DSS_WITH_AES_256_CBC_SHA256" +-# define TLS1_RFC_DHE_RSA_WITH_AES_256_SHA256 "TLS_DHE_RSA_WITH_AES_256_CBC_SHA256" +-# define TLS1_RFC_ADH_WITH_AES_128_SHA256 "TLS_DH_anon_WITH_AES_128_CBC_SHA256" +-# define TLS1_RFC_ADH_WITH_AES_256_SHA256 "TLS_DH_anon_WITH_AES_256_CBC_SHA256" +-# define TLS1_RFC_RSA_WITH_AES_128_GCM_SHA256 "TLS_RSA_WITH_AES_128_GCM_SHA256" +-# define TLS1_RFC_RSA_WITH_AES_256_GCM_SHA384 "TLS_RSA_WITH_AES_256_GCM_SHA384" +-# define TLS1_RFC_DHE_RSA_WITH_AES_128_GCM_SHA256 "TLS_DHE_RSA_WITH_AES_128_GCM_SHA256" +-# define TLS1_RFC_DHE_RSA_WITH_AES_256_GCM_SHA384 "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384" +-# define TLS1_RFC_DHE_DSS_WITH_AES_128_GCM_SHA256 "TLS_DHE_DSS_WITH_AES_128_GCM_SHA256" +-# define TLS1_RFC_DHE_DSS_WITH_AES_256_GCM_SHA384 "TLS_DHE_DSS_WITH_AES_256_GCM_SHA384" +-# define TLS1_RFC_ADH_WITH_AES_128_GCM_SHA256 "TLS_DH_anon_WITH_AES_128_GCM_SHA256" +-# define TLS1_RFC_ADH_WITH_AES_256_GCM_SHA384 "TLS_DH_anon_WITH_AES_256_GCM_SHA384" +-# define TLS1_RFC_RSA_WITH_AES_128_CCM "TLS_RSA_WITH_AES_128_CCM" +-# define TLS1_RFC_RSA_WITH_AES_256_CCM "TLS_RSA_WITH_AES_256_CCM" +-# define TLS1_RFC_DHE_RSA_WITH_AES_128_CCM "TLS_DHE_RSA_WITH_AES_128_CCM" +-# define TLS1_RFC_DHE_RSA_WITH_AES_256_CCM "TLS_DHE_RSA_WITH_AES_256_CCM" +-# define TLS1_RFC_RSA_WITH_AES_128_CCM_8 "TLS_RSA_WITH_AES_128_CCM_8" +-# define TLS1_RFC_RSA_WITH_AES_256_CCM_8 "TLS_RSA_WITH_AES_256_CCM_8" +-# define TLS1_RFC_DHE_RSA_WITH_AES_128_CCM_8 "TLS_DHE_RSA_WITH_AES_128_CCM_8" +-# define TLS1_RFC_DHE_RSA_WITH_AES_256_CCM_8 "TLS_DHE_RSA_WITH_AES_256_CCM_8" +-# define TLS1_RFC_PSK_WITH_AES_128_CCM "TLS_PSK_WITH_AES_128_CCM" +-# define TLS1_RFC_PSK_WITH_AES_256_CCM "TLS_PSK_WITH_AES_256_CCM" +-# define TLS1_RFC_DHE_PSK_WITH_AES_128_CCM "TLS_DHE_PSK_WITH_AES_128_CCM" +-# define TLS1_RFC_DHE_PSK_WITH_AES_256_CCM "TLS_DHE_PSK_WITH_AES_256_CCM" +-# define TLS1_RFC_PSK_WITH_AES_128_CCM_8 "TLS_PSK_WITH_AES_128_CCM_8" +-# define TLS1_RFC_PSK_WITH_AES_256_CCM_8 "TLS_PSK_WITH_AES_256_CCM_8" +-# define TLS1_RFC_DHE_PSK_WITH_AES_128_CCM_8 "TLS_PSK_DHE_WITH_AES_128_CCM_8" +-# define TLS1_RFC_DHE_PSK_WITH_AES_256_CCM_8 "TLS_PSK_DHE_WITH_AES_256_CCM_8" +-# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CCM "TLS_ECDHE_ECDSA_WITH_AES_128_CCM" +-# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CCM "TLS_ECDHE_ECDSA_WITH_AES_256_CCM" +-# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CCM_8 "TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8" +-# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CCM_8 "TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8" +-# define TLS1_3_RFC_AES_128_GCM_SHA256 "TLS_AES_128_GCM_SHA256" +-# define TLS1_3_RFC_AES_256_GCM_SHA384 "TLS_AES_256_GCM_SHA384" +-# define TLS1_3_RFC_CHACHA20_POLY1305_SHA256 "TLS_CHACHA20_POLY1305_SHA256" +-# define TLS1_3_RFC_AES_128_CCM_SHA256 "TLS_AES_128_CCM_SHA256" +-# define TLS1_3_RFC_AES_128_CCM_8_SHA256 "TLS_AES_128_CCM_8_SHA256" +-# define TLS1_RFC_ECDHE_ECDSA_WITH_NULL_SHA "TLS_ECDHE_ECDSA_WITH_NULL_SHA" +-# define TLS1_RFC_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA" +-# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CBC_SHA "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA" +-# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CBC_SHA "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA" +-# define TLS1_RFC_ECDHE_RSA_WITH_NULL_SHA "TLS_ECDHE_RSA_WITH_NULL_SHA" +-# define TLS1_RFC_ECDHE_RSA_WITH_DES_192_CBC3_SHA "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA" +-# define TLS1_RFC_ECDHE_RSA_WITH_AES_128_CBC_SHA "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA" +-# define TLS1_RFC_ECDHE_RSA_WITH_AES_256_CBC_SHA "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA" +-# define TLS1_RFC_ECDH_anon_WITH_NULL_SHA "TLS_ECDH_anon_WITH_NULL_SHA" +-# define TLS1_RFC_ECDH_anon_WITH_DES_192_CBC3_SHA "TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA" +-# define TLS1_RFC_ECDH_anon_WITH_AES_128_CBC_SHA "TLS_ECDH_anon_WITH_AES_128_CBC_SHA" +-# define TLS1_RFC_ECDH_anon_WITH_AES_256_CBC_SHA "TLS_ECDH_anon_WITH_AES_256_CBC_SHA" +-# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_SHA256 "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256" +-# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_SHA384 "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384" +-# define TLS1_RFC_ECDHE_RSA_WITH_AES_128_SHA256 "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256" +-# define TLS1_RFC_ECDHE_RSA_WITH_AES_256_SHA384 "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384" +-# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256" +-# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384" +-# define TLS1_RFC_ECDHE_RSA_WITH_AES_128_GCM_SHA256 "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256" +-# define TLS1_RFC_ECDHE_RSA_WITH_AES_256_GCM_SHA384 "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384" +-# define TLS1_RFC_PSK_WITH_NULL_SHA "TLS_PSK_WITH_NULL_SHA" +-# define TLS1_RFC_DHE_PSK_WITH_NULL_SHA "TLS_DHE_PSK_WITH_NULL_SHA" +-# define TLS1_RFC_RSA_PSK_WITH_NULL_SHA "TLS_RSA_PSK_WITH_NULL_SHA" +-# define TLS1_RFC_PSK_WITH_3DES_EDE_CBC_SHA "TLS_PSK_WITH_3DES_EDE_CBC_SHA" +-# define TLS1_RFC_PSK_WITH_AES_128_CBC_SHA "TLS_PSK_WITH_AES_128_CBC_SHA" +-# define TLS1_RFC_PSK_WITH_AES_256_CBC_SHA "TLS_PSK_WITH_AES_256_CBC_SHA" +-# define TLS1_RFC_DHE_PSK_WITH_3DES_EDE_CBC_SHA "TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA" +-# define TLS1_RFC_DHE_PSK_WITH_AES_128_CBC_SHA "TLS_DHE_PSK_WITH_AES_128_CBC_SHA" +-# define TLS1_RFC_DHE_PSK_WITH_AES_256_CBC_SHA "TLS_DHE_PSK_WITH_AES_256_CBC_SHA" +-# define TLS1_RFC_RSA_PSK_WITH_3DES_EDE_CBC_SHA "TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA" +-# define TLS1_RFC_RSA_PSK_WITH_AES_128_CBC_SHA "TLS_RSA_PSK_WITH_AES_128_CBC_SHA" +-# define TLS1_RFC_RSA_PSK_WITH_AES_256_CBC_SHA "TLS_RSA_PSK_WITH_AES_256_CBC_SHA" +-# define TLS1_RFC_PSK_WITH_AES_128_GCM_SHA256 "TLS_PSK_WITH_AES_128_GCM_SHA256" +-# define TLS1_RFC_PSK_WITH_AES_256_GCM_SHA384 "TLS_PSK_WITH_AES_256_GCM_SHA384" +-# define TLS1_RFC_DHE_PSK_WITH_AES_128_GCM_SHA256 "TLS_DHE_PSK_WITH_AES_128_GCM_SHA256" +-# define TLS1_RFC_DHE_PSK_WITH_AES_256_GCM_SHA384 "TLS_DHE_PSK_WITH_AES_256_GCM_SHA384" +-# define TLS1_RFC_RSA_PSK_WITH_AES_128_GCM_SHA256 "TLS_RSA_PSK_WITH_AES_128_GCM_SHA256" +-# define TLS1_RFC_RSA_PSK_WITH_AES_256_GCM_SHA384 "TLS_RSA_PSK_WITH_AES_256_GCM_SHA384" +-# define TLS1_RFC_PSK_WITH_AES_128_CBC_SHA256 "TLS_PSK_WITH_AES_128_CBC_SHA256" +-# define TLS1_RFC_PSK_WITH_AES_256_CBC_SHA384 "TLS_PSK_WITH_AES_256_CBC_SHA384" +-# define TLS1_RFC_PSK_WITH_NULL_SHA256 "TLS_PSK_WITH_NULL_SHA256" +-# define TLS1_RFC_PSK_WITH_NULL_SHA384 "TLS_PSK_WITH_NULL_SHA384" +-# define TLS1_RFC_DHE_PSK_WITH_AES_128_CBC_SHA256 "TLS_DHE_PSK_WITH_AES_128_CBC_SHA256" +-# define TLS1_RFC_DHE_PSK_WITH_AES_256_CBC_SHA384 "TLS_DHE_PSK_WITH_AES_256_CBC_SHA384" +-# define TLS1_RFC_DHE_PSK_WITH_NULL_SHA256 "TLS_DHE_PSK_WITH_NULL_SHA256" +-# define TLS1_RFC_DHE_PSK_WITH_NULL_SHA384 "TLS_DHE_PSK_WITH_NULL_SHA384" +-# define TLS1_RFC_RSA_PSK_WITH_AES_128_CBC_SHA256 "TLS_RSA_PSK_WITH_AES_128_CBC_SHA256" +-# define TLS1_RFC_RSA_PSK_WITH_AES_256_CBC_SHA384 "TLS_RSA_PSK_WITH_AES_256_CBC_SHA384" +-# define TLS1_RFC_RSA_PSK_WITH_NULL_SHA256 "TLS_RSA_PSK_WITH_NULL_SHA256" +-# define TLS1_RFC_RSA_PSK_WITH_NULL_SHA384 "TLS_RSA_PSK_WITH_NULL_SHA384" +-# define TLS1_RFC_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA "TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA" +-# define TLS1_RFC_ECDHE_PSK_WITH_AES_128_CBC_SHA "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA" +-# define TLS1_RFC_ECDHE_PSK_WITH_AES_256_CBC_SHA "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA" +-# define TLS1_RFC_ECDHE_PSK_WITH_AES_128_CBC_SHA256 "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256" +-# define TLS1_RFC_ECDHE_PSK_WITH_AES_256_CBC_SHA384 "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384" +-# define TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA "TLS_ECDHE_PSK_WITH_NULL_SHA" +-# define TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA256 "TLS_ECDHE_PSK_WITH_NULL_SHA256" +-# define TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA384 "TLS_ECDHE_PSK_WITH_NULL_SHA384" +-# define TLS1_RFC_SRP_SHA_WITH_3DES_EDE_CBC_SHA "TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA" +-# define TLS1_RFC_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA "TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA" +-# define TLS1_RFC_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA "TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA" +-# define TLS1_RFC_SRP_SHA_WITH_AES_128_CBC_SHA "TLS_SRP_SHA_WITH_AES_128_CBC_SHA" +-# define TLS1_RFC_SRP_SHA_RSA_WITH_AES_128_CBC_SHA "TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA" +-# define TLS1_RFC_SRP_SHA_DSS_WITH_AES_128_CBC_SHA "TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA" +-# define TLS1_RFC_SRP_SHA_WITH_AES_256_CBC_SHA "TLS_SRP_SHA_WITH_AES_256_CBC_SHA" +-# define TLS1_RFC_SRP_SHA_RSA_WITH_AES_256_CBC_SHA "TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA" +-# define TLS1_RFC_SRP_SHA_DSS_WITH_AES_256_CBC_SHA "TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA" +-# define TLS1_RFC_DHE_RSA_WITH_CHACHA20_POLY1305 "TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256" +-# define TLS1_RFC_ECDHE_RSA_WITH_CHACHA20_POLY1305 "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256" +-# define TLS1_RFC_ECDHE_ECDSA_WITH_CHACHA20_POLY1305 "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256" +-# define TLS1_RFC_PSK_WITH_CHACHA20_POLY1305 "TLS_PSK_WITH_CHACHA20_POLY1305_SHA256" +-# define TLS1_RFC_ECDHE_PSK_WITH_CHACHA20_POLY1305 "TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256" +-# define TLS1_RFC_DHE_PSK_WITH_CHACHA20_POLY1305 "TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256" +-# define TLS1_RFC_RSA_PSK_WITH_CHACHA20_POLY1305 "TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256" +-# define TLS1_RFC_RSA_WITH_CAMELLIA_128_CBC_SHA256 "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256" +-# define TLS1_RFC_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256 "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256" +-# define TLS1_RFC_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256" +-# define TLS1_RFC_ADH_WITH_CAMELLIA_128_CBC_SHA256 "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256" +-# define TLS1_RFC_RSA_WITH_CAMELLIA_256_CBC_SHA256 "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256" +-# define TLS1_RFC_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256 "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256" +-# define TLS1_RFC_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256 "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256" +-# define TLS1_RFC_ADH_WITH_CAMELLIA_256_CBC_SHA256 "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256" +-# define TLS1_RFC_RSA_WITH_CAMELLIA_256_CBC_SHA "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA" +-# define TLS1_RFC_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA" +-# define TLS1_RFC_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA" +-# define TLS1_RFC_ADH_WITH_CAMELLIA_256_CBC_SHA "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA" +-# define TLS1_RFC_RSA_WITH_CAMELLIA_128_CBC_SHA "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA" +-# define TLS1_RFC_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA" +-# define TLS1_RFC_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA" +-# define TLS1_RFC_ADH_WITH_CAMELLIA_128_CBC_SHA "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA" +-# define TLS1_RFC_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 "TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256" +-# define TLS1_RFC_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 "TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384" +-# define TLS1_RFC_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 "TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256" +-# define TLS1_RFC_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384 "TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384" +-# define TLS1_RFC_PSK_WITH_CAMELLIA_128_CBC_SHA256 "TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256" +-# define TLS1_RFC_PSK_WITH_CAMELLIA_256_CBC_SHA384 "TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384" +-# define TLS1_RFC_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 "TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256" +-# define TLS1_RFC_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 "TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384" +-# define TLS1_RFC_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256 "TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256" +-# define TLS1_RFC_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384 "TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384" +-# define TLS1_RFC_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 "TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256" +-# define TLS1_RFC_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 "TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384" +-# define TLS1_RFC_RSA_WITH_SEED_SHA "TLS_RSA_WITH_SEED_CBC_SHA" +-# define TLS1_RFC_DHE_DSS_WITH_SEED_SHA "TLS_DHE_DSS_WITH_SEED_CBC_SHA" +-# define TLS1_RFC_DHE_RSA_WITH_SEED_SHA "TLS_DHE_RSA_WITH_SEED_CBC_SHA" +-# define TLS1_RFC_ADH_WITH_SEED_SHA "TLS_DH_anon_WITH_SEED_CBC_SHA" +-# define TLS1_RFC_ECDHE_PSK_WITH_RC4_128_SHA "TLS_ECDHE_PSK_WITH_RC4_128_SHA" +-# define TLS1_RFC_ECDH_anon_WITH_RC4_128_SHA "TLS_ECDH_anon_WITH_RC4_128_SHA" +-# define TLS1_RFC_ECDHE_ECDSA_WITH_RC4_128_SHA "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA" +-# define TLS1_RFC_ECDHE_RSA_WITH_RC4_128_SHA "TLS_ECDHE_RSA_WITH_RC4_128_SHA" +-# define TLS1_RFC_PSK_WITH_RC4_128_SHA "TLS_PSK_WITH_RC4_128_SHA" +-# define TLS1_RFC_RSA_PSK_WITH_RC4_128_SHA "TLS_RSA_PSK_WITH_RC4_128_SHA" +-# define TLS1_RFC_DHE_PSK_WITH_RC4_128_SHA "TLS_DHE_PSK_WITH_RC4_128_SHA" +-# define TLS1_RFC_RSA_WITH_ARIA_128_GCM_SHA256 "TLS_RSA_WITH_ARIA_128_GCM_SHA256" +-# define TLS1_RFC_RSA_WITH_ARIA_256_GCM_SHA384 "TLS_RSA_WITH_ARIA_256_GCM_SHA384" +-# define TLS1_RFC_DHE_RSA_WITH_ARIA_128_GCM_SHA256 "TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256" +-# define TLS1_RFC_DHE_RSA_WITH_ARIA_256_GCM_SHA384 "TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384" +-# define TLS1_RFC_DH_RSA_WITH_ARIA_128_GCM_SHA256 "TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256" +-# define TLS1_RFC_DH_RSA_WITH_ARIA_256_GCM_SHA384 "TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384" +-# define TLS1_RFC_DHE_DSS_WITH_ARIA_128_GCM_SHA256 "TLS_DHE_DSS_WITH_ARIA_128_GCM_SHA256" +-# define TLS1_RFC_DHE_DSS_WITH_ARIA_256_GCM_SHA384 "TLS_DHE_DSS_WITH_ARIA_256_GCM_SHA384" +-# define TLS1_RFC_DH_DSS_WITH_ARIA_128_GCM_SHA256 "TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256" +-# define TLS1_RFC_DH_DSS_WITH_ARIA_256_GCM_SHA384 "TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384" +-# define TLS1_RFC_DH_anon_WITH_ARIA_128_GCM_SHA256 "TLS_DH_anon_WITH_ARIA_128_GCM_SHA256" +-# define TLS1_RFC_DH_anon_WITH_ARIA_256_GCM_SHA384 "TLS_DH_anon_WITH_ARIA_256_GCM_SHA384" +-# define TLS1_RFC_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256 "TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256" +-# define TLS1_RFC_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384 "TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384" +-# define TLS1_RFC_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256 "TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256" +-# define TLS1_RFC_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384 "TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384" +-# define TLS1_RFC_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256 "TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256" +-# define TLS1_RFC_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384 "TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384" +-# define TLS1_RFC_ECDH_RSA_WITH_ARIA_128_GCM_SHA256 "TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256" +-# define TLS1_RFC_ECDH_RSA_WITH_ARIA_256_GCM_SHA384 "TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384" +-# define TLS1_RFC_PSK_WITH_ARIA_128_GCM_SHA256 "TLS_PSK_WITH_ARIA_128_GCM_SHA256" +-# define TLS1_RFC_PSK_WITH_ARIA_256_GCM_SHA384 "TLS_PSK_WITH_ARIA_256_GCM_SHA384" +-# define TLS1_RFC_DHE_PSK_WITH_ARIA_128_GCM_SHA256 "TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256" +-# define TLS1_RFC_DHE_PSK_WITH_ARIA_256_GCM_SHA384 "TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384" +-# define TLS1_RFC_RSA_PSK_WITH_ARIA_128_GCM_SHA256 "TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256" +-# define TLS1_RFC_RSA_PSK_WITH_ARIA_256_GCM_SHA384 "TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384" +- +- +-/* +- * XXX Backward compatibility alert: Older versions of OpenSSL gave some DHE +- * ciphers names with "EDH" instead of "DHE". Going forward, we should be +- * using DHE everywhere, though we may indefinitely maintain aliases for +- * users or configurations that used "EDH" +- */ +-# define TLS1_TXT_DHE_DSS_WITH_RC4_128_SHA "DHE-DSS-RC4-SHA" +- +-# define TLS1_TXT_PSK_WITH_NULL_SHA "PSK-NULL-SHA" +-# define TLS1_TXT_DHE_PSK_WITH_NULL_SHA "DHE-PSK-NULL-SHA" +-# define TLS1_TXT_RSA_PSK_WITH_NULL_SHA "RSA-PSK-NULL-SHA" +- +-/* AES ciphersuites from RFC3268 */ +-# define TLS1_TXT_RSA_WITH_AES_128_SHA "AES128-SHA" +-# define TLS1_TXT_DH_DSS_WITH_AES_128_SHA "DH-DSS-AES128-SHA" +-# define TLS1_TXT_DH_RSA_WITH_AES_128_SHA "DH-RSA-AES128-SHA" +-# define TLS1_TXT_DHE_DSS_WITH_AES_128_SHA "DHE-DSS-AES128-SHA" +-# define TLS1_TXT_DHE_RSA_WITH_AES_128_SHA "DHE-RSA-AES128-SHA" +-# define TLS1_TXT_ADH_WITH_AES_128_SHA "ADH-AES128-SHA" +- +-# define TLS1_TXT_RSA_WITH_AES_256_SHA "AES256-SHA" +-# define TLS1_TXT_DH_DSS_WITH_AES_256_SHA "DH-DSS-AES256-SHA" +-# define TLS1_TXT_DH_RSA_WITH_AES_256_SHA "DH-RSA-AES256-SHA" +-# define TLS1_TXT_DHE_DSS_WITH_AES_256_SHA "DHE-DSS-AES256-SHA" +-# define TLS1_TXT_DHE_RSA_WITH_AES_256_SHA "DHE-RSA-AES256-SHA" +-# define TLS1_TXT_ADH_WITH_AES_256_SHA "ADH-AES256-SHA" +- +-/* ECC ciphersuites from RFC4492 */ +-# define TLS1_TXT_ECDH_ECDSA_WITH_NULL_SHA "ECDH-ECDSA-NULL-SHA" +-# define TLS1_TXT_ECDH_ECDSA_WITH_RC4_128_SHA "ECDH-ECDSA-RC4-SHA" +-# define TLS1_TXT_ECDH_ECDSA_WITH_DES_192_CBC3_SHA "ECDH-ECDSA-DES-CBC3-SHA" +-# define TLS1_TXT_ECDH_ECDSA_WITH_AES_128_CBC_SHA "ECDH-ECDSA-AES128-SHA" +-# define TLS1_TXT_ECDH_ECDSA_WITH_AES_256_CBC_SHA "ECDH-ECDSA-AES256-SHA" +- +-# define TLS1_TXT_ECDHE_ECDSA_WITH_NULL_SHA "ECDHE-ECDSA-NULL-SHA" +-# define TLS1_TXT_ECDHE_ECDSA_WITH_RC4_128_SHA "ECDHE-ECDSA-RC4-SHA" +-# define TLS1_TXT_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA "ECDHE-ECDSA-DES-CBC3-SHA" +-# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CBC_SHA "ECDHE-ECDSA-AES128-SHA" +-# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CBC_SHA "ECDHE-ECDSA-AES256-SHA" +- +-# define TLS1_TXT_ECDH_RSA_WITH_NULL_SHA "ECDH-RSA-NULL-SHA" +-# define TLS1_TXT_ECDH_RSA_WITH_RC4_128_SHA "ECDH-RSA-RC4-SHA" +-# define TLS1_TXT_ECDH_RSA_WITH_DES_192_CBC3_SHA "ECDH-RSA-DES-CBC3-SHA" +-# define TLS1_TXT_ECDH_RSA_WITH_AES_128_CBC_SHA "ECDH-RSA-AES128-SHA" +-# define TLS1_TXT_ECDH_RSA_WITH_AES_256_CBC_SHA "ECDH-RSA-AES256-SHA" +- +-# define TLS1_TXT_ECDHE_RSA_WITH_NULL_SHA "ECDHE-RSA-NULL-SHA" +-# define TLS1_TXT_ECDHE_RSA_WITH_RC4_128_SHA "ECDHE-RSA-RC4-SHA" +-# define TLS1_TXT_ECDHE_RSA_WITH_DES_192_CBC3_SHA "ECDHE-RSA-DES-CBC3-SHA" +-# define TLS1_TXT_ECDHE_RSA_WITH_AES_128_CBC_SHA "ECDHE-RSA-AES128-SHA" +-# define TLS1_TXT_ECDHE_RSA_WITH_AES_256_CBC_SHA "ECDHE-RSA-AES256-SHA" +- +-# define TLS1_TXT_ECDH_anon_WITH_NULL_SHA "AECDH-NULL-SHA" +-# define TLS1_TXT_ECDH_anon_WITH_RC4_128_SHA "AECDH-RC4-SHA" +-# define TLS1_TXT_ECDH_anon_WITH_DES_192_CBC3_SHA "AECDH-DES-CBC3-SHA" +-# define TLS1_TXT_ECDH_anon_WITH_AES_128_CBC_SHA "AECDH-AES128-SHA" +-# define TLS1_TXT_ECDH_anon_WITH_AES_256_CBC_SHA "AECDH-AES256-SHA" +- +-/* PSK ciphersuites from RFC 4279 */ +-# define TLS1_TXT_PSK_WITH_RC4_128_SHA "PSK-RC4-SHA" +-# define TLS1_TXT_PSK_WITH_3DES_EDE_CBC_SHA "PSK-3DES-EDE-CBC-SHA" +-# define TLS1_TXT_PSK_WITH_AES_128_CBC_SHA "PSK-AES128-CBC-SHA" +-# define TLS1_TXT_PSK_WITH_AES_256_CBC_SHA "PSK-AES256-CBC-SHA" +- +-# define TLS1_TXT_DHE_PSK_WITH_RC4_128_SHA "DHE-PSK-RC4-SHA" +-# define TLS1_TXT_DHE_PSK_WITH_3DES_EDE_CBC_SHA "DHE-PSK-3DES-EDE-CBC-SHA" +-# define TLS1_TXT_DHE_PSK_WITH_AES_128_CBC_SHA "DHE-PSK-AES128-CBC-SHA" +-# define TLS1_TXT_DHE_PSK_WITH_AES_256_CBC_SHA "DHE-PSK-AES256-CBC-SHA" +-# define TLS1_TXT_RSA_PSK_WITH_RC4_128_SHA "RSA-PSK-RC4-SHA" +-# define TLS1_TXT_RSA_PSK_WITH_3DES_EDE_CBC_SHA "RSA-PSK-3DES-EDE-CBC-SHA" +-# define TLS1_TXT_RSA_PSK_WITH_AES_128_CBC_SHA "RSA-PSK-AES128-CBC-SHA" +-# define TLS1_TXT_RSA_PSK_WITH_AES_256_CBC_SHA "RSA-PSK-AES256-CBC-SHA" +- +-/* PSK ciphersuites from RFC 5487 */ +-# define TLS1_TXT_PSK_WITH_AES_128_GCM_SHA256 "PSK-AES128-GCM-SHA256" +-# define TLS1_TXT_PSK_WITH_AES_256_GCM_SHA384 "PSK-AES256-GCM-SHA384" +-# define TLS1_TXT_DHE_PSK_WITH_AES_128_GCM_SHA256 "DHE-PSK-AES128-GCM-SHA256" +-# define TLS1_TXT_DHE_PSK_WITH_AES_256_GCM_SHA384 "DHE-PSK-AES256-GCM-SHA384" +-# define TLS1_TXT_RSA_PSK_WITH_AES_128_GCM_SHA256 "RSA-PSK-AES128-GCM-SHA256" +-# define TLS1_TXT_RSA_PSK_WITH_AES_256_GCM_SHA384 "RSA-PSK-AES256-GCM-SHA384" +- +-# define TLS1_TXT_PSK_WITH_AES_128_CBC_SHA256 "PSK-AES128-CBC-SHA256" +-# define TLS1_TXT_PSK_WITH_AES_256_CBC_SHA384 "PSK-AES256-CBC-SHA384" +-# define TLS1_TXT_PSK_WITH_NULL_SHA256 "PSK-NULL-SHA256" +-# define TLS1_TXT_PSK_WITH_NULL_SHA384 "PSK-NULL-SHA384" +- +-# define TLS1_TXT_DHE_PSK_WITH_AES_128_CBC_SHA256 "DHE-PSK-AES128-CBC-SHA256" +-# define TLS1_TXT_DHE_PSK_WITH_AES_256_CBC_SHA384 "DHE-PSK-AES256-CBC-SHA384" +-# define TLS1_TXT_DHE_PSK_WITH_NULL_SHA256 "DHE-PSK-NULL-SHA256" +-# define TLS1_TXT_DHE_PSK_WITH_NULL_SHA384 "DHE-PSK-NULL-SHA384" +- +-# define TLS1_TXT_RSA_PSK_WITH_AES_128_CBC_SHA256 "RSA-PSK-AES128-CBC-SHA256" +-# define TLS1_TXT_RSA_PSK_WITH_AES_256_CBC_SHA384 "RSA-PSK-AES256-CBC-SHA384" +-# define TLS1_TXT_RSA_PSK_WITH_NULL_SHA256 "RSA-PSK-NULL-SHA256" +-# define TLS1_TXT_RSA_PSK_WITH_NULL_SHA384 "RSA-PSK-NULL-SHA384" +- +-/* SRP ciphersuite from RFC 5054 */ +-# define TLS1_TXT_SRP_SHA_WITH_3DES_EDE_CBC_SHA "SRP-3DES-EDE-CBC-SHA" +-# define TLS1_TXT_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA "SRP-RSA-3DES-EDE-CBC-SHA" +-# define TLS1_TXT_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA "SRP-DSS-3DES-EDE-CBC-SHA" +-# define TLS1_TXT_SRP_SHA_WITH_AES_128_CBC_SHA "SRP-AES-128-CBC-SHA" +-# define TLS1_TXT_SRP_SHA_RSA_WITH_AES_128_CBC_SHA "SRP-RSA-AES-128-CBC-SHA" +-# define TLS1_TXT_SRP_SHA_DSS_WITH_AES_128_CBC_SHA "SRP-DSS-AES-128-CBC-SHA" +-# define TLS1_TXT_SRP_SHA_WITH_AES_256_CBC_SHA "SRP-AES-256-CBC-SHA" +-# define TLS1_TXT_SRP_SHA_RSA_WITH_AES_256_CBC_SHA "SRP-RSA-AES-256-CBC-SHA" +-# define TLS1_TXT_SRP_SHA_DSS_WITH_AES_256_CBC_SHA "SRP-DSS-AES-256-CBC-SHA" +- +-/* Camellia ciphersuites from RFC4132 */ +-# define TLS1_TXT_RSA_WITH_CAMELLIA_128_CBC_SHA "CAMELLIA128-SHA" +-# define TLS1_TXT_DH_DSS_WITH_CAMELLIA_128_CBC_SHA "DH-DSS-CAMELLIA128-SHA" +-# define TLS1_TXT_DH_RSA_WITH_CAMELLIA_128_CBC_SHA "DH-RSA-CAMELLIA128-SHA" +-# define TLS1_TXT_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA "DHE-DSS-CAMELLIA128-SHA" +-# define TLS1_TXT_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA "DHE-RSA-CAMELLIA128-SHA" +-# define TLS1_TXT_ADH_WITH_CAMELLIA_128_CBC_SHA "ADH-CAMELLIA128-SHA" +- +-# define TLS1_TXT_RSA_WITH_CAMELLIA_256_CBC_SHA "CAMELLIA256-SHA" +-# define TLS1_TXT_DH_DSS_WITH_CAMELLIA_256_CBC_SHA "DH-DSS-CAMELLIA256-SHA" +-# define TLS1_TXT_DH_RSA_WITH_CAMELLIA_256_CBC_SHA "DH-RSA-CAMELLIA256-SHA" +-# define TLS1_TXT_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA "DHE-DSS-CAMELLIA256-SHA" +-# define TLS1_TXT_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA "DHE-RSA-CAMELLIA256-SHA" +-# define TLS1_TXT_ADH_WITH_CAMELLIA_256_CBC_SHA "ADH-CAMELLIA256-SHA" +- +-/* TLS 1.2 Camellia SHA-256 ciphersuites from RFC5932 */ +-# define TLS1_TXT_RSA_WITH_CAMELLIA_128_CBC_SHA256 "CAMELLIA128-SHA256" +-# define TLS1_TXT_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256 "DH-DSS-CAMELLIA128-SHA256" +-# define TLS1_TXT_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256 "DH-RSA-CAMELLIA128-SHA256" +-# define TLS1_TXT_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256 "DHE-DSS-CAMELLIA128-SHA256" +-# define TLS1_TXT_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 "DHE-RSA-CAMELLIA128-SHA256" +-# define TLS1_TXT_ADH_WITH_CAMELLIA_128_CBC_SHA256 "ADH-CAMELLIA128-SHA256" +- +-# define TLS1_TXT_RSA_WITH_CAMELLIA_256_CBC_SHA256 "CAMELLIA256-SHA256" +-# define TLS1_TXT_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256 "DH-DSS-CAMELLIA256-SHA256" +-# define TLS1_TXT_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256 "DH-RSA-CAMELLIA256-SHA256" +-# define TLS1_TXT_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256 "DHE-DSS-CAMELLIA256-SHA256" +-# define TLS1_TXT_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256 "DHE-RSA-CAMELLIA256-SHA256" +-# define TLS1_TXT_ADH_WITH_CAMELLIA_256_CBC_SHA256 "ADH-CAMELLIA256-SHA256" +- +-# define TLS1_TXT_PSK_WITH_CAMELLIA_128_CBC_SHA256 "PSK-CAMELLIA128-SHA256" +-# define TLS1_TXT_PSK_WITH_CAMELLIA_256_CBC_SHA384 "PSK-CAMELLIA256-SHA384" +-# define TLS1_TXT_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 "DHE-PSK-CAMELLIA128-SHA256" +-# define TLS1_TXT_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 "DHE-PSK-CAMELLIA256-SHA384" +-# define TLS1_TXT_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256 "RSA-PSK-CAMELLIA128-SHA256" +-# define TLS1_TXT_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384 "RSA-PSK-CAMELLIA256-SHA384" +-# define TLS1_TXT_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 "ECDHE-PSK-CAMELLIA128-SHA256" +-# define TLS1_TXT_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 "ECDHE-PSK-CAMELLIA256-SHA384" +- +-/* SEED ciphersuites from RFC4162 */ +-# define TLS1_TXT_RSA_WITH_SEED_SHA "SEED-SHA" +-# define TLS1_TXT_DH_DSS_WITH_SEED_SHA "DH-DSS-SEED-SHA" +-# define TLS1_TXT_DH_RSA_WITH_SEED_SHA "DH-RSA-SEED-SHA" +-# define TLS1_TXT_DHE_DSS_WITH_SEED_SHA "DHE-DSS-SEED-SHA" +-# define TLS1_TXT_DHE_RSA_WITH_SEED_SHA "DHE-RSA-SEED-SHA" +-# define TLS1_TXT_ADH_WITH_SEED_SHA "ADH-SEED-SHA" +- +-/* TLS v1.2 ciphersuites */ +-# define TLS1_TXT_RSA_WITH_NULL_SHA256 "NULL-SHA256" +-# define TLS1_TXT_RSA_WITH_AES_128_SHA256 "AES128-SHA256" +-# define TLS1_TXT_RSA_WITH_AES_256_SHA256 "AES256-SHA256" +-# define TLS1_TXT_DH_DSS_WITH_AES_128_SHA256 "DH-DSS-AES128-SHA256" +-# define TLS1_TXT_DH_RSA_WITH_AES_128_SHA256 "DH-RSA-AES128-SHA256" +-# define TLS1_TXT_DHE_DSS_WITH_AES_128_SHA256 "DHE-DSS-AES128-SHA256" +-# define TLS1_TXT_DHE_RSA_WITH_AES_128_SHA256 "DHE-RSA-AES128-SHA256" +-# define TLS1_TXT_DH_DSS_WITH_AES_256_SHA256 "DH-DSS-AES256-SHA256" +-# define TLS1_TXT_DH_RSA_WITH_AES_256_SHA256 "DH-RSA-AES256-SHA256" +-# define TLS1_TXT_DHE_DSS_WITH_AES_256_SHA256 "DHE-DSS-AES256-SHA256" +-# define TLS1_TXT_DHE_RSA_WITH_AES_256_SHA256 "DHE-RSA-AES256-SHA256" +-# define TLS1_TXT_ADH_WITH_AES_128_SHA256 "ADH-AES128-SHA256" +-# define TLS1_TXT_ADH_WITH_AES_256_SHA256 "ADH-AES256-SHA256" +- +-/* TLS v1.2 GCM ciphersuites from RFC5288 */ +-# define TLS1_TXT_RSA_WITH_AES_128_GCM_SHA256 "AES128-GCM-SHA256" +-# define TLS1_TXT_RSA_WITH_AES_256_GCM_SHA384 "AES256-GCM-SHA384" +-# define TLS1_TXT_DHE_RSA_WITH_AES_128_GCM_SHA256 "DHE-RSA-AES128-GCM-SHA256" +-# define TLS1_TXT_DHE_RSA_WITH_AES_256_GCM_SHA384 "DHE-RSA-AES256-GCM-SHA384" +-# define TLS1_TXT_DH_RSA_WITH_AES_128_GCM_SHA256 "DH-RSA-AES128-GCM-SHA256" +-# define TLS1_TXT_DH_RSA_WITH_AES_256_GCM_SHA384 "DH-RSA-AES256-GCM-SHA384" +-# define TLS1_TXT_DHE_DSS_WITH_AES_128_GCM_SHA256 "DHE-DSS-AES128-GCM-SHA256" +-# define TLS1_TXT_DHE_DSS_WITH_AES_256_GCM_SHA384 "DHE-DSS-AES256-GCM-SHA384" +-# define TLS1_TXT_DH_DSS_WITH_AES_128_GCM_SHA256 "DH-DSS-AES128-GCM-SHA256" +-# define TLS1_TXT_DH_DSS_WITH_AES_256_GCM_SHA384 "DH-DSS-AES256-GCM-SHA384" +-# define TLS1_TXT_ADH_WITH_AES_128_GCM_SHA256 "ADH-AES128-GCM-SHA256" +-# define TLS1_TXT_ADH_WITH_AES_256_GCM_SHA384 "ADH-AES256-GCM-SHA384" +- +-/* CCM ciphersuites from RFC6655 */ +-# define TLS1_TXT_RSA_WITH_AES_128_CCM "AES128-CCM" +-# define TLS1_TXT_RSA_WITH_AES_256_CCM "AES256-CCM" +-# define TLS1_TXT_DHE_RSA_WITH_AES_128_CCM "DHE-RSA-AES128-CCM" +-# define TLS1_TXT_DHE_RSA_WITH_AES_256_CCM "DHE-RSA-AES256-CCM" +- +-# define TLS1_TXT_RSA_WITH_AES_128_CCM_8 "AES128-CCM8" +-# define TLS1_TXT_RSA_WITH_AES_256_CCM_8 "AES256-CCM8" +-# define TLS1_TXT_DHE_RSA_WITH_AES_128_CCM_8 "DHE-RSA-AES128-CCM8" +-# define TLS1_TXT_DHE_RSA_WITH_AES_256_CCM_8 "DHE-RSA-AES256-CCM8" +- +-# define TLS1_TXT_PSK_WITH_AES_128_CCM "PSK-AES128-CCM" +-# define TLS1_TXT_PSK_WITH_AES_256_CCM "PSK-AES256-CCM" +-# define TLS1_TXT_DHE_PSK_WITH_AES_128_CCM "DHE-PSK-AES128-CCM" +-# define TLS1_TXT_DHE_PSK_WITH_AES_256_CCM "DHE-PSK-AES256-CCM" +- +-# define TLS1_TXT_PSK_WITH_AES_128_CCM_8 "PSK-AES128-CCM8" +-# define TLS1_TXT_PSK_WITH_AES_256_CCM_8 "PSK-AES256-CCM8" +-# define TLS1_TXT_DHE_PSK_WITH_AES_128_CCM_8 "DHE-PSK-AES128-CCM8" +-# define TLS1_TXT_DHE_PSK_WITH_AES_256_CCM_8 "DHE-PSK-AES256-CCM8" +- +-/* CCM ciphersuites from RFC7251 */ +-# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CCM "ECDHE-ECDSA-AES128-CCM" +-# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CCM "ECDHE-ECDSA-AES256-CCM" +-# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CCM_8 "ECDHE-ECDSA-AES128-CCM8" +-# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CCM_8 "ECDHE-ECDSA-AES256-CCM8" +- +-/* ECDH HMAC based ciphersuites from RFC5289 */ +-# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_SHA256 "ECDHE-ECDSA-AES128-SHA256" +-# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_SHA384 "ECDHE-ECDSA-AES256-SHA384" +-# define TLS1_TXT_ECDH_ECDSA_WITH_AES_128_SHA256 "ECDH-ECDSA-AES128-SHA256" +-# define TLS1_TXT_ECDH_ECDSA_WITH_AES_256_SHA384 "ECDH-ECDSA-AES256-SHA384" +-# define TLS1_TXT_ECDHE_RSA_WITH_AES_128_SHA256 "ECDHE-RSA-AES128-SHA256" +-# define TLS1_TXT_ECDHE_RSA_WITH_AES_256_SHA384 "ECDHE-RSA-AES256-SHA384" +-# define TLS1_TXT_ECDH_RSA_WITH_AES_128_SHA256 "ECDH-RSA-AES128-SHA256" +-# define TLS1_TXT_ECDH_RSA_WITH_AES_256_SHA384 "ECDH-RSA-AES256-SHA384" +- +-/* ECDH GCM based ciphersuites from RFC5289 */ +-# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 "ECDHE-ECDSA-AES128-GCM-SHA256" +-# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 "ECDHE-ECDSA-AES256-GCM-SHA384" +-# define TLS1_TXT_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 "ECDH-ECDSA-AES128-GCM-SHA256" +-# define TLS1_TXT_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 "ECDH-ECDSA-AES256-GCM-SHA384" +-# define TLS1_TXT_ECDHE_RSA_WITH_AES_128_GCM_SHA256 "ECDHE-RSA-AES128-GCM-SHA256" +-# define TLS1_TXT_ECDHE_RSA_WITH_AES_256_GCM_SHA384 "ECDHE-RSA-AES256-GCM-SHA384" +-# define TLS1_TXT_ECDH_RSA_WITH_AES_128_GCM_SHA256 "ECDH-RSA-AES128-GCM-SHA256" +-# define TLS1_TXT_ECDH_RSA_WITH_AES_256_GCM_SHA384 "ECDH-RSA-AES256-GCM-SHA384" +- +-/* TLS v1.2 PSK GCM ciphersuites from RFC5487 */ +-# define TLS1_TXT_PSK_WITH_AES_128_GCM_SHA256 "PSK-AES128-GCM-SHA256" +-# define TLS1_TXT_PSK_WITH_AES_256_GCM_SHA384 "PSK-AES256-GCM-SHA384" +- +-/* ECDHE PSK ciphersuites from RFC 5489 */ +-# define TLS1_TXT_ECDHE_PSK_WITH_RC4_128_SHA "ECDHE-PSK-RC4-SHA" +-# define TLS1_TXT_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA "ECDHE-PSK-3DES-EDE-CBC-SHA" +-# define TLS1_TXT_ECDHE_PSK_WITH_AES_128_CBC_SHA "ECDHE-PSK-AES128-CBC-SHA" +-# define TLS1_TXT_ECDHE_PSK_WITH_AES_256_CBC_SHA "ECDHE-PSK-AES256-CBC-SHA" +- +-# define TLS1_TXT_ECDHE_PSK_WITH_AES_128_CBC_SHA256 "ECDHE-PSK-AES128-CBC-SHA256" +-# define TLS1_TXT_ECDHE_PSK_WITH_AES_256_CBC_SHA384 "ECDHE-PSK-AES256-CBC-SHA384" +- +-# define TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA "ECDHE-PSK-NULL-SHA" +-# define TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA256 "ECDHE-PSK-NULL-SHA256" +-# define TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA384 "ECDHE-PSK-NULL-SHA384" +- +-/* Camellia-CBC ciphersuites from RFC6367 */ +-# define TLS1_TXT_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 "ECDHE-ECDSA-CAMELLIA128-SHA256" +-# define TLS1_TXT_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 "ECDHE-ECDSA-CAMELLIA256-SHA384" +-# define TLS1_TXT_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 "ECDH-ECDSA-CAMELLIA128-SHA256" +-# define TLS1_TXT_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 "ECDH-ECDSA-CAMELLIA256-SHA384" +-# define TLS1_TXT_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 "ECDHE-RSA-CAMELLIA128-SHA256" +-# define TLS1_TXT_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384 "ECDHE-RSA-CAMELLIA256-SHA384" +-# define TLS1_TXT_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256 "ECDH-RSA-CAMELLIA128-SHA256" +-# define TLS1_TXT_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384 "ECDH-RSA-CAMELLIA256-SHA384" +- +-/* draft-ietf-tls-chacha20-poly1305-03 */ +-# define TLS1_TXT_ECDHE_RSA_WITH_CHACHA20_POLY1305 "ECDHE-RSA-CHACHA20-POLY1305" +-# define TLS1_TXT_ECDHE_ECDSA_WITH_CHACHA20_POLY1305 "ECDHE-ECDSA-CHACHA20-POLY1305" +-# define TLS1_TXT_DHE_RSA_WITH_CHACHA20_POLY1305 "DHE-RSA-CHACHA20-POLY1305" +-# define TLS1_TXT_PSK_WITH_CHACHA20_POLY1305 "PSK-CHACHA20-POLY1305" +-# define TLS1_TXT_ECDHE_PSK_WITH_CHACHA20_POLY1305 "ECDHE-PSK-CHACHA20-POLY1305" +-# define TLS1_TXT_DHE_PSK_WITH_CHACHA20_POLY1305 "DHE-PSK-CHACHA20-POLY1305" +-# define TLS1_TXT_RSA_PSK_WITH_CHACHA20_POLY1305 "RSA-PSK-CHACHA20-POLY1305" +- +-/* Aria ciphersuites from RFC6209 */ +-# define TLS1_TXT_RSA_WITH_ARIA_128_GCM_SHA256 "ARIA128-GCM-SHA256" +-# define TLS1_TXT_RSA_WITH_ARIA_256_GCM_SHA384 "ARIA256-GCM-SHA384" +-# define TLS1_TXT_DHE_RSA_WITH_ARIA_128_GCM_SHA256 "DHE-RSA-ARIA128-GCM-SHA256" +-# define TLS1_TXT_DHE_RSA_WITH_ARIA_256_GCM_SHA384 "DHE-RSA-ARIA256-GCM-SHA384" +-# define TLS1_TXT_DH_RSA_WITH_ARIA_128_GCM_SHA256 "DH-RSA-ARIA128-GCM-SHA256" +-# define TLS1_TXT_DH_RSA_WITH_ARIA_256_GCM_SHA384 "DH-RSA-ARIA256-GCM-SHA384" +-# define TLS1_TXT_DHE_DSS_WITH_ARIA_128_GCM_SHA256 "DHE-DSS-ARIA128-GCM-SHA256" +-# define TLS1_TXT_DHE_DSS_WITH_ARIA_256_GCM_SHA384 "DHE-DSS-ARIA256-GCM-SHA384" +-# define TLS1_TXT_DH_DSS_WITH_ARIA_128_GCM_SHA256 "DH-DSS-ARIA128-GCM-SHA256" +-# define TLS1_TXT_DH_DSS_WITH_ARIA_256_GCM_SHA384 "DH-DSS-ARIA256-GCM-SHA384" +-# define TLS1_TXT_DH_anon_WITH_ARIA_128_GCM_SHA256 "ADH-ARIA128-GCM-SHA256" +-# define TLS1_TXT_DH_anon_WITH_ARIA_256_GCM_SHA384 "ADH-ARIA256-GCM-SHA384" +-# define TLS1_TXT_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256 "ECDHE-ECDSA-ARIA128-GCM-SHA256" +-# define TLS1_TXT_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384 "ECDHE-ECDSA-ARIA256-GCM-SHA384" +-# define TLS1_TXT_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256 "ECDH-ECDSA-ARIA128-GCM-SHA256" +-# define TLS1_TXT_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384 "ECDH-ECDSA-ARIA256-GCM-SHA384" +-# define TLS1_TXT_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256 "ECDHE-ARIA128-GCM-SHA256" +-# define TLS1_TXT_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384 "ECDHE-ARIA256-GCM-SHA384" +-# define TLS1_TXT_ECDH_RSA_WITH_ARIA_128_GCM_SHA256 "ECDH-ARIA128-GCM-SHA256" +-# define TLS1_TXT_ECDH_RSA_WITH_ARIA_256_GCM_SHA384 "ECDH-ARIA256-GCM-SHA384" +-# define TLS1_TXT_PSK_WITH_ARIA_128_GCM_SHA256 "PSK-ARIA128-GCM-SHA256" +-# define TLS1_TXT_PSK_WITH_ARIA_256_GCM_SHA384 "PSK-ARIA256-GCM-SHA384" +-# define TLS1_TXT_DHE_PSK_WITH_ARIA_128_GCM_SHA256 "DHE-PSK-ARIA128-GCM-SHA256" +-# define TLS1_TXT_DHE_PSK_WITH_ARIA_256_GCM_SHA384 "DHE-PSK-ARIA256-GCM-SHA384" +-# define TLS1_TXT_RSA_PSK_WITH_ARIA_128_GCM_SHA256 "RSA-PSK-ARIA128-GCM-SHA256" +-# define TLS1_TXT_RSA_PSK_WITH_ARIA_256_GCM_SHA384 "RSA-PSK-ARIA256-GCM-SHA384" +- +-# define TLS_CT_RSA_SIGN 1 +-# define TLS_CT_DSS_SIGN 2 +-# define TLS_CT_RSA_FIXED_DH 3 +-# define TLS_CT_DSS_FIXED_DH 4 +-# define TLS_CT_ECDSA_SIGN 64 +-# define TLS_CT_RSA_FIXED_ECDH 65 +-# define TLS_CT_ECDSA_FIXED_ECDH 66 +-# define TLS_CT_GOST01_SIGN 22 +-# define TLS_CT_GOST12_SIGN 238 +-# define TLS_CT_GOST12_512_SIGN 239 +- +-/* +- * when correcting this number, correct also SSL3_CT_NUMBER in ssl3.h (see +- * comment there) +- */ +-# define TLS_CT_NUMBER 10 +- +-# if defined(SSL3_CT_NUMBER) +-# if TLS_CT_NUMBER != SSL3_CT_NUMBER +-# error "SSL/TLS CT_NUMBER values do not match" +-# endif +-# endif +- +-# define TLS1_FINISH_MAC_LENGTH 12 +- +-# define TLS_MD_MAX_CONST_SIZE 22 +-# define TLS_MD_CLIENT_FINISH_CONST "client finished" +-# define TLS_MD_CLIENT_FINISH_CONST_SIZE 15 +-# define TLS_MD_SERVER_FINISH_CONST "server finished" +-# define TLS_MD_SERVER_FINISH_CONST_SIZE 15 +-# define TLS_MD_KEY_EXPANSION_CONST "key expansion" +-# define TLS_MD_KEY_EXPANSION_CONST_SIZE 13 +-# define TLS_MD_CLIENT_WRITE_KEY_CONST "client write key" +-# define TLS_MD_CLIENT_WRITE_KEY_CONST_SIZE 16 +-# define TLS_MD_SERVER_WRITE_KEY_CONST "server write key" +-# define TLS_MD_SERVER_WRITE_KEY_CONST_SIZE 16 +-# define TLS_MD_IV_BLOCK_CONST "IV block" +-# define TLS_MD_IV_BLOCK_CONST_SIZE 8 +-# define TLS_MD_MASTER_SECRET_CONST "master secret" +-# define TLS_MD_MASTER_SECRET_CONST_SIZE 13 +-# define TLS_MD_EXTENDED_MASTER_SECRET_CONST "extended master secret" +-# define TLS_MD_EXTENDED_MASTER_SECRET_CONST_SIZE 22 +- +-# ifdef CHARSET_EBCDIC +-# undef TLS_MD_CLIENT_FINISH_CONST +-/* +- * client finished +- */ +-# define TLS_MD_CLIENT_FINISH_CONST "\x63\x6c\x69\x65\x6e\x74\x20\x66\x69\x6e\x69\x73\x68\x65\x64" +- +-# undef TLS_MD_SERVER_FINISH_CONST +-/* +- * server finished +- */ +-# define TLS_MD_SERVER_FINISH_CONST "\x73\x65\x72\x76\x65\x72\x20\x66\x69\x6e\x69\x73\x68\x65\x64" +- +-# undef TLS_MD_SERVER_WRITE_KEY_CONST +-/* +- * server write key +- */ +-# define TLS_MD_SERVER_WRITE_KEY_CONST "\x73\x65\x72\x76\x65\x72\x20\x77\x72\x69\x74\x65\x20\x6b\x65\x79" +- +-# undef TLS_MD_KEY_EXPANSION_CONST +-/* +- * key expansion +- */ +-# define TLS_MD_KEY_EXPANSION_CONST "\x6b\x65\x79\x20\x65\x78\x70\x61\x6e\x73\x69\x6f\x6e" +- +-# undef TLS_MD_CLIENT_WRITE_KEY_CONST +-/* +- * client write key +- */ +-# define TLS_MD_CLIENT_WRITE_KEY_CONST "\x63\x6c\x69\x65\x6e\x74\x20\x77\x72\x69\x74\x65\x20\x6b\x65\x79" +- +-# undef TLS_MD_SERVER_WRITE_KEY_CONST +-/* +- * server write key +- */ +-# define TLS_MD_SERVER_WRITE_KEY_CONST "\x73\x65\x72\x76\x65\x72\x20\x77\x72\x69\x74\x65\x20\x6b\x65\x79" +- +-# undef TLS_MD_IV_BLOCK_CONST +-/* +- * IV block +- */ +-# define TLS_MD_IV_BLOCK_CONST "\x49\x56\x20\x62\x6c\x6f\x63\x6b" +- +-# undef TLS_MD_MASTER_SECRET_CONST +-/* +- * master secret +- */ +-# define TLS_MD_MASTER_SECRET_CONST "\x6d\x61\x73\x74\x65\x72\x20\x73\x65\x63\x72\x65\x74" +-# undef TLS_MD_EXTENDED_MASTER_SECRET_CONST +-/* +- * extended master secret +- */ +-# define TLS_MD_EXTENDED_MASTER_SECRET_CONST "\x65\x78\x74\x65\x6e\x64\x65\x64\x20\x6d\x61\x73\x74\x65\x72\x20\x73\x65\x63\x72\x65\x74" +-# endif +- +-/* TLS Session Ticket extension struct */ +-struct tls_session_ticket_ext_st { +- unsigned short length; +- void *data; +-}; +- +-#ifdef __cplusplus +-} +-#endif +-#endif +diff --git a/uadk_tool/include/openssl/ts.h b/uadk_tool/include/openssl/ts.h +deleted file mode 100644 +index 3b58aa5..0000000 +--- a/uadk_tool/include/openssl/ts.h ++++ /dev/null +@@ -1,559 +0,0 @@ +-/* +- * Copyright 2006-2018 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_TS_H +-# define HEADER_TS_H +- +-# include +- +-# ifndef OPENSSL_NO_TS +-# include +-# include +-# include +-# include +-# include +-# include +-# include +-# include +-# include +-# include +-# ifdef __cplusplus +-extern "C" { +-# endif +- +-# include +-# include +- +-typedef struct TS_msg_imprint_st TS_MSG_IMPRINT; +-typedef struct TS_req_st TS_REQ; +-typedef struct TS_accuracy_st TS_ACCURACY; +-typedef struct TS_tst_info_st TS_TST_INFO; +- +-/* Possible values for status. */ +-# define TS_STATUS_GRANTED 0 +-# define TS_STATUS_GRANTED_WITH_MODS 1 +-# define TS_STATUS_REJECTION 2 +-# define TS_STATUS_WAITING 3 +-# define TS_STATUS_REVOCATION_WARNING 4 +-# define TS_STATUS_REVOCATION_NOTIFICATION 5 +- +-/* Possible values for failure_info. */ +-# define TS_INFO_BAD_ALG 0 +-# define TS_INFO_BAD_REQUEST 2 +-# define TS_INFO_BAD_DATA_FORMAT 5 +-# define TS_INFO_TIME_NOT_AVAILABLE 14 +-# define TS_INFO_UNACCEPTED_POLICY 15 +-# define TS_INFO_UNACCEPTED_EXTENSION 16 +-# define TS_INFO_ADD_INFO_NOT_AVAILABLE 17 +-# define TS_INFO_SYSTEM_FAILURE 25 +- +- +-typedef struct TS_status_info_st TS_STATUS_INFO; +-typedef struct ESS_issuer_serial ESS_ISSUER_SERIAL; +-typedef struct ESS_cert_id ESS_CERT_ID; +-typedef struct ESS_signing_cert ESS_SIGNING_CERT; +- +-DEFINE_STACK_OF(ESS_CERT_ID) +- +-typedef struct ESS_cert_id_v2_st ESS_CERT_ID_V2; +-typedef struct ESS_signing_cert_v2_st ESS_SIGNING_CERT_V2; +- +-DEFINE_STACK_OF(ESS_CERT_ID_V2) +- +-typedef struct TS_resp_st TS_RESP; +- +-TS_REQ *TS_REQ_new(void); +-void TS_REQ_free(TS_REQ *a); +-int i2d_TS_REQ(const TS_REQ *a, unsigned char **pp); +-TS_REQ *d2i_TS_REQ(TS_REQ **a, const unsigned char **pp, long length); +- +-TS_REQ *TS_REQ_dup(TS_REQ *a); +- +-#ifndef OPENSSL_NO_STDIO +-TS_REQ *d2i_TS_REQ_fp(FILE *fp, TS_REQ **a); +-int i2d_TS_REQ_fp(FILE *fp, TS_REQ *a); +-#endif +-TS_REQ *d2i_TS_REQ_bio(BIO *fp, TS_REQ **a); +-int i2d_TS_REQ_bio(BIO *fp, TS_REQ *a); +- +-TS_MSG_IMPRINT *TS_MSG_IMPRINT_new(void); +-void TS_MSG_IMPRINT_free(TS_MSG_IMPRINT *a); +-int i2d_TS_MSG_IMPRINT(const TS_MSG_IMPRINT *a, unsigned char **pp); +-TS_MSG_IMPRINT *d2i_TS_MSG_IMPRINT(TS_MSG_IMPRINT **a, +- const unsigned char **pp, long length); +- +-TS_MSG_IMPRINT *TS_MSG_IMPRINT_dup(TS_MSG_IMPRINT *a); +- +-#ifndef OPENSSL_NO_STDIO +-TS_MSG_IMPRINT *d2i_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT **a); +-int i2d_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT *a); +-#endif +-TS_MSG_IMPRINT *d2i_TS_MSG_IMPRINT_bio(BIO *bio, TS_MSG_IMPRINT **a); +-int i2d_TS_MSG_IMPRINT_bio(BIO *bio, TS_MSG_IMPRINT *a); +- +-TS_RESP *TS_RESP_new(void); +-void TS_RESP_free(TS_RESP *a); +-int i2d_TS_RESP(const TS_RESP *a, unsigned char **pp); +-TS_RESP *d2i_TS_RESP(TS_RESP **a, const unsigned char **pp, long length); +-TS_TST_INFO *PKCS7_to_TS_TST_INFO(PKCS7 *token); +-TS_RESP *TS_RESP_dup(TS_RESP *a); +- +-#ifndef OPENSSL_NO_STDIO +-TS_RESP *d2i_TS_RESP_fp(FILE *fp, TS_RESP **a); +-int i2d_TS_RESP_fp(FILE *fp, TS_RESP *a); +-#endif +-TS_RESP *d2i_TS_RESP_bio(BIO *bio, TS_RESP **a); +-int i2d_TS_RESP_bio(BIO *bio, TS_RESP *a); +- +-TS_STATUS_INFO *TS_STATUS_INFO_new(void); +-void TS_STATUS_INFO_free(TS_STATUS_INFO *a); +-int i2d_TS_STATUS_INFO(const TS_STATUS_INFO *a, unsigned char **pp); +-TS_STATUS_INFO *d2i_TS_STATUS_INFO(TS_STATUS_INFO **a, +- const unsigned char **pp, long length); +-TS_STATUS_INFO *TS_STATUS_INFO_dup(TS_STATUS_INFO *a); +- +-TS_TST_INFO *TS_TST_INFO_new(void); +-void TS_TST_INFO_free(TS_TST_INFO *a); +-int i2d_TS_TST_INFO(const TS_TST_INFO *a, unsigned char **pp); +-TS_TST_INFO *d2i_TS_TST_INFO(TS_TST_INFO **a, const unsigned char **pp, +- long length); +-TS_TST_INFO *TS_TST_INFO_dup(TS_TST_INFO *a); +- +-#ifndef OPENSSL_NO_STDIO +-TS_TST_INFO *d2i_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO **a); +-int i2d_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO *a); +-#endif +-TS_TST_INFO *d2i_TS_TST_INFO_bio(BIO *bio, TS_TST_INFO **a); +-int i2d_TS_TST_INFO_bio(BIO *bio, TS_TST_INFO *a); +- +-TS_ACCURACY *TS_ACCURACY_new(void); +-void TS_ACCURACY_free(TS_ACCURACY *a); +-int i2d_TS_ACCURACY(const TS_ACCURACY *a, unsigned char **pp); +-TS_ACCURACY *d2i_TS_ACCURACY(TS_ACCURACY **a, const unsigned char **pp, +- long length); +-TS_ACCURACY *TS_ACCURACY_dup(TS_ACCURACY *a); +- +-ESS_ISSUER_SERIAL *ESS_ISSUER_SERIAL_new(void); +-void ESS_ISSUER_SERIAL_free(ESS_ISSUER_SERIAL *a); +-int i2d_ESS_ISSUER_SERIAL(const ESS_ISSUER_SERIAL *a, unsigned char **pp); +-ESS_ISSUER_SERIAL *d2i_ESS_ISSUER_SERIAL(ESS_ISSUER_SERIAL **a, +- const unsigned char **pp, +- long length); +-ESS_ISSUER_SERIAL *ESS_ISSUER_SERIAL_dup(ESS_ISSUER_SERIAL *a); +- +-ESS_CERT_ID *ESS_CERT_ID_new(void); +-void ESS_CERT_ID_free(ESS_CERT_ID *a); +-int i2d_ESS_CERT_ID(const ESS_CERT_ID *a, unsigned char **pp); +-ESS_CERT_ID *d2i_ESS_CERT_ID(ESS_CERT_ID **a, const unsigned char **pp, +- long length); +-ESS_CERT_ID *ESS_CERT_ID_dup(ESS_CERT_ID *a); +- +-ESS_SIGNING_CERT *ESS_SIGNING_CERT_new(void); +-void ESS_SIGNING_CERT_free(ESS_SIGNING_CERT *a); +-int i2d_ESS_SIGNING_CERT(const ESS_SIGNING_CERT *a, unsigned char **pp); +-ESS_SIGNING_CERT *d2i_ESS_SIGNING_CERT(ESS_SIGNING_CERT **a, +- const unsigned char **pp, long length); +-ESS_SIGNING_CERT *ESS_SIGNING_CERT_dup(ESS_SIGNING_CERT *a); +- +-ESS_CERT_ID_V2 *ESS_CERT_ID_V2_new(void); +-void ESS_CERT_ID_V2_free(ESS_CERT_ID_V2 *a); +-int i2d_ESS_CERT_ID_V2(const ESS_CERT_ID_V2 *a, unsigned char **pp); +-ESS_CERT_ID_V2 *d2i_ESS_CERT_ID_V2(ESS_CERT_ID_V2 **a, +- const unsigned char **pp, long length); +-ESS_CERT_ID_V2 *ESS_CERT_ID_V2_dup(ESS_CERT_ID_V2 *a); +- +-ESS_SIGNING_CERT_V2 *ESS_SIGNING_CERT_V2_new(void); +-void ESS_SIGNING_CERT_V2_free(ESS_SIGNING_CERT_V2 *a); +-int i2d_ESS_SIGNING_CERT_V2(const ESS_SIGNING_CERT_V2 *a, unsigned char **pp); +-ESS_SIGNING_CERT_V2 *d2i_ESS_SIGNING_CERT_V2(ESS_SIGNING_CERT_V2 **a, +- const unsigned char **pp, +- long length); +-ESS_SIGNING_CERT_V2 *ESS_SIGNING_CERT_V2_dup(ESS_SIGNING_CERT_V2 *a); +- +-int TS_REQ_set_version(TS_REQ *a, long version); +-long TS_REQ_get_version(const TS_REQ *a); +- +-int TS_STATUS_INFO_set_status(TS_STATUS_INFO *a, int i); +-const ASN1_INTEGER *TS_STATUS_INFO_get0_status(const TS_STATUS_INFO *a); +- +-const STACK_OF(ASN1_UTF8STRING) * +-TS_STATUS_INFO_get0_text(const TS_STATUS_INFO *a); +- +-const ASN1_BIT_STRING * +-TS_STATUS_INFO_get0_failure_info(const TS_STATUS_INFO *a); +- +-int TS_REQ_set_msg_imprint(TS_REQ *a, TS_MSG_IMPRINT *msg_imprint); +-TS_MSG_IMPRINT *TS_REQ_get_msg_imprint(TS_REQ *a); +- +-int TS_MSG_IMPRINT_set_algo(TS_MSG_IMPRINT *a, X509_ALGOR *alg); +-X509_ALGOR *TS_MSG_IMPRINT_get_algo(TS_MSG_IMPRINT *a); +- +-int TS_MSG_IMPRINT_set_msg(TS_MSG_IMPRINT *a, unsigned char *d, int len); +-ASN1_OCTET_STRING *TS_MSG_IMPRINT_get_msg(TS_MSG_IMPRINT *a); +- +-int TS_REQ_set_policy_id(TS_REQ *a, const ASN1_OBJECT *policy); +-ASN1_OBJECT *TS_REQ_get_policy_id(TS_REQ *a); +- +-int TS_REQ_set_nonce(TS_REQ *a, const ASN1_INTEGER *nonce); +-const ASN1_INTEGER *TS_REQ_get_nonce(const TS_REQ *a); +- +-int TS_REQ_set_cert_req(TS_REQ *a, int cert_req); +-int TS_REQ_get_cert_req(const TS_REQ *a); +- +-STACK_OF(X509_EXTENSION) *TS_REQ_get_exts(TS_REQ *a); +-void TS_REQ_ext_free(TS_REQ *a); +-int TS_REQ_get_ext_count(TS_REQ *a); +-int TS_REQ_get_ext_by_NID(TS_REQ *a, int nid, int lastpos); +-int TS_REQ_get_ext_by_OBJ(TS_REQ *a, const ASN1_OBJECT *obj, int lastpos); +-int TS_REQ_get_ext_by_critical(TS_REQ *a, int crit, int lastpos); +-X509_EXTENSION *TS_REQ_get_ext(TS_REQ *a, int loc); +-X509_EXTENSION *TS_REQ_delete_ext(TS_REQ *a, int loc); +-int TS_REQ_add_ext(TS_REQ *a, X509_EXTENSION *ex, int loc); +-void *TS_REQ_get_ext_d2i(TS_REQ *a, int nid, int *crit, int *idx); +- +-/* Function declarations for TS_REQ defined in ts/ts_req_print.c */ +- +-int TS_REQ_print_bio(BIO *bio, TS_REQ *a); +- +-/* Function declarations for TS_RESP defined in ts/ts_resp_utils.c */ +- +-int TS_RESP_set_status_info(TS_RESP *a, TS_STATUS_INFO *info); +-TS_STATUS_INFO *TS_RESP_get_status_info(TS_RESP *a); +- +-/* Caller loses ownership of PKCS7 and TS_TST_INFO objects. */ +-void TS_RESP_set_tst_info(TS_RESP *a, PKCS7 *p7, TS_TST_INFO *tst_info); +-PKCS7 *TS_RESP_get_token(TS_RESP *a); +-TS_TST_INFO *TS_RESP_get_tst_info(TS_RESP *a); +- +-int TS_TST_INFO_set_version(TS_TST_INFO *a, long version); +-long TS_TST_INFO_get_version(const TS_TST_INFO *a); +- +-int TS_TST_INFO_set_policy_id(TS_TST_INFO *a, ASN1_OBJECT *policy_id); +-ASN1_OBJECT *TS_TST_INFO_get_policy_id(TS_TST_INFO *a); +- +-int TS_TST_INFO_set_msg_imprint(TS_TST_INFO *a, TS_MSG_IMPRINT *msg_imprint); +-TS_MSG_IMPRINT *TS_TST_INFO_get_msg_imprint(TS_TST_INFO *a); +- +-int TS_TST_INFO_set_serial(TS_TST_INFO *a, const ASN1_INTEGER *serial); +-const ASN1_INTEGER *TS_TST_INFO_get_serial(const TS_TST_INFO *a); +- +-int TS_TST_INFO_set_time(TS_TST_INFO *a, const ASN1_GENERALIZEDTIME *gtime); +-const ASN1_GENERALIZEDTIME *TS_TST_INFO_get_time(const TS_TST_INFO *a); +- +-int TS_TST_INFO_set_accuracy(TS_TST_INFO *a, TS_ACCURACY *accuracy); +-TS_ACCURACY *TS_TST_INFO_get_accuracy(TS_TST_INFO *a); +- +-int TS_ACCURACY_set_seconds(TS_ACCURACY *a, const ASN1_INTEGER *seconds); +-const ASN1_INTEGER *TS_ACCURACY_get_seconds(const TS_ACCURACY *a); +- +-int TS_ACCURACY_set_millis(TS_ACCURACY *a, const ASN1_INTEGER *millis); +-const ASN1_INTEGER *TS_ACCURACY_get_millis(const TS_ACCURACY *a); +- +-int TS_ACCURACY_set_micros(TS_ACCURACY *a, const ASN1_INTEGER *micros); +-const ASN1_INTEGER *TS_ACCURACY_get_micros(const TS_ACCURACY *a); +- +-int TS_TST_INFO_set_ordering(TS_TST_INFO *a, int ordering); +-int TS_TST_INFO_get_ordering(const TS_TST_INFO *a); +- +-int TS_TST_INFO_set_nonce(TS_TST_INFO *a, const ASN1_INTEGER *nonce); +-const ASN1_INTEGER *TS_TST_INFO_get_nonce(const TS_TST_INFO *a); +- +-int TS_TST_INFO_set_tsa(TS_TST_INFO *a, GENERAL_NAME *tsa); +-GENERAL_NAME *TS_TST_INFO_get_tsa(TS_TST_INFO *a); +- +-STACK_OF(X509_EXTENSION) *TS_TST_INFO_get_exts(TS_TST_INFO *a); +-void TS_TST_INFO_ext_free(TS_TST_INFO *a); +-int TS_TST_INFO_get_ext_count(TS_TST_INFO *a); +-int TS_TST_INFO_get_ext_by_NID(TS_TST_INFO *a, int nid, int lastpos); +-int TS_TST_INFO_get_ext_by_OBJ(TS_TST_INFO *a, const ASN1_OBJECT *obj, +- int lastpos); +-int TS_TST_INFO_get_ext_by_critical(TS_TST_INFO *a, int crit, int lastpos); +-X509_EXTENSION *TS_TST_INFO_get_ext(TS_TST_INFO *a, int loc); +-X509_EXTENSION *TS_TST_INFO_delete_ext(TS_TST_INFO *a, int loc); +-int TS_TST_INFO_add_ext(TS_TST_INFO *a, X509_EXTENSION *ex, int loc); +-void *TS_TST_INFO_get_ext_d2i(TS_TST_INFO *a, int nid, int *crit, int *idx); +- +-/* +- * Declarations related to response generation, defined in ts/ts_resp_sign.c. +- */ +- +-/* Optional flags for response generation. */ +- +-/* Don't include the TSA name in response. */ +-# define TS_TSA_NAME 0x01 +- +-/* Set ordering to true in response. */ +-# define TS_ORDERING 0x02 +- +-/* +- * Include the signer certificate and the other specified certificates in +- * the ESS signing certificate attribute beside the PKCS7 signed data. +- * Only the signer certificates is included by default. +- */ +-# define TS_ESS_CERT_ID_CHAIN 0x04 +- +-/* Forward declaration. */ +-struct TS_resp_ctx; +- +-/* This must return a unique number less than 160 bits long. */ +-typedef ASN1_INTEGER *(*TS_serial_cb) (struct TS_resp_ctx *, void *); +- +-/* +- * This must return the seconds and microseconds since Jan 1, 1970 in the sec +- * and usec variables allocated by the caller. Return non-zero for success +- * and zero for failure. +- */ +-typedef int (*TS_time_cb) (struct TS_resp_ctx *, void *, long *sec, +- long *usec); +- +-/* +- * This must process the given extension. It can modify the TS_TST_INFO +- * object of the context. Return values: !0 (processed), 0 (error, it must +- * set the status info/failure info of the response). +- */ +-typedef int (*TS_extension_cb) (struct TS_resp_ctx *, X509_EXTENSION *, +- void *); +- +-typedef struct TS_resp_ctx TS_RESP_CTX; +- +-DEFINE_STACK_OF_CONST(EVP_MD) +- +-/* Creates a response context that can be used for generating responses. */ +-TS_RESP_CTX *TS_RESP_CTX_new(void); +-void TS_RESP_CTX_free(TS_RESP_CTX *ctx); +- +-/* This parameter must be set. */ +-int TS_RESP_CTX_set_signer_cert(TS_RESP_CTX *ctx, X509 *signer); +- +-/* This parameter must be set. */ +-int TS_RESP_CTX_set_signer_key(TS_RESP_CTX *ctx, EVP_PKEY *key); +- +-int TS_RESP_CTX_set_signer_digest(TS_RESP_CTX *ctx, +- const EVP_MD *signer_digest); +-int TS_RESP_CTX_set_ess_cert_id_digest(TS_RESP_CTX *ctx, const EVP_MD *md); +- +-/* This parameter must be set. */ +-int TS_RESP_CTX_set_def_policy(TS_RESP_CTX *ctx, const ASN1_OBJECT *def_policy); +- +-/* No additional certs are included in the response by default. */ +-int TS_RESP_CTX_set_certs(TS_RESP_CTX *ctx, STACK_OF(X509) *certs); +- +-/* +- * Adds a new acceptable policy, only the default policy is accepted by +- * default. +- */ +-int TS_RESP_CTX_add_policy(TS_RESP_CTX *ctx, const ASN1_OBJECT *policy); +- +-/* +- * Adds a new acceptable message digest. Note that no message digests are +- * accepted by default. The md argument is shared with the caller. +- */ +-int TS_RESP_CTX_add_md(TS_RESP_CTX *ctx, const EVP_MD *md); +- +-/* Accuracy is not included by default. */ +-int TS_RESP_CTX_set_accuracy(TS_RESP_CTX *ctx, +- int secs, int millis, int micros); +- +-/* +- * Clock precision digits, i.e. the number of decimal digits: '0' means sec, +- * '3' msec, '6' usec, and so on. Default is 0. +- */ +-int TS_RESP_CTX_set_clock_precision_digits(TS_RESP_CTX *ctx, +- unsigned clock_precision_digits); +-/* At most we accept usec precision. */ +-# define TS_MAX_CLOCK_PRECISION_DIGITS 6 +- +-/* Maximum status message length */ +-# define TS_MAX_STATUS_LENGTH (1024 * 1024) +- +-/* No flags are set by default. */ +-void TS_RESP_CTX_add_flags(TS_RESP_CTX *ctx, int flags); +- +-/* Default callback always returns a constant. */ +-void TS_RESP_CTX_set_serial_cb(TS_RESP_CTX *ctx, TS_serial_cb cb, void *data); +- +-/* Default callback uses the gettimeofday() and gmtime() system calls. */ +-void TS_RESP_CTX_set_time_cb(TS_RESP_CTX *ctx, TS_time_cb cb, void *data); +- +-/* +- * Default callback rejects all extensions. The extension callback is called +- * when the TS_TST_INFO object is already set up and not signed yet. +- */ +-/* FIXME: extension handling is not tested yet. */ +-void TS_RESP_CTX_set_extension_cb(TS_RESP_CTX *ctx, +- TS_extension_cb cb, void *data); +- +-/* The following methods can be used in the callbacks. */ +-int TS_RESP_CTX_set_status_info(TS_RESP_CTX *ctx, +- int status, const char *text); +- +-/* Sets the status info only if it is still TS_STATUS_GRANTED. */ +-int TS_RESP_CTX_set_status_info_cond(TS_RESP_CTX *ctx, +- int status, const char *text); +- +-int TS_RESP_CTX_add_failure_info(TS_RESP_CTX *ctx, int failure); +- +-/* The get methods below can be used in the extension callback. */ +-TS_REQ *TS_RESP_CTX_get_request(TS_RESP_CTX *ctx); +- +-TS_TST_INFO *TS_RESP_CTX_get_tst_info(TS_RESP_CTX *ctx); +- +-/* +- * Creates the signed TS_TST_INFO and puts it in TS_RESP. +- * In case of errors it sets the status info properly. +- * Returns NULL only in case of memory allocation/fatal error. +- */ +-TS_RESP *TS_RESP_create_response(TS_RESP_CTX *ctx, BIO *req_bio); +- +-/* +- * Declarations related to response verification, +- * they are defined in ts/ts_resp_verify.c. +- */ +- +-int TS_RESP_verify_signature(PKCS7 *token, STACK_OF(X509) *certs, +- X509_STORE *store, X509 **signer_out); +- +-/* Context structure for the generic verify method. */ +- +-/* Verify the signer's certificate and the signature of the response. */ +-# define TS_VFY_SIGNATURE (1u << 0) +-/* Verify the version number of the response. */ +-# define TS_VFY_VERSION (1u << 1) +-/* Verify if the policy supplied by the user matches the policy of the TSA. */ +-# define TS_VFY_POLICY (1u << 2) +-/* +- * Verify the message imprint provided by the user. This flag should not be +- * specified with TS_VFY_DATA. +- */ +-# define TS_VFY_IMPRINT (1u << 3) +-/* +- * Verify the message imprint computed by the verify method from the user +- * provided data and the MD algorithm of the response. This flag should not +- * be specified with TS_VFY_IMPRINT. +- */ +-# define TS_VFY_DATA (1u << 4) +-/* Verify the nonce value. */ +-# define TS_VFY_NONCE (1u << 5) +-/* Verify if the TSA name field matches the signer certificate. */ +-# define TS_VFY_SIGNER (1u << 6) +-/* Verify if the TSA name field equals to the user provided name. */ +-# define TS_VFY_TSA_NAME (1u << 7) +- +-/* You can use the following convenience constants. */ +-# define TS_VFY_ALL_IMPRINT (TS_VFY_SIGNATURE \ +- | TS_VFY_VERSION \ +- | TS_VFY_POLICY \ +- | TS_VFY_IMPRINT \ +- | TS_VFY_NONCE \ +- | TS_VFY_SIGNER \ +- | TS_VFY_TSA_NAME) +-# define TS_VFY_ALL_DATA (TS_VFY_SIGNATURE \ +- | TS_VFY_VERSION \ +- | TS_VFY_POLICY \ +- | TS_VFY_DATA \ +- | TS_VFY_NONCE \ +- | TS_VFY_SIGNER \ +- | TS_VFY_TSA_NAME) +- +-typedef struct TS_verify_ctx TS_VERIFY_CTX; +- +-int TS_RESP_verify_response(TS_VERIFY_CTX *ctx, TS_RESP *response); +-int TS_RESP_verify_token(TS_VERIFY_CTX *ctx, PKCS7 *token); +- +-/* +- * Declarations related to response verification context, +- */ +-TS_VERIFY_CTX *TS_VERIFY_CTX_new(void); +-void TS_VERIFY_CTX_init(TS_VERIFY_CTX *ctx); +-void TS_VERIFY_CTX_free(TS_VERIFY_CTX *ctx); +-void TS_VERIFY_CTX_cleanup(TS_VERIFY_CTX *ctx); +-int TS_VERIFY_CTX_set_flags(TS_VERIFY_CTX *ctx, int f); +-int TS_VERIFY_CTX_add_flags(TS_VERIFY_CTX *ctx, int f); +-BIO *TS_VERIFY_CTX_set_data(TS_VERIFY_CTX *ctx, BIO *b); +-unsigned char *TS_VERIFY_CTX_set_imprint(TS_VERIFY_CTX *ctx, +- unsigned char *hexstr, long len); +-X509_STORE *TS_VERIFY_CTX_set_store(TS_VERIFY_CTX *ctx, X509_STORE *s); +-STACK_OF(X509) *TS_VERIFY_CTS_set_certs(TS_VERIFY_CTX *ctx, STACK_OF(X509) *certs); +- +-/*- +- * If ctx is NULL, it allocates and returns a new object, otherwise +- * it returns ctx. It initialises all the members as follows: +- * flags = TS_VFY_ALL_IMPRINT & ~(TS_VFY_TSA_NAME | TS_VFY_SIGNATURE) +- * certs = NULL +- * store = NULL +- * policy = policy from the request or NULL if absent (in this case +- * TS_VFY_POLICY is cleared from flags as well) +- * md_alg = MD algorithm from request +- * imprint, imprint_len = imprint from request +- * data = NULL +- * nonce, nonce_len = nonce from the request or NULL if absent (in this case +- * TS_VFY_NONCE is cleared from flags as well) +- * tsa_name = NULL +- * Important: after calling this method TS_VFY_SIGNATURE should be added! +- */ +-TS_VERIFY_CTX *TS_REQ_to_TS_VERIFY_CTX(TS_REQ *req, TS_VERIFY_CTX *ctx); +- +-/* Function declarations for TS_RESP defined in ts/ts_resp_print.c */ +- +-int TS_RESP_print_bio(BIO *bio, TS_RESP *a); +-int TS_STATUS_INFO_print_bio(BIO *bio, TS_STATUS_INFO *a); +-int TS_TST_INFO_print_bio(BIO *bio, TS_TST_INFO *a); +- +-/* Common utility functions defined in ts/ts_lib.c */ +- +-int TS_ASN1_INTEGER_print_bio(BIO *bio, const ASN1_INTEGER *num); +-int TS_OBJ_print_bio(BIO *bio, const ASN1_OBJECT *obj); +-int TS_ext_print_bio(BIO *bio, const STACK_OF(X509_EXTENSION) *extensions); +-int TS_X509_ALGOR_print_bio(BIO *bio, const X509_ALGOR *alg); +-int TS_MSG_IMPRINT_print_bio(BIO *bio, TS_MSG_IMPRINT *msg); +- +-/* +- * Function declarations for handling configuration options, defined in +- * ts/ts_conf.c +- */ +- +-X509 *TS_CONF_load_cert(const char *file); +-STACK_OF(X509) *TS_CONF_load_certs(const char *file); +-EVP_PKEY *TS_CONF_load_key(const char *file, const char *pass); +-const char *TS_CONF_get_tsa_section(CONF *conf, const char *section); +-int TS_CONF_set_serial(CONF *conf, const char *section, TS_serial_cb cb, +- TS_RESP_CTX *ctx); +-#ifndef OPENSSL_NO_ENGINE +-int TS_CONF_set_crypto_device(CONF *conf, const char *section, +- const char *device); +-int TS_CONF_set_default_engine(const char *name); +-#endif +-int TS_CONF_set_signer_cert(CONF *conf, const char *section, +- const char *cert, TS_RESP_CTX *ctx); +-int TS_CONF_set_certs(CONF *conf, const char *section, const char *certs, +- TS_RESP_CTX *ctx); +-int TS_CONF_set_signer_key(CONF *conf, const char *section, +- const char *key, const char *pass, +- TS_RESP_CTX *ctx); +-int TS_CONF_set_signer_digest(CONF *conf, const char *section, +- const char *md, TS_RESP_CTX *ctx); +-int TS_CONF_set_def_policy(CONF *conf, const char *section, +- const char *policy, TS_RESP_CTX *ctx); +-int TS_CONF_set_policies(CONF *conf, const char *section, TS_RESP_CTX *ctx); +-int TS_CONF_set_digests(CONF *conf, const char *section, TS_RESP_CTX *ctx); +-int TS_CONF_set_accuracy(CONF *conf, const char *section, TS_RESP_CTX *ctx); +-int TS_CONF_set_clock_precision_digits(CONF *conf, const char *section, +- TS_RESP_CTX *ctx); +-int TS_CONF_set_ordering(CONF *conf, const char *section, TS_RESP_CTX *ctx); +-int TS_CONF_set_tsa_name(CONF *conf, const char *section, TS_RESP_CTX *ctx); +-int TS_CONF_set_ess_cert_id_chain(CONF *conf, const char *section, +- TS_RESP_CTX *ctx); +-int TS_CONF_set_ess_cert_id_digest(CONF *conf, const char *section, +- TS_RESP_CTX *ctx); +- +-# ifdef __cplusplus +-} +-# endif +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/tserr.h b/uadk_tool/include/openssl/tserr.h +deleted file mode 100644 +index 07f2333..0000000 +--- a/uadk_tool/include/openssl/tserr.h ++++ /dev/null +@@ -1,132 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_TSERR_H +-# define HEADER_TSERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# include +- +-# ifndef OPENSSL_NO_TS +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_TS_strings(void); +- +-/* +- * TS function codes. +- */ +-# define TS_F_DEF_SERIAL_CB 110 +-# define TS_F_DEF_TIME_CB 111 +-# define TS_F_ESS_ADD_SIGNING_CERT 112 +-# define TS_F_ESS_ADD_SIGNING_CERT_V2 147 +-# define TS_F_ESS_CERT_ID_NEW_INIT 113 +-# define TS_F_ESS_CERT_ID_V2_NEW_INIT 156 +-# define TS_F_ESS_SIGNING_CERT_NEW_INIT 114 +-# define TS_F_ESS_SIGNING_CERT_V2_NEW_INIT 157 +-# define TS_F_INT_TS_RESP_VERIFY_TOKEN 149 +-# define TS_F_PKCS7_TO_TS_TST_INFO 148 +-# define TS_F_TS_ACCURACY_SET_MICROS 115 +-# define TS_F_TS_ACCURACY_SET_MILLIS 116 +-# define TS_F_TS_ACCURACY_SET_SECONDS 117 +-# define TS_F_TS_CHECK_IMPRINTS 100 +-# define TS_F_TS_CHECK_NONCES 101 +-# define TS_F_TS_CHECK_POLICY 102 +-# define TS_F_TS_CHECK_SIGNING_CERTS 103 +-# define TS_F_TS_CHECK_STATUS_INFO 104 +-# define TS_F_TS_COMPUTE_IMPRINT 145 +-# define TS_F_TS_CONF_INVALID 151 +-# define TS_F_TS_CONF_LOAD_CERT 153 +-# define TS_F_TS_CONF_LOAD_CERTS 154 +-# define TS_F_TS_CONF_LOAD_KEY 155 +-# define TS_F_TS_CONF_LOOKUP_FAIL 152 +-# define TS_F_TS_CONF_SET_DEFAULT_ENGINE 146 +-# define TS_F_TS_GET_STATUS_TEXT 105 +-# define TS_F_TS_MSG_IMPRINT_SET_ALGO 118 +-# define TS_F_TS_REQ_SET_MSG_IMPRINT 119 +-# define TS_F_TS_REQ_SET_NONCE 120 +-# define TS_F_TS_REQ_SET_POLICY_ID 121 +-# define TS_F_TS_RESP_CREATE_RESPONSE 122 +-# define TS_F_TS_RESP_CREATE_TST_INFO 123 +-# define TS_F_TS_RESP_CTX_ADD_FAILURE_INFO 124 +-# define TS_F_TS_RESP_CTX_ADD_MD 125 +-# define TS_F_TS_RESP_CTX_ADD_POLICY 126 +-# define TS_F_TS_RESP_CTX_NEW 127 +-# define TS_F_TS_RESP_CTX_SET_ACCURACY 128 +-# define TS_F_TS_RESP_CTX_SET_CERTS 129 +-# define TS_F_TS_RESP_CTX_SET_DEF_POLICY 130 +-# define TS_F_TS_RESP_CTX_SET_SIGNER_CERT 131 +-# define TS_F_TS_RESP_CTX_SET_STATUS_INFO 132 +-# define TS_F_TS_RESP_GET_POLICY 133 +-# define TS_F_TS_RESP_SET_GENTIME_WITH_PRECISION 134 +-# define TS_F_TS_RESP_SET_STATUS_INFO 135 +-# define TS_F_TS_RESP_SET_TST_INFO 150 +-# define TS_F_TS_RESP_SIGN 136 +-# define TS_F_TS_RESP_VERIFY_SIGNATURE 106 +-# define TS_F_TS_TST_INFO_SET_ACCURACY 137 +-# define TS_F_TS_TST_INFO_SET_MSG_IMPRINT 138 +-# define TS_F_TS_TST_INFO_SET_NONCE 139 +-# define TS_F_TS_TST_INFO_SET_POLICY_ID 140 +-# define TS_F_TS_TST_INFO_SET_SERIAL 141 +-# define TS_F_TS_TST_INFO_SET_TIME 142 +-# define TS_F_TS_TST_INFO_SET_TSA 143 +-# define TS_F_TS_VERIFY 108 +-# define TS_F_TS_VERIFY_CERT 109 +-# define TS_F_TS_VERIFY_CTX_NEW 144 +- +-/* +- * TS reason codes. +- */ +-# define TS_R_BAD_PKCS7_TYPE 132 +-# define TS_R_BAD_TYPE 133 +-# define TS_R_CANNOT_LOAD_CERT 137 +-# define TS_R_CANNOT_LOAD_KEY 138 +-# define TS_R_CERTIFICATE_VERIFY_ERROR 100 +-# define TS_R_COULD_NOT_SET_ENGINE 127 +-# define TS_R_COULD_NOT_SET_TIME 115 +-# define TS_R_DETACHED_CONTENT 134 +-# define TS_R_ESS_ADD_SIGNING_CERT_ERROR 116 +-# define TS_R_ESS_ADD_SIGNING_CERT_V2_ERROR 139 +-# define TS_R_ESS_SIGNING_CERTIFICATE_ERROR 101 +-# define TS_R_INVALID_NULL_POINTER 102 +-# define TS_R_INVALID_SIGNER_CERTIFICATE_PURPOSE 117 +-# define TS_R_MESSAGE_IMPRINT_MISMATCH 103 +-# define TS_R_NONCE_MISMATCH 104 +-# define TS_R_NONCE_NOT_RETURNED 105 +-# define TS_R_NO_CONTENT 106 +-# define TS_R_NO_TIME_STAMP_TOKEN 107 +-# define TS_R_PKCS7_ADD_SIGNATURE_ERROR 118 +-# define TS_R_PKCS7_ADD_SIGNED_ATTR_ERROR 119 +-# define TS_R_PKCS7_TO_TS_TST_INFO_FAILED 129 +-# define TS_R_POLICY_MISMATCH 108 +-# define TS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 120 +-# define TS_R_RESPONSE_SETUP_ERROR 121 +-# define TS_R_SIGNATURE_FAILURE 109 +-# define TS_R_THERE_MUST_BE_ONE_SIGNER 110 +-# define TS_R_TIME_SYSCALL_ERROR 122 +-# define TS_R_TOKEN_NOT_PRESENT 130 +-# define TS_R_TOKEN_PRESENT 131 +-# define TS_R_TSA_NAME_MISMATCH 111 +-# define TS_R_TSA_UNTRUSTED 112 +-# define TS_R_TST_INFO_SETUP_ERROR 123 +-# define TS_R_TS_DATASIGN 124 +-# define TS_R_UNACCEPTABLE_POLICY 125 +-# define TS_R_UNSUPPORTED_MD_ALGORITHM 126 +-# define TS_R_UNSUPPORTED_VERSION 113 +-# define TS_R_VAR_BAD_VALUE 135 +-# define TS_R_VAR_LOOKUP_FAILURE 136 +-# define TS_R_WRONG_CONTENT_TYPE 114 +- +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/txt_db.h b/uadk_tool/include/openssl/txt_db.h +deleted file mode 100644 +index ec981a4..0000000 +--- a/uadk_tool/include/openssl/txt_db.h ++++ /dev/null +@@ -1,57 +0,0 @@ +-/* +- * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_TXT_DB_H +-# define HEADER_TXT_DB_H +- +-# include +-# include +-# include +-# include +- +-# define DB_ERROR_OK 0 +-# define DB_ERROR_MALLOC 1 +-# define DB_ERROR_INDEX_CLASH 2 +-# define DB_ERROR_INDEX_OUT_OF_RANGE 3 +-# define DB_ERROR_NO_INDEX 4 +-# define DB_ERROR_INSERT_INDEX_CLASH 5 +-# define DB_ERROR_WRONG_NUM_FIELDS 6 +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-typedef OPENSSL_STRING *OPENSSL_PSTRING; +-DEFINE_SPECIAL_STACK_OF(OPENSSL_PSTRING, OPENSSL_STRING) +- +-typedef struct txt_db_st { +- int num_fields; +- STACK_OF(OPENSSL_PSTRING) *data; +- LHASH_OF(OPENSSL_STRING) **index; +- int (**qual) (OPENSSL_STRING *); +- long error; +- long arg1; +- long arg2; +- OPENSSL_STRING *arg_row; +-} TXT_DB; +- +-TXT_DB *TXT_DB_read(BIO *in, int num); +-long TXT_DB_write(BIO *out, TXT_DB *db); +-int TXT_DB_create_index(TXT_DB *db, int field, int (*qual) (OPENSSL_STRING *), +- OPENSSL_LH_HASHFUNC hash, OPENSSL_LH_COMPFUNC cmp); +-void TXT_DB_free(TXT_DB *db); +-OPENSSL_STRING *TXT_DB_get_by_index(TXT_DB *db, int idx, +- OPENSSL_STRING *value); +-int TXT_DB_insert(TXT_DB *db, OPENSSL_STRING *value); +- +-#ifdef __cplusplus +-} +-#endif +- +-#endif +diff --git a/uadk_tool/include/openssl/ui.h b/uadk_tool/include/openssl/ui.h +deleted file mode 100644 +index 7c721ec..0000000 +--- a/uadk_tool/include/openssl/ui.h ++++ /dev/null +@@ -1,368 +0,0 @@ +-/* +- * Copyright 2001-2018 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_UI_H +-# define HEADER_UI_H +- +-# include +- +-# if OPENSSL_API_COMPAT < 0x10100000L +-# include +-# endif +-# include +-# include +-# include +-# include +- +-/* For compatibility reasons, the macro OPENSSL_NO_UI is currently retained */ +-# if OPENSSL_API_COMPAT < 0x10200000L +-# ifdef OPENSSL_NO_UI_CONSOLE +-# define OPENSSL_NO_UI +-# endif +-# endif +- +-# ifdef __cplusplus +-extern "C" { +-# endif +- +-/* +- * All the following functions return -1 or NULL on error and in some cases +- * (UI_process()) -2 if interrupted or in some other way cancelled. When +- * everything is fine, they return 0, a positive value or a non-NULL pointer, +- * all depending on their purpose. +- */ +- +-/* Creators and destructor. */ +-UI *UI_new(void); +-UI *UI_new_method(const UI_METHOD *method); +-void UI_free(UI *ui); +- +-/*- +- The following functions are used to add strings to be printed and prompt +- strings to prompt for data. The names are UI_{add,dup}__string +- and UI_{add,dup}_input_boolean. +- +- UI_{add,dup}__string have the following meanings: +- add add a text or prompt string. The pointers given to these +- functions are used verbatim, no copying is done. +- dup make a copy of the text or prompt string, then add the copy +- to the collection of strings in the user interface. +- +- The function is a name for the functionality that the given +- string shall be used for. It can be one of: +- input use the string as data prompt. +- verify use the string as verification prompt. This +- is used to verify a previous input. +- info use the string for informational output. +- error use the string for error output. +- Honestly, there's currently no difference between info and error for the +- moment. +- +- UI_{add,dup}_input_boolean have the same semantics for "add" and "dup", +- and are typically used when one wants to prompt for a yes/no response. +- +- All of the functions in this group take a UI and a prompt string. +- The string input and verify addition functions also take a flag argument, +- a buffer for the result to end up with, a minimum input size and a maximum +- input size (the result buffer MUST be large enough to be able to contain +- the maximum number of characters). Additionally, the verify addition +- functions takes another buffer to compare the result against. +- The boolean input functions take an action description string (which should +- be safe to ignore if the expected user action is obvious, for example with +- a dialog box with an OK button and a Cancel button), a string of acceptable +- characters to mean OK and to mean Cancel. The two last strings are checked +- to make sure they don't have common characters. Additionally, the same +- flag argument as for the string input is taken, as well as a result buffer. +- The result buffer is required to be at least one byte long. Depending on +- the answer, the first character from the OK or the Cancel character strings +- will be stored in the first byte of the result buffer. No NUL will be +- added, so the result is *not* a string. +- +- On success, the all return an index of the added information. That index +- is useful when retrieving results with UI_get0_result(). */ +-int UI_add_input_string(UI *ui, const char *prompt, int flags, +- char *result_buf, int minsize, int maxsize); +-int UI_dup_input_string(UI *ui, const char *prompt, int flags, +- char *result_buf, int minsize, int maxsize); +-int UI_add_verify_string(UI *ui, const char *prompt, int flags, +- char *result_buf, int minsize, int maxsize, +- const char *test_buf); +-int UI_dup_verify_string(UI *ui, const char *prompt, int flags, +- char *result_buf, int minsize, int maxsize, +- const char *test_buf); +-int UI_add_input_boolean(UI *ui, const char *prompt, const char *action_desc, +- const char *ok_chars, const char *cancel_chars, +- int flags, char *result_buf); +-int UI_dup_input_boolean(UI *ui, const char *prompt, const char *action_desc, +- const char *ok_chars, const char *cancel_chars, +- int flags, char *result_buf); +-int UI_add_info_string(UI *ui, const char *text); +-int UI_dup_info_string(UI *ui, const char *text); +-int UI_add_error_string(UI *ui, const char *text); +-int UI_dup_error_string(UI *ui, const char *text); +- +-/* These are the possible flags. They can be or'ed together. */ +-/* Use to have echoing of input */ +-# define UI_INPUT_FLAG_ECHO 0x01 +-/* +- * Use a default password. Where that password is found is completely up to +- * the application, it might for example be in the user data set with +- * UI_add_user_data(). It is not recommended to have more than one input in +- * each UI being marked with this flag, or the application might get +- * confused. +- */ +-# define UI_INPUT_FLAG_DEFAULT_PWD 0x02 +- +-/*- +- * The user of these routines may want to define flags of their own. The core +- * UI won't look at those, but will pass them on to the method routines. They +- * must use higher bits so they don't get confused with the UI bits above. +- * UI_INPUT_FLAG_USER_BASE tells which is the lowest bit to use. A good +- * example of use is this: +- * +- * #define MY_UI_FLAG1 (0x01 << UI_INPUT_FLAG_USER_BASE) +- * +-*/ +-# define UI_INPUT_FLAG_USER_BASE 16 +- +-/*- +- * The following function helps construct a prompt. object_desc is a +- * textual short description of the object, for example "pass phrase", +- * and object_name is the name of the object (might be a card name or +- * a file name. +- * The returned string shall always be allocated on the heap with +- * OPENSSL_malloc(), and need to be free'd with OPENSSL_free(). +- * +- * If the ui_method doesn't contain a pointer to a user-defined prompt +- * constructor, a default string is built, looking like this: +- * +- * "Enter {object_desc} for {object_name}:" +- * +- * So, if object_desc has the value "pass phrase" and object_name has +- * the value "foo.key", the resulting string is: +- * +- * "Enter pass phrase for foo.key:" +-*/ +-char *UI_construct_prompt(UI *ui_method, +- const char *object_desc, const char *object_name); +- +-/* +- * The following function is used to store a pointer to user-specific data. +- * Any previous such pointer will be returned and replaced. +- * +- * For callback purposes, this function makes a lot more sense than using +- * ex_data, since the latter requires that different parts of OpenSSL or +- * applications share the same ex_data index. +- * +- * Note that the UI_OpenSSL() method completely ignores the user data. Other +- * methods may not, however. +- */ +-void *UI_add_user_data(UI *ui, void *user_data); +-/* +- * Alternatively, this function is used to duplicate the user data. +- * This uses the duplicator method function. The destroy function will +- * be used to free the user data in this case. +- */ +-int UI_dup_user_data(UI *ui, void *user_data); +-/* We need a user data retrieving function as well. */ +-void *UI_get0_user_data(UI *ui); +- +-/* Return the result associated with a prompt given with the index i. */ +-const char *UI_get0_result(UI *ui, int i); +-int UI_get_result_length(UI *ui, int i); +- +-/* When all strings have been added, process the whole thing. */ +-int UI_process(UI *ui); +- +-/* +- * Give a user interface parameterised control commands. This can be used to +- * send down an integer, a data pointer or a function pointer, as well as be +- * used to get information from a UI. +- */ +-int UI_ctrl(UI *ui, int cmd, long i, void *p, void (*f) (void)); +- +-/* The commands */ +-/* +- * Use UI_CONTROL_PRINT_ERRORS with the value 1 to have UI_process print the +- * OpenSSL error stack before printing any info or added error messages and +- * before any prompting. +- */ +-# define UI_CTRL_PRINT_ERRORS 1 +-/* +- * Check if a UI_process() is possible to do again with the same instance of +- * a user interface. This makes UI_ctrl() return 1 if it is redoable, and 0 +- * if not. +- */ +-# define UI_CTRL_IS_REDOABLE 2 +- +-/* Some methods may use extra data */ +-# define UI_set_app_data(s,arg) UI_set_ex_data(s,0,arg) +-# define UI_get_app_data(s) UI_get_ex_data(s,0) +- +-# define UI_get_ex_new_index(l, p, newf, dupf, freef) \ +- CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_UI, l, p, newf, dupf, freef) +-int UI_set_ex_data(UI *r, int idx, void *arg); +-void *UI_get_ex_data(UI *r, int idx); +- +-/* Use specific methods instead of the built-in one */ +-void UI_set_default_method(const UI_METHOD *meth); +-const UI_METHOD *UI_get_default_method(void); +-const UI_METHOD *UI_get_method(UI *ui); +-const UI_METHOD *UI_set_method(UI *ui, const UI_METHOD *meth); +- +-# ifndef OPENSSL_NO_UI_CONSOLE +- +-/* The method with all the built-in thingies */ +-UI_METHOD *UI_OpenSSL(void); +- +-# endif +- +-/* +- * NULL method. Literally does nothing, but may serve as a placeholder +- * to avoid internal default. +- */ +-const UI_METHOD *UI_null(void); +- +-/* ---------- For method writers ---------- */ +-/*- +- A method contains a number of functions that implement the low level +- of the User Interface. The functions are: +- +- an opener This function starts a session, maybe by opening +- a channel to a tty, or by opening a window. +- a writer This function is called to write a given string, +- maybe to the tty, maybe as a field label in a +- window. +- a flusher This function is called to flush everything that +- has been output so far. It can be used to actually +- display a dialog box after it has been built. +- a reader This function is called to read a given prompt, +- maybe from the tty, maybe from a field in a +- window. Note that it's called with all string +- structures, not only the prompt ones, so it must +- check such things itself. +- a closer This function closes the session, maybe by closing +- the channel to the tty, or closing the window. +- +- All these functions are expected to return: +- +- 0 on error. +- 1 on success. +- -1 on out-of-band events, for example if some prompting has +- been canceled (by pressing Ctrl-C, for example). This is +- only checked when returned by the flusher or the reader. +- +- The way this is used, the opener is first called, then the writer for all +- strings, then the flusher, then the reader for all strings and finally the +- closer. Note that if you want to prompt from a terminal or other command +- line interface, the best is to have the reader also write the prompts +- instead of having the writer do it. If you want to prompt from a dialog +- box, the writer can be used to build up the contents of the box, and the +- flusher to actually display the box and run the event loop until all data +- has been given, after which the reader only grabs the given data and puts +- them back into the UI strings. +- +- All method functions take a UI as argument. Additionally, the writer and +- the reader take a UI_STRING. +-*/ +- +-/* +- * The UI_STRING type is the data structure that contains all the needed info +- * about a string or a prompt, including test data for a verification prompt. +- */ +-typedef struct ui_string_st UI_STRING; +-DEFINE_STACK_OF(UI_STRING) +- +-/* +- * The different types of strings that are currently supported. This is only +- * needed by method authors. +- */ +-enum UI_string_types { +- UIT_NONE = 0, +- UIT_PROMPT, /* Prompt for a string */ +- UIT_VERIFY, /* Prompt for a string and verify */ +- UIT_BOOLEAN, /* Prompt for a yes/no response */ +- UIT_INFO, /* Send info to the user */ +- UIT_ERROR /* Send an error message to the user */ +-}; +- +-/* Create and manipulate methods */ +-UI_METHOD *UI_create_method(const char *name); +-void UI_destroy_method(UI_METHOD *ui_method); +-int UI_method_set_opener(UI_METHOD *method, int (*opener) (UI *ui)); +-int UI_method_set_writer(UI_METHOD *method, +- int (*writer) (UI *ui, UI_STRING *uis)); +-int UI_method_set_flusher(UI_METHOD *method, int (*flusher) (UI *ui)); +-int UI_method_set_reader(UI_METHOD *method, +- int (*reader) (UI *ui, UI_STRING *uis)); +-int UI_method_set_closer(UI_METHOD *method, int (*closer) (UI *ui)); +-int UI_method_set_data_duplicator(UI_METHOD *method, +- void *(*duplicator) (UI *ui, void *ui_data), +- void (*destructor)(UI *ui, void *ui_data)); +-int UI_method_set_prompt_constructor(UI_METHOD *method, +- char *(*prompt_constructor) (UI *ui, +- const char +- *object_desc, +- const char +- *object_name)); +-int UI_method_set_ex_data(UI_METHOD *method, int idx, void *data); +-int (*UI_method_get_opener(const UI_METHOD *method)) (UI *); +-int (*UI_method_get_writer(const UI_METHOD *method)) (UI *, UI_STRING *); +-int (*UI_method_get_flusher(const UI_METHOD *method)) (UI *); +-int (*UI_method_get_reader(const UI_METHOD *method)) (UI *, UI_STRING *); +-int (*UI_method_get_closer(const UI_METHOD *method)) (UI *); +-char *(*UI_method_get_prompt_constructor(const UI_METHOD *method)) +- (UI *, const char *, const char *); +-void *(*UI_method_get_data_duplicator(const UI_METHOD *method)) (UI *, void *); +-void (*UI_method_get_data_destructor(const UI_METHOD *method)) (UI *, void *); +-const void *UI_method_get_ex_data(const UI_METHOD *method, int idx); +- +-/* +- * The following functions are helpers for method writers to access relevant +- * data from a UI_STRING. +- */ +- +-/* Return type of the UI_STRING */ +-enum UI_string_types UI_get_string_type(UI_STRING *uis); +-/* Return input flags of the UI_STRING */ +-int UI_get_input_flags(UI_STRING *uis); +-/* Return the actual string to output (the prompt, info or error) */ +-const char *UI_get0_output_string(UI_STRING *uis); +-/* +- * Return the optional action string to output (the boolean prompt +- * instruction) +- */ +-const char *UI_get0_action_string(UI_STRING *uis); +-/* Return the result of a prompt */ +-const char *UI_get0_result_string(UI_STRING *uis); +-int UI_get_result_string_length(UI_STRING *uis); +-/* +- * Return the string to test the result against. Only useful with verifies. +- */ +-const char *UI_get0_test_string(UI_STRING *uis); +-/* Return the required minimum size of the result */ +-int UI_get_result_minsize(UI_STRING *uis); +-/* Return the required maximum size of the result */ +-int UI_get_result_maxsize(UI_STRING *uis); +-/* Set the result of a UI_STRING. */ +-int UI_set_result(UI *ui, UI_STRING *uis, const char *result); +-int UI_set_result_ex(UI *ui, UI_STRING *uis, const char *result, int len); +- +-/* A couple of popular utility functions */ +-int UI_UTIL_read_pw_string(char *buf, int length, const char *prompt, +- int verify); +-int UI_UTIL_read_pw(char *buf, char *buff, int size, const char *prompt, +- int verify); +-UI_METHOD *UI_UTIL_wrap_read_pem_callback(pem_password_cb *cb, int rwflag); +- +- +-# ifdef __cplusplus +-} +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/uierr.h b/uadk_tool/include/openssl/uierr.h +deleted file mode 100644 +index bd68864..0000000 +--- a/uadk_tool/include/openssl/uierr.h ++++ /dev/null +@@ -1,65 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_UIERR_H +-# define HEADER_UIERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_UI_strings(void); +- +-/* +- * UI function codes. +- */ +-# define UI_F_CLOSE_CONSOLE 115 +-# define UI_F_ECHO_CONSOLE 116 +-# define UI_F_GENERAL_ALLOCATE_BOOLEAN 108 +-# define UI_F_GENERAL_ALLOCATE_PROMPT 109 +-# define UI_F_NOECHO_CONSOLE 117 +-# define UI_F_OPEN_CONSOLE 114 +-# define UI_F_UI_CONSTRUCT_PROMPT 121 +-# define UI_F_UI_CREATE_METHOD 112 +-# define UI_F_UI_CTRL 111 +-# define UI_F_UI_DUP_ERROR_STRING 101 +-# define UI_F_UI_DUP_INFO_STRING 102 +-# define UI_F_UI_DUP_INPUT_BOOLEAN 110 +-# define UI_F_UI_DUP_INPUT_STRING 103 +-# define UI_F_UI_DUP_USER_DATA 118 +-# define UI_F_UI_DUP_VERIFY_STRING 106 +-# define UI_F_UI_GET0_RESULT 107 +-# define UI_F_UI_GET_RESULT_LENGTH 119 +-# define UI_F_UI_NEW_METHOD 104 +-# define UI_F_UI_PROCESS 113 +-# define UI_F_UI_SET_RESULT 105 +-# define UI_F_UI_SET_RESULT_EX 120 +- +-/* +- * UI reason codes. +- */ +-# define UI_R_COMMON_OK_AND_CANCEL_CHARACTERS 104 +-# define UI_R_INDEX_TOO_LARGE 102 +-# define UI_R_INDEX_TOO_SMALL 103 +-# define UI_R_NO_RESULT_BUFFER 105 +-# define UI_R_PROCESSING_ERROR 107 +-# define UI_R_RESULT_TOO_LARGE 100 +-# define UI_R_RESULT_TOO_SMALL 101 +-# define UI_R_SYSASSIGN_ERROR 109 +-# define UI_R_SYSDASSGN_ERROR 110 +-# define UI_R_SYSQIOW_ERROR 111 +-# define UI_R_UNKNOWN_CONTROL_COMMAND 106 +-# define UI_R_UNKNOWN_TTYGET_ERRNO_VALUE 108 +-# define UI_R_USER_DATA_DUPLICATION_UNSUPPORTED 112 +- +-#endif +diff --git a/uadk_tool/include/openssl/whrlpool.h b/uadk_tool/include/openssl/whrlpool.h +deleted file mode 100644 +index 20ea350..0000000 +--- a/uadk_tool/include/openssl/whrlpool.h ++++ /dev/null +@@ -1,48 +0,0 @@ +-/* +- * Copyright 2005-2016 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_WHRLPOOL_H +-# define HEADER_WHRLPOOL_H +- +-#include +- +-# ifndef OPENSSL_NO_WHIRLPOOL +-# include +-# include +-# ifdef __cplusplus +-extern "C" { +-# endif +- +-# define WHIRLPOOL_DIGEST_LENGTH (512/8) +-# define WHIRLPOOL_BBLOCK 512 +-# define WHIRLPOOL_COUNTER (256/8) +- +-typedef struct { +- union { +- unsigned char c[WHIRLPOOL_DIGEST_LENGTH]; +- /* double q is here to ensure 64-bit alignment */ +- double q[WHIRLPOOL_DIGEST_LENGTH / sizeof(double)]; +- } H; +- unsigned char data[WHIRLPOOL_BBLOCK / 8]; +- unsigned int bitoff; +- size_t bitlen[WHIRLPOOL_COUNTER / sizeof(size_t)]; +-} WHIRLPOOL_CTX; +- +-int WHIRLPOOL_Init(WHIRLPOOL_CTX *c); +-int WHIRLPOOL_Update(WHIRLPOOL_CTX *c, const void *inp, size_t bytes); +-void WHIRLPOOL_BitUpdate(WHIRLPOOL_CTX *c, const void *inp, size_t bits); +-int WHIRLPOOL_Final(unsigned char *md, WHIRLPOOL_CTX *c); +-unsigned char *WHIRLPOOL(const void *inp, size_t bytes, unsigned char *md); +- +-# ifdef __cplusplus +-} +-# endif +-# endif +- +-#endif +diff --git a/uadk_tool/include/openssl/x509.h b/uadk_tool/include/openssl/x509.h +deleted file mode 100644 +index 3ff86ec..0000000 +--- a/uadk_tool/include/openssl/x509.h ++++ /dev/null +@@ -1,1050 +0,0 @@ +-/* +- * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. +- * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_X509_H +-# define HEADER_X509_H +- +-# include +-# include +-# include +-# include +-# include +-# include +-# include +-# include +-# include +- +-# if OPENSSL_API_COMPAT < 0x10100000L +-# include +-# include +-# include +-# endif +- +-# include +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +- +-/* Flags for X509_get_signature_info() */ +-/* Signature info is valid */ +-# define X509_SIG_INFO_VALID 0x1 +-/* Signature is suitable for TLS use */ +-# define X509_SIG_INFO_TLS 0x2 +- +-# define X509_FILETYPE_PEM 1 +-# define X509_FILETYPE_ASN1 2 +-# define X509_FILETYPE_DEFAULT 3 +- +-# define X509v3_KU_DIGITAL_SIGNATURE 0x0080 +-# define X509v3_KU_NON_REPUDIATION 0x0040 +-# define X509v3_KU_KEY_ENCIPHERMENT 0x0020 +-# define X509v3_KU_DATA_ENCIPHERMENT 0x0010 +-# define X509v3_KU_KEY_AGREEMENT 0x0008 +-# define X509v3_KU_KEY_CERT_SIGN 0x0004 +-# define X509v3_KU_CRL_SIGN 0x0002 +-# define X509v3_KU_ENCIPHER_ONLY 0x0001 +-# define X509v3_KU_DECIPHER_ONLY 0x8000 +-# define X509v3_KU_UNDEF 0xffff +- +-struct X509_algor_st { +- ASN1_OBJECT *algorithm; +- ASN1_TYPE *parameter; +-} /* X509_ALGOR */ ; +- +-typedef STACK_OF(X509_ALGOR) X509_ALGORS; +- +-typedef struct X509_val_st { +- ASN1_TIME *notBefore; +- ASN1_TIME *notAfter; +-} X509_VAL; +- +-typedef struct X509_sig_st X509_SIG; +- +-typedef struct X509_name_entry_st X509_NAME_ENTRY; +- +-DEFINE_STACK_OF(X509_NAME_ENTRY) +- +-DEFINE_STACK_OF(X509_NAME) +- +-# define X509_EX_V_NETSCAPE_HACK 0x8000 +-# define X509_EX_V_INIT 0x0001 +-typedef struct X509_extension_st X509_EXTENSION; +- +-typedef STACK_OF(X509_EXTENSION) X509_EXTENSIONS; +- +-DEFINE_STACK_OF(X509_EXTENSION) +- +-typedef struct x509_attributes_st X509_ATTRIBUTE; +- +-DEFINE_STACK_OF(X509_ATTRIBUTE) +- +-typedef struct X509_req_info_st X509_REQ_INFO; +- +-typedef struct X509_req_st X509_REQ; +- +-typedef struct x509_cert_aux_st X509_CERT_AUX; +- +-typedef struct x509_cinf_st X509_CINF; +- +-DEFINE_STACK_OF(X509) +- +-/* This is used for a table of trust checking functions */ +- +-typedef struct x509_trust_st { +- int trust; +- int flags; +- int (*check_trust) (struct x509_trust_st *, X509 *, int); +- char *name; +- int arg1; +- void *arg2; +-} X509_TRUST; +- +-DEFINE_STACK_OF(X509_TRUST) +- +-/* standard trust ids */ +- +-# define X509_TRUST_DEFAULT 0 /* Only valid in purpose settings */ +- +-# define X509_TRUST_COMPAT 1 +-# define X509_TRUST_SSL_CLIENT 2 +-# define X509_TRUST_SSL_SERVER 3 +-# define X509_TRUST_EMAIL 4 +-# define X509_TRUST_OBJECT_SIGN 5 +-# define X509_TRUST_OCSP_SIGN 6 +-# define X509_TRUST_OCSP_REQUEST 7 +-# define X509_TRUST_TSA 8 +- +-/* Keep these up to date! */ +-# define X509_TRUST_MIN 1 +-# define X509_TRUST_MAX 8 +- +-/* trust_flags values */ +-# define X509_TRUST_DYNAMIC (1U << 0) +-# define X509_TRUST_DYNAMIC_NAME (1U << 1) +-/* No compat trust if self-signed, preempts "DO_SS" */ +-# define X509_TRUST_NO_SS_COMPAT (1U << 2) +-/* Compat trust if no explicit accepted trust EKUs */ +-# define X509_TRUST_DO_SS_COMPAT (1U << 3) +-/* Accept "anyEKU" as a wildcard trust OID */ +-# define X509_TRUST_OK_ANY_EKU (1U << 4) +- +-/* check_trust return codes */ +- +-# define X509_TRUST_TRUSTED 1 +-# define X509_TRUST_REJECTED 2 +-# define X509_TRUST_UNTRUSTED 3 +- +-/* Flags for X509_print_ex() */ +- +-# define X509_FLAG_COMPAT 0 +-# define X509_FLAG_NO_HEADER 1L +-# define X509_FLAG_NO_VERSION (1L << 1) +-# define X509_FLAG_NO_SERIAL (1L << 2) +-# define X509_FLAG_NO_SIGNAME (1L << 3) +-# define X509_FLAG_NO_ISSUER (1L << 4) +-# define X509_FLAG_NO_VALIDITY (1L << 5) +-# define X509_FLAG_NO_SUBJECT (1L << 6) +-# define X509_FLAG_NO_PUBKEY (1L << 7) +-# define X509_FLAG_NO_EXTENSIONS (1L << 8) +-# define X509_FLAG_NO_SIGDUMP (1L << 9) +-# define X509_FLAG_NO_AUX (1L << 10) +-# define X509_FLAG_NO_ATTRIBUTES (1L << 11) +-# define X509_FLAG_NO_IDS (1L << 12) +- +-/* Flags specific to X509_NAME_print_ex() */ +- +-/* The field separator information */ +- +-# define XN_FLAG_SEP_MASK (0xf << 16) +- +-# define XN_FLAG_COMPAT 0/* Traditional; use old X509_NAME_print */ +-# define XN_FLAG_SEP_COMMA_PLUS (1 << 16)/* RFC2253 ,+ */ +-# define XN_FLAG_SEP_CPLUS_SPC (2 << 16)/* ,+ spaced: more readable */ +-# define XN_FLAG_SEP_SPLUS_SPC (3 << 16)/* ;+ spaced */ +-# define XN_FLAG_SEP_MULTILINE (4 << 16)/* One line per field */ +- +-# define XN_FLAG_DN_REV (1 << 20)/* Reverse DN order */ +- +-/* How the field name is shown */ +- +-# define XN_FLAG_FN_MASK (0x3 << 21) +- +-# define XN_FLAG_FN_SN 0/* Object short name */ +-# define XN_FLAG_FN_LN (1 << 21)/* Object long name */ +-# define XN_FLAG_FN_OID (2 << 21)/* Always use OIDs */ +-# define XN_FLAG_FN_NONE (3 << 21)/* No field names */ +- +-# define XN_FLAG_SPC_EQ (1 << 23)/* Put spaces round '=' */ +- +-/* +- * This determines if we dump fields we don't recognise: RFC2253 requires +- * this. +- */ +- +-# define XN_FLAG_DUMP_UNKNOWN_FIELDS (1 << 24) +- +-# define XN_FLAG_FN_ALIGN (1 << 25)/* Align field names to 20 +- * characters */ +- +-/* Complete set of RFC2253 flags */ +- +-# define XN_FLAG_RFC2253 (ASN1_STRFLGS_RFC2253 | \ +- XN_FLAG_SEP_COMMA_PLUS | \ +- XN_FLAG_DN_REV | \ +- XN_FLAG_FN_SN | \ +- XN_FLAG_DUMP_UNKNOWN_FIELDS) +- +-/* readable oneline form */ +- +-# define XN_FLAG_ONELINE (ASN1_STRFLGS_RFC2253 | \ +- ASN1_STRFLGS_ESC_QUOTE | \ +- XN_FLAG_SEP_CPLUS_SPC | \ +- XN_FLAG_SPC_EQ | \ +- XN_FLAG_FN_SN) +- +-/* readable multiline form */ +- +-# define XN_FLAG_MULTILINE (ASN1_STRFLGS_ESC_CTRL | \ +- ASN1_STRFLGS_ESC_MSB | \ +- XN_FLAG_SEP_MULTILINE | \ +- XN_FLAG_SPC_EQ | \ +- XN_FLAG_FN_LN | \ +- XN_FLAG_FN_ALIGN) +- +-DEFINE_STACK_OF(X509_REVOKED) +- +-typedef struct X509_crl_info_st X509_CRL_INFO; +- +-DEFINE_STACK_OF(X509_CRL) +- +-typedef struct private_key_st { +- int version; +- /* The PKCS#8 data types */ +- X509_ALGOR *enc_algor; +- ASN1_OCTET_STRING *enc_pkey; /* encrypted pub key */ +- /* When decrypted, the following will not be NULL */ +- EVP_PKEY *dec_pkey; +- /* used to encrypt and decrypt */ +- int key_length; +- char *key_data; +- int key_free; /* true if we should auto free key_data */ +- /* expanded version of 'enc_algor' */ +- EVP_CIPHER_INFO cipher; +-} X509_PKEY; +- +-typedef struct X509_info_st { +- X509 *x509; +- X509_CRL *crl; +- X509_PKEY *x_pkey; +- EVP_CIPHER_INFO enc_cipher; +- int enc_len; +- char *enc_data; +-} X509_INFO; +- +-DEFINE_STACK_OF(X509_INFO) +- +-/* +- * The next 2 structures and their 8 routines are used to manipulate Netscape's +- * spki structures - useful if you are writing a CA web page +- */ +-typedef struct Netscape_spkac_st { +- X509_PUBKEY *pubkey; +- ASN1_IA5STRING *challenge; /* challenge sent in atlas >= PR2 */ +-} NETSCAPE_SPKAC; +- +-typedef struct Netscape_spki_st { +- NETSCAPE_SPKAC *spkac; /* signed public key and challenge */ +- X509_ALGOR sig_algor; +- ASN1_BIT_STRING *signature; +-} NETSCAPE_SPKI; +- +-/* Netscape certificate sequence structure */ +-typedef struct Netscape_certificate_sequence { +- ASN1_OBJECT *type; +- STACK_OF(X509) *certs; +-} NETSCAPE_CERT_SEQUENCE; +- +-/*- Unused (and iv length is wrong) +-typedef struct CBCParameter_st +- { +- unsigned char iv[8]; +- } CBC_PARAM; +-*/ +- +-/* Password based encryption structure */ +- +-typedef struct PBEPARAM_st { +- ASN1_OCTET_STRING *salt; +- ASN1_INTEGER *iter; +-} PBEPARAM; +- +-/* Password based encryption V2 structures */ +- +-typedef struct PBE2PARAM_st { +- X509_ALGOR *keyfunc; +- X509_ALGOR *encryption; +-} PBE2PARAM; +- +-typedef struct PBKDF2PARAM_st { +-/* Usually OCTET STRING but could be anything */ +- ASN1_TYPE *salt; +- ASN1_INTEGER *iter; +- ASN1_INTEGER *keylength; +- X509_ALGOR *prf; +-} PBKDF2PARAM; +- +-#ifndef OPENSSL_NO_SCRYPT +-typedef struct SCRYPT_PARAMS_st { +- ASN1_OCTET_STRING *salt; +- ASN1_INTEGER *costParameter; +- ASN1_INTEGER *blockSize; +- ASN1_INTEGER *parallelizationParameter; +- ASN1_INTEGER *keyLength; +-} SCRYPT_PARAMS; +-#endif +- +-#ifdef __cplusplus +-} +-#endif +- +-# include +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-# define X509_EXT_PACK_UNKNOWN 1 +-# define X509_EXT_PACK_STRING 2 +- +-# define X509_extract_key(x) X509_get_pubkey(x)/*****/ +-# define X509_REQ_extract_key(a) X509_REQ_get_pubkey(a) +-# define X509_name_cmp(a,b) X509_NAME_cmp((a),(b)) +- +-void X509_CRL_set_default_method(const X509_CRL_METHOD *meth); +-X509_CRL_METHOD *X509_CRL_METHOD_new(int (*crl_init) (X509_CRL *crl), +- int (*crl_free) (X509_CRL *crl), +- int (*crl_lookup) (X509_CRL *crl, +- X509_REVOKED **ret, +- ASN1_INTEGER *ser, +- X509_NAME *issuer), +- int (*crl_verify) (X509_CRL *crl, +- EVP_PKEY *pk)); +-void X509_CRL_METHOD_free(X509_CRL_METHOD *m); +- +-void X509_CRL_set_meth_data(X509_CRL *crl, void *dat); +-void *X509_CRL_get_meth_data(X509_CRL *crl); +- +-const char *X509_verify_cert_error_string(long n); +- +-int X509_verify(X509 *a, EVP_PKEY *r); +- +-int X509_REQ_verify(X509_REQ *a, EVP_PKEY *r); +-int X509_CRL_verify(X509_CRL *a, EVP_PKEY *r); +-int NETSCAPE_SPKI_verify(NETSCAPE_SPKI *a, EVP_PKEY *r); +- +-NETSCAPE_SPKI *NETSCAPE_SPKI_b64_decode(const char *str, int len); +-char *NETSCAPE_SPKI_b64_encode(NETSCAPE_SPKI *x); +-EVP_PKEY *NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI *x); +-int NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI *x, EVP_PKEY *pkey); +- +-int NETSCAPE_SPKI_print(BIO *out, NETSCAPE_SPKI *spki); +- +-int X509_signature_dump(BIO *bp, const ASN1_STRING *sig, int indent); +-int X509_signature_print(BIO *bp, const X509_ALGOR *alg, +- const ASN1_STRING *sig); +- +-int X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md); +-int X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx); +-# ifndef OPENSSL_NO_OCSP +-int X509_http_nbio(OCSP_REQ_CTX *rctx, X509 **pcert); +-# endif +-int X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md); +-int X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx); +-int X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md); +-int X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx); +-# ifndef OPENSSL_NO_OCSP +-int X509_CRL_http_nbio(OCSP_REQ_CTX *rctx, X509_CRL **pcrl); +-# endif +-int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md); +- +-int X509_pubkey_digest(const X509 *data, const EVP_MD *type, +- unsigned char *md, unsigned int *len); +-int X509_digest(const X509 *data, const EVP_MD *type, +- unsigned char *md, unsigned int *len); +-int X509_CRL_digest(const X509_CRL *data, const EVP_MD *type, +- unsigned char *md, unsigned int *len); +-int X509_REQ_digest(const X509_REQ *data, const EVP_MD *type, +- unsigned char *md, unsigned int *len); +-int X509_NAME_digest(const X509_NAME *data, const EVP_MD *type, +- unsigned char *md, unsigned int *len); +- +-# ifndef OPENSSL_NO_STDIO +-X509 *d2i_X509_fp(FILE *fp, X509 **x509); +-int i2d_X509_fp(FILE *fp, X509 *x509); +-X509_CRL *d2i_X509_CRL_fp(FILE *fp, X509_CRL **crl); +-int i2d_X509_CRL_fp(FILE *fp, X509_CRL *crl); +-X509_REQ *d2i_X509_REQ_fp(FILE *fp, X509_REQ **req); +-int i2d_X509_REQ_fp(FILE *fp, X509_REQ *req); +-# ifndef OPENSSL_NO_RSA +-RSA *d2i_RSAPrivateKey_fp(FILE *fp, RSA **rsa); +-int i2d_RSAPrivateKey_fp(FILE *fp, RSA *rsa); +-RSA *d2i_RSAPublicKey_fp(FILE *fp, RSA **rsa); +-int i2d_RSAPublicKey_fp(FILE *fp, RSA *rsa); +-RSA *d2i_RSA_PUBKEY_fp(FILE *fp, RSA **rsa); +-int i2d_RSA_PUBKEY_fp(FILE *fp, RSA *rsa); +-# endif +-# ifndef OPENSSL_NO_DSA +-DSA *d2i_DSA_PUBKEY_fp(FILE *fp, DSA **dsa); +-int i2d_DSA_PUBKEY_fp(FILE *fp, DSA *dsa); +-DSA *d2i_DSAPrivateKey_fp(FILE *fp, DSA **dsa); +-int i2d_DSAPrivateKey_fp(FILE *fp, DSA *dsa); +-# endif +-# ifndef OPENSSL_NO_EC +-EC_KEY *d2i_EC_PUBKEY_fp(FILE *fp, EC_KEY **eckey); +-int i2d_EC_PUBKEY_fp(FILE *fp, EC_KEY *eckey); +-EC_KEY *d2i_ECPrivateKey_fp(FILE *fp, EC_KEY **eckey); +-int i2d_ECPrivateKey_fp(FILE *fp, EC_KEY *eckey); +-# endif +-X509_SIG *d2i_PKCS8_fp(FILE *fp, X509_SIG **p8); +-int i2d_PKCS8_fp(FILE *fp, X509_SIG *p8); +-PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, +- PKCS8_PRIV_KEY_INFO **p8inf); +-int i2d_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO *p8inf); +-int i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, EVP_PKEY *key); +-int i2d_PrivateKey_fp(FILE *fp, EVP_PKEY *pkey); +-EVP_PKEY *d2i_PrivateKey_fp(FILE *fp, EVP_PKEY **a); +-int i2d_PUBKEY_fp(FILE *fp, EVP_PKEY *pkey); +-EVP_PKEY *d2i_PUBKEY_fp(FILE *fp, EVP_PKEY **a); +-# endif +- +-X509 *d2i_X509_bio(BIO *bp, X509 **x509); +-int i2d_X509_bio(BIO *bp, X509 *x509); +-X509_CRL *d2i_X509_CRL_bio(BIO *bp, X509_CRL **crl); +-int i2d_X509_CRL_bio(BIO *bp, X509_CRL *crl); +-X509_REQ *d2i_X509_REQ_bio(BIO *bp, X509_REQ **req); +-int i2d_X509_REQ_bio(BIO *bp, X509_REQ *req); +-# ifndef OPENSSL_NO_RSA +-RSA *d2i_RSAPrivateKey_bio(BIO *bp, RSA **rsa); +-int i2d_RSAPrivateKey_bio(BIO *bp, RSA *rsa); +-RSA *d2i_RSAPublicKey_bio(BIO *bp, RSA **rsa); +-int i2d_RSAPublicKey_bio(BIO *bp, RSA *rsa); +-RSA *d2i_RSA_PUBKEY_bio(BIO *bp, RSA **rsa); +-int i2d_RSA_PUBKEY_bio(BIO *bp, RSA *rsa); +-# endif +-# ifndef OPENSSL_NO_DSA +-DSA *d2i_DSA_PUBKEY_bio(BIO *bp, DSA **dsa); +-int i2d_DSA_PUBKEY_bio(BIO *bp, DSA *dsa); +-DSA *d2i_DSAPrivateKey_bio(BIO *bp, DSA **dsa); +-int i2d_DSAPrivateKey_bio(BIO *bp, DSA *dsa); +-# endif +-# ifndef OPENSSL_NO_EC +-EC_KEY *d2i_EC_PUBKEY_bio(BIO *bp, EC_KEY **eckey); +-int i2d_EC_PUBKEY_bio(BIO *bp, EC_KEY *eckey); +-EC_KEY *d2i_ECPrivateKey_bio(BIO *bp, EC_KEY **eckey); +-int i2d_ECPrivateKey_bio(BIO *bp, EC_KEY *eckey); +-# endif +-X509_SIG *d2i_PKCS8_bio(BIO *bp, X509_SIG **p8); +-int i2d_PKCS8_bio(BIO *bp, X509_SIG *p8); +-PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, +- PKCS8_PRIV_KEY_INFO **p8inf); +-int i2d_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO *p8inf); +-int i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, EVP_PKEY *key); +-int i2d_PrivateKey_bio(BIO *bp, EVP_PKEY *pkey); +-EVP_PKEY *d2i_PrivateKey_bio(BIO *bp, EVP_PKEY **a); +-int i2d_PUBKEY_bio(BIO *bp, EVP_PKEY *pkey); +-EVP_PKEY *d2i_PUBKEY_bio(BIO *bp, EVP_PKEY **a); +- +-X509 *X509_dup(X509 *x509); +-X509_ATTRIBUTE *X509_ATTRIBUTE_dup(X509_ATTRIBUTE *xa); +-X509_EXTENSION *X509_EXTENSION_dup(X509_EXTENSION *ex); +-X509_CRL *X509_CRL_dup(X509_CRL *crl); +-X509_REVOKED *X509_REVOKED_dup(X509_REVOKED *rev); +-X509_REQ *X509_REQ_dup(X509_REQ *req); +-X509_ALGOR *X509_ALGOR_dup(X509_ALGOR *xn); +-int X509_ALGOR_set0(X509_ALGOR *alg, ASN1_OBJECT *aobj, int ptype, +- void *pval); +-void X509_ALGOR_get0(const ASN1_OBJECT **paobj, int *pptype, +- const void **ppval, const X509_ALGOR *algor); +-void X509_ALGOR_set_md(X509_ALGOR *alg, const EVP_MD *md); +-int X509_ALGOR_cmp(const X509_ALGOR *a, const X509_ALGOR *b); +-int X509_ALGOR_copy(X509_ALGOR *dest, const X509_ALGOR *src); +- +-X509_NAME *X509_NAME_dup(X509_NAME *xn); +-X509_NAME_ENTRY *X509_NAME_ENTRY_dup(X509_NAME_ENTRY *ne); +- +-int X509_cmp_time(const ASN1_TIME *s, time_t *t); +-int X509_cmp_current_time(const ASN1_TIME *s); +-ASN1_TIME *X509_time_adj(ASN1_TIME *s, long adj, time_t *t); +-ASN1_TIME *X509_time_adj_ex(ASN1_TIME *s, +- int offset_day, long offset_sec, time_t *t); +-ASN1_TIME *X509_gmtime_adj(ASN1_TIME *s, long adj); +- +-const char *X509_get_default_cert_area(void); +-const char *X509_get_default_cert_dir(void); +-const char *X509_get_default_cert_file(void); +-const char *X509_get_default_cert_dir_env(void); +-const char *X509_get_default_cert_file_env(void); +-const char *X509_get_default_private_dir(void); +- +-X509_REQ *X509_to_X509_REQ(X509 *x, EVP_PKEY *pkey, const EVP_MD *md); +-X509 *X509_REQ_to_X509(X509_REQ *r, int days, EVP_PKEY *pkey); +- +-DECLARE_ASN1_FUNCTIONS(X509_ALGOR) +-DECLARE_ASN1_ENCODE_FUNCTIONS(X509_ALGORS, X509_ALGORS, X509_ALGORS) +-DECLARE_ASN1_FUNCTIONS(X509_VAL) +- +-DECLARE_ASN1_FUNCTIONS(X509_PUBKEY) +- +-int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey); +-EVP_PKEY *X509_PUBKEY_get0(X509_PUBKEY *key); +-EVP_PKEY *X509_PUBKEY_get(X509_PUBKEY *key); +-int X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK_OF(X509) *chain); +-long X509_get_pathlen(X509 *x); +-int i2d_PUBKEY(EVP_PKEY *a, unsigned char **pp); +-EVP_PKEY *d2i_PUBKEY(EVP_PKEY **a, const unsigned char **pp, long length); +-# ifndef OPENSSL_NO_RSA +-int i2d_RSA_PUBKEY(RSA *a, unsigned char **pp); +-RSA *d2i_RSA_PUBKEY(RSA **a, const unsigned char **pp, long length); +-# endif +-# ifndef OPENSSL_NO_DSA +-int i2d_DSA_PUBKEY(DSA *a, unsigned char **pp); +-DSA *d2i_DSA_PUBKEY(DSA **a, const unsigned char **pp, long length); +-# endif +-# ifndef OPENSSL_NO_EC +-int i2d_EC_PUBKEY(EC_KEY *a, unsigned char **pp); +-EC_KEY *d2i_EC_PUBKEY(EC_KEY **a, const unsigned char **pp, long length); +-# endif +- +-DECLARE_ASN1_FUNCTIONS(X509_SIG) +-void X509_SIG_get0(const X509_SIG *sig, const X509_ALGOR **palg, +- const ASN1_OCTET_STRING **pdigest); +-void X509_SIG_getm(X509_SIG *sig, X509_ALGOR **palg, +- ASN1_OCTET_STRING **pdigest); +- +-DECLARE_ASN1_FUNCTIONS(X509_REQ_INFO) +-DECLARE_ASN1_FUNCTIONS(X509_REQ) +- +-DECLARE_ASN1_FUNCTIONS(X509_ATTRIBUTE) +-X509_ATTRIBUTE *X509_ATTRIBUTE_create(int nid, int atrtype, void *value); +- +-DECLARE_ASN1_FUNCTIONS(X509_EXTENSION) +-DECLARE_ASN1_ENCODE_FUNCTIONS(X509_EXTENSIONS, X509_EXTENSIONS, X509_EXTENSIONS) +- +-DECLARE_ASN1_FUNCTIONS(X509_NAME_ENTRY) +- +-DECLARE_ASN1_FUNCTIONS(X509_NAME) +- +-int X509_NAME_set(X509_NAME **xn, X509_NAME *name); +- +-DECLARE_ASN1_FUNCTIONS(X509_CINF) +- +-DECLARE_ASN1_FUNCTIONS(X509) +-DECLARE_ASN1_FUNCTIONS(X509_CERT_AUX) +- +-#define X509_get_ex_new_index(l, p, newf, dupf, freef) \ +- CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509, l, p, newf, dupf, freef) +-int X509_set_ex_data(X509 *r, int idx, void *arg); +-void *X509_get_ex_data(X509 *r, int idx); +-int i2d_X509_AUX(X509 *a, unsigned char **pp); +-X509 *d2i_X509_AUX(X509 **a, const unsigned char **pp, long length); +- +-int i2d_re_X509_tbs(X509 *x, unsigned char **pp); +- +-int X509_SIG_INFO_get(const X509_SIG_INFO *siginf, int *mdnid, int *pknid, +- int *secbits, uint32_t *flags); +-void X509_SIG_INFO_set(X509_SIG_INFO *siginf, int mdnid, int pknid, +- int secbits, uint32_t flags); +- +-int X509_get_signature_info(X509 *x, int *mdnid, int *pknid, int *secbits, +- uint32_t *flags); +- +-void X509_get0_signature(const ASN1_BIT_STRING **psig, +- const X509_ALGOR **palg, const X509 *x); +-int X509_get_signature_nid(const X509 *x); +- +-int X509_trusted(const X509 *x); +-int X509_alias_set1(X509 *x, const unsigned char *name, int len); +-int X509_keyid_set1(X509 *x, const unsigned char *id, int len); +-unsigned char *X509_alias_get0(X509 *x, int *len); +-unsigned char *X509_keyid_get0(X509 *x, int *len); +-int (*X509_TRUST_set_default(int (*trust) (int, X509 *, int))) (int, X509 *, +- int); +-int X509_TRUST_set(int *t, int trust); +-int X509_add1_trust_object(X509 *x, const ASN1_OBJECT *obj); +-int X509_add1_reject_object(X509 *x, const ASN1_OBJECT *obj); +-void X509_trust_clear(X509 *x); +-void X509_reject_clear(X509 *x); +- +-STACK_OF(ASN1_OBJECT) *X509_get0_trust_objects(X509 *x); +-STACK_OF(ASN1_OBJECT) *X509_get0_reject_objects(X509 *x); +- +-DECLARE_ASN1_FUNCTIONS(X509_REVOKED) +-DECLARE_ASN1_FUNCTIONS(X509_CRL_INFO) +-DECLARE_ASN1_FUNCTIONS(X509_CRL) +- +-int X509_CRL_add0_revoked(X509_CRL *crl, X509_REVOKED *rev); +-int X509_CRL_get0_by_serial(X509_CRL *crl, +- X509_REVOKED **ret, ASN1_INTEGER *serial); +-int X509_CRL_get0_by_cert(X509_CRL *crl, X509_REVOKED **ret, X509 *x); +- +-X509_PKEY *X509_PKEY_new(void); +-void X509_PKEY_free(X509_PKEY *a); +- +-DECLARE_ASN1_FUNCTIONS(NETSCAPE_SPKI) +-DECLARE_ASN1_FUNCTIONS(NETSCAPE_SPKAC) +-DECLARE_ASN1_FUNCTIONS(NETSCAPE_CERT_SEQUENCE) +- +-X509_INFO *X509_INFO_new(void); +-void X509_INFO_free(X509_INFO *a); +-char *X509_NAME_oneline(const X509_NAME *a, char *buf, int size); +- +-int ASN1_verify(i2d_of_void *i2d, X509_ALGOR *algor1, +- ASN1_BIT_STRING *signature, char *data, EVP_PKEY *pkey); +- +-int ASN1_digest(i2d_of_void *i2d, const EVP_MD *type, char *data, +- unsigned char *md, unsigned int *len); +- +-int ASN1_sign(i2d_of_void *i2d, X509_ALGOR *algor1, +- X509_ALGOR *algor2, ASN1_BIT_STRING *signature, +- char *data, EVP_PKEY *pkey, const EVP_MD *type); +- +-int ASN1_item_digest(const ASN1_ITEM *it, const EVP_MD *type, void *data, +- unsigned char *md, unsigned int *len); +- +-int ASN1_item_verify(const ASN1_ITEM *it, X509_ALGOR *algor1, +- ASN1_BIT_STRING *signature, void *data, EVP_PKEY *pkey); +- +-int ASN1_item_sign(const ASN1_ITEM *it, X509_ALGOR *algor1, +- X509_ALGOR *algor2, ASN1_BIT_STRING *signature, void *data, +- EVP_PKEY *pkey, const EVP_MD *type); +-int ASN1_item_sign_ctx(const ASN1_ITEM *it, X509_ALGOR *algor1, +- X509_ALGOR *algor2, ASN1_BIT_STRING *signature, +- void *asn, EVP_MD_CTX *ctx); +- +-long X509_get_version(const X509 *x); +-int X509_set_version(X509 *x, long version); +-int X509_set_serialNumber(X509 *x, ASN1_INTEGER *serial); +-ASN1_INTEGER *X509_get_serialNumber(X509 *x); +-const ASN1_INTEGER *X509_get0_serialNumber(const X509 *x); +-int X509_set_issuer_name(X509 *x, X509_NAME *name); +-X509_NAME *X509_get_issuer_name(const X509 *a); +-int X509_set_subject_name(X509 *x, X509_NAME *name); +-X509_NAME *X509_get_subject_name(const X509 *a); +-const ASN1_TIME * X509_get0_notBefore(const X509 *x); +-ASN1_TIME *X509_getm_notBefore(const X509 *x); +-int X509_set1_notBefore(X509 *x, const ASN1_TIME *tm); +-const ASN1_TIME *X509_get0_notAfter(const X509 *x); +-ASN1_TIME *X509_getm_notAfter(const X509 *x); +-int X509_set1_notAfter(X509 *x, const ASN1_TIME *tm); +-int X509_set_pubkey(X509 *x, EVP_PKEY *pkey); +-int X509_up_ref(X509 *x); +-int X509_get_signature_type(const X509 *x); +- +-# if OPENSSL_API_COMPAT < 0x10100000L +-# define X509_get_notBefore X509_getm_notBefore +-# define X509_get_notAfter X509_getm_notAfter +-# define X509_set_notBefore X509_set1_notBefore +-# define X509_set_notAfter X509_set1_notAfter +-#endif +- +- +-/* +- * This one is only used so that a binary form can output, as in +- * i2d_X509_PUBKEY(X509_get_X509_PUBKEY(x), &buf) +- */ +-X509_PUBKEY *X509_get_X509_PUBKEY(const X509 *x); +-const STACK_OF(X509_EXTENSION) *X509_get0_extensions(const X509 *x); +-void X509_get0_uids(const X509 *x, const ASN1_BIT_STRING **piuid, +- const ASN1_BIT_STRING **psuid); +-const X509_ALGOR *X509_get0_tbs_sigalg(const X509 *x); +- +-EVP_PKEY *X509_get0_pubkey(const X509 *x); +-EVP_PKEY *X509_get_pubkey(X509 *x); +-ASN1_BIT_STRING *X509_get0_pubkey_bitstr(const X509 *x); +-int X509_certificate_type(const X509 *x, const EVP_PKEY *pubkey); +- +-long X509_REQ_get_version(const X509_REQ *req); +-int X509_REQ_set_version(X509_REQ *x, long version); +-X509_NAME *X509_REQ_get_subject_name(const X509_REQ *req); +-int X509_REQ_set_subject_name(X509_REQ *req, X509_NAME *name); +-void X509_REQ_get0_signature(const X509_REQ *req, const ASN1_BIT_STRING **psig, +- const X509_ALGOR **palg); +-void X509_REQ_set0_signature(X509_REQ *req, ASN1_BIT_STRING *psig); +-int X509_REQ_set1_signature_algo(X509_REQ *req, X509_ALGOR *palg); +-int X509_REQ_get_signature_nid(const X509_REQ *req); +-int i2d_re_X509_REQ_tbs(X509_REQ *req, unsigned char **pp); +-int X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey); +-EVP_PKEY *X509_REQ_get_pubkey(X509_REQ *req); +-EVP_PKEY *X509_REQ_get0_pubkey(X509_REQ *req); +-X509_PUBKEY *X509_REQ_get_X509_PUBKEY(X509_REQ *req); +-int X509_REQ_extension_nid(int nid); +-int *X509_REQ_get_extension_nids(void); +-void X509_REQ_set_extension_nids(int *nids); +-STACK_OF(X509_EXTENSION) *X509_REQ_get_extensions(X509_REQ *req); +-int X509_REQ_add_extensions_nid(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts, +- int nid); +-int X509_REQ_add_extensions(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts); +-int X509_REQ_get_attr_count(const X509_REQ *req); +-int X509_REQ_get_attr_by_NID(const X509_REQ *req, int nid, int lastpos); +-int X509_REQ_get_attr_by_OBJ(const X509_REQ *req, const ASN1_OBJECT *obj, +- int lastpos); +-X509_ATTRIBUTE *X509_REQ_get_attr(const X509_REQ *req, int loc); +-X509_ATTRIBUTE *X509_REQ_delete_attr(X509_REQ *req, int loc); +-int X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr); +-int X509_REQ_add1_attr_by_OBJ(X509_REQ *req, +- const ASN1_OBJECT *obj, int type, +- const unsigned char *bytes, int len); +-int X509_REQ_add1_attr_by_NID(X509_REQ *req, +- int nid, int type, +- const unsigned char *bytes, int len); +-int X509_REQ_add1_attr_by_txt(X509_REQ *req, +- const char *attrname, int type, +- const unsigned char *bytes, int len); +- +-int X509_CRL_set_version(X509_CRL *x, long version); +-int X509_CRL_set_issuer_name(X509_CRL *x, X509_NAME *name); +-int X509_CRL_set1_lastUpdate(X509_CRL *x, const ASN1_TIME *tm); +-int X509_CRL_set1_nextUpdate(X509_CRL *x, const ASN1_TIME *tm); +-int X509_CRL_sort(X509_CRL *crl); +-int X509_CRL_up_ref(X509_CRL *crl); +- +-# if OPENSSL_API_COMPAT < 0x10100000L +-# define X509_CRL_set_lastUpdate X509_CRL_set1_lastUpdate +-# define X509_CRL_set_nextUpdate X509_CRL_set1_nextUpdate +-#endif +- +-long X509_CRL_get_version(const X509_CRL *crl); +-const ASN1_TIME *X509_CRL_get0_lastUpdate(const X509_CRL *crl); +-const ASN1_TIME *X509_CRL_get0_nextUpdate(const X509_CRL *crl); +-DEPRECATEDIN_1_1_0(ASN1_TIME *X509_CRL_get_lastUpdate(X509_CRL *crl)) +-DEPRECATEDIN_1_1_0(ASN1_TIME *X509_CRL_get_nextUpdate(X509_CRL *crl)) +-X509_NAME *X509_CRL_get_issuer(const X509_CRL *crl); +-const STACK_OF(X509_EXTENSION) *X509_CRL_get0_extensions(const X509_CRL *crl); +-STACK_OF(X509_REVOKED) *X509_CRL_get_REVOKED(X509_CRL *crl); +-void X509_CRL_get0_signature(const X509_CRL *crl, const ASN1_BIT_STRING **psig, +- const X509_ALGOR **palg); +-int X509_CRL_get_signature_nid(const X509_CRL *crl); +-int i2d_re_X509_CRL_tbs(X509_CRL *req, unsigned char **pp); +- +-const ASN1_INTEGER *X509_REVOKED_get0_serialNumber(const X509_REVOKED *x); +-int X509_REVOKED_set_serialNumber(X509_REVOKED *x, ASN1_INTEGER *serial); +-const ASN1_TIME *X509_REVOKED_get0_revocationDate(const X509_REVOKED *x); +-int X509_REVOKED_set_revocationDate(X509_REVOKED *r, ASN1_TIME *tm); +-const STACK_OF(X509_EXTENSION) * +-X509_REVOKED_get0_extensions(const X509_REVOKED *r); +- +-X509_CRL *X509_CRL_diff(X509_CRL *base, X509_CRL *newer, +- EVP_PKEY *skey, const EVP_MD *md, unsigned int flags); +- +-int X509_REQ_check_private_key(X509_REQ *x509, EVP_PKEY *pkey); +- +-int X509_check_private_key(const X509 *x509, const EVP_PKEY *pkey); +-int X509_chain_check_suiteb(int *perror_depth, +- X509 *x, STACK_OF(X509) *chain, +- unsigned long flags); +-int X509_CRL_check_suiteb(X509_CRL *crl, EVP_PKEY *pk, unsigned long flags); +-STACK_OF(X509) *X509_chain_up_ref(STACK_OF(X509) *chain); +- +-int X509_issuer_and_serial_cmp(const X509 *a, const X509 *b); +-unsigned long X509_issuer_and_serial_hash(X509 *a); +- +-int X509_issuer_name_cmp(const X509 *a, const X509 *b); +-unsigned long X509_issuer_name_hash(X509 *a); +- +-int X509_subject_name_cmp(const X509 *a, const X509 *b); +-unsigned long X509_subject_name_hash(X509 *x); +- +-# ifndef OPENSSL_NO_MD5 +-unsigned long X509_issuer_name_hash_old(X509 *a); +-unsigned long X509_subject_name_hash_old(X509 *x); +-# endif +- +-int X509_cmp(const X509 *a, const X509 *b); +-int X509_NAME_cmp(const X509_NAME *a, const X509_NAME *b); +-unsigned long X509_NAME_hash(X509_NAME *x); +-unsigned long X509_NAME_hash_old(X509_NAME *x); +- +-int X509_CRL_cmp(const X509_CRL *a, const X509_CRL *b); +-int X509_CRL_match(const X509_CRL *a, const X509_CRL *b); +-int X509_aux_print(BIO *out, X509 *x, int indent); +-# ifndef OPENSSL_NO_STDIO +-int X509_print_ex_fp(FILE *bp, X509 *x, unsigned long nmflag, +- unsigned long cflag); +-int X509_print_fp(FILE *bp, X509 *x); +-int X509_CRL_print_fp(FILE *bp, X509_CRL *x); +-int X509_REQ_print_fp(FILE *bp, X509_REQ *req); +-int X509_NAME_print_ex_fp(FILE *fp, const X509_NAME *nm, int indent, +- unsigned long flags); +-# endif +- +-int X509_NAME_print(BIO *bp, const X509_NAME *name, int obase); +-int X509_NAME_print_ex(BIO *out, const X509_NAME *nm, int indent, +- unsigned long flags); +-int X509_print_ex(BIO *bp, X509 *x, unsigned long nmflag, +- unsigned long cflag); +-int X509_print(BIO *bp, X509 *x); +-int X509_ocspid_print(BIO *bp, X509 *x); +-int X509_CRL_print_ex(BIO *out, X509_CRL *x, unsigned long nmflag); +-int X509_CRL_print(BIO *bp, X509_CRL *x); +-int X509_REQ_print_ex(BIO *bp, X509_REQ *x, unsigned long nmflag, +- unsigned long cflag); +-int X509_REQ_print(BIO *bp, X509_REQ *req); +- +-int X509_NAME_entry_count(const X509_NAME *name); +-int X509_NAME_get_text_by_NID(X509_NAME *name, int nid, char *buf, int len); +-int X509_NAME_get_text_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, +- char *buf, int len); +- +-/* +- * NOTE: you should be passing -1, not 0 as lastpos. The functions that use +- * lastpos, search after that position on. +- */ +-int X509_NAME_get_index_by_NID(X509_NAME *name, int nid, int lastpos); +-int X509_NAME_get_index_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, +- int lastpos); +-X509_NAME_ENTRY *X509_NAME_get_entry(const X509_NAME *name, int loc); +-X509_NAME_ENTRY *X509_NAME_delete_entry(X509_NAME *name, int loc); +-int X509_NAME_add_entry(X509_NAME *name, const X509_NAME_ENTRY *ne, +- int loc, int set); +-int X509_NAME_add_entry_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, int type, +- const unsigned char *bytes, int len, int loc, +- int set); +-int X509_NAME_add_entry_by_NID(X509_NAME *name, int nid, int type, +- const unsigned char *bytes, int len, int loc, +- int set); +-X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY **ne, +- const char *field, int type, +- const unsigned char *bytes, +- int len); +-X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid, +- int type, +- const unsigned char *bytes, +- int len); +-int X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type, +- const unsigned char *bytes, int len, int loc, +- int set); +-X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_OBJ(X509_NAME_ENTRY **ne, +- const ASN1_OBJECT *obj, int type, +- const unsigned char *bytes, +- int len); +-int X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne, const ASN1_OBJECT *obj); +-int X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type, +- const unsigned char *bytes, int len); +-ASN1_OBJECT *X509_NAME_ENTRY_get_object(const X509_NAME_ENTRY *ne); +-ASN1_STRING * X509_NAME_ENTRY_get_data(const X509_NAME_ENTRY *ne); +-int X509_NAME_ENTRY_set(const X509_NAME_ENTRY *ne); +- +-int X509_NAME_get0_der(X509_NAME *nm, const unsigned char **pder, +- size_t *pderlen); +- +-int X509v3_get_ext_count(const STACK_OF(X509_EXTENSION) *x); +-int X509v3_get_ext_by_NID(const STACK_OF(X509_EXTENSION) *x, +- int nid, int lastpos); +-int X509v3_get_ext_by_OBJ(const STACK_OF(X509_EXTENSION) *x, +- const ASN1_OBJECT *obj, int lastpos); +-int X509v3_get_ext_by_critical(const STACK_OF(X509_EXTENSION) *x, +- int crit, int lastpos); +-X509_EXTENSION *X509v3_get_ext(const STACK_OF(X509_EXTENSION) *x, int loc); +-X509_EXTENSION *X509v3_delete_ext(STACK_OF(X509_EXTENSION) *x, int loc); +-STACK_OF(X509_EXTENSION) *X509v3_add_ext(STACK_OF(X509_EXTENSION) **x, +- X509_EXTENSION *ex, int loc); +- +-int X509_get_ext_count(const X509 *x); +-int X509_get_ext_by_NID(const X509 *x, int nid, int lastpos); +-int X509_get_ext_by_OBJ(const X509 *x, const ASN1_OBJECT *obj, int lastpos); +-int X509_get_ext_by_critical(const X509 *x, int crit, int lastpos); +-X509_EXTENSION *X509_get_ext(const X509 *x, int loc); +-X509_EXTENSION *X509_delete_ext(X509 *x, int loc); +-int X509_add_ext(X509 *x, X509_EXTENSION *ex, int loc); +-void *X509_get_ext_d2i(const X509 *x, int nid, int *crit, int *idx); +-int X509_add1_ext_i2d(X509 *x, int nid, void *value, int crit, +- unsigned long flags); +- +-int X509_CRL_get_ext_count(const X509_CRL *x); +-int X509_CRL_get_ext_by_NID(const X509_CRL *x, int nid, int lastpos); +-int X509_CRL_get_ext_by_OBJ(const X509_CRL *x, const ASN1_OBJECT *obj, +- int lastpos); +-int X509_CRL_get_ext_by_critical(const X509_CRL *x, int crit, int lastpos); +-X509_EXTENSION *X509_CRL_get_ext(const X509_CRL *x, int loc); +-X509_EXTENSION *X509_CRL_delete_ext(X509_CRL *x, int loc); +-int X509_CRL_add_ext(X509_CRL *x, X509_EXTENSION *ex, int loc); +-void *X509_CRL_get_ext_d2i(const X509_CRL *x, int nid, int *crit, int *idx); +-int X509_CRL_add1_ext_i2d(X509_CRL *x, int nid, void *value, int crit, +- unsigned long flags); +- +-int X509_REVOKED_get_ext_count(const X509_REVOKED *x); +-int X509_REVOKED_get_ext_by_NID(const X509_REVOKED *x, int nid, int lastpos); +-int X509_REVOKED_get_ext_by_OBJ(const X509_REVOKED *x, const ASN1_OBJECT *obj, +- int lastpos); +-int X509_REVOKED_get_ext_by_critical(const X509_REVOKED *x, int crit, +- int lastpos); +-X509_EXTENSION *X509_REVOKED_get_ext(const X509_REVOKED *x, int loc); +-X509_EXTENSION *X509_REVOKED_delete_ext(X509_REVOKED *x, int loc); +-int X509_REVOKED_add_ext(X509_REVOKED *x, X509_EXTENSION *ex, int loc); +-void *X509_REVOKED_get_ext_d2i(const X509_REVOKED *x, int nid, int *crit, +- int *idx); +-int X509_REVOKED_add1_ext_i2d(X509_REVOKED *x, int nid, void *value, int crit, +- unsigned long flags); +- +-X509_EXTENSION *X509_EXTENSION_create_by_NID(X509_EXTENSION **ex, +- int nid, int crit, +- ASN1_OCTET_STRING *data); +-X509_EXTENSION *X509_EXTENSION_create_by_OBJ(X509_EXTENSION **ex, +- const ASN1_OBJECT *obj, int crit, +- ASN1_OCTET_STRING *data); +-int X509_EXTENSION_set_object(X509_EXTENSION *ex, const ASN1_OBJECT *obj); +-int X509_EXTENSION_set_critical(X509_EXTENSION *ex, int crit); +-int X509_EXTENSION_set_data(X509_EXTENSION *ex, ASN1_OCTET_STRING *data); +-ASN1_OBJECT *X509_EXTENSION_get_object(X509_EXTENSION *ex); +-ASN1_OCTET_STRING *X509_EXTENSION_get_data(X509_EXTENSION *ne); +-int X509_EXTENSION_get_critical(const X509_EXTENSION *ex); +- +-int X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x); +-int X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid, +- int lastpos); +-int X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk, +- const ASN1_OBJECT *obj, int lastpos); +-X509_ATTRIBUTE *X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc); +-X509_ATTRIBUTE *X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc); +-STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) **x, +- X509_ATTRIBUTE *attr); +-STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE) +- **x, const ASN1_OBJECT *obj, +- int type, +- const unsigned char *bytes, +- int len); +-STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE) +- **x, int nid, int type, +- const unsigned char *bytes, +- int len); +-STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE) +- **x, const char *attrname, +- int type, +- const unsigned char *bytes, +- int len); +-void *X509at_get0_data_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *x, +- const ASN1_OBJECT *obj, int lastpos, int type); +-X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid, +- int atrtype, const void *data, +- int len); +-X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr, +- const ASN1_OBJECT *obj, +- int atrtype, const void *data, +- int len); +-X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr, +- const char *atrname, int type, +- const unsigned char *bytes, +- int len); +-int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj); +-int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype, +- const void *data, int len); +-void *X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx, int atrtype, +- void *data); +-int X509_ATTRIBUTE_count(const X509_ATTRIBUTE *attr); +-ASN1_OBJECT *X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr); +-ASN1_TYPE *X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx); +- +-int EVP_PKEY_get_attr_count(const EVP_PKEY *key); +-int EVP_PKEY_get_attr_by_NID(const EVP_PKEY *key, int nid, int lastpos); +-int EVP_PKEY_get_attr_by_OBJ(const EVP_PKEY *key, const ASN1_OBJECT *obj, +- int lastpos); +-X509_ATTRIBUTE *EVP_PKEY_get_attr(const EVP_PKEY *key, int loc); +-X509_ATTRIBUTE *EVP_PKEY_delete_attr(EVP_PKEY *key, int loc); +-int EVP_PKEY_add1_attr(EVP_PKEY *key, X509_ATTRIBUTE *attr); +-int EVP_PKEY_add1_attr_by_OBJ(EVP_PKEY *key, +- const ASN1_OBJECT *obj, int type, +- const unsigned char *bytes, int len); +-int EVP_PKEY_add1_attr_by_NID(EVP_PKEY *key, +- int nid, int type, +- const unsigned char *bytes, int len); +-int EVP_PKEY_add1_attr_by_txt(EVP_PKEY *key, +- const char *attrname, int type, +- const unsigned char *bytes, int len); +- +-int X509_verify_cert(X509_STORE_CTX *ctx); +- +-/* lookup a cert from a X509 STACK */ +-X509 *X509_find_by_issuer_and_serial(STACK_OF(X509) *sk, X509_NAME *name, +- ASN1_INTEGER *serial); +-X509 *X509_find_by_subject(STACK_OF(X509) *sk, X509_NAME *name); +- +-DECLARE_ASN1_FUNCTIONS(PBEPARAM) +-DECLARE_ASN1_FUNCTIONS(PBE2PARAM) +-DECLARE_ASN1_FUNCTIONS(PBKDF2PARAM) +-#ifndef OPENSSL_NO_SCRYPT +-DECLARE_ASN1_FUNCTIONS(SCRYPT_PARAMS) +-#endif +- +-int PKCS5_pbe_set0_algor(X509_ALGOR *algor, int alg, int iter, +- const unsigned char *salt, int saltlen); +- +-X509_ALGOR *PKCS5_pbe_set(int alg, int iter, +- const unsigned char *salt, int saltlen); +-X509_ALGOR *PKCS5_pbe2_set(const EVP_CIPHER *cipher, int iter, +- unsigned char *salt, int saltlen); +-X509_ALGOR *PKCS5_pbe2_set_iv(const EVP_CIPHER *cipher, int iter, +- unsigned char *salt, int saltlen, +- unsigned char *aiv, int prf_nid); +- +-#ifndef OPENSSL_NO_SCRYPT +-X509_ALGOR *PKCS5_pbe2_set_scrypt(const EVP_CIPHER *cipher, +- const unsigned char *salt, int saltlen, +- unsigned char *aiv, uint64_t N, uint64_t r, +- uint64_t p); +-#endif +- +-X509_ALGOR *PKCS5_pbkdf2_set(int iter, unsigned char *salt, int saltlen, +- int prf_nid, int keylen); +- +-/* PKCS#8 utilities */ +- +-DECLARE_ASN1_FUNCTIONS(PKCS8_PRIV_KEY_INFO) +- +-EVP_PKEY *EVP_PKCS82PKEY(const PKCS8_PRIV_KEY_INFO *p8); +-PKCS8_PRIV_KEY_INFO *EVP_PKEY2PKCS8(EVP_PKEY *pkey); +- +-int PKCS8_pkey_set0(PKCS8_PRIV_KEY_INFO *priv, ASN1_OBJECT *aobj, +- int version, int ptype, void *pval, +- unsigned char *penc, int penclen); +-int PKCS8_pkey_get0(const ASN1_OBJECT **ppkalg, +- const unsigned char **pk, int *ppklen, +- const X509_ALGOR **pa, const PKCS8_PRIV_KEY_INFO *p8); +- +-const STACK_OF(X509_ATTRIBUTE) * +-PKCS8_pkey_get0_attrs(const PKCS8_PRIV_KEY_INFO *p8); +-int PKCS8_pkey_add1_attr_by_NID(PKCS8_PRIV_KEY_INFO *p8, int nid, int type, +- const unsigned char *bytes, int len); +- +-int X509_PUBKEY_set0_param(X509_PUBKEY *pub, ASN1_OBJECT *aobj, +- int ptype, void *pval, +- unsigned char *penc, int penclen); +-int X509_PUBKEY_get0_param(ASN1_OBJECT **ppkalg, +- const unsigned char **pk, int *ppklen, +- X509_ALGOR **pa, X509_PUBKEY *pub); +- +-int X509_check_trust(X509 *x, int id, int flags); +-int X509_TRUST_get_count(void); +-X509_TRUST *X509_TRUST_get0(int idx); +-int X509_TRUST_get_by_id(int id); +-int X509_TRUST_add(int id, int flags, int (*ck) (X509_TRUST *, X509 *, int), +- const char *name, int arg1, void *arg2); +-void X509_TRUST_cleanup(void); +-int X509_TRUST_get_flags(const X509_TRUST *xp); +-char *X509_TRUST_get0_name(const X509_TRUST *xp); +-int X509_TRUST_get_trust(const X509_TRUST *xp); +- +-# ifdef __cplusplus +-} +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/x509_vfy.h b/uadk_tool/include/openssl/x509_vfy.h +deleted file mode 100644 +index 25c79f1..0000000 +--- a/uadk_tool/include/openssl/x509_vfy.h ++++ /dev/null +@@ -1,632 +0,0 @@ +-/* +- * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_X509_VFY_H +-# define HEADER_X509_VFY_H +- +-/* +- * Protect against recursion, x509.h and x509_vfy.h each include the other. +- */ +-# ifndef HEADER_X509_H +-# include +-# endif +- +-# include +-# include +-# include +-# include +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-/*- +-SSL_CTX -> X509_STORE +- -> X509_LOOKUP +- ->X509_LOOKUP_METHOD +- -> X509_LOOKUP +- ->X509_LOOKUP_METHOD +- +-SSL -> X509_STORE_CTX +- ->X509_STORE +- +-The X509_STORE holds the tables etc for verification stuff. +-A X509_STORE_CTX is used while validating a single certificate. +-The X509_STORE has X509_LOOKUPs for looking up certs. +-The X509_STORE then calls a function to actually verify the +-certificate chain. +-*/ +- +-typedef enum { +- X509_LU_NONE = 0, +- X509_LU_X509, X509_LU_CRL +-} X509_LOOKUP_TYPE; +- +-#if OPENSSL_API_COMPAT < 0x10100000L +-#define X509_LU_RETRY -1 +-#define X509_LU_FAIL 0 +-#endif +- +-DEFINE_STACK_OF(X509_LOOKUP) +-DEFINE_STACK_OF(X509_OBJECT) +-DEFINE_STACK_OF(X509_VERIFY_PARAM) +- +-int X509_STORE_set_depth(X509_STORE *store, int depth); +- +-typedef int (*X509_STORE_CTX_verify_cb)(int, X509_STORE_CTX *); +-typedef int (*X509_STORE_CTX_verify_fn)(X509_STORE_CTX *); +-typedef int (*X509_STORE_CTX_get_issuer_fn)(X509 **issuer, +- X509_STORE_CTX *ctx, X509 *x); +-typedef int (*X509_STORE_CTX_check_issued_fn)(X509_STORE_CTX *ctx, +- X509 *x, X509 *issuer); +-typedef int (*X509_STORE_CTX_check_revocation_fn)(X509_STORE_CTX *ctx); +-typedef int (*X509_STORE_CTX_get_crl_fn)(X509_STORE_CTX *ctx, +- X509_CRL **crl, X509 *x); +-typedef int (*X509_STORE_CTX_check_crl_fn)(X509_STORE_CTX *ctx, X509_CRL *crl); +-typedef int (*X509_STORE_CTX_cert_crl_fn)(X509_STORE_CTX *ctx, +- X509_CRL *crl, X509 *x); +-typedef int (*X509_STORE_CTX_check_policy_fn)(X509_STORE_CTX *ctx); +-typedef STACK_OF(X509) *(*X509_STORE_CTX_lookup_certs_fn)(X509_STORE_CTX *ctx, +- X509_NAME *nm); +-typedef STACK_OF(X509_CRL) *(*X509_STORE_CTX_lookup_crls_fn)(X509_STORE_CTX *ctx, +- X509_NAME *nm); +-typedef int (*X509_STORE_CTX_cleanup_fn)(X509_STORE_CTX *ctx); +- +- +-void X509_STORE_CTX_set_depth(X509_STORE_CTX *ctx, int depth); +- +-# define X509_STORE_CTX_set_app_data(ctx,data) \ +- X509_STORE_CTX_set_ex_data(ctx,0,data) +-# define X509_STORE_CTX_get_app_data(ctx) \ +- X509_STORE_CTX_get_ex_data(ctx,0) +- +-# define X509_L_FILE_LOAD 1 +-# define X509_L_ADD_DIR 2 +- +-# define X509_LOOKUP_load_file(x,name,type) \ +- X509_LOOKUP_ctrl((x),X509_L_FILE_LOAD,(name),(long)(type),NULL) +- +-# define X509_LOOKUP_add_dir(x,name,type) \ +- X509_LOOKUP_ctrl((x),X509_L_ADD_DIR,(name),(long)(type),NULL) +- +-# define X509_V_OK 0 +-# define X509_V_ERR_UNSPECIFIED 1 +-# define X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT 2 +-# define X509_V_ERR_UNABLE_TO_GET_CRL 3 +-# define X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE 4 +-# define X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE 5 +-# define X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY 6 +-# define X509_V_ERR_CERT_SIGNATURE_FAILURE 7 +-# define X509_V_ERR_CRL_SIGNATURE_FAILURE 8 +-# define X509_V_ERR_CERT_NOT_YET_VALID 9 +-# define X509_V_ERR_CERT_HAS_EXPIRED 10 +-# define X509_V_ERR_CRL_NOT_YET_VALID 11 +-# define X509_V_ERR_CRL_HAS_EXPIRED 12 +-# define X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD 13 +-# define X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD 14 +-# define X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD 15 +-# define X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD 16 +-# define X509_V_ERR_OUT_OF_MEM 17 +-# define X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT 18 +-# define X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN 19 +-# define X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY 20 +-# define X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE 21 +-# define X509_V_ERR_CERT_CHAIN_TOO_LONG 22 +-# define X509_V_ERR_CERT_REVOKED 23 +-# define X509_V_ERR_INVALID_CA 24 +-# define X509_V_ERR_PATH_LENGTH_EXCEEDED 25 +-# define X509_V_ERR_INVALID_PURPOSE 26 +-# define X509_V_ERR_CERT_UNTRUSTED 27 +-# define X509_V_ERR_CERT_REJECTED 28 +-/* These are 'informational' when looking for issuer cert */ +-# define X509_V_ERR_SUBJECT_ISSUER_MISMATCH 29 +-# define X509_V_ERR_AKID_SKID_MISMATCH 30 +-# define X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH 31 +-# define X509_V_ERR_KEYUSAGE_NO_CERTSIGN 32 +-# define X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER 33 +-# define X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION 34 +-# define X509_V_ERR_KEYUSAGE_NO_CRL_SIGN 35 +-# define X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION 36 +-# define X509_V_ERR_INVALID_NON_CA 37 +-# define X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED 38 +-# define X509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE 39 +-# define X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED 40 +-# define X509_V_ERR_INVALID_EXTENSION 41 +-# define X509_V_ERR_INVALID_POLICY_EXTENSION 42 +-# define X509_V_ERR_NO_EXPLICIT_POLICY 43 +-# define X509_V_ERR_DIFFERENT_CRL_SCOPE 44 +-# define X509_V_ERR_UNSUPPORTED_EXTENSION_FEATURE 45 +-# define X509_V_ERR_UNNESTED_RESOURCE 46 +-# define X509_V_ERR_PERMITTED_VIOLATION 47 +-# define X509_V_ERR_EXCLUDED_VIOLATION 48 +-# define X509_V_ERR_SUBTREE_MINMAX 49 +-/* The application is not happy */ +-# define X509_V_ERR_APPLICATION_VERIFICATION 50 +-# define X509_V_ERR_UNSUPPORTED_CONSTRAINT_TYPE 51 +-# define X509_V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX 52 +-# define X509_V_ERR_UNSUPPORTED_NAME_SYNTAX 53 +-# define X509_V_ERR_CRL_PATH_VALIDATION_ERROR 54 +-/* Another issuer check debug option */ +-# define X509_V_ERR_PATH_LOOP 55 +-/* Suite B mode algorithm violation */ +-# define X509_V_ERR_SUITE_B_INVALID_VERSION 56 +-# define X509_V_ERR_SUITE_B_INVALID_ALGORITHM 57 +-# define X509_V_ERR_SUITE_B_INVALID_CURVE 58 +-# define X509_V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHM 59 +-# define X509_V_ERR_SUITE_B_LOS_NOT_ALLOWED 60 +-# define X509_V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256 61 +-/* Host, email and IP check errors */ +-# define X509_V_ERR_HOSTNAME_MISMATCH 62 +-# define X509_V_ERR_EMAIL_MISMATCH 63 +-# define X509_V_ERR_IP_ADDRESS_MISMATCH 64 +-/* DANE TLSA errors */ +-# define X509_V_ERR_DANE_NO_MATCH 65 +-/* security level errors */ +-# define X509_V_ERR_EE_KEY_TOO_SMALL 66 +-# define X509_V_ERR_CA_KEY_TOO_SMALL 67 +-# define X509_V_ERR_CA_MD_TOO_WEAK 68 +-/* Caller error */ +-# define X509_V_ERR_INVALID_CALL 69 +-/* Issuer lookup error */ +-# define X509_V_ERR_STORE_LOOKUP 70 +-/* Certificate transparency */ +-# define X509_V_ERR_NO_VALID_SCTS 71 +- +-# define X509_V_ERR_PROXY_SUBJECT_NAME_VIOLATION 72 +-/* OCSP status errors */ +-# define X509_V_ERR_OCSP_VERIFY_NEEDED 73 /* Need OCSP verification */ +-# define X509_V_ERR_OCSP_VERIFY_FAILED 74 /* Couldn't verify cert through OCSP */ +-# define X509_V_ERR_OCSP_CERT_UNKNOWN 75 /* Certificate wasn't recognized by the OCSP responder */ +-# define X509_V_ERR_SIGNATURE_ALGORITHM_MISMATCH 76 +-# define X509_V_ERR_NO_ISSUER_PUBLIC_KEY 77 +-# define X509_V_ERR_UNSUPPORTED_SIGNATURE_ALGORITHM 78 +-# define X509_V_ERR_EC_KEY_EXPLICIT_PARAMS 79 +- +-/* Certificate verify flags */ +- +-# if OPENSSL_API_COMPAT < 0x10100000L +-# define X509_V_FLAG_CB_ISSUER_CHECK 0x0 /* Deprecated */ +-# endif +-/* Use check time instead of current time */ +-# define X509_V_FLAG_USE_CHECK_TIME 0x2 +-/* Lookup CRLs */ +-# define X509_V_FLAG_CRL_CHECK 0x4 +-/* Lookup CRLs for whole chain */ +-# define X509_V_FLAG_CRL_CHECK_ALL 0x8 +-/* Ignore unhandled critical extensions */ +-# define X509_V_FLAG_IGNORE_CRITICAL 0x10 +-/* Disable workarounds for broken certificates */ +-# define X509_V_FLAG_X509_STRICT 0x20 +-/* Enable proxy certificate validation */ +-# define X509_V_FLAG_ALLOW_PROXY_CERTS 0x40 +-/* Enable policy checking */ +-# define X509_V_FLAG_POLICY_CHECK 0x80 +-/* Policy variable require-explicit-policy */ +-# define X509_V_FLAG_EXPLICIT_POLICY 0x100 +-/* Policy variable inhibit-any-policy */ +-# define X509_V_FLAG_INHIBIT_ANY 0x200 +-/* Policy variable inhibit-policy-mapping */ +-# define X509_V_FLAG_INHIBIT_MAP 0x400 +-/* Notify callback that policy is OK */ +-# define X509_V_FLAG_NOTIFY_POLICY 0x800 +-/* Extended CRL features such as indirect CRLs, alternate CRL signing keys */ +-# define X509_V_FLAG_EXTENDED_CRL_SUPPORT 0x1000 +-/* Delta CRL support */ +-# define X509_V_FLAG_USE_DELTAS 0x2000 +-/* Check self-signed CA signature */ +-# define X509_V_FLAG_CHECK_SS_SIGNATURE 0x4000 +-/* Use trusted store first */ +-# define X509_V_FLAG_TRUSTED_FIRST 0x8000 +-/* Suite B 128 bit only mode: not normally used */ +-# define X509_V_FLAG_SUITEB_128_LOS_ONLY 0x10000 +-/* Suite B 192 bit only mode */ +-# define X509_V_FLAG_SUITEB_192_LOS 0x20000 +-/* Suite B 128 bit mode allowing 192 bit algorithms */ +-# define X509_V_FLAG_SUITEB_128_LOS 0x30000 +-/* Allow partial chains if at least one certificate is in trusted store */ +-# define X509_V_FLAG_PARTIAL_CHAIN 0x80000 +-/* +- * If the initial chain is not trusted, do not attempt to build an alternative +- * chain. Alternate chain checking was introduced in 1.1.0. Setting this flag +- * will force the behaviour to match that of previous versions. +- */ +-# define X509_V_FLAG_NO_ALT_CHAINS 0x100000 +-/* Do not check certificate/CRL validity against current time */ +-# define X509_V_FLAG_NO_CHECK_TIME 0x200000 +- +-# define X509_VP_FLAG_DEFAULT 0x1 +-# define X509_VP_FLAG_OVERWRITE 0x2 +-# define X509_VP_FLAG_RESET_FLAGS 0x4 +-# define X509_VP_FLAG_LOCKED 0x8 +-# define X509_VP_FLAG_ONCE 0x10 +- +-/* Internal use: mask of policy related options */ +-# define X509_V_FLAG_POLICY_MASK (X509_V_FLAG_POLICY_CHECK \ +- | X509_V_FLAG_EXPLICIT_POLICY \ +- | X509_V_FLAG_INHIBIT_ANY \ +- | X509_V_FLAG_INHIBIT_MAP) +- +-int X509_OBJECT_idx_by_subject(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type, +- X509_NAME *name); +-X509_OBJECT *X509_OBJECT_retrieve_by_subject(STACK_OF(X509_OBJECT) *h, +- X509_LOOKUP_TYPE type, +- X509_NAME *name); +-X509_OBJECT *X509_OBJECT_retrieve_match(STACK_OF(X509_OBJECT) *h, +- X509_OBJECT *x); +-int X509_OBJECT_up_ref_count(X509_OBJECT *a); +-X509_OBJECT *X509_OBJECT_new(void); +-void X509_OBJECT_free(X509_OBJECT *a); +-X509_LOOKUP_TYPE X509_OBJECT_get_type(const X509_OBJECT *a); +-X509 *X509_OBJECT_get0_X509(const X509_OBJECT *a); +-int X509_OBJECT_set1_X509(X509_OBJECT *a, X509 *obj); +-X509_CRL *X509_OBJECT_get0_X509_CRL(X509_OBJECT *a); +-int X509_OBJECT_set1_X509_CRL(X509_OBJECT *a, X509_CRL *obj); +-X509_STORE *X509_STORE_new(void); +-void X509_STORE_free(X509_STORE *v); +-int X509_STORE_lock(X509_STORE *ctx); +-int X509_STORE_unlock(X509_STORE *ctx); +-int X509_STORE_up_ref(X509_STORE *v); +-STACK_OF(X509_OBJECT) *X509_STORE_get0_objects(X509_STORE *v); +- +-STACK_OF(X509) *X509_STORE_CTX_get1_certs(X509_STORE_CTX *st, X509_NAME *nm); +-STACK_OF(X509_CRL) *X509_STORE_CTX_get1_crls(X509_STORE_CTX *st, X509_NAME *nm); +-int X509_STORE_set_flags(X509_STORE *ctx, unsigned long flags); +-int X509_STORE_set_purpose(X509_STORE *ctx, int purpose); +-int X509_STORE_set_trust(X509_STORE *ctx, int trust); +-int X509_STORE_set1_param(X509_STORE *ctx, X509_VERIFY_PARAM *pm); +-X509_VERIFY_PARAM *X509_STORE_get0_param(X509_STORE *ctx); +- +-void X509_STORE_set_verify(X509_STORE *ctx, X509_STORE_CTX_verify_fn verify); +-#define X509_STORE_set_verify_func(ctx, func) \ +- X509_STORE_set_verify((ctx),(func)) +-void X509_STORE_CTX_set_verify(X509_STORE_CTX *ctx, +- X509_STORE_CTX_verify_fn verify); +-X509_STORE_CTX_verify_fn X509_STORE_get_verify(X509_STORE *ctx); +-void X509_STORE_set_verify_cb(X509_STORE *ctx, +- X509_STORE_CTX_verify_cb verify_cb); +-# define X509_STORE_set_verify_cb_func(ctx,func) \ +- X509_STORE_set_verify_cb((ctx),(func)) +-X509_STORE_CTX_verify_cb X509_STORE_get_verify_cb(X509_STORE *ctx); +-void X509_STORE_set_get_issuer(X509_STORE *ctx, +- X509_STORE_CTX_get_issuer_fn get_issuer); +-X509_STORE_CTX_get_issuer_fn X509_STORE_get_get_issuer(X509_STORE *ctx); +-void X509_STORE_set_check_issued(X509_STORE *ctx, +- X509_STORE_CTX_check_issued_fn check_issued); +-X509_STORE_CTX_check_issued_fn X509_STORE_get_check_issued(X509_STORE *ctx); +-void X509_STORE_set_check_revocation(X509_STORE *ctx, +- X509_STORE_CTX_check_revocation_fn check_revocation); +-X509_STORE_CTX_check_revocation_fn X509_STORE_get_check_revocation(X509_STORE *ctx); +-void X509_STORE_set_get_crl(X509_STORE *ctx, +- X509_STORE_CTX_get_crl_fn get_crl); +-X509_STORE_CTX_get_crl_fn X509_STORE_get_get_crl(X509_STORE *ctx); +-void X509_STORE_set_check_crl(X509_STORE *ctx, +- X509_STORE_CTX_check_crl_fn check_crl); +-X509_STORE_CTX_check_crl_fn X509_STORE_get_check_crl(X509_STORE *ctx); +-void X509_STORE_set_cert_crl(X509_STORE *ctx, +- X509_STORE_CTX_cert_crl_fn cert_crl); +-X509_STORE_CTX_cert_crl_fn X509_STORE_get_cert_crl(X509_STORE *ctx); +-void X509_STORE_set_check_policy(X509_STORE *ctx, +- X509_STORE_CTX_check_policy_fn check_policy); +-X509_STORE_CTX_check_policy_fn X509_STORE_get_check_policy(X509_STORE *ctx); +-void X509_STORE_set_lookup_certs(X509_STORE *ctx, +- X509_STORE_CTX_lookup_certs_fn lookup_certs); +-X509_STORE_CTX_lookup_certs_fn X509_STORE_get_lookup_certs(X509_STORE *ctx); +-void X509_STORE_set_lookup_crls(X509_STORE *ctx, +- X509_STORE_CTX_lookup_crls_fn lookup_crls); +-#define X509_STORE_set_lookup_crls_cb(ctx, func) \ +- X509_STORE_set_lookup_crls((ctx), (func)) +-X509_STORE_CTX_lookup_crls_fn X509_STORE_get_lookup_crls(X509_STORE *ctx); +-void X509_STORE_set_cleanup(X509_STORE *ctx, +- X509_STORE_CTX_cleanup_fn cleanup); +-X509_STORE_CTX_cleanup_fn X509_STORE_get_cleanup(X509_STORE *ctx); +- +-#define X509_STORE_get_ex_new_index(l, p, newf, dupf, freef) \ +- CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509_STORE, l, p, newf, dupf, freef) +-int X509_STORE_set_ex_data(X509_STORE *ctx, int idx, void *data); +-void *X509_STORE_get_ex_data(X509_STORE *ctx, int idx); +- +-X509_STORE_CTX *X509_STORE_CTX_new(void); +- +-int X509_STORE_CTX_get1_issuer(X509 **issuer, X509_STORE_CTX *ctx, X509 *x); +- +-void X509_STORE_CTX_free(X509_STORE_CTX *ctx); +-int X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, +- X509 *x509, STACK_OF(X509) *chain); +-void X509_STORE_CTX_set0_trusted_stack(X509_STORE_CTX *ctx, STACK_OF(X509) *sk); +-void X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx); +- +-X509_STORE *X509_STORE_CTX_get0_store(X509_STORE_CTX *ctx); +-X509 *X509_STORE_CTX_get0_cert(X509_STORE_CTX *ctx); +-STACK_OF(X509)* X509_STORE_CTX_get0_untrusted(X509_STORE_CTX *ctx); +-void X509_STORE_CTX_set0_untrusted(X509_STORE_CTX *ctx, STACK_OF(X509) *sk); +-void X509_STORE_CTX_set_verify_cb(X509_STORE_CTX *ctx, +- X509_STORE_CTX_verify_cb verify); +-X509_STORE_CTX_verify_cb X509_STORE_CTX_get_verify_cb(X509_STORE_CTX *ctx); +-X509_STORE_CTX_verify_fn X509_STORE_CTX_get_verify(X509_STORE_CTX *ctx); +-X509_STORE_CTX_get_issuer_fn X509_STORE_CTX_get_get_issuer(X509_STORE_CTX *ctx); +-X509_STORE_CTX_check_issued_fn X509_STORE_CTX_get_check_issued(X509_STORE_CTX *ctx); +-X509_STORE_CTX_check_revocation_fn X509_STORE_CTX_get_check_revocation(X509_STORE_CTX *ctx); +-X509_STORE_CTX_get_crl_fn X509_STORE_CTX_get_get_crl(X509_STORE_CTX *ctx); +-X509_STORE_CTX_check_crl_fn X509_STORE_CTX_get_check_crl(X509_STORE_CTX *ctx); +-X509_STORE_CTX_cert_crl_fn X509_STORE_CTX_get_cert_crl(X509_STORE_CTX *ctx); +-X509_STORE_CTX_check_policy_fn X509_STORE_CTX_get_check_policy(X509_STORE_CTX *ctx); +-X509_STORE_CTX_lookup_certs_fn X509_STORE_CTX_get_lookup_certs(X509_STORE_CTX *ctx); +-X509_STORE_CTX_lookup_crls_fn X509_STORE_CTX_get_lookup_crls(X509_STORE_CTX *ctx); +-X509_STORE_CTX_cleanup_fn X509_STORE_CTX_get_cleanup(X509_STORE_CTX *ctx); +- +-#if OPENSSL_API_COMPAT < 0x10100000L +-# define X509_STORE_CTX_get_chain X509_STORE_CTX_get0_chain +-# define X509_STORE_CTX_set_chain X509_STORE_CTX_set0_untrusted +-# define X509_STORE_CTX_trusted_stack X509_STORE_CTX_set0_trusted_stack +-# define X509_STORE_get_by_subject X509_STORE_CTX_get_by_subject +-# define X509_STORE_get1_certs X509_STORE_CTX_get1_certs +-# define X509_STORE_get1_crls X509_STORE_CTX_get1_crls +-/* the following macro is misspelled; use X509_STORE_get1_certs instead */ +-# define X509_STORE_get1_cert X509_STORE_CTX_get1_certs +-/* the following macro is misspelled; use X509_STORE_get1_crls instead */ +-# define X509_STORE_get1_crl X509_STORE_CTX_get1_crls +-#endif +- +-X509_LOOKUP *X509_STORE_add_lookup(X509_STORE *v, X509_LOOKUP_METHOD *m); +-X509_LOOKUP_METHOD *X509_LOOKUP_hash_dir(void); +-X509_LOOKUP_METHOD *X509_LOOKUP_file(void); +- +-typedef int (*X509_LOOKUP_ctrl_fn)(X509_LOOKUP *ctx, int cmd, const char *argc, +- long argl, char **ret); +-typedef int (*X509_LOOKUP_get_by_subject_fn)(X509_LOOKUP *ctx, +- X509_LOOKUP_TYPE type, +- X509_NAME *name, +- X509_OBJECT *ret); +-typedef int (*X509_LOOKUP_get_by_issuer_serial_fn)(X509_LOOKUP *ctx, +- X509_LOOKUP_TYPE type, +- X509_NAME *name, +- ASN1_INTEGER *serial, +- X509_OBJECT *ret); +-typedef int (*X509_LOOKUP_get_by_fingerprint_fn)(X509_LOOKUP *ctx, +- X509_LOOKUP_TYPE type, +- const unsigned char* bytes, +- int len, +- X509_OBJECT *ret); +-typedef int (*X509_LOOKUP_get_by_alias_fn)(X509_LOOKUP *ctx, +- X509_LOOKUP_TYPE type, +- const char *str, +- int len, +- X509_OBJECT *ret); +- +-X509_LOOKUP_METHOD *X509_LOOKUP_meth_new(const char *name); +-void X509_LOOKUP_meth_free(X509_LOOKUP_METHOD *method); +- +-int X509_LOOKUP_meth_set_new_item(X509_LOOKUP_METHOD *method, +- int (*new_item) (X509_LOOKUP *ctx)); +-int (*X509_LOOKUP_meth_get_new_item(const X509_LOOKUP_METHOD* method)) +- (X509_LOOKUP *ctx); +- +-int X509_LOOKUP_meth_set_free(X509_LOOKUP_METHOD *method, +- void (*free_fn) (X509_LOOKUP *ctx)); +-void (*X509_LOOKUP_meth_get_free(const X509_LOOKUP_METHOD* method)) +- (X509_LOOKUP *ctx); +- +-int X509_LOOKUP_meth_set_init(X509_LOOKUP_METHOD *method, +- int (*init) (X509_LOOKUP *ctx)); +-int (*X509_LOOKUP_meth_get_init(const X509_LOOKUP_METHOD* method)) +- (X509_LOOKUP *ctx); +- +-int X509_LOOKUP_meth_set_shutdown(X509_LOOKUP_METHOD *method, +- int (*shutdown) (X509_LOOKUP *ctx)); +-int (*X509_LOOKUP_meth_get_shutdown(const X509_LOOKUP_METHOD* method)) +- (X509_LOOKUP *ctx); +- +-int X509_LOOKUP_meth_set_ctrl(X509_LOOKUP_METHOD *method, +- X509_LOOKUP_ctrl_fn ctrl_fn); +-X509_LOOKUP_ctrl_fn X509_LOOKUP_meth_get_ctrl(const X509_LOOKUP_METHOD *method); +- +-int X509_LOOKUP_meth_set_get_by_subject(X509_LOOKUP_METHOD *method, +- X509_LOOKUP_get_by_subject_fn fn); +-X509_LOOKUP_get_by_subject_fn X509_LOOKUP_meth_get_get_by_subject( +- const X509_LOOKUP_METHOD *method); +- +-int X509_LOOKUP_meth_set_get_by_issuer_serial(X509_LOOKUP_METHOD *method, +- X509_LOOKUP_get_by_issuer_serial_fn fn); +-X509_LOOKUP_get_by_issuer_serial_fn X509_LOOKUP_meth_get_get_by_issuer_serial( +- const X509_LOOKUP_METHOD *method); +- +-int X509_LOOKUP_meth_set_get_by_fingerprint(X509_LOOKUP_METHOD *method, +- X509_LOOKUP_get_by_fingerprint_fn fn); +-X509_LOOKUP_get_by_fingerprint_fn X509_LOOKUP_meth_get_get_by_fingerprint( +- const X509_LOOKUP_METHOD *method); +- +-int X509_LOOKUP_meth_set_get_by_alias(X509_LOOKUP_METHOD *method, +- X509_LOOKUP_get_by_alias_fn fn); +-X509_LOOKUP_get_by_alias_fn X509_LOOKUP_meth_get_get_by_alias( +- const X509_LOOKUP_METHOD *method); +- +- +-int X509_STORE_add_cert(X509_STORE *ctx, X509 *x); +-int X509_STORE_add_crl(X509_STORE *ctx, X509_CRL *x); +- +-int X509_STORE_CTX_get_by_subject(X509_STORE_CTX *vs, X509_LOOKUP_TYPE type, +- X509_NAME *name, X509_OBJECT *ret); +-X509_OBJECT *X509_STORE_CTX_get_obj_by_subject(X509_STORE_CTX *vs, +- X509_LOOKUP_TYPE type, +- X509_NAME *name); +- +-int X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc, +- long argl, char **ret); +- +-int X509_load_cert_file(X509_LOOKUP *ctx, const char *file, int type); +-int X509_load_crl_file(X509_LOOKUP *ctx, const char *file, int type); +-int X509_load_cert_crl_file(X509_LOOKUP *ctx, const char *file, int type); +- +-X509_LOOKUP *X509_LOOKUP_new(X509_LOOKUP_METHOD *method); +-void X509_LOOKUP_free(X509_LOOKUP *ctx); +-int X509_LOOKUP_init(X509_LOOKUP *ctx); +-int X509_LOOKUP_by_subject(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, +- X509_NAME *name, X509_OBJECT *ret); +-int X509_LOOKUP_by_issuer_serial(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, +- X509_NAME *name, ASN1_INTEGER *serial, +- X509_OBJECT *ret); +-int X509_LOOKUP_by_fingerprint(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, +- const unsigned char *bytes, int len, +- X509_OBJECT *ret); +-int X509_LOOKUP_by_alias(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, +- const char *str, int len, X509_OBJECT *ret); +-int X509_LOOKUP_set_method_data(X509_LOOKUP *ctx, void *data); +-void *X509_LOOKUP_get_method_data(const X509_LOOKUP *ctx); +-X509_STORE *X509_LOOKUP_get_store(const X509_LOOKUP *ctx); +-int X509_LOOKUP_shutdown(X509_LOOKUP *ctx); +- +-int X509_STORE_load_locations(X509_STORE *ctx, +- const char *file, const char *dir); +-int X509_STORE_set_default_paths(X509_STORE *ctx); +- +-#define X509_STORE_CTX_get_ex_new_index(l, p, newf, dupf, freef) \ +- CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509_STORE_CTX, l, p, newf, dupf, freef) +-int X509_STORE_CTX_set_ex_data(X509_STORE_CTX *ctx, int idx, void *data); +-void *X509_STORE_CTX_get_ex_data(X509_STORE_CTX *ctx, int idx); +-int X509_STORE_CTX_get_error(X509_STORE_CTX *ctx); +-void X509_STORE_CTX_set_error(X509_STORE_CTX *ctx, int s); +-int X509_STORE_CTX_get_error_depth(X509_STORE_CTX *ctx); +-void X509_STORE_CTX_set_error_depth(X509_STORE_CTX *ctx, int depth); +-X509 *X509_STORE_CTX_get_current_cert(X509_STORE_CTX *ctx); +-void X509_STORE_CTX_set_current_cert(X509_STORE_CTX *ctx, X509 *x); +-X509 *X509_STORE_CTX_get0_current_issuer(X509_STORE_CTX *ctx); +-X509_CRL *X509_STORE_CTX_get0_current_crl(X509_STORE_CTX *ctx); +-X509_STORE_CTX *X509_STORE_CTX_get0_parent_ctx(X509_STORE_CTX *ctx); +-STACK_OF(X509) *X509_STORE_CTX_get0_chain(X509_STORE_CTX *ctx); +-STACK_OF(X509) *X509_STORE_CTX_get1_chain(X509_STORE_CTX *ctx); +-void X509_STORE_CTX_set_cert(X509_STORE_CTX *c, X509 *x); +-void X509_STORE_CTX_set0_verified_chain(X509_STORE_CTX *c, STACK_OF(X509) *sk); +-void X509_STORE_CTX_set0_crls(X509_STORE_CTX *c, STACK_OF(X509_CRL) *sk); +-int X509_STORE_CTX_set_purpose(X509_STORE_CTX *ctx, int purpose); +-int X509_STORE_CTX_set_trust(X509_STORE_CTX *ctx, int trust); +-int X509_STORE_CTX_purpose_inherit(X509_STORE_CTX *ctx, int def_purpose, +- int purpose, int trust); +-void X509_STORE_CTX_set_flags(X509_STORE_CTX *ctx, unsigned long flags); +-void X509_STORE_CTX_set_time(X509_STORE_CTX *ctx, unsigned long flags, +- time_t t); +- +-X509_POLICY_TREE *X509_STORE_CTX_get0_policy_tree(X509_STORE_CTX *ctx); +-int X509_STORE_CTX_get_explicit_policy(X509_STORE_CTX *ctx); +-int X509_STORE_CTX_get_num_untrusted(X509_STORE_CTX *ctx); +- +-X509_VERIFY_PARAM *X509_STORE_CTX_get0_param(X509_STORE_CTX *ctx); +-void X509_STORE_CTX_set0_param(X509_STORE_CTX *ctx, X509_VERIFY_PARAM *param); +-int X509_STORE_CTX_set_default(X509_STORE_CTX *ctx, const char *name); +- +-/* +- * Bridge opacity barrier between libcrypt and libssl, also needed to support +- * offline testing in test/danetest.c +- */ +-void X509_STORE_CTX_set0_dane(X509_STORE_CTX *ctx, SSL_DANE *dane); +-#define DANE_FLAG_NO_DANE_EE_NAMECHECKS (1L << 0) +- +-/* X509_VERIFY_PARAM functions */ +- +-X509_VERIFY_PARAM *X509_VERIFY_PARAM_new(void); +-void X509_VERIFY_PARAM_free(X509_VERIFY_PARAM *param); +-int X509_VERIFY_PARAM_inherit(X509_VERIFY_PARAM *to, +- const X509_VERIFY_PARAM *from); +-int X509_VERIFY_PARAM_set1(X509_VERIFY_PARAM *to, +- const X509_VERIFY_PARAM *from); +-int X509_VERIFY_PARAM_set1_name(X509_VERIFY_PARAM *param, const char *name); +-int X509_VERIFY_PARAM_set_flags(X509_VERIFY_PARAM *param, +- unsigned long flags); +-int X509_VERIFY_PARAM_clear_flags(X509_VERIFY_PARAM *param, +- unsigned long flags); +-unsigned long X509_VERIFY_PARAM_get_flags(X509_VERIFY_PARAM *param); +-int X509_VERIFY_PARAM_set_purpose(X509_VERIFY_PARAM *param, int purpose); +-int X509_VERIFY_PARAM_set_trust(X509_VERIFY_PARAM *param, int trust); +-void X509_VERIFY_PARAM_set_depth(X509_VERIFY_PARAM *param, int depth); +-void X509_VERIFY_PARAM_set_auth_level(X509_VERIFY_PARAM *param, int auth_level); +-time_t X509_VERIFY_PARAM_get_time(const X509_VERIFY_PARAM *param); +-void X509_VERIFY_PARAM_set_time(X509_VERIFY_PARAM *param, time_t t); +-int X509_VERIFY_PARAM_add0_policy(X509_VERIFY_PARAM *param, +- ASN1_OBJECT *policy); +-int X509_VERIFY_PARAM_set1_policies(X509_VERIFY_PARAM *param, +- STACK_OF(ASN1_OBJECT) *policies); +- +-int X509_VERIFY_PARAM_set_inh_flags(X509_VERIFY_PARAM *param, +- uint32_t flags); +-uint32_t X509_VERIFY_PARAM_get_inh_flags(const X509_VERIFY_PARAM *param); +- +-int X509_VERIFY_PARAM_set1_host(X509_VERIFY_PARAM *param, +- const char *name, size_t namelen); +-int X509_VERIFY_PARAM_add1_host(X509_VERIFY_PARAM *param, +- const char *name, size_t namelen); +-void X509_VERIFY_PARAM_set_hostflags(X509_VERIFY_PARAM *param, +- unsigned int flags); +-unsigned int X509_VERIFY_PARAM_get_hostflags(const X509_VERIFY_PARAM *param); +-char *X509_VERIFY_PARAM_get0_peername(X509_VERIFY_PARAM *); +-void X509_VERIFY_PARAM_move_peername(X509_VERIFY_PARAM *, X509_VERIFY_PARAM *); +-int X509_VERIFY_PARAM_set1_email(X509_VERIFY_PARAM *param, +- const char *email, size_t emaillen); +-int X509_VERIFY_PARAM_set1_ip(X509_VERIFY_PARAM *param, +- const unsigned char *ip, size_t iplen); +-int X509_VERIFY_PARAM_set1_ip_asc(X509_VERIFY_PARAM *param, +- const char *ipasc); +- +-int X509_VERIFY_PARAM_get_depth(const X509_VERIFY_PARAM *param); +-int X509_VERIFY_PARAM_get_auth_level(const X509_VERIFY_PARAM *param); +-const char *X509_VERIFY_PARAM_get0_name(const X509_VERIFY_PARAM *param); +- +-int X509_VERIFY_PARAM_add0_table(X509_VERIFY_PARAM *param); +-int X509_VERIFY_PARAM_get_count(void); +-const X509_VERIFY_PARAM *X509_VERIFY_PARAM_get0(int id); +-const X509_VERIFY_PARAM *X509_VERIFY_PARAM_lookup(const char *name); +-void X509_VERIFY_PARAM_table_cleanup(void); +- +-/* Non positive return values are errors */ +-#define X509_PCY_TREE_FAILURE -2 /* Failure to satisfy explicit policy */ +-#define X509_PCY_TREE_INVALID -1 /* Inconsistent or invalid extensions */ +-#define X509_PCY_TREE_INTERNAL 0 /* Internal error, most likely malloc */ +- +-/* +- * Positive return values form a bit mask, all but the first are internal to +- * the library and don't appear in results from X509_policy_check(). +- */ +-#define X509_PCY_TREE_VALID 1 /* The policy tree is valid */ +-#define X509_PCY_TREE_EMPTY 2 /* The policy tree is empty */ +-#define X509_PCY_TREE_EXPLICIT 4 /* Explicit policy required */ +- +-int X509_policy_check(X509_POLICY_TREE **ptree, int *pexplicit_policy, +- STACK_OF(X509) *certs, +- STACK_OF(ASN1_OBJECT) *policy_oids, unsigned int flags); +- +-void X509_policy_tree_free(X509_POLICY_TREE *tree); +- +-int X509_policy_tree_level_count(const X509_POLICY_TREE *tree); +-X509_POLICY_LEVEL *X509_policy_tree_get0_level(const X509_POLICY_TREE *tree, +- int i); +- +-STACK_OF(X509_POLICY_NODE) *X509_policy_tree_get0_policies(const +- X509_POLICY_TREE +- *tree); +- +-STACK_OF(X509_POLICY_NODE) *X509_policy_tree_get0_user_policies(const +- X509_POLICY_TREE +- *tree); +- +-int X509_policy_level_node_count(X509_POLICY_LEVEL *level); +- +-X509_POLICY_NODE *X509_policy_level_get0_node(X509_POLICY_LEVEL *level, +- int i); +- +-const ASN1_OBJECT *X509_policy_node_get0_policy(const X509_POLICY_NODE *node); +- +-STACK_OF(POLICYQUALINFO) *X509_policy_node_get0_qualifiers(const +- X509_POLICY_NODE +- *node); +-const X509_POLICY_NODE *X509_policy_node_get0_parent(const X509_POLICY_NODE +- *node); +- +-#ifdef __cplusplus +-} +-#endif +-#endif +diff --git a/uadk_tool/include/openssl/x509err.h b/uadk_tool/include/openssl/x509err.h +deleted file mode 100644 +index cd08673..0000000 +--- a/uadk_tool/include/openssl/x509err.h ++++ /dev/null +@@ -1,129 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_X509ERR_H +-# define HEADER_X509ERR_H +- +-# include +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_X509_strings(void); +- +-/* +- * X509 function codes. +- */ +-# define X509_F_ADD_CERT_DIR 100 +-# define X509_F_BUILD_CHAIN 106 +-# define X509_F_BY_FILE_CTRL 101 +-# define X509_F_CHECK_NAME_CONSTRAINTS 149 +-# define X509_F_CHECK_POLICY 145 +-# define X509_F_DANE_I2D 107 +-# define X509_F_DIR_CTRL 102 +-# define X509_F_GET_CERT_BY_SUBJECT 103 +-# define X509_F_I2D_X509_AUX 151 +-# define X509_F_LOOKUP_CERTS_SK 152 +-# define X509_F_NETSCAPE_SPKI_B64_DECODE 129 +-# define X509_F_NETSCAPE_SPKI_B64_ENCODE 130 +-# define X509_F_NEW_DIR 153 +-# define X509_F_X509AT_ADD1_ATTR 135 +-# define X509_F_X509V3_ADD_EXT 104 +-# define X509_F_X509_ATTRIBUTE_CREATE_BY_NID 136 +-# define X509_F_X509_ATTRIBUTE_CREATE_BY_OBJ 137 +-# define X509_F_X509_ATTRIBUTE_CREATE_BY_TXT 140 +-# define X509_F_X509_ATTRIBUTE_GET0_DATA 139 +-# define X509_F_X509_ATTRIBUTE_SET1_DATA 138 +-# define X509_F_X509_CHECK_PRIVATE_KEY 128 +-# define X509_F_X509_CRL_DIFF 105 +-# define X509_F_X509_CRL_METHOD_NEW 154 +-# define X509_F_X509_CRL_PRINT_FP 147 +-# define X509_F_X509_EXTENSION_CREATE_BY_NID 108 +-# define X509_F_X509_EXTENSION_CREATE_BY_OBJ 109 +-# define X509_F_X509_GET_PUBKEY_PARAMETERS 110 +-# define X509_F_X509_LOAD_CERT_CRL_FILE 132 +-# define X509_F_X509_LOAD_CERT_FILE 111 +-# define X509_F_X509_LOAD_CRL_FILE 112 +-# define X509_F_X509_LOOKUP_METH_NEW 160 +-# define X509_F_X509_LOOKUP_NEW 155 +-# define X509_F_X509_NAME_ADD_ENTRY 113 +-# define X509_F_X509_NAME_CANON 156 +-# define X509_F_X509_NAME_ENTRY_CREATE_BY_NID 114 +-# define X509_F_X509_NAME_ENTRY_CREATE_BY_TXT 131 +-# define X509_F_X509_NAME_ENTRY_SET_OBJECT 115 +-# define X509_F_X509_NAME_ONELINE 116 +-# define X509_F_X509_NAME_PRINT 117 +-# define X509_F_X509_OBJECT_NEW 150 +-# define X509_F_X509_PRINT_EX_FP 118 +-# define X509_F_X509_PUBKEY_DECODE 148 +-# define X509_F_X509_PUBKEY_GET 161 +-# define X509_F_X509_PUBKEY_GET0 119 +-# define X509_F_X509_PUBKEY_SET 120 +-# define X509_F_X509_REQ_CHECK_PRIVATE_KEY 144 +-# define X509_F_X509_REQ_PRINT_EX 121 +-# define X509_F_X509_REQ_PRINT_FP 122 +-# define X509_F_X509_REQ_TO_X509 123 +-# define X509_F_X509_STORE_ADD_CERT 124 +-# define X509_F_X509_STORE_ADD_CRL 125 +-# define X509_F_X509_STORE_ADD_LOOKUP 157 +-# define X509_F_X509_STORE_CTX_GET1_ISSUER 146 +-# define X509_F_X509_STORE_CTX_INIT 143 +-# define X509_F_X509_STORE_CTX_NEW 142 +-# define X509_F_X509_STORE_CTX_PURPOSE_INHERIT 134 +-# define X509_F_X509_STORE_NEW 158 +-# define X509_F_X509_TO_X509_REQ 126 +-# define X509_F_X509_TRUST_ADD 133 +-# define X509_F_X509_TRUST_SET 141 +-# define X509_F_X509_VERIFY_CERT 127 +-# define X509_F_X509_VERIFY_PARAM_NEW 159 +- +-/* +- * X509 reason codes. +- */ +-# define X509_R_AKID_MISMATCH 110 +-# define X509_R_BAD_SELECTOR 133 +-# define X509_R_BAD_X509_FILETYPE 100 +-# define X509_R_BASE64_DECODE_ERROR 118 +-# define X509_R_CANT_CHECK_DH_KEY 114 +-# define X509_R_CERT_ALREADY_IN_HASH_TABLE 101 +-# define X509_R_CRL_ALREADY_DELTA 127 +-# define X509_R_CRL_VERIFY_FAILURE 131 +-# define X509_R_IDP_MISMATCH 128 +-# define X509_R_INVALID_ATTRIBUTES 138 +-# define X509_R_INVALID_DIRECTORY 113 +-# define X509_R_INVALID_FIELD_NAME 119 +-# define X509_R_INVALID_TRUST 123 +-# define X509_R_ISSUER_MISMATCH 129 +-# define X509_R_KEY_TYPE_MISMATCH 115 +-# define X509_R_KEY_VALUES_MISMATCH 116 +-# define X509_R_LOADING_CERT_DIR 103 +-# define X509_R_LOADING_DEFAULTS 104 +-# define X509_R_METHOD_NOT_SUPPORTED 124 +-# define X509_R_NAME_TOO_LONG 134 +-# define X509_R_NEWER_CRL_NOT_NEWER 132 +-# define X509_R_NO_CERTIFICATE_FOUND 135 +-# define X509_R_NO_CERTIFICATE_OR_CRL_FOUND 136 +-# define X509_R_NO_CERT_SET_FOR_US_TO_VERIFY 105 +-# define X509_R_NO_CRL_FOUND 137 +-# define X509_R_NO_CRL_NUMBER 130 +-# define X509_R_PUBLIC_KEY_DECODE_ERROR 125 +-# define X509_R_PUBLIC_KEY_ENCODE_ERROR 126 +-# define X509_R_SHOULD_RETRY 106 +-# define X509_R_UNABLE_TO_FIND_PARAMETERS_IN_CHAIN 107 +-# define X509_R_UNABLE_TO_GET_CERTS_PUBLIC_KEY 108 +-# define X509_R_UNKNOWN_KEY_TYPE 117 +-# define X509_R_UNKNOWN_NID 109 +-# define X509_R_UNKNOWN_PURPOSE_ID 121 +-# define X509_R_UNKNOWN_TRUST_ID 120 +-# define X509_R_UNSUPPORTED_ALGORITHM 111 +-# define X509_R_WRONG_LOOKUP_TYPE 112 +-# define X509_R_WRONG_TYPE 122 +- +-#endif +diff --git a/uadk_tool/include/openssl/x509v3.h b/uadk_tool/include/openssl/x509v3.h +deleted file mode 100644 +index 90fa359..0000000 +--- a/uadk_tool/include/openssl/x509v3.h ++++ /dev/null +@@ -1,938 +0,0 @@ +-/* +- * Copyright 1999-2021 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_X509V3_H +-# define HEADER_X509V3_H +- +-# include +-# include +-# include +-# include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-/* Forward reference */ +-struct v3_ext_method; +-struct v3_ext_ctx; +- +-/* Useful typedefs */ +- +-typedef void *(*X509V3_EXT_NEW)(void); +-typedef void (*X509V3_EXT_FREE) (void *); +-typedef void *(*X509V3_EXT_D2I)(void *, const unsigned char **, long); +-typedef int (*X509V3_EXT_I2D) (void *, unsigned char **); +-typedef STACK_OF(CONF_VALUE) * +- (*X509V3_EXT_I2V) (const struct v3_ext_method *method, void *ext, +- STACK_OF(CONF_VALUE) *extlist); +-typedef void *(*X509V3_EXT_V2I)(const struct v3_ext_method *method, +- struct v3_ext_ctx *ctx, +- STACK_OF(CONF_VALUE) *values); +-typedef char *(*X509V3_EXT_I2S)(const struct v3_ext_method *method, +- void *ext); +-typedef void *(*X509V3_EXT_S2I)(const struct v3_ext_method *method, +- struct v3_ext_ctx *ctx, const char *str); +-typedef int (*X509V3_EXT_I2R) (const struct v3_ext_method *method, void *ext, +- BIO *out, int indent); +-typedef void *(*X509V3_EXT_R2I)(const struct v3_ext_method *method, +- struct v3_ext_ctx *ctx, const char *str); +- +-/* V3 extension structure */ +- +-struct v3_ext_method { +- int ext_nid; +- int ext_flags; +-/* If this is set the following four fields are ignored */ +- ASN1_ITEM_EXP *it; +-/* Old style ASN1 calls */ +- X509V3_EXT_NEW ext_new; +- X509V3_EXT_FREE ext_free; +- X509V3_EXT_D2I d2i; +- X509V3_EXT_I2D i2d; +-/* The following pair is used for string extensions */ +- X509V3_EXT_I2S i2s; +- X509V3_EXT_S2I s2i; +-/* The following pair is used for multi-valued extensions */ +- X509V3_EXT_I2V i2v; +- X509V3_EXT_V2I v2i; +-/* The following are used for raw extensions */ +- X509V3_EXT_I2R i2r; +- X509V3_EXT_R2I r2i; +- void *usr_data; /* Any extension specific data */ +-}; +- +-typedef struct X509V3_CONF_METHOD_st { +- char *(*get_string) (void *db, const char *section, const char *value); +- STACK_OF(CONF_VALUE) *(*get_section) (void *db, const char *section); +- void (*free_string) (void *db, char *string); +- void (*free_section) (void *db, STACK_OF(CONF_VALUE) *section); +-} X509V3_CONF_METHOD; +- +-/* Context specific info */ +-struct v3_ext_ctx { +-# define CTX_TEST 0x1 +-# define X509V3_CTX_REPLACE 0x2 +- int flags; +- X509 *issuer_cert; +- X509 *subject_cert; +- X509_REQ *subject_req; +- X509_CRL *crl; +- X509V3_CONF_METHOD *db_meth; +- void *db; +-/* Maybe more here */ +-}; +- +-typedef struct v3_ext_method X509V3_EXT_METHOD; +- +-DEFINE_STACK_OF(X509V3_EXT_METHOD) +- +-/* ext_flags values */ +-# define X509V3_EXT_DYNAMIC 0x1 +-# define X509V3_EXT_CTX_DEP 0x2 +-# define X509V3_EXT_MULTILINE 0x4 +- +-typedef BIT_STRING_BITNAME ENUMERATED_NAMES; +- +-typedef struct BASIC_CONSTRAINTS_st { +- int ca; +- ASN1_INTEGER *pathlen; +-} BASIC_CONSTRAINTS; +- +-typedef struct PKEY_USAGE_PERIOD_st { +- ASN1_GENERALIZEDTIME *notBefore; +- ASN1_GENERALIZEDTIME *notAfter; +-} PKEY_USAGE_PERIOD; +- +-typedef struct otherName_st { +- ASN1_OBJECT *type_id; +- ASN1_TYPE *value; +-} OTHERNAME; +- +-typedef struct EDIPartyName_st { +- ASN1_STRING *nameAssigner; +- ASN1_STRING *partyName; +-} EDIPARTYNAME; +- +-typedef struct GENERAL_NAME_st { +-# define GEN_OTHERNAME 0 +-# define GEN_EMAIL 1 +-# define GEN_DNS 2 +-# define GEN_X400 3 +-# define GEN_DIRNAME 4 +-# define GEN_EDIPARTY 5 +-# define GEN_URI 6 +-# define GEN_IPADD 7 +-# define GEN_RID 8 +- int type; +- union { +- char *ptr; +- OTHERNAME *otherName; /* otherName */ +- ASN1_IA5STRING *rfc822Name; +- ASN1_IA5STRING *dNSName; +- ASN1_TYPE *x400Address; +- X509_NAME *directoryName; +- EDIPARTYNAME *ediPartyName; +- ASN1_IA5STRING *uniformResourceIdentifier; +- ASN1_OCTET_STRING *iPAddress; +- ASN1_OBJECT *registeredID; +- /* Old names */ +- ASN1_OCTET_STRING *ip; /* iPAddress */ +- X509_NAME *dirn; /* dirn */ +- ASN1_IA5STRING *ia5; /* rfc822Name, dNSName, +- * uniformResourceIdentifier */ +- ASN1_OBJECT *rid; /* registeredID */ +- ASN1_TYPE *other; /* x400Address */ +- } d; +-} GENERAL_NAME; +- +-typedef struct ACCESS_DESCRIPTION_st { +- ASN1_OBJECT *method; +- GENERAL_NAME *location; +-} ACCESS_DESCRIPTION; +- +-typedef STACK_OF(ACCESS_DESCRIPTION) AUTHORITY_INFO_ACCESS; +- +-typedef STACK_OF(ASN1_OBJECT) EXTENDED_KEY_USAGE; +- +-typedef STACK_OF(ASN1_INTEGER) TLS_FEATURE; +- +-DEFINE_STACK_OF(GENERAL_NAME) +-typedef STACK_OF(GENERAL_NAME) GENERAL_NAMES; +-DEFINE_STACK_OF(GENERAL_NAMES) +- +-DEFINE_STACK_OF(ACCESS_DESCRIPTION) +- +-typedef struct DIST_POINT_NAME_st { +- int type; +- union { +- GENERAL_NAMES *fullname; +- STACK_OF(X509_NAME_ENTRY) *relativename; +- } name; +-/* If relativename then this contains the full distribution point name */ +- X509_NAME *dpname; +-} DIST_POINT_NAME; +-/* All existing reasons */ +-# define CRLDP_ALL_REASONS 0x807f +- +-# define CRL_REASON_NONE -1 +-# define CRL_REASON_UNSPECIFIED 0 +-# define CRL_REASON_KEY_COMPROMISE 1 +-# define CRL_REASON_CA_COMPROMISE 2 +-# define CRL_REASON_AFFILIATION_CHANGED 3 +-# define CRL_REASON_SUPERSEDED 4 +-# define CRL_REASON_CESSATION_OF_OPERATION 5 +-# define CRL_REASON_CERTIFICATE_HOLD 6 +-# define CRL_REASON_REMOVE_FROM_CRL 8 +-# define CRL_REASON_PRIVILEGE_WITHDRAWN 9 +-# define CRL_REASON_AA_COMPROMISE 10 +- +-struct DIST_POINT_st { +- DIST_POINT_NAME *distpoint; +- ASN1_BIT_STRING *reasons; +- GENERAL_NAMES *CRLissuer; +- int dp_reasons; +-}; +- +-typedef STACK_OF(DIST_POINT) CRL_DIST_POINTS; +- +-DEFINE_STACK_OF(DIST_POINT) +- +-struct AUTHORITY_KEYID_st { +- ASN1_OCTET_STRING *keyid; +- GENERAL_NAMES *issuer; +- ASN1_INTEGER *serial; +-}; +- +-/* Strong extranet structures */ +- +-typedef struct SXNET_ID_st { +- ASN1_INTEGER *zone; +- ASN1_OCTET_STRING *user; +-} SXNETID; +- +-DEFINE_STACK_OF(SXNETID) +- +-typedef struct SXNET_st { +- ASN1_INTEGER *version; +- STACK_OF(SXNETID) *ids; +-} SXNET; +- +-typedef struct NOTICEREF_st { +- ASN1_STRING *organization; +- STACK_OF(ASN1_INTEGER) *noticenos; +-} NOTICEREF; +- +-typedef struct USERNOTICE_st { +- NOTICEREF *noticeref; +- ASN1_STRING *exptext; +-} USERNOTICE; +- +-typedef struct POLICYQUALINFO_st { +- ASN1_OBJECT *pqualid; +- union { +- ASN1_IA5STRING *cpsuri; +- USERNOTICE *usernotice; +- ASN1_TYPE *other; +- } d; +-} POLICYQUALINFO; +- +-DEFINE_STACK_OF(POLICYQUALINFO) +- +-typedef struct POLICYINFO_st { +- ASN1_OBJECT *policyid; +- STACK_OF(POLICYQUALINFO) *qualifiers; +-} POLICYINFO; +- +-typedef STACK_OF(POLICYINFO) CERTIFICATEPOLICIES; +- +-DEFINE_STACK_OF(POLICYINFO) +- +-typedef struct POLICY_MAPPING_st { +- ASN1_OBJECT *issuerDomainPolicy; +- ASN1_OBJECT *subjectDomainPolicy; +-} POLICY_MAPPING; +- +-DEFINE_STACK_OF(POLICY_MAPPING) +- +-typedef STACK_OF(POLICY_MAPPING) POLICY_MAPPINGS; +- +-typedef struct GENERAL_SUBTREE_st { +- GENERAL_NAME *base; +- ASN1_INTEGER *minimum; +- ASN1_INTEGER *maximum; +-} GENERAL_SUBTREE; +- +-DEFINE_STACK_OF(GENERAL_SUBTREE) +- +-struct NAME_CONSTRAINTS_st { +- STACK_OF(GENERAL_SUBTREE) *permittedSubtrees; +- STACK_OF(GENERAL_SUBTREE) *excludedSubtrees; +-}; +- +-typedef struct POLICY_CONSTRAINTS_st { +- ASN1_INTEGER *requireExplicitPolicy; +- ASN1_INTEGER *inhibitPolicyMapping; +-} POLICY_CONSTRAINTS; +- +-/* Proxy certificate structures, see RFC 3820 */ +-typedef struct PROXY_POLICY_st { +- ASN1_OBJECT *policyLanguage; +- ASN1_OCTET_STRING *policy; +-} PROXY_POLICY; +- +-typedef struct PROXY_CERT_INFO_EXTENSION_st { +- ASN1_INTEGER *pcPathLengthConstraint; +- PROXY_POLICY *proxyPolicy; +-} PROXY_CERT_INFO_EXTENSION; +- +-DECLARE_ASN1_FUNCTIONS(PROXY_POLICY) +-DECLARE_ASN1_FUNCTIONS(PROXY_CERT_INFO_EXTENSION) +- +-struct ISSUING_DIST_POINT_st { +- DIST_POINT_NAME *distpoint; +- int onlyuser; +- int onlyCA; +- ASN1_BIT_STRING *onlysomereasons; +- int indirectCRL; +- int onlyattr; +-}; +- +-/* Values in idp_flags field */ +-/* IDP present */ +-# define IDP_PRESENT 0x1 +-/* IDP values inconsistent */ +-# define IDP_INVALID 0x2 +-/* onlyuser true */ +-# define IDP_ONLYUSER 0x4 +-/* onlyCA true */ +-# define IDP_ONLYCA 0x8 +-/* onlyattr true */ +-# define IDP_ONLYATTR 0x10 +-/* indirectCRL true */ +-# define IDP_INDIRECT 0x20 +-/* onlysomereasons present */ +-# define IDP_REASONS 0x40 +- +-# define X509V3_conf_err(val) ERR_add_error_data(6, \ +- "section:", (val)->section, \ +- ",name:", (val)->name, ",value:", (val)->value) +- +-# define X509V3_set_ctx_test(ctx) \ +- X509V3_set_ctx(ctx, NULL, NULL, NULL, NULL, CTX_TEST) +-# define X509V3_set_ctx_nodb(ctx) (ctx)->db = NULL; +- +-# define EXT_BITSTRING(nid, table) { nid, 0, ASN1_ITEM_ref(ASN1_BIT_STRING), \ +- 0,0,0,0, \ +- 0,0, \ +- (X509V3_EXT_I2V)i2v_ASN1_BIT_STRING, \ +- (X509V3_EXT_V2I)v2i_ASN1_BIT_STRING, \ +- NULL, NULL, \ +- table} +- +-# define EXT_IA5STRING(nid) { nid, 0, ASN1_ITEM_ref(ASN1_IA5STRING), \ +- 0,0,0,0, \ +- (X509V3_EXT_I2S)i2s_ASN1_IA5STRING, \ +- (X509V3_EXT_S2I)s2i_ASN1_IA5STRING, \ +- 0,0,0,0, \ +- NULL} +- +-# define EXT_END { -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} +- +-/* X509_PURPOSE stuff */ +- +-# define EXFLAG_BCONS 0x1 +-# define EXFLAG_KUSAGE 0x2 +-# define EXFLAG_XKUSAGE 0x4 +-# define EXFLAG_NSCERT 0x8 +- +-# define EXFLAG_CA 0x10 +-/* Really self issued not necessarily self signed */ +-# define EXFLAG_SI 0x20 +-# define EXFLAG_V1 0x40 +-# define EXFLAG_INVALID 0x80 +-/* EXFLAG_SET is set to indicate that some values have been precomputed */ +-# define EXFLAG_SET 0x100 +-# define EXFLAG_CRITICAL 0x200 +-# define EXFLAG_PROXY 0x400 +- +-# define EXFLAG_INVALID_POLICY 0x800 +-# define EXFLAG_FRESHEST 0x1000 +-# define EXFLAG_SS 0x2000 /* cert is apparently self-signed */ +- +-# define EXFLAG_NO_FINGERPRINT 0x100000 +- +-# define KU_DIGITAL_SIGNATURE 0x0080 +-# define KU_NON_REPUDIATION 0x0040 +-# define KU_KEY_ENCIPHERMENT 0x0020 +-# define KU_DATA_ENCIPHERMENT 0x0010 +-# define KU_KEY_AGREEMENT 0x0008 +-# define KU_KEY_CERT_SIGN 0x0004 +-# define KU_CRL_SIGN 0x0002 +-# define KU_ENCIPHER_ONLY 0x0001 +-# define KU_DECIPHER_ONLY 0x8000 +- +-# define NS_SSL_CLIENT 0x80 +-# define NS_SSL_SERVER 0x40 +-# define NS_SMIME 0x20 +-# define NS_OBJSIGN 0x10 +-# define NS_SSL_CA 0x04 +-# define NS_SMIME_CA 0x02 +-# define NS_OBJSIGN_CA 0x01 +-# define NS_ANY_CA (NS_SSL_CA|NS_SMIME_CA|NS_OBJSIGN_CA) +- +-# define XKU_SSL_SERVER 0x1 +-# define XKU_SSL_CLIENT 0x2 +-# define XKU_SMIME 0x4 +-# define XKU_CODE_SIGN 0x8 +-# define XKU_SGC 0x10 +-# define XKU_OCSP_SIGN 0x20 +-# define XKU_TIMESTAMP 0x40 +-# define XKU_DVCS 0x80 +-# define XKU_ANYEKU 0x100 +- +-# define X509_PURPOSE_DYNAMIC 0x1 +-# define X509_PURPOSE_DYNAMIC_NAME 0x2 +- +-typedef struct x509_purpose_st { +- int purpose; +- int trust; /* Default trust ID */ +- int flags; +- int (*check_purpose) (const struct x509_purpose_st *, const X509 *, int); +- char *name; +- char *sname; +- void *usr_data; +-} X509_PURPOSE; +- +-# define X509_PURPOSE_SSL_CLIENT 1 +-# define X509_PURPOSE_SSL_SERVER 2 +-# define X509_PURPOSE_NS_SSL_SERVER 3 +-# define X509_PURPOSE_SMIME_SIGN 4 +-# define X509_PURPOSE_SMIME_ENCRYPT 5 +-# define X509_PURPOSE_CRL_SIGN 6 +-# define X509_PURPOSE_ANY 7 +-# define X509_PURPOSE_OCSP_HELPER 8 +-# define X509_PURPOSE_TIMESTAMP_SIGN 9 +- +-# define X509_PURPOSE_MIN 1 +-# define X509_PURPOSE_MAX 9 +- +-/* Flags for X509V3_EXT_print() */ +- +-# define X509V3_EXT_UNKNOWN_MASK (0xfL << 16) +-/* Return error for unknown extensions */ +-# define X509V3_EXT_DEFAULT 0 +-/* Print error for unknown extensions */ +-# define X509V3_EXT_ERROR_UNKNOWN (1L << 16) +-/* ASN1 parse unknown extensions */ +-# define X509V3_EXT_PARSE_UNKNOWN (2L << 16) +-/* BIO_dump unknown extensions */ +-# define X509V3_EXT_DUMP_UNKNOWN (3L << 16) +- +-/* Flags for X509V3_add1_i2d */ +- +-# define X509V3_ADD_OP_MASK 0xfL +-# define X509V3_ADD_DEFAULT 0L +-# define X509V3_ADD_APPEND 1L +-# define X509V3_ADD_REPLACE 2L +-# define X509V3_ADD_REPLACE_EXISTING 3L +-# define X509V3_ADD_KEEP_EXISTING 4L +-# define X509V3_ADD_DELETE 5L +-# define X509V3_ADD_SILENT 0x10 +- +-DEFINE_STACK_OF(X509_PURPOSE) +- +-DECLARE_ASN1_FUNCTIONS(BASIC_CONSTRAINTS) +- +-DECLARE_ASN1_FUNCTIONS(SXNET) +-DECLARE_ASN1_FUNCTIONS(SXNETID) +- +-int SXNET_add_id_asc(SXNET **psx, const char *zone, const char *user, int userlen); +-int SXNET_add_id_ulong(SXNET **psx, unsigned long lzone, const char *user, +- int userlen); +-int SXNET_add_id_INTEGER(SXNET **psx, ASN1_INTEGER *izone, const char *user, +- int userlen); +- +-ASN1_OCTET_STRING *SXNET_get_id_asc(SXNET *sx, const char *zone); +-ASN1_OCTET_STRING *SXNET_get_id_ulong(SXNET *sx, unsigned long lzone); +-ASN1_OCTET_STRING *SXNET_get_id_INTEGER(SXNET *sx, ASN1_INTEGER *zone); +- +-DECLARE_ASN1_FUNCTIONS(AUTHORITY_KEYID) +- +-DECLARE_ASN1_FUNCTIONS(PKEY_USAGE_PERIOD) +- +-DECLARE_ASN1_FUNCTIONS(GENERAL_NAME) +-GENERAL_NAME *GENERAL_NAME_dup(GENERAL_NAME *a); +-int GENERAL_NAME_cmp(GENERAL_NAME *a, GENERAL_NAME *b); +- +-ASN1_BIT_STRING *v2i_ASN1_BIT_STRING(X509V3_EXT_METHOD *method, +- X509V3_CTX *ctx, +- STACK_OF(CONF_VALUE) *nval); +-STACK_OF(CONF_VALUE) *i2v_ASN1_BIT_STRING(X509V3_EXT_METHOD *method, +- ASN1_BIT_STRING *bits, +- STACK_OF(CONF_VALUE) *extlist); +-char *i2s_ASN1_IA5STRING(X509V3_EXT_METHOD *method, ASN1_IA5STRING *ia5); +-ASN1_IA5STRING *s2i_ASN1_IA5STRING(X509V3_EXT_METHOD *method, +- X509V3_CTX *ctx, const char *str); +- +-STACK_OF(CONF_VALUE) *i2v_GENERAL_NAME(X509V3_EXT_METHOD *method, +- GENERAL_NAME *gen, +- STACK_OF(CONF_VALUE) *ret); +-int GENERAL_NAME_print(BIO *out, GENERAL_NAME *gen); +- +-DECLARE_ASN1_FUNCTIONS(GENERAL_NAMES) +- +-STACK_OF(CONF_VALUE) *i2v_GENERAL_NAMES(X509V3_EXT_METHOD *method, +- GENERAL_NAMES *gen, +- STACK_OF(CONF_VALUE) *extlist); +-GENERAL_NAMES *v2i_GENERAL_NAMES(const X509V3_EXT_METHOD *method, +- X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *nval); +- +-DECLARE_ASN1_FUNCTIONS(OTHERNAME) +-DECLARE_ASN1_FUNCTIONS(EDIPARTYNAME) +-int OTHERNAME_cmp(OTHERNAME *a, OTHERNAME *b); +-void GENERAL_NAME_set0_value(GENERAL_NAME *a, int type, void *value); +-void *GENERAL_NAME_get0_value(const GENERAL_NAME *a, int *ptype); +-int GENERAL_NAME_set0_othername(GENERAL_NAME *gen, +- ASN1_OBJECT *oid, ASN1_TYPE *value); +-int GENERAL_NAME_get0_otherName(const GENERAL_NAME *gen, +- ASN1_OBJECT **poid, ASN1_TYPE **pvalue); +- +-char *i2s_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method, +- const ASN1_OCTET_STRING *ia5); +-ASN1_OCTET_STRING *s2i_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method, +- X509V3_CTX *ctx, const char *str); +- +-DECLARE_ASN1_FUNCTIONS(EXTENDED_KEY_USAGE) +-int i2a_ACCESS_DESCRIPTION(BIO *bp, const ACCESS_DESCRIPTION *a); +- +-DECLARE_ASN1_ALLOC_FUNCTIONS(TLS_FEATURE) +- +-DECLARE_ASN1_FUNCTIONS(CERTIFICATEPOLICIES) +-DECLARE_ASN1_FUNCTIONS(POLICYINFO) +-DECLARE_ASN1_FUNCTIONS(POLICYQUALINFO) +-DECLARE_ASN1_FUNCTIONS(USERNOTICE) +-DECLARE_ASN1_FUNCTIONS(NOTICEREF) +- +-DECLARE_ASN1_FUNCTIONS(CRL_DIST_POINTS) +-DECLARE_ASN1_FUNCTIONS(DIST_POINT) +-DECLARE_ASN1_FUNCTIONS(DIST_POINT_NAME) +-DECLARE_ASN1_FUNCTIONS(ISSUING_DIST_POINT) +- +-int DIST_POINT_set_dpname(DIST_POINT_NAME *dpn, X509_NAME *iname); +- +-int NAME_CONSTRAINTS_check(X509 *x, NAME_CONSTRAINTS *nc); +-int NAME_CONSTRAINTS_check_CN(X509 *x, NAME_CONSTRAINTS *nc); +- +-DECLARE_ASN1_FUNCTIONS(ACCESS_DESCRIPTION) +-DECLARE_ASN1_FUNCTIONS(AUTHORITY_INFO_ACCESS) +- +-DECLARE_ASN1_ITEM(POLICY_MAPPING) +-DECLARE_ASN1_ALLOC_FUNCTIONS(POLICY_MAPPING) +-DECLARE_ASN1_ITEM(POLICY_MAPPINGS) +- +-DECLARE_ASN1_ITEM(GENERAL_SUBTREE) +-DECLARE_ASN1_ALLOC_FUNCTIONS(GENERAL_SUBTREE) +- +-DECLARE_ASN1_ITEM(NAME_CONSTRAINTS) +-DECLARE_ASN1_ALLOC_FUNCTIONS(NAME_CONSTRAINTS) +- +-DECLARE_ASN1_ALLOC_FUNCTIONS(POLICY_CONSTRAINTS) +-DECLARE_ASN1_ITEM(POLICY_CONSTRAINTS) +- +-GENERAL_NAME *a2i_GENERAL_NAME(GENERAL_NAME *out, +- const X509V3_EXT_METHOD *method, +- X509V3_CTX *ctx, int gen_type, +- const char *value, int is_nc); +- +-# ifdef HEADER_CONF_H +-GENERAL_NAME *v2i_GENERAL_NAME(const X509V3_EXT_METHOD *method, +- X509V3_CTX *ctx, CONF_VALUE *cnf); +-GENERAL_NAME *v2i_GENERAL_NAME_ex(GENERAL_NAME *out, +- const X509V3_EXT_METHOD *method, +- X509V3_CTX *ctx, CONF_VALUE *cnf, +- int is_nc); +-void X509V3_conf_free(CONF_VALUE *val); +- +-X509_EXTENSION *X509V3_EXT_nconf_nid(CONF *conf, X509V3_CTX *ctx, int ext_nid, +- const char *value); +-X509_EXTENSION *X509V3_EXT_nconf(CONF *conf, X509V3_CTX *ctx, const char *name, +- const char *value); +-int X509V3_EXT_add_nconf_sk(CONF *conf, X509V3_CTX *ctx, const char *section, +- STACK_OF(X509_EXTENSION) **sk); +-int X509V3_EXT_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section, +- X509 *cert); +-int X509V3_EXT_REQ_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section, +- X509_REQ *req); +-int X509V3_EXT_CRL_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section, +- X509_CRL *crl); +- +-X509_EXTENSION *X509V3_EXT_conf_nid(LHASH_OF(CONF_VALUE) *conf, +- X509V3_CTX *ctx, int ext_nid, +- const char *value); +-X509_EXTENSION *X509V3_EXT_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx, +- const char *name, const char *value); +-int X509V3_EXT_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx, +- const char *section, X509 *cert); +-int X509V3_EXT_REQ_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx, +- const char *section, X509_REQ *req); +-int X509V3_EXT_CRL_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx, +- const char *section, X509_CRL *crl); +- +-int X509V3_add_value_bool_nf(const char *name, int asn1_bool, +- STACK_OF(CONF_VALUE) **extlist); +-int X509V3_get_value_bool(const CONF_VALUE *value, int *asn1_bool); +-int X509V3_get_value_int(const CONF_VALUE *value, ASN1_INTEGER **aint); +-void X509V3_set_nconf(X509V3_CTX *ctx, CONF *conf); +-void X509V3_set_conf_lhash(X509V3_CTX *ctx, LHASH_OF(CONF_VALUE) *lhash); +-# endif +- +-char *X509V3_get_string(X509V3_CTX *ctx, const char *name, const char *section); +-STACK_OF(CONF_VALUE) *X509V3_get_section(X509V3_CTX *ctx, const char *section); +-void X509V3_string_free(X509V3_CTX *ctx, char *str); +-void X509V3_section_free(X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *section); +-void X509V3_set_ctx(X509V3_CTX *ctx, X509 *issuer, X509 *subject, +- X509_REQ *req, X509_CRL *crl, int flags); +- +-int X509V3_add_value(const char *name, const char *value, +- STACK_OF(CONF_VALUE) **extlist); +-int X509V3_add_value_uchar(const char *name, const unsigned char *value, +- STACK_OF(CONF_VALUE) **extlist); +-int X509V3_add_value_bool(const char *name, int asn1_bool, +- STACK_OF(CONF_VALUE) **extlist); +-int X509V3_add_value_int(const char *name, const ASN1_INTEGER *aint, +- STACK_OF(CONF_VALUE) **extlist); +-char *i2s_ASN1_INTEGER(X509V3_EXT_METHOD *meth, const ASN1_INTEGER *aint); +-ASN1_INTEGER *s2i_ASN1_INTEGER(X509V3_EXT_METHOD *meth, const char *value); +-char *i2s_ASN1_ENUMERATED(X509V3_EXT_METHOD *meth, const ASN1_ENUMERATED *aint); +-char *i2s_ASN1_ENUMERATED_TABLE(X509V3_EXT_METHOD *meth, +- const ASN1_ENUMERATED *aint); +-int X509V3_EXT_add(X509V3_EXT_METHOD *ext); +-int X509V3_EXT_add_list(X509V3_EXT_METHOD *extlist); +-int X509V3_EXT_add_alias(int nid_to, int nid_from); +-void X509V3_EXT_cleanup(void); +- +-const X509V3_EXT_METHOD *X509V3_EXT_get(X509_EXTENSION *ext); +-const X509V3_EXT_METHOD *X509V3_EXT_get_nid(int nid); +-int X509V3_add_standard_extensions(void); +-STACK_OF(CONF_VALUE) *X509V3_parse_list(const char *line); +-void *X509V3_EXT_d2i(X509_EXTENSION *ext); +-void *X509V3_get_d2i(const STACK_OF(X509_EXTENSION) *x, int nid, int *crit, +- int *idx); +- +-X509_EXTENSION *X509V3_EXT_i2d(int ext_nid, int crit, void *ext_struc); +-int X509V3_add1_i2d(STACK_OF(X509_EXTENSION) **x, int nid, void *value, +- int crit, unsigned long flags); +- +-#if OPENSSL_API_COMPAT < 0x10100000L +-/* The new declarations are in crypto.h, but the old ones were here. */ +-# define hex_to_string OPENSSL_buf2hexstr +-# define string_to_hex OPENSSL_hexstr2buf +-#endif +- +-void X509V3_EXT_val_prn(BIO *out, STACK_OF(CONF_VALUE) *val, int indent, +- int ml); +-int X509V3_EXT_print(BIO *out, X509_EXTENSION *ext, unsigned long flag, +- int indent); +-#ifndef OPENSSL_NO_STDIO +-int X509V3_EXT_print_fp(FILE *out, X509_EXTENSION *ext, int flag, int indent); +-#endif +-int X509V3_extensions_print(BIO *out, const char *title, +- const STACK_OF(X509_EXTENSION) *exts, +- unsigned long flag, int indent); +- +-int X509_check_ca(X509 *x); +-int X509_check_purpose(X509 *x, int id, int ca); +-int X509_supported_extension(X509_EXTENSION *ex); +-int X509_PURPOSE_set(int *p, int purpose); +-int X509_check_issued(X509 *issuer, X509 *subject); +-int X509_check_akid(X509 *issuer, AUTHORITY_KEYID *akid); +-void X509_set_proxy_flag(X509 *x); +-void X509_set_proxy_pathlen(X509 *x, long l); +-long X509_get_proxy_pathlen(X509 *x); +- +-uint32_t X509_get_extension_flags(X509 *x); +-uint32_t X509_get_key_usage(X509 *x); +-uint32_t X509_get_extended_key_usage(X509 *x); +-const ASN1_OCTET_STRING *X509_get0_subject_key_id(X509 *x); +-const ASN1_OCTET_STRING *X509_get0_authority_key_id(X509 *x); +-const GENERAL_NAMES *X509_get0_authority_issuer(X509 *x); +-const ASN1_INTEGER *X509_get0_authority_serial(X509 *x); +- +-int X509_PURPOSE_get_count(void); +-X509_PURPOSE *X509_PURPOSE_get0(int idx); +-int X509_PURPOSE_get_by_sname(const char *sname); +-int X509_PURPOSE_get_by_id(int id); +-int X509_PURPOSE_add(int id, int trust, int flags, +- int (*ck) (const X509_PURPOSE *, const X509 *, int), +- const char *name, const char *sname, void *arg); +-char *X509_PURPOSE_get0_name(const X509_PURPOSE *xp); +-char *X509_PURPOSE_get0_sname(const X509_PURPOSE *xp); +-int X509_PURPOSE_get_trust(const X509_PURPOSE *xp); +-void X509_PURPOSE_cleanup(void); +-int X509_PURPOSE_get_id(const X509_PURPOSE *); +- +-STACK_OF(OPENSSL_STRING) *X509_get1_email(X509 *x); +-STACK_OF(OPENSSL_STRING) *X509_REQ_get1_email(X509_REQ *x); +-void X509_email_free(STACK_OF(OPENSSL_STRING) *sk); +-STACK_OF(OPENSSL_STRING) *X509_get1_ocsp(X509 *x); +-/* Flags for X509_check_* functions */ +- +-/* +- * Always check subject name for host match even if subject alt names present +- */ +-# define X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT 0x1 +-/* Disable wildcard matching for dnsName fields and common name. */ +-# define X509_CHECK_FLAG_NO_WILDCARDS 0x2 +-/* Wildcards must not match a partial label. */ +-# define X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS 0x4 +-/* Allow (non-partial) wildcards to match multiple labels. */ +-# define X509_CHECK_FLAG_MULTI_LABEL_WILDCARDS 0x8 +-/* Constraint verifier subdomain patterns to match a single labels. */ +-# define X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS 0x10 +-/* Never check the subject CN */ +-# define X509_CHECK_FLAG_NEVER_CHECK_SUBJECT 0x20 +-/* +- * Match reference identifiers starting with "." to any sub-domain. +- * This is a non-public flag, turned on implicitly when the subject +- * reference identity is a DNS name. +- */ +-# define _X509_CHECK_FLAG_DOT_SUBDOMAINS 0x8000 +- +-int X509_check_host(X509 *x, const char *chk, size_t chklen, +- unsigned int flags, char **peername); +-int X509_check_email(X509 *x, const char *chk, size_t chklen, +- unsigned int flags); +-int X509_check_ip(X509 *x, const unsigned char *chk, size_t chklen, +- unsigned int flags); +-int X509_check_ip_asc(X509 *x, const char *ipasc, unsigned int flags); +- +-ASN1_OCTET_STRING *a2i_IPADDRESS(const char *ipasc); +-ASN1_OCTET_STRING *a2i_IPADDRESS_NC(const char *ipasc); +-int X509V3_NAME_from_section(X509_NAME *nm, STACK_OF(CONF_VALUE) *dn_sk, +- unsigned long chtype); +- +-void X509_POLICY_NODE_print(BIO *out, X509_POLICY_NODE *node, int indent); +-DEFINE_STACK_OF(X509_POLICY_NODE) +- +-#ifndef OPENSSL_NO_RFC3779 +-typedef struct ASRange_st { +- ASN1_INTEGER *min, *max; +-} ASRange; +- +-# define ASIdOrRange_id 0 +-# define ASIdOrRange_range 1 +- +-typedef struct ASIdOrRange_st { +- int type; +- union { +- ASN1_INTEGER *id; +- ASRange *range; +- } u; +-} ASIdOrRange; +- +-typedef STACK_OF(ASIdOrRange) ASIdOrRanges; +-DEFINE_STACK_OF(ASIdOrRange) +- +-# define ASIdentifierChoice_inherit 0 +-# define ASIdentifierChoice_asIdsOrRanges 1 +- +-typedef struct ASIdentifierChoice_st { +- int type; +- union { +- ASN1_NULL *inherit; +- ASIdOrRanges *asIdsOrRanges; +- } u; +-} ASIdentifierChoice; +- +-typedef struct ASIdentifiers_st { +- ASIdentifierChoice *asnum, *rdi; +-} ASIdentifiers; +- +-DECLARE_ASN1_FUNCTIONS(ASRange) +-DECLARE_ASN1_FUNCTIONS(ASIdOrRange) +-DECLARE_ASN1_FUNCTIONS(ASIdentifierChoice) +-DECLARE_ASN1_FUNCTIONS(ASIdentifiers) +- +-typedef struct IPAddressRange_st { +- ASN1_BIT_STRING *min, *max; +-} IPAddressRange; +- +-# define IPAddressOrRange_addressPrefix 0 +-# define IPAddressOrRange_addressRange 1 +- +-typedef struct IPAddressOrRange_st { +- int type; +- union { +- ASN1_BIT_STRING *addressPrefix; +- IPAddressRange *addressRange; +- } u; +-} IPAddressOrRange; +- +-typedef STACK_OF(IPAddressOrRange) IPAddressOrRanges; +-DEFINE_STACK_OF(IPAddressOrRange) +- +-# define IPAddressChoice_inherit 0 +-# define IPAddressChoice_addressesOrRanges 1 +- +-typedef struct IPAddressChoice_st { +- int type; +- union { +- ASN1_NULL *inherit; +- IPAddressOrRanges *addressesOrRanges; +- } u; +-} IPAddressChoice; +- +-typedef struct IPAddressFamily_st { +- ASN1_OCTET_STRING *addressFamily; +- IPAddressChoice *ipAddressChoice; +-} IPAddressFamily; +- +-typedef STACK_OF(IPAddressFamily) IPAddrBlocks; +-DEFINE_STACK_OF(IPAddressFamily) +- +-DECLARE_ASN1_FUNCTIONS(IPAddressRange) +-DECLARE_ASN1_FUNCTIONS(IPAddressOrRange) +-DECLARE_ASN1_FUNCTIONS(IPAddressChoice) +-DECLARE_ASN1_FUNCTIONS(IPAddressFamily) +- +-/* +- * API tag for elements of the ASIdentifer SEQUENCE. +- */ +-# define V3_ASID_ASNUM 0 +-# define V3_ASID_RDI 1 +- +-/* +- * AFI values, assigned by IANA. It'd be nice to make the AFI +- * handling code totally generic, but there are too many little things +- * that would need to be defined for other address families for it to +- * be worth the trouble. +- */ +-# define IANA_AFI_IPV4 1 +-# define IANA_AFI_IPV6 2 +- +-/* +- * Utilities to construct and extract values from RFC3779 extensions, +- * since some of the encodings (particularly for IP address prefixes +- * and ranges) are a bit tedious to work with directly. +- */ +-int X509v3_asid_add_inherit(ASIdentifiers *asid, int which); +-int X509v3_asid_add_id_or_range(ASIdentifiers *asid, int which, +- ASN1_INTEGER *min, ASN1_INTEGER *max); +-int X509v3_addr_add_inherit(IPAddrBlocks *addr, +- const unsigned afi, const unsigned *safi); +-int X509v3_addr_add_prefix(IPAddrBlocks *addr, +- const unsigned afi, const unsigned *safi, +- unsigned char *a, const int prefixlen); +-int X509v3_addr_add_range(IPAddrBlocks *addr, +- const unsigned afi, const unsigned *safi, +- unsigned char *min, unsigned char *max); +-unsigned X509v3_addr_get_afi(const IPAddressFamily *f); +-int X509v3_addr_get_range(IPAddressOrRange *aor, const unsigned afi, +- unsigned char *min, unsigned char *max, +- const int length); +- +-/* +- * Canonical forms. +- */ +-int X509v3_asid_is_canonical(ASIdentifiers *asid); +-int X509v3_addr_is_canonical(IPAddrBlocks *addr); +-int X509v3_asid_canonize(ASIdentifiers *asid); +-int X509v3_addr_canonize(IPAddrBlocks *addr); +- +-/* +- * Tests for inheritance and containment. +- */ +-int X509v3_asid_inherits(ASIdentifiers *asid); +-int X509v3_addr_inherits(IPAddrBlocks *addr); +-int X509v3_asid_subset(ASIdentifiers *a, ASIdentifiers *b); +-int X509v3_addr_subset(IPAddrBlocks *a, IPAddrBlocks *b); +- +-/* +- * Check whether RFC 3779 extensions nest properly in chains. +- */ +-int X509v3_asid_validate_path(X509_STORE_CTX *); +-int X509v3_addr_validate_path(X509_STORE_CTX *); +-int X509v3_asid_validate_resource_set(STACK_OF(X509) *chain, +- ASIdentifiers *ext, +- int allow_inheritance); +-int X509v3_addr_validate_resource_set(STACK_OF(X509) *chain, +- IPAddrBlocks *ext, int allow_inheritance); +- +-#endif /* OPENSSL_NO_RFC3779 */ +- +-DEFINE_STACK_OF(ASN1_STRING) +- +-/* +- * Admission Syntax +- */ +-typedef struct NamingAuthority_st NAMING_AUTHORITY; +-typedef struct ProfessionInfo_st PROFESSION_INFO; +-typedef struct Admissions_st ADMISSIONS; +-typedef struct AdmissionSyntax_st ADMISSION_SYNTAX; +-DECLARE_ASN1_FUNCTIONS(NAMING_AUTHORITY) +-DECLARE_ASN1_FUNCTIONS(PROFESSION_INFO) +-DECLARE_ASN1_FUNCTIONS(ADMISSIONS) +-DECLARE_ASN1_FUNCTIONS(ADMISSION_SYNTAX) +-DEFINE_STACK_OF(ADMISSIONS) +-DEFINE_STACK_OF(PROFESSION_INFO) +-typedef STACK_OF(PROFESSION_INFO) PROFESSION_INFOS; +- +-const ASN1_OBJECT *NAMING_AUTHORITY_get0_authorityId( +- const NAMING_AUTHORITY *n); +-const ASN1_IA5STRING *NAMING_AUTHORITY_get0_authorityURL( +- const NAMING_AUTHORITY *n); +-const ASN1_STRING *NAMING_AUTHORITY_get0_authorityText( +- const NAMING_AUTHORITY *n); +-void NAMING_AUTHORITY_set0_authorityId(NAMING_AUTHORITY *n, +- ASN1_OBJECT* namingAuthorityId); +-void NAMING_AUTHORITY_set0_authorityURL(NAMING_AUTHORITY *n, +- ASN1_IA5STRING* namingAuthorityUrl); +-void NAMING_AUTHORITY_set0_authorityText(NAMING_AUTHORITY *n, +- ASN1_STRING* namingAuthorityText); +- +-const GENERAL_NAME *ADMISSION_SYNTAX_get0_admissionAuthority( +- const ADMISSION_SYNTAX *as); +-void ADMISSION_SYNTAX_set0_admissionAuthority( +- ADMISSION_SYNTAX *as, GENERAL_NAME *aa); +-const STACK_OF(ADMISSIONS) *ADMISSION_SYNTAX_get0_contentsOfAdmissions( +- const ADMISSION_SYNTAX *as); +-void ADMISSION_SYNTAX_set0_contentsOfAdmissions( +- ADMISSION_SYNTAX *as, STACK_OF(ADMISSIONS) *a); +-const GENERAL_NAME *ADMISSIONS_get0_admissionAuthority(const ADMISSIONS *a); +-void ADMISSIONS_set0_admissionAuthority(ADMISSIONS *a, GENERAL_NAME *aa); +-const NAMING_AUTHORITY *ADMISSIONS_get0_namingAuthority(const ADMISSIONS *a); +-void ADMISSIONS_set0_namingAuthority(ADMISSIONS *a, NAMING_AUTHORITY *na); +-const PROFESSION_INFOS *ADMISSIONS_get0_professionInfos(const ADMISSIONS *a); +-void ADMISSIONS_set0_professionInfos(ADMISSIONS *a, PROFESSION_INFOS *pi); +-const ASN1_OCTET_STRING *PROFESSION_INFO_get0_addProfessionInfo( +- const PROFESSION_INFO *pi); +-void PROFESSION_INFO_set0_addProfessionInfo( +- PROFESSION_INFO *pi, ASN1_OCTET_STRING *aos); +-const NAMING_AUTHORITY *PROFESSION_INFO_get0_namingAuthority( +- const PROFESSION_INFO *pi); +-void PROFESSION_INFO_set0_namingAuthority( +- PROFESSION_INFO *pi, NAMING_AUTHORITY *na); +-const STACK_OF(ASN1_STRING) *PROFESSION_INFO_get0_professionItems( +- const PROFESSION_INFO *pi); +-void PROFESSION_INFO_set0_professionItems( +- PROFESSION_INFO *pi, STACK_OF(ASN1_STRING) *as); +-const STACK_OF(ASN1_OBJECT) *PROFESSION_INFO_get0_professionOIDs( +- const PROFESSION_INFO *pi); +-void PROFESSION_INFO_set0_professionOIDs( +- PROFESSION_INFO *pi, STACK_OF(ASN1_OBJECT) *po); +-const ASN1_PRINTABLESTRING *PROFESSION_INFO_get0_registrationNumber( +- const PROFESSION_INFO *pi); +-void PROFESSION_INFO_set0_registrationNumber( +- PROFESSION_INFO *pi, ASN1_PRINTABLESTRING *rn); +- +-# ifdef __cplusplus +-} +-# endif +-#endif +diff --git a/uadk_tool/include/openssl/x509v3err.h b/uadk_tool/include/openssl/x509v3err.h +deleted file mode 100644 +index 3b9f713..0000000 +--- a/uadk_tool/include/openssl/x509v3err.h ++++ /dev/null +@@ -1,164 +0,0 @@ +-/* +- * Generated by util/mkerr.pl DO NOT EDIT +- * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved. +- * +- * Licensed under the OpenSSL license (the "License"). You may not use +- * this file except in compliance with the License. You can obtain a copy +- * in the file LICENSE in the source distribution or at +- * https://www.openssl.org/source/license.html +- */ +- +-#ifndef HEADER_X509V3ERR_H +-# define HEADER_X509V3ERR_H +- +-# ifndef HEADER_SYMHACKS_H +-# include +-# endif +- +-# ifdef __cplusplus +-extern "C" +-# endif +-int ERR_load_X509V3_strings(void); +- +-/* +- * X509V3 function codes. +- */ +-# define X509V3_F_A2I_GENERAL_NAME 164 +-# define X509V3_F_ADDR_VALIDATE_PATH_INTERNAL 166 +-# define X509V3_F_ASIDENTIFIERCHOICE_CANONIZE 161 +-# define X509V3_F_ASIDENTIFIERCHOICE_IS_CANONICAL 162 +-# define X509V3_F_BIGNUM_TO_STRING 167 +-# define X509V3_F_COPY_EMAIL 122 +-# define X509V3_F_COPY_ISSUER 123 +-# define X509V3_F_DO_DIRNAME 144 +-# define X509V3_F_DO_EXT_I2D 135 +-# define X509V3_F_DO_EXT_NCONF 151 +-# define X509V3_F_GNAMES_FROM_SECTNAME 156 +-# define X509V3_F_I2S_ASN1_ENUMERATED 121 +-# define X509V3_F_I2S_ASN1_IA5STRING 149 +-# define X509V3_F_I2S_ASN1_INTEGER 120 +-# define X509V3_F_I2V_AUTHORITY_INFO_ACCESS 138 +-# define X509V3_F_I2V_AUTHORITY_KEYID 173 +-# define X509V3_F_LEVEL_ADD_NODE 168 +-# define X509V3_F_NOTICE_SECTION 132 +-# define X509V3_F_NREF_NOS 133 +-# define X509V3_F_POLICY_CACHE_CREATE 169 +-# define X509V3_F_POLICY_CACHE_NEW 170 +-# define X509V3_F_POLICY_DATA_NEW 171 +-# define X509V3_F_POLICY_SECTION 131 +-# define X509V3_F_PROCESS_PCI_VALUE 150 +-# define X509V3_F_R2I_CERTPOL 130 +-# define X509V3_F_R2I_PCI 155 +-# define X509V3_F_S2I_ASN1_IA5STRING 100 +-# define X509V3_F_S2I_ASN1_INTEGER 108 +-# define X509V3_F_S2I_ASN1_OCTET_STRING 112 +-# define X509V3_F_S2I_SKEY_ID 115 +-# define X509V3_F_SET_DIST_POINT_NAME 158 +-# define X509V3_F_SXNET_ADD_ID_ASC 125 +-# define X509V3_F_SXNET_ADD_ID_INTEGER 126 +-# define X509V3_F_SXNET_ADD_ID_ULONG 127 +-# define X509V3_F_SXNET_GET_ID_ASC 128 +-# define X509V3_F_SXNET_GET_ID_ULONG 129 +-# define X509V3_F_TREE_INIT 172 +-# define X509V3_F_V2I_ASIDENTIFIERS 163 +-# define X509V3_F_V2I_ASN1_BIT_STRING 101 +-# define X509V3_F_V2I_AUTHORITY_INFO_ACCESS 139 +-# define X509V3_F_V2I_AUTHORITY_KEYID 119 +-# define X509V3_F_V2I_BASIC_CONSTRAINTS 102 +-# define X509V3_F_V2I_CRLD 134 +-# define X509V3_F_V2I_EXTENDED_KEY_USAGE 103 +-# define X509V3_F_V2I_GENERAL_NAMES 118 +-# define X509V3_F_V2I_GENERAL_NAME_EX 117 +-# define X509V3_F_V2I_IDP 157 +-# define X509V3_F_V2I_IPADDRBLOCKS 159 +-# define X509V3_F_V2I_ISSUER_ALT 153 +-# define X509V3_F_V2I_NAME_CONSTRAINTS 147 +-# define X509V3_F_V2I_POLICY_CONSTRAINTS 146 +-# define X509V3_F_V2I_POLICY_MAPPINGS 145 +-# define X509V3_F_V2I_SUBJECT_ALT 154 +-# define X509V3_F_V2I_TLS_FEATURE 165 +-# define X509V3_F_V3_GENERIC_EXTENSION 116 +-# define X509V3_F_X509V3_ADD1_I2D 140 +-# define X509V3_F_X509V3_ADD_LEN_VALUE 174 +-# define X509V3_F_X509V3_ADD_VALUE 105 +-# define X509V3_F_X509V3_EXT_ADD 104 +-# define X509V3_F_X509V3_EXT_ADD_ALIAS 106 +-# define X509V3_F_X509V3_EXT_I2D 136 +-# define X509V3_F_X509V3_EXT_NCONF 152 +-# define X509V3_F_X509V3_GET_SECTION 142 +-# define X509V3_F_X509V3_GET_STRING 143 +-# define X509V3_F_X509V3_GET_VALUE_BOOL 110 +-# define X509V3_F_X509V3_PARSE_LIST 109 +-# define X509V3_F_X509_PURPOSE_ADD 137 +-# define X509V3_F_X509_PURPOSE_SET 141 +- +-/* +- * X509V3 reason codes. +- */ +-# define X509V3_R_BAD_IP_ADDRESS 118 +-# define X509V3_R_BAD_OBJECT 119 +-# define X509V3_R_BN_DEC2BN_ERROR 100 +-# define X509V3_R_BN_TO_ASN1_INTEGER_ERROR 101 +-# define X509V3_R_DIRNAME_ERROR 149 +-# define X509V3_R_DISTPOINT_ALREADY_SET 160 +-# define X509V3_R_DUPLICATE_ZONE_ID 133 +-# define X509V3_R_ERROR_CONVERTING_ZONE 131 +-# define X509V3_R_ERROR_CREATING_EXTENSION 144 +-# define X509V3_R_ERROR_IN_EXTENSION 128 +-# define X509V3_R_EXPECTED_A_SECTION_NAME 137 +-# define X509V3_R_EXTENSION_EXISTS 145 +-# define X509V3_R_EXTENSION_NAME_ERROR 115 +-# define X509V3_R_EXTENSION_NOT_FOUND 102 +-# define X509V3_R_EXTENSION_SETTING_NOT_SUPPORTED 103 +-# define X509V3_R_EXTENSION_VALUE_ERROR 116 +-# define X509V3_R_ILLEGAL_EMPTY_EXTENSION 151 +-# define X509V3_R_INCORRECT_POLICY_SYNTAX_TAG 152 +-# define X509V3_R_INVALID_ASNUMBER 162 +-# define X509V3_R_INVALID_ASRANGE 163 +-# define X509V3_R_INVALID_BOOLEAN_STRING 104 +-# define X509V3_R_INVALID_EXTENSION_STRING 105 +-# define X509V3_R_INVALID_INHERITANCE 165 +-# define X509V3_R_INVALID_IPADDRESS 166 +-# define X509V3_R_INVALID_MULTIPLE_RDNS 161 +-# define X509V3_R_INVALID_NAME 106 +-# define X509V3_R_INVALID_NULL_ARGUMENT 107 +-# define X509V3_R_INVALID_NULL_NAME 108 +-# define X509V3_R_INVALID_NULL_VALUE 109 +-# define X509V3_R_INVALID_NUMBER 140 +-# define X509V3_R_INVALID_NUMBERS 141 +-# define X509V3_R_INVALID_OBJECT_IDENTIFIER 110 +-# define X509V3_R_INVALID_OPTION 138 +-# define X509V3_R_INVALID_POLICY_IDENTIFIER 134 +-# define X509V3_R_INVALID_PROXY_POLICY_SETTING 153 +-# define X509V3_R_INVALID_PURPOSE 146 +-# define X509V3_R_INVALID_SAFI 164 +-# define X509V3_R_INVALID_SECTION 135 +-# define X509V3_R_INVALID_SYNTAX 143 +-# define X509V3_R_ISSUER_DECODE_ERROR 126 +-# define X509V3_R_MISSING_VALUE 124 +-# define X509V3_R_NEED_ORGANIZATION_AND_NUMBERS 142 +-# define X509V3_R_NO_CONFIG_DATABASE 136 +-# define X509V3_R_NO_ISSUER_CERTIFICATE 121 +-# define X509V3_R_NO_ISSUER_DETAILS 127 +-# define X509V3_R_NO_POLICY_IDENTIFIER 139 +-# define X509V3_R_NO_PROXY_CERT_POLICY_LANGUAGE_DEFINED 154 +-# define X509V3_R_NO_PUBLIC_KEY 114 +-# define X509V3_R_NO_SUBJECT_DETAILS 125 +-# define X509V3_R_OPERATION_NOT_DEFINED 148 +-# define X509V3_R_OTHERNAME_ERROR 147 +-# define X509V3_R_POLICY_LANGUAGE_ALREADY_DEFINED 155 +-# define X509V3_R_POLICY_PATH_LENGTH 156 +-# define X509V3_R_POLICY_PATH_LENGTH_ALREADY_DEFINED 157 +-# define X509V3_R_POLICY_WHEN_PROXY_LANGUAGE_REQUIRES_NO_POLICY 159 +-# define X509V3_R_SECTION_NOT_FOUND 150 +-# define X509V3_R_UNABLE_TO_GET_ISSUER_DETAILS 122 +-# define X509V3_R_UNABLE_TO_GET_ISSUER_KEYID 123 +-# define X509V3_R_UNKNOWN_BIT_STRING_ARGUMENT 111 +-# define X509V3_R_UNKNOWN_EXTENSION 129 +-# define X509V3_R_UNKNOWN_EXTENSION_NAME 130 +-# define X509V3_R_UNKNOWN_OPTION 120 +-# define X509V3_R_UNSUPPORTED_OPTION 117 +-# define X509V3_R_UNSUPPORTED_TYPE 167 +-# define X509V3_R_USER_TOO_LONG 132 +- +-#endif +diff --git a/uadk_tool/uadk_benchmark.c b/uadk_tool/uadk_benchmark.c +index 8067ed7..0d7fc71 100644 +--- a/uadk_tool/uadk_benchmark.c ++++ b/uadk_tool/uadk_benchmark.c +@@ -419,9 +419,11 @@ static int benchmark_run(struct acc_option *option) + ret = sec_wd_benchmark(option); + } + usleep(20000); ++ #ifdef WITH_OPENSSL_DIR + if (option->modetype & SOFT_MODE) { + ret = sec_soft_benchmark(option); + } ++ #endif + break; + case HPRE_TYPE: + break; +-- +2.25.1 + diff --git a/0047-uadk-fix-for-wd_env_config-numa_num.patch b/0047-uadk-fix-for-wd_env_config-numa_num.patch new file mode 100644 index 0000000..973a10b --- /dev/null +++ b/0047-uadk-fix-for-wd_env_config-numa_num.patch @@ -0,0 +1,51 @@ +From 4491fd2e4fb1c1d101e4c2d45998b484ce946443 Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Wed, 19 Jan 2022 11:25:34 +0800 +Subject: [PATCH 51/53] uadk: fix for wd_env_config numa_num + +numa number should be updated synchronously +with config_per_numa, so set it to zero when +free numa. + +Signed-off-by: Wenkai Lin +--- + include/wd_util.h | 2 +- + wd_util.c | 2 ++ + 2 files changed, 3 insertions(+), 1 deletion(-) + +diff --git a/include/wd_util.h b/include/wd_util.h +index c07ecce..2d3c1e4 100644 +--- a/include/wd_util.h ++++ b/include/wd_util.h +@@ -16,7 +16,7 @@ extern "C" { + + #define FOREACH_NUMA(i, config, config_numa) \ + for (i = 0, config_numa = config->config_per_numa; \ +- config_numa && i < config->numa_num; config_numa++, i++) ++ i < config->numa_num; config_numa++, i++) + + struct wd_async_msg_pool { + struct msg_pool *pools; +diff --git a/wd_util.c b/wd_util.c +index 7fa688d..44c8909 100644 +--- a/wd_util.c ++++ b/wd_util.c +@@ -356,6 +356,7 @@ static void wd_free_numa(struct wd_env_config *config) + + free(config->config_per_numa); + config->config_per_numa = NULL; ++ config->numa_num = 0; + } + + /** +@@ -484,6 +485,7 @@ static int wd_alloc_numa(struct wd_env_config *config, + return 0; + + free_list: ++ config->numa_num = 0; + wd_free_list_accels(head); + free_numa_dev_num: + free(numa_dev_num); +-- +2.25.1 + diff --git a/0048-hisi-sec-add-some-dfx-information-in-comments.patch b/0048-hisi-sec-add-some-dfx-information-in-comments.patch new file mode 100644 index 0000000..40c33ea --- /dev/null +++ b/0048-hisi-sec-add-some-dfx-information-in-comments.patch @@ -0,0 +1,588 @@ +From 92364a0a3a38a02d64cca10d3153e94ee01c3969 Mon Sep 17 00:00:00 2001 +From: Kai Ye +Date: Tue, 25 Jan 2022 14:33:48 +0800 +Subject: [PATCH 52/53] hisi-sec: add some dfx information in comments + +Add some dfx information in comments to improves locating +efficiency. + +Signed-off-by: Kai Ye +--- + drv/hisi_sec.c | 86 ++++++++++++++++++++++++++++++-------------------- + wd_aead.c | 39 ++++++++++++++--------- + wd_cipher.c | 21 +++++++----- + wd_digest.c | 12 ++++--- + 4 files changed, 97 insertions(+), 61 deletions(-) + +diff --git a/drv/hisi_sec.c b/drv/hisi_sec.c +index f5db7eb..14656c8 100644 +--- a/drv/hisi_sec.c ++++ b/drv/hisi_sec.c +@@ -576,7 +576,7 @@ static int get_3des_c_key_len(struct wd_cipher_msg *msg, __u8 *c_key_len) + } else if (msg->key_bytes == SEC_3DES_3KEY_SIZE) { + *c_key_len = CKEY_LEN_3DES_3KEY; + } else { +- WD_ERR("invalid 3des key size!\n"); ++ WD_ERR("invalid 3des key size, size = %u\n", msg->key_bytes); + return -WD_EINVAL; + } + +@@ -602,7 +602,7 @@ static int get_aes_c_key_len(struct wd_cipher_msg *msg, __u8 *c_key_len) + *c_key_len = CKEY_LEN_256BIT; + break; + default: +- WD_ERR("invalid AES key size!\n"); ++ WD_ERR("invalid AES key size, size = %u\n", len); + return -WD_EINVAL; + } + +@@ -634,7 +634,7 @@ static int fill_cipher_bd2_alg(struct wd_cipher_msg *msg, struct hisi_sec_sqe *s + sqe->type2.icvw_kmode = (__u16)c_key_len << SEC_CKEY_OFFSET; + break; + default: +- WD_ERR("invalid cipher type!\n"); ++ WD_ERR("invalid cipher alg type, alg = %u\n", msg->alg); + return -WD_EINVAL; + } + +@@ -660,7 +660,7 @@ static int fill_cipher_bd2_mode(struct wd_cipher_msg *msg, struct hisi_sec_sqe * + c_mode = C_MODE_XTS; + break; + default: +- WD_ERR("invalid cipher mode type!\n"); ++ WD_ERR("invalid cipher mode type, mode = %u\n", msg->mode); + return -WD_EINVAL; + } + sqe->type2.icvw_kmode |= (__u16)(c_mode) << SEC_CMODE_OFFSET; +@@ -719,7 +719,8 @@ static int cipher_len_check(struct wd_cipher_msg *msg) + { + if (msg->in_bytes > MAX_INPUT_DATA_LEN || + !msg->in_bytes) { +- WD_ERR("input cipher length is error!\n"); ++ WD_ERR("input cipher length is error, size = %u\n", ++ msg->in_bytes); + return -WD_EINVAL; + } + +@@ -730,7 +731,8 @@ static int cipher_len_check(struct wd_cipher_msg *msg) + + if (msg->mode == WD_CIPHER_XTS) { + if (msg->in_bytes < AES_BLOCK_SIZE) { +- WD_ERR("input cipher length is too small!\n"); ++ WD_ERR("input cipher length is too small, size = %u\n", ++ msg->in_bytes); + return -WD_EINVAL; + } + return 0; +@@ -738,13 +740,15 @@ static int cipher_len_check(struct wd_cipher_msg *msg) + + if (msg->alg == WD_CIPHER_3DES || msg->alg == WD_CIPHER_DES) { + if (msg->in_bytes & (DES3_BLOCK_SIZE - 1)) { +- WD_ERR("input 3DES or DES cipher parameter is error!\n"); ++ WD_ERR("input 3DES or DES cipher parameter is error, size = %u\n", ++ msg->in_bytes); + return -WD_EINVAL; + } + return 0; + } else if (msg->alg == WD_CIPHER_AES || msg->alg == WD_CIPHER_SM4) { + if (msg->in_bytes & (AES_BLOCK_SIZE - 1)) { +- WD_ERR("input AES or SM4 cipher parameter is error!\n"); ++ WD_ERR("input AES or SM4 cipher parameter is error, size = %u\n", ++ msg->in_bytes); + return -WD_EINVAL; + } + return 0; +@@ -1006,7 +1010,7 @@ static int fill_cipher_bd3_alg(struct wd_cipher_msg *msg, + sqe->c_icv_key |= (__u16)c_key_len << SEC_CKEY_OFFSET_V3; + break; + default: +- WD_ERR("invalid cipher type!\n"); ++ WD_ERR("invalid cipher alg type, alg = %u\n", msg->alg); + return -WD_EINVAL; + } + +@@ -1041,7 +1045,7 @@ static int fill_cipher_bd3_mode(struct wd_cipher_msg *msg, + c_mode = C_MODE_CFB; + break; + default: +- WD_ERR("invalid cipher mode type!\n"); ++ WD_ERR("invalid cipher mode type, mode = %u\n", msg->mode); + return -WD_EINVAL; + } + sqe->c_mode_alg |= (__u16)c_mode; +@@ -1201,7 +1205,7 @@ static int fill_digest_bd2_alg(struct wd_digest_msg *msg, + struct hisi_sec_sqe *sqe) + { + if (msg->alg >= WD_DIGEST_TYPE_MAX) { +- WD_ERR("invalid digest type!\n"); ++ WD_ERR("invalid digest alg type, alg = %u\n", msg->alg); + return -WD_EINVAL; + } + +@@ -1211,7 +1215,8 @@ static int fill_digest_bd2_alg(struct wd_digest_msg *msg, + (__u32)g_digest_a_alg[msg->alg] << AUTH_ALG_OFFSET; + else if (msg->mode == WD_DIGEST_HMAC) { + if (msg->key_bytes & WORD_ALIGNMENT_MASK) { +- WD_ERR("invalid digest key_bytes!\n"); ++ WD_ERR("invalid digest key_bytes, size = %u\n", ++ msg->key_bytes); + return -WD_EINVAL; + } + sqe->type2.mac_key_alg |= (__u32)(msg->key_bytes / +@@ -1221,7 +1226,7 @@ static int fill_digest_bd2_alg(struct wd_digest_msg *msg, + sqe->type2.mac_key_alg |= + (__u32)g_hmac_a_alg[msg->alg] << AUTH_ALG_OFFSET; + } else { +- WD_ERR("invalid digest mode!\n"); ++ WD_ERR("invalid digest mode, mode = %u\n", msg->mode); + return -WD_EINVAL; + } + +@@ -1298,19 +1303,22 @@ static int digest_len_check(struct wd_digest_msg *msg, enum sec_bd_type type) + } + + if (unlikely(msg->in_bytes > MAX_INPUT_DATA_LEN)) { +- WD_ERR("digest input length is too long, size:%u!\n", msg->in_bytes); ++ WD_ERR("digest input length is too long, size = %u\n", ++ msg->in_bytes); + return -WD_EINVAL; + } + + if (unlikely(msg->out_bytes & WORD_ALIGNMENT_MASK)) { +- WD_ERR("digest out length is error, size:%u!\n", msg->out_bytes); ++ WD_ERR("digest out length is error, size = %u\n", ++ msg->out_bytes); + return -WD_EINVAL; + } + + if (msg->has_next) { + ret = digest_long_bd_check(msg); + if (ret) { +- WD_ERR("input data isn't aligned, size:%u!\n", msg->in_bytes); ++ WD_ERR("input data isn't aligned, size = %u\n", ++ msg->in_bytes); + return -WD_EINVAL; + } + } +@@ -1421,7 +1429,7 @@ static int fill_digest_bd3_alg(struct wd_digest_msg *msg, + struct hisi_sec_sqe3 *sqe) + { + if (msg->alg >= WD_DIGEST_TYPE_MAX) { +- WD_ERR("Invalid digest type!\n"); ++ WD_ERR("invalid digest type, alg = %u\n", msg->alg); + return -WD_EINVAL; + } + +@@ -1432,7 +1440,8 @@ static int fill_digest_bd3_alg(struct wd_digest_msg *msg, + (__u32)g_digest_a_alg[msg->alg] << SEC_AUTH_ALG_OFFSET_V3; + } else if (msg->mode == WD_DIGEST_HMAC) { + if (msg->key_bytes & WORD_ALIGNMENT_MASK) { +- WD_ERR("Invalid digest key_bytes!\n"); ++ WD_ERR("invalid digest key_bytes, size = %u\n", ++ msg->key_bytes); + return -WD_EINVAL; + } + sqe->auth_mac_key |= (__u32)(msg->key_bytes / +@@ -1441,7 +1450,7 @@ static int fill_digest_bd3_alg(struct wd_digest_msg *msg, + sqe->auth_mac_key |= + (__u32)g_hmac_a_alg[msg->alg] << SEC_AUTH_ALG_OFFSET_V3; + } else { +- WD_ERR("Invalid digest mode!\n"); ++ WD_ERR("invalid digest mode, mode = %u\n", msg->mode); + return -WD_EINVAL; + } + +@@ -1601,7 +1610,8 @@ static int aead_get_aes_key_len(struct wd_aead_msg *msg, __u8 *key_len) + *key_len = CKEY_LEN_256BIT; + break; + default: +- WD_ERR("failed to check AES key size!\n"); ++ WD_ERR("failed to check AES key size, size = %u\n", ++ msg->ckey_bytes); + return -WD_EINVAL; + } + +@@ -1622,7 +1632,7 @@ static int fill_aead_bd2_alg(struct wd_aead_msg *msg, + sqe->type2.icvw_kmode = (__u16)c_key_len << SEC_CKEY_OFFSET; + break; + default: +- WD_ERR("failed to check aead calg type!\n"); ++ WD_ERR("failed to check aead calg type, calg = %u\n", msg->calg); + ret = -WD_EINVAL; + } + +@@ -1632,13 +1642,15 @@ static int fill_aead_bd2_alg(struct wd_aead_msg *msg, + return ret; + + if (unlikely(msg->auth_bytes & WORD_ALIGNMENT_MASK)) { +- WD_ERR("failed to check aead auth_bytes!\n"); ++ WD_ERR("failed to check aead auth_bytes, size = %u\n", ++ msg->auth_bytes); + return -WD_EINVAL; + } + sqe->type2.mac_key_alg = msg->auth_bytes / WORD_BYTES; + + if (unlikely(msg->akey_bytes & WORD_ALIGNMENT_MASK)) { +- WD_ERR("failed to check aead auth key bytes!\n"); ++ WD_ERR("failed to check aead auth key bytes, size = %u\n", ++ msg->akey_bytes); + return -WD_EINVAL; + } + sqe->type2.mac_key_alg |= (__u32)(msg->akey_bytes / +@@ -1655,7 +1667,7 @@ static int fill_aead_bd2_alg(struct wd_aead_msg *msg, + d_alg = A_ALG_HMAC_SHA512 << AUTH_ALG_OFFSET; + break; + default: +- WD_ERR("failed to check aead dalg type!\n"); ++ WD_ERR("failed to check aead dalg type, dalg = %u\n", msg->dalg); + ret = -WD_EINVAL; + } + sqe->type2.mac_key_alg |= d_alg; +@@ -1685,7 +1697,8 @@ static int fill_aead_bd2_mode(struct wd_aead_msg *msg, + sqe->type2.icvw_kmode |= msg->auth_bytes; + break; + default: +- WD_ERR("failed to check aead cmode type!\n"); ++ WD_ERR("failed to check aead cmode type, cmode = %u\n", ++ msg->cmode); + return -WD_EINVAL; + } + sqe->type2.icvw_kmode |= (__u16)(c_mode) << SEC_CMODE_OFFSET; +@@ -1758,13 +1771,15 @@ static void fill_aead_bd2_addr(struct wd_aead_msg *msg, + static int aead_len_check(struct wd_aead_msg *msg) + { + if (unlikely(msg->in_bytes + msg->assoc_bytes > MAX_INPUT_DATA_LEN)) { +- WD_ERR("aead input data length is too long!\n"); ++ WD_ERR("aead input data length is too long, size = %u\n", ++ msg->in_bytes + msg->assoc_bytes); + return -WD_EINVAL; + } + + if (unlikely(msg->cmode == WD_CIPHER_CCM && + msg->assoc_bytes > MAX_CCM_AAD_LEN)) { +- WD_ERR("failed to check ccm aad len, input is too long!\n"); ++ WD_ERR("failed to check ccm aad len, input is too long, size = %u\n", ++ msg->assoc_bytes); + return -WD_EINVAL; + } + +@@ -1793,7 +1808,7 @@ static int fill_aead_bd2(struct wd_aead_msg *msg, struct hisi_sec_sqe *sqe) + sqe->type_auth_cipher |= AUTH_MAC_VERIFY << + SEC_AUTH_OFFSET; + } else { +- WD_ERR("failed to check aead op type!\n"); ++ WD_ERR("failed to check aead op type, op = %u\n", msg->op_type); + return -WD_EINVAL; + } + sqe->sds_sa_type |= (__u8)(de | scene); +@@ -1950,12 +1965,14 @@ static int aead_bd3_msg_check(struct wd_aead_msg *msg) + } + + if (unlikely(msg->auth_bytes & WORD_ALIGNMENT_MASK)) { +- WD_ERR("failed to check aead auth_bytes!\n"); ++ WD_ERR("failed to check aead auth_bytes, size = %u\n", ++ msg->auth_bytes); + return -WD_EINVAL; + } + + if (unlikely(msg->akey_bytes & WORD_ALIGNMENT_MASK)) { +- WD_ERR("failed to check aead auth key bytes!\n"); ++ WD_ERR("failed to check aead auth key bytes, size = %u\n", ++ msg->akey_bytes); + return -WD_EINVAL; + } + +@@ -1980,7 +1997,7 @@ static int fill_aead_bd3_alg(struct wd_aead_msg *msg, + sqe->c_icv_key |= (__u16)c_key_len << SEC_CKEY_OFFSET_V3; + break; + default: +- WD_ERR("failed to check aead calg type!\n"); ++ WD_ERR("failed to check aead calg type, calg = %u\n", msg->calg); + ret = -WD_EINVAL; + } + +@@ -2009,7 +2026,7 @@ static int fill_aead_bd3_alg(struct wd_aead_msg *msg, + d_alg = A_ALG_HMAC_SHA512 << SEC_AUTH_ALG_OFFSET_V3; + break; + default: +- WD_ERR("failed to check aead dalg type!\n"); ++ WD_ERR("failed to check aead dalg type, dalg = %u\n", msg->dalg); + ret = -WD_EINVAL; + } + sqe->auth_mac_key |= d_alg; +@@ -2037,7 +2054,8 @@ static int fill_aead_bd3_mode(struct wd_aead_msg *msg, + sqe->c_icv_key |= msg->auth_bytes << SEC_MAC_OFFSET_V3; + break; + default: +- WD_ERR("failed to check aead cmode type!\n"); ++ WD_ERR("failed to check aead cmode type, cmode = %u\n", ++ msg->cmode); + return -WD_EINVAL; + } + +@@ -2082,7 +2100,7 @@ static int fill_aead_bd3(struct wd_aead_msg *msg, struct hisi_sec_sqe3 *sqe) + sqe->auth_mac_key = AUTH_MAC_VERIFY; + sqe->huk_iv_seq = WD_DIGEST_THEN_CIPHER << SEC_SEQ_OFFSET_V3; + } else { +- WD_ERR("failed to check aead op type!\n"); ++ WD_ERR("failed to check aead op type, op = %u\n", msg->op_type); + return -WD_EINVAL; + } + sqe->bd_param |= (__u16)(de | scene); +diff --git a/wd_aead.c b/wd_aead.c +index 32d06ec..82a1f97 100644 +--- a/wd_aead.c ++++ b/wd_aead.c +@@ -110,7 +110,7 @@ static int cipher_key_len_check(enum wd_cipher_alg alg, __u16 length) + ret = aes_key_len_check(length); + break; + default: +- WD_ERR("failed to check cipher key!\n"); ++ WD_ERR("failed to set the cipher alg, alg = %d\n", alg); + return -WD_EINVAL; + } + +@@ -143,7 +143,7 @@ int wd_aead_set_ckey(handle_t h_sess, const __u8 *key, __u16 key_len) + int ret; + + if (unlikely(!key || !sess)) { +- WD_ERR("failed to check cipher key inpupt param!\n"); ++ WD_ERR("failed to check cipher key input param!\n"); + return -WD_EINVAL; + } + +@@ -189,7 +189,7 @@ int wd_aead_set_akey(handle_t h_sess, const __u8 *key, __u16 key_len) + return 0; + + err_key_len: +- WD_ERR("failed to check authenticate key length!\n"); ++ WD_ERR("failed to check authenticate key length, size = %u\n", key_len); + return -WD_EINVAL; + } + +@@ -206,20 +206,23 @@ int wd_aead_set_authsize(handle_t h_sess, __u16 authsize) + if (authsize < WD_AEAD_CCM_GCM_MIN || + authsize > WD_AEAD_CCM_GCM_MAX || + authsize % (WD_AEAD_CCM_GCM_MIN >> 1)) { +- WD_ERR("failed to check aead CCM authsize!\n"); ++ WD_ERR("failed to check aead CCM authsize, size = %u\n", ++ authsize); + return -WD_EINVAL; + } + } else if (sess->cmode == WD_CIPHER_GCM) { + if (authsize < WD_AEAD_CCM_GCM_MIN << 1 || + authsize > WD_AEAD_CCM_GCM_MAX) { +- WD_ERR("failed to check aead GCM authsize!\n"); ++ WD_ERR("failed to check aead GCM authsize, size = %u\n", ++ authsize); + return -WD_EINVAL; + } + } else { + if (sess->dalg >= WD_DIGEST_TYPE_MAX || + authsize & (WD_AEAD_CCM_GCM_MAX - 1) || + authsize > g_aead_mac_len[sess->dalg]) { +- WD_ERR("failed to check aead mac authsize!\n"); ++ WD_ERR("failed to check aead mac authsize, size = %u\n", ++ authsize); + return -WD_EINVAL; + } + } +@@ -313,20 +316,22 @@ static int aead_mac_param_check(struct wd_aead_sess *sess, + switch (sess->cmode) { + case WD_CIPHER_CBC: + if (req->mac_bytes < g_aead_mac_len[sess->dalg]) { +- WD_ERR("failed to check cbc-hmac mac buffer length!\n"); ++ WD_ERR("failed to check cbc-hmac mac buffer length, size = %u\n", ++ req->mac_bytes); + ret = -WD_EINVAL; + } + break; + case WD_CIPHER_CCM: + case WD_CIPHER_GCM: + if (req->mac_bytes < WD_AEAD_CCM_GCM_MAX) { +- WD_ERR("failed to check CCM or GCM mac buffer length!\n"); ++ WD_ERR("failed to check CCM or GCM mac buffer length, size = %u\n", ++ req->mac_bytes); + ret = -WD_EINVAL; + } + break; + default: + ret = -WD_EINVAL; +- WD_ERR("set the aead cmode is error!\n"); ++ WD_ERR("set the aead cmode is error, cmode = %d\n", sess->cmode); + } + + return ret; +@@ -350,12 +355,14 @@ static int aead_param_check(struct wd_aead_sess *sess, + + if (unlikely(sess->cmode == WD_CIPHER_CBC && + (req->in_bytes & (AES_BLOCK_SIZE - 1)))) { +- WD_ERR("failed to check aead input data length!\n"); ++ WD_ERR("failed to check aead input data length, size = %u\n", ++ req->in_bytes); + return -WD_EINVAL; + } + + if (unlikely(req->iv_bytes != get_iv_block_size(sess->cmode))) { +- WD_ERR("failed to check aead IV length, size:%u\n", req->iv_bytes); ++ WD_ERR("failed to check aead IV length, size = %u\n", ++ req->iv_bytes); + return -WD_EINVAL; + } + +@@ -367,13 +374,15 @@ static int aead_param_check(struct wd_aead_sess *sess, + len = req->in_bytes + req->assoc_bytes; + ret = wd_check_datalist(req->list_src, len); + if (unlikely(ret)) { +- WD_ERR("failed to check the src datalist!\n"); ++ WD_ERR("failed to check the src datalist, size = %u\n", ++ len); + return -WD_EINVAL; + } + + ret = wd_check_datalist(req->list_dst, req->out_bytes); + if (unlikely(ret)) { +- WD_ERR("failed to check the dst datalist!\n"); ++ WD_ERR("failed to check the dst datalist, size = %u\n", ++ req->out_bytes); + return -WD_EINVAL; + } + } +@@ -407,13 +416,13 @@ int wd_aead_init(struct wd_ctx_config *config, struct wd_sched *sched) + + ret = wd_init_ctx_config(&wd_aead_setting.config, config); + if (ret) { +- WD_ERR("failed to set config, ret = %d!\n", ret); ++ WD_ERR("failed to set config, ret = %d\n", ret); + return ret; + } + + ret = wd_init_sched(&wd_aead_setting.sched, sched); + if (ret < 0) { +- WD_ERR("failed to set sched, ret = %d!\n", ret); ++ WD_ERR("failed to set sched, ret = %d\n", ret); + goto out; + } + +diff --git a/wd_cipher.c b/wd_cipher.c +index 5be3123..0b29fb5 100644 +--- a/wd_cipher.c ++++ b/wd_cipher.c +@@ -126,7 +126,7 @@ static int cipher_key_len_check(struct wd_cipher_sess *sess, __u32 length) + int ret = 0; + + if (sess->mode == WD_CIPHER_XTS && length == AES_KEYSIZE_192) { +- WD_ERR("unsupported XTS key length, length = %u.\n", length); ++ WD_ERR("unsupported XTS key length, length = %u\n", length); + return -WD_EINVAL; + } + +@@ -147,7 +147,7 @@ static int cipher_key_len_check(struct wd_cipher_sess *sess, __u32 length) + ret = -WD_EINVAL; + break; + default: +- WD_ERR("cipher input alg err, alg is %d.\n", sess->alg); ++ WD_ERR("cipher input alg err, alg = %d\n", sess->alg); + return -WD_EINVAL; + } + +@@ -358,14 +358,16 @@ static int cipher_iv_len_check(struct wd_cipher_req *req, + case WD_CIPHER_AES: + case WD_CIPHER_SM4: + if (req->iv_bytes != AES_BLOCK_SIZE) { +- WD_ERR("AES or SM4 input iv bytes is err!\n"); ++ WD_ERR("AES or SM4 input iv bytes is err, size = %u\n", ++ req->iv_bytes); + ret = -WD_EINVAL; + } + break; + case WD_CIPHER_3DES: + case WD_CIPHER_DES: + if (req->iv_bytes != DES3_BLOCK_SIZE) { +- WD_ERR("3DES or DES input iv bytes is err!\n"); ++ WD_ERR("3DES or DES input iv bytes is err, size = %u\n", ++ req->iv_bytes); + ret = -WD_EINVAL; + } + break; +@@ -384,7 +386,7 @@ static int wd_cipher_check_params(handle_t h_sess, + int ret = 0; + + if (unlikely(!h_sess || !req)) { +- WD_ERR("cipher input sess or req is NULL.\n"); ++ WD_ERR("cipher input sess or req is NULL!\n"); + return -WD_EINVAL; + } + +@@ -394,21 +396,24 @@ static int wd_cipher_check_params(handle_t h_sess, + } + + if (unlikely(req->out_buf_bytes < req->in_bytes)) { +- WD_ERR("cipher set out_buf_bytes is error!\n"); ++ WD_ERR("cipher set out_buf_bytes is error, size = %u\n", ++ req->out_buf_bytes); + return -WD_EINVAL; + } + + if (req->data_fmt == WD_SGL_BUF) { + ret = wd_check_datalist(req->list_src, req->in_bytes); + if (unlikely(ret)) { +- WD_ERR("failed to check the src datalist!\n"); ++ WD_ERR("failed to check the src datalist, len = %u\n", ++ req->in_bytes); + return -WD_EINVAL; + } + + /* cipher dst len is equal to src len */ + ret = wd_check_datalist(req->list_dst, req->in_bytes); + if (unlikely(ret)) { +- WD_ERR("failed to check the dst datalist!\n"); ++ WD_ERR("failed to check the dst datalist, len = %u\n", ++ req->in_bytes); + return -WD_EINVAL; + } + } +diff --git a/wd_digest.c b/wd_digest.c +index 525d6a9..d4e710d 100644 +--- a/wd_digest.c ++++ b/wd_digest.c +@@ -98,7 +98,8 @@ int wd_digest_set_key(handle_t h_sess, const __u8 *key, __u32 key_len) + if ((sess->alg <= WD_DIGEST_SHA224 && key_len > + MAX_HMAC_KEY_SIZE >> 1) || key_len == 0 || + key_len > MAX_HMAC_KEY_SIZE) { +- WD_ERR("failed to check digest key length!\n"); ++ WD_ERR("failed to check digest key length, size = %u\n", ++ key_len); + return -WD_EINVAL; + } + +@@ -258,20 +259,23 @@ static int digest_param_check(struct wd_digest_sess *sess, + } + + if (unlikely(req->out_buf_bytes < req->out_bytes)) { +- WD_ERR("failed to check digest out buffer length!\n"); ++ WD_ERR("failed to check digest out buffer length, size = %u\n", ++ req->out_buf_bytes); + return -WD_EINVAL; + } + + if (unlikely(sess->alg >= WD_DIGEST_TYPE_MAX || req->out_bytes == 0 || + req->out_bytes > g_digest_mac_len[sess->alg])) { +- WD_ERR("failed to check digest type or mac length!\n"); ++ WD_ERR("failed to check digest type or mac length, alg = %d, out_bytes = %u\n", ++ sess->alg, req->out_bytes); + return -WD_EINVAL; + } + + if (req->data_fmt == WD_SGL_BUF) { + ret = wd_check_datalist(req->list_in, req->in_bytes); + if (unlikely(ret)) { +- WD_ERR("failed to check the src datalist!\n"); ++ WD_ERR("failed to check the src datalist, size = %u\n", ++ req->in_bytes); + return -WD_EINVAL; + } + } +-- +2.25.1 + diff --git a/0049-hisi-sec-delete-some-dummy-parameter-checking.patch b/0049-hisi-sec-delete-some-dummy-parameter-checking.patch new file mode 100644 index 0000000..f935289 --- /dev/null +++ b/0049-hisi-sec-delete-some-dummy-parameter-checking.patch @@ -0,0 +1,119 @@ +From 7d208baa2ea3b3adb161683e9e2446dd01ae14a0 Mon Sep 17 00:00:00 2001 +From: Kai Ye +Date: Thu, 27 Jan 2022 10:16:59 +0800 +Subject: [PATCH 53/53] hisi-sec: delete some dummy parameter checking + +1. If an error is detected, the system exits rather than + continues. here is fix it. +2. Due to the auth length checking logic same as the api +layer. So this code is reduntant and needs to be deleted. + +Signed-off-by: Kai Ye +--- + drv/hisi_sec.c | 56 +++++++++++++++++--------------------------------- + 1 file changed, 19 insertions(+), 37 deletions(-) + +diff --git a/drv/hisi_sec.c b/drv/hisi_sec.c +index 14656c8..61e0698 100644 +--- a/drv/hisi_sec.c ++++ b/drv/hisi_sec.c +@@ -1618,6 +1618,17 @@ static int aead_get_aes_key_len(struct wd_aead_msg *msg, __u8 *key_len) + return 0; + } + ++static int aead_bd_msg_check(struct wd_aead_msg *msg) ++{ ++ if (unlikely(msg->akey_bytes & WORD_ALIGNMENT_MASK)) { ++ WD_ERR("failed to check aead auth key bytes, size = %u\n", ++ msg->akey_bytes); ++ return -WD_EINVAL; ++ } ++ ++ return 0; ++} ++ + static int fill_aead_bd2_alg(struct wd_aead_msg *msg, + struct hisi_sec_sqe *sqe) + { +@@ -1633,26 +1644,19 @@ static int fill_aead_bd2_alg(struct wd_aead_msg *msg, + break; + default: + WD_ERR("failed to check aead calg type, calg = %u\n", msg->calg); +- ret = -WD_EINVAL; ++ return -WD_EINVAL; + } + + /* CCM/GCM this region is set to 0 */ +- if (msg->cmode == WD_CIPHER_CCM || +- msg->cmode == WD_CIPHER_GCM) ++ if (msg->cmode == WD_CIPHER_CCM || msg->cmode == WD_CIPHER_GCM) + return ret; + +- if (unlikely(msg->auth_bytes & WORD_ALIGNMENT_MASK)) { +- WD_ERR("failed to check aead auth_bytes, size = %u\n", +- msg->auth_bytes); +- return -WD_EINVAL; +- } + sqe->type2.mac_key_alg = msg->auth_bytes / WORD_BYTES; + +- if (unlikely(msg->akey_bytes & WORD_ALIGNMENT_MASK)) { +- WD_ERR("failed to check aead auth key bytes, size = %u\n", +- msg->akey_bytes); +- return -WD_EINVAL; +- } ++ ret = aead_bd_msg_check(msg); ++ if (ret) ++ return ret; ++ + sqe->type2.mac_key_alg |= (__u32)(msg->akey_bytes / + WORD_BYTES) << MAC_LEN_OFFSET; + +@@ -1957,28 +1961,6 @@ static struct wd_aead_driver hisi_aead_driver = { + + WD_AEAD_SET_DRIVER(hisi_aead_driver); + +-static int aead_bd3_msg_check(struct wd_aead_msg *msg) +-{ +- if (unlikely(!msg->in_bytes)) { +- WD_ERR("failed to check aead in_bytes 0 length!\n"); +- return -WD_EINVAL; +- } +- +- if (unlikely(msg->auth_bytes & WORD_ALIGNMENT_MASK)) { +- WD_ERR("failed to check aead auth_bytes, size = %u\n", +- msg->auth_bytes); +- return -WD_EINVAL; +- } +- +- if (unlikely(msg->akey_bytes & WORD_ALIGNMENT_MASK)) { +- WD_ERR("failed to check aead auth key bytes, size = %u\n", +- msg->akey_bytes); +- return -WD_EINVAL; +- } +- +- return 0; +-} +- + static int fill_aead_bd3_alg(struct wd_aead_msg *msg, + struct hisi_sec_sqe3 *sqe) + { +@@ -1998,14 +1980,14 @@ static int fill_aead_bd3_alg(struct wd_aead_msg *msg, + break; + default: + WD_ERR("failed to check aead calg type, calg = %u\n", msg->calg); +- ret = -WD_EINVAL; ++ return -WD_EINVAL; + } + + /* CCM/GCM this region is set to 0 */ + if (msg->cmode == WD_CIPHER_CCM || msg->cmode == WD_CIPHER_GCM) + return ret; + +- ret = aead_bd3_msg_check(msg); ++ ret = aead_bd_msg_check(msg); + if (ret) + return ret; + +-- +2.25.1 + diff --git a/0050-hisi-qm-udrv-v1-deleted-a-dummy-branch.patch b/0050-hisi-qm-udrv-v1-deleted-a-dummy-branch.patch new file mode 100644 index 0000000..6d9fdaf --- /dev/null +++ b/0050-hisi-qm-udrv-v1-deleted-a-dummy-branch.patch @@ -0,0 +1,45 @@ +From bbdb8e4337270cbc1125f9e5fa3b004e98a543d1 Mon Sep 17 00:00:00 2001 +From: Kai Ye +Date: Thu, 10 Feb 2022 14:55:43 +0800 +Subject: [PATCH 54/64] hisi-qm-udrv/v1: deleted a dummy branch + +Deleted an invalid branch in qm_set_queue_alg_info. the software +won't go to that line of code. + +Signed-off-by: Kai Ye +--- + v1/drv/hisi_qm_udrv.c | 18 ++++-------------- + 1 file changed, 4 insertions(+), 14 deletions(-) + +diff --git a/v1/drv/hisi_qm_udrv.c b/v1/drv/hisi_qm_udrv.c +index 63f346b..b457efd 100644 +--- a/v1/drv/hisi_qm_udrv.c ++++ b/v1/drv/hisi_qm_udrv.c +@@ -423,20 +423,10 @@ static int qm_set_queue_alg_info(struct wd_queue *q) + } else if (!strcmp(alg, "xts(aes)") || + !strcmp(alg, "xts(sm4)")) { + qinfo->atype = WCRYPTO_CIPHER; +- if (strstr(q->dev_path, "zip")) { +- info->sqe_size = QM_ZIP_BD_SIZE; +- info->sqe_fill[WCRYPTO_CIPHER] = qm_fill_zip_cipher_sqe; +- info->sqe_parse[WCRYPTO_CIPHER] = qm_parse_zip_cipher_sqe; +- ret = WD_SUCCESS; +- } else if (strstr(q->dev_path, "sec")) { +- priv->direction = 0; +- info->sqe_size = QM_SEC_BD_SIZE; +- info->sqe_fill[WCRYPTO_CIPHER] = qm_fill_cipher_sqe; +- info->sqe_parse[WCRYPTO_CIPHER] = qm_parse_cipher_sqe; +- ret = WD_SUCCESS; +- } else { /* To be extended */ +- WD_ERR("queue xts alg engine err!\n"); +- } ++ info->sqe_size = QM_ZIP_BD_SIZE; ++ info->sqe_fill[WCRYPTO_CIPHER] = qm_fill_zip_cipher_sqe; ++ info->sqe_parse[WCRYPTO_CIPHER] = qm_parse_zip_cipher_sqe; ++ ret = WD_SUCCESS; + } else { /* To be extended */ + WD_ERR("queue alg err!\n"); + } +-- +2.25.1 + diff --git a/0051-hisi-sec-v1-update-the-SEC-BD1-mode-configuration.patch b/0051-hisi-sec-v1-update-the-SEC-BD1-mode-configuration.patch new file mode 100644 index 0000000..df58841 --- /dev/null +++ b/0051-hisi-sec-v1-update-the-SEC-BD1-mode-configuration.patch @@ -0,0 +1,51 @@ +From 124472212b51781c8ab8ad26131d8442cd049380 Mon Sep 17 00:00:00 2001 +From: Kai Ye +Date: Thu, 10 Feb 2022 14:55:44 +0800 +Subject: [PATCH 55/64] hisi-sec/v1: update the SEC BD1 mode configuration + +Update SEC BD1 XTS mode CI_GEN config from 3 to 0, because +ZIP XTS LBA hardware accomplish is different from SEC XTS LBA. +So we config SEC BD1 XTS ci_gen=0, which means cipher_ivin_addr +mode. + +Signed-off-by: Kai Ye +--- + v1/drv/hisi_sec_udrv.c | 15 +++++++++++---- + 1 file changed, 11 insertions(+), 4 deletions(-) + +diff --git a/v1/drv/hisi_sec_udrv.c b/v1/drv/hisi_sec_udrv.c +index 2d06bd7..7345baf 100644 +--- a/v1/drv/hisi_sec_udrv.c ++++ b/v1/drv/hisi_sec_udrv.c +@@ -298,10 +298,11 @@ static int fill_cipher_bd1_type(struct wcrypto_cipher_msg *msg, + + fill_bd_addr_type(msg->data_fmt, sqe); + +- if (msg->mode == WCRYPTO_CIPHER_XTS) +- sqe->type1.ci_gen = CI_GEN_BY_LBA; +- else +- sqe->type1.ci_gen = CI_GEN_BY_ADDR; ++ /* ++ * BD1 cipher only provides ci_gen=0 for compatibility, so user ++ * should prepare iv[gran_num] and iv_bytes is sum of all grans ++ */ ++ sqe->type1.ci_gen = CI_GEN_BY_ADDR; + + return WD_SUCCESS; + } +@@ -1453,6 +1454,12 @@ static void parse_cipher_bd1(struct wd_queue *q, struct hisi_sec_sqe *sqe, + sqe->type1.c_key_addr_l); + drv_iova_unmap(q, cipher_msg->key, (void *)(uintptr_t)dma_addr, + cipher_msg->key_bytes); ++ if (cipher_msg->iv) { ++ dma_addr = DMA_ADDR(sqe->type1.c_ivin_addr_h, ++ sqe->type1.c_ivin_addr_l); ++ drv_iova_unmap(q, cipher_msg->iv, (void *)(uintptr_t)dma_addr, ++ cipher_msg->iv_bytes); ++ } + } + + static void cipher_ofb_data_handle(struct wcrypto_cipher_msg *msg) +-- +2.25.1 + diff --git a/0052-uadk-optimize-algorithm-initialization.patch b/0052-uadk-optimize-algorithm-initialization.patch new file mode 100644 index 0000000..0d9ec37 --- /dev/null +++ b/0052-uadk-optimize-algorithm-initialization.patch @@ -0,0 +1,116 @@ +From a1d263fc8bc5aa87a9287b7d5a5fb717a1556bc5 Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Tue, 15 Feb 2022 11:49:49 +0800 +Subject: [PATCH 56/64] uadk: optimize algorithm initialization + +malloc and memset can be replaced by calloc. + +Signed-off-by: Wenkai Lin +--- + wd_aead.c | 3 +-- + wd_dh.c | 4 +--- + wd_digest.c | 4 +--- + wd_ecc.c | 4 +--- + wd_rsa.c | 4 +--- + 5 files changed, 5 insertions(+), 14 deletions(-) + +diff --git a/wd_aead.c b/wd_aead.c +index 82a1f97..d8581db 100644 +--- a/wd_aead.c ++++ b/wd_aead.c +@@ -441,12 +441,11 @@ int wd_aead_init(struct wd_ctx_config *config, struct wd_sched *sched) + } + + /* init ctx related resources in specific driver */ +- priv = malloc(wd_aead_setting.driver->drv_ctx_size); ++ priv = calloc(1, wd_aead_setting.driver->drv_ctx_size); + if (!priv) { + ret = -WD_ENOMEM; + goto out_priv; + } +- memset(priv, 0, wd_aead_setting.driver->drv_ctx_size); + wd_aead_setting.priv = priv; + + ret = wd_aead_setting.driver->init(&wd_aead_setting.config, priv); +diff --git a/wd_dh.c b/wd_dh.c +index 1784099..b361d5d 100644 +--- a/wd_dh.c ++++ b/wd_dh.c +@@ -127,14 +127,12 @@ int wd_dh_init(struct wd_ctx_config *config, struct wd_sched *sched) + } + + /* initialize ctx related resources in specific driver */ +- priv = malloc(wd_dh_setting.driver->drv_ctx_size); ++ priv = calloc(1, wd_dh_setting.driver->drv_ctx_size); + if (!priv) { +- WD_ERR("failed to calloc drv ctx\n"); + ret = -WD_ENOMEM; + goto out_priv; + } + +- memset(priv, 0, wd_dh_setting.driver->drv_ctx_size); + wd_dh_setting.priv = priv; + ret = wd_dh_setting.driver->init(&wd_dh_setting.config, priv, + wd_dh_setting.driver->alg_name); +diff --git a/wd_digest.c b/wd_digest.c +index d4e710d..1c05851 100644 +--- a/wd_digest.c ++++ b/wd_digest.c +@@ -203,13 +203,11 @@ int wd_digest_init(struct wd_ctx_config *config, struct wd_sched *sched) + } + + /* init ctx related resources in specific driver */ +- priv = malloc(wd_digest_setting.driver->drv_ctx_size); ++ priv = calloc(1, wd_digest_setting.driver->drv_ctx_size); + if (!priv) { +- WD_ERR("failed to alloc digest driver ctx!\n"); + ret = -WD_ENOMEM; + goto out_priv; + } +- memset(priv, 0, wd_digest_setting.driver->drv_ctx_size); + wd_digest_setting.priv = priv; + + ret = wd_digest_setting.driver->init(&wd_digest_setting.config, priv); +diff --git a/wd_ecc.c b/wd_ecc.c +index e324473..89566ea 100644 +--- a/wd_ecc.c ++++ b/wd_ecc.c +@@ -181,14 +181,12 @@ int wd_ecc_init(struct wd_ctx_config *config, struct wd_sched *sched) + } + + /* initialize ctx related resources in specific driver */ +- priv = malloc(wd_ecc_setting.driver->drv_ctx_size); ++ priv = calloc(1, wd_ecc_setting.driver->drv_ctx_size); + if (!priv) { +- WD_ERR("failed to calloc drv ctx\n"); + ret = -WD_ENOMEM; + goto out_priv; + } + +- memset(priv, 0, wd_ecc_setting.driver->drv_ctx_size); + wd_ecc_setting.priv = priv; + ret = wd_ecc_setting.driver->init(&wd_ecc_setting.config, priv, + wd_ecc_setting.driver->alg_name); +diff --git a/wd_rsa.c b/wd_rsa.c +index 1f911b4..2e61927 100644 +--- a/wd_rsa.c ++++ b/wd_rsa.c +@@ -167,14 +167,12 @@ int wd_rsa_init(struct wd_ctx_config *config, struct wd_sched *sched) + } + + /* initialize ctx related resources in specific driver */ +- priv = malloc(wd_rsa_setting.driver->drv_ctx_size); ++ priv = calloc(1, wd_rsa_setting.driver->drv_ctx_size); + if (!priv) { +- WD_ERR("failed to calloc drv ctx\n"); + ret = -WD_ENOMEM; + goto out_priv; + } + +- memset(priv, 0, wd_rsa_setting.driver->drv_ctx_size); + wd_rsa_setting.priv = priv; + ret = wd_rsa_setting.driver->init(&wd_rsa_setting.config, priv, + wd_rsa_setting.driver->alg_name); +-- +2.25.1 + diff --git a/0053-uadk-fix-send-exception-handling.patch b/0053-uadk-fix-send-exception-handling.patch new file mode 100644 index 0000000..89a1106 --- /dev/null +++ b/0053-uadk-fix-send-exception-handling.patch @@ -0,0 +1,135 @@ +From b2bcc88b513328491a0f02700b926678e63c944b Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Tue, 15 Feb 2022 11:49:50 +0800 +Subject: [PATCH 57/64] uadk: fix send exception handling + +when qm send message failed, uadk should return immediately +instead of enable interrupt. + +Signed-off-by: Wenkai Lin +--- + drv/hisi_comp.c | 10 +++++++--- + drv/hisi_sec.c | 24 ++++++++++++++++++------ + 2 files changed, 25 insertions(+), 9 deletions(-) + +diff --git a/drv/hisi_comp.c b/drv/hisi_comp.c +index e0e913d..5ea5dc3 100644 +--- a/drv/hisi_comp.c ++++ b/drv/hisi_comp.c +@@ -945,12 +945,16 @@ static int hisi_zip_comp_send(handle_t ctx, struct wd_comp_msg *msg, void *priv) + return ret; + } + ret = hisi_qm_send(h_qp, &sqe, 1, &count); +- if (ret < 0 && ret != -WD_EBUSY) +- WD_ERR("qm send is err(%d)!\n", ret); ++ if (ret < 0) { ++ if (ret != -WD_EBUSY) ++ WD_ERR("qm send is err(%d)!\n", ret); ++ ++ return ret; ++ } + + hisi_qm_enable_interrupt(ctx, msg->is_polled); + +- return ret; ++ return 0; + } + + static int get_alg_type(__u32 type) +diff --git a/drv/hisi_sec.c b/drv/hisi_sec.c +index 61e0698..338823b 100644 +--- a/drv/hisi_sec.c ++++ b/drv/hisi_sec.c +@@ -946,11 +946,13 @@ int hisi_sec_cipher_send(handle_t ctx, struct wd_cipher_msg *msg) + + if (msg->data_fmt == WD_SGL_BUF) + hisi_sec_put_sgl(h_qp, msg->alg_type, msg->in, msg->out); ++ ++ return ret; + } + + hisi_qm_enable_interrupt(ctx, msg->is_polled); + +- return ret; ++ return 0; + } + + int hisi_sec_cipher_recv(handle_t ctx, struct wd_cipher_msg *recv_msg) +@@ -1147,11 +1149,13 @@ int hisi_sec_cipher_send_v3(handle_t ctx, struct wd_cipher_msg *msg) + + if (msg->data_fmt == WD_SGL_BUF) + hisi_sec_put_sgl(h_qp, msg->alg_type, msg->in, msg->out); ++ ++ return ret; + } + + hisi_qm_enable_interrupt(ctx, msg->is_polled); + +- return ret; ++ return 0; + } + + static void parse_cipher_bd3(struct hisi_sec_sqe3 *sqe, struct wd_cipher_msg *recv_msg) +@@ -1388,11 +1392,13 @@ int hisi_sec_digest_send(handle_t ctx, struct wd_digest_msg *msg) + + if (msg->data_fmt == WD_SGL_BUF) + hisi_sec_put_sgl(h_qp, msg->alg_type, msg->in, msg->out); ++ ++ return ret; + } + + hisi_qm_enable_interrupt(ctx, msg->is_polled); + +- return ret; ++ return 0; + } + + int hisi_sec_digest_recv(handle_t ctx, struct wd_digest_msg *recv_msg) +@@ -1544,11 +1550,13 @@ int hisi_sec_digest_send_v3(handle_t ctx, struct wd_digest_msg *msg) + + if (msg->data_fmt == WD_SGL_BUF) + hisi_sec_put_sgl(h_qp, msg->alg_type, msg->in, msg->out); ++ ++ return ret; + } + + hisi_qm_enable_interrupt(ctx, msg->is_polled); + +- return ret; ++ return 0; + } + + static void parse_digest_bd3(struct hisi_sec_sqe3 *sqe, +@@ -1887,11 +1895,13 @@ int hisi_sec_aead_send(handle_t ctx, struct wd_aead_msg *msg) + + if (msg->data_fmt == WD_SGL_BUF) + hisi_sec_put_sgl(h_qp, msg->alg_type, msg->in, msg->out); ++ ++ return ret; + } + + hisi_qm_enable_interrupt(ctx, msg->is_polled); + +- return ret; ++ return 0; + } + + static void parse_aead_bd2(struct hisi_sec_sqe *sqe, +@@ -2152,11 +2162,13 @@ int hisi_sec_aead_send_v3(handle_t ctx, struct wd_aead_msg *msg) + + if (msg->data_fmt == WD_SGL_BUF) + hisi_sec_put_sgl(h_qp, msg->alg_type, msg->in, msg->out); ++ ++ return ret; + } + + hisi_qm_enable_interrupt(ctx, msg->is_polled); + +- return ret; ++ return 0; + } + + static void parse_aead_bd3(struct hisi_sec_sqe3 *sqe, +-- +2.25.1 + diff --git a/0054-uadk-sec-fix-hisi_sec_digest_send.patch b/0054-uadk-sec-fix-hisi_sec_digest_send.patch new file mode 100644 index 0000000..d73fd6f --- /dev/null +++ b/0054-uadk-sec-fix-hisi_sec_digest_send.patch @@ -0,0 +1,165 @@ +From c7d657b037cb9a37daaa3df79ac806e6ac1d4fa2 Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Tue, 15 Feb 2022 11:49:51 +0800 +Subject: [PATCH 58/64] uadk: sec: fix hisi_sec_digest_send + +When digest send a sgl format message, it will use +hisi_sec_fill_sgl to get sgl memory from sgl memory pool, +when send message exit abnormally, sgl should be put back. + +Signed-off-by: Wenkai Lin +--- + drv/hisi_sec.c | 58 +++++++++++++++++++++----------------------------- + 1 file changed, 24 insertions(+), 34 deletions(-) + +diff --git a/drv/hisi_sec.c b/drv/hisi_sec.c +index 338823b..7f5aae2 100644 +--- a/drv/hisi_sec.c ++++ b/drv/hisi_sec.c +@@ -929,10 +929,8 @@ int hisi_sec_cipher_send(handle_t ctx, struct wd_cipher_msg *msg) + if (msg->data_fmt == WD_SGL_BUF) { + ret = hisi_sec_fill_sgl(h_qp, &msg->in, &msg->out, &sqe, + msg->alg_type); +- if (ret) { +- WD_ERR("failed to get sgl!\n"); ++ if (ret) + return ret; +- } + } + + sqe.type2.clen_ivhlen |= (__u32)msg->in_bytes; +@@ -1132,10 +1130,8 @@ int hisi_sec_cipher_send_v3(handle_t ctx, struct wd_cipher_msg *msg) + if (msg->data_fmt == WD_SGL_BUF) { + ret = hisi_sec_fill_sgl_v3(h_qp, &msg->in, &msg->out, &sqe, + msg->alg_type); +- if (ret) { +- WD_ERR("failed to get sgl!\n"); ++ if (ret) + return ret; +- } + } + + sqe.c_len_ivin = (__u32)msg->in_bytes; +@@ -1360,10 +1356,8 @@ int hisi_sec_digest_send(handle_t ctx, struct wd_digest_msg *msg) + if (msg->data_fmt == WD_SGL_BUF) { + ret = hisi_sec_fill_sgl(h_qp, &msg->in, &msg->out, &sqe, + msg->alg_type); +- if (ret) { +- WD_ERR("failed to get sgl!\n"); ++ if (ret) + return ret; +- } + } + + sqe.sds_sa_type |= (__u8)(de | scene); +@@ -1372,10 +1366,8 @@ int hisi_sec_digest_send(handle_t ctx, struct wd_digest_msg *msg) + sqe.type2.mac_addr = (__u64)(uintptr_t)msg->out; + + ret = fill_digest_bd2_alg(msg, &sqe); +- if (ret) { +- WD_ERR("failed to fill digest bd alg!\n"); +- return ret; +- } ++ if (ret) ++ goto put_sgl; + + qm_fill_digest_long_bd(msg, &sqe); + +@@ -1390,15 +1382,18 @@ int hisi_sec_digest_send(handle_t ctx, struct wd_digest_msg *msg) + if (ret != -WD_EBUSY) + WD_ERR("digest send sqe is err(%d)!\n", ret); + +- if (msg->data_fmt == WD_SGL_BUF) +- hisi_sec_put_sgl(h_qp, msg->alg_type, msg->in, msg->out); +- +- return ret; ++ goto put_sgl; + } + + hisi_qm_enable_interrupt(ctx, msg->is_polled); + + return 0; ++ ++put_sgl: ++ if (msg->data_fmt == WD_SGL_BUF) ++ hisi_sec_put_sgl(h_qp, msg->alg_type, msg->in, msg->out); ++ ++ return ret; + } + + int hisi_sec_digest_recv(handle_t ctx, struct wd_digest_msg *recv_msg) +@@ -1517,10 +1512,8 @@ int hisi_sec_digest_send_v3(handle_t ctx, struct wd_digest_msg *msg) + if (msg->data_fmt == WD_SGL_BUF) { + ret = hisi_sec_fill_sgl_v3(h_qp, &msg->in, &msg->out, &sqe, + msg->alg_type); +- if (ret) { +- WD_ERR("failed to get sgl!\n"); ++ if (ret) + return ret; +- } + } + + sqe.bd_param |= (__u16)(de | scene); +@@ -1529,10 +1522,8 @@ int hisi_sec_digest_send_v3(handle_t ctx, struct wd_digest_msg *msg) + sqe.mac_addr = (__u64)(uintptr_t)msg->out; + + ret = fill_digest_bd3_alg(msg, &sqe); +- if (ret) { +- WD_ERR("failed to fill digest bd alg!\n"); +- return ret; +- } ++ if (ret) ++ goto put_sgl; + + qm_fill_digest_long_bd3(msg, &sqe); + +@@ -1548,15 +1539,18 @@ int hisi_sec_digest_send_v3(handle_t ctx, struct wd_digest_msg *msg) + if (ret != -WD_EBUSY) + WD_ERR("digest send sqe is err(%d)!\n", ret); + +- if (msg->data_fmt == WD_SGL_BUF) +- hisi_sec_put_sgl(h_qp, msg->alg_type, msg->in, msg->out); +- +- return ret; ++ goto put_sgl; + } + + hisi_qm_enable_interrupt(ctx, msg->is_polled); + + return 0; ++ ++put_sgl: ++ if (msg->data_fmt == WD_SGL_BUF) ++ hisi_sec_put_sgl(h_qp, msg->alg_type, msg->in, msg->out); ++ ++ return ret; + } + + static void parse_digest_bd3(struct hisi_sec_sqe3 *sqe, +@@ -1873,10 +1867,8 @@ int hisi_sec_aead_send(handle_t ctx, struct wd_aead_msg *msg) + + if (msg->data_fmt == WD_SGL_BUF) { + ret = hisi_sec_fill_sgl(h_qp, &msg->in, &msg->out, &sqe, msg->alg_type); +- if (ret) { +- WD_ERR("failed to get sgl!\n"); ++ if (ret) + return ret; +- } + } + + fill_aead_bd2_addr(msg, &sqe); +@@ -2141,10 +2133,8 @@ int hisi_sec_aead_send_v3(handle_t ctx, struct wd_aead_msg *msg) + if (msg->data_fmt == WD_SGL_BUF) { + ret = hisi_sec_fill_sgl_v3(h_qp, &msg->in, &msg->out, &sqe, + msg->alg_type); +- if (ret) { +- WD_ERR("failed to get sgl!\n"); ++ if (ret) + return ret; +- } + } + + fill_aead_bd3_addr(msg, &sqe); +-- +2.25.1 + diff --git a/0055-uadk-sec-some-clean-code.patch b/0055-uadk-sec-some-clean-code.patch new file mode 100644 index 0000000..f205a3f --- /dev/null +++ b/0055-uadk-sec-some-clean-code.patch @@ -0,0 +1,606 @@ +From 42055f42381b51428be8138042f2a7b6b9964c10 Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Tue, 15 Feb 2022 11:49:52 +0800 +Subject: [PATCH 59/64] uadk: sec: some clean code + +The number of characters in a single line exceeds 80 and +WD_ERR's line change is not aligned. + +Signed-off-by: Wenkai Lin +--- + drv/hisi_sec.c | 175 ++++++++++++++++++++++++++++--------------------- + 1 file changed, 102 insertions(+), 73 deletions(-) + +diff --git a/drv/hisi_sec.c b/drv/hisi_sec.c +index 7f5aae2..264d850 100644 +--- a/drv/hisi_sec.c ++++ b/drv/hisi_sec.c +@@ -547,18 +547,24 @@ static void update_iv_sgl(struct wd_cipher_msg *msg) + case WD_CIPHER_CBC: + if (msg->op_type == WD_CIPHER_ENCRYPTION && + msg->out_bytes >= msg->iv_bytes) +- hisi_qm_sgl_copy(msg->iv, msg->out, msg->out_bytes - +- msg->iv_bytes, msg->iv_bytes, COPY_SGL_TO_PBUFF); ++ hisi_qm_sgl_copy(msg->iv, msg->out, ++ msg->out_bytes - msg->iv_bytes, ++ msg->iv_bytes, COPY_SGL_TO_PBUFF); ++ + if (msg->op_type == WD_CIPHER_DECRYPTION && + msg->in_bytes >= msg->iv_bytes) +- hisi_qm_sgl_copy(msg->iv, msg->in, msg->in_bytes - +- msg->iv_bytes, msg->iv_bytes, COPY_SGL_TO_PBUFF); ++ hisi_qm_sgl_copy(msg->iv, msg->in, ++ msg->in_bytes - msg->iv_bytes, ++ msg->iv_bytes, COPY_SGL_TO_PBUFF); ++ + break; + case WD_CIPHER_OFB: + case WD_CIPHER_CFB: + if (msg->out_bytes >= msg->iv_bytes) +- hisi_qm_sgl_copy(msg->iv, msg->out, msg->out_bytes - +- msg->iv_bytes, msg->iv_bytes, COPY_SGL_TO_PBUFF); ++ hisi_qm_sgl_copy(msg->iv, msg->out, ++ msg->out_bytes - msg->iv_bytes, ++ msg->iv_bytes, COPY_SGL_TO_PBUFF); ++ + break; + case WD_CIPHER_CTR: + ctr_iv_inc(msg->iv, msg->iv_bytes >> +@@ -576,7 +582,8 @@ static int get_3des_c_key_len(struct wd_cipher_msg *msg, __u8 *c_key_len) + } else if (msg->key_bytes == SEC_3DES_3KEY_SIZE) { + *c_key_len = CKEY_LEN_3DES_3KEY; + } else { +- WD_ERR("invalid 3des key size, size = %u\n", msg->key_bytes); ++ WD_ERR("failed to check 3des key size, size = %u\n", ++ msg->key_bytes); + return -WD_EINVAL; + } + +@@ -602,14 +609,15 @@ static int get_aes_c_key_len(struct wd_cipher_msg *msg, __u8 *c_key_len) + *c_key_len = CKEY_LEN_256BIT; + break; + default: +- WD_ERR("invalid AES key size, size = %u\n", len); ++ WD_ERR("failed to check AES key size, size = %u\n", len); + return -WD_EINVAL; + } + + return 0; + } + +-static int fill_cipher_bd2_alg(struct wd_cipher_msg *msg, struct hisi_sec_sqe *sqe) ++static int fill_cipher_bd2_alg(struct wd_cipher_msg *msg, ++ struct hisi_sec_sqe *sqe) + { + __u8 c_key_len = 0; + int ret = 0; +@@ -634,14 +642,15 @@ static int fill_cipher_bd2_alg(struct wd_cipher_msg *msg, struct hisi_sec_sqe *s + sqe->type2.icvw_kmode = (__u16)c_key_len << SEC_CKEY_OFFSET; + break; + default: +- WD_ERR("invalid cipher alg type, alg = %u\n", msg->alg); ++ WD_ERR("failed to check cipher alg type, alg = %u\n", msg->alg); + return -WD_EINVAL; + } + + return ret; + } + +-static int fill_cipher_bd2_mode(struct wd_cipher_msg *msg, struct hisi_sec_sqe *sqe) ++static int fill_cipher_bd2_mode(struct wd_cipher_msg *msg, ++ struct hisi_sec_sqe *sqe) + { + __u16 c_mode; + +@@ -660,7 +669,8 @@ static int fill_cipher_bd2_mode(struct wd_cipher_msg *msg, struct hisi_sec_sqe * + c_mode = C_MODE_XTS; + break; + default: +- WD_ERR("invalid cipher mode type, mode = %u\n", msg->mode); ++ WD_ERR("failed to check cipher mode type, mode = %u\n", ++ msg->mode); + return -WD_EINVAL; + } + sqe->type2.icvw_kmode |= (__u16)(c_mode) << SEC_CMODE_OFFSET; +@@ -668,7 +678,8 @@ static int fill_cipher_bd2_mode(struct wd_cipher_msg *msg, struct hisi_sec_sqe * + return 0; + } + +-static void fill_cipher_bd2_addr(struct wd_cipher_msg *msg, struct hisi_sec_sqe *sqe) ++static void fill_cipher_bd2_addr(struct wd_cipher_msg *msg, ++ struct hisi_sec_sqe *sqe) + { + sqe->type2.data_src_addr = (__u64)(uintptr_t)msg->in; + sqe->type2.data_dst_addr = (__u64)(uintptr_t)msg->out; +@@ -688,7 +699,8 @@ static void fill_cipher_bd2_addr(struct wd_cipher_msg *msg, struct hisi_sec_sqe + sqe->type2.mac_addr = (__u64)(uintptr_t)msg; + } + +-static void parse_cipher_bd2(struct hisi_sec_sqe *sqe, struct wd_cipher_msg *recv_msg) ++static void parse_cipher_bd2(struct hisi_sec_sqe *sqe, ++ struct wd_cipher_msg *recv_msg) + { + struct wd_cipher_msg *rmsg; + __u16 done; +@@ -696,7 +708,7 @@ static void parse_cipher_bd2(struct hisi_sec_sqe *sqe, struct wd_cipher_msg *rec + done = sqe->type2.done_flag & SEC_DONE_MASK; + if (done != SEC_HW_TASK_DONE || sqe->type2.error_type) { + WD_ERR("SEC BD %s fail! done=0x%x, etype=0x%x\n", "cipher", +- done, sqe->type2.error_type); ++ done, sqe->type2.error_type); + recv_msg->result = WD_IN_EPARA; + } else { + recv_msg->result = WD_SUCCESS; +@@ -720,7 +732,7 @@ static int cipher_len_check(struct wd_cipher_msg *msg) + if (msg->in_bytes > MAX_INPUT_DATA_LEN || + !msg->in_bytes) { + WD_ERR("input cipher length is error, size = %u\n", +- msg->in_bytes); ++ msg->in_bytes); + return -WD_EINVAL; + } + +@@ -732,7 +744,7 @@ static int cipher_len_check(struct wd_cipher_msg *msg) + if (msg->mode == WD_CIPHER_XTS) { + if (msg->in_bytes < AES_BLOCK_SIZE) { + WD_ERR("input cipher length is too small, size = %u\n", +- msg->in_bytes); ++ msg->in_bytes); + return -WD_EINVAL; + } + return 0; +@@ -740,15 +752,15 @@ static int cipher_len_check(struct wd_cipher_msg *msg) + + if (msg->alg == WD_CIPHER_3DES || msg->alg == WD_CIPHER_DES) { + if (msg->in_bytes & (DES3_BLOCK_SIZE - 1)) { +- WD_ERR("input 3DES or DES cipher parameter is error, size = %u\n", +- msg->in_bytes); ++ WD_ERR("failed to check input bytes of 3DES or DES, size = %u\n", ++ msg->in_bytes); + return -WD_EINVAL; + } + return 0; + } else if (msg->alg == WD_CIPHER_AES || msg->alg == WD_CIPHER_SM4) { + if (msg->in_bytes & (AES_BLOCK_SIZE - 1)) { +- WD_ERR("input AES or SM4 cipher parameter is error, size = %u\n", +- msg->in_bytes); ++ WD_ERR("failed to check input bytes of AES or SM4, size = %u\n", ++ msg->in_bytes); + return -WD_EINVAL; + } + return 0; +@@ -802,7 +814,7 @@ static int hisi_sec_fill_sgl(handle_t h_qp, __u8 **in, __u8 **out, + return -WD_EINVAL; + } + +- hw_sgl_in = hisi_qm_get_hw_sgl(h_sgl_pool, (struct wd_datalist*)(*in)); ++ hw_sgl_in = hisi_qm_get_hw_sgl(h_sgl_pool, (struct wd_datalist *)(*in)); + if (!hw_sgl_in) { + WD_ERR("failed to get sgl in for hw_v2!\n"); + return -WD_EINVAL; +@@ -811,9 +823,10 @@ static int hisi_sec_fill_sgl(handle_t h_qp, __u8 **in, __u8 **out, + if (type == WD_DIGEST) { + hw_sgl_out = *out; + } else { +- hw_sgl_out = hisi_qm_get_hw_sgl(h_sgl_pool, (struct wd_datalist*)(*out)); ++ hw_sgl_out = hisi_qm_get_hw_sgl(h_sgl_pool, ++ (struct wd_datalist *)(*out)); + if (!hw_sgl_out) { +- WD_ERR("failed to get hw sgl out!\n"); ++ WD_ERR("failed to get hw sgl out for hw_v2!\n"); + hisi_qm_put_hw_sgl(h_sgl_pool, hw_sgl_in); + return -WD_EINVAL; + } +@@ -841,7 +854,7 @@ static int hisi_sec_fill_sgl_v3(handle_t h_qp, __u8 **in, __u8 **out, + return -WD_EINVAL; + } + +- hw_sgl_in = hisi_qm_get_hw_sgl(h_sgl_pool, (struct wd_datalist*)(*in)); ++ hw_sgl_in = hisi_qm_get_hw_sgl(h_sgl_pool, (struct wd_datalist *)(*in)); + if (!hw_sgl_in) { + WD_ERR("failed to get sgl in for hw_v3!\n"); + return -WD_EINVAL; +@@ -851,9 +864,10 @@ static int hisi_sec_fill_sgl_v3(handle_t h_qp, __u8 **in, __u8 **out, + hw_sgl_out = *out; + sqe->bd_param |= SEC_PBUFF_MODE_MASK_V3; + } else { +- hw_sgl_out = hisi_qm_get_hw_sgl(h_sgl_pool, (struct wd_datalist*)(*out)); ++ hw_sgl_out = hisi_qm_get_hw_sgl(h_sgl_pool, ++ (struct wd_datalist *)(*out)); + if (!hw_sgl_out) { +- WD_ERR("failed to get hw sgl out!\n"); ++ WD_ERR("failed to get hw sgl out for hw_v3!\n"); + hisi_qm_put_hw_sgl(h_sgl_pool, hw_sgl_in); + return -WD_EINVAL; + } +@@ -943,7 +957,8 @@ int hisi_sec_cipher_send(handle_t ctx, struct wd_cipher_msg *msg) + WD_ERR("cipher send sqe is err(%d)!\n", ret); + + if (msg->data_fmt == WD_SGL_BUF) +- hisi_sec_put_sgl(h_qp, msg->alg_type, msg->in, msg->out); ++ hisi_sec_put_sgl(h_qp, msg->alg_type, msg->in, ++ msg->out); + + return ret; + } +@@ -969,7 +984,7 @@ int hisi_sec_cipher_recv(handle_t ctx, struct wd_cipher_msg *recv_msg) + + if (recv_msg->data_fmt == WD_SGL_BUF) + hisi_sec_put_sgl(h_qp, recv_msg->alg_type, recv_msg->in, +- recv_msg->out); ++ recv_msg->out); + + return 0; + } +@@ -1010,7 +1025,7 @@ static int fill_cipher_bd3_alg(struct wd_cipher_msg *msg, + sqe->c_icv_key |= (__u16)c_key_len << SEC_CKEY_OFFSET_V3; + break; + default: +- WD_ERR("invalid cipher alg type, alg = %u\n", msg->alg); ++ WD_ERR("failed to check cipher alg type, alg = %u\n", msg->alg); + return -WD_EINVAL; + } + +@@ -1045,7 +1060,8 @@ static int fill_cipher_bd3_mode(struct wd_cipher_msg *msg, + c_mode = C_MODE_CFB; + break; + default: +- WD_ERR("invalid cipher mode type, mode = %u\n", msg->mode); ++ WD_ERR("failed to check cipher mode type, mode = %u\n", ++ msg->mode); + return -WD_EINVAL; + } + sqe->c_mode_alg |= (__u16)c_mode; +@@ -1144,7 +1160,8 @@ int hisi_sec_cipher_send_v3(handle_t ctx, struct wd_cipher_msg *msg) + WD_ERR("cipher send sqe is err(%d)!\n", ret); + + if (msg->data_fmt == WD_SGL_BUF) +- hisi_sec_put_sgl(h_qp, msg->alg_type, msg->in, msg->out); ++ hisi_sec_put_sgl(h_qp, msg->alg_type, msg->in, ++ msg->out); + + return ret; + } +@@ -1154,7 +1171,8 @@ int hisi_sec_cipher_send_v3(handle_t ctx, struct wd_cipher_msg *msg) + return 0; + } + +-static void parse_cipher_bd3(struct hisi_sec_sqe3 *sqe, struct wd_cipher_msg *recv_msg) ++static void parse_cipher_bd3(struct hisi_sec_sqe3 *sqe, ++ struct wd_cipher_msg *recv_msg) + { + struct wd_cipher_msg *rmsg; + __u16 done; +@@ -1162,7 +1180,7 @@ static void parse_cipher_bd3(struct hisi_sec_sqe3 *sqe, struct wd_cipher_msg *re + done = sqe->done_flag & SEC_DONE_MASK; + if (done != SEC_HW_TASK_DONE || sqe->error_type) { + WD_ERR("SEC BD3 %s fail! done=0x%x, etype=0x%x\n", "cipher", +- done, sqe->error_type); ++ done, sqe->error_type); + recv_msg->result = WD_IN_EPARA; + } else { + recv_msg->result = WD_SUCCESS; +@@ -1205,7 +1223,7 @@ static int fill_digest_bd2_alg(struct wd_digest_msg *msg, + struct hisi_sec_sqe *sqe) + { + if (msg->alg >= WD_DIGEST_TYPE_MAX) { +- WD_ERR("invalid digest alg type, alg = %u\n", msg->alg); ++ WD_ERR("failed to check digest alg type, alg = %u\n", msg->alg); + return -WD_EINVAL; + } + +@@ -1215,8 +1233,8 @@ static int fill_digest_bd2_alg(struct wd_digest_msg *msg, + (__u32)g_digest_a_alg[msg->alg] << AUTH_ALG_OFFSET; + else if (msg->mode == WD_DIGEST_HMAC) { + if (msg->key_bytes & WORD_ALIGNMENT_MASK) { +- WD_ERR("invalid digest key_bytes, size = %u\n", +- msg->key_bytes); ++ WD_ERR("failed to check digest key_bytes, size = %u\n", ++ msg->key_bytes); + return -WD_EINVAL; + } + sqe->type2.mac_key_alg |= (__u32)(msg->key_bytes / +@@ -1226,7 +1244,7 @@ static int fill_digest_bd2_alg(struct wd_digest_msg *msg, + sqe->type2.mac_key_alg |= + (__u32)g_hmac_a_alg[msg->alg] << AUTH_ALG_OFFSET; + } else { +- WD_ERR("invalid digest mode, mode = %u\n", msg->mode); ++ WD_ERR("failed to check digest mode, mode = %u\n", msg->mode); + return -WD_EINVAL; + } + +@@ -1238,7 +1256,7 @@ static void qm_fill_digest_long_bd(struct wd_digest_msg *msg, + { + __u64 total_bits; + +- if (msg->has_next && (msg->iv_bytes == 0)) { ++ if (msg->has_next && !msg->iv_bytes) { + /* LONG BD FIRST */ + sqe->ai_apd_cs = AI_GEN_INNER; + sqe->ai_apd_cs |= AUTHPAD_NOPAD << AUTHPAD_OFFSET; +@@ -1257,14 +1275,15 @@ static void qm_fill_digest_long_bd(struct wd_digest_msg *msg, + } + } + +-static void parse_digest_bd2(struct hisi_sec_sqe *sqe, struct wd_digest_msg *recv_msg) ++static void parse_digest_bd2(struct hisi_sec_sqe *sqe, ++ struct wd_digest_msg *recv_msg) + { + __u16 done; + + done = sqe->type2.done_flag & SEC_DONE_MASK; + if (done != SEC_HW_TASK_DONE || sqe->type2.error_type) { + WD_ERR("SEC BD %s fail! done=0x%x, etype=0x%x\n", "digest", +- done, sqe->type2.error_type); ++ done, sqe->type2.error_type); + recv_msg->result = WD_IN_EPARA; + } else { + recv_msg->result = WD_SUCCESS; +@@ -1284,9 +1303,12 @@ static void parse_digest_bd2(struct hisi_sec_sqe *sqe, struct wd_digest_msg *rec + + static int digest_long_bd_check(struct wd_digest_msg *msg) + { +- if (msg->alg >= WD_DIGEST_SHA512 && msg->in_bytes & (SHA512_ALIGN_SZ - 1)) +- return -WD_EINVAL; +- else if (msg->in_bytes & (SHA1_ALIGN_SZ - 1)) ++ __u32 alg_align_sz; ++ ++ alg_align_sz = msg->alg >= WD_DIGEST_SHA512 ? ++ SHA512_ALIGN_SZ - 1 : SHA1_ALIGN_SZ - 1; ++ ++ if (msg->in_bytes & alg_align_sz) + return -WD_EINVAL; + + return 0; +@@ -1297,20 +1319,20 @@ static int digest_len_check(struct wd_digest_msg *msg, enum sec_bd_type type) + int ret; + + /* End BD not need to check the input zero bytes */ +- if (unlikely(type == BD_TYPE2 && (!msg->has_next && msg->in_bytes == 0))) { ++ if (unlikely(type == BD_TYPE2 && !msg->has_next && !msg->in_bytes)) { + WD_ERR("kunpeng 920, digest mode not support 0 size!\n"); + return -WD_EINVAL; + } + + if (unlikely(msg->in_bytes > MAX_INPUT_DATA_LEN)) { + WD_ERR("digest input length is too long, size = %u\n", +- msg->in_bytes); ++ msg->in_bytes); + return -WD_EINVAL; + } + + if (unlikely(msg->out_bytes & WORD_ALIGNMENT_MASK)) { + WD_ERR("digest out length is error, size = %u\n", +- msg->out_bytes); ++ msg->out_bytes); + return -WD_EINVAL; + } + +@@ -1318,7 +1340,7 @@ static int digest_len_check(struct wd_digest_msg *msg, enum sec_bd_type type) + ret = digest_long_bd_check(msg); + if (ret) { + WD_ERR("input data isn't aligned, size = %u\n", +- msg->in_bytes); ++ msg->in_bytes); + return -WD_EINVAL; + } + } +@@ -1430,7 +1452,7 @@ static int fill_digest_bd3_alg(struct wd_digest_msg *msg, + struct hisi_sec_sqe3 *sqe) + { + if (msg->alg >= WD_DIGEST_TYPE_MAX) { +- WD_ERR("invalid digest type, alg = %u\n", msg->alg); ++ WD_ERR("failed to check digest type, alg = %u\n", msg->alg); + return -WD_EINVAL; + } + +@@ -1441,8 +1463,8 @@ static int fill_digest_bd3_alg(struct wd_digest_msg *msg, + (__u32)g_digest_a_alg[msg->alg] << SEC_AUTH_ALG_OFFSET_V3; + } else if (msg->mode == WD_DIGEST_HMAC) { + if (msg->key_bytes & WORD_ALIGNMENT_MASK) { +- WD_ERR("invalid digest key_bytes, size = %u\n", +- msg->key_bytes); ++ WD_ERR("failed to check digest key bytes, size = %u\n", ++ msg->key_bytes); + return -WD_EINVAL; + } + sqe->auth_mac_key |= (__u32)(msg->key_bytes / +@@ -1451,7 +1473,7 @@ static int fill_digest_bd3_alg(struct wd_digest_msg *msg, + sqe->auth_mac_key |= + (__u32)g_hmac_a_alg[msg->alg] << SEC_AUTH_ALG_OFFSET_V3; + } else { +- WD_ERR("invalid digest mode, mode = %u\n", msg->mode); ++ WD_ERR("failed to check digest mode, mode = %u\n", msg->mode); + return -WD_EINVAL; + } + +@@ -1463,7 +1485,7 @@ static void qm_fill_digest_long_bd3(struct wd_digest_msg *msg, + { + __u64 total_bits; + +- if (msg->has_next && (msg->iv_bytes == 0)) { ++ if (msg->has_next && !msg->iv_bytes) { + /* LONG BD FIRST */ + sqe->auth_mac_key |= AI_GEN_INNER << SEC_AI_GEN_OFFSET_V3; + sqe->stream_scene.stream_auth_pad = AUTHPAD_NOPAD; +@@ -1561,7 +1583,7 @@ static void parse_digest_bd3(struct hisi_sec_sqe3 *sqe, + done = sqe->done_flag & SEC_DONE_MASK; + if (done != SEC_HW_TASK_DONE || sqe->error_type) { + WD_ERR("SEC BD3 %s fail! done=0x%x, etype=0x%x\n", "digest", +- done, sqe->error_type); ++ done, sqe->error_type); + recv_msg->result = WD_IN_EPARA; + } else { + recv_msg->result = WD_SUCCESS; +@@ -1613,7 +1635,7 @@ static int aead_get_aes_key_len(struct wd_aead_msg *msg, __u8 *key_len) + break; + default: + WD_ERR("failed to check AES key size, size = %u\n", +- msg->ckey_bytes); ++ msg->ckey_bytes); + return -WD_EINVAL; + } + +@@ -1624,7 +1646,7 @@ static int aead_bd_msg_check(struct wd_aead_msg *msg) + { + if (unlikely(msg->akey_bytes & WORD_ALIGNMENT_MASK)) { + WD_ERR("failed to check aead auth key bytes, size = %u\n", +- msg->akey_bytes); ++ msg->akey_bytes); + return -WD_EINVAL; + } + +@@ -1645,7 +1667,8 @@ static int fill_aead_bd2_alg(struct wd_aead_msg *msg, + sqe->type2.icvw_kmode = (__u16)c_key_len << SEC_CKEY_OFFSET; + break; + default: +- WD_ERR("failed to check aead calg type, calg = %u\n", msg->calg); ++ WD_ERR("failed to check aead calg type, calg = %u\n", ++ msg->calg); + return -WD_EINVAL; + } + +@@ -1673,7 +1696,8 @@ static int fill_aead_bd2_alg(struct wd_aead_msg *msg, + d_alg = A_ALG_HMAC_SHA512 << AUTH_ALG_OFFSET; + break; + default: +- WD_ERR("failed to check aead dalg type, dalg = %u\n", msg->dalg); ++ WD_ERR("failed to check aead dalg type, dalg = %u\n", ++ msg->dalg); + ret = -WD_EINVAL; + } + sqe->type2.mac_key_alg |= d_alg; +@@ -1704,7 +1728,7 @@ static int fill_aead_bd2_mode(struct wd_aead_msg *msg, + break; + default: + WD_ERR("failed to check aead cmode type, cmode = %u\n", +- msg->cmode); ++ msg->cmode); + return -WD_EINVAL; + } + sqe->type2.icvw_kmode |= (__u16)(c_mode) << SEC_CMODE_OFFSET; +@@ -1778,14 +1802,14 @@ static int aead_len_check(struct wd_aead_msg *msg) + { + if (unlikely(msg->in_bytes + msg->assoc_bytes > MAX_INPUT_DATA_LEN)) { + WD_ERR("aead input data length is too long, size = %u\n", +- msg->in_bytes + msg->assoc_bytes); ++ msg->in_bytes + msg->assoc_bytes); + return -WD_EINVAL; + } + + if (unlikely(msg->cmode == WD_CIPHER_CCM && + msg->assoc_bytes > MAX_CCM_AAD_LEN)) { +- WD_ERR("failed to check ccm aad len, input is too long, size = %u\n", +- msg->assoc_bytes); ++ WD_ERR("aead ccm aad length is too long, size = %u\n", ++ msg->assoc_bytes); + return -WD_EINVAL; + } + +@@ -1851,7 +1875,7 @@ int hisi_sec_aead_send(handle_t ctx, struct wd_aead_msg *msg) + return -WD_EINVAL; + } + +- if (unlikely(msg->cmode != WD_CIPHER_CBC && msg->in_bytes == 0)) { ++ if (unlikely(msg->cmode != WD_CIPHER_CBC && !msg->in_bytes)) { + WD_ERR("ccm or gcm not supports 0 packet size at hw_v2!\n"); + return -WD_EINVAL; + } +@@ -1866,7 +1890,8 @@ int hisi_sec_aead_send(handle_t ctx, struct wd_aead_msg *msg) + return ret; + + if (msg->data_fmt == WD_SGL_BUF) { +- ret = hisi_sec_fill_sgl(h_qp, &msg->in, &msg->out, &sqe, msg->alg_type); ++ ret = hisi_sec_fill_sgl(h_qp, &msg->in, &msg->out, ++ &sqe, msg->alg_type); + if (ret) + return ret; + } +@@ -1886,7 +1911,8 @@ int hisi_sec_aead_send(handle_t ctx, struct wd_aead_msg *msg) + WD_ERR("aead send sqe is err(%d)!\n", ret); + + if (msg->data_fmt == WD_SGL_BUF) +- hisi_sec_put_sgl(h_qp, msg->alg_type, msg->in, msg->out); ++ hisi_sec_put_sgl(h_qp, msg->alg_type, msg->in, ++ msg->out); + + return ret; + } +@@ -1906,7 +1932,7 @@ static void parse_aead_bd2(struct hisi_sec_sqe *sqe, + if (done != SEC_HW_TASK_DONE || sqe->type2.error_type || + icv == SEC_HW_ICV_ERR) { + WD_ERR("SEC BD aead fail! done=0x%x, etype=0x%x, icv=0x%x\n", +- done, sqe->type2.error_type, icv); ++ done, sqe->type2.error_type, icv); + recv_msg->result = WD_IN_EPARA; + } else { + recv_msg->result = WD_SUCCESS; +@@ -1921,7 +1947,7 @@ static void parse_aead_bd2(struct hisi_sec_sqe *sqe, + recv_msg->mac = (__u8 *)(uintptr_t)sqe->type2.mac_addr; + recv_msg->auth_bytes = (sqe->type2.mac_key_alg & + SEC_MAC_LEN_MASK) * WORD_BYTES; +- if (recv_msg->auth_bytes == 0) ++ if (!recv_msg->auth_bytes) + recv_msg->auth_bytes = sqe->type2.icvw_kmode & + SEC_AUTH_LEN_MASK; + recv_msg->out_bytes = sqe->type2.clen_ivhlen + +@@ -1981,7 +2007,8 @@ static int fill_aead_bd3_alg(struct wd_aead_msg *msg, + sqe->c_icv_key |= (__u16)c_key_len << SEC_CKEY_OFFSET_V3; + break; + default: +- WD_ERR("failed to check aead calg type, calg = %u\n", msg->calg); ++ WD_ERR("failed to check aead calg type, calg = %u\n", ++ msg->calg); + return -WD_EINVAL; + } + +@@ -2010,7 +2037,8 @@ static int fill_aead_bd3_alg(struct wd_aead_msg *msg, + d_alg = A_ALG_HMAC_SHA512 << SEC_AUTH_ALG_OFFSET_V3; + break; + default: +- WD_ERR("failed to check aead dalg type, dalg = %u\n", msg->dalg); ++ WD_ERR("failed to check aead dalg type, dalg = %u\n", ++ msg->dalg); + ret = -WD_EINVAL; + } + sqe->auth_mac_key |= d_alg; +@@ -2039,7 +2067,7 @@ static int fill_aead_bd3_mode(struct wd_aead_msg *msg, + break; + default: + WD_ERR("failed to check aead cmode type, cmode = %u\n", +- msg->cmode); ++ msg->cmode); + return -WD_EINVAL; + } + +@@ -2151,7 +2179,8 @@ int hisi_sec_aead_send_v3(handle_t ctx, struct wd_aead_msg *msg) + WD_ERR("aead send sqe is err(%d)!\n", ret); + + if (msg->data_fmt == WD_SGL_BUF) +- hisi_sec_put_sgl(h_qp, msg->alg_type, msg->in, msg->out); ++ hisi_sec_put_sgl(h_qp, msg->alg_type, msg->in, ++ msg->out); + + return ret; + } +@@ -2171,7 +2200,7 @@ static void parse_aead_bd3(struct hisi_sec_sqe3 *sqe, + if (done != SEC_HW_TASK_DONE || sqe->error_type || + icv == SEC_HW_ICV_ERR) { + WD_ERR("SEC BD3 aead fail! done=0x%x, etype=0x%x, icv=0x%x\n", +- done, sqe->error_type, icv); ++ done, sqe->error_type, icv); + recv_msg->result = WD_IN_EPARA; + } else { + recv_msg->result = WD_SUCCESS; +@@ -2186,7 +2215,7 @@ static void parse_aead_bd3(struct hisi_sec_sqe3 *sqe, + recv_msg->mac = (__u8 *)(uintptr_t)sqe->mac_addr; + recv_msg->auth_bytes = ((sqe->auth_mac_key >> SEC_MAC_OFFSET_V3) & + SEC_MAC_LEN_MASK) * WORD_BYTES; +- if (recv_msg->auth_bytes == 0) ++ if (!recv_msg->auth_bytes) + recv_msg->auth_bytes = (sqe->c_icv_key >> SEC_MAC_OFFSET_V3) & + SEC_MAC_LEN_MASK; + recv_msg->out_bytes = sqe->c_len_ivin + +-- +2.25.1 + diff --git a/0056-uadk-optimize-wd_ctx_qfr_mmap.patch b/0056-uadk-optimize-wd_ctx_qfr_mmap.patch new file mode 100644 index 0000000..1eb1d75 --- /dev/null +++ b/0056-uadk-optimize-wd_ctx_qfr_mmap.patch @@ -0,0 +1,59 @@ +From b9b1cb826756b2a27ed99745a5fb9be338abd09f Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Tue, 15 Feb 2022 11:49:53 +0800 +Subject: [PATCH 60/64] uadk: optimize wd_ctx_qfr_mmap + +wd_ctx_qfr_mmap may return NULL when user input wrong parameters +or mmap failed, so detail information should be printed. + +Signed-off-by: Wenkai Lin +--- + wd.c | 12 ++++++++---- + 1 file changed, 8 insertions(+), 4 deletions(-) + +diff --git a/wd.c b/wd.c +index 6bbf677..d1652dd 100644 +--- a/wd.c ++++ b/wd.c +@@ -386,7 +386,7 @@ int wd_ctx_start(handle_t h_ctx) + + ret = wd_ctx_set_io_cmd(h_ctx, UACCE_CMD_START, NULL); + if (ret) +- WD_ERR("Fail to start on %s (%d), ret = %d!\n", ++ WD_ERR("failed to start on %s (%d), ret = %d!\n", + ctx->dev_path, -errno, ret); + + return ret; +@@ -402,7 +402,7 @@ int wd_release_ctx_force(handle_t h_ctx) + + ret = wd_ctx_set_io_cmd(h_ctx, UACCE_CMD_PUT_Q, NULL); + if (ret) +- WD_ERR("Fail to stop on %s (%d), ret = %d!\n", ++ WD_ERR("failed to stop on %s (%d), ret = %d!\n", + ctx->dev_path, -errno, ret); + + return ret; +@@ -415,14 +415,18 @@ void *wd_ctx_mmap_qfr(handle_t h_ctx, enum uacce_qfrt qfrt) + size_t size; + void *addr; + +- if (!ctx || qfrt >= UACCE_QFRT_MAX || !ctx->qfrs_offs[qfrt]) ++ if (!ctx || qfrt >= UACCE_QFRT_MAX || !ctx->qfrs_offs[qfrt]) { ++ WD_ERR("failed to check input ctx or qfrt!\n"); + return NULL; ++ } + + size = ctx->qfrs_offs[qfrt]; + + addr = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, ctx->fd, off); +- if (addr == MAP_FAILED) ++ if (addr == MAP_FAILED) { ++ WD_ERR("failed to mmap, qfrt = %d, err = %d!\n", qfrt, -errno); + return NULL; ++ } + + ctx->qfrs_base[qfrt] = addr; + +-- +2.25.1 + diff --git a/0057-uadk-optimize-wd_sched_rr_instance.patch b/0057-uadk-optimize-wd_sched_rr_instance.patch new file mode 100644 index 0000000..142d519 --- /dev/null +++ b/0057-uadk-optimize-wd_sched_rr_instance.patch @@ -0,0 +1,65 @@ +From 1da22fb07ffeabe82310b8619563fd5971214e18 Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Tue, 15 Feb 2022 11:49:54 +0800 +Subject: [PATCH 61/64] uadk: optimize wd_sched_rr_instance + +Schedule ctx numa number and schedule type number should +also be printed, the error information is more usefull +if when it has a comparison. + +Signed-off-by: Wenkai Lin +--- + wd_sched.c | 24 +++++++++++++++++------- + 1 file changed, 17 insertions(+), 7 deletions(-) + +diff --git a/wd_sched.c b/wd_sched.c +index aeaf11b..ef90233 100644 +--- a/wd_sched.c ++++ b/wd_sched.c +@@ -129,7 +129,7 @@ static bool sched_key_valid(struct wd_sched_ctx *ctx, + { + if (key->numa_id >= ctx->numa_num || key->mode >= SCHED_MODE_BUTT || + key->type >= ctx->type_num) { +- WD_ERR("ERROR: %s key error - numa:%d, mode:%u, type%u!\n", ++ WD_ERR("ERROR: %s key error - numa: %d, mode: %u, type: %u!\n", + __FUNCTION__, key->numa_id, key->mode, key->type); + return false; + } +@@ -372,18 +372,28 @@ int wd_sched_rr_instance(const struct wd_sched *sched, + mode = param->mode; + sched_ctx = (struct wd_sched_ctx *)sched->h_sched_ctx; + +- if ((numa_id >= sched_ctx->numa_num) || (numa_id < 0) || +- (mode >= SCHED_MODE_BUTT) || +- (type >= sched_ctx->type_num)) { +- WD_ERR("ERROR: %s para err: numa_id=%d, mode=%u, type=%u!\n", +- __FUNCTION__, numa_id, mode, type); ++ if (numa_id >= sched_ctx->numa_num || numa_id < 0) { ++ WD_ERR("ERROR: %s para err: numa_id = %d, numa_num = %u\n", ++ __FUNCTION__, numa_id, sched_ctx->numa_num); ++ return -WD_EINVAL; ++ } ++ ++ if (type >= sched_ctx->type_num) { ++ WD_ERR("ERROR: %s para err: type = %u, type_num = %u\n", ++ __FUNCTION__, type, sched_ctx->type_num); ++ return -WD_EINVAL; ++ } ++ ++ if (mode >= SCHED_MODE_BUTT) { ++ WD_ERR("ERROR: %s para err: mode = %u, mode_num = %d!\n", ++ __FUNCTION__, mode, SCHED_MODE_BUTT); + return -WD_EINVAL; + } + + sched_info = sched_ctx->sched_info; + + if (!sched_info[numa_id].ctx_region[mode]) { +- WD_ERR("ERROR: %s para err: ctx_region:numa_id=%d, mode=%u is NULL!\n", ++ WD_ERR("ERROR: %s ctx_region of numa_id = %d, mode = %u is NULL!\n", + __FUNCTION__, numa_id, mode); + return -WD_EINVAL; + } +-- +2.25.1 + diff --git a/0058-uadk-optimize-wd_get_accel_list.patch b/0058-uadk-optimize-wd_get_accel_list.patch new file mode 100644 index 0000000..164f954 --- /dev/null +++ b/0058-uadk-optimize-wd_get_accel_list.patch @@ -0,0 +1,127 @@ +From b670d346baac3be4b3b55a481c196abbdaf36bd3 Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Tue, 15 Feb 2022 11:49:55 +0800 +Subject: [PATCH 62/64] uadk: optimize wd_get_accel_list + +wd_get_accel_list should skip nosva device, +so add a step to check sva flags, get_dev_info +should not print error info when device is nosva. + +Signed-off-by: Wenkai Lin +--- + wd.c | 39 +++++++++++++++++++++------------------ + 1 file changed, 21 insertions(+), 18 deletions(-) + +diff --git a/wd.c b/wd.c +index d1652dd..afcf134 100644 +--- a/wd.c ++++ b/wd.c +@@ -44,16 +44,18 @@ static int get_raw_attr(const char *dev_root, const char *attr, char *buf, + ssize_t size; + int fd; + +- if (!dev_root || !attr || !buf || !sz) +- return -WD_EINVAL; +- + size = snprintf(attr_file, PATH_STR_SIZE, "%s/%s", dev_root, attr); +- if (size < 0) ++ if (size < 0) { ++ WD_ERR("failed to snprintf, dev_root: %s, attr: %s!\n", ++ dev_root, attr); + return -WD_EINVAL; ++ } + + ptrRet = realpath(attr_file, attr_path); +- if (ptrRet == NULL) ++ if (ptrRet == NULL) { ++ WD_ERR("failed to resolve path, attr_file: %s!\n", attr_file); + return -WD_ENODEV; ++ } + + fd = open(attr_path, O_RDONLY, 0); + if (fd < 0) { +@@ -78,16 +80,15 @@ static int get_int_attr(struct uacce_dev *dev, const char *attr, int *val) + char buf[MAX_ATTR_STR_SIZE] = {0}; + int ret; + +- if (!dev || !val) +- return -WD_EINVAL; +- + ret = get_raw_attr(dev->dev_root, attr, buf, MAX_ATTR_STR_SIZE - 1); + if (ret < 0) + return ret; + + *val = strtol(buf, NULL, 10); +- if (errno == ERANGE) ++ if (errno == ERANGE) { ++ WD_ERR("failed to strtol %s, out of range!\n", buf); + return -errno; ++ } + + return 0; + } +@@ -97,9 +98,6 @@ static int get_str_attr(struct uacce_dev *dev, const char *attr, char *buf, + { + int ret; + +- if (!dev) +- return -WD_EINVAL; +- + ret = get_raw_attr(dev->dev_root, attr, buf, buf_sz); + if (ret < 0) { + buf[0] = '\0'; +@@ -143,13 +141,19 @@ static int get_dev_info(struct uacce_dev *dev) + ret = get_int_attr(dev, "isolate", &value); + if (ret < 0) + return ret; +- else if (value == 1) ++ else if (value == 1) { ++ WD_ERR("skip isolated uacce device!\n"); + return -ENODEV; ++ } + } + + ret = get_int_attr(dev, "flags", &dev->flags); + if (ret < 0) + return ret; ++ else if (!(dev->flags & UACCE_DEV_SVA)) { ++ WD_ERR("skip none sva uacce device!\n"); ++ return -ENODEV; ++ } + + ret = get_int_attr(dev, "region_mmio_size", &value); + if (ret < 0) +@@ -211,10 +215,8 @@ static struct uacce_dev *read_uacce_sysfs(const char *dev_name) + goto out_dir; + + ret = get_dev_info(dev); +- if (ret < 0) { +- WD_ERR("failed to get dev info: ret = %d!\n", ret); ++ if (ret < 0) + goto out_dir; +- } + + break; + } +@@ -529,6 +531,9 @@ int wd_get_avail_ctx(struct uacce_dev *dev) + { + int avail_ctx, ret; + ++ if (!dev) ++ return -WD_EINVAL; ++ + ret = get_int_attr(dev, "available_instances", &avail_ctx); + if (ret < 0) + return ret; +@@ -551,8 +556,6 @@ static int get_dev_alg_name(const char *d_name, char *dev_alg_name, size_t sz) + ret = get_raw_attr(dev_path, "algorithms", dev_alg_name, sz); + if (ret < 0) { + dev_alg_name[0] = '\0'; +- WD_ERR("failed to get alg for %s, ret = %d\n", +- dev_path, ret); + return ret; + } + +-- +2.25.1 + diff --git a/0059-uadk-fix-staic-check-warning.patch b/0059-uadk-fix-staic-check-warning.patch new file mode 100644 index 0000000..6db3794 --- /dev/null +++ b/0059-uadk-fix-staic-check-warning.patch @@ -0,0 +1,38 @@ +From f266f7920f0f58b71f2755a8cbad284f1848316c Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Tue, 15 Feb 2022 11:49:56 +0800 +Subject: [PATCH 63/64] uadk: fix staic check warning + +1.fix unterminated string. +2.fix bit operation of int data. + +Signed-off-by: Wenkai Lin +--- + wd.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/wd.c b/wd.c +index afcf134..565c173 100644 +--- a/wd.c ++++ b/wd.c +@@ -77,7 +77,7 @@ static int get_raw_attr(const char *dev_root, const char *attr, char *buf, + + static int get_int_attr(struct uacce_dev *dev, const char *attr, int *val) + { +- char buf[MAX_ATTR_STR_SIZE] = {0}; ++ char buf[MAX_ATTR_STR_SIZE] = {'\0'}; + int ret; + + ret = get_raw_attr(dev->dev_root, attr, buf, MAX_ATTR_STR_SIZE - 1); +@@ -150,7 +150,7 @@ static int get_dev_info(struct uacce_dev *dev) + ret = get_int_attr(dev, "flags", &dev->flags); + if (ret < 0) + return ret; +- else if (!(dev->flags & UACCE_DEV_SVA)) { ++ else if (!((unsigned int)dev->flags & UACCE_DEV_SVA)) { + WD_ERR("skip none sva uacce device!\n"); + return -ENODEV; + } +-- +2.25.1 + diff --git a/0060-uadk-v1-fix-the-waiting-time-for-receiving-task.patch b/0060-uadk-v1-fix-the-waiting-time-for-receiving-task.patch new file mode 100644 index 0000000..0d5d734 --- /dev/null +++ b/0060-uadk-v1-fix-the-waiting-time-for-receiving-task.patch @@ -0,0 +1,134 @@ +From 2b4923b7290eba36bc2fefc517129fb30a3d207d Mon Sep 17 00:00:00 2001 +From: Weili Qian +Date: Mon, 21 Feb 2022 09:14:17 +0800 +Subject: [PATCH 64/64] uadk/v1: fix the waiting time for receiving task + +SEC device processes tasks quickly. If 'usleep' is used to +wait for the hardware to process tasks, CPU scheduling will +reduce performance. Therefore, increase the number of cycles +to replace 'usleep'. + +Signed-off-by: Weili Qian +--- + v1/wd_aead.c | 15 ++++++++------- + v1/wd_cipher.c | 15 ++++++++------- + v1/wd_digest.c | 15 ++++++++------- + 3 files changed, 24 insertions(+), 21 deletions(-) + +diff --git a/v1/wd_aead.c b/v1/wd_aead.c +index 181b971..ad22426 100644 +--- a/v1/wd_aead.c ++++ b/v1/wd_aead.c +@@ -35,8 +35,7 @@ + #define MAX_AEAD_AUTH_SIZE 64 + #define MAX_AEAD_ASSOC_SIZE 65536 + #define MAX_HMAC_KEY_SIZE 128 +-#define MAX_AEAD_RETRY_CNT 2000000 +-#define AEAD_SLEEP_INTERVAL 0xf ++#define MAX_AEAD_RETRY_CNT 20000000 + + #define DES_KEY_SIZE 8 + #define SM4_KEY_SIZE 16 +@@ -509,16 +508,18 @@ static int aead_recv_sync(struct wcrypto_aead_ctx *a_ctx, + while (true) { + ret = wd_burst_recv(a_ctx->q, (void **)(resp + recv_count), + num - recv_count); +- if (ret >= 0) { ++ if (ret > 0) { + recv_count += ret; + if (recv_count == num) + break; + +- if (++rx_cnt > MAX_AEAD_RETRY_CNT) ++ rx_cnt = 0; ++ } else if (ret == 0) { ++ if (++rx_cnt > MAX_AEAD_RETRY_CNT) { ++ WD_ERR("%s:wcrypto_recv timeout, num = %u, recv_count = %u!\n", ++ __func__, num, recv_count); + break; +- +- if (!(rx_cnt & AEAD_SLEEP_INTERVAL)) +- usleep(1); ++ } + } else { + WD_ERR("do aead wcrypto_recv error!\n"); + return ret; +diff --git a/v1/wd_cipher.c b/v1/wd_cipher.c +index 7df44e7..8bf71be 100644 +--- a/v1/wd_cipher.c ++++ b/v1/wd_cipher.c +@@ -30,8 +30,7 @@ + #include "v1/wd_util.h" + + #define MAX_CIPHER_KEY_SIZE 64 +-#define MAX_CIPHER_RETRY_CNT 2000000 +-#define CIPHER_SLEEP_INTERVAL 0xf ++#define MAX_CIPHER_RETRY_CNT 20000000 + + #define DES_KEY_SIZE 8 + #define SM4_KEY_SIZE 16 +@@ -379,16 +378,18 @@ static int cipher_recv_sync(struct wcrypto_cipher_ctx *c_ctx, + while (true) { + ret = wd_burst_recv(c_ctx->q, (void **)(resp + recv_count), + num - recv_count); +- if (ret >= 0) { ++ if (ret > 0) { + recv_count += ret; + if (recv_count == num) + break; + +- if (++rx_cnt > MAX_CIPHER_RETRY_CNT) ++ rx_cnt = 0; ++ } else if (ret == 0) { ++ if (++rx_cnt > MAX_CIPHER_RETRY_CNT) { ++ WD_ERR("%s:wcrypto_recv timeout, num = %u, recv_count = %u!\n", ++ __func__, num, recv_count); + break; +- +- if (!(rx_cnt & CIPHER_SLEEP_INTERVAL)) +- usleep(1); ++ } + } else { + WD_ERR("do cipher wcrypto_recv error!\n"); + return ret; +diff --git a/v1/wd_digest.c b/v1/wd_digest.c +index aae4823..2179415 100644 +--- a/v1/wd_digest.c ++++ b/v1/wd_digest.c +@@ -30,8 +30,7 @@ + #include "wd_util.h" + + #define MAX_HMAC_KEY_SIZE 128 +-#define MAX_DIGEST_RETRY_CNT 2000000 +-#define DIGEST_SLEEP_INTERVAL 0xf ++#define MAX_DIGEST_RETRY_CNT 20000000 + #define SEC_SHA1_ALIGN_SZ 64 + #define SEC_SHA512_ALIGN_SZ 128 + +@@ -275,16 +274,18 @@ static int digest_recv_sync(struct wcrypto_digest_ctx *d_ctx, + while (true) { + ret = wd_burst_recv(d_ctx->q, (void **)(resp + recv_count), + num - recv_count); +- if (ret >= 0) { ++ if (ret > 0) { + recv_count += ret; + if (recv_count == num) + break; + +- if (++rx_cnt > MAX_DIGEST_RETRY_CNT) ++ rx_cnt = 0; ++ } else if (ret == 0) { ++ if (++rx_cnt > MAX_DIGEST_RETRY_CNT) { ++ WD_ERR("%s:wcrypto_recv timeout, num = %u, recv_count = %u!\n", ++ __func__, num, recv_count); + break; +- +- if (!(rx_cnt & DIGEST_SLEEP_INTERVAL)) +- usleep(1); ++ } + } else { + WD_ERR("do digest wcrypto_recv error!\n"); + return ret; +-- +2.25.1 + diff --git a/warpdrive.spec b/warpdrive.spec index fac12d3..977fd17 100644 --- a/warpdrive.spec +++ b/warpdrive.spec @@ -1,7 +1,7 @@ Name: libwd Summary: User Space Accelerator Development Kit Version: 2.3.21 -Release: 2 +Release: 3 License: Apache-2.0 Source: %{name}-%{version}.tar.gz Vendor: Huawei Corporation @@ -39,6 +39,41 @@ Patch0022: 0022-uadk-v1-delete-unused-parameter.patch Patch0023: 0023-uadk-env-fix-wd_add_task_to_async_queue-return-value.patch Patch0024: 0024-uadk-sched-fix-memory-leak.patch Patch0025: 0025-hisi-sec-bugfix-for-out_bytes-checking.patch +Patch0026: 0026-uadk-tools-modify-NO-SVA-test-scenario.patch +Patch0027: 0027-wd-fix-wd_parse_async_poll_num.patch +Patch0028: 0028-uadk-optimize-wd_init_async_polling_thread_per_numa.patch +Patch0029: 0029-uadk-env-fix-wd_add_task_to_async_queue.patch +Patch0030: 0030-uadk-optimize-find_async_queue.patch +Patch0031: 0031-uadk-fix-check_after_sink.patch +Patch0032: 0032-uadk-fix-wd_request_ctx.patch +Patch0033: 0033-uadk-fix-sched-params-begin-issue.patch +Patch0034: 0034-uadk-optimize-wd_request_ctx.patch +Patch0035: 0035-uadk-env-bugfix-for-wd_init_resource.patch +Patch0036: 0036-uadk-env-fix-wd-ctx-num-init.patch +Patch0037: 0037-uadk-modify-for-free-and-return.patch +Patch0038: 0038-uadk-include-fix-uadk-compatibility.patch +Patch0039: 0039-uadk-fix-for-resources-are-repeatedly-released.patch +Patch0040: 0040-aead-modify-the-aead-s-request-api.patch +Patch0041: 0041-cipher-add-semi-weak-keys-checking.patch +Patch0042: 0042-uadk-ioctl-return-result-should-be-printed.patch +Patch0043: 0043-uadk-fix-environment-uninit-repeatly-error.patch +Patch0044: 0044-uadk-fix-wd_free_ctx-and-wd_uninit_sched_config.patch +Patch0045: 0045-uadk-env-fix-free-ctx-table-memory-leak.patch +Patch0046: 0046-uadk-remove-uadk_benchmark-binary-and-header-file.patch +Patch0047: 0047-uadk-fix-for-wd_env_config-numa_num.patch +Patch0048: 0048-hisi-sec-add-some-dfx-information-in-comments.patch +Patch0049: 0049-hisi-sec-delete-some-dummy-parameter-checking.patch +Patch0050: 0050-hisi-qm-udrv-v1-deleted-a-dummy-branch.patch +Patch0051: 0051-hisi-sec-v1-update-the-SEC-BD1-mode-configuration.patch +Patch0052: 0052-uadk-optimize-algorithm-initialization.patch +Patch0053: 0053-uadk-fix-send-exception-handling.patch +Patch0054: 0054-uadk-sec-fix-hisi_sec_digest_send.patch +Patch0055: 0055-uadk-sec-some-clean-code.patch +Patch0056: 0056-uadk-optimize-wd_ctx_qfr_mmap.patch +Patch0057: 0057-uadk-optimize-wd_sched_rr_instance.patch +Patch0058: 0058-uadk-optimize-wd_get_accel_list.patch +Patch0059: 0059-uadk-fix-staic-check-warning.patch +Patch0060: 0060-uadk-v1-fix-the-waiting-time-for-receiving-task.patch %description This package contains the User Space Accelerator Library @@ -196,6 +231,9 @@ fi /sbin/ldconfig %changelog +* Mon Feb 21 2022 Yang Shen 2.3.21-3 +- libwd: backport the patch of uadk from 2.3.24 to 2.3.27 + * Tue Jan 04 2022 Yang Shen 2.3.21-2 - libwd: backport the patch of uadk from 2.3.21 to 2.3.24