OpenSSL Tutorial

ソースコード2.1 エラーコード取得例

if (BIO_puts(bio, "This triggers an error.") <= 0) {
	fprintf(stderr, "Error Code: %lx\n", ERR_get_error());
        return;
}

ソースコード2.2 ERR_get_error()のリターン例

Error Code: 2007507e

ソースコード2.3 ERR_error_string()

fprintf(stderr, "%s\n", ERR_error_string(ERR_get_error(), NULL));

ソースコード2.4 ERR_error_string()のリターン例

error:2007507E:BIO routines:mem_write:write to read only BIO

ソースコード2.5 ERR_reason_error_string()

fprintf(stderr, "%s\n", ERR_reason_error_string(ERR_get_error()));

ソースコード2.6 ERR_reason_error_string()のリターン例

write to read only BIO

ソースコード2.7 ERR_print_errors_fp()

ERR_print_errors_fp(stderr);

ソースコード2.8 ERR_print_errors_fp()のリターン例

139914501721216:error:20075073:BIO routines:mem_write:null parameter:crypto/bio/bss_mem.c:224:
139914501721216:error:2007507E:BIO routines:mem_write:write to read only BIO:crypto/bio/bss_mem.c:228:

ソースコード2.9 リザルトコード取得の例

size = SSL_read(ssl, buff, sizeof(buff) - 1);
if (size <= 0) {
        int err;
	err = SSL_get_error(ssl, size);
	switch (err) {
	case SSL_ERROR_ZERO_RETURN:	/* EOF */
		return 0;

	case SSL_ERROR_SSL:
		return -2;
	default:
		printf("Error: %d\n", err);
		break;
	}
}

ソースコード3.1 BIOの作成例

BIO *mem = BIO_new(BIO_s_mem());  /* メモリBIOを作成 */

ソースコード3.2 BIOの作成と解放 bio_new_free.c

#include <openssl/bio.h>

int main()
{
	BIO *mem = BIO_new(BIO_s_mem());
	if (mem == NULL) {
		return 1;
	}

	BIO_free(mem);

	return 0;
}

ソースコード3.3 メモリBIOの作成

BIO *mem = BIO_new(BIO_s_mem());

ソースコード3.4 メモリBIOのwrite/read bio_mem_write_read.c

#include <stdio.h>
#include <openssl/bio.h>
#include <openssl/err.h>

void print_bio(BIO *bio)
{
	char buff[1000];
	int ret;

	while (1) {
		/* メモリBIOに書き込まれたデータの読み込み */
		ret = BIO_gets(bio, buff, sizeof(buff));
		if (ret <= 0) {
			break;
		}
		printf("%s", buff);
	}
}

int main()
{
	BIO *bio = BIO_new(BIO_s_mem());
	if (bio == NULL) {
		goto error;
	}
	if (BIO_puts(bio, "content-type: text/html; charset=UTF-8\r\n") <= 0) {
		goto error;
	}
	/* printfのようなformatting関数もある */
	if (BIO_printf(bio, "content-length: %d\r\n", 100) <= 0) {
		goto error;
	}

	/* 書き込んだデータのread */
	print_bio(bio);

	BIO_free(bio);

	return 0;

error:
	if (bio) {
		BIO_free(bio);
	}

        ERR_print_errors_fp(stderr);

	return 1;
}

ソースコード3.5 BIO_new_mem_buf()の例

#include <stdio.h>
#include <openssl/bio.h>
#include <openssl/err.h>

/* void print_bio(BIO *bio)の定義は省略 */

int main()
{
	char string[] = "Hello\n";

        BIO *bio = BIO_new_mem_buf(string, -1);
	if (bio == NULL) {
		ERR_print_errors_fp(stderr);
		return 1;
	}

	print_bio(bio);

#if 0
	if (BIO_puts(bio, "This triggers an error.") <= 0) {
		ERR_print_errors_fp(stderr);
		BIO_free(bio);
		return 1;
        }
#endif

	BIO_free(bio);

	return 0;
}

ソースコード3.6 BIO_new_mem_buf()と同様の処理の例 bio_new_mem_buf_self.c

#include <stdio.h>
#include <string.h>
#include <openssl/bio.h>
#include <openssl/buffer.h>
#include <openssl/err.h>

/* void print_bio(BIO *bio)の定義は省略 */

/* BIO_new_mem_buf()相当の処理 */
BIO *BIO_new_mem_buf_self(const void *buffer, int len)
{
	BIO *bio = NULL;
	BUF_MEM *buf = NULL;
	size_t sz = (len < 0) ? strlen(buffer) : (size_t) len;

	bio = BIO_new(BIO_s_mem());
	if (bio == NULL) {
		goto error;
	}

	buf = BUF_MEM_new();
	if (buf == NULL) {
		goto error;
	}

	if (BIO_set_mem_buf(bio, buf, BIO_CLOSE) <= 0) {
		/*
		 * BUF_MEM_free()はbufとbuf->dataを解放する。
		 * 先に buf->data = (void *) buffer; を設定していた場合は、
		 * buf->dataを解放させないようbuf->dataをNULLにしてから
		 * BUF_MEM_free()を呼び出す必要がある。
		 */
		BUF_MEM_free(buf);
		goto error;
	}
	/*
	 * bufはbioに接続されたので、これ以降はBIO_free()で
	 * bufも一緒に解放される(BUF_MEM_free()は必要ない)。
	 */

	buf->data = (void *) buffer;
	buf->length = sz;
	buf->max = sz;

	/*
	 * BIOをread onlyにする。
	 * また、BIO_free()でbuf->dataは解放されなくなる。
	 */
	BIO_set_flags(bio, BIO_FLAGS_MEM_RDONLY);

	return bio;

error:
	if (bio) {
		BIO_free(bio);
	}

	return NULL;
}

