path: root/lib/gnutls_hash_int.c

/*
 * Copyright (C) 2000,2001 Nikos Mavroyanopoulos
 * Copyright (C) 2004 Free Software Foundation
 *
 * This file is part of GNUTLS.
 *
 *  The GNUTLS library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public   
 *  License as published by the Free Software Foundation; either 
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library 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
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
 *
 */

/* This file handles all the internal functions that cope with hashes
 * and HMACs. Currently it uses the functions provided by
 * the gcrypt library that this can be easily changed.
 */

#include <gnutls_int.h>
#include <gnutls_hash_int.h>
#include <gnutls_errors.h>

GNUTLS_HASH_HANDLE _gnutls_hash_init(gnutls_mac_algorithm algorithm)
{
	GNUTLS_MAC_HANDLE ret;
	gcry_error_t result;

	ret = gnutls_malloc(sizeof(GNUTLS_MAC_HANDLE_INT));
	if (ret == NULL) {
		gnutls_assert();
		return GNUTLS_HASH_FAILED;
	}

	ret->algorithm = algorithm;

	switch (algorithm) {
	case GNUTLS_MAC_SHA:
		result = gcry_md_open( &ret->handle, GCRY_MD_SHA1, 0);
		break;
	case GNUTLS_MAC_MD5:
		result = gcry_md_open( &ret->handle, GCRY_MD_MD5, 0);
		break;
	case GNUTLS_MAC_RMD160:
		result = gcry_md_open( &ret->handle, GCRY_MD_RMD160, 0);
		break;
	default:
		gnutls_assert();
		result = -1;
	}

	if (result) {
		gnutls_assert();
		gnutls_free(ret);
		ret = GNUTLS_HASH_FAILED;
	}

	return ret;
}

int _gnutls_hash_get_algo_len(gnutls_mac_algorithm algorithm)
{
	int ret;

	switch (algorithm) {
	case GNUTLS_MAC_SHA:
		ret = gcry_md_get_algo_dlen(GCRY_MD_SHA1);
		break;
	case GNUTLS_MAC_MD5:
		ret = gcry_md_get_algo_dlen(GCRY_MD_MD5);
		break;
	case GNUTLS_MAC_RMD160:
		ret = gcry_md_get_algo_dlen(GCRY_MD_RMD160);
		break;
	default:
		ret = 0; break;
	}

	return ret;

}

int _gnutls_hash(GNUTLS_HASH_HANDLE handle, const void *text, size_t textlen)
{
	if (textlen > 0)
		gcry_md_write(handle->handle, text, textlen);
	return 0;
}

GNUTLS_HASH_HANDLE _gnutls_hash_copy(GNUTLS_HASH_HANDLE handle)
{
	GNUTLS_HASH_HANDLE ret;
	gcry_error_t result;

	ret = gnutls_malloc(sizeof(GNUTLS_MAC_HANDLE_INT));

	if (ret == NULL)
		return GNUTLS_HASH_FAILED;

	ret->algorithm = handle->algorithm;
	ret->key = NULL;	/* it's a hash anyway */
	ret->keysize = 0;

	result = gcry_md_copy( &ret->handle, handle->handle);

	if (result) {
		gnutls_free(ret);
		return GNUTLS_HASH_FAILED;
	}

	return ret;
}

void _gnutls_hash_deinit(GNUTLS_HASH_HANDLE handle, void *digest)
{
	opaque *mac;
	int maclen;

	maclen = _gnutls_hash_get_algo_len( handle->algorithm);

	gcry_md_final(handle->handle);
	mac = gcry_md_read(handle->handle, 0);
	if (digest != NULL)
		memcpy(digest, mac, maclen);

	gcry_md_close(handle->handle);

	gnutls_free(handle);
}


