crypto/pem/pem_all.c \
	crypto/pem/pem_x509.c \
	crypto/pem/pem_seal.c \
	crypto/pem/pem_pk8.c \
	crypto/pem/pvkfmt.c \
	crypto/pem/pem_info.c \
	crypto/pem/pem_pkey.c \
	crypto/ecdh/ecdh_kdf.c \
	crypto/ecdh/ech_lib.c \
	crypto/ecdh/ech_key.c \
	crypto/ecdh/ech_err.c \
	crypto/ts/ts_rsp_verify.c \
	crypto/ts/ts_rsp_print.c \
	crypto/ts/ts_verify_ctx.c \
	crypto/ts/ts_req_utils.c \

	$(LOCAL_PATH)/include/compat \
	$(LOCAL_PATH)/crypto \
	$(LOCAL_PATH)/crypto/compat \
	$(LOCAL_PATH)/crypto/asn1 \
	$(LOCAL_PATH)/crypto/bn \
	$(LOCAL_PATH)/crypto/evp \
	$(LOCAL_PATH)/crypto/ec \
	$(LOCAL_PATH)/crypto/ecdh \
	$(LOCAL_PATH)/crypto/ecdsa \
	$(LOCAL_PATH)/crypto/modes

LOCAL_CFLAGS := \
	-DLIBRESSL_INTERNAL \
	-DOPENSSL_NO_HW_PADLOCK \
	-DOPENSSL_NO_ASM \

endif()

if(WIN32)
	add_definitions(-Drestrict)
	add_definitions(-D_CRT_SECURE_NO_WARNINGS)
	add_definitions(-D_CRT_DEPRECATED_NO_WARNINGS)
	add_definitions(-D_REENTRANT -D_POSIX_THREAD_SAFE_FUNCTIONS)
	add_definitions(-DWIN32_LEAN_AND_MEAN -D_WIN32_WINNT=0x0600)
	add_definitions(-DCPPFLAGS -DNO_SYSLOG -DNO_CRYPT)
	set(PLATFORM_LIBS ${PLATFORM_LIBS} ws2_32)
endif()