int main()
{
	char string[] = "Hello\n";

        BIO *bio = BIO_new_mem_buf_self(string, -1);
	if (bio == NULL) {
		ERR_print_errors_fp(stderr);
		return 1;
	}

	print_bio(bio);

	/*
	 * read only BIOの場合、BIO_free()はBUF_MEMのbuf->dataは解放しない。
	 * このため、stringに対して解放処理が動作することはない。
	 * C++やRust風に言えばbuffuerに対する所有権は持たず参照しているだけ。
	 * Ref. crypto/bio/bss_mem.c::mem_buf_free()
	 */
	BIO_free(bio);

	return 0;
}

ソースコード3.7 ファイルBIOの作成

BIO *bio_file = BIO_new(BIO_s_file());

ソースコード3.8 ファイルBIOの初期設定

	bio = BIO_new(BIO_s_file());
	if (bio == NULL) {
		fclose(file);
		return NULL;
	}

	BIO_set_fp(bio, fp, BIO_CLOSE | BIO_FP_TEXT);

ソースコード3.9 ファイルBIOのread/write例 bio_file_read_write.c

#include <stdio.h>
#include <openssl/bio.h>

static BIO *bio_stdout = NULL;

void print_bio(BIO *bio_out, BIO *bio)
{
	char buff[1000];
	int ret;

	while (1) {
		ret = BIO_gets(bio, buff, sizeof(buff));
		if (ret <= 0) {
			break;
		}
		BIO_puts(bio_out, buff);
	}
}

int main(int argc, char *argv[])
{
	BIO *bio_in;

	bio_stdout = BIO_new_fp(stdout, BIO_NOCLOSE | BIO_FP_TEXT);

	/* Create a BIO by helper function. */
	if (argc >= 2) {
		bio_in = BIO_new_file(argv[1], "r");
	} else {
		bio_in = BIO_new_fp(stdin, BIO_NOCLOSE | BIO_FP_TEXT);
	}

	if (bio_in) {
		print_bio(bio_stdout, bio_in);
		BIO_free(bio_in);
	} else {
		fprintf(stderr, "Can't create a bio.\n");
	}

	BIO_free(bio_stdout);

	return 0;
}

ソースコード3.10 ファイルディスクリプタBIOの作成

BIO *bio_file = BIO_new(BIO_s_fd());

ソースコード3.11 ソケットBIOの作成

BIO *bio_socket = BIO_new(BIO_s_socket());

ソースコード3.12 ソケットBIOの例 bio_socket.c

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <netdb.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <openssl/bio.h>
#include <openssl/err.h>

static BIO *bio_stdout;

BIO *connect_to_remote(const char* hostname, unsigned short port)
{
	struct hostent *ent;
	struct sockaddr_in remote;
	int sock;
	BIO *bio;

	ent = gethostbyname(hostname);
	if (ent == NULL) {
		herror("gethostbyname()");
		return NULL;
	}
	if (ent->h_addrtype != AF_INET) {
		fprintf(stderr, "Can' get ipv4 address.\n");
		return NULL;
	}

	memset(&remote, 0, sizeof(remote));
	remote.sin_family = AF_INET;
	remote.sin_port = htons(port);
	memcpy(&remote.sin_addr, ent->h_addr, sizeof(remote.sin_addr));

	sock = socket(AF_INET, SOCK_STREAM, 0); 
	if (sock == -1) {
		perror("socket()");
		return NULL;
	}

	if (connect(sock, (struct sockaddr*) &remote, sizeof(remote)) == -1) {
		perror("connect()");
		close(sock);
		return NULL;
	}

	bio = BIO_new_socket(sock, BIO_CLOSE);
	if (bio == NULL) {
		close(sock);
		return NULL;
	}

	return bio;
}

void http_get(BIO *bio, const char *hostname)
{
	char buff[1024];
	int size;
	BIO *mem;
	char *request;

	mem = BIO_new(BIO_s_mem());
	if (mem == NULL) {
		ERR_print_errors_fp(stderr);
		return ;
	}

	/*
	 * メモリBIOにBIO_printf()で出力すればバッファサイズを気にせず
	 * formattingできる
	 */
	if (BIO_printf(mem, "GET / HTTP/1.1\r\nHost: %s\r\nConnection: Close\r\n\r\n", hostname) < 0) {
		ERR_print_errors_fp(stderr);
		BIO_free(mem);
		return;
	}

	size = BIO_get_mem_data(mem, &request);

	if (BIO_write(bio, request, size) != size) {
		ERR_print_errors_fp(stderr);
		BIO_free(mem);
		return;
	}
	BIO_flush(bio);
	BIO_free(mem);

	while ((size = BIO_read(bio, buff, sizeof(buff) - 1)) > 0) {
		buff[size] = '\0';
		BIO_write(bio_stdout, buff, size);
	}
}

