[thirdparty/openssl.git] / crypto / info.c

/*
 * Copyright 2019-2020 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (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 <openssl/crypto.h>
#include "crypto/rand.h"
#include "crypto/dso_conf.h"
#include "internal/thread_once.h"
#include "internal/cryptlib.h"
#include "internal/e_os.h"
#include "buildinf.h"

#if defined(__arm__) || defined(__arm) || defined(__aarch64__)
# include "arm_arch.h"
# define CPU_INFO_STR_LEN 128
#elif defined(__s390__) || defined(__s390x__)
# include "s390x_arch.h"
# define CPU_INFO_STR_LEN 2048
#else
# define CPU_INFO_STR_LEN 128
#endif

/* extern declaration to avoid warning */
extern char ossl_cpu_info_str[];

static char *seed_sources = NULL;

char ossl_cpu_info_str[CPU_INFO_STR_LEN] = "";
#define CPUINFO_PREFIX "CPUINFO: "

static CRYPTO_ONCE init_info = CRYPTO_ONCE_STATIC_INIT;

DEFINE_RUN_ONCE_STATIC(init_info_strings)
{
#if defined(OPENSSL_CPUID_OBJ)
# if defined(__i386)   || defined(__i386__)   || defined(_M_IX86) || \
     defined(__x86_64) || defined(__x86_64__) || \
     defined(_M_AMD64) || defined(_M_X64)
    const char *env;

    BIO_snprintf(ossl_cpu_info_str, sizeof(ossl_cpu_info_str),
                 CPUINFO_PREFIX "OPENSSL_ia32cap=0x%llx:0x%llx",
                 (long long)OPENSSL_ia32cap_P[0] |
                 (long long)OPENSSL_ia32cap_P[1] << 32,
                 (long long)OPENSSL_ia32cap_P[2] |
                 (long long)OPENSSL_ia32cap_P[3] << 32);
    if ((env = getenv("OPENSSL_ia32cap")) != NULL)
        BIO_snprintf(ossl_cpu_info_str + strlen(ossl_cpu_info_str),
                     sizeof(ossl_cpu_info_str) - strlen(ossl_cpu_info_str),
                     " env:%s", env);
# elif defined(__arm__) || defined(__arm) || defined(__aarch64__)
    const char *env;

    BIO_snprintf(ossl_cpu_info_str, sizeof(ossl_cpu_info_str),
                 CPUINFO_PREFIX "OPENSSL_armcap=0x%x", OPENSSL_armcap_P);
    if ((env = getenv("OPENSSL_armcap")) != NULL)
        BIO_snprintf(ossl_cpu_info_str + strlen(ossl_cpu_info_str),
                     sizeof(ossl_cpu_info_str) - strlen(ossl_cpu_info_str),
                     " env:%s", env);
# elif defined(__s390__) || defined(__s390x__)
    const char *env;

    BIO_snprintf(ossl_cpu_info_str, sizeof(ossl_cpu_info_str),
                 CPUINFO_PREFIX "OPENSSL_s390xcap="
                 "stfle:0x%llx:0x%llx:0x%llx:0x%llx:"
                 "kimd:0x%llx:0x%llx:"
                 "klmd:0x%llx:0x%llx:"
                 "km:0x%llx:0x%llx:"
                 "kmc:0x%llx:0x%llx:"
                 "kmac:0x%llx:0x%llx:"
                 "kmctr:0x%llx:0x%llx:"
                 "kmo:0x%llx:0x%llx:"
                 "kmf:0x%llx:0x%llx:"
                 "prno:0x%llx:0x%llx:"
                 "kma:0x%llx:0x%llx:"
                 "pcc:0x%llx:0x%llx:"
                 "kdsa:0x%llx:0x%llx",
                 OPENSSL_s390xcap_P.stfle[0], OPENSSL_s390xcap_P.stfle[1],
                 OPENSSL_s390xcap_P.stfle[2], OPENSSL_s390xcap_P.stfle[3],
                 OPENSSL_s390xcap_P.kimd[0], OPENSSL_s390xcap_P.kimd[1],
                 OPENSSL_s390xcap_P.klmd[0], OPENSSL_s390xcap_P.klmd[1],
                 OPENSSL_s390xcap_P.km[0], OPENSSL_s390xcap_P.km[1],
                 OPENSSL_s390xcap_P.kmc[0], OPENSSL_s390xcap_P.kmc[1],
                 OPENSSL_s390xcap_P.kmac[0], OPENSSL_s390xcap_P.kmac[1],
                 OPENSSL_s390xcap_P.kmctr[0], OPENSSL_s390xcap_P.kmctr[1],
                 OPENSSL_s390xcap_P.kmo[0], OPENSSL_s390xcap_P.kmo[1],
                 OPENSSL_s390xcap_P.kmf[0], OPENSSL_s390xcap_P.kmf[1],
                 OPENSSL_s390xcap_P.prno[0], OPENSSL_s390xcap_P.prno[1],
                 OPENSSL_s390xcap_P.kma[0], OPENSSL_s390xcap_P.kma[1],
                 OPENSSL_s390xcap_P.pcc[0], OPENSSL_s390xcap_P.pcc[1],
                 OPENSSL_s390xcap_P.kdsa[0], OPENSSL_s390xcap_P.kdsa[1]);
    if ((env = getenv("OPENSSL_s390xcap")) != NULL)
        BIO_snprintf(ossl_cpu_info_str + strlen(ossl_cpu_info_str),
                     sizeof(ossl_cpu_info_str) - strlen(ossl_cpu_info_str),
                     " env:%s", env);
# endif
#endif

    {
        static char seeds[512] = "";

#define add_seeds_string(str)                                           \
        do {                                                            \
            if (seeds[0] != '\0')                                       \
                OPENSSL_strlcat(seeds, " ", sizeof(seeds));             \
            OPENSSL_strlcat(seeds, str, sizeof(seeds));                 \
        } while (0)
#define add_seeds_stringlist(label, strlist)                            \
        do {                                                            \
            add_seeds_string(label "(");                                \
            {                                                           \
                const char *dev[] =  { strlist, NULL };                 \
                const char **p;                                         \
                int first = 1;                                          \
                                                                        \
                for (p = dev; *p != NULL; p++) {                        \
                    if (!first)                                         \
                        OPENSSL_strlcat(seeds, " ", sizeof(seeds));     \
                    first = 0;                                          \
                    OPENSSL_strlcat(seeds, *p, sizeof(seeds));          \
                }                                                       \
            }                                                           \
            OPENSSL_strlcat(seeds, ")", sizeof(seeds));                 \
        } while (0)

#ifdef OPENSSL_RAND_SEED_NONE
        add_seeds_string("none");
#endif
#ifdef OPENSSL_RAND_SEED_RTDSC
        add_seeds_string("stdsc");
#endif
#ifdef OPENSSL_RAND_SEED_RDCPU
# ifdef __aarch64__
        add_seeds_string("rndr ( rndrrs rndr )");
# else
        add_seeds_string("rdrand ( rdseed rdrand )");
# endif
#endif
#ifdef OPENSSL_RAND_SEED_LIBRANDOM
        add_seeds_string("C-library-random");
#endif
#ifdef OPENSSL_RAND_SEED_GETRANDOM
        add_seeds_string("getrandom-syscall");
#endif
#ifdef OPENSSL_RAND_SEED_DEVRANDOM
        add_seeds_stringlist("random-device", DEVRANDOM);
#endif
#ifdef OPENSSL_RAND_SEED_EGD
        add_seeds_stringlist("EGD", DEVRANDOM_EGD);
#endif
#ifdef OPENSSL_RAND_SEED_OS
        add_seeds_string("os-specific");
#endif
        seed_sources = seeds;
    }
    return 1;
}

