Gaming/CheatEngine/Portable/App/ProgramFiles/plugins/cepluginsdk.pas

unit cepluginsdk;        //more an api than sdk

{$MODE Delphi}

interface

uses windows, sysutils;

type
  TColor=dword;
  PColor=^TColor;

{$ifndef fpc}
//if old delphi then define the ptruint type
type ptruint=dword;
type pptruint=^ptruint'
{$endif}

const PluginVersionSDK=6;

type TAutoAssemblerPhase=(aaInitialize=0, aaPhase1=1, aaPhase2=2, aaFinalize=3);
type TPluginType=(ptAddressList=0, ptMemoryView=1, ptOnDebugEvent=2, ptProcesswatcherEvent=3, ptFunctionPointerchange=4, ptMainMenu=5, ptDisassemblerContext=6, ptDisassemblerRenderLine=7, ptAutoAssembler=8);

type TDWordArray = array[0..0] of DWord;
     PDWordArray = ^TDWordArray;

type
  TContinueOption = (co_run=0, co_stepinto=1, co_stepover=2, co_runtill=3);

type
  TBreakpointMethod = (bpmInt3, bpmDebugRegister);

type
  TBreakOption = (bo_Break = 0, bo_ChangeRegister = 1, bo_FindCode = 2, bo_FindWhatCodeAccesses = 3, bo_BreakAndTrace=4);
  TBreakPointAction = TBreakOption;

type
  TBreakpointTrigger = (bptExecute=0, bptAccess=1, bptWrite=2);

type
  tregistermodificationBP32 = record
    address: uint_ptr; //addres to break on
    change_eax: BOOL;
    change_ebx: BOOL;
    change_ecx: BOOL;
    change_edx: BOOL;
    change_esi: BOOL;
    change_edi: BOOL;
    change_ebp: BOOL;
    change_esp: BOOL;
    change_eip: BOOL;
    change_cf: BOOL;
    change_pf: BOOL;
    change_af: BOOL;
    change_zf: BOOL;
    change_sf: BOOL;
    change_of: BOOL;
    new_eax: dword;
    new_ebx: dword;
    new_ecx: dword;
    new_edx: dword;
    new_esi: dword;
    new_edi: dword;
    new_ebp: dword;
    new_esp: dword;
    new_eip: dword;
    new_cf: BOOL;
    new_pf: BOOL;
    new_af: BOOL;
    new_zf: BOOL;
    new_sf: BOOL;
    new_of: BOOL;
  end;

type
  PRegisterModificationBP32 = ^TRegisterModificationBP32;

type
  tregistermodificationBP64 = record
    address: uint_ptr; //addres to break on
    change_eax: BOOL;
    change_ebx: BOOL;
    change_ecx: BOOL;
    change_edx: BOOL;
    change_esi: BOOL;
    change_edi: BOOL;
    change_ebp: BOOL;
    change_esp: BOOL;
    change_eip: BOOL;
    change_r8: BOOL;
    change_r9: BOOL;
    change_r10: BOOL;
    change_r11: BOOL;
    change_r12: BOOL;
    change_r13: BOOL;
    change_r14: BOOL;
    change_r15: BOOL;
    change_cf: BOOL;
    change_pf: BOOL;
    change_af: BOOL;
    change_zf: BOOL;
    change_sf: BOOL;
    change_of: BOOL;
    new_eax: ptrUint;
    new_ebx: ptrUint;
    new_ecx: ptrUint;
    new_edx: ptrUint;
    new_esi: ptrUint;
    new_edi: ptrUint;
    new_ebp: ptrUint;
    new_esp: ptrUint;
    new_eip: ptrUint;
    new_r8: ptrUint;
    new_r9: ptrUint;
    new_r10: ptrUint;
    new_r11: ptrUint;
    new_r12: ptrUint;
    new_r13: ptrUint;
    new_r14: ptrUint;
    new_r15: ptrUint;
    new_cf: BOOL;
    new_pf: BOOL;
    new_af: BOOL;
    new_zf: BOOL;
    new_sf: BOOL;
    new_of: BOOL;
  end;

type
  PRegisterModificationBP64 = ^TRegisterModificationBP64;

