Наставьте на путь истинный

whoami · 06.04.2012, 18:01

Именно так. DLL можно внедрять и совсем без exe-загрузчика.

BritishColonist · 06.04.2012, 19:30

Да, и окно своё создать можно.
Но это относится к сложностям ;D

dwa83 · 10.04.2012, 19:09

Всё, я в истерике блин. Это закон подлости такой? Отчего клиент глючить начинает? Сидишь, минут 20 наблюдаешь - всё ОК. Только отошёл, всё крахом. На инжекты не реагирует, половина текстур начинают белыми становиться. Задержки ставил такие, что бот тупит по 5 секунд перед сбором очередной кучки. Полный ступор и непонимание.

Добавлено через 9 минут
Как узнать длину функции, если в ней присутствует ещё что-либо кроме ASM?
Например:

Код:

void __stdcall SendPacket_THREAD(PACKET* pack)
{
  DWORD Function = F_SEND_PACKET;
  DWORD len = pack->len;
  BYTE Packet[40];
  for (int i=0; i<pack->len; i++)
  Packet[i]=pack->Bytes[i];
  BYTE* Pointer=Packet;

  __asm
  {
     mov ecx, dword ptr [BA]
     mov ecx, dword ptr [ecx+0x20]
     push len
     push Pointer
     call Function
  }
}

Или можно ли как-нибудь стопануть основной поток клиента на время выполнения потока инжектируемой функции?

whoami · 11.04.2012, 10:47

Пишите функции на чистом ассемблере. Это совсем не сложно.
Стопать потоки клиента можно, но так никто не делает (будет тормозить).

BritishColonist · 11.04.2012, 14:55

dwa83, могу предложить способ найти свою функцию.
Простой, но эффективный. Заключается в следующем:
1) Ставим самой первой строкой функции команду типа PUSH 0x12345678.
2) Ищем эту такую команду в отладчике.
3) Смотрим вверх до первого NOP. Здесь будет начало функции (не включая NOP).
4) Смотрим вниз до первого NOP. Над NOP должна быть команда RET (или RETN).
Всё, байты, находящиеся между NOP'ами из 3 и 4 пунктов - код функции.
Ах да, потом нашу добавленную команду PUSH стоит удалить, а адрес функции запомнить, чтобы проверять, как она там.

whoami · 11.04.2012, 15:39

Я вот ещё что скажу, почему очень не рекомендую свои С-шные функции инжектить. Там компилятор может добавлять всевозможные обвязки (рантайм проверки, обработчики всяких нехороших ситуаций и т.д.), которые в элементе скорее всего работать не будут, а будут делать хрен знает что. В лучшем случае

Вот, например, реальный код (подцепился отладчиком, посмотрел).

Код:

0425548F  int         3    
---  -----------
void <skiped>(void*) 
{
04255490  push        ebp  
04255491  mov         ebp,esp 
04255493  push        0FFFFFFFFh 
04255495  push        offset __ehhandler$? <skipped> (42E4901h) 
0425549A  mov         eax,dword ptr fs:[00000000h] 
042554A0  push        eax  
042554A1  sub         esp,91Ch 
042554A7  mov         eax,dword ptr [___security_cookie (433AA4Ch)] 
042554AC  xor         eax,ebp 
042554AE  mov         dword ptr [ebp-64h],eax 
042554B1  push        eax  
042554B2  lea         eax,[ebp-0Ch] 
042554B5  mov         dword ptr fs:[00000000h],eax 
<skipped>
0425570E  mov         ecx,dword ptr [ebp-0Ch] 
04255711  mov         dword ptr fs:[0],ecx 
04255718  pop         ecx  
04255719  mov         ecx,dword ptr [ebp-64h] 
0425571C  xor         ecx,ebp 
0425571E  call        __security_check_cookie (428E9C1h) 
04255723  mov         esp,ebp 
04255725  pop         ebp  
04255726  ret              
--- No source file -------------------------------------------------------------

вот последний call точно обрушит процесс

dwa83 · 11.04.2012, 18:25

Цитата:

Сообщение от whoami


	Там компилятор может добавлять всевозможные обвязки (рантайм проверки, обработчики всяких нехороших ситуаций и т.д.)

Хмм, не подумал об этом, надо бы поковыряться в настройках компилятора.

Спасибо, попробую эти предложения, хорошо что хоть есть за что уцепиться чтобы косяк найти)

Добавлено через 1 час 13 минут
BritishColonist, Способом указанным вами мне почему-то не удаётся найти подобную строчку. Причём, если эту строчку вставлять в функцию-член класса, то находит. А функции для инжекта у меня указаны как независимые ни от чего отдельные функции, и в них почему-то не находит..

Пока что на пробу поставил в компиляторе режим Release(и без рунтайм библиотек и без отладочной инфы). Сейчас тестится. Так же пробую тестить не запуская из среды. Может при запуске из среды тоже что-то отладочное в функции прописывается..

