/*

 * Copyright (C) 2016 Nikos Mavrogiannopoulos

 * Copyright (C) 2017 Red Hat, Inc.

 *

 * This file is part of GnuTLS.

 *

 * GnuTLS is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 3 of the License, or

 * (at your option) any later version.

 *

 * GnuTLS is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with this program.  If not, see <https://www.gnu.org/licenses/>

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <stdio.h>

#include <stdlib.h>

#include <gnutls/gnutls.h>

#include <gnutls/crypto.h>

#include <limits.h>

#include "utils.h"

#if defined(__FreeBSD__) || !defined(HAVE_MMAP)

void doit(void)

{

	exit(77);

}

#else /* working test */

/* Test hashing on very large buffers >= 2^31 */

#if !defined(_WIN32)

# include <signal.h>

# include <unistd.h>

static void exit_77(int signo)

{

	_exit(77);

}

#endif

#define MIN(x,y) ((x)<(y))?(x):(y)

#include <sys/mman.h>

static size_t _mmap_size;

static void *get_mem(size_t size)

{

	void *p;

	_mmap_size = size;

	p = mmap(NULL, size, PROT_READ, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);

	if (p == MAP_FAILED)

		return NULL;

	return p;

}

static void put_mem(void *mem)

{

	munmap(mem, _mmap_size);

}

void doit(void)

{

	unsigned char digest[32];

	int err;

	char *buf, *p;

	ssize_t size, left, size2;

	gnutls_hash_hd_t td;

	if (sizeof(size) <= 4)

		exit(77);

#if !defined(_WIN32)

	signal(SIGSEGV, exit_77);

	signal(SIGBUS, exit_77);

#endif

	global_init();

	size = (ssize_t)UINT_MAX + (ssize_t)64*1024;

	buf = get_mem(size);

	if (buf == NULL)

		exit(77);

	if (size < (ssize_t)UINT_MAX)

		exit(77);

	err =

	    gnutls_hash_fast(GNUTLS_DIG_SHA256, buf, size,

			     digest);

	if (err < 0)

		fail("gnutls_hash_fast(SHA256) failed: %d\n", err);

	else {

#define SHA256_HASH "\x80\x92\xd9\xbe\x54\xa0\xe9\xd7\x7c\xb8\xe4\x2d\xd3\x7c\x19\xfe\x4e\x68\x84\x33\x71\xef\x1c\x81\xd6\x44\x36\x52\x06\xd8\x4b\x8a"

		if (memcmp(digest, SHA256_HASH, 32) == 0) {

			if (debug)

				success("gnutls_hash_fast(SHA256) %lu OK\n", (unsigned long)size);

		} else {

			hexprint(digest, 32);

			fail("gnutls_hash_fast(SHA256) failure\n");

		}

	}

	err = gnutls_hash_init(&td, GNUTLS_DIG_SHA256);

	if (err < 0) {

		fail("failed in %d\n", __LINE__);

	}

	size2 = size;

	p = buf;

	while(size2 > 0) {

		left = MIN(64*1024, size2);

		gnutls_hash(td, p, left);

		size2 -= left;

		p += left;

	}

	gnutls_hash_output(td, digest);

	gnutls_hash_deinit(td, NULL);

	if (memcmp(digest, SHA256_HASH, 32) == 0) {

		if (debug)

			success("gnutls_hash_fast(SHA256) %lu OK\n", (unsigned long)size);

	} else {

		hexprint(digest, 32);

		fail("gnutls_hash(SHA256) failure\n");

	}

	/* SHA1 */

	err =

	    gnutls_hash_fast(GNUTLS_MAC_SHA1, buf, size,

			     digest);

	if (err < 0)

		fail("gnutls_hash_fast(SHA1) failed: %d\n", err);

	else {

#define SHA1_HASH "\x75\xd2\x67\x3f\xec\x73\xe4\x57\xb8\x40\xb3\xb5\xf1\xc7\xa8\x1a\x2d\x11\x7e\xd9"

		if (memcmp(digest, SHA1_HASH, 20) == 0) {

			if (debug)

				success("gnutls_hash_fast(SHA1) OK\n");

		} else {

			hexprint(digest, 20);

			fail("gnutls_hash_fast(SHA1) failure\n");

		}

	}

	err =

	    gnutls_hmac_fast(GNUTLS_MAC_SHA1, "keykeykey", 9, buf, size,

			     digest);

	if (err < 0)

		fail("gnutls_hmac_fast(SHA1) failed: %d\n", err);

	else {

#define SHA1_MAC "\xe2\xe9\x84\x48\x53\xe3\x0b\xfe\x45\x04\xf6\x6b\x5b\x6d\x4d\x2c\xa3\x0f\xcf\x23"

		if (memcmp(digest, SHA1_MAC, 20) == 0) {

			if (debug)

				success("gnutls_hmac_fast(SHA1) OK\n");

		} else {

			hexprint(digest, 20);

			fail("gnutls_hmac_fast(SHA1) failure\n");

		}

	}

	put_mem(buf);

	gnutls_global_deinit();

}

#endif