{$ifdef CPU64}
type
  TRegisterModificationBP = TRegisterModificationBP64;

type
  PRegisterModificationBP = PRegisterModificationBP64;
{$else}
type
  TRegisterModificationBP = TRegisterModificationBP32;

type
  PRegisterModificationBP = PRegisterModificationBP32;
{$endif}


 type TSelectedRecord=record
   interpretedaddress: pchar; //pointer to a 255 bytes long string (0 terminated)
   address: ptruint; //this is a read-only representaion of the address. Change interpretedaddress if you want to change this
   ispointer: boolean;
   countoffsets: integer;
   offsets: PDWordArray; //pointer to a array of dwords randing from 0 to countoffsets-1
   description: pchar; //pointer to a 255 bytes long string
   valuetype: byte;
   size: byte; //stringlenth or bitlength (max 255);
 end;
 type PSelectedRecord=^TSelectedRecord;


 //callback function declarations:
 type TPlugin0_SelectedRecord=record
   interpretedaddress: pchar; //pointer to a 255 bytes long string (0 terminated)
   address: dword; //this is a read-only representaion of the address. Change interpretedaddress if you want to change this
   ispointer: BOOL; //readonly
   countoffsets: integer; //readonly
   offsets: PDWordArray; //pointer to a array of dwords randing from 0 to countoffsets-1 (readonly)
   description: pchar; //pointer to a 255 bytes long string
   valuetype: byte;
   size: byte; //stringlenth or bitlength (max 255);
 end;
 type PPlugin0_SelectedRecord=^TPlugin0_SelectedRecord;
 type TPluginfunction0=function(selectedrecord: PPlugin0_SelectedRecord):bool; stdcall;
 type TPluginfunction1=function(disassembleraddress: pptruint; selected_disassembler_address: pptruint; hexviewaddress:pptruint ):bool; stdcall;
 type TPluginFunction2=function(debugevent: PDebugEvent):integer; stdcall;
 type TPluginFunction3=function(processid: dword; peprocess:ptruint; created: BOOL):integer; stdcall;
 type TPluginFunction4=function(section: integer):boolean; stdcall;
 type TPluginfunction5=procedure; stdcall;
 type TPluginfunction6OnPopup=function(selectedAddress: ptruint; addressofname: pointer; show: pbool):bool; stdcall;
 type TPluginfunction6=function(selectedAddress: pptruint):bool; stdcall;
 type TPluginFunction7=procedure(address: ptruint; addressStringPointer: pointer; bytestringpointer: pointer; opcodestringpointer: pointer; specialstringpointer: pointer; textcolor: PColor); stdcall;
 type TPluginFunction8=procedure(line: ppchar; phase: TAutoAssemblerPhase; id:integer); stdcall;


type Tfunction0=record
  name: pchar;
  callbackroutine: pointer;
end;
type Tfunction1=record
  name: pchar;
  callbackroutine: TPluginfunction1;
  shortcut: pchar;
end;
type Tfunction2=record
  callbackroutine: pointer;
end;
type Tfunction6=record
  name: pchar;
  callbackroutine: pointer;
  callbackroutineOnContext: pointer;
  shortcut: pchar;
end;
type TFunction3=TFunction2;
type TFunction4=TFunction2;
type TFunction5=record
  name: pchar;
  callbackroutine: TPluginfunction5;
  shortcut: pchar;
end;
type TFunction7=TFunction2;
type TFunction8=TFunction2;


type PFunction0=^TFunction0;
type PFunction1=^TFunction1;
type PFunction2=^TFunction2;
type PFunction3=^TFunction3;
type PFunction4=^TFunction4;
type PFunction5=^TFunction5;
type PFunction6=^TFunction6;
type PFunction7=^TFunction7;
type PFunction8=^TFunction8;

type Tce_showmessage=procedure (s: pchar); stdcall;
type Tce_registerfunction=function (pluginid: integer; functiontype:TPluginType; init: pointer):integer; stdcall;
type Tce_unregisterfunction=function (pluginid,functionid: integer): BOOL; stdcall;
type Tce_AutoAssembler=function (s: pchar):BOOL; stdcall;
type Tce_assembler=function(address:ptruint; instruction: pchar; output: PByteArray; maxlength: integer; actualsize: pinteger):BOOL; stdcall;
type Tce_disassembler=function(address: ptruint; output: pchar; maxsize: integer): BOOL; stdcall;


