openssl.c 17.5 KB
Newer Older
1 2 3 4 5 6 7
/*
 * Copyright (C) the libgit2 contributors. All rights reserved.
 *
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
 */

8
#include "streams/openssl.h"
9

10
#ifdef GIT_OPENSSL
11 12 13 14 15 16

#include <ctype.h>

#include "global.h"
#include "posix.h"
#include "stream.h"
17
#include "streams/socket.h"
18
#include "netops.h"
19
#include "git2/transport.h"
20
#include "git2/sys/openssl.h"
21

22 23 24 25 26 27
#ifndef GIT_WIN32
# include <sys/types.h>
# include <sys/socket.h>
# include <netinet/in.h>
#endif

28 29 30
#include <openssl/ssl.h>
#include <openssl/err.h>
#include <openssl/x509v3.h>
31 32
#include <openssl/bio.h>

33 34
SSL_CTX *git__ssl_ctx;

35 36
#define GIT_SSL_DEFAULT_CIPHERS "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:DHE-DSS-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-DSS-AES128-SHA256:DHE-DSS-AES256-SHA256:DHE-DSS-AES128-SHA:DHE-DSS-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA"

37 38 39 40 41
#if (defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER < 0x10100000L) || \
     (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x20700000L)
# define OPENSSL_LEGACY_API
#endif

42 43 44 45
/*
 * OpenSSL 1.1 made BIO opaque so we have to use functions to interact with it
 * which do not exist in previous versions. We define these inline functions so
 * we can program against the interface instead of littering the implementation
46
 * with ifdefs. We do the same for OPENSSL_init_ssl.
47
 */
48
#if defined(OPENSSL_LEGACY_API)
49 50 51 52 53 54 55 56 57
static int OPENSSL_init_ssl(int opts, void *settings)
{
	GIT_UNUSED(opts);
	GIT_UNUSED(settings);
	SSL_load_error_strings();
	OpenSSL_add_ssl_algorithms();
	return 0;
}

58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
static BIO_METHOD* BIO_meth_new(int type, const char *name)
{
	BIO_METHOD *meth = git__calloc(1, sizeof(BIO_METHOD));
	if (!meth) {
		return NULL;
	}

	meth->type = type;
	meth->name = name;

	return meth;
}

static void BIO_meth_free(BIO_METHOD *biom)
{
	git__free(biom);
}

static int BIO_meth_set_write(BIO_METHOD *biom, int (*write) (BIO *, const char *, int))
{
	biom->bwrite = write;
	return 1;
}

static int BIO_meth_set_read(BIO_METHOD *biom, int (*read) (BIO *, char *, int))
{
	biom->bread = read;
	return 1;
}

static int BIO_meth_set_puts(BIO_METHOD *biom, int (*puts) (BIO *, const char *))
{
	biom->bputs = puts;
	return 1;
}

static int BIO_meth_set_gets(BIO_METHOD *biom, int (*gets) (BIO *, char *, int))

{
	biom->bgets = gets;
	return 1;
}

static int BIO_meth_set_ctrl(BIO_METHOD *biom, long (*ctrl) (BIO *, int, long, void *))
{
	biom->ctrl = ctrl;
	return 1;
}

static int BIO_meth_set_create(BIO_METHOD *biom, int (*create) (BIO *))
{
	biom->create = create;
	return 1;
}

static int BIO_meth_set_destroy(BIO_METHOD *biom, int (*destroy) (BIO *))
{
	biom->destroy = destroy;
	return 1;
}

static int BIO_get_new_index(void)
{
	/* This exists as of 1.1 so before we'd just have 0 */
	return 0;
}

static void BIO_set_init(BIO *b, int init)
{
	b->init = init;
}

static void BIO_set_data(BIO *a, void *ptr)
{
	a->ptr = ptr;
}

static void *BIO_get_data(BIO *a)
{
	return a->ptr;
}

static const unsigned char *ASN1_STRING_get0_data(const ASN1_STRING *x)
{
	return ASN1_STRING_data((ASN1_STRING *)x);
}

145
# if defined(GIT_THREADS)
146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172
static git_mutex *openssl_locks;

