302 lines
7.0 KiB
C++
302 lines
7.0 KiB
C++
// Support.cpp : 콘솔 응용 프로그램에 대한 진입점을 정의합니다.
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include "Encrypt.h"
|
|
#include <string.h>
|
|
|
|
#ifdef _DEBUG
|
|
# pragma comment( lib, "TheMola_d.lib" )
|
|
# pragma comment( lib, "TheMola4File_d.lib" )
|
|
#else
|
|
# pragma comment( lib, "TheMOLA.lib" )
|
|
# pragma comment( lib, "TheMola4File.lib" )
|
|
#endif
|
|
|
|
CHAR s_pszSourcePath[128] = { 0, };
|
|
CHAR s_pszTargetPath[128] = { 0, };
|
|
|
|
FileListLoader::SECTION_TYPE
|
|
Test_ParseSection(PVOID pPassingPtr,AttrTag tag)
|
|
{
|
|
if( tag.IsMatch( "[SECTOR]" ) )
|
|
{
|
|
printf( "Section!\n" );
|
|
return FileListLoader::eSECTION_TYPE::SECTION_COLUMNS;
|
|
}
|
|
|
|
return FileListLoader::eSECTION_TYPE::SECTION_ERROR;
|
|
}
|
|
|
|
BOOL
|
|
Test_ParseSectionData(PVOID pPassingPtr, AttrValueName valueName, AttrValue value)
|
|
{
|
|
if( valueName.IsMatch( "SOURCE_PATH" ) )
|
|
{
|
|
_snprintf( s_pszSourcePath, sizeof(s_pszSourcePath), "%s", value.ToString() );
|
|
return TRUE;
|
|
}
|
|
else if( valueName.IsMatch( "TARGET_PATH" ) )
|
|
{
|
|
_snprintf( s_pszTargetPath, sizeof(s_pszTargetPath), "%s", value.ToString() );
|
|
return TRUE;
|
|
}
|
|
else if( valueName.IsMatch( "OKFF" ) )
|
|
{
|
|
DWORD dwValue;
|
|
value.GetValue( dwValue );
|
|
printf( "Section value %u!\n", dwValue );
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
VOID
|
|
Encryption::LoadScriptList()
|
|
{
|
|
FileListLoader loader;
|
|
|
|
loader.SectionCallbackAlloc( &Test_ParseSection, NULL );
|
|
loader.SectionDataCallbackAlloc( &Test_ParseSectionData, NULL );
|
|
|
|
loader.Load( "ScriptList.txt", FALSE );
|
|
|
|
m_FileInfo.dwLineCount = loader.GetLineCount();
|
|
DWORD dwReadedCount = 0;
|
|
|
|
m_FileInfo.pList = (SFiles*)malloc( m_FileInfo.dwLineCount*sizeof(SFiles) );
|
|
SFiles* pListT = m_FileInfo.pList;
|
|
|
|
for( DWORD i=0 ; i<m_FileInfo.dwLineCount ; ++i )
|
|
{
|
|
BOOL bValid = TRUE;
|
|
if( !(bValid && loader.ReadValue( pListT->byValue )) )
|
|
bValid = FALSE;
|
|
|
|
if( !(bValid && loader.ReadString( pListT->pFileName, sizeof(pListT->pFileName) ) ) )
|
|
bValid = FALSE;
|
|
|
|
if( !(bValid && loader.ReadValue( pListT->bLoad ) ) )
|
|
bValid = FALSE;
|
|
|
|
if( !bValid )
|
|
{
|
|
dwReadedCount = i;
|
|
break;
|
|
}
|
|
|
|
pListT++;
|
|
}
|
|
|
|
loader.Close();
|
|
}
|
|
|
|
BOOL
|
|
Encryption::OpenNrewrite(FileHandleInfo* p_FHI,
|
|
SFiles* pListT,
|
|
CHAR* pSrcBuffer,
|
|
DWORD dwSize)
|
|
{
|
|
if( !pListT )
|
|
return FALSE;
|
|
|
|
CHAR pszFullPath[MAX_PATH] = {0, };
|
|
CHAR pszDirPath[128] = {0, };
|
|
|
|
_snprintf( pszFullPath, MAX_PATH, "%s\\%s", m_FolderPath, pListT->pFileName );
|
|
DeleteFile( pszFullPath );
|
|
|
|
HANDLE hFILE = _OpenFile( pszFullPath, OF_CREATE);
|
|
if( hFILE == INVALID_HANDLE_VALUE )
|
|
{
|
|
_MessageOut( pListT, RC_CONVERT_DECODE_SUCCESS, TRUE);
|
|
return FALSE;
|
|
}
|
|
|
|
p_FHI->hFILE = hFILE;
|
|
p_FHI->dwFileSize = dwSize;
|
|
p_FHI->pSTREAM = pSrcBuffer;
|
|
|
|
DWORD dwWritten = 0;
|
|
WriteFile( hFILE, p_FHI->pSTREAM, p_FHI->dwFileSize, &dwWritten, NULL );
|
|
FlushFileBuffers( hFILE );
|
|
CloseHandle( hFILE );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
Encryption::OpenNread( FileHandleInfo* p_FHI, SFiles* pListT )
|
|
{
|
|
if( !pListT )
|
|
return FALSE;
|
|
|
|
CHAR pszFullPath[MAX_PATH] = {0, };
|
|
CHAR pszDirPath[128] = {0, };
|
|
CHAR szEncrypted[5] = {0, };
|
|
|
|
_snprintf( pszFullPath, MAX_PATH, "%s\\%s", m_FolderPath, pListT->pFileName );
|
|
HANDLE hFILE = _OpenFile( pszFullPath, OF_READWRITE);
|
|
if( hFILE == INVALID_HANDLE_VALUE )
|
|
{
|
|
_MessageOut( pListT, RC_CONVERT_DONT_OPEN_FILE, TRUE); // TRUE 에러
|
|
return FALSE;
|
|
}
|
|
|
|
p_FHI->hFILE = hFILE;
|
|
DWORD dwFileSize = GetFileSize( hFILE, NULL );
|
|
p_FHI->dwFileSize = dwFileSize;
|
|
p_FHI->pSTREAM = (CHAR*)malloc( dwFileSize );
|
|
|
|
DWORD dwReaded;
|
|
|
|
if( !ReadFile( hFILE, p_FHI->pSTREAM, dwFileSize, &dwReaded, NULL ) )
|
|
{
|
|
_MessageOut( pListT, RC_CONVERT_DONT_READ_FILE, TRUE);
|
|
// MSGOUT( "Can't Read File\n" );
|
|
return FALSE;
|
|
}
|
|
|
|
strncpy(szEncrypted, p_FHI->pSTREAM, 4);
|
|
szEncrypted[4] = 0;
|
|
if( strcmp( szEncrypted, "WzCF") == 0 )
|
|
{
|
|
CloseHandle( p_FHI->hFILE);
|
|
free( p_FHI->pSTREAM);
|
|
_MessageOut( pListT, RC_CONVERT_CONVERTED, TRUE);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
// <MAIN LOGIC>
|
|
VOID
|
|
Encryption::TestUnit_FileList_EnDecode(BOOL bDecrypt/*=FALSE*/) // FALSE : 인코드 TRUE : 디코드
|
|
{
|
|
m_bEncrytion = bDecrypt;
|
|
|
|
LoadScriptList();
|
|
|
|
if( !bDecrypt )
|
|
{
|
|
SFiles* pListT = m_FileInfo.pList;
|
|
for( DWORD d=0; d < m_FileInfo.dwLineCount; ++d )
|
|
{
|
|
if( pListT->bLoad )
|
|
{
|
|
FileHandleInfo FHI;
|
|
if( OpenNread( &FHI, pListT))
|
|
{
|
|
EnterSect section( m_hSection);
|
|
|
|
FileEncoder* pWriter = new FileEncoder();
|
|
pWriter->WriteStart( FHI.hFILE, "data"/*pListT->pFileName*/ );
|
|
pWriter->SetData( (BYTE*)FHI.pSTREAM, FHI.dwFileSize );
|
|
pWriter->WriteEnd();
|
|
free( FHI.pSTREAM );
|
|
delete pWriter;
|
|
|
|
_MessageOut( pListT, RC_CONVERT_SUCCESS);
|
|
}
|
|
}
|
|
pListT++;
|
|
}
|
|
}
|
|
|
|
if( bDecrypt )
|
|
{
|
|
SFiles* pListT = m_FileInfo.pList;
|
|
for( DWORD d = 0 ; d < m_FileInfo.dwLineCount; ++d, ++pListT )
|
|
{
|
|
if( pListT->bLoad )
|
|
{
|
|
CHAR pszFullPath[MAX_PATH] = {0, };
|
|
CHAR pszDirPath[128] = {0, };
|
|
|
|
_snprintf( pszFullPath, MAX_PATH, "%s\\%s",pListT->pFileName );
|
|
HANDLE hFILE = _OpenFile( pszFullPath, OF_READWRITE);
|
|
if( hFILE == INVALID_HANDLE_VALUE )
|
|
{
|
|
_MessageOut( pListT, RC_CONVERT_DONT_OPEN_FILE, TRUE);
|
|
continue;
|
|
}
|
|
|
|
CloseHandle( hFILE );
|
|
|
|
{
|
|
EnterSect section( m_hSection);
|
|
|
|
FileDecoder* pReader = new FileDecoder();
|
|
pReader->ReadStart( pszFullPath, "data"/*pListT->pFileName*/ );
|
|
FileHandleInfo handleInfo;
|
|
handleInfo.dwFileSize = pReader->GetSize();
|
|
handleInfo.pSTREAM = new CHAR[handleInfo.dwFileSize];
|
|
pReader->GetData( (BYTE*)handleInfo.pSTREAM, handleInfo.dwFileSize );
|
|
pReader->ReadEnd();
|
|
delete pReader;
|
|
|
|
OpenNrewrite( &handleInfo, pListT, handleInfo.pSTREAM, handleInfo.dwFileSize );
|
|
free( handleInfo.pSTREAM );
|
|
_MessageOut( pListT, RC_CONVERT_DECODE_SUCCESS);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
printf("Convert End\n");
|
|
}
|
|
|
|
VOID
|
|
Encryption::_MessageOut(SFiles* pListT, eRC_CONVERT error, BOOL bError/*FALSE*/) const
|
|
{
|
|
static std::string strDecode("Decode");
|
|
static std::string strIncode("Incode");
|
|
DWORD dwError = 0;
|
|
|
|
MSGOUT( "%s\tTYPE[%02d]\tFileName : %s, RC_CODE: %d",
|
|
( m_bEncrytion ? strIncode.c_str() : strDecode.c_str()),
|
|
pListT->byValue, pListT->pFileName, error );
|
|
|
|
m_pResult->AddData( pListT->pFileName, error, m_bEncrytion);
|
|
}
|
|
|
|
HANDLE
|
|
Encryption::_OpenFile(const TCHAR *FullPath, DWORD mode) const
|
|
{
|
|
OFSTRUCT pOF;
|
|
|
|
reopen:
|
|
HANDLE hFILE = (HANDLE)(__int64)OpenFile( FullPath, &pOF, mode);
|
|
if( hFILE == INVALID_HANDLE_VALUE )
|
|
{
|
|
if( GetFileAttributes( FullPath) && FILE_ATTRIBUTE_READONLY )
|
|
if( SetFileAttributes( FullPath, FILE_ATTRIBUTE_NORMAL))
|
|
goto reopen;
|
|
|
|
return hFILE;
|
|
}
|
|
|
|
return hFILE;
|
|
}
|
|
|
|
//VOID
|
|
//Encryption::_MessageOut(const TCHAR* FileName, BOOL bError = FALSE) const
|
|
//{
|
|
// static std::string strDecode("Decode");
|
|
// static std::string strIncode("Incode");
|
|
// DWORD dwError = 0;
|
|
//
|
|
// MSGOUT( "%s\tTYPE[%02d]\tFileName : %s\n",
|
|
// ( m_bEncrytion ? strDecode.c_str() : strIncode.c_str()),
|
|
// pListT->byValue,
|
|
// FileName );
|
|
//
|
|
// if( bError )
|
|
// dwError = GetLastError();
|
|
//
|
|
// m_pResult->AddData( pListT->pFileName, dwError, m_bEncrytion);
|
|
//}
|