type Tce_ChangeRegistersAtAddress=function(address:ptruint; changereg: pregistermodificationBP):BOOL; stdcall;

type Tce_InjectDLL=function(dllname: pchar; functiontocall: pchar):BOOL; stdcall;

type Tce_freezemem= function (address: ptruint; size: integer):integer; stdcall;
type Tce_unfreezemem =function (id: integer):BOOL; stdcall;
//type Tce_fixmem=function:BOOL; stdcall; //obsolete, don't use it
type Tce_processlist=function(listbuffer: pchar; listsize: integer):BOOL; stdcall;
type Tce_reloadsettings=function:BOOL; stdcall;
type Tce_getaddressfrompointer=function(baseaddress: ptruint; offsetcount: integer; offsets: PDwordArray):dword; stdcall;


type Tce_generateAPIHookScript=function(address, addresstojumpto, addresstogetnewcalladdress, script: pchar; maxscriptsize: integer): BOOL; stdcall;
type Tce_sym_addressToName=function(address:ptruint; name: pchar; maxnamesize: integer):BOOL; stdcall;
type Tce_sym_nameToAddress=function(name: pchar; address: Pptruint):BOOL; stdcall;


type Tce_GetMainWindowHandle=function:thandle; stdcall;

type TReadProcessMemory=function (hProcess: THandle; const lpBaseAddress: Pointer; lpBuffer: Pointer;
  nSize: DWORD; var lpNumberOfBytesRead: DWORD): BOOL; stdcall;

type TWriteProcessMemory=function (hProcess: THandle; const lpBaseAddress: Pointer; lpBuffer: Pointer;
  nSize: DWORD; var lpNumberOfBytesWritten: DWORD): BOOL; stdcall;

type TGetProcessNameFromPEProcess=function(peprocess:ptruint; buffer:pchar;buffersize:dword):integer; stdcall;
type TOpenProcess=function(dwDesiredAccess: DWORD; bInheritHandle: BOOL; dwProcessId: DWORD): THandle; stdcall;


type TLoadDBK32=procedure; stdcall;
type TLoadDBVMifneeded=function: BOOL; stdcall;
type TPreviousOpcode=function(address:ptruint): dword; stdcall;
type TNextOpcode=function(address:ptruint): dword; stdcall;
type TloadModule=function(modulepath: pchar; exportlist: pchar; maxsize: pinteger): BOOL; stdcall;
type TDisassembleEx=function(address: pptruint; output: pchar; maxsize: integer): BOOL; stdcall;
type Taa_AddExtraCommand=procedure(command:pchar);
type Taa_RemoveExtraCommand=procedure(command:pchar);



//version 4 functiontype declarations
type TcreateTableEntry=function: pointer; stdcall;
type TgetTableEntry=function(description: pchar): pointer; stdcall;
type Tmemrec_setDescription=function(memrec: pointer; description: pchar): BOOL; stdcall;
type Tmemrec_getDescription=function(memrec: pointer): pchar; stdcall;
type Tmemrec_getAddress=function(memrec: pointer; address: pptruint; offsets: PDwordArray; maxoffsets: integer; neededOffsets: pinteger): BOOL; stdcall;
type Tmemrec_setAddress=function(memrec: pointer; address: pchar; offsets: PDwordArray; offsetcount: integer): BOOL; stdcall;
type Tmemrec_getType=function(memrec: pointer): integer; stdcall;
type Tmemrec_setType=function(memrec: pointer; vtype: integer): BOOL; stdcall;
type Tmemrec_getValue=function(memrec: pointer; value: pchar; maxsize: integer): BOOL; stdcall;
type Tmemrec_setValue=function(memrec: pointer; value: pchar): BOOL; stdcall;
type Tmemrec_getScript=function(memrec: pointer): pchar; stdcall;
type Tmemrec_setScript=function(memrec: pointer; script: pchar): BOOL; stdcall;
type Tmemrec_isFrozen=function(memrec: pointer): BOOL; stdcall;
type Tmemrec_freeze=function(memrec: pointer; direction: integer): BOOL; stdcall;
type Tmemrec_unfreeze=function(memrec: pointer): BOOL; stdcall;
type Tmemrec_setColor=function(memrec: pointer; color: TColor): BOOL; stdcall;
type Tmemrec_appendtoentry=function(memrec1: pointer; memrec2: pointer): BOOL; stdcall;
type Tmemrec_delete=function(memrec: pointer): BOOL; stdcall;
type TgetProcessIDFromProcessName=function(name: pchar): DWORD; stdcall;
type TopenProcessex=function(pid: dword): BOOL; stdcall;
type TdebugProcessex=function(debuggerinterface: integer): BOOL; stdcall;
type Tpause=procedure; stdcall;
type Tunpause=procedure; stdcall;