static void openssl_locking_function(
	int mode, int n, const char *file, int line)
{
	int lock;

	GIT_UNUSED(file);
	GIT_UNUSED(line);

	lock = mode & CRYPTO_LOCK;

	if (lock) {
		git_mutex_lock(&openssl_locks[n]);
	} else {
		git_mutex_unlock(&openssl_locks[n]);
	}
}

static void shutdown_ssl_locking(void)
{
	int num_locks, i;

	num_locks = CRYPTO_num_locks();
	CRYPTO_set_locking_callback(NULL);

	for (i = 0; i < num_locks; ++i)
173
		git_mutex_free(&openssl_locks[i]);
174 175
	git__free(openssl_locks);
}
176 177
# endif /* GIT_THREADS */
#endif /* OPENSSL_LEGACY_API */
178

179 180 181
static BIO_METHOD *git_stream_bio_method;
static int init_bio_method(void);

182 183 184 185 186 187
/**
 * This function aims to clean-up the SSL context which
 * we allocated.
 */
static void shutdown_ssl(void)
{
188 189 190 191 192
	if (git_stream_bio_method) {
		BIO_meth_free(git_stream_bio_method);
		git_stream_bio_method = NULL;
	}

193 194 195 196 197 198 199 200 201
	if (git__ssl_ctx) {
		SSL_CTX_free(git__ssl_ctx);
		git__ssl_ctx = NULL;
	}
}

int git_openssl_stream_global_init(void)
{
	long ssl_opts = SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3;
202
	const char *ciphers = git_libgit2__ssl_ciphers();
203 204 205 206 207 208

	/* Older OpenSSL and MacOS OpenSSL doesn't have this */
#ifdef SSL_OP_NO_COMPRESSION
	ssl_opts |= SSL_OP_NO_COMPRESSION;
#endif

209 210
	OPENSSL_init_ssl(0, NULL);

211 212 213 214 215 216
	/*
	 * Load SSLv{2,3} and TLSv1 so that we can talk with servers
	 * which use the SSL hellos, which are often used for
	 * compatibility. We then disable SSL so we only allow OpenSSL
	 * to speak TLSv1 to perform the encryption itself.
	 */
217 218
	if (!(git__ssl_ctx = SSL_CTX_new(SSLv23_method())))
		goto error;
219

220 221 222
	SSL_CTX_set_options(git__ssl_ctx, ssl_opts);
	SSL_CTX_set_mode(git__ssl_ctx, SSL_MODE_AUTO_RETRY);
	SSL_CTX_set_verify(git__ssl_ctx, SSL_VERIFY_NONE, NULL);
223 224
	if (!SSL_CTX_set_default_verify_paths(git__ssl_ctx))
		goto error;
225

226
	if (!ciphers)
227 228
		ciphers = GIT_SSL_DEFAULT_CIPHERS;

229 230
	if(!SSL_CTX_set_cipher_list(git__ssl_ctx, ciphers))
		goto error;
231

232 233
	if (init_bio_method() < 0)
		goto error;
234

235 236 237
	git__on_shutdown(shutdown_ssl);

	return 0;
238 239

error:
240
	git_error_set(GIT_ERROR_NET, "could not initialize openssl: %s",
241 242 243 244
		ERR_error_string(ERR_get_error(), NULL));
	SSL_CTX_free(git__ssl_ctx);
	git__ssl_ctx = NULL;
	return -1;
245 246
}

247
#if defined(GIT_THREADS) && defined(OPENSSL_LEGACY_API)
248 249
static void threadid_cb(CRYPTO_THREADID *threadid)
{
250 251
	GIT_UNUSED(threadid);
	CRYPTO_THREADID_set_numeric(threadid, git_thread_currentid());
252 253 254
}
#endif

255 256
int git_openssl_set_locking(void)
{
257
#if defined(GIT_THREADS) && defined(OPENSSL_LEGACY_API)
258 259
	int num_locks, i;

260 261
	CRYPTO_THREADID_set_callback(threadid_cb);

262 263
	num_locks = CRYPTO_num_locks();
	openssl_locks = git__calloc(num_locks, sizeof(git_mutex));
264
	GIT_ERROR_CHECK_ALLOC(openssl_locks);
265 266 267

	for (i = 0; i < num_locks; i++) {
		if (git_mutex_init(&openssl_locks[i]) != 0) {
268
			git_error_set(GIT_ERROR_SSL, "failed to initialize openssl locks");
269 270 271 272 273 274 275
			return -1;
		}
	}

	CRYPTO_set_locking_callback(openssl_locking_function);
	git__on_shutdown(shutdown_ssl_locking);
	return 0;
276
#elif !defined(OPENSSL_LEGACY_API)
277
	return 0;
278
#else
279
	git_error_set(GIT_ERROR_THREAD, "libgit2 was not built with threads");
280 281 282 283 284
	return -1;
#endif
}