if(MSVC)
	add_definitions(-Dinline=__inline)
	message(STATUS "Using [${CMAKE_C_COMPILER_ID}] compiler")
	if(CMAKE_C_COMPILER_ID MATCHES "MSVC")

		elseif("${CMAKE_SYSTEM_PROCESSOR}" MATCHES "arm")
			set(HOST_ASM_ELF_ARMV4 true)
		elseif(CMAKE_SYSTEM_NAME STREQUAL "SunOS" AND "${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "i386")
			set(HOST_ASM_ELF_X86_64 true)
		endif()
	elseif(APPLE AND "${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "x86_64")
		set(HOST_ASM_MACOSX_X86_64 true)
	elseif(MSVC AND "${CMAKE_GENERATOR}" MATCHES "Win64")



		set(HOST_ASM_MASM_X86_64 true)
		ENABLE_LANGUAGE(ASM_MASM)
	elseif(CMAKE_SYSTEM_NAME MATCHES "MINGW" AND "${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "x86_64")
		set(HOST_ASM_MINGW64_X86_64 true)
	endif()
endif()

if(NOT MSVC)
	# Create pkgconfig files.
	set(prefix      ${CMAKE_INSTALL_PREFIX})
	set(exec_prefix \${prefix})
	set(libdir      \${exec_prefix}/${CMAKE_INSTALL_LIBDIR})
	set(includedir  \${prefix}/include)
	if(PLATFORM_LIBS)
		string(REGEX REPLACE ";" " -l" PLATFORM_LDADD ";${PLATFORM_LIBS}")
	endif()
	file(STRINGS    "VERSION" VERSION LIMIT_COUNT 1)
	file(GLOB       OPENSSL_PKGCONFIGS "*.pc.in")
	foreach(file ${OPENSSL_PKGCONFIGS})
		get_filename_component(filename ${file} NAME)
		string(REPLACE ".in" "" new_file "${filename}")
		configure_file(${filename} pkgconfig/${new_file} @ONLY)
	endforeach()
	install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/pkgconfig
		DESTINATION ${CMAKE_INSTALL_LIBDIR})
endif()

if(NOT TARGET uninstall)
	configure_file(
		"${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
		"${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
		IMMEDIATE @ONLY)

	add_custom_target(uninstall
		COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
endif()

The portable bits of the project are largely maintained out-of-tree, and their
history is also available from Git.

	https://github.com/libressl-portable/portable

LibreSSL Portable Release Notes:

3.0.2 - Stable release

	* Use a valid curve when constructing an EC_KEY that looks like X25519.
	  The recent EC group cofactor change results in stricter validation,
	  which causes the EC_GROUP_set_generator() call to fail.
	  Issue reported and fix tested by rsadowski@

	* Fixed a padding oracle in PKCS7_dataDecode and CMS_decrypt_set1_pkey.
	  (Note that the CMS code is currently disabled)
	  Port of Edlinger's Fix for CVE-2019-1563 from OpenSSL 1.1.1 (old license) 

	* Avoid a path traversal bug in s_server on Windows when run with the -WWW
	  or -HTTP options, due to incomplete path check logic.
	  Issue reported and fix tested by Jobert Abma

3.0.1 - Development release

	* Ported Billy Brumley's fix for CVE-2019-1547 in OpenSSL 1.1.1. If a NULL
	  or zero cofactor is passed to EC_GROUP_set_generator(), try to compute
	  it using Hasse's bound. This works as long as the cofactor is small
	  enough.

	* Fixed a memory leak in error paths for eckey_type2param().

	* Initial work on supporting Cryptographic Message Syntax (CMS) in
	  libcrypto (not enabled).

	* Various manual page improvements and additions.

	* Added a CMake check for an existing uninstall target, facilitating
	  embedding LibreSSL in larger CMake projects, from Matthew Albrecht.

3.0.0 - Development release

	* Completed the port of RSA_METHOD accessors from the OpenSSL 1.1 API.

	* Documented undescribed options and removed unfunctional options
	  description in openssl(1) manual.

	* A plethora of small fixes due to regular oss-fuzz testing.

	* Various side channels in DSA and ECDSA were addressed.  These are some of
	  the many issues found in an extensive systematic analysis of bignum usage
	  by Samuel Weiser, David Schrammel et al.

	* Enabled openssl(1) speed subcommand on Windows platform.

	* Enabled performance optimizations when building with Visual Studio on Windows.

	* Fixed incorrect carry operation in 512 addition for Streebog.

	* Fixed -modulus option with openssl(1) dsa subcommand.

	* Fixed PVK format output issue with openssl(1) dsa and rsa subcommand.

2.9.2 - Bug fixes

	* Fixed portable builds with older versions of MacOS,
	  Android targets < API 21, and Solaris 10

	* Fixed SRTP profile advertisement for DTLS servers.

![LibreSSL image](https://www.libressl.org/images/libressl.jpg)
## Official portable version of [LibreSSL](https://www.libressl.org) ##

[![Build Status](https://travis-ci.org/libressl-portable/portable.svg?branch=master)](https://travis-ci.org/libressl-portable/portable)

LibreSSL is a fork of [OpenSSL](https://www.openssl.org) 1.0.1g developed by the
[OpenBSD](https://www.openbsd.org) project.  Our goal is to modernize the codebase,
improve security, and apply best practice development processes from OpenBSD.

## Compatibility with OpenSSL: ##

3.0.2

/* $OpenBSD: netcat.c,v 1.206 2019/08/08 16:49:35 mestre Exp $ */
/*
 * Copyright (c) 2001 Eric Jackson <ericj@monkey.org>
 * Copyright (c) 2015 Bob Beck.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:

			if (unveil(host, "rwc") == -1)
				err(1, "unveil");
			if (uflag && !lflag) {
				if (unveil(sflag ? sflag : "/tmp", "rwc") == -1)
					err(1, "unveil");
			}
		} else {
			/* no filesystem visibility */
			if (unveil("/", "") == -1)
				err(1, "unveil");
		}
	}

	if (family == AF_UNIX) {
		if (pledge("stdio rpath wpath cpath tmppath unix", NULL) == -1)

		/* Allow only one connection at a time, but stay alive. */
		for (;;) {
			if (family != AF_UNIX) {
				if (s != -1)
					close(s);
				s = local_listen(host, uport, hints);
			}
			if (s == -1)
				err(1, NULL);
			if (uflag && kflag) {
				/*
				 * For UDP and -k, don't connect the socket,
				 * let it receive datagrams from multiple
				 * socket pairs.
				 */

				int rv;
				char buf[2048];
				struct sockaddr_storage z;

				len = sizeof(z);
				rv = recvfrom(s, buf, sizeof(buf), MSG_PEEK,
				    (struct sockaddr *)&z, &len);
				if (rv == -1)
					err(1, "recvfrom");

				rv = connect(s, (struct sockaddr *)&z, len);
				if (rv == -1)
					err(1, "connect");

				if (vflag)
					report_sock("Connection received",
					    (struct sockaddr *)&z, len, NULL);

				readwrite(s, NULL);

					readwrite(connfd, NULL);
				if (tls_cctx)
					timeout_tls(s, tls_cctx, tls_close);
				close(connfd);
				tls_free(tls_cctx);
			}
			if (family == AF_UNIX && uflag) {
				if (connect(s, NULL, 0) == -1)
					err(1, "connect");
			}

			if (!kflag)
				break;
		}
	} else if (family == AF_UNIX) {

unix_bind(char *path, int flags)
{
	struct sockaddr_un s_un;
	int s, save_errno;

	/* Create unix domain socket. */
	if ((s = socket(AF_UNIX, flags | (uflag ? SOCK_DGRAM : SOCK_STREAM),
	    0)) == -1)
		return -1;

	memset(&s_un, 0, sizeof(struct sockaddr_un));
	s_un.sun_family = AF_UNIX;

	if (strlcpy(s_un.sun_path, path, sizeof(s_un.sun_path)) >=
	    sizeof(s_un.sun_path)) {
		close(s);
		errno = ENAMETOOLONG;
		return -1;
	}

	if (bind(s, (struct sockaddr *)&s_un, sizeof(s_un)) == -1) {
		save_errno = errno;
		close(s);
		errno = save_errno;
		return -1;
	}
	if (vflag)
		report_sock("Bound", NULL, 0, path);

int
unix_connect(char *path)
{
	struct sockaddr_un s_un;
	int s, save_errno;

	if (uflag) {
		if ((s = unix_bind(unix_dg_tmp_socket, SOCK_CLOEXEC)) == -1)
			return -1;
	} else {
		if ((s = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0)) == -1)
			return -1;
	}

	memset(&s_un, 0, sizeof(struct sockaddr_un));
	s_un.sun_family = AF_UNIX;

	if (strlcpy(s_un.sun_path, path, sizeof(s_un.sun_path)) >=
	    sizeof(s_un.sun_path)) {
		close(s);
		errno = ENAMETOOLONG;
		return -1;
	}
	if (connect(s, (struct sockaddr *)&s_un, sizeof(s_un)) == -1) {
		save_errno = errno;
		close(s);
		errno = save_errno;
		return -1;
	}
	return s;

}

/*
 * unix_listen()
 * Create a unix domain socket, and listen on it.
 */
int
unix_listen(char *path)
{
	int s;

	if ((s = unix_bind(path, 0)) == -1)
		return -1;
	if (listen(s, 5) == -1) {
		close(s);
		return -1;
	}
	if (vflag)
		report_sock("Listening", NULL, 0, path);

	return s;

	if ((error = getaddrinfo(host, port, &hints, &res0)))
		errx(1, "getaddrinfo for host \"%s\" port %s: %s", host,
		    port, gai_strerror(error));

	for (res = res0; res; res = res->ai_next) {
		if ((s = socket(res->ai_family, res->ai_socktype |
		    SOCK_NONBLOCK, res->ai_protocol)) == -1)
			continue;

		/* Bind to a local port or source address if specified. */
		if (sflag || pflag) {
			struct addrinfo ahints, *ares;

#ifdef SO_BINDANY
			/* try SO_BINDANY, but don't insist */
			setsockopt(s, SOL_SOCKET, SO_BINDANY, &on, sizeof(on));
#endif
			memset(&ahints, 0, sizeof(struct addrinfo));
			ahints.ai_family = res->ai_family;
			ahints.ai_socktype = uflag ? SOCK_DGRAM : SOCK_STREAM;
			ahints.ai_protocol = uflag ? IPPROTO_UDP : IPPROTO_TCP;
			ahints.ai_flags = AI_PASSIVE;
			if ((error = getaddrinfo(sflag, pflag, &ahints, &ares)))
				errx(1, "getaddrinfo: %s", gai_strerror(error));

			if (bind(s, (struct sockaddr *)ares->ai_addr,
			    ares->ai_addrlen) == -1)
				err(1, "bind failed");
			freeaddrinfo(ares);
		}

		set_common_sockopts(s, res->ai_family);

		if (timeout_connect(s, res->ai_addr, res->ai_addrlen) == 0)

		hints.ai_family = AF_INET;

	if ((error = getaddrinfo(host, port, &hints, &res0)))
		errx(1, "getaddrinfo: %s", gai_strerror(error));

	for (res = res0; res; res = res->ai_next) {
		if ((s = socket(res->ai_family, res->ai_socktype,
		    res->ai_protocol)) == -1)
			continue;

#ifdef SO_REUSEPORT
		ret = setsockopt(s, SOL_SOCKET, SO_REUSEPORT, &x, sizeof(x));
		if (ret == -1)
			err(1, NULL);
#endif

		save_errno = errno;
		close(s);
		errno = save_errno;
		s = -1;
	}

	if (!uflag && s != -1) {
		if (listen(s, 1) == -1)
			err(1, "listen");
	}
	if (vflag && s != -1) {
		struct sockaddr_storage ss;
		socklen_t len;

		len = sizeof(ss);

		 * Initialize portlist with a random permutation.  Based on
		 * Knuth, as in ip_randomid() in sys/netinet/ip_id.c.
		 */
		if (rflag) {
			for (x = 0; x <= hi - lo; x++) {
				cp = arc4random_uniform(x + 1);
				portlist[x] = portlist[cp];
				if (asprintf(&portlist[cp], "%d", x + lo) == -1)
					err(1, "asprintf");
			}
		} else { /* Load ports sequentially. */
			for (cp = lo; cp <= hi; cp++) {
				if (asprintf(&portlist[x], "%d", cp) == -1)
					err(1, "asprintf");
				x++;
			}
		}
	} else {
		char *tmp;

/*	$OpenBSD: socks.c,v 1.29 2019/07/29 15:19:03 benno Exp $	*/

/*
 * Copyright (c) 1999 Niklas Hallqvist.  All rights reserved.
 * Copyright (c) 2004, 2005 Damien Miller.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions

			    "CONNECT [%s]:%d HTTP/1.0\r\n",
			    host, ntohs(serverport));
		} else {
			r = snprintf(buf, sizeof(buf),
			    "CONNECT %s:%d HTTP/1.0\r\n",
			    host, ntohs(serverport));
		}
		if (r < 0 || (size_t)r >= sizeof(buf))
			errx(1, "hostname too long");
		r = strlen(buf);

		cnt = atomicio(vwrite, proxyfd, buf, r);
		if (cnt != r)
			err(1, "write failed (%zu/%d)", cnt, r);

			explicit_bzero(proxypass, sizeof proxypass);
			if (r == -1 || (size_t)r >= sizeof(buf) ||
			    b64_ntop(buf, strlen(buf), resp,
			    sizeof(resp)) == -1)
				errx(1, "Proxy username/password too long");
			r = snprintf(buf, sizeof(buf), "Proxy-Authorization: "
			    "Basic %s\r\n", resp);
			if (r < 0 || (size_t)r >= sizeof(buf))
				errx(1, "Proxy auth response too long");
			r = strlen(buf);
			if ((cnt = atomicio(vwrite, proxyfd, buf, r)) != r)
				err(1, "write failed (%zu/%d)", cnt, r);
			explicit_bzero(proxypass, sizeof proxypass);
			explicit_bzero(buf, sizeof buf);
		}

		/* Terminate headers */
		if ((cnt = atomicio(vwrite, proxyfd, "\r\n", 2)) != 2)
			err(1, "write failed (%zu/2)", cnt);

		/* Read status reply */
		proxy_read_line(proxyfd, buf, sizeof(buf));
		if (proxyuser != NULL &&
		    (strncmp(buf, "HTTP/1.0 407 ", 12) == 0 ||
		    strncmp(buf, "HTTP/1.1 407 ", 12) == 0)) {
			if (authretry > 1) {
				fprintf(stderr, "Proxy authentication "
				    "failed\n");
			}
			close(proxyfd);
			goto again;
		} else if (strncmp(buf, "HTTP/1.0 200 ", 12) != 0 &&

/*	$Id: http.c,v 1.12 2019/06/28 13:32:49 deraadt Exp $ */
/*
 * Copyright (c) 2016 Kristaps Dzonsons <kristaps@bsd.lv>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *

static ssize_t
dosysread(char *buf, size_t sz, const struct http *http)
{
	ssize_t	 rc;

	rc = read(http->fd, buf, sz);
	if (rc == -1)
		warn("%s: read", http->src.ip);
	return rc;
}

static ssize_t
dosyswrite(const void *buf, size_t sz, const struct http *http)
{
	ssize_t	 rc;

	rc = write(http->fd, buf, sz);
	if (rc == -1)
		warn("%s: write", http->src.ip);
	return rc;
}

static ssize_t
dotlsread(char *buf, size_t sz, const struct http *http)
{
	ssize_t	 rc;

	do {
		rc = tls_read(http->ctx, buf, sz);
	} while (rc == TLS_WANT_POLLIN || rc == TLS_WANT_POLLOUT);

	if (rc == -1)
		warnx("%s: tls_read: %s", http->src.ip,
		    tls_error(http->ctx));
	return rc;
}

static ssize_t
dotlswrite(const void *buf, size_t sz, const struct http *http)
{
	ssize_t	 rc;

	do {
		rc = tls_write(http->ctx, buf, sz);
	} while (rc == TLS_WANT_POLLIN || rc == TLS_WANT_POLLOUT);

	if (rc == -1)
		warnx("%s: tls_write: %s", http->src.ip,
		    tls_error(http->ctx));
	return rc;
}

int
http_init()

/* $OpenBSD: ocspcheck.c,v 1.25 2019/05/15 13:44:18 bcook Exp $ */

/*
 * Copyright (c) 2017 Bob Beck <beck@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.

	}

	/*
	 * If we have been given a place to save a staple,
	 * write out the DER format response to the staplefd
	 */
	if (staplefd >= 0) {
		while (ftruncate(staplefd, 0) < 0)
			if (errno != EINTR && errno != EAGAIN)
				err(1, "Write of OCSP response failed");
		w = 0;
		written = 0;
		while (written < instaplesz) {
			w = write(staplefd, instaple + written,
			    instaplesz - written);
			if (w == -1) {
				if (errno != EINTR && errno != EAGAIN)

/* $OpenBSD: apps.c,v 1.54 2019/07/14 03:30:45 guenther Exp $ */
/*
 * Copyright (c) 2014 Joel Sing <jsing@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *

	ASN1_INTEGER *ai = NULL;

	if (suffix == NULL)
		n = strlcpy(serialpath, serialfile, sizeof serialpath);
	else
		n = snprintf(serialpath, sizeof serialpath, "%s.%s",
		    serialfile, suffix);
	if (n < 0 || n >= sizeof(serialpath)) {
		BIO_printf(bio_err, "serial too long\n");
		goto err;
	}
	out = BIO_new(BIO_s_file());
	if (out == NULL) {
		ERR_print_errors(bio_err);
		goto err;

	if (snprintf(opath, sizeof opath, "%s.%s", serialfile,
	    old_suffix) >= sizeof opath) {
		BIO_printf(bio_err, "file name too long\n");
		goto err;
	}

	if (rename(serialfile, opath) == -1 &&
	    errno != ENOENT && errno != ENOTDIR) {
		BIO_printf(bio_err, "unable to rename %s to %s\n",
		    serialfile, opath);
		perror("reason");
		goto err;
	}


	if (rename(npath, serialfile) == -1) {
		BIO_printf(bio_err, "unable to rename %s to %s\n",
		    npath, serialfile);
		perror("reason");
		if (rename(opath, serialfile) == -1) {
			BIO_printf(bio_err, "unable to rename %s to %s\n",
			    opath, serialfile);
			perror("reason");
		}
		goto err;
	}
	return 1;

	}
	if (snprintf(odbpath, sizeof odbpath, "%s.%s",
	    dbfile, old_suffix) >= sizeof odbpath) {
		BIO_printf(bio_err, "file name too long\n");
		goto err;
	}

	if (rename(dbfile, odbpath) == -1 && errno != ENOENT && errno != ENOTDIR) {
		BIO_printf(bio_err, "unable to rename %s to %s\n",
		    dbfile, odbpath);
		perror("reason");
		goto err;
	}

	if (rename(dbpath, dbfile) == -1) {
		BIO_printf(bio_err, "unable to rename %s to %s\n",
		    dbpath, dbfile);
		perror("reason");
		if (rename(odbpath, dbfile) == -1) {
			BIO_printf(bio_err, "unable to rename %s to %s\n",
			    odbpath, dbfile);
			perror("reason");
		}
		goto err;
	}

	if (rename(attrpath, oattrpath) == -1 && errno != ENOENT && errno != ENOTDIR) {
		BIO_printf(bio_err, "unable to rename %s to %s\n",
		    attrpath, oattrpath);
		perror("reason");
		if (rename(dbfile, dbpath) == -1) {
			BIO_printf(bio_err, "unable to rename %s to %s\n",
			    dbfile, dbpath);
			perror("reason");
		}
		if (rename(odbpath, dbfile) == -1) {
			BIO_printf(bio_err, "unable to rename %s to %s\n",
			    odbpath, dbfile);
			perror("reason");
		}
		goto err;
	}

	if (rename(nattrpath, attrpath) == -1) {
		BIO_printf(bio_err, "unable to rename %s to %s\n",
		    nattrpath, attrpath);
		perror("reason");
		if (rename(oattrpath, attrpath) == -1) {
			BIO_printf(bio_err, "unable to rename %s to %s\n",
			    oattrpath, attrpath);
			perror("reason");
		}
		if (rename(dbfile, dbpath) == -1) {
			BIO_printf(bio_err, "unable to rename %s to %s\n",
			    dbfile, dbpath);
			perror("reason");
		}
		if (rename(odbpath, dbfile) == -1) {
			BIO_printf(bio_err, "unable to rename %s to %s\n",
			    odbpath, dbfile);
			perror("reason");
		}
		goto err;
	}
	return 1;

		return S_ISDIR(st.st_mode);
	return -1;
}

#define OPTION_WIDTH 18

void
options_usage(const struct option *opts)
{
	const char *p, *q;
	char optstr[32];
	int i;

	for (i = 0; opts[i].name != NULL; i++) {
		if (opts[i].desc == NULL)

			p = q + 1;
		}
		fprintf(stderr, " %s\n", p);
	}
}

int
options_parse(int argc, char **argv, const struct option *opts, char **unnamed,
    int *argsused)
{
	const char *errstr;
	const struct option *opt;
	long long val;
	char *arg, *p;
	int fmt, used;
	int ord = 0;
	int i, j;

	if (unnamed != NULL)

/* $OpenBSD: apps.h,v 1.23 2019/07/14 03:30:45 guenther Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *

		long *lvalue;
		int *value;
		time_t *tvalue;
	} opt;
	const int value;
};

void options_usage(const struct option *opts);
int options_parse(int argc, char **argv, const struct option *opts,
    char **unnamed, int *argsused);

void show_cipher(const OBJ_NAME *name, void *arg);

#endif

destroy_ui(void)
{
	if (ui_method) {
		UI_destroy_method(ui_method);
		ui_method = NULL;
	}
}

static void (*speed_alarm_handler)(int);
static HANDLE speed_thread;
static unsigned int speed_lapse;
static volatile unsigned int speed_schlock;

void
speed_signal(int sigcatch, void (*func)(int sigraised))
{
	speed_alarm_handler = func;
}

static DWORD WINAPI
speed_timer(VOID * arg)
{
	speed_schlock = 1;
	Sleep(speed_lapse);
	(*speed_alarm_handler)(0);
	return (0);
}

unsigned int
speed_alarm(unsigned int seconds)
{
	DWORD err;

	speed_lapse = seconds * 1000;
	speed_schlock = 0;

	speed_thread = CreateThread(NULL, 4096, speed_timer, NULL, 0, NULL);
	if (speed_thread == NULL) {
		err = GetLastError();
		BIO_printf(bio_err, "CreateThread failed (%lu)", err);
		ExitProcess(err);
	}

	while (!speed_schlock)
		Sleep(0);

	return (seconds);
}

void
speed_alarm_free(int run)
{
	DWORD err;

	if (run) {
		if (TerminateThread(speed_thread, 0) == 0) {
			err = GetLastError();
			BIO_printf(bio_err, "TerminateThread failed (%lu)",
			    err);
			ExitProcess(err);
		}
	}

	if (CloseHandle(speed_thread) == 0) {
		err = GetLastError();
		BIO_printf(bio_err, "CloseHandle failed (%lu)", err);
		ExitProcess(err);
	}

	speed_thread = NULL;
	speed_lapse = 0;
	speed_schlock = 0;
}

/* $OpenBSD: asn1pars.c,v 1.10 2019/07/14 03:30:45 guenther Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *

	if (sk_OPENSSL_STRING_push(asn1pars_config.osk, arg) == 0) {
		fprintf(stderr, "-strparse cannot add argument\n");
		return (-1);
	}
	return (0);
}

static const struct option asn1pars_options[] = {
	{
		.name = "dump",
		.desc = "Dump unknown data in hex form",
		.type = OPTION_VALUE,
		.value = -1,
		.opt.value = &asn1pars_config.dump,
	},

/* $OpenBSD: ca.c,v 1.27 2019/07/03 03:24:02 deraadt Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *

				serialstr = bin2hex(data, j);
			else
				serialstr = strdup("00");
			if (serialstr) {
				k = snprintf(pempath, sizeof(pempath),
				    "%s/%s.pem", outdir, serialstr);
				free(serialstr);
				if (k < 0 || k >= sizeof(pempath)) {
					BIO_printf(bio_err,
					    "certificate file name too long\n");
					goto err;
				}
			} else {
				BIO_printf(bio_err,
				    "memory allocation failed\n");

#include "apps.h"

static struct {
	int dryrun;
	int verbose;
} certhash_config;

static const struct option certhash_options[] = {
	{
		.name = "n",
		.desc = "Perform a dry-run - do not make any changes",
		.type = OPTION_FLAG,
		.opt.flag = &certhash_config.dryrun,
	},
	{

/* $OpenBSD: ciphers.c,v 1.10 2019/07/14 03:30:45 guenther Exp $ */
/*
 * Copyright (c) 2014 Joel Sing <jsing@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *

#include "progs.h"

struct {
	int usage;
	int verbose;
} ciphers_config;

static const struct option ciphers_options[] = {
	{
		.name = "h",
		.type = OPTION_FLAG,
		.opt.flag = &ciphers_config.usage,
	},
	{
		.name = "?",

/* $OpenBSD: crl.c,v 1.13 2019/07/14 03:30:45 guenther Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *

	int noout;
	char *outfile;
	int outformat;
	int text;
	int verify;
} crl_config;

static const struct option crl_options[] = {
	{
		.name = "CAfile",
		.argname = "file",
		.desc = "Verify the CRL using certificates in the given file",
		.type = OPTION_ARG,
		.opt.arg = &crl_config.cafile,
	},

/* $OpenBSD: crl2p7.c,v 1.9 2019/07/14 03:30:45 guenther Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *

		fprintf(stderr, "out of memory\n");
		return (1);
	}

	return (0);
}

static const struct option crl2p7_options[] = {
	{
		.name = "certfile",
		.argname = "file",
		.desc = "Chain of PEM certificates to a trusted CA",
		.type = OPTION_ARG_FUNC,
		.opt.argfunc = crl2p7_opt_certfile,
	},

/* $OpenBSD: dgst.c,v 1.18 2019/08/30 12:32:14 inoguchi Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *

#define BUFSIZE	1024*8

int
do_fp(BIO * out, unsigned char *buf, BIO * bp, int sep, int binout,
    EVP_PKEY * key, unsigned char *sigin, int siglen,
    const char *sig_name, const char *md_name,
    const char *file, BIO * bmd);

static struct {
	int argsused;
	int debug;
	int do_verify;
	char *hmac_key;
	char *keyfile;
	int keyform;
	const EVP_MD *m;
	char *mac_name;
	STACK_OF(OPENSSL_STRING) *macopts;
	const EVP_MD *md;
	int out_bin;
	char *outfile;
	char *passargin;
	int separator;
	char *sigfile;
	STACK_OF(OPENSSL_STRING) *sigopts;
	int want_pub;
} dgst_config;

static int
dgst_opt_macopt(char *arg)
{
	if (arg == NULL)
		return (1);

	if (dgst_config.macopts == NULL &&
	    (dgst_config.macopts = sk_OPENSSL_STRING_new_null()) == NULL)
		return (1);

	if (!sk_OPENSSL_STRING_push(dgst_config.macopts, arg))
		return (1);

	return (0);
}

static int
dgst_opt_md(int argc, char **argv, int *argsused)
{
	char *name = argv[0];

	if (*name++ != '-')
		return (1);

	if ((dgst_config.m = EVP_get_digestbyname(name)) == NULL)
		return (1);

	dgst_config.md = dgst_config.m;

	*argsused = 1;
	return (0);
}

static int
dgst_opt_prverify(char *arg)
{
	if (arg == NULL)
		return (1);

	dgst_config.keyfile = arg;
	dgst_config.do_verify = 1;
	return (0);
}

static int
dgst_opt_sigopt(char *arg)
{
	if (arg == NULL)
		return (1);

	if (dgst_config.sigopts == NULL &&
	    (dgst_config.sigopts = sk_OPENSSL_STRING_new_null()) == NULL)
		return (1);

	if (!sk_OPENSSL_STRING_push(dgst_config.sigopts, arg))
		return (1);

	return (0);
}

static int
dgst_opt_verify(char *arg)
{
	if (arg == NULL)
		return (1);

	dgst_config.keyfile = arg;
	dgst_config.want_pub = 1;
	dgst_config.do_verify = 1;
	return (0);
}

static const struct option dgst_options[] = {
	{
		.name = "binary",
		.desc = "Output the digest or signature in binary form",
		.type = OPTION_VALUE,
		.opt.value = &dgst_config.out_bin,
		.value = 1,
	},
	{
		.name = "c",
		.desc = "Print the digest in two-digit groups separated by colons",
		.type = OPTION_VALUE,
		.opt.value = &dgst_config.separator,
		.value = 1,
	},
	{
		.name = "d",
		.desc = "Print BIO debugging information",
		.type = OPTION_FLAG,
		.opt.flag = &dgst_config.debug,
	},
	{
		.name = "hex",
		.desc = "Output as hex dump",
		.type = OPTION_VALUE,
		.opt.value = &dgst_config.out_bin,
		.value = 0,
	},
	{
		.name = "hmac",
		.argname = "key",
		.desc = "Create hashed MAC with key",
		.type = OPTION_ARG,
		.opt.arg = &dgst_config.hmac_key,
	},
	{
		.name = "keyform",
		.argname = "format",
		.desc = "Key file format (PEM)",
		.type = OPTION_ARG_FORMAT,
		.opt.value = &dgst_config.keyform,
	},
	{
		.name = "mac",
		.argname = "algorithm",
		.desc = "Create MAC (not necessarily HMAC)",
		.type = OPTION_ARG,
		.opt.arg = &dgst_config.mac_name,
	},
	{
		.name = "macopt",
		.argname = "nm:v",
		.desc = "MAC algorithm parameters or key",
		.type = OPTION_ARG_FUNC,
		.opt.argfunc = dgst_opt_macopt,
	},
	{
		.name = "out",
		.argname = "file",
		.desc = "Output to file rather than stdout",
		.type = OPTION_ARG,
		.opt.arg = &dgst_config.outfile,
	},
	{
		.name = "passin",
		.argname = "arg",
		.desc = "Input file passphrase source",
		.type = OPTION_ARG,
		.opt.arg = &dgst_config.passargin,
	},
	{
		.name = "prverify",
		.argname = "file",
		.desc = "Verify a signature using private key in file",
		.type = OPTION_ARG_FUNC,
		.opt.argfunc = dgst_opt_prverify,
	},
	{
		.name = "r",
		.desc = "Output the digest in coreutils format",
		.type = OPTION_VALUE,
		.opt.value = &dgst_config.separator,
		.value = 2,
	},
	{
		.name = "sign",
		.argname = "file",
		.desc = "Sign digest using private key in file",
		.type = OPTION_ARG,
		.opt.arg = &dgst_config.keyfile,
	},
	{
		.name = "signature",
		.argname = "file",
		.desc = "Signature to verify",
		.type = OPTION_ARG,
		.opt.arg = &dgst_config.sigfile,
	},
	{
		.name = "sigopt",
		.argname = "nm:v",
		.desc = "Signature parameter",
		.type = OPTION_ARG_FUNC,
		.opt.argfunc = dgst_opt_sigopt,
	},
	{
		.name = "verify",
		.argname = "file",
		.desc = "Verify a signature using public key in file",
		.type = OPTION_ARG_FUNC,
		.opt.argfunc = dgst_opt_verify,
	},
	{
		.name = NULL,
		.desc = "",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = dgst_opt_md,
	},
	{ NULL },
};

static void
list_md_fn(const EVP_MD * m, const char *from, const char *to, void *arg)
{
	const char *mname;
	/* Skip aliases */
	if (!m)
		return;
	mname = OBJ_nid2ln(EVP_MD_type(m));
	/* Skip shortnames */
	if (strcmp(from, mname))
		return;
	/* Skip clones */
	if (EVP_MD_flags(m) & EVP_MD_FLAG_PKEY_DIGEST)
		return;
	if (strchr(mname, ' '))
		mname = EVP_MD_name(m);
	BIO_printf(arg, " -%-17s To use the %s message digest algorithm\n",
	    mname, mname);
}

static void
dgst_usage(void)
{
	fprintf(stderr, "usage: dgst [-cdr] [-binary] [-digest] [-hex]");
	fprintf(stderr, " [-hmac key] [-keyform fmt]\n");
	fprintf(stderr, "    [-mac algorithm] [-macopt nm:v] [-out file]");
	fprintf(stderr, " [-passin arg]\n");
	fprintf(stderr, "    [-prverify file] [-sign file]");
	fprintf(stderr, " [-signature file]\n");
	fprintf(stderr, "    [-sigopt nm:v] [-verify file] [file ...]\n\n");
	options_usage(dgst_options);
	EVP_MD_do_all_sorted(list_md_fn, bio_err);
	fprintf(stderr, "\n");
}

int
dgst_main(int argc, char **argv)
{
	unsigned char *buf = NULL;
	int i, err = 1;

	BIO *in = NULL, *inp;
	BIO *bmd = NULL;
	BIO *out = NULL;
#define PROG_NAME_SIZE  39
	char pname[PROG_NAME_SIZE + 1];






	EVP_PKEY *sigkey = NULL;
	unsigned char *sigbuf = NULL;
	int siglen = 0;
	char *passin = NULL;




	if (single_execution) {
		if (pledge("stdio cpath wpath rpath tty", NULL) == -1) {
			perror("pledge");
			exit(1);
		}
	}

	if ((buf = malloc(BUFSIZE)) == NULL) {
		BIO_printf(bio_err, "out of memory\n");
		goto end;
	}

	memset(&dgst_config, 0, sizeof(dgst_config));
	dgst_config.keyform = FORMAT_PEM;
	dgst_config.out_bin = -1;

	/* first check the program name */
	program_name(argv[0], pname, sizeof pname);

	dgst_config.md = EVP_get_digestbyname(pname);

	if (options_parse(argc, argv, dgst_options, NULL,











































































	    &dgst_config.argsused) != 0) {
		dgst_usage();


		goto end;
	}
	argc -= dgst_config.argsused;
	argv += dgst_config.argsused;

	if (dgst_config.do_verify && !dgst_config.sigfile) {
		BIO_printf(bio_err,










		    "No signature to verify: use the -signature option\n");






		goto end;
	}

	in = BIO_new(BIO_s_file());
	bmd = BIO_new(BIO_f_md());
	if (in == NULL || bmd == NULL) {
		ERR_print_errors(bio_err);
		goto end;
	}

	if (dgst_config.debug) {
		BIO_set_callback(in, BIO_debug_callback);
		/* needed for windows 3.1 */
		BIO_set_callback_arg(in, (char *) bio_err);
	}
	if (!app_passwd(bio_err, dgst_config.passargin, NULL, &passin, NULL)) {
		BIO_printf(bio_err, "Error getting password\n");
		goto end;
	}
	if (dgst_config.out_bin == -1) {
		if (dgst_config.keyfile)
			dgst_config.out_bin = 1;
		else
			dgst_config.out_bin = 0;
	}

	if (dgst_config.outfile) {
		if (dgst_config.out_bin)
			out = BIO_new_file(dgst_config.outfile, "wb");
		else
			out = BIO_new_file(dgst_config.outfile, "w");
	} else {
		out = BIO_new_fp(stdout, BIO_NOCLOSE);
	}

	if (!out) {
		BIO_printf(bio_err, "Error opening output file %s\n",
		    dgst_config.outfile ? dgst_config.outfile : "(stdout)");
		ERR_print_errors(bio_err);
		goto end;
	}
	if ((!!dgst_config.mac_name + !!dgst_config.keyfile +
	    !!dgst_config.hmac_key) > 1) {
		BIO_printf(bio_err,
		    "MAC and Signing key cannot both be specified\n");
		goto end;
	}
	if (dgst_config.keyfile) {
		if (dgst_config.want_pub)
			sigkey = load_pubkey(bio_err, dgst_config.keyfile,
			    dgst_config.keyform, 0, NULL, "key file");
		else
			sigkey = load_key(bio_err, dgst_config.keyfile,
			    dgst_config.keyform, 0, passin, "key file");
		if (!sigkey) {
			/*
			 * load_[pub]key() has already printed an appropriate
			 * message
			 */
			goto end;
		}
	}
	if (dgst_config.mac_name) {
		EVP_PKEY_CTX *mac_ctx = NULL;
		int r = 0;
		if (!init_gen_str(bio_err, &mac_ctx, dgst_config.mac_name, 0))
			goto mac_end;
		if (dgst_config.macopts) {
			char *macopt;
			for (i = 0; i < sk_OPENSSL_STRING_num(
			    dgst_config.macopts); i++) {
				macopt = sk_OPENSSL_STRING_value(
				    dgst_config.macopts, i);
				if (pkey_ctrl_string(mac_ctx, macopt) <= 0) {
					BIO_printf(bio_err,
					    "MAC parameter error \"%s\"\n",
					    macopt);
					ERR_print_errors(bio_err);
					goto mac_end;
				}
			}
		}
		if (EVP_PKEY_keygen(mac_ctx, &sigkey) <= 0) {
			BIO_puts(bio_err, "Error generating key\n");
			ERR_print_errors(bio_err);
			goto mac_end;
		}
		r = 1;
 mac_end:

		EVP_PKEY_CTX_free(mac_ctx);
		if (r == 0)
			goto end;
	}
	if (dgst_config.hmac_key) {
		sigkey = EVP_PKEY_new_mac_key(EVP_PKEY_HMAC, NULL,
		    (unsigned char *) dgst_config.hmac_key, -1);
		if (!sigkey)
			goto end;
	}
	if (sigkey) {
		EVP_MD_CTX *mctx = NULL;
		EVP_PKEY_CTX *pctx = NULL;
		int r;
		if (!BIO_get_md_ctx(bmd, &mctx)) {
			BIO_printf(bio_err, "Error getting context\n");
			ERR_print_errors(bio_err);
			goto end;
		}
		if (dgst_config.do_verify)
			r = EVP_DigestVerifyInit(mctx, &pctx, dgst_config.md,
			    NULL, sigkey);
		else
			r = EVP_DigestSignInit(mctx, &pctx, dgst_config.md,
			    NULL, sigkey);
		if (!r) {
			BIO_printf(bio_err, "Error setting context\n");
			ERR_print_errors(bio_err);
			goto end;
		}
		if (dgst_config.sigopts) {
			char *sigopt;
			for (i = 0; i < sk_OPENSSL_STRING_num(
			    dgst_config.sigopts); i++) {
				sigopt = sk_OPENSSL_STRING_value(
				    dgst_config.sigopts, i);
				if (pkey_ctrl_string(pctx, sigopt) <= 0) {
					BIO_printf(bio_err,
					    "parameter error \"%s\"\n",
					    sigopt);
					ERR_print_errors(bio_err);
					goto end;
				}
			}
		}
	}
	/* we use md as a filter, reading from 'in' */
	else {
		if (dgst_config.md == NULL)
			dgst_config.md = EVP_sha256();
		if (!BIO_set_md(bmd, dgst_config.md)) {
			BIO_printf(bio_err, "Error setting digest %s\n", pname);
			ERR_print_errors(bio_err);
			goto end;
		}
	}

	if (dgst_config.sigfile && sigkey) {
		BIO *sigbio;
		siglen = EVP_PKEY_size(sigkey);
		sigbuf = malloc(siglen);
		if (sigbuf == NULL) {
			BIO_printf(bio_err, "out of memory\n");
			ERR_print_errors(bio_err);
			goto end;
		}
		sigbio = BIO_new_file(dgst_config.sigfile, "rb");
		if (!sigbio) {
			BIO_printf(bio_err, "Error opening signature file %s\n",
			    dgst_config.sigfile);
			ERR_print_errors(bio_err);
			goto end;
		}
		siglen = BIO_read(sigbio, sigbuf, siglen);
		BIO_free(sigbio);
		if (siglen <= 0) {
			BIO_printf(bio_err, "Error reading signature file %s\n",
			    dgst_config.sigfile);
			ERR_print_errors(bio_err);
			goto end;
		}
	}
	inp = BIO_push(bmd, in);

	if (dgst_config.md == NULL) {
		EVP_MD_CTX *tctx;
		BIO_get_md_ctx(bmd, &tctx);
		dgst_config.md = EVP_MD_CTX_md(tctx);
	}
	if (argc == 0) {
		BIO_set_fp(in, stdin, BIO_NOCLOSE);
		err = do_fp(out, buf, inp, dgst_config.separator,
		    dgst_config.out_bin, sigkey, sigbuf, siglen, NULL, NULL,
		    "stdin", bmd);
	} else {
		const char *md_name = NULL, *sig_name = NULL;
		if (!dgst_config.out_bin) {
			if (sigkey) {
				const EVP_PKEY_ASN1_METHOD *ameth;
				ameth = EVP_PKEY_get0_asn1(sigkey);
				if (ameth)
					EVP_PKEY_asn1_get0_info(NULL, NULL,
					    NULL, NULL, &sig_name, ameth);
			}
			md_name = EVP_MD_name(dgst_config.md);
		}
		err = 0;
		for (i = 0; i < argc; i++) {
			int r;
			if (BIO_read_filename(in, argv[i]) <= 0) {
				perror(argv[i]);
				err++;
				continue;
			} else {
				r = do_fp(out, buf, inp, dgst_config.separator,
				    dgst_config.out_bin, sigkey, sigbuf, siglen,
				    sig_name, md_name, argv[i], bmd);
			}
			if (r)
				err = r;
			(void) BIO_reset(bmd);
		}
	}

 end:
	freezero(buf, BUFSIZE);

	BIO_free(in);
	free(passin);
	BIO_free_all(out);
	EVP_PKEY_free(sigkey);

	sk_OPENSSL_STRING_free(dgst_config.sigopts);

	sk_OPENSSL_STRING_free(dgst_config.macopts);
	free(sigbuf);

	BIO_free(bmd);

	return (err);
}

int
do_fp(BIO * out, unsigned char *buf, BIO * bp, int sep, int binout,
    EVP_PKEY * key, unsigned char *sigin, int siglen,

/* $OpenBSD: dh.c,v 1.12 2019/07/14 03:30:45 guenther Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *

	int informat;
	int noout;
	char *outfile;
	int outformat;
	int text;
} dh_config;

static const struct option dh_options[] = {
	{
		.name = "C",
		.desc = "Convert DH parameters into C code",
		.type = OPTION_FLAG,
		.opt.flag = &dh_config.C,
	},
	{

/* $OpenBSD: dhparam.c,v 1.12 2019/07/14 03:30:45 guenther Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *

	int informat;
	int noout;
	char *outfile;
	int outformat;
	int text;
} dhparam_config;

static const struct option dhparam_options[] = {
	{
		.name = "2",
		.desc = "Generate DH parameters with a generator value of 2 "
		    "(default)",
		.type = OPTION_VALUE,
		.opt.value = &dhparam_config.g,
		.value = 2,

/* $OpenBSD: dsa.c,v 1.15 2019/07/14 03:30:45 guenther Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *

		*argsused = 1;
		return (0);
	}

	return (1);
}

static const struct option dsa_options[] = {
	{
		.name = "in",
		.argname = "file",
		.desc = "Input file (default stdin)",
		.type = OPTION_ARG,
		.opt.arg = &dsa_config.infile,
	},
	{
		.name = "inform",
		.argname = "format",
		.desc = "Input format (PEM (default) or any other supported"
		    " format)",
		.type = OPTION_ARG_FORMAT,
		.opt.value = &dsa_config.informat,
	},
	{
		.name = "modulus",
		.desc = "Print the DSA public value",
		.type = OPTION_FLAG,
		.opt.flag = &dsa_config.modulus,
	},
	{
		.name = "noout",
		.desc = "No output",
		.type = OPTION_FLAG,
		.opt.flag = &dsa_config.noout,
	},
	{

static void
dsa_usage(void)
{
	int n = 0;

	fprintf(stderr,
	    "usage: dsa [-in file] [-inform format] [-modulus] [-noout]\n"
	    "    [-out file] [-outform format] [-passin src] [-passout src]\n"
	    "    [-pubin] [-pubout] [-pvk-none | -pvk-strong | -pvk-weak]\n"
	    "    [-text] [-ciphername]\n\n");
	options_usage(dsa_options);
	fprintf(stderr, "\n");

	fprintf(stderr, "Valid ciphername values:\n\n");

/* $OpenBSD: dsaparam.c,v 1.11 2019/07/14 03:30:45 guenther Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *

	int informat;
	int noout;
	char *outfile;
	int outformat;
	int text;
} dsaparam_config;

static const struct option dsaparam_options[] = {
	{
		.name = "C",
		.desc = "Convert DSA parameters into C code",
		.type = OPTION_FLAG,
		.opt.flag = &dsaparam_config.C,
	},
	{

/* $OpenBSD: ec.c,v 1.14 2019/07/14 03:30:45 guenther Exp $ */
/*
 * Written by Nils Larsch for the OpenSSL project.
 */
/* ====================================================================
 * Copyright (c) 1998-2005 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without

		return (1);
	}

	ec_config.new_asn1_flag = 1;
	return (0);
}

static const struct option ec_options[] = {
	{
		.name = "conv_form",
		.argname = "form",
		.desc = "Specify the point conversion form (default"
		    " \"named_curve\")",
		.type = OPTION_ARG_FUNC,
		.opt.argfunc = ec_opt_form,

/* $OpenBSD: ecparam.c,v 1.18 2019/07/14 03:30:45 guenther Exp $ */
/*
 * Written by Nils Larsch for the OpenSSL project.
 */
/* ====================================================================
 * Copyright (c) 1998-2005 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without

	else
		return (1);

	ecparam_config.new_asn1_flag = 1;
	return (0);
}

static const struct option ecparam_options[] = {
	{
		.name = "C",
		.desc = "Convert the EC parameters into C code",
		.type = OPTION_FLAG,
		.opt.flag = &ecparam_config.C,
	},
	{

/* $OpenBSD: enc.c,v 1.23 2019/07/25 11:42:12 bcook Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *

		*argsused = 1;
		return (0);
	}

	return (1);
}

static const struct option enc_options[] = {
	{
		.name = "A",
		.desc = "Process base64 data on one line (requires -a)",
		.type = OPTION_FLAG,
		.opt.flag = &enc_config.olb64,
	},
	{

					strlen(enc_config.keystr), sptr, islen,
					enc_config.iter, dgst, iklen+ivlen, tmpkeyiv)) {
					BIO_printf(bio_err, "PKCS5_PBKDF2_HMAC failed\n");
					goto end;
				}
				/* split and move data back to global buffer */
				memcpy(key, tmpkeyiv, iklen);
				memcpy(iv, tmpkeyiv + iklen, ivlen);
				explicit_bzero(tmpkeyiv, sizeof tmpkeyiv);
			} else {
				EVP_BytesToKey(enc_config.cipher, dgst, sptr,
				    (unsigned char *)enc_config.keystr,
				    strlen(enc_config.keystr), 1, key, iv);
			}

			/*

/* $OpenBSD: errstr.c,v 1.7 2019/07/14 03:30:45 guenther Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *

#include <openssl/lhash.h>
#include <openssl/ssl.h>

struct {
	int stats;
} errstr_config;

static const struct option errstr_options[] = {
	{
		.name = "stats",
		.desc = "Print debugging statistics for the hash table",
		.type = OPTION_FLAG,
		.opt.flag = &errstr_config.stats,
	},
	{ NULL },

/* $OpenBSD: gendh.c,v 1.11 2019/07/14 03:30:45 guenther Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *

static int dh_cb(int p, int n, BN_GENCB * cb);

static struct {
	int g;
	char *outfile;
} gendh_config;

static const struct option gendh_options[] = {
	{
		.name = "2",
		.desc = "Generate DH parameters with a generator value of 2 "
		    "(default)",
		.type = OPTION_VALUE,
		.value = 2,
		.opt.value = &gendh_config.g,

/* $OpenBSD: gendsa.c,v 1.14 2019/07/24 14:23:25 inoguchi Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *

#include <openssl/bio.h>
#include <openssl/bn.h>
#include <openssl/dsa.h>
#include <openssl/err.h>
#include <openssl/pem.h>
#include <openssl/x509.h>

static struct {
	const EVP_CIPHER *enc;
	char *outfile;
	char *passargout;
} gendsa_config;

static const EVP_CIPHER *get_cipher_by_name(char *name)
{
	if (name == NULL || strcmp(name, "") == 0)
		return (NULL);
#ifndef OPENSSL_NO_AES
	else if (strcmp(name, "aes128") == 0)
		return EVP_aes_128_cbc();
	else if (strcmp(name, "aes192") == 0)
		return EVP_aes_192_cbc();
	else if (strcmp(name, "aes256") == 0)
		return EVP_aes_256_cbc();
#endif
#ifndef OPENSSL_NO_CAMELLIA
	else if (strcmp(name, "camellia128") == 0)
		return EVP_camellia_128_cbc();
	else if (strcmp(name, "camellia192") == 0)
		return EVP_camellia_192_cbc();
	else if (strcmp(name, "camellia256") == 0)
		return EVP_camellia_256_cbc();
#endif
#ifndef OPENSSL_NO_DES
	else if (strcmp(name, "des") == 0)
		return EVP_des_cbc();
	else if (strcmp(name, "des3") == 0)
		return EVP_des_ede3_cbc();
#endif
#ifndef OPENSSL_NO_IDEA
	else if (strcmp(name, "idea") == 0)
		return EVP_idea_cbc();
#endif
	else
		return (NULL);
}

static int
set_enc(int argc, char **argv, int *argsused)
{
	char *name = argv[0];

	if (*name++ != '-')
		return (1);

	if ((gendsa_config.enc = get_cipher_by_name(name)) == NULL)
		return (1);

	*argsused = 1;
	return (0);
}

static const struct option gendsa_options[] = {
#ifndef OPENSSL_NO_AES
	{
		.name = "aes128",
		.desc = "Encrypt PEM output with CBC AES",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = set_enc,
	},
	{
		.name = "aes192",
		.desc = "Encrypt PEM output with CBC AES",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = set_enc,
	},
	{
		.name = "aes256",
		.desc = "Encrypt PEM output with CBC AES",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = set_enc,
	},
#endif
#ifndef OPENSSL_NO_CAMELLIA
	{
		.name = "camellia128",
		.desc = "Encrypt PEM output with CBC Camellia",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = set_enc,
	},
	{
		.name = "camellia192",
		.desc = "Encrypt PEM output with CBC Camellia",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = set_enc,
	},
	{
		.name = "camellia256",
		.desc = "Encrypt PEM output with CBC Camellia",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = set_enc,
	},
#endif
#ifndef OPENSSL_NO_DES
	{
		.name = "des",
		.desc = "Encrypt the generated key with DES in CBC mode",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = set_enc,
	},
	{
		.name = "des3",
		.desc = "Encrypt the generated key with DES in EDE CBC mode (168 bit key)",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = set_enc,
	},
#endif
#ifndef OPENSSL_NO_IDEA
	{
		.name = "idea",
		.desc = "Encrypt the generated key with IDEA in CBC mode",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = set_enc,
	},
#endif
	{
		.name = "out",
		.argname = "file",
		.desc = "Output the key to 'file'",
		.type = OPTION_ARG,
		.opt.arg = &gendsa_config.outfile,
	},
	{
		.name = "passout",
		.argname = "src",
		.desc = "Output file passphrase source",
		.type = OPTION_ARG,
		.opt.arg = &gendsa_config.passargout,
	},
	{ NULL },
};

static void
gendsa_usage(void)
{
	fprintf(stderr, "usage: gendsa [-aes128 | -aes192 | -aes256 |\n");
	fprintf(stderr, "    -camellia128 | -camellia192 | -camellia256 |\n");
	fprintf(stderr, "    -des | -des3 | -idea] [-out file] [-passout src]");
	fprintf(stderr, " paramfile\n\n");
	options_usage(gendsa_options);
	fprintf(stderr, "\n");
}

int
gendsa_main(int argc, char **argv)
{
	DSA *dsa = NULL;
	int ret = 1;

	char *dsaparams = NULL;
	char *passout = NULL;
	BIO *out = NULL, *in = NULL;


	if (single_execution) {
		if (pledge("stdio cpath wpath rpath tty", NULL) == -1) {
			perror("pledge");
			exit(1);
		}
	}

	memset(&gendsa_config, 0, sizeof(gendsa_config));










































	if (options_parse(argc, argv, gendsa_options, &dsaparams, NULL) != 0) {
		gendsa_usage();
		goto end;


	}

	if (dsaparams == NULL) {






		gendsa_usage();













		goto end;
	}
	if (!app_passwd(bio_err, NULL, gendsa_config.passargout, NULL,
	    &passout)) {
		BIO_printf(bio_err, "Error getting password\n");
		goto end;
	}
	in = BIO_new(BIO_s_file());
	if (!(BIO_read_filename(in, dsaparams))) {
		perror(dsaparams);
		goto end;
	}
	if ((dsa = PEM_read_bio_DSAparams(in, NULL, NULL, NULL)) == NULL) {
		BIO_printf(bio_err, "unable to load DSA parameter file\n");
		goto end;
	}
	BIO_free(in);
	in = NULL;

	out = BIO_new(BIO_s_file());
	if (out == NULL)
		goto end;

	if (gendsa_config.outfile == NULL) {
		BIO_set_fp(out, stdout, BIO_NOCLOSE);
	} else {
		if (BIO_write_filename(out, gendsa_config.outfile) <= 0) {
			perror(gendsa_config.outfile);
			goto end;
		}
	}

	BIO_printf(bio_err, "Generating DSA key, %d bits\n",
	    BN_num_bits(dsa->p));
	if (!DSA_generate_key(dsa))
		goto end;

	if (!PEM_write_bio_DSAPrivateKey(out, dsa, gendsa_config.enc, NULL, 0,
	    NULL, passout))
		goto end;
	ret = 0;
 end:
	if (ret != 0)
		ERR_print_errors(bio_err);
	BIO_free(in);
	BIO_free_all(out);
	DSA_free(dsa);
	free(passout);

	return (ret);
}

/* $OpenBSD: genpkey.c,v 1.13 2019/07/14 03:30:46 guenther Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 2006
 */
/* ====================================================================
 * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without

		ERR_print_errors(bio_err);
		return (1);
	}

	return (0);
}

static const struct option genpkey_options[] = {
	{
		.name = "algorithm",
		.argname = "name",
		.desc = "Public key algorithm to use (must precede -pkeyopt)",
		.type = OPTION_ARG_FUNC,
		.opt.argfunc = genpkey_opt_algorithm,
	},

/* $OpenBSD: genrsa.c,v 1.17 2019/07/24 14:23:25 inoguchi Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *

#include <openssl/pem.h>
#include <openssl/rsa.h>
#include <openssl/x509.h>

#define DEFBITS	2048

static int genrsa_cb(int p, int n, BN_GENCB * cb);

static struct {
	const EVP_CIPHER *enc;
	unsigned long f4;
	char *outfile;
	char *passargout;
} genrsa_config;

static int
set_public_exponent(int argc, char **argv, int *argsused)
{
	char *option = argv[0];

	if (strcmp(option, "-3") == 0)
		genrsa_config.f4 = 3;
	else if (strcmp(option, "-f4") == 0 || strcmp(option, "-F4") == 0)
		genrsa_config.f4 = RSA_F4;
	else
		return (1);

	*argsused = 1;
	return (0);
}

static const EVP_CIPHER *get_cipher_by_name(char *name)
{
	if (name == NULL || strcmp(name, "") == 0)
		return (NULL);
#ifndef OPENSSL_NO_AES
	else if (strcmp(name, "aes128") == 0)
		return EVP_aes_128_cbc();
	else if (strcmp(name, "aes192") == 0)
		return EVP_aes_192_cbc();
	else if (strcmp(name, "aes256") == 0)
		return EVP_aes_256_cbc();
#endif
#ifndef OPENSSL_NO_CAMELLIA
	else if (strcmp(name, "camellia128") == 0)
		return EVP_camellia_128_cbc();
	else if (strcmp(name, "camellia192") == 0)
		return EVP_camellia_192_cbc();
	else if (strcmp(name, "camellia256") == 0)
		return EVP_camellia_256_cbc();
#endif
#ifndef OPENSSL_NO_DES
	else if (strcmp(name, "des") == 0)
		return EVP_des_cbc();
	else if (strcmp(name, "des3") == 0)
		return EVP_des_ede3_cbc();
#endif
#ifndef OPENSSL_NO_IDEA
	else if (strcmp(name, "idea") == 0)
		return EVP_idea_cbc();
#endif
	else
		return (NULL);
}

static int
set_enc(int argc, char **argv, int *argsused)
{
	char *name = argv[0];

	if (*name++ != '-')
		return (1);

	if ((genrsa_config.enc = get_cipher_by_name(name)) == NULL)
		return (1);

	*argsused = 1;
	return (0);
}

static const struct option genrsa_options[] = {
	{
		.name = "3",
		.desc = "Use 3 for the E value",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = set_public_exponent,
	},
	{
		.name = "f4",
		.desc = "Use F4 (0x10001) for the E value",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = set_public_exponent,
	},
	{
		.name = "F4",
		.desc = "Use F4 (0x10001) for the E value",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = set_public_exponent,
	},
#ifndef OPENSSL_NO_AES
	{
		.name = "aes128",
		.desc = "Encrypt PEM output with CBC AES",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = set_enc,
	},
	{
		.name = "aes192",
		.desc = "Encrypt PEM output with CBC AES",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = set_enc,
	},
	{
		.name = "aes256",
		.desc = "Encrypt PEM output with CBC AES",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = set_enc,
	},
#endif
#ifndef OPENSSL_NO_CAMELLIA
	{
		.name = "camellia128",
		.desc = "Encrypt PEM output with CBC Camellia",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = set_enc,
	},
	{
		.name = "camellia192",
		.desc = "Encrypt PEM output with CBC Camellia",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = set_enc,
	},
	{
		.name = "camellia256",
		.desc = "Encrypt PEM output with CBC Camellia",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = set_enc,
	},
#endif
#ifndef OPENSSL_NO_DES
	{
		.name = "des",
		.desc = "Encrypt the generated key with DES in CBC mode",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = set_enc,
	},
	{
		.name = "des3",
		.desc = "Encrypt the generated key with DES in EDE CBC mode (168 bit key)",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = set_enc,
	},
#endif
#ifndef OPENSSL_NO_IDEA
	{
		.name = "idea",
		.desc = "Encrypt the generated key with IDEA in CBC mode",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = set_enc,
	},
#endif
	{
		.name = "out",
		.argname = "file",
		.desc = "Output the key to 'file'",
		.type = OPTION_ARG,
		.opt.arg = &genrsa_config.outfile,
	},
	{
		.name = "passout",
		.argname = "arg",
		.desc = "Output file passphrase source",
		.type = OPTION_ARG,
		.opt.arg = &genrsa_config.passargout,
	},
	{ NULL },
};

static void
genrsa_usage(void)
{
	fprintf(stderr, "usage: genrsa [-3 | -f4] [-aes128 | -aes192 |");
	fprintf(stderr, " -aes256 |\n");
	fprintf(stderr, "    -camellia128 | -camellia192 | -camellia256 |");
	fprintf(stderr, " -des | -des3 | -idea]\n");
	fprintf(stderr, "    [-out file] [-passout arg] [numbits]\n\n");
	options_usage(genrsa_options);
	fprintf(stderr, "\n");
}

int
genrsa_main(int argc, char **argv)
{
	BN_GENCB cb;
	int ret = 1;
	int i, num = DEFBITS;
	char *numbits= NULL;
	long l;



	char *passout = NULL;
	BIO *out = NULL;
	BIGNUM *bn = BN_new();
	RSA *rsa = NULL;

	if (single_execution) {
		if (pledge("stdio cpath wpath rpath tty", NULL) == -1) {
			perror("pledge");
			exit(1);
		}
	}

	if (!bn)
		goto err;

	BN_GENCB_set(&cb, genrsa_cb, bio_err);

	if ((out = BIO_new(BIO_s_file())) == NULL) {
		BIO_printf(bio_err, "unable to create BIO for output\n");
		goto err;
	}

	memset(&genrsa_config, 0, sizeof(genrsa_config));










	genrsa_config.f4 = RSA_F4;





	if (options_parse(argc, argv, genrsa_options, &numbits, NULL) != 0) {
		genrsa_usage();






















		goto err;





	}

	if ((numbits != NULL) &&
	    ((sscanf(numbits, "%d", &num) == 0) || (num < 0))) {





		genrsa_usage();















		goto err;
	}

	if (!app_passwd(bio_err, NULL, genrsa_config.passargout, NULL,
	    &passout)) {
		BIO_printf(bio_err, "Error getting password\n");
		goto err;
	}

	if (genrsa_config.outfile == NULL) {
		BIO_set_fp(out, stdout, BIO_NOCLOSE);
	} else {
		if (BIO_write_filename(out, genrsa_config.outfile) <= 0) {
			perror(genrsa_config.outfile);
			goto err;
		}
	}

	BIO_printf(bio_err, "Generating RSA private key, %d bit long modulus\n",
	    num);
	rsa = RSA_new();
	if (!rsa)
		goto err;

	if (!BN_set_word(bn, genrsa_config.f4) ||
	    !RSA_generate_key_ex(rsa, num, bn, &cb))
		goto err;

	/*
	 * We need to do the following for when the base number size is <
	 * long, esp windows 3.1 :-(.
	 */
	l = 0L;
	for (i = 0; i < rsa->e->top; i++) {
#ifndef _LP64
		l <<= BN_BITS4;
		l <<= BN_BITS4;
#endif
		l += rsa->e->d[i];
	}
	BIO_printf(bio_err, "e is %ld (0x%lX)\n", l, l);
	{
		PW_CB_DATA cb_data;
		cb_data.password = passout;
		cb_data.prompt_info = genrsa_config.outfile;
		if (!PEM_write_bio_RSAPrivateKey(out, rsa, genrsa_config.enc,
		    NULL, 0, password_callback, &cb_data))
			goto err;
	}

	ret = 0;
 err:
	BN_free(bn);
	RSA_free(rsa);

/* $OpenBSD: nseq.c,v 1.9 2019/07/14 03:30:46 guenther Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 1999.
 */
/* ====================================================================
 * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without

static struct {
	char *infile;
	char *outfile;
	int toseq;
} nseq_config;

static const struct option nseq_options[] = {
	{
		.name = "in",
		.argname = "file",
		.desc = "Input file to read from (default stdin)",
		.type = OPTION_ARG,
		.opt.arg = &nseq_config.infile,
	},

.\" $OpenBSD: openssl.1,v 1.114 2019/10/04 06:22:51 jmc Exp $
.\" ====================================================================
.\" Copyright (c) 1998-2002 The OpenSSL Project.  All rights reserved.
.\"
.\" Redistribution and use in source and binary forms, with or without
.\" modification, are permitted provided that the following conditions
.\" are met:
.\"

.\" SUCH DAMAGE.
.\"
.\" The licence and distribution terms for any publically available version or
.\" derivative of this code cannot be changed.  i.e. this code cannot simply be
.\" copied and put under another distribution licence
.\" [including the GNU Public Licence.]
.\"
.Dd $Mdocdate: October 4 2019 $
.Dt OPENSSL 1
.Os
.Sh NAME
.Nm openssl
.Nd OpenSSL command line tool
.Sh SYNOPSIS
.Nm

is not able to detect pseudo-commands such as
.Cm quit ,
.Cm list- Ns Ar ... Ns Cm -commands ,
or
.Cm no- Ns Ar command
itself.
.Sh ASN1PARSE
.Bl -hang -width "openssl asn1parse"
.It Nm openssl asn1parse
.Bk -words
.Op Fl i
.Op Fl dlimit Ar number
.Op Fl dump
.Op Fl genconf Ar file
.Op Fl genstr Ar str
.Op Fl in Ar file
.Op Fl inform Cm der | pem | txt
.Op Fl length Ar number
.Op Fl noout
.Op Fl offset Ar number
.Op Fl oid Ar file
.Op Fl out Ar file
.Op Fl strparse Ar offset
.Ek
.El
.Pp
The
.Nm asn1parse
command is a diagnostic utility that can parse ASN.1 structures.
It can also be used to extract data from ASN.1 formatted data.
.Pp
The options are as follows:

Parse the content octets of the ASN.1 object starting at
.Ar offset .
This option can be used multiple times to
.Qq drill down
into a nested structure.
.El
.Sh CA
.Bl -hang -width "openssl ca"
.It Nm openssl ca
.Bk -words
.Op Fl batch
.Op Fl cert Ar file
.Op Fl config Ar file
.Op Fl create_serial
.Op Fl crl_CA_compromise Ar time
.Op Fl crl_compromise Ar time
.Op Fl crl_hold Ar instruction
.Op Fl crl_reason Ar reason
.Op Fl crldays Ar days
.Op Fl crlexts Ar section
.Op Fl crlhours Ar hours
.Op Fl crlsec Ar seconds
.Op Fl days Ar arg
.Op Fl enddate Ar date
.Op Fl extensions Ar section
.Op Fl extfile Ar file
.Op Fl gencrl
.Op Fl in Ar file
.Op Fl infiles
.Op Fl key Ar password
.Op Fl keyfile Ar file
.Op Fl keyform Cm pem | der
.Op Fl md Ar alg
.Op Fl msie_hack
.Op Fl multivalue-rdn
.Op Fl name Ar section
.Op Fl noemailDN
.Op Fl notext
.Op Fl out Ar file
.Op Fl outdir Ar directory
.Op Fl passin Ar arg
.Op Fl policy Ar arg
.Op Fl preserveDN
.Op Fl revoke Ar file
.Op Fl selfsign
.Op Fl sigopt Ar nm:v
.Op Fl spkac Ar file
.Op Fl ss_cert Ar file
.Op Fl startdate Ar date
.Op Fl status Ar serial
.Op Fl subj Ar arg
.Op Fl updatedb
.Op Fl utf8
.Op Fl verbose
.Ek
.El
.Pp
The
.Nm ca
command is a minimal certificate authority (CA) application.
It can be used to sign certificate requests in a variety of forms
and generate certificate revocation lists (CRLs).
It also maintains a text database of issued certificates and their status.

.Qq certenr3 .
It used UniversalStrings for almost everything.
Since the old control has various security bugs,
its use is strongly discouraged.
The newer control
.Qq Xenroll
does not need this option.
.It Fl multivalue-rdn
This option causes the
.Fl subj
argument to be interpreted with full support for multivalued RDNs,
for example
.Qq "/DC=org/DC=OpenSSL/DC=users/UID=123456+CN=John Doe" .
If
.Fl multivalue-rdn
is not used, the UID value is set to
.Qq "123456+CN=John Doe" .
.It Fl name Ar section
Specifies the configuration file
.Ar section
to use (overrides
.Cm default_ca

A consequence of using
.Fl selfsign
is that the self-signed certificate appears among the entries in
the certificate database (see the configuration option
.Cm database )
and uses the same serial number counter as all other certificates
signed with the self-signed certificate.
.It Fl sigopt Ar nm:v
Pass options to the signature algorithm during sign or certify operations.
The names and values of these options are algorithm-specific.
.It Fl spkac Ar file
A file containing a single Netscape signed public key and challenge,
and additional field values to be signed by the CA.
This will usually come from the
KEYGEN tag in an HTML form to create a new private key.
It is, however, possible to create SPKACs using the
.Nm spkac

cessationOfOperation, certificateHold or removeFromCRL.
The matching of
.Ar reason
is case insensitive.
Setting any revocation reason will make the CRL v2.
In practice, removeFromCRL is not particularly useful because it is only used
in delta CRLs which are not currently implemented.
.It Fl crldays Ar days
The number of days before the next CRL is due.
This is the days from now to place in the CRL
.Cm nextUpdate
field.
.It Fl crlexts Ar section
The
.Ar section
of the configuration file containing CRL extensions to include.
If no CRL extension section is present then a V1 CRL is created;
if the CRL extension section is present
(even if it is empty)
then a V2 CRL is created.
The CRL extensions specified are CRL extensions and not CRL entry extensions.
It should be noted that some software can't handle V2 CRLs.
See the
.Xr x509v3.cnf 5
manual page for details of the extension section format.
.It Fl crlhours Ar hours
The number of hours before the next CRL is due.
.It Fl crlsec Ar seconds
The number of seconds before the next CRL is due.
.It Fl gencrl
Generate a CRL based on information in the index file.
.It Fl revoke Ar file
A
.Ar file
containing a certificate to revoke.
.It Fl status Ar serial

key exchange, authentication, encryption, and mac algorithms.
.It Fl v
Like
.Fl V ,
but without cipher suite codes.
.El
.Sh CRL
.Bl -hang -width "openssl crl"
.It Nm openssl crl
.Bk -words
.Op Fl CAfile Ar file
.Op Fl CApath Ar dir
.Op Fl crlnumber
.Op Fl fingerprint
.Op Fl hash
.Op Fl hash_old
.Op Fl in Ar file
.Op Fl inform Cm der | pem
.Op Fl issuer
.Op Fl lastupdate
.Op Fl nameopt Ar option
.Op Fl nextupdate
.Op Fl noout
.Op Fl out Ar file
.Op Fl outform Cm der | pem
.Op Fl text
.Op Fl verify
.Ek
.El
.Pp
The
.Nm crl
command processes CRL files in DER or PEM format.
.Pp
The options are as follows:
.Bl -tag -width Ds
.It Fl CAfile Ar file
Verify the signature on a CRL by looking up the issuing certificate in
.Ar file .
.It Fl CApath Ar directory
Verify the signature on a CRL by looking up the issuing certificate in
.Ar dir .
This directory must be a standard certificate directory,
i.e. a hash of each subject name (using
.Cm x509 Fl hash )
should be linked to each certificate.
.It Fl crlnumber
Print the CRL number.
.It Fl fingerprint
Print the CRL fingerprint.
.It Fl hash
Output a hash of the issuer name.
This can be used to look up CRLs in a directory by issuer name.
.It Fl hash_old
Output an old-style (MD5) hash of the issuer name.
.It Fl in Ar file
The input file to read from, or standard input if not specified.
.It Fl inform Cm der | pem
The input format.
.It Fl issuer
Output the issuer name.
.It Fl lastupdate
Output the
.Cm lastUpdate
field.
.It Fl nameopt Ar option
Specify certificate name options.
.It Fl nextupdate
Output the
.Cm nextUpdate
field.
.It Fl noout
Do not output the encoded version of the CRL.
.It Fl out Ar file
The output file to write to, or standard output if not specified.
.It Fl outform Cm der | pem
The output format.
.It Fl text
Print the CRL in plain text.
.It Fl verify
Verify the signature on the CRL.
.El
.Sh CRL2PKCS7

.Bl -hang -width "openssl crl2pkcs7"
.It Nm openssl crl2pkcs7
.Bk -words
.Op Fl certfile Ar file
.Op Fl in Ar file
.Op Fl inform Cm der | pem
.Op Fl nocrl
.Op Fl out Ar file
.Op Fl outform Cm der | pem
.Ek
.El
.Pp
The
.Nm crl2pkcs7
command takes an optional CRL and one or more
certificates and converts them into a PKCS#7 degenerate
.Qq certificates only
structure.

Write the PKCS#7 structure to
.Ar file ,
or standard output if not specified.
.It Fl outform Cm der | pem
The output format.
.El
.Sh DGST
.Bl -hang -width "openssl dgst"
.It Nm openssl dgst
.Bk -words
.Op Fl cdr
.Op Fl binary
.Op Fl Ar digest
.Op Fl hex
.Op Fl hmac Ar key
.Op Fl keyform Cm pem
.Op Fl mac Ar algorithm
.Op Fl macopt Ar nm : Ns Ar v
.Op Fl out Ar file
.Op Fl passin Ar arg
.Op Fl prverify Ar file
.Op Fl sign Ar file
.Op Fl signature Ar file
.Op Fl sigopt Ar nm : Ns Ar v
.Op Fl verify Ar file
.Op Ar
.Ek
.El
.Pp
The digest functions output the message digest of a supplied
.Ar file
or
.Ar files
in hexadecimal form.
They can also be used for digital signing and verification.

.It Fl prverify Ar file
Verify the signature using the private key in
.Ar file .
The output is either
.Qq Verification OK
or
.Qq Verification Failure .
.It Fl r
Print the digest in coreutils format.
.It Fl sign Ar file
Digitally sign the digest using the private key in
.Ar file .
.It Fl signature Ar file
The actual signature to verify.
.It Fl sigopt Ar nm : Ns Ar v
Pass options to the signature algorithm during sign or verify operations.
The names and values of these options are algorithm-specific.
.It Fl verify Ar file
Verify the signature using the public key in
.Ar file .
The output is either
.Qq Verification OK
or
.Qq Verification Failure .
.It Ar
File or files to digest.
If no files are specified then standard input is used.
.El
.Sh DHPARAM
.Bl -hang -width "openssl dhparam"
.It Nm openssl dhparam
.Bk -words
.Op Fl 2 | 5
.Op Fl C
.Op Fl check
.Op Fl dsaparam
.Op Fl in Ar file
.Op Fl inform Cm der | pem
.Op Fl noout
.Op Fl out Ar file
.Op Fl outform Cm der | pem
.Op Fl text
.Op Ar numbits
.Ek
.El
.Pp
The
.Nm dhparam
command is used to manipulate DH parameter files.
Only the older PKCS#3 DH is supported,
not the newer X9.42 DH.
.Pp

.Ar numbits .
It must be the last option.
If not present, a value of 2048 is used.
If this value is present, the input file is ignored and
parameters are generated instead.
.El
.Sh DSA
.Bl -hang -width "openssl dsa"
.It Nm openssl dsa
.Bk -words
.Oo
.Fl aes128 | aes192 | aes256 |
.Fl des | des3
.Oc
.Op Fl in Ar file
.Op Fl inform Cm der | pem | pvk
.Op Fl modulus
.Op Fl noout
.Op Fl out Ar file
.Op Fl outform Cm der | pem | pvk
.Op Fl passin Ar arg
.Op Fl passout Ar arg
.Op Fl pubin
.Op Fl pubout
.Op Fl pvk-none | pvk-strong | pvk-weak
.Op Fl text
.Ek
.El
.Pp
The
.Nm dsa
command processes DSA keys.
They can be converted between various forms and their components printed out.
.Pp
.Sy Note :

or by setting the encryption options it can be used to add or change
the pass phrase.
These options can only be used with PEM format output files.
.It Fl in Ar file
The input file to read from,
or standard input if not specified.
If the key is encrypted, a pass phrase will be prompted for.
.It Fl inform Cm der | pem | pvk
The input format.
.It Fl modulus
Print the value of the public key component of the key.
.It Fl noout
Do not output the encoded version of the key.
.It Fl out Ar file
The output file to write to,
or standard output if not specified.
If any encryption options are set then a pass phrase will be
prompted for.
.It Fl outform Cm der | pem | pvk
The output format.
.It Fl passin Ar arg
The key password source.
.It Fl passout Ar arg
The output file password source.
.It Fl pubin
Read in a public key, not a private key.
.It Fl pubout
Output a public key, not a private key.
Automatically set if the input is a public key.
.It Xo
.Fl pvk-none | pvk-strong | pvk-weak
.Xc
Enable or disable PVK encoding.
The default is
.Fl pvk-strong .
.It Fl text
Print the public/private key in plain text.
.El
.Sh DSAPARAM
.Bl -hang -width "openssl dsaparam"
.It Nm openssl dsaparam
.Bk -words
.Op Fl C
.Op Fl genkey
.Op Fl in Ar file
.Op Fl inform Cm der | pem
.Op Fl noout
.Op Fl out Ar file
.Op Fl outform Cm der | pem
.Op Fl text
.Op Ar numbits
.Ek
.El
.Pp
The
.Nm dsaparam
command is used to manipulate or generate DSA parameter files.
.Pp
The options are as follows:
.Bl -tag -width Ds

Print the DSA parameters in plain text.
.It Ar numbits
Generate a parameter set of size
.Ar numbits .
If this option is included, the input file is ignored.
.El
.Sh EC
.Bl -hang -width "openssl ec"
.It Nm openssl ec
.Bk -words
.Op Fl conv_form Ar arg
.Op Fl des
.Op Fl des3
.Op Fl in Ar file
.Op Fl inform Cm der | pem
.Op Fl noout
.Op Fl out Ar file
.Op Fl outform Cm der | pem
.Op Fl param_enc Ar arg
.Op Fl param_out
.Op Fl passin Ar arg
.Op Fl passout Ar arg
.Op Fl pubin
.Op Fl pubout
.Op Fl text
.Ek
.El
.Pp
The
.Nm ec
command processes EC keys.
They can be converted between various
forms and their components printed out.
.Nm openssl

The default value is
.Cm named_curve .
Note: the
.Cm implicitlyCA
alternative,
as specified in RFC 3279,
is currently not implemented.
.It Fl param_out
Print the elliptic curve parameters.
.It Fl passin Ar arg
The key password source.
.It Fl passout Ar arg
The output file password source.
.It Fl pubin
Read in a public key, not a private key.
.It Fl pubout
Output a public key, not a private key.
Automatically set if the input is a public key.
.It Fl text
Print the public/private key in plain text.
.El
.Sh ECPARAM
.Bl -hang -width "openssl ecparam"
.It Nm openssl ecparam
.Bk -words
.Op Fl C
.Op Fl check
.Op Fl conv_form Ar arg
.Op Fl genkey
.Op Fl in Ar file
.Op Fl inform Cm der | pem
.Op Fl list_curves
.Op Fl name Ar arg
.Op Fl no_seed
.Op Fl noout
.Op Fl out Ar file
.Op Fl outform Cm der | pem
.Op Fl param_enc Ar arg
.Op Fl text
.Ek
.El
.Pp
The
.Nm ecparam
command is used to manipulate or generate EC parameter files.
.Nm openssl
is not able to generate new groups so
.Nm ecparam

.Cm implicitlyCA
alternative, as specified in RFC 3279,
is currently not implemented.
.It Fl text
Print the EC parameters in plain text.
.El
.Sh ENC
.Bl -hang -width "openssl enc"
.It Nm openssl enc
.Bk -words
.Fl ciphername
.Op Fl AadePpv
.Op Fl base64
.Op Fl bufsize Ar number
.Op Fl debug
.Op Fl in Ar file
.Op Fl iter Ar iterations
.Op Fl iv Ar IV
.Op Fl K Ar key
.Op Fl k Ar password
.Op Fl kfile Ar file
.Op Fl md Ar digest
.Op Fl none
.Op Fl nopad
.Op Fl nosalt
.Op Fl out Ar file
.Op Fl pass Ar arg
.Op Fl pbkdf2
.Op Fl S Ar salt
.Op Fl salt
.Ek
.El
.Pp
The symmetric cipher commands allow data to be encrypted or decrypted
using various block and stream ciphers using keys based on passwords
or explicitly provided.
Base64 encoding or decoding can also be performed either by itself
or in addition to the encryption or decryption.
The program can be called either as

this must be represented as a string comprised only of hex digits.
.It Fl salt
Use a salt in the key derivation routines (the default).
When the salt is being used
the first eight bytes of the encrypted data are reserved for the salt:
it is randomly generated when encrypting a file and read from the
encrypted file when it is decrypted.
.It Fl v
Print extra details about the processing.
.El
.Sh ERRSTR
.Nm openssl errstr
.Op Fl stats
.Ar errno ...
.Pp
The

.Pp
The options are as follows:
.Bl -tag -width Ds
.It Fl stats
Print debugging statistics about various aspects of the hash table.
.El
.Sh GENDSA
.Bl -hang -width "openssl gendsa"
.It Nm openssl gendsa
.Bk -words
.Oo
.Fl aes128 | aes192 | aes256 | camellia128 |
.Fl camellia192 | camellia256 | des | des3 | idea
.Oc
.Op Fl out Ar file
.Op Fl passout Ar arg
.Ar paramfile
.Ek
.El
.Pp
The
.Nm gendsa
command generates a DSA private key from a DSA parameter file
(typically generated by the
.Nm openssl dsaparam
command).
DSA key generation is little more than random number generation so it is
much quicker than,
for example,
RSA key generation.
.Pp
The options are as follows:
.Bl -tag -width Ds
.It Xo
.Fl aes128 | aes192 | aes256 |
.Fl camellia128 | camellia192 | camellia256 |
.Fl des | des3 |
.Fl idea
.Xc
Encrypt the private key with the AES, CAMELLIA, DES, triple DES
or the IDEA ciphers, respectively, before outputting it.
A pass phrase is prompted for.
If none of these options are specified, no encryption is used.
.It Fl out Ar file
The output file to write to,
or standard output if not specified.
.It Fl passout Ar arg
The output file password source.
.It Ar paramfile
Specify the DSA parameter file to use.
The parameters in this file determine the size of the private key.
.El
.Sh GENPKEY
.Bl -hang -width "openssl genpkey"
.It Nm openssl genpkey
.Bk -words
.Op Fl algorithm Ar alg
.Op Ar cipher
.Op Fl genparam
.Op Fl out Ar file
.Op Fl outform Cm der | pem
.Op Fl paramfile Ar file
.Op Fl pass Ar arg
.Op Fl pkeyopt Ar opt : Ns Ar value
.Op Fl text
.Ek
.El
.Pp
The
.Nm genpkey
command generates private keys.
The use of this
program is encouraged over the algorithm specific utilities
because additional algorithm options can be used.

(EC)
The EC curve to use.
.El
.It Fl text
Print the private/public key in plain text.
.El
.Sh GENRSA
.Bl -hang -width "openssl genrsa"
.It Nm openssl genrsa
.Bk -words
.Op Fl 3 | f4
.Oo
.Fl aes128 | aes192 | aes256 | camellia128 |
.Fl camellia192 | camellia256 | des | des3 | idea
.Oc
.Op Fl out Ar file
.Op Fl passout Ar arg
.Op Ar numbits
.Ek
.El
.Pp
The
.Nm genrsa
command generates an RSA private key,
which essentially involves the generation of two prime numbers.
When generating the key,
various symbols will be output to indicate the progress of the generation.
A
.Sq \&.
represents each number which has passed an initial sieve test;
.Sq +
means a number has passed a single round of the Miller-Rabin primality test.
A newline means that the number has passed all the prime tests
(the actual number depends on the key size).
.Pp
The options are as follows:
.Bl -tag -width Ds
.It Fl 3 | f4
The public exponent to use, either 3 or 65537.
The default is 65537.
.It Xo
.Fl aes128 | aes192 | aes256 |
.Fl camellia128 | camellia192 | camellia256 |
.Fl des | des3 |
.Fl idea
.Xc
Encrypt the private key with the AES, CAMELLIA, DES, triple DES
or the IDEA ciphers, respectively, before outputting it.
If none of these options are specified, no encryption is used.
If encryption is used, a pass phrase is prompted for,
if it is not supplied via the
.Fl passout
option.
.It Fl out Ar file
The output file to write to,

is the certificates contained in it.
With the
.Fl toseq
option the situation is reversed:
a Netscape certificate sequence is created from a file of certificates.
.El
.Sh OCSP
.Bl -hang -width "openssl ocsp"
.It Nm openssl ocsp
.Bk -words
.Op Fl CA Ar file
.Op Fl CAfile Ar file
.Op Fl CApath Ar directory
.Op Fl cert Ar file
.Op Fl dgst Ar alg
.Op Fl header Ar name value
.Op Fl host Ar hostname : Ns Ar port
.Op Fl ignore_err
.Op Fl index Ar indexfile
.Op Fl issuer Ar file
.Op Fl ndays Ar days
.Op Fl nmin Ar minutes
.Op Fl no_cert_checks
.Op Fl no_cert_verify
.Op Fl no_certs
.Op Fl no_chain
.Op Fl no_explicit
.Op Fl no_intern
.Op Fl no_nonce
.Op Fl no_signature_verify
.Op Fl nonce
.Op Fl noverify
.Op Fl nrequest Ar number
.Op Fl out Ar file
.Op Fl path Ar path
.Op Fl port Ar portnum
.Op Fl req_text
.Op Fl reqin Ar file
.Op Fl reqout Ar file
.Op Fl resp_key_id
.Op Fl resp_no_certs
.Op Fl resp_text
.Op Fl respin Ar file
.Op Fl respout Ar file
.Op Fl rkey Ar file
.Op Fl rother Ar file
.Op Fl rsigner Ar file
.Op Fl serial Ar num
.Op Fl sign_other Ar file
.Op Fl signer Ar file
.Op Fl signkey Ar file
.Op Fl status_age Ar age
.Op Fl text
.Op Fl timeout Ar seconds
.Op Fl trust_other
.Op Fl url Ar responder_url
.Op Fl VAfile Ar file
.Op Fl validity_period Ar nsec
.Op Fl verify_other Ar file
.Ek
.El
.Pp
The Online Certificate Status Protocol (OCSP)
enables applications to determine the (revocation) state
of an identified certificate (RFC 2560).
.Pp
The
.Nm ocsp

.Ar hostname
on
.Ar port .
.Fl path
specifies the HTTP path name to use, or
.Pa /
by default.
.It Fl header Ar name value
Add the header name with the specified value to the OCSP request that is sent
to the responder.
This may be repeated.
.It Fl issuer Ar file
The current issuer certificate, in PEM format.
Can be used multiple times and must come before any
.Fl cert
options.
.It Fl no_cert_checks
Don't perform any additional checks on the OCSP response signer's certificate.
That is, do not make any checks to see if the signer's certificate is
authorised to provide the necessary status information:
as a result this option should only be used for testing purposes.
.It Fl no_cert_verify
Don't verify the OCSP response signer's certificate at all.
Since this option allows the OCSP response to be signed by any certificate,
it should only be used for testing purposes.
.It Fl no_certs
Don't include any certificates in the signed request.
.It Fl no_chain
Do not use certificates in the response as additional untrusted CA
certificates.
.It Fl no_explicit
Don't check the explicit trust for OCSP signing in the root CA certificate.
.It Fl no_intern
Ignore certificates contained in the OCSP response
when searching for the signer's certificate.
The signer's certificate must be specified with either the
.Fl verify_other
or
.Fl VAfile

.Fl signkey
option.
If the
.Fl signkey
option is not present, then the private key is read from the same file
as the certificate.
If neither option is specified, the OCSP request is not signed.
.It Fl timeout Ar seconds
Connection timeout to the OCSP responder in seconds.
.It Fl trust_other
The certificates specified by the
.Fl verify_other
option should be explicitly trusted and no additional checks will be
performed on them.
This is useful when the complete responder certificate chain is not available
or trusting a root CA is not appropriate.

.El
.Pp
The options for the OCSP server are as follows:
.Bl -tag -width "XXXX"
.It Fl CA Ar file
CA certificate corresponding to the revocation information in
.Ar indexfile .
.It Fl ignore_err
Ignore the invalid response.
.It Fl index Ar indexfile
.Ar indexfile
is a text index file in ca format
containing certificate revocation information.
.Pp
If this option is specified,
.Nm ocsp

and has its own separate certificate chain,
then its root CA can be trusted for OCSP signing.
Alternatively, the responder certificate itself can be explicitly trusted
with the
.Fl VAfile
option.
.Sh PASSWD
.Bl -hang -width "openssl passwd"
.It Nm openssl passwd
.Bk -words
.Op Fl 1 | apr1 | crypt
.Op Fl in Ar file
.Op Fl noverify
.Op Fl quiet
.Op Fl reverse
.Op Fl salt Ar string
.Op Fl stdin
.Op Fl table
.Op Ar password
.Ek
.El
.Pp
The
.Nm passwd
command computes the hash of a password.
.Pp
The options are as follows:
.Bl -tag -width Ds

.It Fl stdin
Read passwords from standard input.
.It Fl table
In the output list, prepend the cleartext password and a TAB character
to each password hash.
.El
.Sh PKCS7
.Bl -hang -width "openssl pkcs7"
.It Nm openssl pkcs7
.Bk -words
.Op Fl in Ar file
.Op Fl inform Cm der | pem
.Op Fl noout
.Op Fl out Ar file
.Op Fl outform Cm der | pem
.Op Fl print
.Op Fl print_certs
.Op Fl text
.Ek
.El
.Pp
The
.Nm pkcs7
command processes PKCS#7 files in DER or PEM format.
The PKCS#7 routines only understand PKCS#7 v 1.5 as specified in RFC 2315.
.Pp
The options are as follows:

.Fl print_certs
is set).
.It Fl out Ar file
The output to write to,
or standard output if not specified.
.It Fl outform Cm der | pem
The output format.
.It Fl print
Print the ASN.1 representation of PKCS#7 structure.
.It Fl print_certs
Print any certificates or CRLs contained in the file,
preceded by their subject and issuer names in a one-line format.
.It Fl text
Print certificate details in full rather than just subject and issuer names.
.El
.Sh PKCS8
.Bl -hang -width "openssl pkcs8"
.It Nm openssl pkcs8
.Bk -words
.Op Fl in Ar file
.Op Fl inform Cm der | pem
.Op Fl nocrypt
.Op Fl noiter
.Op Fl out Ar file
.Op Fl outform Cm der | pem
.Op Fl passin Ar arg
.Op Fl passout Ar arg
.Op Fl topk8
.Op Fl v1 Ar alg
.Op Fl v2 Ar alg
.Ek
.El
.Pp
The
.Nm pkcs8
command processes private keys
(both encrypted and unencrypted)
in PKCS#8 format
with a variety of PKCS#5 (v1.5 and v2.0) and PKCS#12 algorithms.

.Pp
.Ar alg
is the encryption algorithm to use;
valid values include des, des3, and rc2.
It is recommended that des3 is used.
.El
.Sh PKCS12
.Bl -hang -width "openssl pkcs12"
.It Nm openssl pkcs12
.Bk -words
.Oo
.Fl aes128 | aes192 | aes256 | camellia128 |
.Fl camellia192 | camellia256 | des | des3 | idea
.Oc
.Op Fl cacerts
.Op Fl CAfile Ar file
.Op Fl caname Ar name
.Op Fl CApath Ar directory
.Op Fl certfile Ar file
.Op Fl certpbe Ar alg
.Op Fl chain
.Op Fl clcerts
.Op Fl CSP Ar name
.Op Fl descert
.Op Fl export
.Op Fl in Ar file
.Op Fl info
.Op Fl inkey Ar file
.Op Fl keyex
.Op Fl keypbe Ar alg
.Op Fl keysig
.Op Fl LMK
.Op Fl macalg Ar alg
.Op Fl maciter
.Op Fl name Ar name
.Op Fl nocerts
.Op Fl nodes
.Op Fl noiter
.Op Fl nokeys
.Op Fl nomac
.Op Fl nomaciter
.Op Fl nomacver
.Op Fl noout
.Op Fl out Ar file
.Op Fl passin Ar arg
.Op Fl passout Ar arg
.Op Fl password Ar arg
.Op Fl twopass
.Ek
.El
.Pp
The
.Nm pkcs12
command allows PKCS#12 files
.Pq sometimes referred to as PFX files
to be created and parsed.
By default, a PKCS#12 file is parsed;
a PKCS#12 file can be created by using the
.Fl export
option.
.Pp
The options for parsing a PKCS12 file are as follows:
.Bl -tag -width "XXXX"
.It Xo
.Fl aes128 | aes192 | aes256 |
.Fl camellia128 | camellia192 | camellia256 |
.Fl des | des3 |
.Fl idea
.Xc
Encrypt private keys using AES, CAMELLIA, DES, triple DES
or the IDEA ciphers, respectively.
The default is triple DES.
.It Fl cacerts
Only output CA certificates
.Pq not client certificates .
.It Fl clcerts
Only output client certificates
.Pq not CA certificates .

used for encryption purposes, but arbitrary length keys for signing.
The
.Fl keysig
option marks the key for signing only.
Signing only keys can be used for S/MIME signing, authenticode
(ActiveX control signing)
and SSL client authentication.
.It Fl LMK
Add local machine keyset attribute to private key.
.It Fl macalg Ar alg
Specify the MAC digest algorithm.
The default is SHA1.
.It Fl maciter
Included for compatibility only:
it used to be needed to use MAC iterations counts
but they are now used by default.

.It Fl out Ar file
The output file to write to,
or standard output if not specified.
.It Fl passin Ar arg
The key password source.
.It Fl passout Ar arg
The output file password source.
.It Fl password Ar arg
With
.Fl export ,
.Fl password
is equivalent to
.Fl passout .
Otherwise,
.Fl password
is equivalent to
.Fl passin .
.El
.Sh PKEY

.Bl -hang -width "openssl pkey"
.It Nm openssl pkey
.Bk -words
.Op Ar cipher
.Op Fl in Ar file
.Op Fl inform Cm der | pem
.Op Fl noout
.Op Fl out Ar file
.Op Fl outform Cm der | pem
.Op Fl passin Ar arg
.Op Fl passout Ar arg
.Op Fl pubin
.Op Fl pubout
.Op Fl text
.Op Fl text_pub
.Ek
.El
.Pp
The
.Nm pkey
command processes public or private keys.
They can be converted between various forms
and their components printed out.
.Pp

.It Fl out Ar file
The output file to write to,
or standard output if not specified.
.It Fl text
Print the parameters in plain text.
.El
.Sh PKEYUTL
.Bl -hang -width "openssl pkeyutl"
.It Nm openssl pkeyutl
.Bk -words
.Op Fl asn1parse
.Op Fl certin
.Op Fl decrypt
.Op Fl derive
.Op Fl encrypt
.Op Fl hexdump
.Op Fl in Ar file
.Op Fl inkey Ar file
.Op Fl keyform Cm der | pem
.Op Fl out Ar file
.Op Fl passin Ar arg
.Op Fl peerform Cm der | pem
.Op Fl peerkey Ar file
.Op Fl pkeyopt Ar opt : Ns Ar value
.Op Fl pubin
.Op Fl rev
.Op Fl sigfile Ar file
.Op Fl sign
.Op Fl verify
.Op Fl verifyrecover
.Ek
.El
.Pp
The
.Nm pkeyutl
command can be used to perform public key operations using
any supported algorithm.
.Pp
The options are as follows:

(i.e. a prime p so that (p-1)/2 is also prime).
.It Ar p
Test if number
.Ar p
is prime.
.El
.Sh RAND
.Bl -hang -width "openssl rand"
.It Nm openssl rand
.Bk -words
.Op Fl base64
.Op Fl hex
.Op Fl out Ar file
.Ar num
.Ek
.El
.Pp
The
.Nm rand
command outputs
.Ar num
pseudo-random bytes.
.Pp
The options are as follows:
.Bl -tag -width Ds
.It Fl base64
Perform base64 encoding on the output.
.It Fl hex
Specify hexadecimal output.
.It Fl out Ar file
The output file to write to,
or standard output if not specified.
.El
.Sh REQ
.Bl -hang -width "openssl req"
.It Nm openssl req
.Bk -words
.Op Fl asn1-kludge
.Op Fl batch
.Op Fl config Ar file
.Op Fl days Ar n
.Op Fl extensions Ar section
.Op Fl in Ar file
.Op Fl inform Cm der | pem
.Op Fl key Ar keyfile
.Op Fl keyform Cm der | pem
.Op Fl keyout Ar file
.Op Fl md4 | md5 | sha1
.Op Fl modulus
.Op Fl multivalue-rdn
.Op Fl nameopt Ar option
.Op Fl new
.Op Fl newhdr
.Op Fl newkey Ar arg
.Op Fl no-asn1-kludge
.Op Fl nodes
.Op Fl noout
.Op Fl out Ar file
.Op Fl outform Cm der | pem
.Op Fl passin Ar arg
.Op Fl passout Ar arg
.Op Fl pkeyopt Ar opt:value
.Op Fl pubkey
.Op Fl reqexts Ar section
.Op Fl reqopt Ar option
.Op Fl set_serial Ar n
.Op Fl sigopt Ar nm:v
.Op Fl subj Ar arg
.Op Fl subject
.Op Fl text
.Op Fl utf8
.Op Fl verbose
.Op Fl verify
.Op Fl x509
.Ek
.El
.Pp
The
.Nm req
command primarily creates and processes certificate requests
in PKCS#10 format.
It can additionally create self-signed certificates,
for use as root CAs, for example.

The message digest to sign the request with.
This overrides the digest algorithm specified in the configuration file.
.Pp
Some public key algorithms may override this choice.
For instance, DSA signatures always use SHA1.
.It Fl modulus
Print the value of the modulus of the public key contained in the request.
.It Fl multivalue-rdn
This option causes the
.Fl subj
argument to be interpreted with full support for multivalued RDNs,
for example
.Qq "/DC=org/DC=OpenSSL/DC=users/UID=123456+CN=John Doe" .
If
.Fl multivalue-rdn
is not used, the UID value is set to
.Qq "123456+CN=John Doe" .
.It Fl nameopt Ar option , Fl reqopt Ar option
Determine how the subject or issuer names are displayed.
.Ar option
can be a single option or multiple options separated by commas.
Alternatively, these options may be used more than once to set multiple options.
See the
.Sx X509
section below for details.
.It Fl new
Generate a new certificate request.
The user is prompted for the relevant field values.
The actual fields prompted for and their maximum and minimum sizes
are specified in the configuration file and any requested extensions.
.Pp
If the
.Fl key
option is not used, it will generate a new RSA private
key using information specified in the configuration file.
.It Fl newhdr
Add the word NEW to the PEM file header and footer lines
on the outputted request.
Some software and CAs need this.
.It Fl newkey Ar arg
Create a new certificate request and a new private key.
The argument takes one of several forms.
.Pp
.No rsa : Ns Ar nbits
generates an RSA key

or standard output if not specified.
.It Fl outform Cm der | pem
The output format.
.It Fl passin Ar arg
The key password source.
.It Fl passout Ar arg
The output file password source.
.It Fl pkeyopt Ar opt:value
Set the public key algorithm option
.Ar opt
to
.Ar value .
.It Fl pubkey
Output the public key.
.It Fl reqopt Ar option
Customise the output format used with
.Fl text .
The
.Ar option
argument can be a single option or multiple options separated by commas.
See also the discussion of
.Fl certopt
in the
.Nm x509
command.
.It Fl set_serial Ar n
Serial number to use when outputting a self-signed certificate.
This may be specified as a decimal value or a hex value if preceded by
.Sq 0x .
It is possible to use negative serial numbers but this is not recommended.
.It Fl sigopt Ar nm:v
Pass options to the signature algorithm during sign operation.
The names and values of these options are algorithm-specific.
.It Fl subj Ar arg
Replaces the subject field of an input request
with the specified data and output the modified request.
.Ar arg
must be formatted as /type0=value0/type1=value1/type2=...;
characters may be escaped by
.Sq \e

.Cm oid_file
or
.Cm oid_section
options in the configuration file.
Any additional fields will be treated as though they were a
.Cm DirectoryString .
.Sh RSA
.Bl -hang -width "openssl rsa"
.It Nm openssl rsa
.Bk -words
.Op Fl aes128 | aes192 | aes256 | des | des3
.Op Fl check
.Op Fl in Ar file
.Op Fl inform Cm der | net | pem | pvk
.Op Fl modulus
.Op Fl noout
.Op Fl out Ar file
.Op Fl outform Cm der | net | pem | pvk
.Op Fl passin Ar arg
.Op Fl passout Ar arg
.Op Fl pubin
.Op Fl pubout
.Op Fl pvk-none | pvk-strong | pvk-weak
.Op Fl RSAPublicKey_in
.Op Fl RSAPublicKey_out
.Op Fl sgckey
.Op Fl text
.Ek
.El
.Pp
The
.Nm rsa
command processes RSA keys.
They can be converted between various forms and their components printed out.
.Nm rsa
uses the traditional

These options can only be used with PEM format output files.
.It Fl check
Check the consistency of an RSA private key.
.It Fl in Ar file
The input file to read from,
or standard input if not specified.
If the key is encrypted, a pass phrase will be prompted for.
.It Fl inform Cm der | net | pem | pvk
The input format.
.It Fl noout
Do not output the encoded version of the key.
.It Fl modulus
Print the value of the modulus of the key.
.It Fl out Ar file
The output file to write to,
or standard output if not specified.
.It Fl outform Cm der | net | pem | pvk
The output format.
.It Fl passin Ar arg
The key password source.
.It Fl passout Ar arg
The output file password source.
.It Fl pubin
Read in a public key,
not a private key.
.It Fl pubout
Output a public key,
not a private key.
Automatically set if the input is a public key.
.It Xo
.Fl pvk-none | pvk-strong | pvk-weak
.Xc
Enable or disable PVK encoding.
The default is
.Fl pvk-strong .
.It Fl RSAPublicKey_in , RSAPublicKey_out
Same as
.Fl pubin
and
.Fl pubout
except
.Cm RSAPublicKey
format is used instead.
.It Fl sgckey
Use the modified NET algorithm used with some versions of Microsoft IIS
and SGC keys.
.It Fl text
Print the public/private key components in plain text.
.El
.Sh RSAUTL
.Bl -hang -width "openssl rsautl"
.It Nm openssl rsautl
.Bk -words
.Op Fl asn1parse
.Op Fl certin
.Op Fl decrypt
.Op Fl encrypt
.Op Fl hexdump
.Op Fl in Ar file
.Op Fl inkey Ar file
.Op Fl keyform Cm der | pem
.Op Fl oaep | pkcs | raw | x931
.Op Fl out Ar file
.Op Fl passin Ar arg
.Op Fl pubin
.Op Fl rev
.Op Fl sign
.Op Fl verify
.Ek
.El
.Pp
The
.Nm rsautl
command can be used to sign, verify, encrypt and decrypt
data using the RSA algorithm.
.Pp
The options are as follows:

.It Fl sign
Sign the input data and output the signed result.
This requires an RSA private key.
.It Fl verify
Verify the input data and output the recovered data.
.El
.Sh S_CLIENT
.Bl -hang -width "openssl s_client"
.It Nm openssl s_client
.Bk -words
.Op Fl 4 | 6
.Op Fl alpn Ar protocols
.Op Fl bugs
.Op Fl CAfile Ar file
.Op Fl CApath Ar directory
.Op Fl cert Ar file
.Op Fl certform Cm der | pem
.Op Fl check_ss_sig
.Op Fl cipher Ar cipherlist
.Op Fl connect Ar host Ns Op : Ns Ar port
.Op Fl crl_check
.Op Fl crl_check_all
.Op Fl crlf
.Op Fl debug
.Op Fl dtls1
.Op Fl extended_crl
.Op Fl groups
.Op Fl host Ar host
.Op Fl ign_eof
.Op Fl ignore_critical
.Op Fl issuer_checks
.Op Fl key Ar keyfile
.Op Fl keyform Cm der | pem
.Op Fl keymatexport Ar label
.Op Fl keymatexportlen Ar len
.Op Fl legacy_server_connect
.Op Fl msg
.Op Fl mtu Ar mtu
.Op Fl nbio
.Op Fl nbio_test
.Op Fl no_comp
.Op Fl no_ign_eof
.Op Fl no_legacy_server_connect
.Op Fl no_ticket
.Op Fl no_tls1
.Op Fl no_tls1_1
.Op Fl no_tls1_2
.Op Fl pass Ar arg
.Op Fl pause
.Op Fl policy_check
.Op Fl port Ar port
.Op Fl prexit
.Op Fl proxy Ar host : Ns Ar port


.Op Fl quiet
.Op Fl reconnect
.Op Fl servername Ar name
.Op Fl serverpref
.Op Fl sess_in Ar file
.Op Fl sess_out Ar file
.Op Fl showcerts
.Op Fl starttls Ar protocol
.Op Fl state
.Op Fl status
.Op Fl timeout
.Op Fl tls1
.Op Fl tls1_1
.Op Fl tls1_2
.Op Fl tlsextdebug
.Op Fl use_srtp Ar profiles
.Op Fl verify Ar depth
.Op Fl verify_return_error
.Op Fl x509_strict
.Op Fl xmpphost Ar host
.Ek
.El
.Pp
The
.Nm s_client
command implements a generic SSL/TLS client which connects
to a remote host using SSL/TLS.
.Pp
If a connection is established with an SSL server, any data received

.Pp
The options are as follows:
.Bl -tag -width Ds
.It Fl 4
Attempt connections using IPv4 only.
.It Fl 6
Attempt connections using IPv6 only.
.It Fl alpn Ar protocols
Enable the Application-Layer Protocol Negotiation.
.Ar protocols
is a comma-separated list of protocol names that the client should advertise
support for.
.It Fl bugs
Enable various workarounds for buggy implementations.
.It Fl CAfile Ar file
A
.Ar file
containing trusted certificates to use during server authentication
and to use when attempting to build the client certificate chain.
.It Fl CApath Ar directory
The
.Ar directory
to use for server certificate verification.
This directory must be in
.Qq hash format ;
see
.Fl verify
for more information.
These are also used when building the client certificate chain.
.It Fl cert Ar file
The certificate to use, if one is requested by the server.
The default is not to use a certificate.
.It Fl certform Cm der | pem
The certificate format.
The default is
.Cm pem .
.It Xo
.Fl check_ss_sig ,
.Fl crl_check ,
.Fl crl_check_all ,
.Fl extended_crl ,
.Fl ignore_critical ,
.Fl issuer_checks ,

character,
which is useful for numeric IPv6 addresses.
.It Fl crlf
Translate a line feed from the terminal into CR+LF,
as required by some servers.
.It Fl debug
Print extensive debugging information, including a hex dump of all traffic.
.It Fl dtls1
Permit only DTLS1.0.
.It Fl groups Ar ecgroups
Specify a colon-separated list of permitted EC curve groups.
.It Fl host Ar host
The
.Ar host
to connect to.
The default is localhost.
.It Fl ign_eof
Inhibit shutting down the connection when end of file is reached in the input.
.It Fl key Ar keyfile
The private key to use.
If not specified, the certificate file will be used.
.It Fl keyform Cm der | pem
The private key format.
The default is
.Cm pem .
.It Fl keymatexport Ar label
Export keying material using label.
.It Fl keymatexportlen Ar len
Export len bytes of keying material (default 20).
.It Fl legacy_server_connect , no_legacy_server_connect
Allow or disallow initial connection to servers that don't support RI.
.It Fl msg
Show all protocol messages with hex dump.
.It Fl mtu Ar mtu
Set the link layer MTU.
.It Fl nbio
Turn on non-blocking I/O.
.It Fl nbio_test
Test non-blocking I/O.
.It Fl no_ign_eof
Shut down the connection when end of file is reached in the input.
Can be used to override the implicit
.Fl ign_eof
after
.Fl quiet .
.It Fl no_tls1 | no_tls1_1 | no_tls1_2
Disable the use of TLS1.0, 1.1, and 1.2, respectively.
.It Fl no_ticket
Disable RFC 4507 session ticket support.
.It Fl pass Ar arg
The private key password source.
.It Fl pause
Pause 1 second between each read and write call.
.It Fl port Ar port
The
.Ar port
to connect to.
The default is 4433.
.It Fl prexit
Print session information when the program exits.
This will always attempt
to print out information even if the connection fails.
Normally, information will only be printed out once if the connection succeeds.
This option is useful because the cipher in use may be renegotiated
or the connection may fail because a client certificate is required or is

.Ar port .
The connection to the proxy is done in cleartext and the
.Fl connect
argument is given to the proxy.
If not specified, localhost is used as final destination.
After that, switch the connection through the proxy to the destination
to TLS.










.It Fl quiet
Inhibit printing of session and certificate information.
This implicitly turns on
.Fl ign_eof
as well.
.It Fl reconnect
Reconnect to the same server 5 times using the same session ID; this can
be used as a test that session caching is working.
.It Fl servername Ar name
Include the TLS Server Name Indication (SNI) extension in the ClientHello
message, using the specified server
.Ar name .
.It Fl showcerts
Display the whole server certificate chain: normally only the server
certificate itself is displayed.
.It Fl serverpref
Use the server's cipher preferences.
.It Fl sess_in Ar file
Load TLS session from file.
The client will attempt to resume a connection from this session.
.It Fl sess_out Ar file
Output TLS session to file.
.It Fl starttls Ar protocol
Send the protocol-specific messages to switch to TLS for communication.
.Ar protocol
is a keyword for the intended protocol.
Currently, the supported keywords are
.Qq ftp ,
.Qq imap ,
.Qq smtp ,
.Qq pop3 ,
and
.Qq xmpp .
.It Fl state
Print the SSL session states.
.It Fl status
Send a certificate status request to the server (OCSP stapling).
The server response (if any) is printed out.
.It Fl timeout
Enable send/receive timeout on DTLS connections.
.It Fl tls1 | tls1_1 | tls1_2
Permit only TLS1.0, 1.1, or 1.2, respectively.
.It Fl tlsextdebug
Print a hex dump of any TLS extensions received from the server.
.It Fl use_srtp Ar profiles
Offer SRTP key management with a colon-separated profile list.
.It Fl verify Ar depth
Turn on server certificate verification,
with a maximum length of
.Ar depth .
Currently the verify operation continues after errors so all the problems
with a certificate chain can be seen.
As a side effect the connection will never fail due to a server
certificate verify failure.
.It Fl verify_return_error
Return verification error.
.It Fl xmpphost Ar hostname
When used with
.Fl starttls Ar xmpp ,
specify the host for the "to" attribute of the stream element.
If this option is not specified then the host specified with
.Fl connect
will be used.
.El
.Sh S_SERVER
.Bl -hang -width "openssl s_server"
.It Nm openssl s_server
.Bk -words
.Op Fl accept Ar port
.Op Fl alpn Ar protocols
.Op Fl bugs
.Op Fl CAfile Ar file
.Op Fl CApath Ar directory
.Op Fl cert Ar file
.Op Fl cert2 Ar file
.Op Fl certform Cm der | pem
.Op Fl cipher Ar cipherlist
.Op Fl context Ar id
.Op Fl crl_check
.Op Fl crl_check_all
.Op Fl crlf
.Op Fl dcert Ar file
.Op Fl dcertform Cm der | pem
.Op Fl debug
.Op Fl dhparam Ar file
.Op Fl dkey Ar file
.Op Fl dkeyform Cm der | pem
.Op Fl dpass Ar arg
.Op Fl dtls1
.Op Fl HTTP
.Op Fl id_prefix Ar arg
.Op Fl key Ar keyfile
.Op Fl key2 Ar keyfile
.Op Fl keyform Cm der | pem
.Op Fl keymatexport Ar label
.Op Fl keymatexportlen Ar len
.Op Fl msg
.Op Fl mtu Ar mtu
.Op Fl named_curve Ar arg
.Op Fl nbio
.Op Fl nbio_test
.Op Fl no_cache
.Op Fl no_dhe
.Op Fl no_ecdhe
.Op Fl no_ticket
.Op Fl no_tls1
.Op Fl no_tls1_1
.Op Fl no_tls1_2
.Op Fl no_tmp_rsa
.Op Fl nocert
.Op Fl pass Ar arg
.Op Fl quiet
.Op Fl servername Ar name
.Op Fl servername_fatal
.Op Fl serverpref
.Op Fl state
.Op Fl status
.Op Fl status_timeout Ar nsec
.Op Fl status_url Ar url
.Op Fl status_verbose
.Op Fl timeout
.Op Fl tls1
.Op Fl tls1_1
.Op Fl tls1_2
.Op Fl tlsextdebug
.Op Fl use_srtp Ar profiles
.Op Fl Verify Ar depth
.Op Fl verify Ar depth
.Op Fl verify_return_error
.Op Fl WWW
.Op Fl www
.Ek
.El
.Pp
The
.Nm s_server
command implements a generic SSL/TLS server which listens
for connections on a given port using SSL/TLS.
.Pp
If a connection request is established with a client and neither the

The options are as follows:
.Bl -tag -width Ds
.It Fl accept Ar port
Listen on TCP
.Ar port
for connections.
The default is port 4433.
.It Fl alpn Ar protocols
Enable the Application-Layer Protocol Negotiation.
.Ar protocols
is a comma-separated list of supported protocol names.
.It Fl bugs
Enable various workarounds for buggy implementations.
.It Fl CAfile Ar file
A
.Ar file
containing trusted certificates to use during client authentication
and to use when attempting to build the server certificate chain.

The certificate to use: most server's cipher suites require the use of a
certificate and some require a certificate with a certain public key type.
For example, the DSS cipher suites require a certificate containing a DSS
(DSA) key.
If not specified, the file
.Pa server.pem
will be used.
.It Fl cert2 Ar file
The certificate to use for servername.
.It Fl certform Cm der | pem
The certificate format.
The default is
.Cm pem .
.It Fl cipher Ar cipherlist
Modify the cipher list used by the server.
This allows the cipher list used by the server to be modified.
When the client sends a list of supported ciphers, the first client cipher
also included in the server list is used.
Because the client specifies the preference order, the order of the server
cipherlist is irrelevant.

and
.Fl key
options except there is no default if they are not specified
(no additional certificate or key is used).
By using RSA and DSS certificates and keys,
a server can support clients which only support RSA or DSS cipher suites
by using an appropriate certificate.
.It Fl dcertform Cm der | pem , Fl dkeyform Cm der | pem , Fl dpass Ar arg
Additional certificate and private key format, and private key password source,
respectively.
.It Fl debug
Print extensive debugging information, including a hex dump of all traffic.
.It Fl dhparam Ar file
The DH parameter file to use.
The ephemeral DH cipher suites generate keys
using a set of DH parameters.
If not specified, an attempt is made to
load the parameters from the server certificate file.
If this fails, a static set of parameters hard coded into the
.Nm s_server
program will be used.
.It Fl dtls1
Permit only DTLS1.0.
.It Fl HTTP
Emulate a simple web server.
Pages are resolved relative to the current directory.
For example if the URL
.Pa https://myhost/page.html
is requested, the file
.Pa ./page.html
will be loaded.
The files loaded are assumed to contain a complete and correct HTTP
response (lines that are part of the HTTP response line and headers
must end with CRLF).
.It Fl id_prefix Ar arg
Generate SSL/TLS session IDs prefixed by
.Ar arg .
This is mostly useful for testing any SSL/TLS code
that wish to deal with multiple servers,
when each of which might be generating a unique range of session IDs.
.It Fl key Ar keyfile
The private key to use.
If not specified, the certificate file will be used.
.It Fl key2 Ar keyfile
The private key to use for servername.
.It Fl keyform Cm der | pem
The private key format.
The default is
.Cm pem .
.It Fl keymatexport Ar label
Export keying material using label.
.It Fl keymatexportlen Ar len
Export len bytes of keying material (default 20).
.It Fl msg
Show all protocol messages with hex dump.
.It Fl mtu Ar mtu
Set the link layer MTU.
.It Fl named_curve Ar arg
Specify the elliptic curve name to use for ephemeral ECDH keys.
.It Fl nbio
Turn on non-blocking I/O.
.It Fl nbio_test
Test non-blocking I/O.
.It Fl no_cache
Disable session caching.
.It Fl no_dhe
Disable ephemeral DH cipher suites.
.It Fl no_ecdhe
Disable ephemeral ECDH cipher suites.
.It Fl no_ticket
Disable RFC 4507 session ticket support.
.It Fl no_tls1 | no_tls1_1 | no_tls1_2
Disable the use of TLS1.0, 1.1, and 1.2, respectively.
.It Fl no_tmp_rsa
Disable temporary RSA key generation.
.It Fl nocert
Do not use a certificate.
This restricts the cipher suites available to the anonymous ones
(currently just anonymous DH).
.It Fl pass Ar arg

The private key password source.







.It Fl quiet
Inhibit printing of session and certificate information.
.It Fl servername Ar name
Set the TLS Server Name Indication (SNI) extension with
.Ar name .
.It Fl servername_fatal
Send fatal alert if servername does not match.
The default is warning alert.
.It Fl serverpref
Use server's cipher preferences.
.It Fl state
Print the SSL session states.
.It Fl status
Enables certificate status request support (OCSP stapling).
.It Fl status_timeout Ar nsec
Sets the timeout for OCSP response in seconds.
.It Fl status_url Ar url
Sets a fallback responder URL to use if no responder URL is present in the
server certificate.
Without this option, an error is returned if the server certificate does not
contain a responder address.
.It Fl status_verbose
Enables certificate status request support (OCSP stapling) and gives a verbose
printout of the OCSP response.
.It Fl timeout
Enable send/receive timeout on DTLS connections.
.It Fl tls1 | tls1_1 | tls1_2
Permit only TLS1.0, 1.1, or 1.2, respectively.
.It Fl tlsextdebug
Print a hex dump of any TLS extensions received from the server.
.It Fl use_srtp Ar profiles
Offer SRTP key management with a colon-separated profile list.
.It Fl verify_return_error
Return verification error.
.It Fl WWW
Emulate a simple web server.
Pages are resolved relative to the current directory.
For example if the URL
.Pa https://myhost/page.html
is requested, the file
.Pa ./page.html

.Fl Verify ,
the client must supply a certificate or an error occurs;
with
.Fl verify ,
a certificate is requested but the client does not have to send one.
.El
.Sh S_TIME
.Bl -hang -width "openssl s_time"
.It Nm openssl s_time
.Bk -words
.Op Fl bugs
.Op Fl CAfile Ar file
.Op Fl CApath Ar directory
.Op Fl cert Ar file
.Op Fl cipher Ar cipherlist
.Op Fl connect Ar host Ns Op : Ns Ar port
.Op Fl key Ar keyfile
.Op Fl nbio
.Op Fl new
.Op Fl no_shutdown
.Op Fl reuse
.Op Fl time Ar seconds
.Op Fl verify Ar depth
.Op Fl www Ar page
.Ek
.El
.Pp
The
.Nm s_time
command implements a generic SSL/TLS client which connects to a
remote host using SSL/TLS.
It can request a page from the server and includes
the time to transfer the payload data in its timing measurements.

gets the index.htm[l] page.
If this parameter is not specified,
.Nm s_time
will only perform the handshake to establish SSL connections
but not transfer any payload data.
.El
.Sh SESS_ID
.Bl -hang -width "openssl sess_id"
.It Nm openssl sess_id
.Bk -words
.Op Fl cert
.Op Fl context Ar ID
.Op Fl in Ar file
.Op Fl inform Cm der | pem
.Op Fl noout
.Op Fl out Ar file
.Op Fl outform Cm der | pem
.Op Fl text
.Ek
.El
.Pp
The
.Nm sess_id
program processes the encoded version of the SSL session structure and
optionally prints out SSL session details
(for example the SSL session master key)
in human-readable format.

Therefore appropriate security precautions
should be taken if the information is being output by a
.Qq real
application.
This is, however, strongly discouraged and should only be used for
debugging purposes.
.Sh SMIME
.Bl -hang -width "openssl smime"
.It Nm openssl smime
.Bk -words
.Oo
.Fl aes128 | aes192 | aes256 | des |
.Fl des3 | rc2-40 | rc2-64 | rc2-128
.Oc
.Op Fl binary
.Op Fl CAfile Ar file
.Op Fl CApath Ar directory

.Op Fl from Ar addr
.Op Fl ignore_critical
.Op Fl in Ar file
.Op Fl indef
.Op Fl inform Cm der | pem | smime
.Op Fl inkey Ar file
.Op Fl issuer_checks
.Op Fl keyform Cm der | pem
.Op Fl md Ar digest
.Op Fl noattr
.Op Fl nocerts
.Op Fl nochain
.Op Fl nodetach
.Op Fl noindef
.Op Fl nointern
.Op Fl nosigs
.Op Fl nosmimecap
.Op Fl noverify
.Op Fl out Ar file
.Op Fl outform Cm der | pem | smime
.Op Fl passin Ar arg
.Op Fl pk7out
.Op Fl policy_check
.Op Fl recip Ar file
.Op Fl resign
.Op Fl sign
.Op Fl signer Ar file
.Op Fl stream
.Op Fl subject Ar s
.Op Fl text
.Op Fl to Ar addr
.Op Fl verify
.Op Fl x509_strict
.Op Ar cert.pem ...
.Ek
.El
.Pp
The
.Nm smime
command handles S/MIME mail.
It can encrypt, decrypt, sign, and verify S/MIME messages.
.Pp
The MIME message must be sent without any blank lines between the

the
.Fl recip
or
.Fl signer
file.
When signing,
this option can be used multiple times to specify successive keys.
.It Fl keyform Cm der | pem
Input private key format.
The default is
.Cm pem .
.It Fl md Ar digest
The digest algorithm to use when signing or resigning.
If not present then the default digest algorithm for the signing key is used
(usually SHA1).
.It Fl noattr
Do not include attributes.
.It Fl nocerts

(currently has no effect).
.It Fl nointern
Only use certificates specified in the
.Fl certfile .
The supplied certificates can still be used as untrusted CAs.
.It Fl nosigs
Do not try to verify the signatures on the message.
.It Fl nosmimecap
Exclude the list of supported algorithms from signed attributes,
other options such as signing time and content type are still included.
.It Fl noverify
Do not verify the signer's certificate of a signed message.
.It Fl out Ar file
The output file to write to.
.It Fl outform Cm der | pem | smime
The output format.
The default is smime, which writes an S/MIME format message.

An error occurred creating the file or when reading the message.
.It 4
An error occurred decrypting or verifying the message.
.It 5
An error occurred writing certificates.
.El
.Sh SPEED
.Bl -hang -width "openssl speed"
.It Nm openssl speed
.Bk -words
.Op Ar algorithm
.Op Fl decrypt
.Op Fl elapsed
.Op Fl evp Ar algorithm
.Op Fl mr
.Op Fl multi Ar number
.Ek
.El
.Pp
The
.Nm speed
command is used to test the performance of cryptographic algorithms.
.Bl -tag -width "XXXX"
.It Ar algorithm
Perform the test using

Produce machine readable output.
.It Fl multi Ar number
Run
.Ar number
benchmarks in parallel.
.El
.Sh SPKAC
.Bl -hang -width "openssl spkac"
.It Nm openssl spkac
.Bk -words
.Op Fl challenge Ar string
.Op Fl in Ar file
.Op Fl key Ar keyfile
.Op Fl noout
.Op Fl out Ar file
.Op Fl passin Ar arg
.Op Fl pubkey
.Op Fl spkac Ar spkacname
.Op Fl spksect Ar section
.Op Fl verify
.Ek
.El
.Pp
The
.Nm spkac
command processes signed public key and challenge (SPKAC) files.
It can print out their contents, verify the signature,
and produce its own SPKACs from a supplied private key.
.Pp

An alternative name for the
.Ar section
containing the SPKAC.
.It Fl verify
Verify the digital signature on the supplied SPKAC.
.El
.Sh TS
.Bk -words
.Bl -hang -width "openssl ts"
.It Nm openssl ts
.Fl query
.Op Fl md4 | md5 | ripemd160 | sha1
.Op Fl cert
.Op Fl config Ar configfile
.Op Fl data Ar file_to_hash
.Op Fl digest Ar digest_bytes
.Op Fl in Ar request.tsq
.Op Fl no_nonce
.Op Fl out Ar request.tsq
.Op Fl policy Ar object_id
.Op Fl text



.It Nm openssl ts
.Fl reply
.Op Fl chain Ar certs_file.pem
.Op Fl config Ar configfile
.Op Fl in Ar response.tsr
.Op Fl inkey Ar private.pem
.Op Fl out Ar response.tsr
.Op Fl passin Ar arg
.Op Fl policy Ar object_id
.Op Fl queryfile Ar request.tsq
.Op Fl section Ar tsa_section
.Op Fl signer Ar tsa_cert.pem
.Op Fl text
.Op Fl token_in
.Op Fl token_out



.It Nm openssl ts
.Fl verify
.Op Fl CAfile Ar trusted_certs.pem
.Op Fl CApath Ar trusted_cert_path
.Op Fl data Ar file_to_hash
.Op Fl digest Ar digest_bytes
.Op Fl in Ar response.tsr
.Op Fl queryfile Ar request.tsq
.Op Fl token_in
.Op Fl untrusted Ar cert_file.pem
.El
.Ek
.Pp
The
.Nm ts
command is a basic Time Stamping Authority (TSA) client and server
application as specified in RFC 3161 (Time-Stamp Protocol, TSP).
A TSA can be part of a PKI deployment and its role is to provide long
term proof of the existence of specific data.

See
.Nm verify
for additional details.
Either this option or
.Fl CApath
must be specified.
.It Fl CApath Ar trusted_cert_path
The directory containing the trusted CA certificates of the client.
See
.Nm verify
for additional details.
Either this option or
.Fl CAfile
must be specified.
.It Fl data Ar file_to_hash

option is specified then the certificate identifiers of the chain will also
be included in the SigningCertificate signed attribute.
If this variable is set to no,
only the signing certificate identifier is included.
The default is no.
.El
.Sh VERIFY
.Bl -hang -width "openssl verify"
.It Nm openssl verify
.Bk -words
.Op Fl CAfile Ar file
.Op Fl CApath Ar directory
.Op Fl check_ss_sig
.Op Fl CRLfile Ar file
.Op Fl crl_check
.Op Fl crl_check_all
.Op Fl explicit_policy
.Op Fl extended_crl
.Op Fl help
.Op Fl ignore_critical
.Op Fl inhibit_any
.Op Fl inhibit_map
.Op Fl issuer_checks
.Op Fl policy_check
.Op Fl purpose Ar purpose
.Op Fl trusted Ar file
.Op Fl untrusted Ar file
.Op Fl verbose
.Op Fl x509_strict
.Op Ar certificates
.Ek
.El
.Pp
The
.Nm verify
command verifies certificate chains.
.Pp
The options are as follows:
.Bl -tag -width Ds




.It Fl CAfile Ar file
A
.Ar file
of trusted certificates.
The
.Ar file
should contain multiple certificates in PEM format, concatenated together.

.Ar hash
is the hashed certificate subject name
(see the
.Fl hash
option of the
.Nm x509
utility).
.It Fl check_ss_sig
Verify the signature on the self-signed root CA.
This is disabled by default
because it doesn't add any security.
.It Fl CRLfile Ar file
The
.Ar file
should contain one or more CRLs in PEM format.
.It Fl crl_check
Check end entity certificate validity by attempting to look up a valid CRL.
If a valid CRL cannot be found an error occurs.
.It Fl crl_check_all
Check the validity of all certificates in the chain by attempting
to look up valid CRLs.
.It Fl explicit_policy

Currently accepted uses are
.Cm sslclient , sslserver ,
.Cm nssslserver , smimesign ,
.Cm smimeencrypt , crlsign ,
.Cm any ,
and
.Cm ocsphelper .
.It Fl trusted Ar file
A
.Ar file
of trusted certificates.
The
.Ar file
should contain multiple certificates.
.It Fl untrusted Ar file
A
.Ar file
of untrusted certificates.
The
.Ar file
should contain multiple certificates.

Platform setting.
.It Fl v
The current
.Nm openssl
version.
.El
.Sh X509
.Bl -hang -width "openssl x509"
.It Nm openssl x509
.Bk -words
.Op Fl C
.Op Fl addreject Ar arg
.Op Fl addtrust Ar arg
.Op Fl alias
.Op Fl CA Ar file
.Op Fl CAcreateserial
.Op Fl CAform Cm der | pem

.Op Fl issuer
.Op Fl issuer_hash
.Op Fl issuer_hash_old
.Op Fl keyform Cm der | pem
.Op Fl md5 | sha1
.Op Fl modulus
.Op Fl nameopt Ar option
.Op Fl next_serial
.Op Fl noout
.Op Fl ocsp_uri
.Op Fl ocspid
.Op Fl out Ar file
.Op Fl outform Cm der | net | pem
.Op Fl passin Ar arg
.Op Fl pubkey
.Op Fl purpose
.Op Fl req
.Op Fl serial
.Op Fl set_serial Ar n
.Op Fl setalias Ar arg
.Op Fl signkey Ar file
.Op Fl sigopt Ar nm:v
.Op Fl startdate
.Op Fl subject
.Op Fl subject_hash
.Op Fl subject_hash_old
.Op Fl text
.Op Fl trustout
.Op Fl x509toreq
.Ek
.El
.Pp
The
.Nm x509
command is a multi-purpose certificate utility.
It can be used to display certificate information, convert certificates to
various forms, sign certificate requests like a
.Qq mini CA ,

.Cm esc_msb )
may result in the correct display of multibyte characters.
Usually, multibyte characters larger than 0xff
are represented using the format \eUXXXX for 16 bits and \eWXXXXXXXX
for 32 bits,
and any UTF8Strings are converted to their character form first.
.El
.It Fl next_serial
Print the next serial number.
.It Fl noout
Do not output the encoded version of the request.
.It Fl ocsp_uri
Print the OCSP responder addresses, if any.
.It Fl ocspid
Print OCSP hash values for the subject name and public key.
.It Fl pubkey
Print the public key.
.It Fl serial
Print the certificate serial number.
.It Fl sigopt Ar nm:v
Pass options to the signature algorithm during sign or certify operations.
The names and values of these options are algorithm-specific.
.It Fl startdate
Print the start date of the certificate; that is, the
.Cm notBefore
date.
.It Fl subject
Print the subject name.
.It Fl subject_hash

Distinguished Encoding Rules (DER)
is a binary format.
.It Cm net
Insecure legacy format.
.It Cm pem
Privacy Enhanced Mail (PEM)
is base64-encoded.
.It Cm pvk
Private Key format.
.It Cm smime
An SMIME format message.
.It Cm txt
Plain ASCII text.
.El
.Sh ENVIRONMENT
The following environment variables affect the execution of

/* $OpenBSD: passwd.c,v 1.10 2019/07/14 03:30:46 guenther Exp $ */

#if defined OPENSSL_NO_MD5
#define NO_MD5CRYPT_1
#endif

#if !defined(OPENSSL_NO_DES) || !defined(NO_MD5CRYPT_1)

	char *salt;
	int table;
	int use1;
	int useapr1;
	int usecrypt;
} passwd_config;

static const struct option passwd_options[] = {
#ifndef NO_MD5CRYPT_1
	{
		.name = "1",
		.desc = "Use MD5 based BSD password algorithm 1",
		.type = OPTION_FLAG,
		.opt.flag = &passwd_config.use1,
	},

/* $OpenBSD: pkcs12.c,v 1.14 2019/07/26 12:35:59 inoguchi Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project.
 */
/* ====================================================================
 * Copyright (c) 1999-2006 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without

#include "apps.h"

#include <openssl/crypto.h>
#include <openssl/err.h>
#include <openssl/pem.h>
#include <openssl/pkcs12.h>



#define NOKEYS		0x1
#define NOCERTS 	0x2
#define INFO		0x4
#define CLCERTS		0x8
#define CACERTS		0x10

int get_cert_chain(X509 *cert, X509_STORE *store, STACK_OF(X509) **chain);
int dump_certs_keys_p12(BIO *out, PKCS12 *p12, char *pass, int passlen,
    int options, char *pempass);
int dump_certs_pkeys_bags(BIO *out, STACK_OF(PKCS12_SAFEBAG) *bags, char *pass,
    int passlen, int options, char *pempass);
int dump_certs_pkeys_bag(BIO *out, PKCS12_SAFEBAG *bags, char *pass,
    int passlen, int options, char *pempass);
int print_attribs(BIO *out, STACK_OF(X509_ATTRIBUTE) *attrlst,
    const char *name);
void hex_prin(BIO *out, unsigned char *buf, int len);
int alg_print(BIO *x, X509_ALGOR *alg);
int cert_load(BIO *in, STACK_OF(X509) *sk);
static int set_pbe(BIO *err, int *ppbe, const char *str);

static struct {
	int add_lmk;
	char *CAfile;
	STACK_OF(OPENSSL_STRING) *canames;
	char *CApath;
	int cert_pbe;
	char *certfile;
	int chain;
	char *csp_name;
	const EVP_CIPHER *enc;
	int export_cert;
	int key_pbe;
	char *keyname;
	int keytype;
	char *infile;
	int iter;
	char *macalg;
	int maciter;
	int macver;
	char *name;
	int noprompt;
	int options;
	char *outfile;
	char *passarg;
	char *passargin;
	char *passargout;
	int twopass;
} pkcs12_config;

static int
pkcs12_opt_canames(char *arg)
{
	if (pkcs12_config.canames == NULL &&
	    (pkcs12_config.canames = sk_OPENSSL_STRING_new_null()) == NULL)
		return (1);

	if (!sk_OPENSSL_STRING_push(pkcs12_config.canames, arg))
		return (1);

	return (0);
}

static int
pkcs12_opt_cert_pbe(char *arg)
{
	return (!set_pbe(bio_err, &pkcs12_config.cert_pbe, arg));
}

static int
pkcs12_opt_key_pbe(char *arg)
{
	return (!set_pbe(bio_err, &pkcs12_config.key_pbe, arg));
}

static int
pkcs12_opt_passarg(char *arg)
{
	pkcs12_config.passarg = arg;
	pkcs12_config.noprompt = 1;
	return (0);
}

static const EVP_CIPHER *get_cipher_by_name(char *name)
{
	if (name == NULL || strcmp(name, "") == 0)
		return (NULL);
#ifndef OPENSSL_NO_AES
	else if (strcmp(name, "aes128") == 0)
		return EVP_aes_128_cbc();
	else if (strcmp(name, "aes192") == 0)
		return EVP_aes_192_cbc();
	else if (strcmp(name, "aes256") == 0)
		return EVP_aes_256_cbc();
#endif
#ifndef OPENSSL_NO_CAMELLIA
	else if (strcmp(name, "camellia128") == 0)
		return EVP_camellia_128_cbc();
	else if (strcmp(name, "camellia192") == 0)
		return EVP_camellia_192_cbc();
	else if (strcmp(name, "camellia256") == 0)
		return EVP_camellia_256_cbc();
#endif
#ifndef OPENSSL_NO_DES
	else if (strcmp(name, "des") == 0)
		return EVP_des_cbc();
	else if (strcmp(name, "des3") == 0)
		return EVP_des_ede3_cbc();
#endif
#ifndef OPENSSL_NO_IDEA
	else if (strcmp(name, "idea") == 0)
		return EVP_idea_cbc();
#endif
	else
		return (NULL);
}

static int
pkcs12_opt_enc(int argc, char **argv, int *argsused)
{
	char *name = argv[0];

	if (*name++ != '-')
		return (1);

	if (strcmp(name, "nodes") == 0)
		pkcs12_config.enc = NULL;
	else if ((pkcs12_config.enc = get_cipher_by_name(name)) == NULL)
		return (1);

	*argsused = 1;
	return (0);
}

static const struct option pkcs12_options[] = {
#ifndef OPENSSL_NO_AES
	{
		.name = "aes128",
		.desc = "Encrypt PEM output with CBC AES",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = pkcs12_opt_enc,
	},
	{
		.name = "aes192",
		.desc = "Encrypt PEM output with CBC AES",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = pkcs12_opt_enc,
	},
	{
		.name = "aes256",
		.desc = "Encrypt PEM output with CBC AES",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = pkcs12_opt_enc,
	},
#endif
#ifndef OPENSSL_NO_CAMELLIA
	{
		.name = "camellia128",
		.desc = "Encrypt PEM output with CBC Camellia",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = pkcs12_opt_enc,
	},
	{
		.name = "camellia192",
		.desc = "Encrypt PEM output with CBC Camellia",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = pkcs12_opt_enc,
	},
	{
		.name = "camellia256",
		.desc = "Encrypt PEM output with CBC Camellia",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = pkcs12_opt_enc,
	},
#endif
	{
		.name = "des",
		.desc = "Encrypt private keys with DES",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = pkcs12_opt_enc,
	},
	{
		.name = "des3",
		.desc = "Encrypt private keys with triple DES (default)",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = pkcs12_opt_enc,
	},
#ifndef OPENSSL_NO_IDEA
	{
		.name = "idea",
		.desc = "Encrypt private keys with IDEA",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = pkcs12_opt_enc,
	},
#endif
	{
		.name = "cacerts",
		.desc = "Only output CA certificates",
		.type = OPTION_VALUE_OR,
		.opt.value = &pkcs12_config.options,
		.value = CACERTS,
	},
	{
		.name = "CAfile",
		.argname = "file",
		.desc = "PEM format file of CA certificates",
		.type = OPTION_ARG,
		.opt.arg = &pkcs12_config.CAfile,
	},
	{
		.name = "caname",
		.argname = "name",
		.desc = "Use name as CA friendly name (can be used more than once)",
		.type = OPTION_ARG_FUNC,
		.opt.argfunc = pkcs12_opt_canames,
	},
	{
		.name = "CApath",
		.argname = "directory",
		.desc = "PEM format directory of CA certificates",
		.type = OPTION_ARG,
		.opt.arg = &pkcs12_config.CApath,
	},
	{
		.name = "certfile",
		.argname = "file",
		.desc = "Add all certs in file",
		.type = OPTION_ARG,
		.opt.arg = &pkcs12_config.certfile,
	},
	{
		.name = "certpbe",
		.argname = "alg",
		.desc = "Specify certificate PBE algorithm (default RC2-40)",
		.type = OPTION_ARG_FUNC,
		.opt.argfunc = pkcs12_opt_cert_pbe,
	},
	{
		.name = "chain",
		.desc = "Add certificate chain",
		.type = OPTION_FLAG,
		.opt.flag = &pkcs12_config.chain,
	},
	{
		.name = "clcerts",
		.desc = "Only output client certificates",
		.type = OPTION_VALUE_OR,
		.opt.value = &pkcs12_config.options,
		.value = CLCERTS,
	},
	{
		.name = "CSP",
		.argname = "name",
		.desc = "Microsoft CSP name",
		.type = OPTION_ARG,
		.opt.arg = &pkcs12_config.csp_name,
	},
	{
		.name = "descert",
		.desc = "Encrypt PKCS#12 certificates with triple DES (default RC2-40)",
		.type = OPTION_VALUE,
		.opt.value = &pkcs12_config.cert_pbe,
		.value = NID_pbe_WithSHA1And3_Key_TripleDES_CBC,
	},
	{
		.name = "export",
		.desc = "Output PKCS#12 file",
		.type = OPTION_FLAG,
		.opt.flag = &pkcs12_config.export_cert,
	},
	{
		.name = "in",
		.argname = "file",
		.desc = "Input filename",
		.type = OPTION_ARG,
		.opt.arg = &pkcs12_config.infile,
	},
	{
		.name = "info",
		.desc = "Give info about PKCS#12 structure",
		.type = OPTION_VALUE_OR,
		.opt.value = &pkcs12_config.options,
		.value = INFO,
	},
	{
		.name = "inkey",
		.argname = "file",
		.desc = "Private key if not infile",
		.type = OPTION_ARG,
		.opt.arg = &pkcs12_config.keyname,
	},
	{
		.name = "keyex",
		.desc = "Set MS key exchange type",
		.type = OPTION_VALUE,
		.opt.value = &pkcs12_config.keytype,
		.value = KEY_EX,
	},
	{
		.name = "keypbe",
		.argname = "alg",
		.desc = "Specify private key PBE algorithm (default 3DES)",
		.type = OPTION_ARG_FUNC,
		.opt.argfunc = pkcs12_opt_key_pbe,
	},
	{
		.name = "keysig",
		.desc = "Set MS key signature type",
		.type = OPTION_VALUE,
		.opt.value = &pkcs12_config.keytype,
		.value = KEY_SIG,
	},
	{
		.name = "LMK",
		.desc = "Add local machine keyset attribute to private key",
		.type = OPTION_FLAG,
		.opt.flag = &pkcs12_config.add_lmk,
	},
	{
		.name = "macalg",
		.argname = "alg",
		.desc = "Digest algorithm used in MAC (default SHA1)",
		.type = OPTION_ARG,
		.opt.arg = &pkcs12_config.macalg,
	},
	{
		.name = "maciter",
		.desc = "Use MAC iteration",
		.type = OPTION_VALUE,
		.opt.value = &pkcs12_config.maciter,
		.value = PKCS12_DEFAULT_ITER,
	},
	{
		.name = "name",
		.argname = "name",
		.desc = "Use name as friendly name",
		.type = OPTION_ARG,
		.opt.arg = &pkcs12_config.name,
	},
	{
		.name = "nocerts",
		.desc = "Don't output certificates",
		.type = OPTION_VALUE_OR,
		.opt.value = &pkcs12_config.options,
		.value = NOCERTS,
	},
	{
		.name = "nodes",
		.desc = "Don't encrypt private keys",
		.type = OPTION_ARGV_FUNC,
		.opt.argvfunc = pkcs12_opt_enc,
	},
	{
		.name = "noiter",
		.desc = "Don't use encryption iteration",
		.type = OPTION_VALUE,
		.opt.value = &pkcs12_config.iter,
		.value = 1,
	},
	{
		.name = "nokeys",
		.desc = "Don't output private keys",
		.type = OPTION_VALUE_OR,
		.opt.value = &pkcs12_config.options,
		.value = NOKEYS,
	},
	{
		.name = "nomac",
		.desc = "Don't generate MAC",
		.type = OPTION_VALUE,
		.opt.value = &pkcs12_config.maciter,
		.value = -1,
	},
	{
		.name = "nomaciter",
		.desc = "Don't use MAC iteration",
		.type = OPTION_VALUE,
		.opt.value = &pkcs12_config.maciter,
		.value = 1,
	},
	{
		.name = "nomacver",
		.desc = "Don't verify MAC",
		.type = OPTION_VALUE,
		.opt.value = &pkcs12_config.macver,
		.value = 0,
	},
	{
		.name = "noout",
		.desc = "Don't output anything, just verify",
		.type = OPTION_VALUE_OR,
		.opt.value = &pkcs12_config.options,
		.value = (NOKEYS | NOCERTS),
	},
	{
		.name = "out",
		.argname = "file",
		.desc = "Output filename",
		.type = OPTION_ARG,
		.opt.arg = &pkcs12_config.outfile,
	},
	{
		.name = "passin",
		.argname = "arg",
		.desc = "Input file passphrase source",
		.type = OPTION_ARG,
		.opt.arg = &pkcs12_config.passargin,
	},
	{
		.name = "passout",
		.argname = "arg",
		.desc = "Output file passphrase source",
		.type = OPTION_ARG,
		.opt.arg = &pkcs12_config.passargout,
	},
	{
		.name = "password",
		.argname = "arg",
		.desc = "Set import/export password source",
		.type = OPTION_ARG_FUNC,
		.opt.argfunc = pkcs12_opt_passarg,
	},
	{
		.name = "twopass",
		.desc = "Separate MAC, encryption passwords",
		.type = OPTION_FLAG,
		.opt.flag = &pkcs12_config.twopass,
	},
	{ NULL },
};

static void
pkcs12_usage(void)
{
	fprintf(stderr, "usage: pkcs12 [-aes128 | -aes192 | -aes256 |");
	fprintf(stderr, " -camellia128 |\n");
	fprintf(stderr, "    -camellia192 | -camellia256 | -des | -des3 |");
	fprintf(stderr, " -idea]\n");
	fprintf(stderr, "    [-cacerts] [-CAfile file] [-caname name]\n");
	fprintf(stderr, "    [-CApath directory] [-certfile file]");
	fprintf(stderr, " [-certpbe alg]\n");
	fprintf(stderr, "    [-chain] [-clcerts] [-CSP name] [-descert]");
	fprintf(stderr, " [-export]\n");
	fprintf(stderr, "    [-in file] [-info] [-inkey file] [-keyex]");
	fprintf(stderr, " [-keypbe alg]\n");
	fprintf(stderr, "    [-keysig] [-LMK] [-macalg alg] [-maciter]");
	fprintf(stderr, " [-name name]\n");
	fprintf(stderr, "    [-nocerts] [-nodes] [-noiter] [-nokeys]");
	fprintf(stderr, " [-nomac]\n");
	fprintf(stderr, "    [-nomaciter] [-nomacver] [-noout] [-out file]\n");
	fprintf(stderr, "    [-passin arg] [-passout arg] [-password arg]");
	fprintf(stderr, " [-twopass]\n\n");
	options_usage(pkcs12_options);
	fprintf(stderr, "\n");
}

int
pkcs12_main(int argc, char **argv)
{


	BIO *in = NULL, *out = NULL;




	PKCS12 *p12 = NULL;
	char pass[50], macpass[50];










	int ret = 1;



	char *cpass = NULL, *mpass = NULL;

	char *passin = NULL, *passout = NULL;



	if (single_execution) {
		if (pledge("stdio cpath wpath rpath tty", NULL) == -1) {
			perror("pledge");
			exit(1);
		}
	}

	memset(&pkcs12_config, 0, sizeof(pkcs12_config));
	pkcs12_config.cert_pbe = NID_pbe_WithSHA1And40BitRC2_CBC;

	pkcs12_config.enc = EVP_des_ede3_cbc();
	pkcs12_config.iter = PKCS12_DEFAULT_ITER;



























	pkcs12_config.key_pbe = NID_pbe_WithSHA1And3_Key_TripleDES_CBC;





























	pkcs12_config.maciter = PKCS12_DEFAULT_ITER;

	pkcs12_config.macver = 1;




































































































	if (options_parse(argc, argv, pkcs12_options, NULL, NULL) != 0) {

		pkcs12_usage();
















































		goto end;
	}

	if (pkcs12_config.passarg) {
		if (pkcs12_config.export_cert)
			pkcs12_config.passargout = pkcs12_config.passarg;
		else
			pkcs12_config.passargin = pkcs12_config.passarg;
	}
	if (!app_passwd(bio_err, pkcs12_config.passargin,
	    pkcs12_config.passargout, &passin, &passout)) {
		BIO_printf(bio_err, "Error getting passwords\n");
		goto end;
	}
	if (!cpass) {
		if (pkcs12_config.export_cert)
			cpass = passout;
		else
			cpass = passin;
	}
	if (cpass) {
		mpass = cpass;
		pkcs12_config.noprompt = 1;
	} else {
		cpass = pass;
		mpass = macpass;
	}

	if (!pkcs12_config.infile)
		in = BIO_new_fp(stdin, BIO_NOCLOSE);
	else
		in = BIO_new_file(pkcs12_config.infile, "rb");
	if (!in) {
		BIO_printf(bio_err, "Error opening input file %s\n",
		    pkcs12_config.infile ? pkcs12_config.infile : "<stdin>");
		perror(pkcs12_config.infile);
		goto end;
	}

	if (!pkcs12_config.outfile) {
		out = BIO_new_fp(stdout, BIO_NOCLOSE);
	} else
		out = BIO_new_file(pkcs12_config.outfile, "wb");
	if (!out) {
		BIO_printf(bio_err, "Error opening output file %s\n",
		    pkcs12_config.outfile ? pkcs12_config.outfile : "<stdout>");
		perror(pkcs12_config.outfile);
		goto end;
	}
	if (pkcs12_config.twopass) {
		if (EVP_read_pw_string(macpass, sizeof macpass,
		    "Enter MAC Password:", pkcs12_config.export_cert)) {
			BIO_printf(bio_err, "Can't read Password\n");
			goto end;
		}
	}
	if (pkcs12_config.export_cert) {
		EVP_PKEY *key = NULL;
		X509 *ucert = NULL, *x = NULL;
		STACK_OF(X509) *certs = NULL;
		const EVP_MD *macmd = NULL;
		unsigned char *catmp = NULL;
		int i;

		if ((pkcs12_config.options & (NOCERTS | NOKEYS)) ==
		    (NOCERTS | NOKEYS)) {
			BIO_printf(bio_err, "Nothing to do!\n");
			goto export_end;
		}
		if (pkcs12_config.options & NOCERTS)
			pkcs12_config.chain = 0;

		if (!(pkcs12_config.options & NOKEYS)) {
			key = load_key(bio_err, pkcs12_config.keyname ?
			    pkcs12_config.keyname : pkcs12_config.infile,
			    FORMAT_PEM, 1, passin, "private key");
			if (!key)
				goto export_end;
		}

		/* Load in all certs in input file */
		if (!(pkcs12_config.options & NOCERTS)) {
			certs = load_certs(bio_err, pkcs12_config.infile,
			    FORMAT_PEM, NULL, "certificates");
			if (!certs)
				goto export_end;

			if (key) {
				/* Look for matching private key */
				for (i = 0; i < sk_X509_num(certs); i++) {
					x = sk_X509_value(certs, i);
					if (X509_check_private_key(x, key)) {
						ucert = x;
						/* Zero keyid and alias */
						X509_keyid_set1(ucert, NULL, 0);
						X509_alias_set1(ucert, NULL, 0);
						/* Remove from list */
						(void) sk_X509_delete(certs, i);
						break;
					}
				}
				if (!ucert) {
					BIO_printf(bio_err,
					    "No certificate matches private key\n");
					goto export_end;
				}
			}
		}

		/* Add any more certificates asked for */
		if (pkcs12_config.certfile) {
			STACK_OF(X509) *morecerts = NULL;
			if (!(morecerts = load_certs(bio_err,
			    pkcs12_config.certfile, FORMAT_PEM, NULL,
			    "certificates from certfile")))
				goto export_end;
			while (sk_X509_num(morecerts) > 0)
				sk_X509_push(certs, sk_X509_shift(morecerts));
			sk_X509_free(morecerts);
		}


		/* If chaining get chain from user cert */
		if (pkcs12_config.chain) {
			int vret;
			STACK_OF(X509) *chain2;
			X509_STORE *store = X509_STORE_new();
			if (!store) {
				BIO_printf(bio_err,
				    "Memory allocation error\n");
				goto export_end;
			}
			if (!X509_STORE_load_locations(store,
			    pkcs12_config.CAfile, pkcs12_config.CApath))
				X509_STORE_set_default_paths(store);

			vret = get_cert_chain(ucert, store, &chain2);
			X509_STORE_free(store);

			if (!vret) {
				/* Exclude verified certificate */
				for (i = 1; i < sk_X509_num(chain2); i++)
					sk_X509_push(certs, sk_X509_value(
					    chain2, i));
				/* Free first certificate */
				X509_free(sk_X509_value(chain2, 0));
				sk_X509_free(chain2);
			} else {
				if (vret >= 0)
					BIO_printf(bio_err,
					    "Error %s getting chain.\n",
					    X509_verify_cert_error_string(
					    vret));
				else
					ERR_print_errors(bio_err);
				goto export_end;
			}
		}
		/* Add any CA names */

		for (i = 0; i < sk_OPENSSL_STRING_num(pkcs12_config.canames);
		    i++) {
			catmp = (unsigned char *) sk_OPENSSL_STRING_value(
			    pkcs12_config.canames, i);
			X509_alias_set1(sk_X509_value(certs, i), catmp, -1);
		}

		if (pkcs12_config.csp_name && key)
			EVP_PKEY_add1_attr_by_NID(key, NID_ms_csp_name,
			    MBSTRING_ASC,
			    (unsigned char *) pkcs12_config.csp_name, -1);

		if (pkcs12_config.add_lmk && key)
			EVP_PKEY_add1_attr_by_NID(key, NID_LocalKeySet, 0, NULL,
			    -1);

		if (!pkcs12_config.noprompt &&
		    EVP_read_pw_string(pass, sizeof pass,
		    "Enter Export Password:", 1)) {
			BIO_printf(bio_err, "Can't read Password\n");
			goto export_end;
		}
		if (!pkcs12_config.twopass)
			strlcpy(macpass, pass, sizeof macpass);


		p12 = PKCS12_create(cpass, pkcs12_config.name, key, ucert,
		    certs, pkcs12_config.key_pbe, pkcs12_config.cert_pbe,
		    pkcs12_config.iter, -1, pkcs12_config.keytype);

		if (!p12) {
			ERR_print_errors(bio_err);
			goto export_end;
		}
		if (pkcs12_config.macalg) {
			macmd = EVP_get_digestbyname(pkcs12_config.macalg);
			if (!macmd) {
				BIO_printf(bio_err,
				    "Unknown digest algorithm %s\n",
				    pkcs12_config.macalg);
			}
		}
		if (pkcs12_config.maciter != -1)
			PKCS12_set_mac(p12, mpass, -1, NULL, 0,
			    pkcs12_config.maciter, macmd);

		i2d_PKCS12_bio(out, p12);

		ret = 0;

 export_end:


		EVP_PKEY_free(key);

		sk_X509_pop_free(certs, X509_free);

		X509_free(ucert);

		goto end;

	}
	if (!(p12 = d2i_PKCS12_bio(in, NULL))) {
		ERR_print_errors(bio_err);
		goto end;
	}
	if (!pkcs12_config.noprompt && EVP_read_pw_string(pass, sizeof pass,
	    "Enter Import Password:", 0)) {
		BIO_printf(bio_err, "Can't read Password\n");
		goto end;
	}

	if (!pkcs12_config.twopass)
		strlcpy(macpass, pass, sizeof macpass);

	if ((pkcs12_config.options & INFO) && p12->mac)
		BIO_printf(bio_err, "MAC Iteration %ld\n",
		    p12->mac->iter ? ASN1_INTEGER_get(p12->mac->iter) : 1);
	if (pkcs12_config.macver) {
		/* If we enter empty password try no password first */
		if (!mpass[0] && PKCS12_verify_mac(p12, NULL, 0)) {
			/* If mac and crypto pass the same set it to NULL too */
			if (!pkcs12_config.twopass)
				cpass = NULL;
		} else if (!PKCS12_verify_mac(p12, mpass, -1)) {
			BIO_printf(bio_err,
			    "Mac verify error: invalid password?\n");
			ERR_print_errors(bio_err);
			goto end;
		}
		BIO_printf(bio_err, "MAC verified OK\n");
	}
	if (!dump_certs_keys_p12(out, p12, cpass, -1, pkcs12_config.options,
	    passout)) {
		BIO_printf(bio_err, "Error outputting keys and certificates\n");
		ERR_print_errors(bio_err);
		goto end;
	}
	ret = 0;
 end:

	PKCS12_free(p12);
	BIO_free(in);
	BIO_free_all(out);

	sk_OPENSSL_STRING_free(pkcs12_config.canames);
	free(passin);
	free(passout);

	return (ret);
}

int
dump_certs_keys_p12(BIO *out, PKCS12 *p12, char *pass,
    int passlen, int options, char *pempass)
{
	STACK_OF(PKCS7) *asafes = NULL;
	STACK_OF(PKCS12_SAFEBAG) *bags;
	int i, bagnid;
	int ret = 0;
	PKCS7 *p7;

	if (!(asafes = PKCS12_unpack_authsafes(p12)))
		return 0;
	for (i = 0; i < sk_PKCS7_num(asafes); i++) {

		}
		sk_PKCS12_SAFEBAG_pop_free(bags, PKCS12_SAFEBAG_free);
		bags = NULL;
	}
	ret = 1;

 err:


	sk_PKCS7_pop_free(asafes, PKCS7_free);
	return ret;
}

int
dump_certs_pkeys_bags(BIO *out, STACK_OF(PKCS12_SAFEBAG) *bags,
    char *pass, int passlen, int options, char *pempass)
{
	int i;
	for (i = 0; i < sk_PKCS12_SAFEBAG_num(bags); i++) {
		if (!dump_certs_pkeys_bag(out,
			sk_PKCS12_SAFEBAG_value(bags, i),
			pass, passlen,
			options, pempass))
			return 0;
	}
	return 1;
}

int
dump_certs_pkeys_bag(BIO *out, PKCS12_SAFEBAG *bag, char *pass,
    int passlen, int options, char *pempass)
{
	EVP_PKEY *pkey;
	PKCS8_PRIV_KEY_INFO *p8;
	X509 *x509;

	switch (OBJ_obj2nid(bag->type)) {
	case NID_keyBag:
		if (options & INFO)
			BIO_printf(bio_err, "Key bag\n");
		if (options & NOKEYS)
			return 1;
		print_attribs(out, bag->attrib, "Bag Attributes");
		p8 = bag->value.keybag;
		if (!(pkey = EVP_PKCS82PKEY(p8)))
			return 0;
		print_attribs(out, p8->attributes, "Key Attributes");
		PEM_write_bio_PrivateKey(out, pkey, pkcs12_config.enc, NULL, 0,
		    NULL, pempass);
		EVP_PKEY_free(pkey);
		break;

	case NID_pkcs8ShroudedKeyBag:
		if (options & INFO) {
			BIO_printf(bio_err, "Shrouded Keybag: ");
			alg_print(bio_err, bag->value.shkeybag->algor);
		}
		if (options & NOKEYS)
			return 1;
		print_attribs(out, bag->attrib, "Bag Attributes");
		if (!(p8 = PKCS12_decrypt_skey(bag, pass, passlen)))
			return 0;
		if (!(pkey = EVP_PKCS82PKEY(p8))) {
			PKCS8_PRIV_KEY_INFO_free(p8);
			return 0;
		}
		print_attribs(out, p8->attributes, "Key Attributes");
		PKCS8_PRIV_KEY_INFO_free(p8);
		PEM_write_bio_PrivateKey(out, pkey, pkcs12_config.enc, NULL, 0,
		    NULL, pempass);
		EVP_PKEY_free(pkey);
		break;

	case NID_certBag:
		if (options & INFO)
			BIO_printf(bio_err, "Certificate bag\n");
		if (options & NOCERTS)

}

/* Given a single certificate return a verified chain or NULL if error */

/* Hope this is OK .... */

int
get_cert_chain(X509 *cert, X509_STORE *store, STACK_OF(X509) **chain)
{
	X509_STORE_CTX store_ctx;
	STACK_OF(X509) *chn;
	int i = 0;

	/*
	 * FIXME: Should really check the return status of
	 * X509_STORE_CTX_init for an error, but how that fits into the
	 * return value of this function is less obvious.
	 */

	X509_STORE_CTX_cleanup(&store_ctx);
	*chain = chn;

	return i;
}

int
alg_print(BIO *x, X509_ALGOR *alg)
{
	PBEPARAM *pbe;
	const unsigned char *p;
	p = alg->parameter->value.sequence->data;
	pbe = d2i_PBEPARAM(NULL, &p, alg->parameter->value.sequence->length);
	if (!pbe)
		return 1;
	BIO_printf(bio_err, "%s, Iteration %ld\n",
	    OBJ_nid2ln(OBJ_obj2nid(alg->algorithm)),
	    ASN1_INTEGER_get(pbe->iter));
	PBEPARAM_free(pbe);
	return 1;
}

/* Load all certificates from a given file */

int
cert_load(BIO *in, STACK_OF(X509) *sk)
{
	int ret;
	X509 *cert;
	ret = 0;
	while ((cert = PEM_read_bio_X509(in, NULL, NULL, NULL))) {
		ret = 1;
		sk_X509_push(sk, cert);
	}
	if (ret)
		ERR_clear_error();
	return ret;
}

/* Generalised attribute print: handle PKCS#8 and bag attributes */

int
print_attribs(BIO *out, STACK_OF(X509_ATTRIBUTE) *attrlst, const char *name)
{
	X509_ATTRIBUTE *attr;
	ASN1_TYPE *av;
	char *value;
	int i, attr_nid;
	if (!attrlst) {
		BIO_printf(out, "%s: <No Attributes>\n", name);

		} else
			BIO_printf(out, "%s: ", OBJ_nid2ln(attr_nid));

		if (sk_ASN1_TYPE_num(attr->value.set)) {
			av = sk_ASN1_TYPE_value(attr->value.set, 0);
			switch (av->type) {
			case V_ASN1_BMPSTRING:
				value = OPENSSL_uni2asc(
				    av->value.bmpstring->data,
				    av->value.bmpstring->length);
				BIO_printf(out, "%s\n", value);
				free(value);
				break;

			case V_ASN1_OCTET_STRING:
				hex_prin(out, av->value.octet_string->data,
				    av->value.octet_string->length);
				BIO_printf(out, "\n");
				break;

			case V_ASN1_BIT_STRING:
				hex_prin(out, av->value.bit_string->data,
				    av->value.bit_string->length);
				BIO_printf(out, "\n");
				break;

			default:
				BIO_printf(out, "<Unsupported tag %d>\n",
				    av->type);
				break;
			}
		} else
			BIO_printf(out, "<No Values>\n");
	}
	return 1;
}

void
hex_prin(BIO *out, unsigned char *buf, int len)
{
	int i;
	for (i = 0; i < len; i++)
		BIO_printf(out, "%02X ", buf[i]);
}

static int
set_pbe(BIO *err, int *ppbe, const char *str)
{
	if (!str)
		return 0;
	if (!strcmp(str, "NONE")) {
		*ppbe = -1;
		return 1;
	}

/* $OpenBSD: pkcs7.c,v 1.11 2019/07/14 03:30:46 guenther Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *

	char *outfile;
	int outformat;
	int p7_print;
	int print_certs;
	int text;
} pkcs7_config;

static const struct option pkcs7_options[] = {
	{
		.name = "in",
		.argname = "file",
		.desc = "Input file (default stdin)",
		.type = OPTION_ARG,
		.opt.arg = &pkcs7_config.infile,
	},

/* $OpenBSD: pkcs8.c,v 1.14 2019/07/14 03:30:46 guenther Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 1999-2004.
 */
/* ====================================================================
 * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without

		fprintf(stderr, "Unknown cipher '%s'\n", arg);
		return (1);
	}

	return (0);
}

static const struct option pkcs8_options[] = {
	{
		.name = "in",
		.argname = "file",
		.desc = "Input file (default stdin)",
		.type = OPTION_ARG,
		.opt.arg = &pkcs8_config.infile,
	},

/* $OpenBSD: pkey.c,v 1.15 2019/07/14 03:30:46 guenther Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 2006
 */
/* ====================================================================
 * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without

		return (1);
	}

	*argsused = 1;
	return (0);
}

static const struct option pkey_options[] = {
	{
		.name = "in",
		.argname = "file",
		.desc = "Input file (default stdin)",
		.type = OPTION_ARG,
		.opt.arg = &pkey_config.infile,
	},

/* $OpenBSD: pkeyparam.c,v 1.12 2019/07/14 03:30:46 guenther Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 2006
 */
/* ====================================================================
 * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without

struct {
	char *infile;
	int noout;
	char *outfile;
	int text;
} pkeyparam_config;

static const struct option pkeyparam_options[] = {
	{
		.name = "in",
		.argname = "file",
		.desc = "Input file (default stdin)",
		.type = OPTION_ARG,
		.opt.arg = &pkeyparam_config.infile,
	},

/* $OpenBSD: pkeyutl.c,v 1.16 2019/07/14 03:30:46 guenther Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 2006.
 */
/* ====================================================================
 * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without

static int pkeyutl_pkeyopt(char *pkeyopt);

static int do_keyop(EVP_PKEY_CTX * ctx, int pkey_op,
    unsigned char *out, size_t * poutlen,
    unsigned char *in, size_t inlen);

static const struct option pkeyutl_options[] = {
	{
		.name = "asn1parse",
		.desc = "ASN.1 parse the output data",
		.type = OPTION_FLAG,
		.opt.flag = &pkeyutl_config.asn1parse,
	},
	{

/* $OpenBSD: prime.c,v 1.13 2019/07/14 03:30:46 guenther Exp $ */
/* ====================================================================
 * Copyright (c) 2004 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *

	int bits;
	int checks;
	int generate;
	int hex;
	int safe;
} prime_config;

static const struct option prime_options[] = {
	{
		.name = "bits",
		.argname = "n",
		.desc = "Number of bits in the generated prime number",
		.type = OPTION_ARG_INT,
		.opt.value = &prime_config.bits,
	},

/* $OpenBSD: rand.c,v 1.14 2019/07/14 03:30:46 guenther Exp $ */
/* ====================================================================
 * Copyright (c) 1998-2001 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *

struct {
	int base64;
	int hex;
	char *outfile;
} rand_config;

static const struct option rand_options[] = {
	{
		.name = "base64",
		.desc = "Perform base64 encoding on output",
		.type = OPTION_FLAG,
		.opt.flag = &rand_config.base64,
	},
	{

/* $OpenBSD: req.c,v 1.16 2019/07/03 03:24:02 deraadt Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *