[libgit2.git] / src / util / hash / win32.c

/*
 * 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.
 */

#include "win32.h"

#include "runtime.h"

#include <wincrypt.h>
#include <strsafe.h>

#define GIT_HASH_CNG_DLL_NAME           "bcrypt.dll"

/* BCRYPT_SHA1_ALGORITHM */
#define GIT_HASH_CNG_SHA1_TYPE          L"SHA1"
#define GIT_HASH_CNG_SHA256_TYPE        L"SHA256"

/* BCRYPT_OBJECT_LENGTH */
#define GIT_HASH_CNG_HASH_OBJECT_LEN    L"ObjectLength"

/* BCRYPT_HASH_REUSEABLE_FLAGS */
#define GIT_HASH_CNG_HASH_REUSABLE      0x00000020

/* Definitions */

/* CryptoAPI is available for hashing on Windows XP and newer.  */
struct cryptoapi_provider {
	HCRYPTPROV handle;
};

/*
 * CNG (bcrypt.dll) is significantly more performant than CryptoAPI and is
 * preferred, however it is only available on Windows 2008 and newer and
 * must therefore be dynamically loaded, and we must inline constants that
 * would not exist when building in pre-Windows 2008 environments.
 */

/* Function declarations for CNG */
typedef NTSTATUS (WINAPI *cng_open_algorithm_provider_fn)(
	HANDLE /* BCRYPT_ALG_HANDLE */ *phAlgorithm,
	LPCWSTR pszAlgId,
	LPCWSTR pszImplementation,
	DWORD dwFlags);

typedef NTSTATUS (WINAPI *cng_get_property_fn)(
	HANDLE /* BCRYPT_HANDLE */ hObject,
	LPCWSTR pszProperty,
	PUCHAR pbOutput,
	ULONG cbOutput,
	ULONG *pcbResult,
	ULONG dwFlags);

typedef NTSTATUS (WINAPI *cng_create_hash_fn)(
	HANDLE /* BCRYPT_ALG_HANDLE */ hAlgorithm,
	HANDLE /* BCRYPT_HASH_HANDLE */ *phHash,
	PUCHAR pbHashObject, ULONG cbHashObject,
	PUCHAR pbSecret,
	ULONG cbSecret,
	ULONG dwFlags);

typedef NTSTATUS (WINAPI *cng_finish_hash_fn)(
	HANDLE /* BCRYPT_HASH_HANDLE */ hHash,
	PUCHAR pbOutput,
	ULONG cbOutput,
	ULONG dwFlags);

typedef NTSTATUS (WINAPI *cng_hash_data_fn)(
	HANDLE /* BCRYPT_HASH_HANDLE */ hHash,
	PUCHAR pbInput,
	ULONG cbInput,
	ULONG dwFlags);

typedef NTSTATUS (WINAPI *cng_destroy_hash_fn)(
	HANDLE /* BCRYPT_HASH_HANDLE */ hHash);

typedef NTSTATUS (WINAPI *cng_close_algorithm_provider_fn)(
	HANDLE /* BCRYPT_ALG_HANDLE */ hAlgorithm,
	ULONG dwFlags);

struct cng_provider {
	/* DLL for CNG */
	HINSTANCE dll;

	/* Function pointers for CNG */
	cng_open_algorithm_provider_fn open_algorithm_provider;
	cng_get_property_fn get_property;
	cng_create_hash_fn create_hash;
	cng_finish_hash_fn finish_hash;
	cng_hash_data_fn hash_data;
	cng_destroy_hash_fn destroy_hash;
	cng_close_algorithm_provider_fn close_algorithm_provider;

	HANDLE /* BCRYPT_ALG_HANDLE */ sha1_handle;
	DWORD sha1_object_size;

	HANDLE /* BCRYPT_ALG_HANDLE */ sha256_handle;
	DWORD sha256_object_size;
};

typedef struct {
	git_hash_win32_provider_t type;

	union {
		struct cryptoapi_provider cryptoapi;
		struct cng_provider cng;
	} provider;
} hash_win32_provider;

/* Hash provider definition */

static hash_win32_provider hash_provider = {0};

/* Hash initialization */

/* Initialize CNG, if available */
GIT_INLINE(int) cng_provider_init(void)
{
	char dll_path[MAX_PATH];
	DWORD dll_path_len, size_len;

	/* Only use CNG on Windows 2008 / Vista SP1  or better (Windows 6.0 SP1) */
	if (!git_has_win32_version(6, 0, 1)) {
		git_error_set(GIT_ERROR_SHA, "CryptoNG is not supported on this platform");
		return -1;
	}

	/* Load bcrypt.dll explicitly from the system directory */
	if ((dll_path_len = GetSystemDirectory(dll_path, MAX_PATH)) == 0 ||
		dll_path_len > MAX_PATH ||
		StringCchCat(dll_path, MAX_PATH, "\\") < 0 ||
		StringCchCat(dll_path, MAX_PATH, GIT_HASH_CNG_DLL_NAME) < 0 ||
		(hash_provider.provider.cng.dll = LoadLibrary(dll_path)) == NULL) {
		git_error_set(GIT_ERROR_SHA, "CryptoNG library could not be loaded");
		return -1;
	}

	/* Load the function addresses */
	if ((hash_provider.provider.cng.open_algorithm_provider = (cng_open_algorithm_provider_fn)((void *)GetProcAddress(hash_provider.provider.cng.dll, "BCryptOpenAlgorithmProvider"))) == NULL ||
		(hash_provider.provider.cng.get_property = (cng_get_property_fn)((void *)GetProcAddress(hash_provider.provider.cng.dll, "BCryptGetProperty"))) == NULL ||
		(hash_provider.provider.cng.create_hash = (cng_create_hash_fn)((void *)GetProcAddress(hash_provider.provider.cng.dll, "BCryptCreateHash"))) == NULL ||
		(hash_provider.provider.cng.finish_hash = (cng_finish_hash_fn)((void *)GetProcAddress(hash_provider.provider.cng.dll, "BCryptFinishHash"))) == NULL ||
		(hash_provider.provider.cng.hash_data = (cng_hash_data_fn)((void *)GetProcAddress(hash_provider.provider.cng.dll, "BCryptHashData"))) == NULL ||
		(hash_provider.provider.cng.destroy_hash = (cng_destroy_hash_fn)((void *)GetProcAddress(hash_provider.provider.cng.dll, "BCryptDestroyHash"))) == NULL ||
		(hash_provider.provider.cng.close_algorithm_provider = (cng_close_algorithm_provider_fn)((void *)GetProcAddress(hash_provider.provider.cng.dll, "BCryptCloseAlgorithmProvider"))) == NULL) {
		FreeLibrary(hash_provider.provider.cng.dll);

		git_error_set(GIT_ERROR_OS, "CryptoNG functions could not be loaded");
		return -1;
	}

	/* Load the SHA1 algorithm */
	if (hash_provider.provider.cng.open_algorithm_provider(&hash_provider.provider.cng.sha1_handle, GIT_HASH_CNG_SHA1_TYPE, NULL, GIT_HASH_CNG_HASH_REUSABLE) < 0 ||
	    hash_provider.provider.cng.get_property(hash_provider.provider.cng.sha1_handle, GIT_HASH_CNG_HASH_OBJECT_LEN, (PBYTE)&hash_provider.provider.cng.sha1_object_size, sizeof(DWORD), &size_len, 0) < 0) {
		git_error_set(GIT_ERROR_OS, "algorithm provider could not be initialized");
		goto on_error;
	}

	/* Load the SHA256 algorithm */
	if (hash_provider.provider.cng.open_algorithm_provider(&hash_provider.provider.cng.sha256_handle, GIT_HASH_CNG_SHA256_TYPE, NULL, GIT_HASH_CNG_HASH_REUSABLE) < 0 ||
	    hash_provider.provider.cng.get_property(hash_provider.provider.cng.sha256_handle, GIT_HASH_CNG_HASH_OBJECT_LEN, (PBYTE)&hash_provider.provider.cng.sha256_object_size, sizeof(DWORD), &size_len, 0) < 0) {
		git_error_set(GIT_ERROR_OS, "algorithm provider could not be initialized");
		goto on_error;
	}

	hash_provider.type = GIT_HASH_WIN32_CNG;
	return 0;

on_error:
	if (hash_provider.provider.cng.sha1_handle)
		hash_provider.provider.cng.close_algorithm_provider(hash_provider.provider.cng.sha1_handle, 0);

	if (hash_provider.provider.cng.sha256_handle)
		hash_provider.provider.cng.close_algorithm_provider(hash_provider.provider.cng.sha256_handle, 0);

	if (hash_provider.provider.cng.dll)
		FreeLibrary(hash_provider.provider.cng.dll);

	return -1;
}

GIT_INLINE(void) cng_provider_shutdown(void)
{
	if (hash_provider.type == GIT_HASH_WIN32_INVALID)
		return;

	hash_provider.provider.cng.close_algorithm_provider(hash_provider.provider.cng.sha1_handle, 0);
	hash_provider.provider.cng.close_algorithm_provider(hash_provider.provider.cng.sha256_handle, 0);
	FreeLibrary(hash_provider.provider.cng.dll);

	hash_provider.type = GIT_HASH_WIN32_INVALID;
}

/* Initialize CryptoAPI */
GIT_INLINE(int) cryptoapi_provider_init(void)
{
	if (!CryptAcquireContext(&hash_provider.provider.cryptoapi.handle, NULL, 0, PROV_RSA_AES, CRYPT_VERIFYCONTEXT)) {
		git_error_set(GIT_ERROR_OS, "legacy hash context could not be started");
		return -1;
	}

	hash_provider.type = GIT_HASH_WIN32_CRYPTOAPI;
	return 0;
}

GIT_INLINE(void) cryptoapi_provider_shutdown(void)
{
	if (hash_provider.type == GIT_HASH_WIN32_INVALID)
		return;

	CryptReleaseContext(hash_provider.provider.cryptoapi.handle, 0);

	hash_provider.type = GIT_HASH_WIN32_INVALID;
}

static void hash_provider_shutdown(void)
{
	if (hash_provider.type == GIT_HASH_WIN32_CNG)
		cng_provider_shutdown();
	else if (hash_provider.type == GIT_HASH_WIN32_CRYPTOAPI)
		cryptoapi_provider_shutdown();
}

static int hash_provider_init(void)
{
	int error = 0;

	if (hash_provider.type != GIT_HASH_WIN32_INVALID)
		return 0;

	if ((error = cng_provider_init()) < 0)
		error = cryptoapi_provider_init();

	if (!error)
		error = git_runtime_shutdown_register(hash_provider_shutdown);

	return error;
}

git_hash_win32_provider_t git_hash_win32_provider(void)
{
	return hash_provider.type;
}

int git_hash_win32_set_provider(git_hash_win32_provider_t provider)
{
	if (provider == hash_provider.type)
		return 0;

	hash_provider_shutdown();

	if (provider == GIT_HASH_WIN32_CNG)
		return cng_provider_init();
	else if (provider == GIT_HASH_WIN32_CRYPTOAPI)
		return cryptoapi_provider_init();

	git_error_set(GIT_ERROR_SHA, "unsupported win32 provider");
	return -1;
}

/* CryptoAPI: available in Windows XP and newer */

GIT_INLINE(int) hash_cryptoapi_init(git_hash_win32_ctx *ctx)
{
	if (ctx->ctx.cryptoapi.valid)
		CryptDestroyHash(ctx->ctx.cryptoapi.hash_handle);

	if (!CryptCreateHash(hash_provider.provider.cryptoapi.handle, ctx->algorithm, 0, 0, &ctx->ctx.cryptoapi.hash_handle)) {
		ctx->ctx.cryptoapi.valid = 0;
		git_error_set(GIT_ERROR_OS, "legacy hash implementation could not be created");
		return -1;
	}

	ctx->ctx.cryptoapi.valid = 1;
	return 0;
}

GIT_INLINE(int) hash_cryptoapi_update(git_hash_win32_ctx *ctx, const void *_data, size_t len)
{
	const BYTE *data = (BYTE *)_data;

	GIT_ASSERT(ctx->ctx.cryptoapi.valid);

	while (len > 0) {
		DWORD chunk = (len > MAXDWORD) ? MAXDWORD : (DWORD)len;

		if (!CryptHashData(ctx->ctx.cryptoapi.hash_handle, data, chunk, 0)) {
			git_error_set(GIT_ERROR_OS, "legacy hash data could not be updated");
			return -1;
		}

		data += chunk;
		len -= chunk;
	}

	return 0;
}

GIT_INLINE(int) hash_cryptoapi_final(unsigned char *out, git_hash_win32_ctx *ctx)
{
	DWORD len = ctx->algorithm == CALG_SHA_256 ? GIT_HASH_SHA256_SIZE : GIT_HASH_SHA1_SIZE;
	int error = 0;

	GIT_ASSERT(ctx->ctx.cryptoapi.valid);

	if (!CryptGetHashParam(ctx->ctx.cryptoapi.hash_handle, HP_HASHVAL, out, &len, 0)) {
		git_error_set(GIT_ERROR_OS, "legacy hash data could not be finished");
		error = -1;
	}

	CryptDestroyHash(ctx->ctx.cryptoapi.hash_handle);
	ctx->ctx.cryptoapi.valid = 0;

	return error;
}

GIT_INLINE(void) hash_ctx_cryptoapi_cleanup(git_hash_win32_ctx *ctx)
{
	if (ctx->ctx.cryptoapi.valid)
		CryptDestroyHash(ctx->ctx.cryptoapi.hash_handle);
}

GIT_INLINE(int) hash_sha1_cryptoapi_ctx_init_init(git_hash_win32_ctx *ctx)
{
	ctx->algorithm = CALG_SHA1;
	return hash_cryptoapi_init(ctx);
}

GIT_INLINE(int) hash_sha256_cryptoapi_ctx_init(git_hash_win32_ctx *ctx)
{
	ctx->algorithm = CALG_SHA_256;
	return hash_cryptoapi_init(ctx);
}

/* CNG: Available in Windows Server 2008 and newer */

GIT_INLINE(int) hash_sha1_cng_ctx_init(git_hash_win32_ctx *ctx)
{
	if ((ctx->ctx.cng.hash_object = git__malloc(hash_provider.provider.cng.sha1_object_size)) == NULL)
		return -1;

	if (hash_provider.provider.cng.create_hash(hash_provider.provider.cng.sha1_handle, &ctx->ctx.cng.hash_handle, ctx->ctx.cng.hash_object, hash_provider.provider.cng.sha1_object_size, NULL, 0, 0) < 0) {
		git__free(ctx->ctx.cng.hash_object);

		git_error_set(GIT_ERROR_OS, "sha1 implementation could not be created");
		return -1;
	}

	ctx->algorithm = CALG_SHA1;
	return 0;
}

GIT_INLINE(int) hash_sha256_cng_ctx_init(git_hash_win32_ctx *ctx)
{
	if ((ctx->ctx.cng.hash_object = git__malloc(hash_provider.provider.cng.sha256_object_size)) == NULL)
		return -1;

	if (hash_provider.provider.cng.create_hash(hash_provider.provider.cng.sha256_handle, &ctx->ctx.cng.hash_handle, ctx->ctx.cng.hash_object, hash_provider.provider.cng.sha256_object_size, NULL, 0, 0) < 0) {
		git__free(ctx->ctx.cng.hash_object);

		git_error_set(GIT_ERROR_OS, "sha256 implementation could not be created");
		return -1;
	}

	ctx->algorithm = CALG_SHA_256;
	return 0;
}

GIT_INLINE(int) hash_cng_init(git_hash_win32_ctx *ctx)
{
	BYTE hash[GIT_HASH_SHA256_SIZE];
	ULONG size = ctx->algorithm == CALG_SHA_256 ? GIT_HASH_SHA256_SIZE : GIT_HASH_SHA1_SIZE;

	if (!ctx->ctx.cng.updated)
		return 0;

	/* CNG needs to be finished to restart */
	if (hash_provider.provider.cng.finish_hash(ctx->ctx.cng.hash_handle, hash, size, 0) < 0) {
		git_error_set(GIT_ERROR_OS, "hash implementation could not be finished");
		return -1;
	}

	ctx->ctx.cng.updated = 0;

	return 0;
}

GIT_INLINE(int) hash_cng_update(git_hash_win32_ctx *ctx, const void *_data, size_t len)
{
	PBYTE data = (PBYTE)_data;

	while (len > 0) {
		ULONG chunk = (len > ULONG_MAX) ? ULONG_MAX : (ULONG)len;

		if (hash_provider.provider.cng.hash_data(ctx->ctx.cng.hash_handle, data, chunk, 0) < 0) {
			git_error_set(GIT_ERROR_OS, "hash could not be updated");
			return -1;
		}

		data += chunk;
		len -= chunk;
	}

	return 0;
}

GIT_INLINE(int) hash_cng_final(unsigned char *out, git_hash_win32_ctx *ctx)
{
	ULONG size = ctx->algorithm == CALG_SHA_256 ? GIT_HASH_SHA256_SIZE : GIT_HASH_SHA1_SIZE;

	if (hash_provider.provider.cng.finish_hash(ctx->ctx.cng.hash_handle, out, size, 0) < 0) {
		git_error_set(GIT_ERROR_OS, "hash could not be finished");
		return -1;
	}

	ctx->ctx.cng.updated = 0;

	return 0;
}

