hpp.cpp

将exe等可执行文件转化成c程序的反编译程序,先到汇编再到c

// Copyright(C) 1999-2005 LiuTaoTao，[e-mail]


//	exe2c project

#include "stdafx.h"
#include "00000.h"
#include "HPP.h"

#include "CClassManage.h"
#include "CEnumMng.h"
#include "CCbuf.h"
#include "strparse.h"
#include "SVarType.h"
/*
#include "../pub/strparse.h"
#include "../CCbuf/CCbuf.h"
#include "../FileLoad/FileLoad.h"

#include "../CEnumMng/CEnumMng.h"
#include "../CVarTypeMng/SVarType.h"
  */

#include "io.h"

class CHpp
{
public:
	FuncTypeList* m_FuncTypeList;	//	保存从.h得来的全局函数定义

	CHpp();
	~CHpp();
	void newfunc_addlist(CFuncType* pnewfunc);
	void func_define(PCSTR lbuf, CCInfo *p);
	CFuncType* Get_FuncDefine_from_internal_name_(PCSTR pmyinternalname);
	CFuncType* Get_FuncDefine_from_name_(PCSTR pmyname);
};

CHpp* g_Hpp = NULL;

VarTypeID Get_Var_Declare(PCSTR &p, OUT PSTR name);

DefineList* g_DefineList = NULL;


bool LoadIncFile(PCSTR fname);
void prt_defines();
PSTR get_define(PSTR partern);
void define_replace(PSTR buf);

char g_incpath[256];
CHpp::CHpp()
{
	m_FuncTypeList = new FuncTypeList;
}
CHpp::~CHpp()
{
	if (m_FuncTypeList)
	{
		POSITION pos = m_FuncTypeList->GetHeadPosition();
		while (pos)
		{
			CFuncType* p = m_FuncTypeList->GetNext(pos);
			delete p;
		}
		delete m_FuncTypeList;
		m_FuncTypeList = NULL;
	}
}
PCSTR GetMyExePath()
{
    static char lpFilename[256];
    GetModuleFileName(NULL, lpFilename, 255);
    char* p = strrchr(lpFilename, '\\');
    if (p != NULL)
        *p = 0;
    return lpFilename;
}
BOOL hpp_init()
{
	g_Hpp = new CHpp;

	g_DefineList = new DefineList;
	g_ClassManage = new CClassManage;
	g_enum_mng = new Enum_mng;
	
	strcpy(g_incpath, GetMyExePath());//g_mypath);
	strcat(g_incpath, "\\inc\\");

//	if (g_EXEType == enum_PE_sys)
//		strcat(g_incpath, "\\ntddk\\");

	LoadIncFile("MY.H");

	return TRUE;
}

BOOL hpp_onexit()
{
	delete g_Hpp;
	g_Hpp = NULL;

	delete g_enum_mng;
	if (g_DefineList)
	{
		POSITION pos = g_DefineList->GetHeadPosition();
		while (pos)
		{
			define_t* p = g_DefineList->GetNext(pos);
			delete p;
		}
		delete g_DefineList;
		g_DefineList = NULL;
	}


	if (g_ClassManage)
	{
		delete g_ClassManage;
		g_ClassManage = NULL;
	}

	return TRUE;
}
define_t::define_t()
{
	src = NULL, dst = NULL;
}

define_t::~define_t()
{
	delete src, delete dst;
}

//	----------------------------------------------------------
CCInfo::CCInfo()
{
	this->comma1 = 0;
	this->comma2 = 0;
	this->extern_c = 0;
	this->m_default_callc = enum_stdcall;

	this->m_len = 0;
	this->m_buf = NULL;
}

CCInfo::~CCInfo()
{
	if (this->m_buf)
	{
		delete this->m_buf;
		this->m_buf = NULL;
	}
}