int main()
{
	const char *hostname ="localhost";
	BIO *bio_sock = NULL;

	bio_stdout = BIO_new_fp(stdout, BIO_NOCLOSE | BIO_FP_TEXT);

	bio_sock = connect_to_remote(hostname, 80);
	if (bio_sock == NULL) {
		goto error;
	}

	http_get(bio_sock, hostname);

	BIO_free(bio_sock);

	BIO_free(bio_stdout);

	return 0;

error:
	BIO_free(bio_stdout);

	return 1;
}

ソースコード3.13 Base64フィルタによるエンコード bio_base64_encode.c

#include <stdio.h>
#include <string.h>
#include <openssl/bio.h>
#include <openssl/err.h>
#include <openssl/evp.h>

BIO *create_encoder_chain()
{
	BIO *b64 = NULL;
	BIO *bio = NULL;

	b64 = BIO_new(BIO_f_base64());
	if (b64 == NULL) {
		goto error;
	}
	bio = BIO_new_fp(stdout, BIO_NOCLOSE | BIO_FP_TEXT);
	if (bio == NULL) {
		goto error;
	}

        BIO_push(b64, bio);

	return b64;

error:
	if (bio) {
		BIO_free(bio);
	}

	if (b64) {
		BIO_free(b64);
	}

	return NULL;
}

int main()
{
	char buff[1000];
	BIO *bio_stdin;
	BIO *chain;
	int sz;

	bio_stdin = BIO_new_fp(stdin, BIO_NOCLOSE);

	chain = create_encoder_chain();
	if (chain == NULL) {
		goto error;
	}

	/* binaryデータを読めるようにBIO_gets()ではなくBIO_read()で */
	while ((sz = BIO_read(bio_stdin, buff, sizeof(buff))) > 0) {
		/* base64 filter BIOにwrite操作をするとencodeされる */
		if (BIO_write(chain, buff, sz) <= 0) {
			goto error;
		}
	}

        BIO_flush(chain);

	BIO_free_all(chain);

	BIO_free(bio_stdin);

	return 0;

error:
	if (chain) {
		BIO_free_all(chain);
	}

	BIO_free(bio_stdin);

	ERR_print_errors_fp(stderr);

	return 1;
}

ソースコード3.14 Base64フィルタによるデコード bio_base64_decode.c

#include <stdio.h>
#include <string.h>
#include <openssl/bio.h>
#include <openssl/err.h>
#include <openssl/evp.h>

BIO *create_decoder_chain()
{
	BIO *b64 = NULL;
	BIO *bio = NULL;

	b64 = BIO_new(BIO_f_base64());
	if (b64 == NULL) {
		goto error;
	}
	/* data source */
	bio = BIO_new_fp(stdin, BIO_NOCLOSE | BIO_FP_TEXT);
	if (bio == NULL) {
		goto error;
	}

        BIO_push(b64, bio);

	return b64;

error:
	if (bio) {
		BIO_free(bio);
	}

	if (b64) {
		BIO_free(b64);
	}

	return NULL;
}

int main()
{
	char buff[1000];
	BIO *bio_stdout;
	BIO *chain;
	int sz;

	bio_stdout = BIO_new_fp(stdout, BIO_NOCLOSE);

	chain = create_decoder_chain();
	if (chain == NULL) {
		goto error;
	}

	/* base64 filter BIOにread操作をするとdecodeされる */
        while ((sz = BIO_read(chain, buff, sizeof(buff))) > 0) {
		BIO_write(bio_stdout, buff, sz);
	}

	BIO_free_all(chain);

	BIO_free(bio_stdout);

	return 0;

error:
	if (chain) {
		BIO_free_all(chain);
	}

	BIO_free(bio_stdout);

	ERR_print_errors_fp(stderr);

	return 1;
}

ソースコード5.1 TLS接続(Client) tls_client.c

#include <stdio.h>
#include <netdb.h>
#include <netinet/in.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <openssl/err.h>
#include <openssl/ssl.h>
#include <openssl/x509v3.h>

void sending_loop(SSL *ssl)
{
	char buff[256];

	printf("Press Ctrl+d to quit\n");

	while (fgets(buff, sizeof(buff), stdin) != NULL) {
		SSL_write(ssl, buff, strlen(buff));
	}
}

int main()
{
	int sock = -1;
	const char *host_ip = "127.0.0.1";
	uint16_t port = 8000;
	struct sockaddr_in sin;
	SSL_CTX *ctx = NULL;
	SSL *ssl = NULL;

	sock = socket(AF_INET, SOCK_STREAM, 0);
	if (sock == -1) {
		perror("socket()");
		goto error;
	}

	memset(&sin, 0, sizeof(sin));
	sin.sin_family = AF_INET;
	sin.sin_port = htons(port);
	sin.sin_addr.s_addr = inet_addr(host_ip);

	if (connect(sock, (struct sockaddr*) &sin, sizeof(sin)) == -1) {
		perror("connect()");
		goto error;
	}

	ctx = SSL_CTX_new(TLS_client_method());
	if (ctx == NULL) {
		ERR_print_errors_fp(stderr);
		goto error;
	}

	/* SSL_CTXの設定 */
	SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY);

	if (SSL_CTX_set_min_proto_version(ctx, TLS1_2_VERSION) == 0) {
		ERR_print_errors_fp(stderr);
		goto error;
	}

	/* 今回は証明書の検証は省略する */