GNUTLS_MAC_HANDLE _gnutls_hmac_init(gnutls_mac_algorithm algorithm,
				    const void *key, int keylen)
{
	GNUTLS_MAC_HANDLE ret;
	gcry_error_t result;

	ret = gnutls_malloc(sizeof(GNUTLS_MAC_HANDLE_INT));
	if (ret == NULL)
		return GNUTLS_MAC_FAILED;

	switch (algorithm) {
	case GNUTLS_MAC_SHA:
		result = gcry_md_open(&ret->handle, GCRY_MD_SHA1, GCRY_MD_FLAG_HMAC);
		break;
	case GNUTLS_MAC_MD5:
		result = gcry_md_open(&ret->handle, GCRY_MD_MD5, GCRY_MD_FLAG_HMAC);
		break;
	case GNUTLS_MAC_RMD160:
		result = gcry_md_open(&ret->handle, GCRY_MD_RMD160, GCRY_MD_FLAG_HMAC);
		break;
	default:
		gnutls_assert();
		result = -1;
	}

	if (result) {
		gnutls_assert();
		gnutls_free(ret);
		ret = GNUTLS_MAC_FAILED;
	}

	if (ret != GNUTLS_MAC_FAILED) {
		gcry_md_setkey(ret->handle, key, keylen);

		ret->algorithm = algorithm;
		ret->key = key;
		ret->keysize = keylen;
	}

	return ret;
}

void _gnutls_hmac_deinit(GNUTLS_MAC_HANDLE handle, void *digest)
{
	opaque *mac;
	int maclen;

	maclen = _gnutls_hash_get_algo_len( handle->algorithm);

	gcry_md_final(handle->handle);
	mac = gcry_md_read(handle->handle, 0);

	if (digest != NULL)
		memcpy(digest, mac, maclen);

	gcry_md_close(handle->handle);

	gnutls_free(handle);
}

inline static int get_padsize( gnutls_mac_algorithm algorithm)
{
	switch (algorithm) {
	case GNUTLS_MAC_MD5:
		return 48;
	case GNUTLS_MAC_SHA:
		return 40;
	default:
		return 0;
	}
}

GNUTLS_MAC_HANDLE _gnutls_mac_init_ssl3(gnutls_mac_algorithm algorithm, void *key,
					int keylen)
{
	GNUTLS_MAC_HANDLE ret;
	opaque ipad[48];
	int padsize;

	padsize = get_padsize( algorithm);
	if (padsize == 0) {
		gnutls_assert();
		return GNUTLS_MAC_FAILED;
	}

	memset(ipad, 0x36, padsize);

	ret = _gnutls_hash_init(algorithm);
	if (ret != GNUTLS_HASH_FAILED) {
		ret->key = key;
		ret->keysize = keylen;

		if (keylen > 0)
			_gnutls_hash(ret, key, keylen);
		_gnutls_hash(ret, ipad, padsize);
	}

	return ret;
}

void _gnutls_mac_deinit_ssl3(GNUTLS_MAC_HANDLE handle, void *digest)
{
	opaque ret[MAX_HASH_SIZE];
	GNUTLS_MAC_HANDLE td;
	opaque opad[48];
	int padsize;
	int block;

	padsize = get_padsize( handle->algorithm);
	if (padsize == 0) {
		gnutls_assert();
		return;
	}

	memset(opad, 0x5C, padsize);

	td = _gnutls_hash_init(handle->algorithm);
	if (td != GNUTLS_MAC_FAILED) {
		if (handle->keysize > 0)
			_gnutls_hash(td, handle->key, handle->keysize);

		_gnutls_hash(td, opad, padsize);
		block = _gnutls_hmac_get_algo_len(handle->algorithm);
		_gnutls_hash_deinit(handle, ret);	/* get the previous hash */
		_gnutls_hash(td, ret, block);

		_gnutls_hash_deinit(td, digest);
	}
}