Добавлено через 3 часа 30 минут
Пытаюсь записать функцию полностью на ассемблере с целью инжектить её просто в виде кода. Попробовал на примере:

Код:

void __stdcall SendPacket_THREAD(PACKET* pack)
{
  DWORD len = pack->len;
  BYTE* Pointer=pack->Bytes;
  __asm
  {
     mov ecx, dword ptr [BA]
     mov ecx, dword ptr [ecx+0x20]
     push len
     push Pointer
     mov eax, F_SEND_PACKET
     call eax
  }
}

__stdcall означает что наша функция получает параметры через стек. У нас 1 параметр - указатель на структуру(адрес структуры). Значит надо в функции получить его из стека. В структуре 4 первые байта - это параметр len, всё остальное - это данные пакета. Я пробую сделать так:

Код:

void __stdcall SendPacket_THREAD(PACKET* pack)
{
  __asm
  {
     mov ecx, dword ptr [BA]
     mov ecx, dword ptr [ecx+0x20]
     pop eax
     mov ebx, dword ptr [eax]
     push ebx
     add eax, 0x4
     push eax
     mov eax, F_SEND_PACKET
     call eax
     ret
  }
}

Вылетает. Что не так?

Добавлено через 4 часа 22 минуты
Ничего не понимаю.. Почему компилятор коверкает мою функцию? Оптимизацию вообще отключил..

Ясно пишу

Код:

void __stdcall SendPacket_THREAD()
{
  //DWORD len = pack->len;
  //BYTE* Pointer=pack->Bytes;
  __asm
  {
     mov edx,0  // будет заноситься адрес параметров
     mov ecx, dword ptr [BA]
     mov ecx, dword ptr [ecx+0x20]
     mov eax,[edx]
     push eax    // len
     add edx,4
     push edx
     mov eax, F_SEND_PACKET
     call eax
  }
}

В итоге Olly показывает

Код:

CPU Disasm
Address   Hex dump          Command                                  Comments
00401A87  /.  0D 047AB200   OR EAX,00B27A04
00401A8C  |.  8B49 20       MOV ECX,DWORD PTR DS:[ECX+20]
00401A8F  |.  8B02          MOV EAX,DWORD PTR DS:[EDX]
00401A91  |.  50            PUSH EAX
00401A92  |.  83C2 04       ADD EDX,4
00401A95  |.  52            PUSH EDX
00401A96  |.  B8 B0376700   MOV EAX,6737B0
00401A9B  |.  FFD0          CALL EAX
00401A9D  |.  5B            POP EBX
00401A9E  \.  C3            RETN

Добавлено через 7 часов 4 минуты
Пока что бот полчаса или час работает без зависов и появления артефактов. Судя по всему решение проблемы я нашёл. Если через минут 20-30 не повиснет, то теперь точно стало ясно откуда такие странные глюки клиента. Судя по всему дело не в отсутствии задержек и частых вызовах инжектов(хотя это и влияло на длительность работы без ошибок), и даже не в конфликте потоков, обращающихся одновременно к одним данным. Обвязка компилятором кода различной белибердой тоже не причина(проверял дизасм - там всё лаконично, хоть и не так как я хотел видеть). Оказывается просто напросто со временем происходила порча стека(не переполнение а наоборот) и он начинал показывать на нужные клиенту данные портя их. Это произошло вследствии использования протокола функций __stdcall без знания того, что это вообще такое. Тоесть все инжектируемые функции обязывались "почистить" за собой стек, что они и делали. Но вызывающий код использовал другой протокол обмена параметрами в функциях(в настройках проекта совсем не stdcall выставлен был). В итоге вызывающий код после выполнения инжекта ещё раз чистил уже чищеный стек. Убрал все stdkall перед фуекциями, давая тем самым компилятору использовать для вызываемой и вызывабщей функции один протокол обмена параметрами и всё