#if 0
	if (SSL_CTX_set_default_verify_paths(ctx) == 0) {
		ERR_print_errors_fp(stderr);
		goto error;
	}

	/* 証明書の検証設定(ホスト名の検証は省略) */
	SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL);
#endif

	ssl = SSL_new(ctx);
	if (ssl == NULL) {
		ERR_print_errors_fp(stderr);
		goto error;
	}

	if (SSL_set_fd(ssl, sock) == 0) {
		ERR_print_errors_fp(stderr);
		goto error;
	}

	/* TLS handshake開始 */
	if (SSL_connect(ssl) <= 0) {
		ERR_print_errors_fp(stderr);
		goto error;
	}

	sending_loop(ssl);

	SSL_shutdown(ssl);

	SSL_free(ssl); 
	SSL_CTX_free(ctx);
	close(sock);

	return 0;

 error:
	if (ssl) {
		SSL_free(ssl); 
	}
	if (ctx) {
		SSL_CTX_free(ctx);
	}
	if (sock != -1) {
		close(sock);
	}

	return 1;
}

ソースコード5.2 TLS接続(Server) tls_server.c

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <string.h>
#include <openssl/err.h>
#include <openssl/ssl.h>
#include <openssl/x509v3.h>

/*
 * return 0   正常終了
 *        -1  エラー
 *        -2  エラー(SSL_shutdown()を呼び出してはいけない)
 */
int read_loop(SSL *ssl)
{
	char buff[1000];
	int size;
	int err;

	while (1) {
		size = SSL_read(ssl, buff, sizeof(buff) - 1);
		if (size <= 0) {
			err = SSL_get_error(ssl, size);
			switch (err) {
			case SSL_ERROR_ZERO_RETURN:	/* EOF */
				return 0;

			case SSL_ERROR_SYSCALL:
				/*
				 * clientをctrl-cで止めたような場合は
				 * SSL_ERROR_SYSCALL(5)が返る。
				 * ECONNRESET("Connection reset by peer")
				 */
				perror("SSL_ERROR_SYSCALL");
				return -2;

			case SSL_ERROR_SSL:
				return -2;
			default:
				printf("Error: %d\n", err);
				break;
			}

			return -1;
		}
		buff[size] = '\0';
		printf("SSL_read(): %d bytes received: %s\n", size, buff);
		fflush(stdout);
	}
	/* not to reach */

	return 0;
}

int main(int argc, char *argv[])
{
	int sock = -1;
	uint16_t port = 8000;
	struct sockaddr_in listen_addr;
	SSL_CTX *ctx = NULL;

	sock = socket(AF_INET, SOCK_STREAM, 0);
	if (sock == -1) {
		perror("socket");
		goto error;
	}

	memset(&listen_addr, 0, sizeof(listen_addr));
	listen_addr.sin_family = AF_INET;
	listen_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	listen_addr.sin_port = htons(port);

	if (bind(sock, (struct sockaddr *) &listen_addr, sizeof(listen_addr)) < 0) {
		perror("bind");
		goto error;
	}

	if (listen(sock, 512) == -1) {
		perror("listen");
		goto error;
	}

	ctx = SSL_CTX_new(TLS_server_method());
	if (ctx == NULL) {
		ERR_print_errors_fp(stderr);
		goto error;
	}


	if (!SSL_CTX_use_certificate_file(ctx, "localhost.crt", SSL_FILETYPE_PEM) ||
	    !SSL_CTX_use_PrivateKey_file(ctx, "localhost.key", SSL_FILETYPE_PEM)) {
		ERR_print_errors_fp(stderr);
		goto error;
	}
	if (!SSL_CTX_check_private_key(ctx)) {
		ERR_print_errors_fp(stderr);
		goto error;
	}

	/*
	 * v1.1.1ではデフォルトでSSL_MODE_AUTO_RETRYは設定されている
	 * https://github.com/openssl/openssl/issues/7908
	 */
	SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY);

	if (SSL_CTX_set_min_proto_version(ctx, TLS1_2_VERSION) == 0) {
		ERR_print_errors_fp(stderr);
		goto error;
	}

	printf("Listening port %d ...\n", port);

	while (1) {
		int peer;
		SSL *ssl = NULL;
		int ret = 0;

		peer = accept(sock, NULL, NULL);
		if (peer == -1) {
			perror("accept");
			goto next;
		}
		printf("Accepted\n");

		ssl = SSL_new(ctx);
		if (ssl == NULL) {
			ERR_print_errors_fp(stderr);
			goto next;
		}

		if (SSL_set_fd(ssl, peer) == 0) {
			ERR_print_errors_fp(stderr);
			goto next;
		}

		/* handshake */
		ret = SSL_accept(ssl);
		if (ret <= 0) {
			ERR_print_errors_fp(stderr);
			goto next;
		}
		printf("Handshaked\n");
		printf("%s\nCipher: %s\n",
		       SSL_get_version(ssl),
		       SSL_get_cipher(ssl));

		ret = read_loop(ssl);

	next:
		if (ssl) {
			/*
			 * SSL_ERROR_SYSCALL/SSL_ERROR_SSLが発生していたら
			 * SSL_shutdown()を呼び出してはいけない。
			 */
			if (ret != -2) {
				SSL_shutdown(ssl);
			}
			SSL_free(ssl); 
		}
		if (peer != -1) {
			close(peer);
		}
		printf("Closed\n");
	}

	SSL_CTX_free(ctx);
	close(sock);

	return 0;

 error:
	if (ctx) {
		SSL_CTX_free(ctx);
	}

	if (sock != -1) {
		close(sock);
	}

	return -1;
}

