libewf_hash_values.c

sleuthit-2.09 一个磁盘的工具集

	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_set_value: unable to set value.\n" );

		libewf_common_free( hash_values->values[ index ] );

		hash_values->values[ index ] = NULL;

		return( -1 );
	}
	return( 1 );
}

/* Parse a xml hash string for the values
 * Returns a pointer to the new instance, NULL on error
 */
LIBEWF_HASH_VALUES *libewf_hash_values_parse_hash_string_xml( LIBEWF_CHAR *hash_string_xml, size_t length )
{
	LIBEWF_HASH_VALUES *hash_values = NULL;
	LIBEWF_CHAR **lines             = NULL;
	LIBEWF_CHAR *open_tag_start     = NULL;
	LIBEWF_CHAR *open_tag_end       = NULL;
	LIBEWF_CHAR *close_tag_start    = NULL;
	LIBEWF_CHAR *close_tag_end      = NULL;
	size_t string_length            = 0;
	uint32_t line_count             = 0;
	uint32_t iterator               = 0;

	if( hash_string_xml == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_parse_hash_string_xml: invalid hash string\n" );

		return( NULL );
	}
	lines = libewf_string_split( (LIBEWF_CHAR *) hash_string_xml, length, (LIBEWF_CHAR) '\n', &line_count );

	if( lines == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_parse_hash_string_xml: unable to split lines in hash string.\n" );

		return( NULL );
	}
	hash_values = libewf_hash_values_alloc();

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

		libewf_string_split_values_free( lines, line_count );

		return( NULL );
	}
	for( iterator = 0; iterator < line_count; iterator++ )
	{
		if( ( lines[ iterator ] == NULL )
		 || ( lines[ iterator ] == (LIBEWF_CHAR *) _S_LIBEWF_CHAR( "" ) ) )
		{
			continue;
		}
		string_length = libewf_string_length( lines[ iterator ] );

		/* Ignore empty lines
		 */
		if( string_length == 0 )
		{
			continue;
		}
		open_tag_start = libewf_string_search( lines[ iterator ], (LIBEWF_CHAR) '<', string_length );

		/* Ignore lines without an open tag
		 */
		if( open_tag_start == NULL )
		{
			continue;
		}
		open_tag_end = libewf_string_search( lines[ iterator ], (LIBEWF_CHAR) '>', string_length );

		/* Ignore lines without an open tag
		 */
		if( open_tag_end == NULL )
		{
			continue;
		}
		/* Ignore the first part of the xml string
		 */
		string_length -= (size_t) ( open_tag_end - lines[ iterator ] );

		/* Ignore lines only containing a single tag
		 */
		if( string_length <= 1 )
		{
			continue;
		}
		close_tag_start = libewf_string_search_reverse( &open_tag_end[ 1 ], (LIBEWF_CHAR) '<', string_length );

		/* Ignore lines without a close tag
		 */
		if( close_tag_start == NULL )
		{
			continue;
		}
		close_tag_end = libewf_string_search_reverse( &open_tag_end[ 1 ], (LIBEWF_CHAR) '>', string_length );

		/* Ignore lines without a close tag
		 */
		if( close_tag_end == NULL )
		{
			continue;
		}
		/* Ignore the second part of the xml string
		 */
		string_length = (size_t) ( close_tag_start - open_tag_end ) - 1;

		/* Make sure the identifier string will be terminated
		 */
		*open_tag_end = (LIBEWF_CHAR) '\0';

		if( libewf_hash_values_set_value( hash_values, &open_tag_start[ 1 ] , &open_tag_end[ 1 ], string_length ) != 1 )
		{
			LIBEWF_VERBOSE_PRINT( "libewf_hash_values_parse_hash_string_xml: unable to set value with identifier: %" PRIs_EWF ".\n", &open_tag_start[ 1 ] );
		}
	}
	libewf_string_split_values_free( lines, line_count );

	return( hash_values );
}

/* Parse an EWF xhash for the values
 * Returns a pointer to the new instance, NULL on error
 */