type Tdebug_setBreakpoint=function(address: ptruint; size: integer; trigger: TBreakpointTrigger): BOOL; stdcall;
type Tdebug_removeBreakpoint=function(address: ptruint): BOOL; stdcall;
type Tdebug_continueFromBreakpoint=function(ContinueOption: TContinueOption): BOOL; stdcall;

type TcloseCE=procedure; stdcall;
type ThideAllCEWindows=procedure; stdcall;
type TunhideMainCEwindow=procedure; stdcall;
type TcreateForm=function(visible: boolean): pointer; stdcall;
type Tform_centerScreen=procedure(f: pointer); stdcall;
type Tform_hide=procedure(f: pointer); stdcall;
type Tform_show=procedure(f: pointer); stdcall;
type Tform_onClose=procedure(frm: pointer; f: pointer); stdcall;

type TcreatePanel=function(owner: pointer): pointer; stdcall;
type TcreateGroupBox=function(owner: pointer): pointer; stdcall;
type TcreateButton=function(owner: pointer): pointer; stdcall;
type TcreateImage=function(owner: pointer): pointer; stdcall;
type Timage_loadImageFromFile=function(image: pointer; filename: pchar): BOOL; stdcall;
type Timage_transparent=procedure(image: pointer; transparent: boolean); stdcall;
type Timage_stretch=procedure(image: pointer; stretch: boolean); stdcall;

type TcreateLabel=function(owner: pointer): pointer; stdcall;
type TcreateEdit=function(owner: pointer): pointer; stdcall;
type TcreateMemo=function(owner: pointer): pointer; stdcall;
type TcreateTimer=function(owner: pointer): pointer; stdcall;
type Ttimer_setInterval=procedure(timer: pointer; interval: integer); stdcall;
type Ttimer_onTimer=procedure(t: pointer; f: pointer); stdcall;
type Tcontrol_setCaption=procedure(control: pointer; caption: pchar); stdcall;
type Tcontrol_getCaption=function(control: pointer; caption: pchar; maxsize: integer): BOOL; stdcall;
type Tcontrol_setPosition=procedure(control: pointer; x,y: integer); stdcall;
type Tcontrol_getX=function(control: pointer): integer; stdcall;
type Tcontrol_getY=function(control: pointer): integer; stdcall;
type Tcontrol_setSize=procedure(control: pointer; width,height: integer); stdcall;
type Tcontrol_getWidth=function(control: pointer): integer; stdcall;
type Tcontrol_getHeight=function(control: pointer): integer; stdcall;
type Tcontrol_setAlign=procedure(control: pointer; align: integer); stdcall;
type Tcontrol_onClick=procedure(c: pointer; f: pointer); stdcall;

type Tobject_destroy=procedure(o: pointer); stdcall;
type TmessageDialog=function(message: pchar; messagetype: integer; buttoncombination: integer): integer; stdcall;
type Tspeedhack_setSpeed=function(speed: single): BOOL; stdcall;

type TUserdefinedInterruptHook=function(interruptnr: integer; newCS: word; newEIP: system.qword; addressofjumpback: system.qword):boolean; stdcall;
type TExecuteKernelCode=function(address: system.qword; parameters: system.qword): BOOL; stdcall;
type TGetLoadedState=function: BOOLEAN; stdcall;
type TGetLuaState=function: pointer; stdcall;

