compressdlg.cpp

来自「一些初级的网络编程」· C++ 代码 · 共 1,352 行 · 第 1/3 页

// CompressDlg.cpp : implementation file
//

#include "stdafx.h"
#include "bambam.h"
#include "CompressDlg.h"
#include "OptionsDlg.h"

#include "perealign.h"
#include "peutils.h"

#include "..\aPLib-0.42\lib\mscoff\aplib.h"
#include "..\stub\gev.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#define VERSION 0.02

DWORD dwNewResourceSize = 0;
GLOBAL_EXTERNAL_VARS gev = { 0 };

/////////////////////////////////////////////////////////////////////////////
// CCompressDlg dialog


CCompressDlg::CCompressDlg(CWnd* pParent /*=NULL*/)
	: CTexturedDlg(CCompressDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CCompressDlg)
	m_SourceFile = _T("");
	m_CompressionProgress = _T("");
	m_FileSize = _T("");
	//}}AFX_DATA_INIT
}


void CCompressDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CCompressDlg)
	DDX_Control(pDX, IDC_COMP_SIZE, m_ctrlCompessedSize);
	DDX_Control(pDX, IDC_COMP_PROGRESS, m_ctrlCompressionProgress);
	DDX_Text(pDX, IDC_SOURCE_FILE, m_SourceFile);
	DDX_Text(pDX, IDC_COMP_PROG, m_CompressionProgress);
	DDX_Text(pDX, IDC_FILE_SIZE, m_FileSize);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CCompressDlg, CDialog)
	//{{AFX_MSG_MAP(CCompressDlg)
	ON_BN_CLICKED(IDC_BROWSE, OnBrowse)
	ON_BN_CLICKED(IDC_EXIT, OnExit)
	ON_BN_CLICKED(IDC_COMPRESS, OnCompress)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CCompressDlg message handlers

void CCompressDlg::OnBrowse() 
{
	OPENFILENAME ofn;
	char szFile[_MAX_PATH] = {0};

	// Initialize OPENFILENAME
	ZeroMemory(&ofn, sizeof(ofn));
	ofn.lStructSize = sizeof(ofn);
	ofn.hwndOwner = this->GetSafeHwnd();
	ofn.lpstrFile = szFile;


	ofn.lpstrFile[0] = '\0';
	ofn.nMaxFile = _MAX_PATH;
	ofn.lpstrFilter = "All\0*.*\0Executables\0*.EXE\0";
	ofn.nFilterIndex = 1;
	ofn.lpstrFileTitle = NULL;
	ofn.nMaxFileTitle = 0;
	ofn.lpstrInitialDir = NULL;
	ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;

	// open file dialog
	if(GetOpenFileName(&ofn))
	{
		m_CompressionProgress = "";
		m_ctrlCompressionProgress.SetPos(0);
		
		m_FileSize = "";
		m_ctrlCompessedSize.SetPos(0);

		m_SourceFile = ofn.lpstrFile;
	}

	UpdateData(FALSE);
}

void CCompressDlg::OnExit() 
{
	ExitProcess(0);
}