LIBEWF_HASH_VALUES *libewf_hash_values_parse_xhash( EWF_CHAR *xhash, size_t size )
{
	LIBEWF_HASH_VALUES* hash_values = NULL;
	LIBEWF_CHAR *xml_hash_string    = NULL;

	if( xhash == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_parse_xhash: invalid xhash.\n" );

		return( NULL );
	}
	xml_hash_string = (LIBEWF_CHAR *) libewf_common_alloc( LIBEWF_CHAR_SIZE * ( size + 1 ) );

	if( xml_hash_string == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_parse_xhash: unable to create XML hash string.\n" );

		return( NULL );
	}
	if( libewf_string_copy_from_ewf_char( xml_hash_string, size, xhash, size ) != 1 )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_parse_xhash: unable to copy xhash to xml hash string.\n" );

		libewf_common_free( xml_hash_string );

		return( NULL );
	}
	hash_values = libewf_hash_values_parse_hash_string_xml( xml_hash_string, size );

	libewf_common_free( xml_hash_string );

	return( hash_values );
}

/* Converts a hash string into a hash
 * Cleans the hash string
 * Sets hash length
 * Returns a pointer to the new instance, NULL on error
 */
EWF_CHAR *libewf_hash_values_convert_hash_string_to_hash( LIBEWF_CHAR *hash_string, size_t string_length, size_t *hash_length )
{
	EWF_CHAR *hash = NULL;

	if( hash_string == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_convert_hash_string_to_hash: invalid hash string.\n" );

		return( NULL );
	}
	if( hash_length == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_convert_hash_string_to_hash: invalid hash length.\n" );

		return( NULL );
	}
	hash = (EWF_CHAR *) libewf_common_alloc( EWF_CHAR_SIZE * string_length );

	if( hash == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_convert_hash_string_to_hash: unable to create hash.\n" );

		libewf_common_free( hash_string );

		return( NULL );
	}
	*hash_length = string_length;

	if( libewf_string_copy_to_ewf_char( hash_string, string_length, hash, *hash_length ) != 1 )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_convert_hash_string_to_hash: unable to set hash.\n" );

		libewf_common_free( hash );
		libewf_common_free( hash_string );

		*hash_length = 0;

		return( NULL );
	}
	libewf_common_free( hash_string );

	return( hash );
}

/* Generate a hash format in XML
 * Sets string length
 * Returns a pointer to the new instance, NULL on error
 */