ソースコード5.3 SSL *の行単位の読み込み tls_server_bio_gets.c

BIO *create_bio_from_ssl(SSL *ssl)
{
	BIO *bio = NULL;
	BIO *bio_ssl = NULL;

	bio = BIO_new(BIO_f_buffer());
	if (!bio) {
		goto error;
	}

	bio_ssl = BIO_new(BIO_f_ssl());
	if (!bio_ssl) {
		goto error;
	}

	BIO_set_ssl(bio_ssl, ssl, BIO_NOCLOSE);
	BIO_push(bio, bio_ssl);

	return bio;

error:
	if (bio_ssl) {
		BIO_free(bio_ssl);
	}

	if (bio) {
		BIO_free(bio);
	}

	return NULL;
}

int read_loop(SSL *ssl)
{
	char buff[1000];
	BIO *bio = NULL;

	bio = create_bio_from_ssl(ssl);
	if (!bio) {
		return -1;
	}

	while (BIO_gets(bio, buff, sizeof(buff)) > 0) {
		fputs(buff, stdout);
	}

	BIO_free_all(bio);

	return 0;
}

ソースコード5.4 TLS接続(Client) tls_https_client.c

#include <stdio.h>
#include <openssl/bio.h>
#include <openssl/err.h>
#include <openssl/ssl.h>
#include <openssl/x509v3.h>

static BIO *bio_stdout;

int https_get(BIO *bio_ssl, const char *hostname) {
	char buff[1024];
	int size;

	size = snprintf(buff, sizeof(buff), "GET / HTTP/1.1\r\nHost: %s\r\nConnection: Close\r\n\r\n", hostname);
	if (size + 1 > sizeof(buff)) {
		fprintf(stderr, "Insufficient buffer size.\n");
		return -1;
	}
	BIO_puts(bio_ssl, buff);

	while ((size = BIO_read(bio_ssl, buff, sizeof(buff) - 1)) > 0) {
		buff[size] = '\0';
		BIO_write(bio_stdout, buff, size);
	}
	return 0;
}

/* for Debug */
int verify_callback(int preverified, X509_STORE_CTX *ctx)
{
	X509* cert;
	char subject[1024];

	cert = X509_STORE_CTX_get_current_cert(ctx);
	if (cert == NULL) {
		return 0;
	}
	X509_NAME_oneline(X509_get_subject_name(cert), &subject[0], sizeof(subject));
	printf("%d %s\n", preverified, subject);

	return preverified;
}

void enable_hostname_validation(SSL *ssl, const char *hostname)
{
	X509_VERIFY_PARAM *param;

	param = SSL_get0_param(ssl);

	X509_VERIFY_PARAM_set_hostflags(param, X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS);
	if (!X509_VERIFY_PARAM_set1_host(param, hostname, 0)) {
		ERR_print_errors_fp(stderr);
	}
}

int main(int argc, char *argv[])
{
	const char *hostname;
	BIO *bio_ssl = NULL;
	SSL_CTX *ctx = NULL;
	SSL *ssl;

	bio_stdout = BIO_new_fp(stdout, BIO_NOCLOSE | BIO_FP_TEXT);

	if (argc < 2) {
		fprintf(stderr, "Usage:\ntls_https_client <hostname>\n");
		goto error;
	}
	hostname = argv[1];

	ctx = SSL_CTX_new(TLS_client_method());
	if (ctx == NULL) {
		ERR_print_errors_fp(stderr);
		goto error;
	}

	SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY);

	if (SSL_CTX_set_min_proto_version(ctx, TLS1_2_VERSION) == 0) {
		ERR_print_errors_fp(stderr);
		goto error;
	}

	if (SSL_CTX_set_default_verify_paths(ctx) == 0) {
		ERR_print_errors_fp(stderr);
		goto error;
	}

	/* 証明書の検証設定 */
#if 1
	SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, verify_callback);
#endif

	bio_ssl = BIO_new_ssl_connect(ctx);
	if (bio_ssl == NULL) {
		ERR_print_errors_fp(stderr);
		goto error;
	}

	if (BIO_get_ssl(bio_ssl, &ssl) <= 0) {
		ERR_print_errors_fp(stderr);
		goto error;
	}

	enable_hostname_validation(ssl, hostname);

	/* For SNI */
	SSL_set_tlsext_host_name(ssl, hostname);

	BIO_set_conn_hostname(bio_ssl, hostname);
	BIO_set_conn_port(bio_ssl, "443");
	if (BIO_do_connect(bio_ssl) <= 0) {
		ERR_print_errors_fp(stderr);
		goto error;
	}

	if (https_get(bio_ssl, hostname) == -1) {
		goto error;
	}

	BIO_ssl_shutdown(bio_ssl);

	BIO_free_all(bio_ssl);
	SSL_CTX_free(ctx);

	BIO_free(bio_stdout);

	return 0;