GIT_INLINE(void) hash_ctx_cng_cleanup(git_hash_win32_ctx *ctx)
{
	hash_provider.provider.cng.destroy_hash(ctx->ctx.cng.hash_handle);
	git__free(ctx->ctx.cng.hash_object);
}

/* Indirection between CryptoAPI and CNG */

GIT_INLINE(int) hash_sha1_win32_ctx_init(git_hash_win32_ctx *ctx)
{
	GIT_ASSERT_ARG(hash_provider.type);

	memset(ctx, 0x0, sizeof(git_hash_win32_ctx));
	return (hash_provider.type == GIT_HASH_WIN32_CNG) ? hash_sha1_cng_ctx_init(ctx) : hash_sha1_cryptoapi_ctx_init_init(ctx);
}

GIT_INLINE(int) hash_sha256_win32_ctx_init(git_hash_win32_ctx *ctx)
{
	GIT_ASSERT_ARG(hash_provider.type);

	memset(ctx, 0x0, sizeof(git_hash_win32_ctx));
	return (hash_provider.type == GIT_HASH_WIN32_CNG) ? hash_sha256_cng_ctx_init(ctx) : hash_sha256_cryptoapi_ctx_init(ctx);
}

GIT_INLINE(int) hash_win32_init(git_hash_win32_ctx *ctx)
{
	return (hash_provider.type == GIT_HASH_WIN32_CNG) ? hash_cng_init(ctx) : hash_cryptoapi_init(ctx);
}

GIT_INLINE(int) hash_win32_update(git_hash_win32_ctx *ctx, const void *data, size_t len)
{
	return (hash_provider.type == GIT_HASH_WIN32_CNG) ? hash_cng_update(ctx, data, len) : hash_cryptoapi_update(ctx, data, len);
}

GIT_INLINE(int) hash_win32_final(unsigned char *out, git_hash_win32_ctx *ctx)
{
	GIT_ASSERT_ARG(ctx);
	return (hash_provider.type == GIT_HASH_WIN32_CNG) ? hash_cng_final(out, ctx) : hash_cryptoapi_final(out, ctx);
}

GIT_INLINE(void) hash_win32_cleanup(git_hash_win32_ctx *ctx)
{
	if (hash_provider.type == GIT_HASH_WIN32_CNG)
		hash_ctx_cng_cleanup(ctx);
	else if(hash_provider.type == GIT_HASH_WIN32_CRYPTOAPI)
		hash_ctx_cryptoapi_cleanup(ctx);
}

#ifdef GIT_SHA1_WIN32

int git_hash_sha1_global_init(void)
{
	return hash_provider_init();
}

int git_hash_sha1_ctx_init(git_hash_sha1_ctx *ctx)
{
	GIT_ASSERT_ARG(ctx);
	return hash_sha1_win32_ctx_init(&ctx->win32);
}

int git_hash_sha1_init(git_hash_sha1_ctx *ctx)
{
	GIT_ASSERT_ARG(ctx);
	return hash_win32_init(&ctx->win32);
}

int git_hash_sha1_update(git_hash_sha1_ctx *ctx, const void *data, size_t len)
{
	GIT_ASSERT_ARG(ctx);
	return hash_win32_update(&ctx->win32, data, len);
}

int git_hash_sha1_final(unsigned char *out, git_hash_sha1_ctx *ctx)
{
	GIT_ASSERT_ARG(ctx);
	return hash_win32_final(out, &ctx->win32);
}

void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx)
{
	if (!ctx)
		return;
	hash_win32_cleanup(&ctx->win32);
}

#endif

#ifdef GIT_SHA256_WIN32

int git_hash_sha256_global_init(void)
{
	return hash_provider_init();
}

int git_hash_sha256_ctx_init(git_hash_sha256_ctx *ctx)
{
	GIT_ASSERT_ARG(ctx);
	return hash_sha256_win32_ctx_init(&ctx->win32);
}

int git_hash_sha256_init(git_hash_sha256_ctx *ctx)
{
	GIT_ASSERT_ARG(ctx);
	return hash_win32_init(&ctx->win32);
}

int git_hash_sha256_update(git_hash_sha256_ctx *ctx, const void *data, size_t len)
{
	GIT_ASSERT_ARG(ctx);
	return hash_win32_update(&ctx->win32, data, len);
}

int git_hash_sha256_final(unsigned char *out, git_hash_sha256_ctx *ctx)
{
	GIT_ASSERT_ARG(ctx);
	return hash_win32_final(out, &ctx->win32);
}

void git_hash_sha256_ctx_cleanup(git_hash_sha256_ctx *ctx)
{
	if (!ctx)
		return;
	hash_win32_cleanup(&ctx->win32);
}