285 286
static int bio_create(BIO *b)
{
287
	BIO_set_init(b, 1);
288
	BIO_set_data(b, NULL);
289 290 291 292 293 294 295 296 297

	return 1;
}

static int bio_destroy(BIO *b)
{
	if (!b)
		return 0;

298
	BIO_set_data(b, NULL);
299 300 301 302 303 304

	return 1;
}

static int bio_read(BIO *b, char *buf, int len)
{
305
	git_stream *io = (git_stream *) BIO_get_data(b);
306

307 308 309 310 311
	return (int) git_stream_read(io, buf, len);
}

static int bio_write(BIO *b, const char *buf, int len)
{
312
	git_stream *io = (git_stream *) BIO_get_data(b);
313

314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
	return (int) git_stream_write(io, buf, len, 0);
}

static long bio_ctrl(BIO *b, int cmd, long num, void *ptr)
{
	GIT_UNUSED(b);
	GIT_UNUSED(num);
	GIT_UNUSED(ptr);

	if (cmd == BIO_CTRL_FLUSH)
		return 1;

	return 0;
}

static int bio_gets(BIO *b, char *buf, int len)
{
	GIT_UNUSED(b);
	GIT_UNUSED(buf);
	GIT_UNUSED(len);
	return -1;
}

static int bio_puts(BIO *b, const char *str)
{
	return bio_write(b, str, strlen(str));
}

342 343 344 345
static int init_bio_method(void)
{
	/* Set up the BIO_METHOD we use for wrapping our own stream implementations */
	git_stream_bio_method = BIO_meth_new(BIO_TYPE_SOURCE_SINK | BIO_get_new_index(), "git_stream");
346
	GIT_ERROR_CHECK_ALLOC(git_stream_bio_method);
347 348 349 350 351 352 353 354 355 356 357

	BIO_meth_set_write(git_stream_bio_method, bio_write);
	BIO_meth_set_read(git_stream_bio_method, bio_read);
	BIO_meth_set_puts(git_stream_bio_method, bio_puts);
	BIO_meth_set_gets(git_stream_bio_method, bio_gets);
	BIO_meth_set_ctrl(git_stream_bio_method, bio_ctrl);
	BIO_meth_set_create(git_stream_bio_method, bio_create);
	BIO_meth_set_destroy(git_stream_bio_method, bio_destroy);

	return 0;
}
358

359 360 361 362 363 364 365 366 367 368 369 370 371
static int ssl_set_error(SSL *ssl, int error)
{
	int err;
	unsigned long e;

	err = SSL_get_error(ssl, error);

	assert(err != SSL_ERROR_WANT_READ);
	assert(err != SSL_ERROR_WANT_WRITE);

	switch (err) {
	case SSL_ERROR_WANT_CONNECT:
	case SSL_ERROR_WANT_ACCEPT:
372
		git_error_set(GIT_ERROR_SSL, "SSL error: connection failure");
373 374
		break;
	case SSL_ERROR_WANT_X509_LOOKUP:
375
		git_error_set(GIT_ERROR_SSL, "SSL error: x509 error");
376 377 378 379
		break;
	case SSL_ERROR_SYSCALL:
		e = ERR_get_error();
		if (e > 0) {
380 381
			char errmsg[256];
			ERR_error_string_n(e, errmsg, sizeof(errmsg));
382
			git_error_set(GIT_ERROR_NET, "SSL error: %s", errmsg);
383 384
			break;
		} else if (error < 0) {
385
			git_error_set(GIT_ERROR_OS, "SSL error: syscall failure");
386 387
			break;
		}
388
		git_error_set(GIT_ERROR_SSL, "SSL error: received early EOF");
389
		return GIT_EEOF;
390 391
		break;
	case SSL_ERROR_SSL:
392 393
	{
		char errmsg[256];
394
		e = ERR_get_error();
395
		ERR_error_string_n(e, errmsg, sizeof(errmsg));
396
		git_error_set(GIT_ERROR_SSL, "SSL error: %s", errmsg);
397
		break;
398
	}
399 400 401
	case SSL_ERROR_NONE:
	case SSL_ERROR_ZERO_RETURN:
	default:
402
		git_error_set(GIT_ERROR_SSL, "SSL error: unknown error");
403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433
		break;
	}
	return -1;
}

