#include "project.h"

const SIZE_T cbPackedHeader = 0xAC;
const SIZE_T cbUnpackedHeader = 0x80;

typedef struct _FILE_MAPPING {
	HANDLE	hFile;
	HANDLE	hMap;
	PVOID	base;
	SIZE_T	size;
} FILE_MAPPING, *PFILE_MAPPING;

VOID
UnmapFile(
		  OUT PFILE_MAPPING		mapping
		  )
{
	if( mapping->base ) {
		UnmapViewOfFile( mapping->base );
	}
	if( mapping->hMap ) {
		CloseHandle( mapping->hMap );
	}
	if( mapping->hFile && mapping->hFile != INVALID_HANDLE_VALUE ) {
		CloseHandle( mapping->hFile );
	}
	memset(mapping, 0, sizeof(*mapping));
}


PVOID
MapFile(
		OUT PFILE_MAPPING		mapping,
		IN PTCHAR				fileName,
		BOOLEAN					fWrite,
		SIZE_T					size
		)
{
	memset(mapping, 0, sizeof(*mapping));
	mapping->hFile = CreateFile(
		fileName, GENERIC_READ | ( fWrite ? GENERIC_WRITE : 0 ), 
		FILE_SHARE_READ, NULL, fWrite ? CREATE_ALWAYS : OPEN_EXISTING, 0, NULL);
	if( mapping->hFile == INVALID_HANDLE_VALUE )
		goto bad;
	if( fWrite ) {
		if ( !SetFilePointer( mapping->hFile, (LONG)size, NULL, FILE_BEGIN ) ||
			!SetEndOfFile( mapping->hFile ) )
		{
			goto bad;
		}
	} else {
		mapping->size = GetFileSize( mapping->hFile, NULL );
	}
	mapping->hMap = CreateFileMapping( mapping->hFile, NULL, 
		fWrite ? PAGE_READWRITE : PAGE_READONLY, 0, (DWORD)size, NULL );
	if( !mapping->hMap ) {
		goto bad;
	}
	mapping->base = MapViewOfFile( mapping->hMap, fWrite ? FILE_MAP_ALL_ACCESS : FILE_MAP_READ, 0, 0, size );
	if( !mapping->base) {
		goto bad;
	}
	return mapping->base;
bad:
	UnmapFile( mapping );
	return NULL;
}

PVOID
MapFileForRead(
			   OUT PFILE_MAPPING	mapping,
			   IN PTCHAR			fileName,
			   OUT PSIZE_T			fileSize	OPTIONAL
			   )
{
	PVOID base = MapFile( mapping, fileName, FALSE, 0 );
	if( base ) {
		if( fileSize )
			*fileSize = mapping->size;
	}
	return base;
}

PVOID
MapFileForWrite(
				OUT PFILE_MAPPING	mapping,
				IN PTCHAR			fileName,
				IN SIZE_T			fileSize
				)
{
	return MapFile( mapping, fileName, TRUE, fileSize );
}

BOOLEAN
Decode(
	   PTCHAR srcName, 
	   PTCHAR dstName
	   )
{
	BOOLEAN fSuccess = FALSE;
	FILE_MAPPING src[1] = {{0}}, dst[1] = {{0}};
	SIZE_T cbSrc;
	PUCHAR pSrc = MapFileForRead( src, srcName, &cbSrc );
	SIZE_T cbData = cbSrc - cbPackedHeader;
	SIZE_T cbDst = cbData + cbUnpackedHeader;
	PUCHAR pDst = MapFileForWrite( src, dstName, cbDst );
	PUCHAR 
		pSrcData = pSrc + cbPackedHeader, 
		pDstData = pDst + cbUnpackedHeader;
	ULONG headerCrc, fileCrc;
	PNBF_HEADER pNbfHeader;
	UCHAR strCrc32[9];
	UCHAR buf[0x200];
	
	if( !pSrc || !pDst ) {
		goto cleanup;
	}
	
	HeaderCryptInit();
	HeaderDecrypt( pSrc, cbPackedHeader, pDst, cbUnpackedHeader );
	HeaderEncrypt( pDst, cbUnpackedHeader, buf, cbPackedHeader );
	pNbfHeader = (PNBF_HEADER)pDst;
	HeaderDump( pNbfHeader );
	_snprintf( strCrc32, sizeof(strCrc32) - 1, "%s", pNbfHeader->crc32);
	headerCrc = strtoul( strCrc32, NULL, 0x10 );
	pSrcData = pSrc + cbPackedHeader;
	pDstData = pDst + cbUnpackedHeader;
	cbData = cbSrc - cbPackedHeader;
	XorDecryptData( pSrcData, pDstData, cbData, headerCrc );
	fileCrc = crc32( pDstData, cbData ) + 
		crc32( pNbfHeader, (SIZE_T) ( ( (PNBF_HEADER) NULL )->crc32 ) );
	fSuccess = headerCrc == fileCrc;
	printf("\nHeader crc32/file crc: %x/%x - %s \n", headerCrc, fileCrc, fSuccess ? "MATCH" : "FAIL" );
cleanup:
	UnmapFile( src );
	UnmapFile( dst );
	if( !fSuccess ) {
		DeleteFile( dstName );
	}
	return fSuccess;
}

BOOLEAN
Encode(
	   PTCHAR srcName, 
	   PTCHAR dstName
	   )
{
	BOOLEAN fSuccess = FALSE;
	FILE_MAPPING src[1] = {{0}}, dst[1] = {{0}};
	SIZE_T cbSrc;
	PUCHAR pSrc = MapFileForRead( src, srcName, &cbSrc );
	SIZE_T cbData = cbSrc - cbUnpackedHeader;
	SIZE_T cbDst = cbData + cbPackedHeader;
	PUCHAR pDst = MapFileForWrite( src, dstName, cbDst );
	PUCHAR 
		pSrcData = pSrc + cbUnpackedHeader, 
		pDstData = pDst + cbPackedHeader;
	ULONG fileCrc;
	NBF_HEADER nbfHeader;
	
	if( !pSrc || !pDst ) {
		goto cleanup;
	}
	
	memcpy( &nbfHeader, pSrc, sizeof( NBF_HEADER ) );
	HeaderDump( &nbfHeader );
	fileCrc = crc32( pSrcData, cbData ) + 
		crc32( &nbfHeader, (SIZE_T) ( ( (PNBF_HEADER) NULL )->crc32 ) );
	printf( "\nFile crc32: %x \n", fileCrc );
	_snprintf( nbfHeader.crc32, sizeof(nbfHeader.crc32), "%- 8x", fileCrc);
	HeaderCryptInit();
	HeaderEncrypt( &nbfHeader, sizeof(nbfHeader), pDst, cbPackedHeader );
	XorEncryptData( pSrcData, pDstData, cbData, fileCrc );
	fSuccess = TRUE;
cleanup:
	UnmapFile( src );
	UnmapFile( dst );
	if( !fSuccess ) {
		DeleteFile( dstName );
	}
	return fSuccess;
}

VOID
Usage(
	  VOID
	  )
{
	printf("Usage: {-e|-d} <source> <destination>\n"
		"\t-d - decode\n"
		"\t-e - encode\n"
		);	
}

int 
main(int ac, char** av)
{
	av++;
	if ( !strcmpi( *av, "-d" ) ) {
		av++;
		Decode( av[0], av[1] );
	} else if ( !strcmpi( *av, "-e" ) ) {
		av++;
		Encode( av[0], av[1] );
	} else {
		Usage();
	}
	return 0;
}