| 1 | /*
|
|---|
| 2 | * Copyright 2007-2022 The OpenSSL Project Authors. All Rights Reserved.
|
|---|
| 3 | * Copyright Nokia 2007-2019
|
|---|
| 4 | * Copyright Siemens AG 2015-2019
|
|---|
| 5 | *
|
|---|
| 6 | * Licensed under the Apache License 2.0 (the "License"). You may not use
|
|---|
| 7 | * this file except in compliance with the License. You can obtain a copy
|
|---|
| 8 | * in the file LICENSE in the source distribution or at
|
|---|
| 9 | * https://www.openssl.org/source/license.html
|
|---|
| 10 | */
|
|---|
| 11 |
|
|---|
| 12 | #include <string.h>
|
|---|
| 13 | #include <openssl/cmp_util.h>
|
|---|
| 14 | #include "cmp_local.h" /* just for decls of internal functions defined here */
|
|---|
| 15 | #include <openssl/cmperr.h>
|
|---|
| 16 | #include <openssl/err.h> /* should be implied by cmperr.h */
|
|---|
| 17 | #include <openssl/x509v3.h>
|
|---|
| 18 |
|
|---|
| 19 | /*
|
|---|
| 20 | * use trace API for CMP-specific logging, prefixed by "CMP " and severity
|
|---|
| 21 | */
|
|---|
| 22 |
|
|---|
| 23 | int OSSL_CMP_log_open(void) /* is designed to be idempotent */
|
|---|
| 24 | {
|
|---|
| 25 | #ifdef OPENSSL_NO_TRACE
|
|---|
| 26 | return 1;
|
|---|
| 27 | #else
|
|---|
| 28 | # ifndef OPENSSL_NO_STDIO
|
|---|
| 29 | BIO *bio = BIO_new_fp(stdout, BIO_NOCLOSE);
|
|---|
| 30 |
|
|---|
| 31 | if (bio != NULL && OSSL_trace_set_channel(OSSL_TRACE_CATEGORY_CMP, bio))
|
|---|
| 32 | return 1;
|
|---|
| 33 | BIO_free(bio);
|
|---|
| 34 | # endif
|
|---|
| 35 | ERR_raise(ERR_LIB_CMP, CMP_R_NO_STDIO);
|
|---|
| 36 | return 0;
|
|---|
| 37 | #endif
|
|---|
| 38 | }
|
|---|
| 39 |
|
|---|
| 40 | void OSSL_CMP_log_close(void) /* is designed to be idempotent */
|
|---|
| 41 | {
|
|---|
| 42 | (void)OSSL_trace_set_channel(OSSL_TRACE_CATEGORY_CMP, NULL);
|
|---|
| 43 | }
|
|---|
| 44 |
|
|---|
| 45 | /* return >= 0 if level contains logging level, possibly preceded by "CMP " */
|
|---|
| 46 | #define max_level_len 5 /* = max length of the below strings, e.g., "EMERG" */
|
|---|
| 47 | static OSSL_CMP_severity parse_level(const char *level)
|
|---|
| 48 | {
|
|---|
| 49 | const char *end_level = strchr(level, ':');
|
|---|
| 50 | int len;
|
|---|
| 51 | char level_copy[max_level_len + 1];
|
|---|
| 52 |
|
|---|
| 53 | if (end_level == NULL)
|
|---|
| 54 | return -1;
|
|---|
| 55 |
|
|---|
| 56 | if (strncmp(level, OSSL_CMP_LOG_PREFIX,
|
|---|
| 57 | strlen(OSSL_CMP_LOG_PREFIX)) == 0)
|
|---|
| 58 | level += strlen(OSSL_CMP_LOG_PREFIX);
|
|---|
| 59 | len = end_level - level;
|
|---|
| 60 | if (len > max_level_len)
|
|---|
| 61 | return -1;
|
|---|
| 62 | OPENSSL_strlcpy(level_copy, level, len + 1);
|
|---|
| 63 | return
|
|---|
| 64 | strcmp(level_copy, "EMERG") == 0 ? OSSL_CMP_LOG_EMERG :
|
|---|
| 65 | strcmp(level_copy, "ALERT") == 0 ? OSSL_CMP_LOG_ALERT :
|
|---|
| 66 | strcmp(level_copy, "CRIT") == 0 ? OSSL_CMP_LOG_CRIT :
|
|---|
| 67 | strcmp(level_copy, "ERROR") == 0 ? OSSL_CMP_LOG_ERR :
|
|---|
| 68 | strcmp(level_copy, "WARN") == 0 ? OSSL_CMP_LOG_WARNING :
|
|---|
| 69 | strcmp(level_copy, "NOTE") == 0 ? OSSL_CMP_LOG_NOTICE :
|
|---|
| 70 | strcmp(level_copy, "INFO") == 0 ? OSSL_CMP_LOG_INFO :
|
|---|
| 71 | strcmp(level_copy, "DEBUG") == 0 ? OSSL_CMP_LOG_DEBUG :
|
|---|
| 72 | -1;
|
|---|
| 73 | }
|
|---|
| 74 |
|
|---|
| 75 | const char *ossl_cmp_log_parse_metadata(const char *buf,
|
|---|
| 76 | OSSL_CMP_severity *level,
|
|---|
| 77 | char **func, char **file, int *line)
|
|---|
| 78 | {
|
|---|
| 79 | const char *p_func = buf;
|
|---|
| 80 | const char *p_file = buf == NULL ? NULL : strchr(buf, ':');
|
|---|
| 81 | const char *p_level = buf;
|
|---|
| 82 | const char *msg = buf;
|
|---|
| 83 |
|
|---|
| 84 | *level = -1;
|
|---|
| 85 | *func = NULL;
|
|---|
| 86 | *file = NULL;
|
|---|
| 87 | *line = 0;
|
|---|
| 88 |
|
|---|
| 89 | if (p_file != NULL) {
|
|---|
| 90 | const char *p_line = strchr(++p_file, ':');
|
|---|
| 91 |
|
|---|
| 92 | if ((*level = parse_level(buf)) < 0 && p_line != NULL) {
|
|---|
| 93 | /* check if buf contains location info and logging level */
|
|---|
| 94 | char *p_level_tmp = (char *)p_level;
|
|---|
| 95 | const long line_number = strtol(++p_line, &p_level_tmp, 10);
|
|---|
| 96 |
|
|---|
| 97 | p_level = p_level_tmp;
|
|---|
| 98 | if (p_level > p_line && *(p_level++) == ':') {
|
|---|
| 99 | if ((*level = parse_level(p_level)) >= 0) {
|
|---|
| 100 | *func = OPENSSL_strndup(p_func, p_file - 1 - p_func);
|
|---|
| 101 | *file = OPENSSL_strndup(p_file, p_line - 1 - p_file);
|
|---|
| 102 | /* no real problem if OPENSSL_strndup() returns NULL */
|
|---|
| 103 | *line = (int)line_number;
|
|---|
| 104 | msg = strchr(p_level, ':');
|
|---|
| 105 | if (msg != NULL && *++msg == ' ')
|
|---|
| 106 | msg++;
|
|---|
| 107 | }
|
|---|
| 108 | }
|
|---|
| 109 | }
|
|---|
| 110 | }
|
|---|
| 111 | return msg;
|
|---|
| 112 | }
|
|---|
| 113 |
|
|---|
| 114 | #define UNKNOWN_FUNC "(unknown function)" /* the default for OPENSSL_FUNC */
|
|---|
| 115 | /*
|
|---|
| 116 | * substitute fallback if component/function name is NULL or empty or contains
|
|---|
| 117 | * just pseudo-information "(unknown function)" due to -pedantic and macros.h
|
|---|
| 118 | */
|
|---|
| 119 | static const char *improve_location_name(const char *func, const char *fallback)
|
|---|
| 120 | {
|
|---|
| 121 | if (fallback == NULL)
|
|---|
| 122 | return func == NULL ? UNKNOWN_FUNC : func;
|
|---|
| 123 |
|
|---|
| 124 | return func == NULL || *func == '\0' || strcmp(func, UNKNOWN_FUNC) == 0
|
|---|
| 125 | ? fallback : func;
|
|---|
| 126 | }
|
|---|
| 127 |
|
|---|
| 128 | int OSSL_CMP_print_to_bio(BIO *bio, const char *component, const char *file,
|
|---|
| 129 | int line, OSSL_CMP_severity level, const char *msg)
|
|---|
| 130 | {
|
|---|
| 131 | const char *level_string =
|
|---|
| 132 | level == OSSL_CMP_LOG_EMERG ? "EMERG" :
|
|---|
| 133 | level == OSSL_CMP_LOG_ALERT ? "ALERT" :
|
|---|
| 134 | level == OSSL_CMP_LOG_CRIT ? "CRIT" :
|
|---|
| 135 | level == OSSL_CMP_LOG_ERR ? "error" :
|
|---|
| 136 | level == OSSL_CMP_LOG_WARNING ? "warning" :
|
|---|
| 137 | level == OSSL_CMP_LOG_NOTICE ? "NOTE" :
|
|---|
| 138 | level == OSSL_CMP_LOG_INFO ? "info" :
|
|---|
| 139 | level == OSSL_CMP_LOG_DEBUG ? "DEBUG" : "(unknown level)";
|
|---|
| 140 |
|
|---|
| 141 | #ifndef NDEBUG
|
|---|
| 142 | if (BIO_printf(bio, "%s:%s:%d:", improve_location_name(component, "CMP"),
|
|---|
| 143 | file, line) < 0)
|
|---|
| 144 | return 0;
|
|---|
| 145 | #endif
|
|---|
| 146 | return BIO_printf(bio, OSSL_CMP_LOG_PREFIX"%s: %s\n",
|
|---|
| 147 | level_string, msg) >= 0;
|
|---|
| 148 | }
|
|---|
| 149 |
|
|---|
| 150 | #define ERR_PRINT_BUF_SIZE 4096
|
|---|
| 151 | /* this is similar to ERR_print_errors_cb, but uses the CMP-specific cb type */
|
|---|
| 152 | void OSSL_CMP_print_errors_cb(OSSL_CMP_log_cb_t log_fn)
|
|---|
| 153 | {
|
|---|
| 154 | unsigned long err;
|
|---|
| 155 | char msg[ERR_PRINT_BUF_SIZE];
|
|---|
| 156 | const char *file = NULL, *func = NULL, *data = NULL;
|
|---|
| 157 | int line, flags;
|
|---|
| 158 |
|
|---|
| 159 | while ((err = ERR_get_error_all(&file, &line, &func, &data, &flags)) != 0) {
|
|---|
| 160 | const char *component =
|
|---|
| 161 | improve_location_name(func, ERR_lib_error_string(err));
|
|---|
| 162 | unsigned long reason = ERR_GET_REASON(err);
|
|---|
| 163 | const char *rs = NULL;
|
|---|
| 164 | char rsbuf[256];
|
|---|
| 165 |
|
|---|
| 166 | #ifndef OPENSSL_NO_ERR
|
|---|
| 167 | if (ERR_SYSTEM_ERROR(err)) {
|
|---|
| 168 | if (openssl_strerror_r(reason, rsbuf, sizeof(rsbuf)))
|
|---|
| 169 | rs = rsbuf;
|
|---|
| 170 | } else {
|
|---|
| 171 | rs = ERR_reason_error_string(err);
|
|---|
| 172 | }
|
|---|
| 173 | #endif
|
|---|
| 174 | if (rs == NULL) {
|
|---|
| 175 | BIO_snprintf(rsbuf, sizeof(rsbuf), "reason(%lu)", reason);
|
|---|
| 176 | rs = rsbuf;
|
|---|
| 177 | }
|
|---|
| 178 | if (data != NULL && (flags & ERR_TXT_STRING) != 0)
|
|---|
| 179 | BIO_snprintf(msg, sizeof(msg), "%s:%s", rs, data);
|
|---|
| 180 | else
|
|---|
| 181 | BIO_snprintf(msg, sizeof(msg), "%s", rs);
|
|---|
| 182 |
|
|---|
| 183 | if (log_fn == NULL) {
|
|---|
| 184 | #ifndef OPENSSL_NO_STDIO
|
|---|
| 185 | BIO *bio = BIO_new_fp(stderr, BIO_NOCLOSE);
|
|---|
| 186 |
|
|---|
| 187 | if (bio != NULL) {
|
|---|
| 188 | OSSL_CMP_print_to_bio(bio, component, file, line,
|
|---|
| 189 | OSSL_CMP_LOG_ERR, msg);
|
|---|
| 190 | BIO_free(bio);
|
|---|
| 191 | }
|
|---|
| 192 | #else
|
|---|
| 193 | /* ERR_raise(ERR_LIB_CMP, CMP_R_NO_STDIO) makes no sense during error printing */
|
|---|
| 194 | #endif
|
|---|
| 195 | } else {
|
|---|
| 196 | if (log_fn(component, file, line, OSSL_CMP_LOG_ERR, msg) <= 0)
|
|---|
| 197 | break; /* abort outputting the error report */
|
|---|
| 198 | }
|
|---|
| 199 | }
|
|---|
| 200 | }
|
|---|
| 201 |
|
|---|
| 202 | int ossl_cmp_X509_STORE_add1_certs(X509_STORE *store, STACK_OF(X509) *certs,
|
|---|
| 203 | int only_self_signed)
|
|---|
| 204 | {
|
|---|
| 205 | int i;
|
|---|
| 206 |
|
|---|
| 207 | if (store == NULL) {
|
|---|
| 208 | ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
|
|---|
| 209 | return 0;
|
|---|
| 210 | }
|
|---|
| 211 | if (certs == NULL)
|
|---|
| 212 | return 1;
|
|---|
| 213 | for (i = 0; i < sk_X509_num(certs); i++) {
|
|---|
| 214 | X509 *cert = sk_X509_value(certs, i);
|
|---|
| 215 |
|
|---|
| 216 | if (!only_self_signed || X509_self_signed(cert, 0) == 1)
|
|---|
| 217 | if (!X509_STORE_add_cert(store, cert)) /* ups cert ref counter */
|
|---|
| 218 | return 0;
|
|---|
| 219 | }
|
|---|
| 220 | return 1;
|
|---|
| 221 | }
|
|---|
| 222 |
|
|---|
| 223 | int ossl_cmp_sk_ASN1_UTF8STRING_push_str(STACK_OF(ASN1_UTF8STRING) *sk,
|
|---|
| 224 | const char *text, int len)
|
|---|
| 225 | {
|
|---|
| 226 | ASN1_UTF8STRING *utf8string;
|
|---|
| 227 |
|
|---|
| 228 | if (!ossl_assert(sk != NULL && text != NULL))
|
|---|
| 229 | return 0;
|
|---|
| 230 | if ((utf8string = ASN1_UTF8STRING_new()) == NULL)
|
|---|
| 231 | return 0;
|
|---|
| 232 | if (!ASN1_STRING_set(utf8string, text, len))
|
|---|
| 233 | goto err;
|
|---|
| 234 | if (!sk_ASN1_UTF8STRING_push(sk, utf8string))
|
|---|
| 235 | goto err;
|
|---|
| 236 | return 1;
|
|---|
| 237 |
|
|---|
| 238 | err:
|
|---|
| 239 | ASN1_UTF8STRING_free(utf8string);
|
|---|
| 240 | return 0;
|
|---|
| 241 | }
|
|---|
| 242 |
|
|---|
| 243 | int ossl_cmp_asn1_octet_string_set1(ASN1_OCTET_STRING **tgt,
|
|---|
| 244 | const ASN1_OCTET_STRING *src)
|
|---|
| 245 | {
|
|---|
| 246 | ASN1_OCTET_STRING *new;
|
|---|
| 247 | if (tgt == NULL) {
|
|---|
| 248 | ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
|
|---|
| 249 | return 0;
|
|---|
| 250 | }
|
|---|
| 251 | if (*tgt == src) /* self-assignment */
|
|---|
| 252 | return 1;
|
|---|
| 253 |
|
|---|
| 254 | if (src != NULL) {
|
|---|
| 255 | if ((new = ASN1_OCTET_STRING_dup(src)) == NULL)
|
|---|
| 256 | return 0;
|
|---|
| 257 | } else {
|
|---|
| 258 | new = NULL;
|
|---|
| 259 | }
|
|---|
| 260 |
|
|---|
| 261 | ASN1_OCTET_STRING_free(*tgt);
|
|---|
| 262 | *tgt = new;
|
|---|
| 263 | return 1;
|
|---|
| 264 | }
|
|---|
| 265 |
|
|---|
| 266 | int ossl_cmp_asn1_octet_string_set1_bytes(ASN1_OCTET_STRING **tgt,
|
|---|
| 267 | const unsigned char *bytes, int len)
|
|---|
| 268 | {
|
|---|
| 269 | ASN1_OCTET_STRING *new = NULL;
|
|---|
| 270 |
|
|---|
| 271 | if (tgt == NULL) {
|
|---|
| 272 | ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
|
|---|
| 273 | return 0;
|
|---|
| 274 | }
|
|---|
| 275 | if (bytes != NULL) {
|
|---|
| 276 | if ((new = ASN1_OCTET_STRING_new()) == NULL
|
|---|
| 277 | || !(ASN1_OCTET_STRING_set(new, bytes, len))) {
|
|---|
| 278 | ASN1_OCTET_STRING_free(new);
|
|---|
| 279 | return 0;
|
|---|
| 280 | }
|
|---|
| 281 | }
|
|---|
| 282 |
|
|---|
| 283 | ASN1_OCTET_STRING_free(*tgt);
|
|---|
| 284 | *tgt = new;
|
|---|
| 285 | return 1;
|
|---|
| 286 | }
|
|---|