static int ssl_teardown(SSL *ssl)
{
	int ret;

	ret = SSL_shutdown(ssl);
	if (ret < 0)
		ret = ssl_set_error(ssl, ret);
	else
		ret = 0;

	return ret;
}

static int check_host_name(const char *name, const char *host)
{
	if (!strcasecmp(name, host))
		return 0;

	if (gitno__match_host(name, host) < 0)
		return -1;

	return 0;
}

static int verify_server_cert(SSL *ssl, const char *host)
{
434
	X509 *cert = NULL;
435 436 437 438 439 440 441
	X509_NAME *peer_name;
	ASN1_STRING *str;
	unsigned char *peer_cn = NULL;
	int matched = -1, type = GEN_DNS;
	GENERAL_NAMES *alts;
	struct in6_addr addr6;
	struct in_addr addr4;
442
	void *addr = NULL;
443
	int i = -1, j, error = 0;
444 445

	if (SSL_get_verify_result(ssl) != X509_V_OK) {
446
		git_error_set(GIT_ERROR_SSL, "the SSL certificate is invalid");
447
		return GIT_ECERTIFICATE;
448 449 450 451 452 453 454
	}

	/* Try to parse the host as an IP address to see if it is */
	if (p_inet_pton(AF_INET, host, &addr4)) {
		type = GEN_IPADD;
		addr = &addr4;
	} else {
455
		if (p_inet_pton(AF_INET6, host, &addr6)) {
456 457 458 459 460 461 462 463
			type = GEN_IPADD;
			addr = &addr6;
		}
	}


	cert = SSL_get_peer_certificate(ssl);
	if (!cert) {
464
		error = -1;
465
		git_error_set(GIT_ERROR_SSL, "the server did not provide a certificate");
466
		goto cleanup;
467 468 469 470 471 472 473 474 475 476
	}

	/* Check the alternative names */
	alts = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);
	if (alts) {
		int num;

		num = sk_GENERAL_NAME_num(alts);
		for (i = 0; i < num && matched != 1; i++) {
			const GENERAL_NAME *gn = sk_GENERAL_NAME_value(alts, i);
477
			const char *name = (char *) ASN1_STRING_get0_data(gn->d.ia5);
478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494
			size_t namelen = (size_t) ASN1_STRING_length(gn->d.ia5);

			/* Skip any names of a type we're not looking for */
			if (gn->type != type)
				continue;

			if (type == GEN_DNS) {
				/* If it contains embedded NULs, don't even try */
				if (memchr(name, '\0', namelen))
					continue;

				if (check_host_name(name, host) < 0)
					matched = 0;
				else
					matched = 1;
			} else if (type == GEN_IPADD) {
				/* Here name isn't so much a name but a binary representation of the IP */
495
				matched = addr && !!memcmp(name, addr, namelen);
496 497 498 499 500 501 502 503
			}
		}
	}
	GENERAL_NAMES_free(alts);

	if (matched == 0)
		goto cert_fail_name;

504 505 506
	if (matched == 1) {
		goto cleanup;
	}