const char *OPENSSL_info(int t)
{
    /*
     * We don't care about the result.  Worst case scenario, the strings
     * won't be initialised, i.e. remain NULL, which means that the info
     * isn't available anyway...
     */
    (void)RUN_ONCE(&init_info, init_info_strings);

    switch (t) {
    case OPENSSL_INFO_CONFIG_DIR:
        return OPENSSLDIR;
    case OPENSSL_INFO_ENGINES_DIR:
        return ENGINESDIR;
    case OPENSSL_INFO_MODULES_DIR:
        return MODULESDIR;
    case OPENSSL_INFO_DSO_EXTENSION:
        return DSO_EXTENSION;
    case OPENSSL_INFO_DIR_FILENAME_SEPARATOR:
#if defined(_WIN32)
        return "\\";
#elif defined(__VMS)
        return "";
#else  /* Assume POSIX */
        return "/";
#endif
    case OPENSSL_INFO_LIST_SEPARATOR:
        {
            static const char list_sep[] = { LIST_SEPARATOR_CHAR, '\0' };
            return list_sep;
        }
    case OPENSSL_INFO_SEED_SOURCE:
        return seed_sources;
    case OPENSSL_INFO_CPU_SETTINGS:
        /*
         * If successfully initialized, ossl_cpu_info_str will start
         * with CPUINFO_PREFIX, if failed it will be an empty string.
         * Strip away the CPUINFO_PREFIX which we don't need here.
         */
        if (ossl_cpu_info_str[0] != '\0')
            return ossl_cpu_info_str + strlen(CPUINFO_PREFIX);
        break;
    default:
        break;
    }
    /* Not an error */
    return NULL;
}
Commit	Line	Data
0109e030	1	/*
33388b44	2	* Copyright 2019-2020 The OpenSSL Project Authors. All Rights Reserved.
0109e030 RL	3	*
	4	* Licensed under the Apache License 2.0 (the "License"). You may not use
	5	* this file except in compliance with the License. You can obtain a copy
	6	* in the file LICENSE in the source distribution or at
	7	* https://www.openssl.org/source/license.html
	8	*/
	9