error:
	if (bio_ssl) {
		BIO_free_all(bio_ssl);
	}
	if (ctx) {
		SSL_CTX_free(ctx);
	}

	BIO_free(bio_stdout);

	return 1;
}

ソースコード5.5 TLS接続(Server) tls_https_server.c

#include <stdio.h>
#include <string.h>
#include <openssl/bio.h>
#include <openssl/err.h>
#include <openssl/ssl.h>
#include <openssl/x509v3.h>

static const char *cert_file = "localhost.crt";
static const char *private_key_file = "localhost.key";

int process_request(BIO *bio)
{
	char buff[1000];
	const char *response = "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\ntest\r\n";
	int sz;
	int on_going = 0;

	while ((sz = BIO_gets(bio, buff, sizeof(buff))) > 0) {
		if (on_going == 0 &&
		    buff[0] == 0x0d && buff[1] == 0x0a && buff[2] == 0x00) {
			/* empty line */
			break;
		}
		on_going = buff[sz - 1] == 0x0a ? 0 : 1;

		fputs(buff, stdout);
	}

	/* http response */
	BIO_write(bio, response, strlen(response));
	BIO_flush(bio);

	return 0;
}

BIO *create_bio_from_ctx(SSL_CTX *ctx)
{
	BIO *bio_buf = NULL;
	BIO *bio_ssl = NULL;

	bio_buf = BIO_new(BIO_f_buffer());
	if (!bio_buf) {
		goto error;
	}

	bio_ssl = BIO_new_ssl(ctx, 0);
	if (!bio_ssl) {
		goto error;
	}
	BIO_push(bio_buf, bio_ssl);

	return bio_buf;

error:
	if (bio_ssl) {
		BIO_free(bio_ssl);
	}
	if (bio_buf) {
		BIO_free(bio_buf);
	}

	return NULL;
}

int main(int argc, char *argv[])
{
	SSL_CTX *ctx = NULL;
	BIO *bio_ssl = NULL;
	BIO *bio_accept = NULL;

	ctx = SSL_CTX_new(TLS_server_method());
	if (ctx == NULL) {
		ERR_print_errors_fp(stderr);
		goto error;
	}

	if (!SSL_CTX_use_certificate_chain_file(ctx, cert_file)) {
		ERR_print_errors_fp(stderr);
		goto error;
	}
	if (!SSL_CTX_use_PrivateKey_file(ctx, private_key_file, SSL_FILETYPE_PEM)) {
		ERR_print_errors_fp(stderr);
		goto error;
	}
	if (!SSL_CTX_check_private_key(ctx)) {
		ERR_print_errors_fp(stderr);
		goto error;
	}

	SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY);

	if (SSL_CTX_set_min_proto_version(ctx, TLS1_2_VERSION) == 0) {
		ERR_print_errors_fp(stderr);
		goto error;
	}

	bio_ssl = create_bio_from_ctx(ctx);
	if (!bio_ssl) {
		ERR_print_errors_fp(stderr);
		goto error;
	}
	bio_accept = BIO_new_accept("8000");
	if (!bio_accept) {
		ERR_print_errors_fp(stderr);
		goto error;
	}
	if (BIO_do_accept(bio_accept) <= 0) {	/* bind */
		ERR_print_errors_fp(stderr);
		goto error;
	}

	/*
	 * ここで指定したbio(chain)はbio_accept内に保持される。
	 * bio_accept解放時に一緒に解放されるので、bioを解放してはいけない。
	 *
	 * Accept BIOは通常、accept時に新しいSocket Bio(accept()が返した
	 * socketを格納したBIO)をbio_acceptにチェーンするだけ。
	 *     Accept BIO -> Socket BIO
	 *
	 * BIO(Chain)を登録しておくと、accept時にBIO_dup_chain()で複製して
	 * Accept BIOの後ろに挿入する。
	 *     Accept BIO -> BIO(Chain) -> Socket BIO
	 *
	 * TLS通信する場合に自動でSSL BIOを挟みたい場合に使用する。
	 * SSL BIOを挟んだ場合は、末尾のSocket bioは使われない。
	 */
	if (BIO_set_accept_bios(bio_accept, bio_ssl) <= 0) {
		ERR_print_errors_fp(stderr);
		goto error;
	}
	bio_ssl = NULL;	/* エラー時に解放させないように */

	while (1) {
		BIO *bio = NULL;
		SSL *ssl = NULL;

		if (BIO_do_accept(bio_accept) <= 0) {
			ERR_print_errors_fp(stderr);
			goto error;	/* end */
		}
		printf("Accepted\n");

		/* get new connection */
		bio = BIO_pop(bio_accept);

		if (BIO_do_handshake(bio) <= 0) {
			ERR_print_errors_fp(stderr);
			goto next;
		}
		printf("Handshaked\n");

		if (BIO_get_ssl(bio, &ssl) <= 0) {
			ERR_print_errors_fp(stderr);
			goto error;
		}

		printf("%s\nCipher: %s\n",
		       SSL_get_version(ssl),
		       SSL_get_cipher(ssl));

		process_request(bio);

	next:
		if (bio) {
			BIO_ssl_shutdown(bio);
			BIO_free_all(bio);
		}
	}

	BIO_free_all(bio_accept);

	/* bio_sslの解放は不要 */

	SSL_CTX_free(ctx);

	return 0;

 error:
	if (bio_accept) {
		BIO_free_all(bio_accept);
	}
	if (bio_ssl) {
		BIO_free_all(bio_ssl);
	}
	if (ctx) {
		SSL_CTX_free(ctx);
	}

	return -1;
}