Добавлено через 20 часов 45 минут
Похоже я ошибся( глюки всё равно вылазят спустя какое то время, но не пропали( всё, вообще не понимаю что к чему..

dwa83 · 12.04.2012, 19:38

Пытаюсь, как было замечено в недостатках, оптимизировать.

Переделал инжектор чтобы он инжектил просто массив кода. Всё ли тут верно и нужно ли что-то поменять\добавить\убавить?

Код:

BYTE INJECTOR::InjectAndExecute2(void *Func, int len)
{
  HANDLE hProcThread;
  void* pFunction;

  pFunction = VirtualAllocEx(hProcess,NULL,len,MEM_COMMIT,PAGE_READWRITE);
  WriteProcessMemory(hProcess,pFunction,Func,len,NULL);
  hProcThread = CreateRemoteThread(hProcess,NULL,NULL,(LPTHREAD_START_ROUTINE)pFunction,NULL,NULL,NULL);
  if(hProcThread==INVALID_HANDLE_VALUE) // íå óäàëîñü ñîçäàòü ïîòîê
  {
    VirtualFreeEx(hProcess,pFunction,len,MEM_RELEASE);
    return 0;
  }

  WaitForSingleObject(hProcThread,INFINITE); // îæèäàåì çàâåðøåíèÿ ðàáîòû ïîòîêà
  CloseHandle(hProcThread); // îñâîáîæäàåì ïàìÿòü
  VirtualFreeEx(hProcess,pFunction,len,MEM_RELEASE); // ñòèðàåì èç ïðîöåññà íàøó ôóíêöèþ
  return 1;	// óñïåøíàÿ èíúåêöèÿ è âûïîëíåíèå êîäà
}

и инжектируемая функция

Код:

void INJECTOR::targetmob(DWORD wid)
{
  char fdata[28]="\xBF\x00\x00\x00\x00\xBB\x00\x00\x00\x00\xA1\x00\x00\x00\x00\x57\x8B\x48\x20\x81\xC1\xEC\x00\x00\x00\xFF\xD3\xC3";
  DWORD func=F_TARGET;
  DWORD ba=BA;
  memcpy(fdata+1,&wid,4);
  memcpy(fdata+6,&func,4);
  memcpy(fdata+11,&ba,4);
  InjectAndExecute2(&fdata,28);
}

BritishColonist · 12.04.2012, 21:49

stdcall - соглашение о передаче параметров. Вроде бы stdcall указывает, что порядок параметров обратный. Мы об этом вообще не задумываемся, т.к. нам эти параметры самостоятельно из стека вынимать не надо, к ним мы обращаемся просто по имени соответствующей переменной. Так что никаких pop в асме быть не должно, если это не предусмотрено инжектом.
Вряд ли дело в компиляторе, т.к. лично я никаких специальных настроек не делаю (даже если меняю конфигурацию (Debug или Release), это не вызывает никаких изменений результирующего кода ассемблера).

И в инжектах можно использовать любой код C++, можно объявлять новые переменные и т.д.
Главное - не ссылаться на то, что находится за пределами видимости данной функции.

dwa83 · 13.04.2012, 01:09

Цитата:

Сообщение от BritishColonist


	Вроде бы stdcall указывает, что порядок параметров обратный

не только это, но ещё и говорит о том, что параметры передаются через стек, а так же о том, что вызывающий код не будет чистить стек, а вызываемая функция сама должна это сделать. У меня в настройках проекта стояло cdecl - Аргументы передаются через стек, но очистку стека производит вызывающая программа. А, для примера, в соглашении fastcall вообще стек не нужен, так как через регистры передача параметров. Так что не только в порядке параметров тут дело

Но это не важно. Я вот проблему свою не знаю как решить( Сейчас все инжекты переделал, инжекчу напрямик массив кода, как посоветовали. Перед инжектом прямо в код параметры пишу, чтобы функции вообще без параметров были. Этим исключил всякие обвязки кода и тд. Проблема не исчезла. Я грешу на неправильность написания мной некорорых самонайденных инжектов, может в асме что-то пропустил перед вызовом. Заменил их всех на пакеты. Посмотрю что будет теперь..

Всё равно виснет( полчаса работы и потом виснет.. короче мне не понять..

whoami · 13.04.2012, 12:03

а ты pusha/popa делаешь?

dwa83 · 13.04.2012, 13:55

Да, но сначала не ставил, потом, когда глюки начали проявляться, везде расставил, не помогло. Хотя сейчас, когда инжектится готовый массив кода, он их в себя не включает, сейчас расставлю снова попробую.

whoami · 13.04.2012, 14:05

Вообще, возьми код из PWFramework, вместе с инжектами, там всё 100% работающее. Я думаю, перевести с c# на C++ будет не сложно.

dwa83 · 13.04.2012, 14:34

Сейчас расставил пока что во всех функциях(которые не пакетами) 0x60 (PUSHAD) и в конце перед RETN 0x61(POPAD), снова запустил, проверяю. Если опять выскочит неполадка, полезу фреймворк ковырять.

На всякий случай вод весь код инжектора, может посмотрите, кому не лень. Вдруг где ошибка.
ИНЖЕКТОР

Код:

#include <vcl.h>
#include "offsets.h"

struct PACKET
{
  int len;
  BYTE Bytes[40];
};


struct WIN_ACTION
{
  DWORD WinOffset;
  DWORD ControlOffset;
};

struct COORDS
{
  float x;
  float y;
  float z;
};

struct MOVE_PARAM
{
  COORDS coord;
  BYTE state;
};

struct LOOT_ITEM
{
  DWORD wid;
  WORD type;
};

struct CELL_ITEM
{
  DWORD id;
  DWORD CellNum;
};

struct INJECTOR
{
  HWND hwndPW;     // Õýíäë îêíà Perfect World
  DWORD pid;       // Èäåíòèôèêàòîð Ïðîöåññà
  HANDLE hProcess; // Õýíäë ïðîöåññà

  void TargetMob(DWORD wid);
  void Skill(DWORD id);
  void Move(float x, float y, float z, int walkmode);
  void Fly(DWORD FlyID);
  void CallPet(int nom);
  void GetLoot(DWORD wid, BYTE type);
  void OpenDialog(DWORD wid);
  void UseItem(DWORD id, int cell);
  void RepairAll();
  void WinAction(DWORD WinOffset, DWORD ControlOffset);
  void Sell(BYTE nomcell, DWORD kol, DWORD ID);
  void Buy(BYTE NPCcell, DWORD kol, DWORD ID);
  void Meditation();
  void PetAttack(DWORD wid);
  void PetGuard();
  void PetSkill(DWORD mobwid, DWORD skillid);
  void PetDefSkill(DWORD skillid);
  void Repair();
  void Res();
  void Print();


  BYTE InjectAndExecute(void *Func, void* Params);
  BYTE InjectAndExecute2(void *Func, int len);
  BYTE SendPacket(PACKET* pack);


  
  void StrToChar(char* str, char* mas);
};

//______________________________________________________________________________
// Èíúåêòîð ôóíêöèé
/*BYTE INJECTOR::InjectAndExecute(void *Func, void* Params)
{
  HANDLE hProcThread;
  DWORD* pFunction;
  DWORD* pParams;

  pFunction = (DWORD*)VirtualAllocEx(hProcess,NULL,511,MEM_COMMIT,PAGE_READWRITE);
  pParams = pFunction + 256;
  WriteProcessMemory(hProcess,pFunction,Func,256,NULL);
  WriteProcessMemory(hProcess,pParams,Params,255,NULL);

  hProcThread = CreateRemoteThread(hProcess,NULL,NULL,(LPTHREAD_START_ROUTINE)pFunction,pParams,NULL,NULL);
  if(hProcThread==INVALID_HANDLE_VALUE) // íå óäàëîñü ñîçäàòü ïîòîê
  {
    VirtualFreeEx(hProcess,pFunction,511,MEM_RELEASE);
    return 0;
  }

  WaitForSingleObject(hProcThread,INFINITE); // îæèäàåì çàâåðøåíèÿ ðàáîòû ïîòîêà
  CloseHandle(hProcThread); // îñâîáîæäàåì ïàìÿòü
  VirtualFreeEx(hProcess,pFunction,511,MEM_RELEASE); // ñòèðàåì èç ïðîöåññà íàøó ôóíêöèþ
  return 1;	// óñïåøíàÿ èíúåêöèÿ è âûïîëíåíèå êîäà
}   */

//______________________________________________________________________________
// Èíúåêòîð ôóíêöèé
BYTE INJECTOR::InjectAndExecute2(void *Func, int len)
{
  HANDLE hProcThread;
  void* pFunction;

  pFunction = VirtualAllocEx(hProcess,NULL,len,MEM_COMMIT,PAGE_READWRITE);
  WriteProcessMemory(hProcess,pFunction,Func,len,NULL);
  hProcThread = CreateRemoteThread(hProcess,NULL,NULL,(LPTHREAD_START_ROUTINE)pFunction,NULL,NULL,NULL);
  if(hProcThread==INVALID_HANDLE_VALUE) // íå óäàëîñü ñîçäàòü ïîòîê
  {
    VirtualFreeEx(hProcess,pFunction,len,MEM_RELEASE);
    return 0;
  }

  WaitForSingleObject(hProcThread,INFINITE); // îæèäàåì çàâåðøåíèÿ ðàáîòû ïîòîêà
  CloseHandle(hProcThread); // îñâîáîæäàåì ïàìÿòü
  VirtualFreeEx(hProcess,pFunction,len,MEM_RELEASE); // ñòèðàåì èç ïðîöåññà íàøó ôóíêöèþ
  return 1;	// óñïåøíàÿ èíúåêöèÿ è âûïîëíåíèå êîäà
}


//______________________________________________________________________________
// îòïðàâêà ïàêåòà
/*void SendPacket_THREAD(PACKET* pack)
{
  DWORD len = pack->len;
  BYTE* Pointer=pack->Bytes;
  __asm
  {
     mov ecx, dword ptr [BA]
     mov ecx, dword ptr [ecx+0x20]
     push len
     push Pointer
     mov eax, F_SEND_PACKET
     call eax
     retn
  }
}   */

BYTE INJECTOR::SendPacket(PACKET* pack)
{
  HANDLE hProcThread;
  void* pFunction;
  void* pParam;

  char fdata[29]="\x60\x8B\x0D\x00\x00\x00\x00\x8B\x49\x20\x68\x11\x11\x11\x11\x68\x22\x22\x22\x22\xB8\x33\x33\x33\x33\xFF\xD0\x61\xC3";
  int lenfunc=29;
  DWORD func=F_SEND_PACKET;
  DWORD ba=BA;
  DWORD len=pack->len;

  pParam = VirtualAllocEx(hProcess,NULL,len,MEM_COMMIT,PAGE_READWRITE);
  WriteProcessMemory(hProcess,pParam,pack->Bytes,len,NULL);

  DWORD addr=DWORD(pParam);
  memcpy(fdata+3,&ba,4);
  memcpy(fdata+11,&len,4);
  memcpy(fdata+16,&addr,4);
  memcpy(fdata+21,&func,4);

  pFunction = VirtualAllocEx(hProcess,NULL,lenfunc,MEM_COMMIT,PAGE_READWRITE);
  WriteProcessMemory(hProcess,pFunction,fdata,lenfunc,NULL);


  hProcThread = CreateRemoteThread(hProcess,NULL,NULL,(LPTHREAD_START_ROUTINE)pFunction,NULL,NULL,NULL);
  if(hProcThread==INVALID_HANDLE_VALUE) // íå óäàëîñü ñîçäàòü ïîòîê
  {
    VirtualFreeEx(hProcess,pFunction,lenfunc,MEM_RELEASE);
    VirtualFreeEx(hProcess,pParam,len,MEM_RELEASE);
    return 0;
  }

  WaitForSingleObject(hProcThread,INFINITE); // îæèäàåì çàâåðøåíèÿ ðàáîòû ïîòîêà
  CloseHandle(hProcThread); // îñâîáîæäàåì ïàìÿòü
  VirtualFreeEx(hProcess,pFunction,lenfunc,MEM_RELEASE); // ñòèðàåì èç ïðîöåññà íàøó ôóíêöèþ
  VirtualFreeEx(hProcess,pParam,len,MEM_RELEASE);
  return 1;	// óñïåøíàÿ èíúåêöèÿ è âûïîëíåíèå êîäà
}


//______________________________________________________________________________
// Òàðãåò ìîáà ïî WID
/*void INJECTOR::TargetMob(DWORD wid)
{
  char fdata[28]="\xBF\x00\x00\x00\x00\xBB\x00\x00\x00\x00\xA1\x00\x00\x00\x00\x57\x8B\x48\x20\x81\xC1\xEC\x00\x00\x00\xFF\xD3\xC3";
  DWORD func=F_TARGET;
  DWORD ba=BA;
  memcpy(fdata+1,&wid,4);
  memcpy(fdata+6,&func,4);
  memcpy(fdata+11,&ba,4);
  InjectAndExecute2(&fdata,28);
}  */

void INJECTOR::TargetMob(DWORD wid)
{
  PACKET pack;
  pack.len=6;
  char Packet[6] = "\x02\x00\x01\x00\x00\x00";
  memcpy(pack.Bytes,Packet,pack.len);
  memcpy(pack.Bytes+2,&wid,4);
  SendPacket(&pack);
}


//______________________________________________________________________________
// Èñïîëüçîâàíèå ñêèëëà ïî ID
void INJECTOR::Skill(DWORD id)
{
  char fdata[39]="\x60\x6A\xFF\x6A\x00\x6A\x00\x68\x00\x00\x00\x00\x8B\x0D\x00\x00\x00\x00\x8B\x89\x00\x00\x00\x00\x8B\x89\x00\x00\x00\x00\xB8\x00\x00\x00\x00\xFF\xD0\x61\xC3";

  DWORD func=F_SKILL;
  DWORD ba=BA;
  DWORD dga=D_GA;
  DWORD ps=PERS_STRUCT;

  memcpy(fdata+8,&id,4);
  memcpy(fdata+14,&ba,4);
  memcpy(fdata+20,&dga,4);
  memcpy(fdata+26,&ps,4);
  memcpy(fdata+31,&func,4);
  InjectAndExecute2(&fdata,39);
}


//______________________________________________________________________________
// Ïåðåìåùåíèå â êîîðäèíàòû
void INJECTOR::Move(float x, float y, float z, int walkmode)
{
  char fdata[117]="\x60\xA1\x00\x00\x00\x00\x8B\xB0\x11\x11\x11\x11\x8B\x8E\x22\x22\x22\x22\x6A\x01\xBB\x33\x33\x33\x33\xFF\xD3\x89\xC7\x8D\x44\xE4\x0C\x50\x68\x44\x44\x44\x44\x89\xF9\xBB\x55\x55\x55\x55\xFF\xD3\x8B\x8E\x66\x66\x66\x66\x6A\x00\x6A\x01\x57\x6A\x01\xBB\x77\x77\x77\x77\xFF\xD3\xA1\x88\x88\x88\x88\x8B\x80\x99\x99\x99\x99\x8B\x80\xAA\xAA\xAA\xAA\x8B\x40\x30\x8B\x48\x04\xB8\xBB\xBB\xBB\xBB\x89\x41\x20\xB8\xCC\xCC\xCC\xCC\x89\x41\x24\xB8\xDD\xDD\xDD\xDD\x89\x41\x28\x61\xC3";
  DWORD func1=F_MOVE1;
  DWORD func2=F_MOVE2;
  DWORD func3=F_MOVE3;
  DWORD ga=GA;
  DWORD ps=PERS_STRUCT;
  DWORD maa=MY_ACTION_ARRAY;
  DWORD wmode=1; if (walkmode==0) wmode=0;


  memcpy(fdata+2,&ga,4);
  memcpy(fdata+8,&ps,4);
  memcpy(fdata+14,&maa,4);
  memcpy(fdata+21,&func1,4);
  memcpy(fdata+35,&wmode,4);
  memcpy(fdata+42,&func2,4);
  memcpy(fdata+50,&maa,4);
  memcpy(fdata+62,&func3,4);
  memcpy(fdata+69,&ga,4);
  memcpy(fdata+75,&ps,4);
  memcpy(fdata+81,&maa,4);
  memcpy(fdata+92,&x,4);
  memcpy(fdata+100,&z,4);
  memcpy(fdata+108,&y,4);
  
  InjectAndExecute2(&fdata,117);
}

//______________________________________________________________________________
// Âêëþ÷åíèå/âûêëþ÷åíèå ïîë¸òà
/*void INJECTOR::Fly(DWORD FlyID)
{
  char fdata[33]="\x6A\x01\x68\x00\x00\x00\x00\xA1\x00\x00\x00\x00\x8B\x48\x20\x6A\x0C\x6A\x01\x81\xC1\xEC\x00\x00\x00\xBB\x00\x00\x00\x00\xFF\xD3\xC3";
  DWORD func=F_FLY;
  DWORD ba=BA;
  memcpy(fdata+3,&FlyID,4);
  memcpy(fdata+8,&ba,4);
  memcpy(fdata+26,&func,4);
  InjectAndExecute2(&fdata,33);
}     */

void INJECTOR::Fly(DWORD FlyID)
{
  PACKET pack;
  pack.len=10;
  char Packet[10] = "\x28\x00\x01\x01\x0C\x00\xF7\x31\x00\x00";
  memcpy(pack.Bytes,Packet,pack.len);
  memcpy(pack.Bytes+6,&FlyID,4);
  SendPacket(&pack);
}

//______________________________________________________________________________
// Âûçîâ ïåòà èç ÿ÷åéêè
/*void INJECTOR::CallPet(int nom)
{
  char fdata[38]="\x8B\x0D\x00\x00\x00\x00\xB8\x00\x00\x00\x00\x8B\x91\x11\x11\x11\x11\x8B\x8A\x22\x22\x22\x22\x8B\x91\x33\x33\x33\x33\x50\xBB\x44\x44\x44\x44\xFF\xD3\xC3";
  DWORD func=F_CALL_PET;
  DWORD ba=BA;
  DWORD dga=D_GA;
  DWORD prs=PERS_STRUCT;
  DWORD pts=PET_STRUCT;
  memcpy(fdata+2,&ba,4);
  memcpy(fdata+7,&nom,4);
  memcpy(fdata+13,&dga,4);
  memcpy(fdata+19,&prs,4);
  memcpy(fdata+25,&pts,4);
  memcpy(fdata+31,&func,4);
  InjectAndExecute2(&fdata,38);
} */

void INJECTOR::CallPet(int nom)
{
  PACKET pack;
  pack.len=6;
  char PacketSell[6] = "\x64\x00\x01\x00\x00\x00";
  memcpy(pack.Bytes,PacketSell,pack.len);
  pack.Bytes[2]=nom;
  SendPacket(&pack);
}

//______________________________________________________________________________
// Ïîäáîð ëóòà/øàõòû ïî WID
void INJECTOR::GetLoot(DWORD wid, BYTE type)
{
  char fdata[29]="\x60\x8B\x0D\x00\x00\x00\x00\x8B\x89\x11\x11\x11\x11\x6A\x22\x68\x33\x33\x33\x33\xBB\x44\x44\x44\x44\xFF\xD3\x61\xC3";
  DWORD func=F_GET_LOOT;
  DWORD ga=GA;
  DWORD prs=PERS_STRUCT;
  BYTE typ=0; if (type==2) typ=1;
  memcpy(fdata+3,&ga,4);
  memcpy(fdata+9,&prs,4);
  fdata[14]=typ;
  memcpy(fdata+16,&wid,4);
  memcpy(fdata+21,&func,4);
  InjectAndExecute2(&fdata,29);
}

/*void INJECTOR::GetLoot(DWORD wid, DWORD id)
{
  PACKET pack;
  pack.len=10;
  char PacketSell[10] = "\x06\x00\xDD\x51\x12\xC0\x0B\x03\x00\x00";
  memcpy(pack.Bytes,PacketSell,pack.len);
  memcpy(pack.Bytes+2,&wid,4);
  memcpy(pack.Bytes+6,&id,4);
  SendPacket(&pack);
}     */

//______________________________________________________________________________
// Îòêðûòèå äèàëîãà ñ ÍÏÑ ïî WID
void INJECTOR::OpenDialog(DWORD wid)
{
  char fdata[30]="\x60\x8B\x15\x00\x00\x00\x00\x8B\x4A\x20\x68\x11\x11\x11\x11\x81\xC1\xEC\x00\x00\x00\xBB\x22\x22\x22\x22\xFF\xD3\x61\xC3";
  DWORD func=F_DIALOG;
  DWORD ba=BA;
  memcpy(fdata+3,&ba,4);
  memcpy(fdata+11,&wid,4);
  memcpy(fdata+22,&func,4);
  InjectAndExecute2(&fdata,30);
}

//______________________________________________________________________________
// Èñïîëüçîâàíèå ïðåäìåòà
/*void INJECTOR::UseItem(DWORD id, int cell)
{
  char fdata[37]="\x6A\x01\x68\x00\x00\x00\x00\x68\x11\x11\x11\x11\x6A\x00\x8B\x0D\x22\x22\x22\x22\x8B\x49\x20\x81\xC1\xEC\x00\x00\x00\xBB\x33\x33\x33\x33\xFF\xD3\xC3";
  DWORD func=F_USE_ITEM;
  DWORD ba=BA;
  memcpy(fdata+3,&id,4);
  memcpy(fdata+8,&cell,4);
  memcpy(fdata+16,&ba,4);
  memcpy(fdata+30,&func,4);
  InjectAndExecute2(&fdata,37);
}    */

void INJECTOR::UseItem(DWORD id, int cell)
{
  PACKET pack;
  pack.len=10;
  char PacketSell[10] = "\x28\x00\x00\x01\x0D\x00\xAD\x21\x00\x00";
  memcpy(pack.Bytes,PacketSell,pack.len);
  pack.Bytes[4] = cell;     // íîìåð ÿ÷åéêè
  memcpy(pack.Bytes+6,&id,4);
  SendPacket(&pack);
}


//______________________________________________________________________________
// Çàêðûòèå îêíà
void INJECTOR::WinAction(DWORD WinOffset, DWORD ControlOffset)
{
  char fdata[38]="\x61\xA1\x00\x00\x00\x00\x8B\x40\x1C\x8B\x40\x18\x8B\x40\x08\xBB\x11\x11\x11\x11\x8B\x04\x03\x50\x68\x22\x22\x22\x22\xBA\x33\x33\x33\x33\xFF\xD2\x60\xC3";
  DWORD func=F_WIN_ACTION;
  DWORD ba=BA;
  memcpy(fdata+2,&ba,4);
  memcpy(fdata+16,&WinOffset,4);
  memcpy(fdata+25,&ControlOffset,4);
  memcpy(fdata+30,&func,4);
  InjectAndExecute2(&fdata,38);
}

void INJECTOR::Sell(BYTE nomcell, DWORD kol, DWORD ID)
{
  PACKET pack;
  pack.len=26;
  char PacketSell[26] = "\x25\x00\x02\x00\x00\x00\x10\x00\x00\x00\x01\x00\x00\x00\xFF\xFF\x00\x00\xFF\x00\x00\x00\xD0\x07\x00\x00";
  memcpy(pack.Bytes,PacketSell,pack.len);
  pack.Bytes[18] = nomcell;     // 18 - íîìåð ÿ÷åéêè
  memcpy(pack.Bytes+22,&kol,4); // 22-25 - êîëè÷åñòâî
  memcpy(pack.Bytes+14,&ID,4);  //  14-17 - ID ïðåäìåòà
  SendPacket(&pack);
}

void INJECTOR::Buy(BYTE NPCcell, DWORD kol, DWORD ID)
{
  PACKET pack;
  pack.len=38;
  char PacketSell[38] = "\x25\x00\x01\x00\x00\x00\x1C\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\xAA\xAA\xAA\xAA\xBB\x00\x00\x00\xCC\xCC\xCC\xCC";
  memcpy(pack.Bytes,PacketSell,pack.len);
  pack.Bytes[30] = NPCcell;     // 30 - íîìåð ÿ÷åéêè
  memcpy(pack.Bytes+34,&kol,4); // 34-27 - êîëè÷åñòâî
  memcpy(pack.Bytes+26,&ID,4);  //  26-29 - ID ïðåäìåòà
  SendPacket(&pack);
}

void INJECTOR::Meditation()
{
  PACKET pack;
  pack.len=2;
  char Packet[2] = PACK_MEDITATION;
  memcpy(pack.Bytes,Packet,pack.len);
  SendPacket(&pack);
}

void INJECTOR::PetAttack(DWORD wid)
{
  PACKET pack;
  pack.len=11;
  char Packet[11] = "\x67\x00\x00\x00\x00\x80\x01\x00\x00\x00\x00";
  memcpy(pack.Bytes,Packet,pack.len);
  memcpy(pack.Bytes+2,&wid,4); // 4 áàéòà, íà÷èíàÿ ñ 2 - WID ìîíñòðà
  SendPacket(&pack);
}

void INJECTOR::Repair()
{
  PACKET pack;
  pack.len=16;
  char Packet[16] = "\x25\x00\x03\x00\x00\x00\x06\x00\x00\x00\xFF\xFF\xFF\xFF\x00\x00";
  memcpy(pack.Bytes,Packet,pack.len);
  SendPacket(&pack);
}

void INJECTOR::Res()
{
  PACKET pack;
  pack.len=2;
  char Packet[2] = "\x04\x00";
  memcpy(pack.Bytes,Packet,pack.len);
  SendPacket(&pack);
}

void INJECTOR::PetGuard()
{
  PACKET pack;
  pack.len=14;
  char Packet[14] = "\x67\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00";
  memcpy(pack.Bytes,Packet,pack.len);
  SendPacket(&pack);
}

void INJECTOR::PetSkill(DWORD mobwid, DWORD skillid)
{
  PACKET pack;
  pack.len=15;
  char Packet[15] = "\x67\x00\x38\x15\x10\x80\x04\x00\x00\x00\xED\x02\x00\x00\x00";
  memcpy(pack.Bytes,Packet,pack.len);
  memcpy(pack.Bytes+2,&mobwid,4); 
  memcpy(pack.Bytes+10,&skillid,4);
  SendPacket(&pack);
}

void INJECTOR::PetDefSkill(DWORD skillid)
{
  PACKET pack;
  pack.len=14;
  char Packet[14] = "\x67\x00\x00\x00\x00\x00\x05\x00\x00\x00\xF1\x02\x00\x00";
  memcpy(pack.Bytes,Packet,pack.len);
  memcpy(pack.Bytes+10,&skillid,4);
  SendPacket(&pack);
}

Кстати, половина функций закомментировано /* */, но форум это не показывает

Добавлено через 7 часов 20 минут
Посмотрел я фреймворк для c#, всё совершенно равнозначно, кроме одного. Автор перед каждым инжектом открывает доступ к процессу, а после закрывает

Код:

       // Получаем дескриптор процесса, выбранного клиента PW и открываем память для чтения / записи
            if (window != null) MemoryManager.OpenProcess(window.ProcessId);

            // Отправляем пакет на медитацию
            SendPacket(MemoryManager.OpenProcessHandle, new byte[] { 0x2e, 0x00 });

            // Закрываем дескриптор процесса
            MemoryManager.CloseProcess();

У мнея же процесс открывается один раз вначале подключения бота к клиенту и закрывается по окончанию работы. Может в этом моя ошибка, и во время работы бота у процесса клиента меняется пид или хэндл или ещё что? Сделаю как у автора PWFramework. Если не поможет, наверное единственным выходом будет признать полную свою криворукость, сойти с ума, забиться в угол, изредка подрыгивая ногой)))

Добавлено через 19 часов 58 минут
Переделал всё нафиг, полностью) Теперь в главном модуле достаточно обьявить структуру типа BOT bot и с помощью неё делать всё что угодно, например:
bot.client.init(); // поиск-нашего процесса и инициализация некоторых параметров
int HP = bot.client.get.myHP(); // так слизываются все значения с клиента
bot.client.inject.TargetMob();