LIBEWF_CHAR *libewf_hash_values_generate_hash_string_xml( LIBEWF_HASH_VALUES *hash_values, size_t *string_length )
{
	LIBEWF_CHAR *hash_string         = NULL;
	LIBEWF_CHAR *xml_head            = _S_LIBEWF_CHAR( "<?xml version=\"1.0\"?>" );
	LIBEWF_CHAR *xml_open_tag_xhash  = _S_LIBEWF_CHAR( "<xhash>" );
	LIBEWF_CHAR *xml_close_tag_xhash = _S_LIBEWF_CHAR( "</xhash>" );
	uint32_t iterator                = 0;
	int string_offset                = 0;
	int character_count              = 0;

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

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

		return( NULL );
	}
	if( string_length == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_generate_hash_string_xml: invalid string length.\n" );

		return( NULL );
	}
	/* Add space for the xml data and an end of line
	 */
	*string_length  = libewf_string_length( xml_head ) + 1;
	*string_length += libewf_string_length( xml_open_tag_xhash ) + 1;
	*string_length += libewf_string_length( xml_close_tag_xhash ) + 1;

	for( iterator = 0; iterator < hash_values->amount; iterator++ )
	{
		if( hash_values->identifiers[ iterator ] == NULL )
		{
			LIBEWF_WARNING_PRINT( "libewf_hash_values_generate_hash_string_xml: invalid hash value - missing identifier.\n" );

			continue;
		}
		if( hash_values->values[ iterator ] != NULL )
		{
			/* Add space for a leading tab, <identifier></identifier> and an end of line
			 */
			*string_length += ( 2 * libewf_string_length( hash_values->identifiers[ iterator ] ) ) + 7;

			/* Add space for the hash value
			 */
			*string_length += libewf_string_length( hash_values->values[ iterator ] );
		}
	}
	/* allow for an empty line and an end of string
	 */
	*string_length += 2;

	hash_string = (LIBEWF_CHAR *) libewf_common_alloc( LIBEWF_CHAR_SIZE * *string_length );

	if( hash_string == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_generate_hash_string_xml: unable to create hash string.\n" );

		*string_length = 0;

		return( NULL );
	}
	character_count = libewf_string_snprintf( hash_string, *string_length,
		_S_LIBEWF_CHAR( "%" ) _S_LIBEWF_CHAR( PRIs_EWF ) _S_LIBEWF_CHAR( "\n%" ) _S_LIBEWF_CHAR( PRIs_EWF ) _S_LIBEWF_CHAR( "\n" ),
		xml_head, xml_open_tag_xhash );

	if( character_count <= -1 )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_generate_hash_string_xml: unable to set hash string.\n" );

		libewf_common_free( hash_string );

		*string_length = 0;

		return( NULL );
	}
	string_offset = character_count;

	for( iterator = 0; iterator < hash_values->amount; iterator++ )
	{
		if( hash_values->identifiers[ iterator ] == NULL )
		{
			LIBEWF_WARNING_PRINT( "libewf_hash_values_generate_hash_string_xml: invalid hash value - missing identifier.\n" );

			continue;
		}
		if( hash_values->values[ iterator ] != NULL )
		{
			character_count = libewf_string_snprintf( &hash_string[ string_offset ], ( *string_length - string_offset ),
			                                          _S_LIBEWF_CHAR( "\t<%" ) _S_LIBEWF_CHAR( PRIs_EWF ) _S_LIBEWF_CHAR( ">%" )
								  _S_LIBEWF_CHAR( PRIs_EWF ) _S_LIBEWF_CHAR( "</%" ) _S_LIBEWF_CHAR( PRIs_EWF )
								  _S_LIBEWF_CHAR( ">\n" ), hash_values->identifiers[ iterator ],
			                                          hash_values->values[ iterator ], hash_values->identifiers[ iterator ] );

			if( character_count <= -1 )
			{
				LIBEWF_WARNING_PRINT( "libewf_hash_values_generate_hash_string_xml: unable to set hash string.\n" );

				libewf_common_free( hash_string );

				*string_length = 0;

				return( NULL );
			}
			string_offset += character_count;
		}
	}
	character_count = libewf_string_snprintf( &hash_string[ string_offset ], ( *string_length - string_offset ),
	                                          _S_LIBEWF_CHAR( "%" ) _S_LIBEWF_CHAR( PRIs_EWF ) _S_LIBEWF_CHAR( "\n\n" ),
						  xml_close_tag_xhash );

	if( character_count <= -1 )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_generate_hash_string_xml: unable to set hash string.\n" );

		libewf_common_free( hash_string );

		*string_length = 0;

		return( NULL );
	}
	/* Make sure the string is terminated
	 */
	hash_string[ *string_length - 1 ] = (LIBEWF_CHAR) '\0';

	return( hash_string );
}

/* Generate an EWFX xhash
 * Returns a pointer to the new instance, NULL on error
 */
EWF_CHAR *libewf_hash_values_generate_xhash_string_ewfx( LIBEWF_HASH_VALUES *hash_values, size_t *hash_length )
{
	EWF_CHAR *xhash          = NULL;
	LIBEWF_CHAR *hash_string = NULL;

	hash_string = libewf_hash_values_generate_hash_string_xml( hash_values, hash_length );
	xhash       = libewf_hash_values_convert_hash_string_to_hash( hash_string, *hash_length, hash_length );

	if( xhash == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_hash_values_generate_xhash_string_ewfx: unable to create xhash.\n" );

		return( NULL );
	}
	return( xhash );
}