type TPluginFunc=function(parameters: pointer): pointer; //note, no stdcall. It's a "pascal" calling convention
type TMainThreadCall=function(func: TPluginFunc; parameters: pointer): pointer; stdcall;

type TPluginVersion =record
  version : integer; //write here the minimum version this dll is compatible with
  pluginname: pchar;  //make this point to a 0-terminated string (allocated memory, not stack)
end;



type TExportedFunctions = record
  sizeofTExportedFunctions: integer;
  showmessage: Tce_showmessage;
  registerfunction: Tce_registerfunction;
  unregisterfunction: Tce_unregisterfunction;
  OpenedProcessID: ^dword;
  OpenedProcessHandle: ^thandle;

  GetMainWindowHandle: pointer;
  AutoAssemble: Tce_AutoAssembler;
  //this is just an example plugin, fill theswe missing function pointers in yourself ok...
  assembler: Tce_assembler;
  disassembler: Tce_disassembler;
  ChangeRegistersAtAddress: Tce_ChangeRegistersAtAddress;
  InjectDLL: Tce_InjectDLL;
  freezemem: Tce_freezemem;
  unfreezemem: Tce_unfreezemem;
  fixmem: pointer;
  processlist: Tce_processlist;
  reloadsettings: Tce_reloadsettings;
  getaddressfrompointer: Tce_getaddressfrompointer;

  //pointers to the address that contains the pointers to the functions
  ReadProcessMemory     :ppointer;
  WriteProcessMemory    :ppointer;
  GetThreadContext      :ppointer;
  SetThreadContext      :ppointer;
  SuspendThread         :ppointer;
  ResumeThread          :ppointer;
  OpenProcess           :ppointer;
  WaitForDebugEvent     :ppointer;
  ContinueDebugEvent    :ppointer;
  DebugActiveProcess    :ppointer;
  StopDebugging         :ppointer;
  StopRegisterChange    :ppointer;
  VirtualProtect        :ppointer;
  VirtualProtectEx      :ppointer;
  VirtualQueryEx        :ppointer;
  VirtualAllocEx        :ppointer;
  CreateRemoteThread    :ppointer;
  OpenThread            :ppointer;
  GetPEProcess          :ppointer;
  GetPEThread           :ppointer;
  GetThreadsProcessOffset:ppointer;
  GetThreadListEntryOffset:ppointer;
  GetProcessnameOffset  :ppointer;
  GetDebugportOffset    :ppointer;
  GetPhysicalAddress    :ppointer;
  ProtectMe             :ppointer;
  GetCR4                :ppointer;
  GetCR3                :ppointer;
  SetCR3                :ppointer;
  GetSDT                :ppointer;
  GetSDTShadow          :ppointer;
  setAlternateDebugMethod: ppointer;
  getAlternateDebugMethod: ppointer;
  DebugProcess          :ppointer;
  ChangeRegOnBP         :ppointer;
  RetrieveDebugData     :ppointer;
  StartProcessWatch     :ppointer;
  WaitForProcessListData:ppointer;
  GetProcessNameFromID  :ppointer;
  GetProcessNameFromPEProcess:ppointer;
  KernelOpenProcess       :ppointer;
  KernelReadProcessMemory :ppointer;
  KernelWriteProcessMemory:ppointer;
  KernelVirtualAllocEx    :ppointer;
  IsValidHandle           :ppointer;
  GetIDTCurrentThread     :ppointer;
  GetIDTs                 :ppointer;
  MakeWritable            :ppointer;
  GetLoadedState          :TGetLoadedState;
  DBKSuspendThread        :ppointer;
  DBKResumeThread         :ppointer;
  DBKSuspendProcess       :ppointer;
  DBKResumeProcess        :ppointer;
  KernelAlloc             :ppointer;
  GetKProcAddress         :ppointer;
  CreateToolhelp32Snapshot:ppointer;
  Process32First          :ppointer;
  Process32Next           :ppointer;
  Thread32First           :ppointer;
  Thread32Next            :ppointer;
  Module32First           :ppointer;
  Module32Next            :ppointer;
  Heap32ListFirst         :ppointer;
  Heap32ListNext          :ppointer;

  //advanced for delphi 7 enterprise dll programmers only
  mainform                :pointer;
  memorybrowser           :pointer;

  //version 2 extension:
  sym_nameToAddress         : Tce_sym_NameToAddress;
  sym_addressToName         : Tce_sym_addressToName;
  ce_generateAPIHookScript  : Tce_generateAPIHookScript;

  //version 3
  loadDBK32         : TLoadDBK32;
  loaddbvmifneeded  : TLoadDBVMifneeded;
  previousOpcode    : TPreviousOpcode;
  nextopcode        : TNextOpcode;
  disassembleEx     : TDisassembleEx;
  loadModule        : TloadModule;

  aa_AddExtraCommand: Taa_AddExtraCommand;
  aa_RemoveExtraCommand:Taa_RemoveExtraCommand;

  //version 4 extension
  createTableEntry: TcreateTableEntry;
  getTableEntry: TgetTableEntry;
  memrec_setDescription: Tmemrec_setDescription;
  memrec_getDescription: Tmemrec_getDescription;
  memrec_getAddress: Tmemrec_getAddress;
  memrec_setAddress: Tmemrec_setAddress;
  memrec_getType: Tmemrec_getType;
  memrec_setType: Tmemrec_setType;
  memrec_getValue: Tmemrec_getValue;
  memrec_setValue: Tmemrec_setValue;
  memrec_getScript: Tmemrec_getScript;
  memrec_setScript: Tmemrec_setScript;
  memrec_isfrozen: Tmemrec_isfrozen;
  memrec_freeze: Tmemrec_freeze;
  memrec_unfreeze: Tmemrec_unfreeze;
  memrec_setColor: Tmemrec_setColor;
  memrec_appendtoentry: Tmemrec_appendtoentry;
  memrec_delete: Tmemrec_delete;

  getProcessIDFromProcessName: TgetProcessIDFromProcessName;
  openProcessEx: TopenProcessEx;
  debugProcessEx: TdebugProcessEx;
  pause: Tpause;
  unpause: Tunpause;

  debug_setBreakpoint: Tdebug_setBreakpoint;
  debug_removeBreakpoint: Tdebug_removeBreakpoint;
  debug_continueFromBreakpoint: Tdebug_continueFromBreakpoint;

  closeCE: TcloseCE;
  hideAllCEWindows: ThideAllCEWindows;
  unhideMainCEwindow: TunhideMainCEwindow;
  createForm: TcreateForm;
  form_centerScreen: Tform_centerScreen;
  form_hide: Tform_hide;
  form_show: Tform_show;
  form_onClose: Tform_onClose;

  createPanel: TcreatePanel;
  createGroupBox: TcreateGroupBox;
  createButton: TcreateButton;
  createImage: TcreateImage;
  image_loadImageFromFile: Timage_loadImageFromFile;
  image_transparent: Timage_transparent;
  image_stretch: Timage_stretch;

  createLabel: TcreateLabel;
  createEdit: TcreateEdit;
  createMemo: TcreateMemo;
  createTimer: TcreateTimer;
  timer_setInterval: Ttimer_setInterval;
  timer_onTimer: Ttimer_onTimer;
  control_setCaption: Tcontrol_setCaption;
  control_getCaption: Tcontrol_getCaption;
  control_setPosition: Tcontrol_setPosition;
  control_getX: Tcontrol_getX;
  control_getY: Tcontrol_getY;
  control_setSize: Tcontrol_setSize;
  control_getWidth: Tcontrol_getWidth;
  control_getHeight: Tcontrol_getHeight;
  control_setAlign: Tcontrol_setAlign;
  control_onClick: Tcontrol_onClick;

  object_destroy: Tobject_destroy;
  messageDialog: TmessageDialog;
  speedhack_setSpeed: Tspeedhack_setSpeed;

  //version 5
  ExecuteKernelCode: TExecuteKernelCode;
  UserdefinedInterruptHook: TUserdefinedInterruptHook;
  GetLuaState: TGetLuaState;
  MainThreadCall: TMainThreadCall;


end;

type PExportedFunctions=^TExportedFunctions;

implementation

end.