void CCInfo::LoadFile(FILE *f)
{
	CCbuf ccbuf;
	ccbuf.LoadFile(f);
	this->m_buf = ccbuf.m_p;
	this->m_len = ccbuf.m_len;
}
bool LoadIncFile(PCSTR fname)
{
	char path[256];
	strcpy(path,g_incpath);
	strcat(path, fname);

	//alert_prtf("begin file %s\n",fname);
	FILE* f = fopen(path,"rb");
	if (f == NULL)
	{
		alert_prtf("File open error: %s",path);
		return FALSE;
	}

	CCInfo *pInfo = new CCInfo;

	pInfo->LoadFile(f);
	
	fclose(f);

	PSTR p = pInfo->m_buf;
	PSTR plast = p + pInfo->m_len;
	while (p < plast)
	{
		
		PSTR pnext = NULL;
		pInfo->OneLine(p, pnext);	//	一般情况下，OneLine不会动pnext
									//	如果它是多行，就会把pnext指向最后
		if (pnext == NULL)
		{
			p += strlen(p) + 1;
		}
		else
		{
			assert( memcmp(pnext,"E ",2) );
			p = pnext;
		}
	}

	assert(pInfo->comma1 == 0);
	assert(pInfo->comma2 == 0);
	assert(pInfo->extern_c == 0);
	delete pInfo->m_buf;
	pInfo->m_buf = NULL;
	delete pInfo;

	//printf("end   file %s\n",fname);
	return TRUE;
}
void LoadIncBuffer(PSTR p,PSTR plast)
{
	CCInfo* pInfo = new CCInfo;
	
	while (p < plast)
	{
		PSTR pnext = NULL;
		pInfo->OneLine(p, pnext);	//	一般情况下，OneLine不会动pnext
									//	如果它是多行，就会把pnext指向最后
		if (pnext == NULL)
		{
			p += strlen(p) + 1;
		}
		else
		{
			p = pnext;
		}
	}

	delete pInfo;
}
void prt_defines()
{
	POSITION pos = g_DefineList->GetHeadPosition();
	while (pos)
	{
		define_t* p = g_DefineList->GetNext(pos);
		p;
		//printf("#define | %s | %s\n",p->src,p->dst);
	}
}
void do_define(PSTR p1,PCSTR p2)
{	//	means #define p1 p2
	//printf("I find #define %s == %s\n",p1,p2);
	POSITION pos = g_DefineList->GetHeadPosition();
	while (pos)
	{
		define_t* p = g_DefineList->GetNext(pos);
		if (strcmp(p->src,p1) == 0)
		{
			if (strcmp(p->dst,p2) == 0)
				return;
			break;
		}
	}
	//	not find
	define_t* pnew = new define_t;
	pnew->src = new_str(p1);
	pnew->dst = new_str(p2);
	if (pos)
		g_DefineList->InsertBefore(pos,pnew);
	else
		g_DefineList->AddTail(pnew);
}

void One_Line_pre(PCSTR lbuf)
{	//	处理所有以 # 开始的行
	PCSTR p = lbuf;
	assert(*p == '#');
	p++;

	if (memcmp(p,"define",6) == 0)
	{	//	#define find
		p+=6;
		skip_space(p);
		assert(*p);	//#define 后面不能什么也没有

		char buf[280];
		get_1part(buf,p);
		skip_space(p);
		do_define(buf,p);
		return;
	}
	if (memcmp(p,"include",7) == 0)
	{
		p += 7;
		skip_space(p);
		if (*p == '\"' || *p == '<')
		{
			char path[80];
			p++;
			int i=0;
			while (*p != '\"' && *p != '>')
			{
				path[i++] = *p++;
			}
			path[i] = '\0';
			log_prtf("Load include file: %s\n",path);
			LoadIncFile(path);
		}
		return;
	}
}