void _gnutls_mac_deinit_ssl3_handshake(GNUTLS_MAC_HANDLE handle,
				       void *digest, opaque * key,
				       uint32 key_size)
{
	opaque ret[MAX_HASH_SIZE];
	GNUTLS_MAC_HANDLE td;
	opaque opad[48];
	opaque ipad[48];
	int padsize;
	int block;

	padsize = get_padsize( handle->algorithm);
	if (padsize == 0) {
		gnutls_assert();
		return;
	}

	memset(opad, 0x5C, padsize);
	memset(ipad, 0x36, padsize);

	td = _gnutls_hash_init(handle->algorithm);
	if (td != GNUTLS_HASH_FAILED) {
		if (key_size > 0)
			_gnutls_hash(td, key, key_size);

		_gnutls_hash(td, opad, padsize);
		block = _gnutls_hmac_get_algo_len(handle->algorithm);

		if (key_size > 0)
			_gnutls_hash(handle, key, key_size);
		_gnutls_hash(handle, ipad, padsize);
		_gnutls_hash_deinit(handle, ret);	/* get the previous hash */

		_gnutls_hash(td, ret, block);

		_gnutls_hash_deinit(td, digest);
	}
}

static int ssl3_sha(int i, opaque *secret, int secret_len, opaque *random,
		    int random_len, void *digest)
{
	int j;
	opaque text1[26];

	GNUTLS_HASH_HANDLE td;

	for (j = 0; j < i + 1; j++) {
		text1[j] = 65 + i;	/* A==65 */
	}

	td = _gnutls_hash_init(GNUTLS_MAC_SHA);
	if (td == NULL) {
		gnutls_assert();
		return GNUTLS_E_HASH_FAILED;
	}

	_gnutls_hash(td, text1, i + 1);
	_gnutls_hash(td, secret, secret_len);
	_gnutls_hash(td, random, random_len);

	_gnutls_hash_deinit(td, digest);
	return 0;
}

static int ssl3_md5(int i, opaque *secret, int secret_len, opaque *random,
		    int random_len, void *digest)
{
	opaque tmp[MAX_HASH_SIZE];
	GNUTLS_MAC_HANDLE td;
	int ret;

	td = _gnutls_hash_init(GNUTLS_MAC_MD5);
	if (td == NULL) {
		gnutls_assert();
		return GNUTLS_E_HASH_FAILED;
	}

	_gnutls_hash(td, secret, secret_len);

	ret = ssl3_sha(i, secret, secret_len, random, random_len, tmp);
	if (ret < 0) {
		gnutls_assert();
		_gnutls_hash_deinit(td, digest);
		return ret;
	}

	_gnutls_hash(td, tmp, _gnutls_hash_get_algo_len(GNUTLS_MAC_SHA));

	_gnutls_hash_deinit(td, digest);
	return 0;
}

int _gnutls_ssl3_hash_md5(void *first, int first_len,
			  void *second, int second_len, int ret_len,
			  opaque * ret)
{
	opaque digest[MAX_HASH_SIZE];
	GNUTLS_MAC_HANDLE td;
	int block = _gnutls_hash_get_algo_len(GNUTLS_MAC_MD5);

	td = _gnutls_hash_init(GNUTLS_MAC_MD5);
	if (td == NULL) {
		gnutls_assert();
		return GNUTLS_E_HASH_FAILED;
	}

	_gnutls_hash(td, first, first_len);
	_gnutls_hash(td, second, second_len);

	_gnutls_hash_deinit(td, digest);

	if (ret_len > block) {
		gnutls_assert();
		return GNUTLS_E_INTERNAL_ERROR;
	}

	memcpy(ret, digest, ret_len);

	return 0;

}

int _gnutls_ssl3_generate_random(void *secret, int secret_len,
				 void *random, int random_len,
				 int ret_bytes, opaque * ret)
{
	int i = 0, copy, output_bytes;
	opaque digest[MAX_HASH_SIZE];
	int block = _gnutls_hash_get_algo_len(GNUTLS_MAC_MD5);
	int result, times;

	output_bytes = 0;
	do {
		output_bytes += block;
	} while (output_bytes < ret_bytes);

	times = output_bytes / block;

	for (i = 0; i < times; i++) {

		result =
		    ssl3_md5(i, secret, secret_len, random, random_len,
			     digest);
		if (result < 0) {
			gnutls_assert();
			return result;
		}

		if ((1 + i) * block < ret_bytes) {
			copy = block;
		} else {
			copy = ret_bytes - (i) * block;
		}

		memcpy(&ret[i * block], digest, copy);
	}

	return 0;
}