507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531

	/* If no alternative names are available, check the common name */
	peer_name = X509_get_subject_name(cert);
	if (peer_name == NULL)
		goto on_error;

	if (peer_name) {
		/* Get the index of the last CN entry */
		while ((j = X509_NAME_get_index_by_NID(peer_name, NID_commonName, i)) >= 0)
			i = j;
	}

	if (i < 0)
		goto on_error;

	str = X509_NAME_ENTRY_get_data(X509_NAME_get_entry(peer_name, i));
	if (str == NULL)
		goto on_error;

	/* Work around a bug in OpenSSL whereby ASN1_STRING_to_UTF8 fails if it's already in utf-8 */
	if (ASN1_STRING_type(str) == V_ASN1_UTF8STRING) {
		int size = ASN1_STRING_length(str);

		if (size > 0) {
			peer_cn = OPENSSL_malloc(size + 1);
532
			GIT_ERROR_CHECK_ALLOC(peer_cn);
533
			memcpy(peer_cn, ASN1_STRING_get0_data(str), size);
534
			peer_cn[size] = '\0';
535 536
		} else {
			goto cert_fail_name;
537 538 539
		}
	} else {
		int size = ASN1_STRING_to_UTF8(&peer_cn, str);
540
		GIT_ERROR_CHECK_ALLOC(peer_cn);
541 542 543 544 545 546 547
		if (memchr(peer_cn, '\0', size))
			goto cert_fail_name;
	}

	if (check_host_name((char *)peer_cn, host) < 0)
		goto cert_fail_name;

548
	goto cleanup;
549

550 551
cert_fail_name:
	error = GIT_ECERTIFICATE;
552
	git_error_set(GIT_ERROR_SSL, "hostname does not match certificate");
553
	goto cleanup;
554 555

on_error:
556 557
	error = ssl_set_error(ssl, 0);
	goto cleanup;
558

559
cleanup:
560
	X509_free(cert);
561
	OPENSSL_free(peer_cn);
562
	return error;
563 564 565 566
}

typedef struct {
	git_stream parent;
567
	git_stream *io;
568
	int owned;
569
	bool connected;
570
	char *host;
571 572 573 574
	SSL *ssl;
	git_cert_x509 cert_info;
} openssl_stream;

575
static int openssl_connect(git_stream *stream)
576 577
{
	int ret;
578
	BIO *bio;
579 580
	openssl_stream *st = (openssl_stream *) stream;

581
	if (st->owned && (ret = git_stream_connect(st->io)) < 0)
582 583
		return ret;

584
	bio = BIO_new(git_stream_bio_method);
585
	GIT_ERROR_CHECK_ALLOC(bio);
586

587
	BIO_set_data(bio, st->io);
588
	SSL_set_bio(st->ssl, bio, bio);
589

590
	/* specify the host in case SNI is needed */
591
#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
592
	SSL_set_tlsext_host_name(st->ssl, st->host);
593
#endif
594

595 596 597
	if ((ret = SSL_connect(st->ssl)) <= 0)
		return ssl_set_error(st->ssl, ret);

598 599
	st->connected = true;

600
	return verify_server_cert(st->ssl, st->host);
601 602
}

603
static int openssl_certificate(git_cert **out, git_stream *stream)
604 605 606 607 608 609 610 611 612
{
	openssl_stream *st = (openssl_stream *) stream;
	int len;
	X509 *cert = SSL_get_peer_certificate(st->ssl);
	unsigned char *guard, *encoded_cert;

	/* Retrieve the length of the certificate first */
	len = i2d_X509(cert, NULL);
	if (len < 0) {
613
		git_error_set(GIT_ERROR_NET, "failed to retrieve certificate information");
614 615 616 617
		return -1;
	}

	encoded_cert = git__malloc(len);
618
	GIT_ERROR_CHECK_ALLOC(encoded_cert);
619 620 621 622 623 624
	/* i2d_X509 makes 'guard' point to just after the data */
	guard = encoded_cert;

	len = i2d_X509(cert, &guard);
	if (len < 0) {
		git__free(encoded_cert);
625
		git_error_set(GIT_ERROR_NET, "failed to retrieve certificate information");
626 627 628
		return -1;
	}

629
	st->cert_info.parent.cert_type = GIT_CERT_X509;
630 631 632
	st->cert_info.data = encoded_cert;
	st->cert_info.len = len;

633 634
	*out = &st->cert_info.parent;

635 636 637
	return 0;
}

638
static int openssl_set_proxy(git_stream *stream, const git_proxy_options *proxy_opts)
639 640 641
{
	openssl_stream *st = (openssl_stream *) stream;

642
	return git_stream_set_proxy(st->io, proxy_opts);
643 644
}

645
static ssize_t openssl_write(git_stream *stream, const char *data, size_t data_len, int flags)
646 647
{
	openssl_stream *st = (openssl_stream *) stream;
648
	int ret, len = min(data_len, INT_MAX);
649 650 651

	GIT_UNUSED(flags);

652
	if ((ret = SSL_write(st->ssl, data, len)) <= 0)
653
		return ssl_set_error(st->ssl, ret);
654

655
	return ret;
656 657
}

