libewf_hash_values.c

sleuthit-2.09 一个磁盘的工具集

/*
 * libewf hash values
 *
 * Copyright (c) 2006-2007, Joachim Metz <[e-mail]>,
 * Hoffmann Investigations. All rights reserved.
 *
 * Refer to AUTHORS for acknowledgements.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 * - Neither the name of the creator, related organisations, nor the names of
 *   its contributors may be used to endorse or promote products derived from
 *   this software without specific prior written permission.
 * - All advertising materials mentioning features or use of this software
 *   must acknowledge the contribution by people stated in the acknowledgements.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER, COMPANY AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "libewf_includes.h"

#include <libewf/libewf_definitions.h>

#include "libewf_common.h"
#include "libewf_hash_values.h"
#include "libewf_notify.h"
#include "libewf_string.h"

#include "ewf_compress.h"
#include "ewf_definitions.h"

/* Allocates memory for a new hash values struct
 * Returns a pointer to the new instance, NULL on error
 */
LIBEWF_HASH_VALUES *libewf_hash_values_alloc( void )
{
	LIBEWF_HASH_VALUES *hash_values = NULL;
	size_t hash_values_size         = 0;

	hash_values = (LIBEWF_HASH_VALUES *) libewf_common_alloc_cleared( LIBEWF_HASH_VALUES_SIZE, 0 );

	if( hash_values == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_alloc: unable to allocate hash values.\n" );

		return( NULL );
	}
	hash_values->amount = LIBEWF_HASH_VALUES_DEFAULT_AMOUNT;
	hash_values_size    = hash_values->amount * sizeof( LIBEWF_CHAR* );

	if( hash_values_size > (size_t) SSIZE_MAX )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_alloc: invalid size value exceeds maximum.\n" );

		libewf_common_free( hash_values );

		return( NULL );
	}
	hash_values->identifiers = (LIBEWF_CHAR **) libewf_common_alloc_cleared( hash_values_size, 0 );

	if( hash_values->identifiers == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_alloc: unable to allocate identifiers.\n" );

		libewf_common_free( hash_values );

		return( NULL );
	}
	hash_values->values = (LIBEWF_CHAR **) libewf_common_alloc_cleared( hash_values_size, 0 );

	if( hash_values->values == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_alloc: unable to allocate values.\n" );

		libewf_common_free( hash_values->identifiers );
		libewf_common_free( hash_values );

		return( NULL );
	}
	hash_values->identifiers[ 0 ] = libewf_string_duplicate( _S_LIBEWF_CHAR( "MD5" ), 3 );

	return( hash_values );
}

/* Reallocates memory for the hash values
 * Returns a pointer to the instance, NULL on error
 */
LIBEWF_HASH_VALUES *libewf_hash_values_realloc( LIBEWF_HASH_VALUES *hash_values, uint32_t previous_amount, uint32_t new_amount )
{
	LIBEWF_CHAR **reallocation = NULL;
	size_t previous_size       = previous_amount * sizeof( LIBEWF_CHAR* );
	size_t new_size            = new_amount * sizeof( LIBEWF_CHAR* );

	if( hash_values == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_realloc: invalid hash values.\n" );

		return( NULL );
	}
	if( ( previous_amount > (uint32_t) INT32_MAX ) || ( new_amount > (uint32_t) INT32_MAX ) )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_realloc: invalid amount only values below 2^32 are supported.\n" );

		return( NULL );
	}
	if( previous_amount >= new_amount )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_realloc: new amount smaller than previous amount.\n" );

		return( NULL );
	}
	if( ( previous_size > (size_t) SSIZE_MAX ) || ( new_size > (ssize_t) SSIZE_MAX ) )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_realloc: invalid size value exceeds maximum.\n" );

		return( NULL );
	}
	reallocation = (LIBEWF_CHAR **) libewf_common_realloc_new_cleared( hash_values->identifiers, previous_size, new_size, 0 );

	if( reallocation == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_realloc: unable to reallocate identifiers.\n" );

		return( NULL );
	}
	hash_values->identifiers = reallocation;
	reallocation             = (LIBEWF_CHAR **) libewf_common_realloc_new_cleared( hash_values->values, previous_size, new_size, 0 );

	if( reallocation == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_realloc: unable to reallocate values.\n" );

		return( NULL );
	}
	hash_values->values = reallocation;
	hash_values->amount = new_amount;

	return( hash_values );
}

/* Frees memory of a hash values struct including elements
 */
void libewf_hash_values_free( LIBEWF_HASH_VALUES *hash_values )
{
	uint32_t iterator = 0;

	if( hash_values == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_free: invalid hash values.\n" );

		return;
	}
	if( hash_values->values != NULL )
	{
		for( iterator = 0; iterator < hash_values->amount; iterator++ )
		{
			libewf_common_free( hash_values->identifiers[ iterator ] );
			libewf_common_free( hash_values->values[ iterator ] );
		}
		libewf_common_free( hash_values->values );
	}
	libewf_common_free( hash_values );
}

/* Retrieves the hash value index number, or -1 on error
 * The index number will be larger than the amount when the identifier is not present in the hash values
 */