0109e030	10	#include <openssl/crypto.h>
2e912f63	11	#include "crypto/rand.h"
25f2138b	12	#include "crypto/dso_conf.h"
363e941e BE	13	#include "internal/thread_once.h"
363e941e BE	14	#include "internal/cryptlib.h"
d5f9166b	15	#include "internal/e_os.h"
096978f0	16	#include "buildinf.h"
363e941e BE	17
	18	#if defined(__arm__) \|\| defined(__arm) \|\| defined(__aarch64__)
	19	# include "arm_arch.h"
b55a0b0f PS	20	# define CPU_INFO_STR_LEN 128
	21	#elif defined(__s390__) \|\| defined(__s390x__)
	22	# include "s390x_arch.h"
	23	# define CPU_INFO_STR_LEN 2048
	24	#else
	25	# define CPU_INFO_STR_LEN 128
363e941e BE	26	#endif
	27
	28	/* extern declaration to avoid warning */
	29	extern char ossl_cpu_info_str[];
096978f0 RL	30
096978f0 RL	31	static char *seed_sources = NULL;
363e941e	32
b55a0b0f	33	char ossl_cpu_info_str[CPU_INFO_STR_LEN] = "";
363e941e BE	34	#define CPUINFO_PREFIX "CPUINFO: "
363e941e BE	35
096978f0 RL	36	static CRYPTO_ONCE init_info = CRYPTO_ONCE_STATIC_INIT;
	37
	38	DEFINE_RUN_ONCE_STATIC(init_info_strings)
	39	{
363e941e BE	40	#if defined(OPENSSL_CPUID_OBJ)
	41	# if defined(__i386) \|\| defined(__i386__) \|\| defined(_M_IX86) \|\| \
	42	defined(__x86_64) \|\| defined(__x86_64__) \|\| \
	43	defined(_M_AMD64) \|\| defined(_M_X64)
	44	const char *env;
	45
	46	BIO_snprintf(ossl_cpu_info_str, sizeof(ossl_cpu_info_str),
	47	CPUINFO_PREFIX "OPENSSL_ia32cap=0x%llx:0x%llx",
	48	(long long)OPENSSL_ia32cap_P[0] \|
	49	(long long)OPENSSL_ia32cap_P[1] << 32,
	50	(long long)OPENSSL_ia32cap_P[2] \|
	51	(long long)OPENSSL_ia32cap_P[3] << 32);
	52	if ((env = getenv("OPENSSL_ia32cap")) != NULL)
	53	BIO_snprintf(ossl_cpu_info_str + strlen(ossl_cpu_info_str),
	54	sizeof(ossl_cpu_info_str) - strlen(ossl_cpu_info_str),
	55	" env:%s", env);
	56	# elif defined(__arm__) \|\| defined(__arm) \|\| defined(__aarch64__)
	57	const char *env;
	58
	59	BIO_snprintf(ossl_cpu_info_str, sizeof(ossl_cpu_info_str),
	60	CPUINFO_PREFIX "OPENSSL_armcap=0x%x", OPENSSL_armcap_P);
	61	if ((env = getenv("OPENSSL_armcap")) != NULL)
	62	BIO_snprintf(ossl_cpu_info_str + strlen(ossl_cpu_info_str),
	63	sizeof(ossl_cpu_info_str) - strlen(ossl_cpu_info_str),
	64	" env:%s", env);
b55a0b0f PS	65	# elif defined(__s390__) \|\| defined(__s390x__)
	66	const char *env;
	67
	68	BIO_snprintf(ossl_cpu_info_str, sizeof(ossl_cpu_info_str),
	69	CPUINFO_PREFIX "OPENSSL_s390xcap="
	70	"stfle:0x%llx:0x%llx:0x%llx:0x%llx:"
	71	"kimd:0x%llx:0x%llx:"
	72	"klmd:0x%llx:0x%llx:"
	73	"km:0x%llx:0x%llx:"
	74	"kmc:0x%llx:0x%llx:"
	75	"kmac:0x%llx:0x%llx:"
	76	"kmctr:0x%llx:0x%llx:"
	77	"kmo:0x%llx:0x%llx:"
	78	"kmf:0x%llx:0x%llx:"
	79	"prno:0x%llx:0x%llx:"
	80	"kma:0x%llx:0x%llx:"
	81	"pcc:0x%llx:0x%llx:"
	82	"kdsa:0x%llx:0x%llx",
	83	OPENSSL_s390xcap_P.stfle[0], OPENSSL_s390xcap_P.stfle[1],
	84	OPENSSL_s390xcap_P.stfle[2], OPENSSL_s390xcap_P.stfle[3],
	85	OPENSSL_s390xcap_P.kimd[0], OPENSSL_s390xcap_P.kimd[1],
	86	OPENSSL_s390xcap_P.klmd[0], OPENSSL_s390xcap_P.klmd[1],
	87	OPENSSL_s390xcap_P.km[0], OPENSSL_s390xcap_P.km[1],
	88	OPENSSL_s390xcap_P.kmc[0], OPENSSL_s390xcap_P.kmc[1],
	89	OPENSSL_s390xcap_P.kmac[0], OPENSSL_s390xcap_P.kmac[1],
	90	OPENSSL_s390xcap_P.kmctr[0], OPENSSL_s390xcap_P.kmctr[1],
	91	OPENSSL_s390xcap_P.kmo[0], OPENSSL_s390xcap_P.kmo[1],
	92	OPENSSL_s390xcap_P.kmf[0], OPENSSL_s390xcap_P.kmf[1],
	93	OPENSSL_s390xcap_P.prno[0], OPENSSL_s390xcap_P.prno[1],
	94	OPENSSL_s390xcap_P.kma[0], OPENSSL_s390xcap_P.kma[1],
	95	OPENSSL_s390xcap_P.pcc[0], OPENSSL_s390xcap_P.pcc[1],
	96	OPENSSL_s390xcap_P.kdsa[0], OPENSSL_s390xcap_P.kdsa[1]);
	97	if ((env = getenv("OPENSSL_s390xcap")) != NULL)
	98	BIO_snprintf(ossl_cpu_info_str + strlen(ossl_cpu_info_str),
	99	sizeof(ossl_cpu_info_str) - strlen(ossl_cpu_info_str),
	100	" env:%s", env);
363e941e BE	101	# endif
	102	#endif
	103
096978f0 RL	104	{
	105	static char seeds[512] = "";
	106
	107	#define add_seeds_string(str) \
	108	do { \
	109	if (seeds[0] != '\0') \
	110	OPENSSL_strlcat(seeds, " ", sizeof(seeds)); \
	111	OPENSSL_strlcat(seeds, str, sizeof(seeds)); \
	112	} while (0)
	113	#define add_seeds_stringlist(label, strlist) \
	114	do { \
	115	add_seeds_string(label "("); \
	116	{ \
9484b67d DMSP	117	const char *dev[] = { strlist, NULL }; \
9484b67d DMSP	118	const char **p; \
096978f0 RL	119	int first = 1; \
096978f0 RL	120	\
9484b67d	121	for (p = dev; *p != NULL; p++) { \
096978f0 RL	122	if (!first) \
	123	OPENSSL_strlcat(seeds, " ", sizeof(seeds)); \
	124	first = 0; \
9484b67d	125	OPENSSL_strlcat(seeds, *p, sizeof(seeds)); \
096978f0 RL	126	} \
	127	} \
	128	OPENSSL_strlcat(seeds, ")", sizeof(seeds)); \
	129	} while (0)
	130
	131	#ifdef OPENSSL_RAND_SEED_NONE
	132	add_seeds_string("none");
	133	#endif
	134	#ifdef OPENSSL_RAND_SEED_RTDSC
	135	add_seeds_string("stdsc");
	136	#endif
	137	#ifdef OPENSSL_RAND_SEED_RDCPU
eb28fda7 OT	138	# ifdef __aarch64__
	139	add_seeds_string("rndr ( rndrrs rndr )");
	140	# else
096978f0	141	add_seeds_string("rdrand ( rdseed rdrand )");
eb28fda7	142	# endif
096978f0 RL	143	#endif
	144	#ifdef OPENSSL_RAND_SEED_LIBRANDOM
	145	add_seeds_string("C-library-random");
	146	#endif
	147	#ifdef OPENSSL_RAND_SEED_GETRANDOM
	148	add_seeds_string("getrandom-syscall");
	149	#endif
	150	#ifdef OPENSSL_RAND_SEED_DEVRANDOM
9484b67d	151	add_seeds_stringlist("random-device", DEVRANDOM);
096978f0 RL	152	#endif
096978f0 RL	153	#ifdef OPENSSL_RAND_SEED_EGD
9484b67d	154	add_seeds_stringlist("EGD", DEVRANDOM_EGD);
096978f0 RL	155	#endif
	156	#ifdef OPENSSL_RAND_SEED_OS
	157	add_seeds_string("os-specific");
	158	#endif
	159	seed_sources = seeds;
	160	}
	161	return 1;
	162	}