void skip_string(char c1, PCSTR & p)
{
	//c1 is ' or "
	for(;;)
	{
		char c = *p++;
		if (c == '\\')
		{
			p++;
			continue;
		}
		assert(c != '\0');
		if (c == c1)
			return;
	}
}
BOOL Read_Var_Declare(PCSTR pstr, st_Var_Declare* pvardcl)
{
	VarTypeID id = Get_Var_Declare(pstr, pvardcl->m_name);
	if (id == 0)
	{
		alert("Read Struct Item error");
		return FALSE;
	}
	pvardcl->m_size = GG_VarType_ID2Size(id);
	pvardcl->m_vartypeid = id;
	return TRUE;
}
void log_display_structure(Class_st* p)
{
	log_prtt("struct ");
	log_prtt(p->m_name);
	log_prtf("\n{    \\\\sizeof = 0x%x\n",p->m_size);
	int nident = 1;
	for (int i=0;i<p->m_nDataItem;i++)
	{
		st_Var_Declare* pv = &p->m_DataItems[i];
		if (pv->m_access == nm_sub_end)
			nident--;
		for (int j=0;j<nident;j++)
			log_prtt("    ");
		if (pv->m_access == nm_substruc)
		{
			log_prtt("struct {\n");
			nident++;
			continue;
		}
		if (pv->m_access == nm_subunion)
		{
			log_prtt("union {\n");
			nident++;
			continue;
		}
		if (pv->m_access == nm_sub_end)
		{
			log_prtt("} ");
			if (pv->m_name[0])
				log_prtt(pv->m_name);
			log_prtt(";\n");
            continue;
		}

		log_prtl("%s\t%s;\t//+%02x",
				 GG_VarType_ID2Name(pv->m_vartypeid),
				 pv->m_name,
				 pv->m_offset_in_struc);
	}
	log_prtt("}\n");
}
VarTypeID do_struct_after_name(PCSTR strucname, PCSTR &p, BOOL Fstruc_Tunion);
VarTypeID do_struct(PCSTR &p)
{
	PCSTR savp = p;

	char name[80];
	get_1part(name,p);

	skip_eos(p);

	if (*p == '{')
		return do_struct_after_name(name,p,FALSE);
	VarTypeID id = g_VarTypeManage->NewUnknownStruc(name);
	return id;
}
VarTypeID do_union(PCSTR &p)
{
	PCSTR savp = p;

	char name[80];
	get_1part(name,p);

	skip_eos(p);

	if (*p == '{')
		return do_struct_after_name(name,p,TRUE);
	VarTypeID id = g_VarTypeManage->NewUnknownStruc(name);
	return id;
}
VarTypeID do_struct_after_name(PCSTR strucname, PCSTR &p, BOOL Fstruc_Tunion)
{
	assert(*p == '{');
	p++;
	skip_eos(p);

	int n = 0;
	st_Var_Declare items[150];	//50个，够了吗
	SIZEOF size = 0;
	ZeroMemory(items,150 * sizeof(st_Var_Declare));

	BOOL f_tbl[20];
	BOOL f = Fstruc_Tunion;	//FALSE means struct, TRUE means union
	SIZEOF size_tbl[20];
	SIZEOF maxsize_tbl[20];
	SIZEOF maxsize_in_union = 0;
	int	substruc_stack = 0;

	while (*p != '}' || substruc_stack != 0)
	{
		assert(n < 150);
		st_Var_Declare* pvar = &items[n];
		{
			PCSTR savp = p;
			char buf[80];
			get_1part(buf,p);
			skip_eos(p);
			if (strcmp(buf,"struct") == 0 && *p == '{')
			{	//	这是一个struct 中的struct定义
				size_tbl[substruc_stack] = size;
				maxsize_tbl[substruc_stack] = maxsize_in_union;
				f_tbl[substruc_stack++] = f;
				assert(substruc_stack<20);
				f = FALSE;
				pvar->m_access = nm_substruc;
				n++;

				p++;
				skip_eos(p);
				continue;
			}
			if (strcmp(buf,"union") == 0 && *p == '{')
			{	//	这是一个struct 中的union定义
				size_tbl[substruc_stack] = size;
				maxsize_tbl[substruc_stack] = maxsize_in_union;
				f_tbl[substruc_stack++] = f;
				assert(substruc_stack<20);
				f = TRUE;
				maxsize_in_union = size;
				pvar->m_access = nm_subunion;
				n++;

				p++;
				skip_eos(p);
				continue;
			}
			
			p = savp;
		}
		if (substruc_stack > 0 && *p == '}')
		{
			if (f)	//union
			{
				size = maxsize_in_union;
			}
			substruc_stack--;
			f = f_tbl[substruc_stack];
			if (f)
			{
				maxsize_in_union = maxsize_tbl[substruc_stack];
				if (size > maxsize_in_union)
					maxsize_in_union = size;
				size = size_tbl[substruc_stack];	//	退回原来的size
			}
			pvar->m_access = nm_sub_end;
			n++;

			p++;
			skip_eos(p);
			if (*p != ';')
			{	//	说明有名的
				get_1part(pvar->m_name,p);
				skip_eos(p);
				assert(*p == ';');
			}
			p++;
			skip_eos(p);
			continue;
		}
		Read_Var_Declare(p,pvar);
		pvar->m_offset_in_struc = size;

		//alert_prtf("var_item %s",pvar->m_name);

		if (!f)
			size += pvar->m_size;
		else
		{	//union
			if (size + pvar->m_size > maxsize_in_union)
				maxsize_in_union = size + pvar->m_size;
		}
		n++;
		p += strlen(p)+1;
	}
	

	p++;
	skip_space(p);
	if (*p == ';')
	{
		p++;
		skip_eos(p);
	}

	//	------------------------------------------
	Class_st* pnew = new Class_st;
	strcpy(pnew->m_name, strucname);
	pnew->m_nDataItem = n;
	pnew->m_DataItems = new st_Var_Declare[n];
	memcpy(pnew->m_DataItems, items, sizeof(st_Var_Declare)*n);
	if (Fstruc_Tunion)
		pnew->m_size = maxsize_in_union;
	else
		pnew->m_size = size;
	pnew->m_Fstruc_Tunion = Fstruc_Tunion;

	log_display_structure(pnew);

	g_ClassManage->new_struc(pnew);

	return g_VarTypeManage->Class2VarID(pnew);
}
void CCInfo::OneLine(const char * lbuf, const char * &pnext)
{
	//	已经把所有的双空格变成了单空格
	//	已经去掉了最后的换行符
	//	已经把\连接的行接起来了
	
	//printf("%s\n",lbuf);
	//return;

	PCSTR p = lbuf;
	assert(p);
	skip_space(p);

	if (*p == '#')
	{	//	它总是单行的
		One_Line_pre(p);
		return;
	}
	//_CRTIMP int __cdecl printf(const char *, ...);
	PCSTR p1 = p;
	char part1[80];
	get_1part(part1,p1);
	skip_eos(p1);
	
	if (strcmp(part1,"__inline") == 0)
	{
		pnext = p1;
		OneLine(p1,pnext);
		return;
	}
	if (strcmp(part1,"extern") == 0)
	{
		char part2[80];
		assert(*p1);
		PCSTR p2 = p1;
		get_1part(part2,p2);
		if (strcmp(part2,"\"C\"") == 0)
		{	//extern "C"
			//printf("extern C find\n");
			assert(*p2);			
			if (*p2 == '{')
			{
				assert(this->comma1 == 0);
				assert(this->comma2 == 0);
				this->extern_c++;
				this->OneLine(p2+1, pnext);
				return;
			}
			else
			{	//	just 1 line
				this->extern_c++;
				this->OneLine(p2, pnext);
				this->extern_c--;
				return;
			}
		}
	}
	else if (strcmp(part1,"typedef") == 0)
	{
		do_typedef(p1);
		pnext = p1;
		return;
	}
	else if (strcmp(part1,"struct") == 0)
	{
		do_struct(p1);
		pnext = p1;
		return;
	}
	else if (strcmp(part1,"union") == 0)
	{
		do_union(p1);
		pnext = p1;
		return;
	}
	else if (strcmp(part1,"class") == 0)
	{
		do_class(p1,pnext);
		return;
	}
	else if (strcmp(part1,"enum") == 0)
	{
		do_enum(p1);
		pnext = p1;
		return;
	}
	{	//	检查是不是多行的 func define
		if (strcmp(p,"NTSTATUS") == 0)
			nop();

		PCSTR pf = p;
		VarTypeID id = get_DataType(pf);
		if (id)	//	第一个量肯定是数据类型
		{
			char buf1[80];
			skip_eos(pf);
			get_1part(buf1,pf);
			enum_CallC cc = if_CallC(buf1);
			if (cc == enum_unknown)
				cc = enum_stdcall;
			else
			{
				skip_eos(pf);
				get_1part(buf1,pf);
			}
			skip_eos(pf);
			if (*pf == '(')		//	这下，肯定是func define 了
			{
				CFuncType* pnewfunc = new CFuncType;
				if (this->extern_c)
					pnewfunc->m_extern_c = TRUE;
				pnewfunc->m_callc = cc;
				pnewfunc->m_retdatatype_id = id;
				pnewfunc->m_pname = new_str(buf1);
				//this->do_func_proto
				func_define_2(pnewfunc,pf);
				g_Hpp->newfunc_addlist(pnewfunc);
				if (*pf == '{')
				{
					int n = 1;
					for (;;)
					{
						pf++;
						if (*pf == '{') n++;
						if (*pf == '}') n--;
						if (n == 0) break;
					}
				}
				else if (*pf == ';')
				{
				}
				else
					assert(0);
				pf++;
				skip_eos(pf);
				pnext = pf;