ソースコード5.6 TLS接続(Server)仮想ホスト対応 tls_https_server_vhost.c

#include <stdio.h>
#include <string.h>
#include <openssl/bio.h>
#include <openssl/err.h>
#include <openssl/ssl.h>
#include <openssl/x509v3.h>

#define USE_SNI    1

 /* vhostごとにprotocol version/cipherを指定できるようにする。
  * 0の場合、default(vhosts[0])の設定が使われる。
  */
#define USE_CLIENT_HELLO_CALLBACK  1

struct vhost {
	char *server_name;
	char *cert;	/* サーバー証明書 + 中間証明書 */
	char *private;
	long ssl_options;
	char *cipher_list;
	SSL_CTX *ssl_ctx;
};

/* Virtual Hosts Configuration */
struct vhost vhosts[] = {
	{"www.example.com",
	 "example.com.chained.crt",
	 "example.com.key",
	 0,
	 NULL,
	 NULL,
	},
	{"www.example.net",
	 "example.net.chained.crt",
	 "example.net.key",
	 SSL_OP_NO_TLSv1_3,
	 "ECDHE-RSA-AES128-GCM-SHA256",
	 NULL,
	},
};

struct vhost *find_vhost(const char *server_name)
{
	int i;

	for (i = 0 ; i < sizeof(vhosts) / sizeof(struct vhost) ; i++) {
		/* ケース非依存なホスト名比較などが必要だが省略 */
		if (strcmp(server_name, vhosts[i].server_name) == 0) {
			return &vhosts[i];
		}
	}

	return NULL;
}

/* ref. apache ssl_find_vhost() */
void select_vhost(SSL *ssl, struct vhost *vh)
{
	/* 証明書設定をコピー */
	SSL_set_SSL_CTX(ssl, vh->ssl_ctx);

	SSL_set_options(ssl, SSL_CTX_get_options(vh->ssl_ctx));
}

char *get_servername_from_client_hello(SSL *ssl)
{
	const unsigned char *ext;
	size_t ext_len;
	size_t p = 0;
	size_t server_name_list_len;
	size_t server_name_len;

	if (!SSL_client_hello_get0_ext(ssl, TLSEXT_TYPE_server_name,
				       &ext,
				       &ext_len)) {
		return NULL;
	}

	/* length (2 bytes) + type (1) + length (2) + server name (1+) */
	if (ext_len < 6) {
		return NULL;
	}

	/* Fetch Server Name list length */
	server_name_list_len = (ext[p] << 8) + ext[p + 1];
	p += 2;
	if (p + server_name_list_len != ext_len) {
		return NULL;
	}

	/* Fetch Server Name Type */
	if (ext[p] != TLSEXT_NAMETYPE_host_name) {
		return NULL;
	}
	p++;

	/* Fetch Server Name Length */
	server_name_len = (ext[p] << 8) + ext[p + 1];
	p += 2;
	if (p + server_name_len != ext_len) {
		return NULL;
	}

	/* ext_len >= 6 && p == 5 */

	/* Finally fetch Server Name */

	return strndup((const char *) ext + p, ext_len - p);
}

/*
 * SNIで指定されたName based virtual hostのTLS protocol versionを
 * 選択できるようにする。
 * servername_callback()ではTLS protocol versionは既に決まっているので手遅れ。
 * clienthello_callback()で処理する必要がある。
 */
int clienthello_callback(SSL *ssl, int *al, void *arg)
{
	char *servername = NULL;
	struct vhost *vh;

	printf("clienthello_callback\n");

	/* SSL_get_servername()はまだ使えない */

	servername = get_servername_from_client_hello(ssl);
	if (!servername) {
		goto end;
	}

	printf("%s\n", servername);

	vh = find_vhost(servername);
	if (!vh) {
		goto end;
	}

	select_vhost(ssl, vh);

 end:
	if (servername) {
		free(servername);
	}

	return SSL_CLIENT_HELLO_SUCCESS;
}

int servername_callback(SSL *ssl, int *al, void *arg)
{
	struct vhost *vh;

	printf("servername_callback\n");

	const char *server_name = SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name);
	if (!server_name) {
		/* Client doesn't support SNI. Select default vhost. */
		return SSL_TLSEXT_ERR_OK;
	}

	printf("%s\n", server_name);

	vh = find_vhost(server_name);
	if (!vh) {
		return SSL_TLSEXT_ERR_ALERT_FATAL;
	}

#if !USE_CLIENT_HELLO_CALLBACK
	select_vhost(ssl, vh);
#endif

	return SSL_TLSEXT_ERR_OK;
}


void cleanup_vhosts()
{
	int i;
	for (i = 0 ; i < sizeof(vhosts) / sizeof(struct vhost) ; i++) {
		if (vhosts[i].ssl_ctx) {
			SSL_CTX_free(vhosts[i].ssl_ctx);
			vhosts[i].ssl_ctx = NULL;
		}
	}
}