0109e030 RL	163
	164	const char *OPENSSL_info(int t)
	165	{
096978f0 RL	166	/*
	167	* We don't care about the result. Worst case scenario, the strings
	168	* won't be initialised, i.e. remain NULL, which means that the info
	169	* isn't available anyway...
	170	*/
	171	(void)RUN_ONCE(&init_info, init_info_strings);
	172
0109e030 RL	173	switch (t) {
	174	case OPENSSL_INFO_CONFIG_DIR:
	175	return OPENSSLDIR;
	176	case OPENSSL_INFO_ENGINES_DIR:
	177	return ENGINESDIR;
	178	case OPENSSL_INFO_MODULES_DIR:
	179	return MODULESDIR;
	180	case OPENSSL_INFO_DSO_EXTENSION:
	181	return DSO_EXTENSION;
	182	case OPENSSL_INFO_DIR_FILENAME_SEPARATOR:
	183	#if defined(_WIN32)
	184	return "\\";
	185	#elif defined(__VMS)
	186	return "";
	187	#else /* Assume POSIX */
	188	return "/";
	189	#endif
	190	case OPENSSL_INFO_LIST_SEPARATOR:
	191	{
	192	static const char list_sep[] = { LIST_SEPARATOR_CHAR, '\0' };
	193	return list_sep;
	194	}
096978f0 RL	195	case OPENSSL_INFO_SEED_SOURCE:
096978f0 RL	196	return seed_sources;
363e941e BE	197	case OPENSSL_INFO_CPU_SETTINGS:
	198	/*
	199	* If successfully initialized, ossl_cpu_info_str will start
	200	* with CPUINFO_PREFIX, if failed it will be an empty string.
	201	* Strip away the CPUINFO_PREFIX which we don't need here.
	202	*/
	203	if (ossl_cpu_info_str[0] != '\0')
	204	return ossl_cpu_info_str + strlen(CPUINFO_PREFIX);
	205	break;
0109e030 RL	206	default:
	207	break;
	208	}
	209	/* Not an error */
	210	return NULL;
	211	}