int CCompressDlg::Encrypt(char* szFile)
{
	HANDLE hFile;
	HANDLE hMapping;
	LPVOID lpMapping;

	HANDLE hBackupFile;
	HANDLE hBackupMapping;
	LPVOID lpBackupMapping;

	DWORD dwOldOEP = 0;
	DWORD dwFullOnKey = 0;
	DWORD dwRetSec = 0;
	DWORD dwAlignment = 0;

	DWORD dwOrigSize = 0;
	DWORD dwNewSize = 0;

	char szInput[_MAX_PATH] = {0};
	char szBackup[_MAX_PATH] = {0};

	if(m_pOptionsDlg->m_Backup == TRUE)
	{
		strcpy(szInput, szFile);
		sprintf(szBackup, "%s.bak", szInput);
		CopyFile(szFile, szBackup, FALSE);
	}

	// create temp backup
	char szTempPath[_MAX_PATH] = {0};
	char szTempFile[_MAX_PATH] = {0};

	GetTempPath(_MAX_PATH, szTempPath);
	GetTempFileName(szTempPath, "bam", 0, szTempFile);

	CopyFile(szFile, szTempFile, FALSE);

	// open target
	hFile = CreateFile(szFile, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
	
	if(hFile == INVALID_HANDLE_VALUE)
	{
		MessageBox("Invalid file handle", 0, MB_OK | MB_ICONERROR);
		return 1;
	}
	
	DWORD dwSizeToMap = GetFileSize(hFile, 0);
	dwOrigSize = dwSizeToMap;
	dwSizeToMap = dwSizeToMap * 2;

	hMapping = CreateFileMapping(hFile, NULL, PAGE_READWRITE, 0, dwSizeToMap, 0);
	
	if(hMapping == NULL)
	{
		MessageBox("Invalid handle for file mapping", 0, MB_OK | MB_ICONERROR);
		return 1;
	}

	lpMapping = MapViewOfFile(hMapping, FILE_MAP_ALL_ACCESS, 0, 0, dwSizeToMap);


	if(lpMapping == NULL)
	{
		MessageBox("Invalid pointer for mapping", 0, MB_OK | MB_ICONERROR);
		return 1;
	}

	// open backup
	hBackupFile = CreateFile(szTempFile, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
	
	if(hBackupFile == INVALID_HANDLE_VALUE)
	{
		MessageBox("Invalid backup file handle", 0, MB_OK | MB_ICONERROR);
		return 1;
	}
	
	hBackupMapping = CreateFileMapping(hBackupFile, NULL, PAGE_READWRITE, 0, 0, 0);
	
	if(hBackupMapping == NULL)
	{
		MessageBox("Invalid handle for backup file mapping", 0, MB_OK | MB_ICONERROR);
		return 1;
	}
	
	lpBackupMapping = MapViewOfFile(hBackupMapping, FILE_MAP_ALL_ACCESS, 0, 0, 0);
	
	if(lpBackupMapping == NULL)
	{
		MessageBox("Invalid pointer for backup mapping", 0, MB_OK | MB_ICONERROR);
		return 1;
	}
	
	if(m_pOptionsDlg->m_Realign == TRUE)
	{
		dwNewSize = RealignPE(lpMapping, dwOrigSize);
		
		// realign backup also, so sections match
		RealignPE(lpBackupMapping, dwOrigSize);
	}

	if(m_pOptionsDlg->m_StripReloc == TRUE)
	{
		dwNewSize = StripReloc(lpMapping);
	}

	// open stub from resource
	DWORD dwWritten;
	LPVOID lpBuf;
	LPVOID lpStubMapping;
	HRSRC hRes = 0;
	HGLOBAL hResLoad = 0;
	hRes = FindResource(0, MAKEINTRESOURCE(IDR_STUB), "BINARY"); 
	hResLoad = LoadResource(0, hRes);
	lpStubMapping = LockResource(hResLoad);
	
	// Compress target sections
	try
	{
		CompressSections(lpMapping, lpBackupMapping);
	}
	catch(...)
	{
		MessageBox("Fatal error during compression", 0, MB_OK | MB_ICONERROR);

		// unmap backup
		UnmapViewOfFile(lpBackupMapping);
		CloseHandle(hBackupMapping);	
		CloseHandle(hBackupFile);
		DeleteFile(szTempFile);

		// unmap target
		UnmapViewOfFile(lpMapping);
		CloseHandle(hMapping);	
		CloseHandle(hFile);

		if(m_pOptionsDlg->m_Backup == TRUE)
		{
			DeleteFile(szFile);
			MoveFile(szBackup, szFile);
		}

		return -1;
	}
	
	DWORD dwKatSup;
	DWORD dwSecStart;
	WORD wNumSections;
	WORD wSizeO;
	LONG lJmp;

	PIMAGE_DOS_HEADER pStubDosHdr;
	PIMAGE_NT_HEADERS pStubNtHdr;
	PIMAGE_SECTION_HEADER pStubSecHdr;

	DWORD dwStubEntryPoint = 0;
	DWORD dwPointerToStubRawData = 0;
	DWORD dwStubSecStart = 0;

	pStubDosHdr = (PIMAGE_DOS_HEADER) lpStubMapping;
	
	lJmp = pStubDosHdr->e_lfanew; // oh yeh and we already checked sig shit so fuck off.

	dwKatSup = (DWORD) lpStubMapping;
	
	dwKatSup += lJmp;

	pStubNtHdr = (PIMAGE_NT_HEADERS) dwKatSup;

	dwStubEntryPoint = pStubNtHdr->OptionalHeader.AddressOfEntryPoint - pStubNtHdr->OptionalHeader.BaseOfCode;

	wNumSections = pStubNtHdr->FileHeader.NumberOfSections;
	wSizeO = pStubNtHdr->FileHeader.SizeOfOptionalHeader;
	
	dwStubSecStart = (DWORD) pStubNtHdr;
	dwStubSecStart += 24;
	dwStubSecStart += wSizeO;
	
	pStubSecHdr = (PIMAGE_SECTION_HEADER)dwStubSecStart;
	
	DWORD dwStubSize = SizeofResource(0, hRes);
	
	lpBuf = malloc(dwStubSize);
	memset(lpBuf, 0, dwStubSize);
	// copy stub data
	memcpy(lpBuf, lpStubMapping, dwStubSize);
	
	PIMAGE_DOS_HEADER pDosHdr;
	PIMAGE_NT_HEADERS pNtHdr;
	PIMAGE_SECTION_HEADER pSecHdr;
	IMAGE_SECTION_HEADER SecHdr;
	int i = 0;
	
	pDosHdr = (PIMAGE_DOS_HEADER) lpMapping;
	
	lJmp = pDosHdr->e_lfanew; // oh yeh and we already checked sig shit so fuck off.
	
	dwKatSup = (DWORD) lpMapping;
	
	dwKatSup += lJmp;
	
	pNtHdr = (PIMAGE_NT_HEADERS) dwKatSup;
	
	dwOldOEP = pNtHdr->OptionalHeader.AddressOfEntryPoint;
	
	wNumSections = pNtHdr->FileHeader.NumberOfSections;
	wSizeO = pNtHdr->FileHeader.SizeOfOptionalHeader;

	dwSecStart = (DWORD) pNtHdr;
	dwSecStart += 24;
	dwSecStart += wSizeO;
	
	dwSecStart += (wNumSections * 0x28);
	dwSecStart -= 0x28;
	
	pSecHdr = (PIMAGE_SECTION_HEADER) dwSecStart;
	
	DWORD dwRvaStart;
	DWORD dwPointerStar;
	DWORD dwSizeOfRawz;
	DWORD dwPointerNew;
	char szSecName[9] = {0};
	DWORD dwVirtSizeNew;

	strcpy(szSecName, m_pOptionsDlg->m_SectionName);

	dwVirtSizeNew = CalcStubSize(pStubDosHdr);
	
	dwRvaStart = pSecHdr->VirtualAddress + pSecHdr->Misc.VirtualSize;
		
	dwPointerStar = pSecHdr->PointerToRawData;
	dwSizeOfRawz = pSecHdr->SizeOfRawData;
	
	dwPointerNew = dwPointerStar + dwSizeOfRawz; // a place to inject
	
	DWORD dwStubRvaStart = dwRvaStart;
	
	lstrcpyn( (LPSTR) &SecHdr.Name, (LPSTR) &szSecName, sizeof(szSecName));
	
	pSecHdr = (PIMAGE_SECTION_HEADER) &SecHdr;
	
	SecHdr.Misc.VirtualSize = ValidAlignment(dwVirtSizeNew, 0x1000);

	SecHdr.VirtualAddress = dwRvaStart;
	SecHdr.PointerToRawData = dwPointerNew;
	SecHdr.SizeOfRawData = ValidAlignment(dwVirtSizeNew, 0x200);
	SecHdr.Characteristics = 0xC0000040;
	
	dwSecStart += 0x28;
	
	memcpy( (void *) dwSecStart, &SecHdr, 0x28);
	
	pNtHdr->OptionalHeader.AddressOfEntryPoint = dwRvaStart + dwStubEntryPoint;
	pNtHdr->OptionalHeader.SizeOfImage = SecHdr.VirtualAddress + ValidAlignment(SecHdr.Misc.VirtualSize, pNtHdr->OptionalHeader.SectionAlignment);;
	pNtHdr->FileHeader.NumberOfSections += 1;
	
	// update some values in lpBuf
	// stub section info
	DWORD dwNumberOfStubSections = 0;
	DWORD dwSectionCount = 0;
	dwNumberOfStubSections = pStubNtHdr->FileHeader.NumberOfSections;

	BOOL fGevFound = FALSE;
	BOOL fCodeFound = FALSE;
	BOOL fImportsFound = FALSE;

	pStubSecHdr = (PIMAGE_SECTION_HEADER)dwStubSecStart;

	// fix code addresses
	for(dwSectionCount = 0; dwSectionCount < dwNumberOfStubSections; dwSectionCount++)
	{
		if(strcmp((char*)pStubSecHdr->Name, ".text") != 0)
		{
			pStubSecHdr++;
		}
		else
		{
			fCodeFound = TRUE;
			break;
		}
	}	

	dwPointerToStubRawData = pStubSecHdr->PointerToRawData;

	if(fCodeFound)
	{
		PIMAGE_SECTION_HEADER pSectionTemp;

		pSectionTemp = pStubSecHdr;

		PerformStubRelocations(lpBuf, dwStubRvaStart + pNtHdr->OptionalHeader.ImageBase);
	}

	// find stub imports
	pStubSecHdr = (PIMAGE_SECTION_HEADER)dwStubSecStart;

	// fix thunks in stub
	for(dwSectionCount = 0; dwSectionCount < dwNumberOfStubSections; dwSectionCount++)
	{
		if(strcmp((char*)pStubSecHdr->Name, ".rdata") != 0)
		//if(strcmp((char*)pStubSecHdr->Name, ".a") != 0)
		{
			pStubSecHdr++;
		}
		else
		{
			fImportsFound = TRUE;
			break;
		}
	}	

	if(fImportsFound)
	{
		// temp
		IMAGE_IMPORT_DESCRIPTOR* pIID = 0;
		IMAGE_THUNK_DATA* pThunk = 0;

		// translate thunk values
		TranslateAddresses((BYTE*)((DWORD)lpBuf + pStubSecHdr->PointerToRawData),
							pStubSecHdr->SizeOfRawData,
							pStubSecHdr->VirtualAddress,
							dwStubRvaStart + (pStubSecHdr->PointerToRawData - dwPointerToStubRawData),	//dwPointerToStubRawData
							pStubSecHdr->VirtualAddress);
	}

	// point PE header at stub IAT
	DWORD dwOriginalIAT = pNtHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
	DWORD dwTemp = (pStubNtHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress & 0x000000ff);
	pNtHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress = dwStubRvaStart + (pStubSecHdr->PointerToRawData - dwPointerToStubRawData) + dwTemp;	//dwPointerToStubRawData
	pNtHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size = pStubNtHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size;

	// wipe IAT
	pNtHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].VirtualAddress = 0;
	pNtHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].Size = 0;


	// end find stub iat

	// find global external vars
	pStubSecHdr = (PIMAGE_SECTION_HEADER)dwStubSecStart;

	GlobalExternalVars* pgev;

	for(dwSectionCount = 0; dwSectionCount < dwNumberOfStubSections; dwSectionCount++)
	{
		if(strcmp((char*)pStubSecHdr->Name, ".a") != 0)
		{