#endif
Commit	Line	Data
ad5611d8 TR	1	/*
	2	* Copyright (C) the libgit2 contributors. All rights reserved.
	3	*
	4	* This file is part of libgit2, distributed under the GNU GPL v2 with
	5	* a Linking Exception. For full terms see the included COPYING file.
	6	*/
	7
	8	#include "win32.h"
	9
	10	#include "runtime.h"
	11
	12	#include <wincrypt.h>
	13	#include <strsafe.h>
	14
	15	#define GIT_HASH_CNG_DLL_NAME "bcrypt.dll"
	16
	17	/* BCRYPT_SHA1_ALGORITHM */
	18	#define GIT_HASH_CNG_SHA1_TYPE L"SHA1"
	19	#define GIT_HASH_CNG_SHA256_TYPE L"SHA256"
	20
	21	/* BCRYPT_OBJECT_LENGTH */
	22	#define GIT_HASH_CNG_HASH_OBJECT_LEN L"ObjectLength"
	23
	24	/* BCRYPT_HASH_REUSEABLE_FLAGS */
	25	#define GIT_HASH_CNG_HASH_REUSABLE 0x00000020
	26
	27	/* Definitions */
	28
	29	/* CryptoAPI is available for hashing on Windows XP and newer. */
	30	struct cryptoapi_provider {
	31	HCRYPTPROV handle;
	32	};
	33
	34	/*
	35	* CNG (bcrypt.dll) is significantly more performant than CryptoAPI and is
	36	* preferred, however it is only available on Windows 2008 and newer and
	37	* must therefore be dynamically loaded, and we must inline constants that
	38	* would not exist when building in pre-Windows 2008 environments.
	39	*/
	40
	41	/* Function declarations for CNG */
	42	typedef NTSTATUS (WINAPI *cng_open_algorithm_provider_fn)(
	43	HANDLE /* BCRYPT_ALG_HANDLE / phAlgorithm,
	44	LPCWSTR pszAlgId,
	45	LPCWSTR pszImplementation,
	46	DWORD dwFlags);
	47
	48	typedef NTSTATUS (WINAPI *cng_get_property_fn)(
	49	HANDLE /* BCRYPT_HANDLE */ hObject,
	50	LPCWSTR pszProperty,
	51	PUCHAR pbOutput,
	52	ULONG cbOutput,
	53	ULONG *pcbResult,
	54	ULONG dwFlags);
	55
	56	typedef NTSTATUS (WINAPI *cng_create_hash_fn)(
	57	HANDLE /* BCRYPT_ALG_HANDLE */ hAlgorithm,
	58	HANDLE /* BCRYPT_HASH_HANDLE / phHash,
	59	PUCHAR pbHashObject, ULONG cbHashObject,
	60	PUCHAR pbSecret,
	61	ULONG cbSecret,
	62	ULONG dwFlags);
	63
	64	typedef NTSTATUS (WINAPI *cng_finish_hash_fn)(
65	HANDLE /* BCRYPT_HASH_HANDLE */ hHash,
66	PUCHAR pbOutput,
67	ULONG cbOutput,
68	ULONG dwFlags);
69
70	typedef NTSTATUS (WINAPI *cng_hash_data_fn)(
71	HANDLE /* BCRYPT_HASH_HANDLE */ hHash,
72	PUCHAR pbInput,
73	ULONG cbInput,
74	ULONG dwFlags);
75
76	typedef NTSTATUS (WINAPI *cng_destroy_hash_fn)(
77	HANDLE /* BCRYPT_HASH_HANDLE */ hHash);
78
79	typedef NTSTATUS (WINAPI *cng_close_algorithm_provider_fn)(
80	HANDLE /* BCRYPT_ALG_HANDLE */ hAlgorithm,
81	ULONG dwFlags);
82
83	struct cng_provider {
84	/* DLL for CNG */
85	HINSTANCE dll;
86
87	/* Function pointers for CNG */
88	cng_open_algorithm_provider_fn open_algorithm_provider;
89	cng_get_property_fn get_property;
90	cng_create_hash_fn create_hash;
91	cng_finish_hash_fn finish_hash;
92	cng_hash_data_fn hash_data;
93	cng_destroy_hash_fn destroy_hash;
94	cng_close_algorithm_provider_fn close_algorithm_provider;
95
96	HANDLE /* BCRYPT_ALG_HANDLE */ sha1_handle;
97	DWORD sha1_object_size;
98
99	HANDLE /* BCRYPT_ALG_HANDLE */ sha256_handle;
100	DWORD sha256_object_size;
101	};
102
103	typedef struct {
104	git_hash_win32_provider_t type;
105
106	union {
107	struct cryptoapi_provider cryptoapi;
108	struct cng_provider cng;
109	} provider;
110	} hash_win32_provider;
111
112	/* Hash provider definition */
113
114	static hash_win32_provider hash_provider = {0};
115
116	/* Hash initialization */
117
118	/* Initialize CNG, if available */
119	GIT_INLINE(int) cng_provider_init(void)
120	{
121	char dll_path[MAX_PATH];
122	DWORD dll_path_len, size_len;
123
124	/* Only use CNG on Windows 2008 / Vista SP1 or better (Windows 6.0 SP1) */
125	if (!git_has_win32_version(6, 0, 1)) {
126	git_error_set(GIT_ERROR_SHA, "CryptoNG is not supported on this platform");
127	return -1;
128	}
129
130	/* Load bcrypt.dll explicitly from the system directory */
131	if ((dll_path_len = GetSystemDirectory(dll_path, MAX_PATH)) == 0 \|\|
132	dll_path_len > MAX_PATH \|\|
133	StringCchCat(dll_path, MAX_PATH, "\\") < 0 \|\|
134	StringCchCat(dll_path, MAX_PATH, GIT_HASH_CNG_DLL_NAME) < 0 \|\|
135	(hash_provider.provider.cng.dll = LoadLibrary(dll_path)) == NULL) {
136	git_error_set(GIT_ERROR_SHA, "CryptoNG library could not be loaded");
137	return -1;
138	}
139
140	/* Load the function addresses */
141	if ((hash_provider.provider.cng.open_algorithm_provider = (cng_open_algorithm_provider_fn)((void *)GetProcAddress(hash_provider.provider.cng.dll, "BCryptOpenAlgorithmProvider"))) == NULL \|\|
142	(hash_provider.provider.cng.get_property = (cng_get_property_fn)((void *)GetProcAddress(hash_provider.provider.cng.dll, "BCryptGetProperty"))) == NULL \|\|
143	(hash_provider.provider.cng.create_hash = (cng_create_hash_fn)((void *)GetProcAddress(hash_provider.provider.cng.dll, "BCryptCreateHash"))) == NULL \|\|
144	(hash_provider.provider.cng.finish_hash = (cng_finish_hash_fn)((void *)GetProcAddress(hash_provider.provider.cng.dll, "BCryptFinishHash"))) == NULL \|\|
145	(hash_provider.provider.cng.hash_data = (cng_hash_data_fn)((void *)GetProcAddress(hash_provider.provider.cng.dll, "BCryptHashData"))) == NULL \|\|
146	(hash_provider.provider.cng.destroy_hash = (cng_destroy_hash_fn)((void *)GetProcAddress(hash_provider.provider.cng.dll, "BCryptDestroyHash"))) == NULL \|\|
147	(hash_provider.provider.cng.close_algorithm_provider = (cng_close_algorithm_provider_fn)((void *)GetProcAddress(hash_provider.provider.cng.dll, "BCryptCloseAlgorithmProvider"))) == NULL) {
148	FreeLibrary(hash_provider.provider.cng.dll);
149
150	git_error_set(GIT_ERROR_OS, "CryptoNG functions could not be loaded");
151	return -1;
152	}
153
154	/* Load the SHA1 algorithm */
155	if (hash_provider.provider.cng.open_algorithm_provider(&hash_provider.provider.cng.sha1_handle, GIT_HASH_CNG_SHA1_TYPE, NULL, GIT_HASH_CNG_HASH_REUSABLE) < 0 \|\|
156	hash_provider.provider.cng.get_property(hash_provider.provider.cng.sha1_handle, GIT_HASH_CNG_HASH_OBJECT_LEN, (PBYTE)&hash_provider.provider.cng.sha1_object_size, sizeof(DWORD), &size_len, 0) < 0) {
157	git_error_set(GIT_ERROR_OS, "algorithm provider could not be initialized");
158	goto on_error;
159	}
160
161	/* Load the SHA256 algorithm */
162	if (hash_provider.provider.cng.open_algorithm_provider(&hash_provider.provider.cng.sha256_handle, GIT_HASH_CNG_SHA256_TYPE, NULL, GIT_HASH_CNG_HASH_REUSABLE) < 0 \|\|
163	hash_provider.provider.cng.get_property(hash_provider.provider.cng.sha256_handle, GIT_HASH_CNG_HASH_OBJECT_LEN, (PBYTE)&hash_provider.provider.cng.sha256_object_size, sizeof(DWORD), &size_len, 0) < 0) {
164	git_error_set(GIT_ERROR_OS, "algorithm provider could not be initialized");
165	goto on_error;
166	}
167
168	hash_provider.type = GIT_HASH_WIN32_CNG;
169	return 0;
170
171	on_error:
172	if (hash_provider.provider.cng.sha1_handle)
173	hash_provider.provider.cng.close_algorithm_provider(hash_provider.provider.cng.sha1_handle, 0);
174
175	if (hash_provider.provider.cng.sha256_handle)
176	hash_provider.provider.cng.close_algorithm_provider(hash_provider.provider.cng.sha256_handle, 0);
177
178	if (hash_provider.provider.cng.dll)
179	FreeLibrary(hash_provider.provider.cng.dll);
180
181	return -1;
182	}
183
184	GIT_INLINE(void) cng_provider_shutdown(void)
185	{
186	if (hash_provider.type == GIT_HASH_WIN32_INVALID)
187	return;
188
189	hash_provider.provider.cng.close_algorithm_provider(hash_provider.provider.cng.sha1_handle, 0);
190	hash_provider.provider.cng.close_algorithm_provider(hash_provider.provider.cng.sha256_handle, 0);
191	FreeLibrary(hash_provider.provider.cng.dll);
192
193	hash_provider.type = GIT_HASH_WIN32_INVALID;
194	}
195
196	/* Initialize CryptoAPI */
197	GIT_INLINE(int) cryptoapi_provider_init(void)
198	{
199	if (!CryptAcquireContext(&hash_provider.provider.cryptoapi.handle, NULL, 0, PROV_RSA_AES, CRYPT_VERIFYCONTEXT)) {
200	git_error_set(GIT_ERROR_OS, "legacy hash context could not be started");
201	return -1;
202	}
203
204	hash_provider.type = GIT_HASH_WIN32_CRYPTOAPI;
205	return 0;
206	}
207
208	GIT_INLINE(void) cryptoapi_provider_shutdown(void)
209	{
210	if (hash_provider.type == GIT_HASH_WIN32_INVALID)
211	return;
212
213	CryptReleaseContext(hash_provider.provider.cryptoapi.handle, 0);
214
215	hash_provider.type = GIT_HASH_WIN32_INVALID;
216	}
217
218	static void hash_provider_shutdown(void)
219	{
220	if (hash_provider.type == GIT_HASH_WIN32_CNG)
221	cng_provider_shutdown();
222	else if (hash_provider.type == GIT_HASH_WIN32_CRYPTOAPI)
223	cryptoapi_provider_shutdown();
224	}
225
226	static int hash_provider_init(void)
227	{
228	int error = 0;
229
230	if (hash_provider.type != GIT_HASH_WIN32_INVALID)
231	return 0;
232
233	if ((error = cng_provider_init()) < 0)
234	error = cryptoapi_provider_init();
235
236	if (!error)
237	error = git_runtime_shutdown_register(hash_provider_shutdown);
238
239	return error;
240	}
241
242	git_hash_win32_provider_t git_hash_win32_provider(void)
243	{
244	return hash_provider.type;
245	}
246
247	int git_hash_win32_set_provider(git_hash_win32_provider_t provider)
248	{
249	if (provider == hash_provider.type)
250	return 0;
251
252	hash_provider_shutdown();
253
254	if (provider == GIT_HASH_WIN32_CNG)
255	return cng_provider_init();
256	else if (provider == GIT_HASH_WIN32_CRYPTOAPI)
257	return cryptoapi_provider_init();
258
259	git_error_set(GIT_ERROR_SHA, "unsupported win32 provider");
260	return -1;
261	}
262
263	/* CryptoAPI: available in Windows XP and newer */
264
265	GIT_INLINE(int) hash_cryptoapi_init(git_hash_win32_ctx *ctx)
266	{
267	if (ctx->ctx.cryptoapi.valid)
268	CryptDestroyHash(ctx->ctx.cryptoapi.hash_handle);
269
270	if (!CryptCreateHash(hash_provider.provider.cryptoapi.handle, ctx->algorithm, 0, 0, &ctx->ctx.cryptoapi.hash_handle)) {
271	ctx->ctx.cryptoapi.valid = 0;
272	git_error_set(GIT_ERROR_OS, "legacy hash implementation could not be created");
273	return -1;
274	}
275
276	ctx->ctx.cryptoapi.valid = 1;
277	return 0;
278	}
279
280	GIT_INLINE(int) hash_cryptoapi_update(git_hash_win32_ctx ctx, const void _data, size_t len)
281	{
282	const BYTE data = (BYTE )_data;
283
284	GIT_ASSERT(ctx->ctx.cryptoapi.valid);
285
286	while (len > 0) {
287	DWORD chunk = (len > MAXDWORD) ? MAXDWORD : (DWORD)len;
288
289	if (!CryptHashData(ctx->ctx.cryptoapi.hash_handle, data, chunk, 0)) {
290	git_error_set(GIT_ERROR_OS, "legacy hash data could not be updated");
291	return -1;
292	}
293
294	data += chunk;
295	len -= chunk;
296	}
297
298	return 0;
299	}
300
301	GIT_INLINE(int) hash_cryptoapi_final(unsigned char out, git_hash_win32_ctx ctx)
302	{
303	DWORD len = ctx->algorithm == CALG_SHA_256 ? GIT_HASH_SHA256_SIZE : GIT_HASH_SHA1_SIZE;
304	int error = 0;
305
306	GIT_ASSERT(ctx->ctx.cryptoapi.valid);
307
308	if (!CryptGetHashParam(ctx->ctx.cryptoapi.hash_handle, HP_HASHVAL, out, &len, 0)) {
309	git_error_set(GIT_ERROR_OS, "legacy hash data could not be finished");
310	error = -1;
311	}
312
313	CryptDestroyHash(ctx->ctx.cryptoapi.hash_handle);
314	ctx->ctx.cryptoapi.valid = 0;
315
316	return error;
317	}
318
319	GIT_INLINE(void) hash_ctx_cryptoapi_cleanup(git_hash_win32_ctx *ctx)
320	{
321	if (ctx->ctx.cryptoapi.valid)
322	CryptDestroyHash(ctx->ctx.cryptoapi.hash_handle);
323	}
324
325	GIT_INLINE(int) hash_sha1_cryptoapi_ctx_init_init(git_hash_win32_ctx *ctx)
326	{
327	ctx->algorithm = CALG_SHA1;
328	return hash_cryptoapi_init(ctx);
329	}
330
331	GIT_INLINE(int) hash_sha256_cryptoapi_ctx_init(git_hash_win32_ctx *ctx)
332	{
333	ctx->algorithm = CALG_SHA_256;
334	return hash_cryptoapi_init(ctx);
335	}
336
337	/* CNG: Available in Windows Server 2008 and newer */
338
339	GIT_INLINE(int) hash_sha1_cng_ctx_init(git_hash_win32_ctx *ctx)
340	{
341	if ((ctx->ctx.cng.hash_object = git__malloc(hash_provider.provider.cng.sha1_object_size)) == NULL)
342	return -1;
343
344	if (hash_provider.provider.cng.create_hash(hash_provider.provider.cng.sha1_handle, &ctx->ctx.cng.hash_handle, ctx->ctx.cng.hash_object, hash_provider.provider.cng.sha1_object_size, NULL, 0, 0) < 0) {
345	git__free(ctx->ctx.cng.hash_object);
346
347	git_error_set(GIT_ERROR_OS, "sha1 implementation could not be created");
348	return -1;
349	}
350
351	ctx->algorithm = CALG_SHA1;
352	return 0;
353	}
354
355	GIT_INLINE(int) hash_sha256_cng_ctx_init(git_hash_win32_ctx *ctx)
356	{
357	if ((ctx->ctx.cng.hash_object = git__malloc(hash_provider.provider.cng.sha256_object_size)) == NULL)
358	return -1;
359
360	if (hash_provider.provider.cng.create_hash(hash_provider.provider.cng.sha256_handle, &ctx->ctx.cng.hash_handle, ctx->ctx.cng.hash_object, hash_provider.provider.cng.sha256_object_size, NULL, 0, 0) < 0) {
361	git__free(ctx->ctx.cng.hash_object);
362
363	git_error_set(GIT_ERROR_OS, "sha256 implementation could not be created");
364	return -1;
365	}
366
367	ctx->algorithm = CALG_SHA_256;
368	return 0;
369	}
370
371	GIT_INLINE(int) hash_cng_init(git_hash_win32_ctx *ctx)
372	{
373	BYTE hash[GIT_HASH_SHA256_SIZE];
374	ULONG size = ctx->algorithm == CALG_SHA_256 ? GIT_HASH_SHA256_SIZE : GIT_HASH_SHA1_SIZE;
375
376	if (!ctx->ctx.cng.updated)
377	return 0;
378
379	/* CNG needs to be finished to restart */
380	if (hash_provider.provider.cng.finish_hash(ctx->ctx.cng.hash_handle, hash, size, 0) < 0) {
381	git_error_set(GIT_ERROR_OS, "hash implementation could not be finished");
382	return -1;
383	}
384
385	ctx->ctx.cng.updated = 0;
386
387	return 0;
388	}
389
390	GIT_INLINE(int) hash_cng_update(git_hash_win32_ctx ctx, const void _data, size_t len)
391	{
392	PBYTE data = (PBYTE)_data;
393
394	while (len > 0) {
395	ULONG chunk = (len > ULONG_MAX) ? ULONG_MAX : (ULONG)len;
396
397	if (hash_provider.provider.cng.hash_data(ctx->ctx.cng.hash_handle, data, chunk, 0) < 0) {
398	git_error_set(GIT_ERROR_OS, "hash could not be updated");
399	return -1;
400	}
401
402	data += chunk;
403	len -= chunk;
404	}
405
406	return 0;
407	}
408
409	GIT_INLINE(int) hash_cng_final(unsigned char out, git_hash_win32_ctx ctx)
410	{
411	ULONG size = ctx->algorithm == CALG_SHA_256 ? GIT_HASH_SHA256_SIZE : GIT_HASH_SHA1_SIZE;
412
413	if (hash_provider.provider.cng.finish_hash(ctx->ctx.cng.hash_handle, out, size, 0) < 0) {
414	git_error_set(GIT_ERROR_OS, "hash could not be finished");
415	return -1;
416	}
417
418	ctx->ctx.cng.updated = 0;
419
420	return 0;
421	}
422
423	GIT_INLINE(void) hash_ctx_cng_cleanup(git_hash_win32_ctx *ctx)
424	{
425	hash_provider.provider.cng.destroy_hash(ctx->ctx.cng.hash_handle);
426	git__free(ctx->ctx.cng.hash_object);
427	}
428
429	/* Indirection between CryptoAPI and CNG */
430
431	GIT_INLINE(int) hash_sha1_win32_ctx_init(git_hash_win32_ctx *ctx)
432	{
433	GIT_ASSERT_ARG(hash_provider.type);
434
435	memset(ctx, 0x0, sizeof(git_hash_win32_ctx));
436	return (hash_provider.type == GIT_HASH_WIN32_CNG) ? hash_sha1_cng_ctx_init(ctx) : hash_sha1_cryptoapi_ctx_init_init(ctx);
437	}
438
439	GIT_INLINE(int) hash_sha256_win32_ctx_init(git_hash_win32_ctx *ctx)
440	{
441	GIT_ASSERT_ARG(hash_provider.type);
442
443	memset(ctx, 0x0, sizeof(git_hash_win32_ctx));
444	return (hash_provider.type == GIT_HASH_WIN32_CNG) ? hash_sha256_cng_ctx_init(ctx) : hash_sha256_cryptoapi_ctx_init(ctx);
445	}
446
447	GIT_INLINE(int) hash_win32_init(git_hash_win32_ctx *ctx)
448	{
449	return (hash_provider.type == GIT_HASH_WIN32_CNG) ? hash_cng_init(ctx) : hash_cryptoapi_init(ctx);
450	}
451
452	GIT_INLINE(int) hash_win32_update(git_hash_win32_ctx ctx, const void data, size_t len)
453	{
454	return (hash_provider.type == GIT_HASH_WIN32_CNG) ? hash_cng_update(ctx, data, len) : hash_cryptoapi_update(ctx, data, len);
455	}
456
457	GIT_INLINE(int) hash_win32_final(unsigned char out, git_hash_win32_ctx ctx)
458	{
459	GIT_ASSERT_ARG(ctx);
460	return (hash_provider.type == GIT_HASH_WIN32_CNG) ? hash_cng_final(out, ctx) : hash_cryptoapi_final(out, ctx);
461	}
462
463	GIT_INLINE(void) hash_win32_cleanup(git_hash_win32_ctx *ctx)
464	{
465	if (hash_provider.type == GIT_HASH_WIN32_CNG)
466	hash_ctx_cng_cleanup(ctx);
467	else if(hash_provider.type == GIT_HASH_WIN32_CRYPTOAPI)
468	hash_ctx_cryptoapi_cleanup(ctx);
469	}
470
471	#ifdef GIT_SHA1_WIN32
472
473	int git_hash_sha1_global_init(void)
474	{
475	return hash_provider_init();
476	}
477
478	int git_hash_sha1_ctx_init(git_hash_sha1_ctx *ctx)
479	{
480	GIT_ASSERT_ARG(ctx);
481	return hash_sha1_win32_ctx_init(&ctx->win32);
482	}
483
484	int git_hash_sha1_init(git_hash_sha1_ctx *ctx)
485	{
486	GIT_ASSERT_ARG(ctx);
487	return hash_win32_init(&ctx->win32);
488	}
489
490	int git_hash_sha1_update(git_hash_sha1_ctx ctx, const void data, size_t len)
491	{
492	GIT_ASSERT_ARG(ctx);
493	return hash_win32_update(&ctx->win32, data, len);
494	}
495
496	int git_hash_sha1_final(unsigned char out, git_hash_sha1_ctx ctx)
497	{
498	GIT_ASSERT_ARG(ctx);
499	return hash_win32_final(out, &ctx->win32);
500	}
501
502	void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx)
503	{
504	if (!ctx)
505	return;
506	hash_win32_cleanup(&ctx->win32);
507	}
508
509	#endif
510
511	#ifdef GIT_SHA256_WIN32
512
513	int git_hash_sha256_global_init(void)
514	{
515	return hash_provider_init();
516	}
517
518	int git_hash_sha256_ctx_init(git_hash_sha256_ctx *ctx)
519	{
520	GIT_ASSERT_ARG(ctx);
521	return hash_sha256_win32_ctx_init(&ctx->win32);
522	}
523
524	int git_hash_sha256_init(git_hash_sha256_ctx *ctx)
525	{
526	GIT_ASSERT_ARG(ctx);
527	return hash_win32_init(&ctx->win32);
528	}
529
530	int git_hash_sha256_update(git_hash_sha256_ctx ctx, const void data, size_t len)
531	{
532	GIT_ASSERT_ARG(ctx);
533	return hash_win32_update(&ctx->win32, data, len);
534	}
535
536	int git_hash_sha256_final(unsigned char out, git_hash_sha256_ctx ctx)
537	{
538	GIT_ASSERT_ARG(ctx);
539	return hash_win32_final(out, &ctx->win32);
540	}
541
542	void git_hash_sha256_ctx_cleanup(git_hash_sha256_ctx *ctx)
543	{
544	if (!ctx)
545	return;
546	hash_win32_cleanup(&ctx->win32);
547	}
548
549	#endif