int init_virtual_hosts()
{
	int i;
	SSL_CTX *ctx;

	for (i = 0 ; i < sizeof(vhosts) / sizeof(struct vhost) ; i++) {
		ctx = SSL_CTX_new(TLS_server_method());
		if (ctx == NULL) {
			ERR_print_errors_fp(stderr);
			goto error;
		}

		vhosts[i].ssl_ctx = ctx;

		if (!SSL_CTX_use_certificate_chain_file(ctx, vhosts[i].cert)) {
			ERR_print_errors_fp(stderr);
			goto error;
		}
		if (!SSL_CTX_use_PrivateKey_file(ctx, vhosts[i].private, SSL_FILETYPE_PEM)) {
			ERR_print_errors_fp(stderr);
			goto error;
		}

		if (!SSL_CTX_check_private_key(ctx)) {
			ERR_print_errors_fp(stderr);
			goto error;
		}

#if USE_SNI
#if USE_CLIENT_HELLO_CALLBACK
		SSL_CTX_set_client_hello_cb(ctx, clienthello_callback, NULL);
#endif
		SSL_CTX_set_tlsext_servername_callback(ctx, servername_callback);
#endif

		SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY);

		if (SSL_CTX_set_min_proto_version(ctx, TLS1_2_VERSION) == 0) {
			ERR_print_errors_fp(stderr);
			goto error;
		}

		if (vhosts[i].ssl_options) {
			SSL_CTX_set_options(ctx, vhosts[i].ssl_options);
		}
		if (vhosts[i].cipher_list) {
			SSL_CTX_set_cipher_list(ctx, vhosts[i].cipher_list);
		}
	}
	return 0;

 error:
	cleanup_vhosts();
	return -1;
}

int process_request(BIO *bio)
{
	char buff[1000];
	const char *response = "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\n";
	SSL *ssl;
	const char *server_name = NULL;
	int sz;
	int on_going = 0;

	if (BIO_get_ssl(bio, &ssl) > 0) {
		server_name = SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name);
	}
	if (!server_name) {
		server_name = vhosts[0].server_name;	/* default server */
	}

	while ((sz = BIO_gets(bio, buff, sizeof(buff))) > 0) {
		if (on_going == 0 &&
		    buff[0] == 0x0d && buff[1] == 0x0a && buff[2] == 0x00) {
			/* empty line */
			break;
		}
		on_going = buff[sz - 1] == 0x0a ? 0 : 1;

		fputs(buff, stdout);
	}

	/* http response */
	BIO_puts(bio, response);
	BIO_puts(bio, "This is ");
	BIO_puts(bio, server_name);
	BIO_puts(bio, "\r\n");
	BIO_flush(bio);

	return 0;
}

BIO *create_bio_from_ctx(SSL_CTX *ctx)
{
	BIO *bio_buf = NULL;
	BIO *bio_ssl = NULL;

	bio_buf = BIO_new(BIO_f_buffer());
	if (!bio_buf) {
		goto error;
	}

	bio_ssl = BIO_new_ssl(ctx, 0);
	if (!bio_ssl) {
		goto error;
	}
	BIO_push(bio_buf, bio_ssl);

	return bio_buf;

error:
	if (bio_ssl) {
		BIO_free(bio_ssl);
	}
	if (bio_buf) {
		BIO_free(bio_buf);
	}

	return NULL;
}

int main(int argc, char *argv[])
{
	BIO *bio_ssl = NULL;
	BIO *bio_accept = NULL;

	init_virtual_hosts();

	/* default host(vhosts[0])のSSL_CTXを使う */
	bio_ssl = create_bio_from_ctx(vhosts[0].ssl_ctx);
	if (!bio_ssl) {
		ERR_print_errors_fp(stderr);
		goto error;
	}
	bio_accept = BIO_new_accept("8000");
	if (!bio_accept) {
		ERR_print_errors_fp(stderr);
		goto error;
	}
	if (BIO_do_accept(bio_accept) <= 0) {	/* bind */
		ERR_print_errors_fp(stderr);
		goto error;
	}

	if (BIO_set_accept_bios(bio_accept, bio_ssl) <= 0) {
		ERR_print_errors_fp(stderr);
		goto error;
	}
	bio_ssl = NULL;	/* エラー時に解放させないように */

	while (1) {
		BIO *bio = NULL;
		SSL *ssl = NULL;

		if (BIO_do_accept(bio_accept) <= 0) {
			ERR_print_errors_fp(stderr);
			goto error;	/* end */
		}
		printf("Accepted\n");

		/* get new connection */
		bio = BIO_pop(bio_accept);

		if (BIO_do_handshake(bio) <= 0) {
			ERR_print_errors_fp(stderr);
			goto next;
		}
		printf("Handshaked\n");

		if (BIO_get_ssl(bio, &ssl) <= 0) {
			ERR_print_errors_fp(stderr);
			goto error;
		}

		printf("%s\nCipher: %s\n",
		       SSL_get_version(ssl),
		       SSL_get_cipher(ssl));

		process_request(bio);

	next:
		if (bio) {
			BIO_ssl_shutdown(bio);
			BIO_free_all(bio);
		}
	}

	cleanup_vhosts();

	BIO_free_all(bio_accept);

	/* bio_sslの解放は不要 */

	return 0;

 error:
	cleanup_vhosts();

	if (bio_accept) {
		BIO_free_all(bio_accept);
	}
	if (bio_ssl) {
		BIO_free_all(bio_ssl);
	}

	return -1;
}