так же переделал нафиг всю логику. теперь можно просто включить режим
bot.st.action=A_SWITCHER
и этот режим в зависимости от полученых с клиента данных переключает различные режимы в зависимости от приоритета.

например, внутри режима свитчера идёт сохранение в специально созданный для этого стек значения текущего режима и может быть включен другой типа
bot.st.push(); // сохранили режим в стек, чтобы по окончанию следующего вернуться в этот
bot.st.action=A_GOTO_FARM; // включает режим перемещения к точке фарма(из него идёт переключение на другие режимы в зависимости от ситуации, например режим всплытия, взлёта, и возврат к предыдущему режиму)

по окончании действия можно вернуться в предыдущий режим, даже не зная какой он был, просто указав
bot.st.pop();
В итоге бот ведёт себя нелинейно, и выбирает действия по мере требования а не по какому либо порядку.

PS: А клиен как переставал реагировать, так и перестаёт

Так и выходит, что получилось то всё неплохо, но бесполезно

dwa83 · 15.04.2012, 06:10

Цитата:

Сообщение от whoami


	на каждый вызов делать VirtualAllocEx

Дурная моя голова и слепые глаза

Моя невнимательность меня подводит. Проблема заключалась в том, что я при каждом инжекте так и делал, но после определённого промежутка времени (20-30мин) VirtualAllocEx начинала отказы в выделении памяти. А, ввиду того, что проверок на ошибки в коде нет вообще, инжект писался хз куда, в NULL

. Плюс к этому дальше шло ещё и освобождение памяти по NULL, итого вообще полный ппц. Теперь сделал выделение памяти один раз, при инициализации. Пока что работает вроде бы, но с моей внимательностью может ещё что всплывёт.

Наставьте на путь истинный

Общение разработчиков