int32_t libewf_hash_values_get_index( LIBEWF_HASH_VALUES *hash_values, LIBEWF_CHAR *identifier )
{
	size_t string_length     = 0;
	size_t identifier_length = 0;
	int32_t iterator         = 0;

	if( hash_values == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_get_index: invalid hash values.\n" );

		return( -1 );
	}
	if( identifier == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_get_index: invalid identifier.\n" );

		return( -1 );
	}
	identifier_length = libewf_string_length( identifier );

	if( identifier_length == 0 )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_get_index: invalid identifier.\n" );

		return( -1 );
	}
	if( hash_values->amount > (uint32_t) INT32_MAX )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_get_index: invalid hash values amount only values below 2^32 are supported.\n" );

		return( -1 );
	}
	for( iterator = 0; iterator < (int32_t) hash_values->amount; iterator++ )
	{
		if( hash_values->identifiers[ iterator ] == NULL )
		{
			LIBEWF_WARNING_PRINT( "libewf_hash_values_get_index: missing identifier for index: %" PRIi32 ".\n", iterator );

			continue;
		}
		string_length = libewf_string_length( hash_values->identifiers[ iterator ] );

		if( string_length == 0 )
		{
			LIBEWF_WARNING_PRINT( "libewf_hash_values_get_index: unable to determine length of identifier of index: %" PRIi32 ".\n", iterator );

			continue;
		}
		if( string_length != identifier_length )
		{
			continue;
		}
		if( libewf_string_compare( identifier, hash_values->identifiers[ iterator ], identifier_length ) == 0 )
		{
			return( iterator );
		}
	}
	return( iterator );
}

/* Retrieves a hash value in value
 * Length should contain the amount of characters in the string
 * Returns 1 if successful, 0 if value not present, -1 on error
 */
int8_t libewf_hash_values_get_value( LIBEWF_HASH_VALUES *hash_values, LIBEWF_CHAR *identifier, LIBEWF_CHAR *value, size_t length )
{
	size_t hash_value_length = 0;
	int32_t index            = 0;

	if( value == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_get_value: invalid value.\n" );

		return( -1 );
	}
	index = libewf_hash_values_get_index( hash_values, identifier );

	if( index <= -1 )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_get_value: unable to find index for: %" PRIs_EWF ".\n", identifier );

		return( -1 );
	}
	if( (uint32_t) index > hash_values->amount )
	{
		return( 0 );
	}
	if( hash_values->values[ index ] == NULL )
	{
		return( 0 );
	}
	hash_value_length = libewf_string_length( hash_values->values[ index ] );

	/* Don't bother with empty values
	 */
	if( hash_value_length == 0 )
	{
		return( 0 );
	}
	/* Add 1 additional byte required for the end of string character
	 */
	hash_value_length += 1;

	if( hash_value_length > length )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_get_value: value too small.\n" );

		return( -1 );
	}
	if( libewf_string_copy( value, hash_values->values[ index ], hash_value_length ) == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_get_value: unable to set hash value.\n" );

		return( -1 );
	}
	value[ hash_value_length - 1 ] = (LIBEWF_CHAR) '\0';

	return( 1 );
}

/* Set a hash value
 * Length should contain the amount of characters in the string
 * Frees the previous hash value if necessary
 * Returns 1 if successful, -1 on error
 */
int8_t libewf_hash_values_set_value( LIBEWF_HASH_VALUES *hash_values, LIBEWF_CHAR *identifier, LIBEWF_CHAR *value, size_t length )
{
	size_t string_length = 0;
	int32_t index        = 0;

	index = libewf_hash_values_get_index( hash_values, identifier );

	if( index <= -1 )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_set_value: unable to find index for: %" PRIs_EWF ".\n", identifier );

		return( -1 );
	}
	if( (uint32_t) index >= hash_values->amount )
	{
		string_length = libewf_string_length( identifier );

		if( string_length == 0 )
		{
			LIBEWF_WARNING_PRINT( "libewf_hash_values_set_value: unable to determine length of identifier.\n" );

			return( -1 );
		}
		if( libewf_hash_values_realloc( hash_values, hash_values->amount, ( index + 1 ) ) == NULL )
		{
			LIBEWF_WARNING_PRINT( "libewf_hash_values_set_value: unable to reallocate hash values.\n" );

			return( -1 );
		}
		hash_values->identifiers[ index ] = libewf_string_duplicate( identifier, string_length );

		if( hash_values->identifiers[ index ] == NULL )
		{
			LIBEWF_WARNING_PRINT( "libewf_hash_values_set_value: unable to set identifier.\n" );

			libewf_common_free( hash_values->identifiers[ index ] );

			hash_values->identifiers[ index ] = NULL;

			return( -1 );
		}
	}
	/* Clear the buffer of the previous hash value
	 */
	if( hash_values->values[ index ] != NULL )
	{
		libewf_common_free( hash_values->values[ index ] );

		hash_values->values[ index ] = NULL;
	}
	/* Don't bother with empty values
	 */
	if( value == NULL )
	{
		return( 1 );
	}
	if( length == 0 )
	{
		return( 1 );
	}
	hash_values->values[ index ] = libewf_string_duplicate( value, length );

	if( hash_values->values[ index ] == NULL )