658
static ssize_t openssl_read(git_stream *stream, void *data, size_t len)
659 660 661 662
{
	openssl_stream *st = (openssl_stream *) stream;
	int ret;

663
	if ((ret = SSL_read(st->ssl, data, len)) <= 0)
664
		return ssl_set_error(st->ssl, ret);
665 666 667 668

	return ret;
}

669
static int openssl_close(git_stream *stream)
670 671 672 673
{
	openssl_stream *st = (openssl_stream *) stream;
	int ret;

674
	if (st->connected && (ret = ssl_teardown(st->ssl)) < 0)
675 676
		return -1;

677 678
	st->connected = false;

679
	return st->owned ? git_stream_close(st->io) : 0;
680 681
}

682
static void openssl_free(git_stream *stream)
683 684 685
{
	openssl_stream *st = (openssl_stream *) stream;

686 687 688
	if (st->owned)
		git_stream_free(st->io);

689
	SSL_free(st->ssl);
690
	git__free(st->host);
691 692 693 694
	git__free(st->cert_info.data);
	git__free(st);
}

695 696 697 698 699
static int openssl_stream_wrap(
	git_stream **out,
	git_stream *in,
	const char *host,
	int owned)
700 701 702
{
	openssl_stream *st;

703 704
	assert(out && in && host);

705
	st = git__calloc(1, sizeof(openssl_stream));
706
	GIT_ERROR_CHECK_ALLOC(st);
707

708 709
	st->io = in;
	st->owned = owned;
710 711 712

	st->ssl = SSL_new(git__ssl_ctx);
	if (st->ssl == NULL) {
713
		git_error_set(GIT_ERROR_SSL, "failed to create ssl object");
714 715
		git__free(st);
		return -1;
716 717
	}

718
	st->host = git__strdup(host);
719
	GIT_ERROR_CHECK_ALLOC(st->host);
720

721 722
	st->parent.version = GIT_STREAM_VERSION;
	st->parent.encrypted = 1;
723
	st->parent.proxy_support = git_stream_supports_proxy(st->io);
724 725
	st->parent.connect = openssl_connect;
	st->parent.certificate = openssl_certificate;
726
	st->parent.set_proxy = openssl_set_proxy;
727 728 729 730 731 732 733
	st->parent.read = openssl_read;
	st->parent.write = openssl_write;
	st->parent.close = openssl_close;
	st->parent.free = openssl_free;

	*out = (git_stream *) st;
	return 0;
734
}
735

736 737 738 739 740 741 742 743 744 745 746 747
int git_openssl_stream_wrap(git_stream **out, git_stream *in, const char *host)
{
	return openssl_stream_wrap(out, in, host, 0);
}

int git_openssl_stream_new(git_stream **out, const char *host, const char *port)
{
	git_stream *stream = NULL;
	int error;

	assert(out && host && port);

Edward Thomson committed
748
	if ((error = git_socket_stream_new(&stream, host, port)) < 0)
749 750 751 752 753 754
		return error;

	if ((error = openssl_stream_wrap(out, stream, host, 1)) < 0) {
		git_stream_close(stream);
		git_stream_free(stream);
	}
755 756

	return error;
757 758
}

759 760 761
int git_openssl__set_cert_location(const char *file, const char *path)
{
	if (SSL_CTX_load_verify_locations(git__ssl_ctx, file, path) == 0) {
762 763 764
		char errmsg[256];

		ERR_error_string_n(ERR_get_error(), errmsg, sizeof(errmsg));
765
		git_error_set(GIT_ERROR_SSL, "OpenSSL error: failed to load certificates: %s",
766 767
			errmsg);

768 769 770 771 772
		return -1;
	}
	return 0;
}

773 774 775
#else

#include "stream.h"
776
#include "git2/sys/openssl.h"
777

778 779 780 781 782 783 784
int git_openssl_stream_global_init(void)
{
	return 0;
}

int git_openssl_set_locking(void)
{
785
	git_error_set(GIT_ERROR_SSL, "libgit2 was not built with OpenSSL support");
786 787 788
	return -1;
}

789
#endif