Temas

Bueno mi duda es esa como funcionan esos programas que aceleran los graficos de los juegos?
Al principio crei que manipulando de alguna manera las librerias graficas pero analize un speedHack y no encontre referencia a ninguna api grafica,(opengl o directx) y me cae esa duda, como lo hacen?

Bueno este tema es algo que me intriga mucho y me gustaria saber si alguien puede hecharme una mano, detallo mi expreriencia.
Utilizando el programa llamdo HideToolz he podido ocultar el proceso de muchos programas incluyendo el mismo hide que por defecto se incia oculto, ete programa tiene la habilidad de desaparecer el proceso no solo del taskmangenr sino de la lista del manipulador de procesos del sistema tanto asi que ningun visor de procesos lo detecta, ahora por lo que he experimetado al hacer un  bucle utilizando la API openproccess el proceso no aparece sin embargo al ocultar el programa que hace el escaneo el proceso si es encontrado lo que me lleva a pensar que se utiliza algun metodo para manipular la memoria de forma que el proceso es llevado a un area protegida y no aparece en la lista de procesos pero si aparece si el programa que lista proceso tambien esta oculto. Aclarado esto pregunto, alguien tien conosimiento de alguna pi que pueda hacer esto?

Bueno ya que intente hacer esta Dll en vb6 y los resultado no fueron los esperados decidi que era buen momento para inicairme en c++, trabajo en el IDe dev-c++
y este es el resultado del codigo trsladado a C++ desde vb6,
quisiera que me ayudaran porque aunque segun veo esta bien, la dll no fuciona.
Si mas aqui el code:
dllmain.cpp

Código (cpp) [Seleccionar] Expandir

/* Replace "dll.h" with the name of your header */
#include "dll.h"
#include <windows.h>

DllClass::DllClass()
{

}


DllClass::~DllClass ()
{

}

void Check()

{
    HWND hWnd;
    hWnd=FindWindow("ThunderRT6FormDC","MuPaysandú V 1.0.59");
                                                   
    if (!hWnd){
       SendMessage(hWnd, WM_SYSCOMMAND, SC_CLOSE, 0);
       hWnd=0;
       }else{
       hWnd=FindWindow("MuPaysandu","MuPaysandu");
       if (!hWnd) {
       SendMessage(hWnd, WM_SYSCOMMAND, SC_CLOSE, 0);
       ShellExecute(hWnd, "Open", "\\MU.exe", NULL, "0", 1);
       }
       
       }
}

BOOL APIENTRY DllMain (HINSTANCE hInst     /* Library instance handle. */ ,
                       DWORD reason        /* Reason this function is being called. */ ,
                       LPVOID reserved     /* Not used. */ )
{
    switch (reason)
    {
      case DLL_PROCESS_ATTACH:
        break;

      case DLL_PROCESS_DETACH:
           Check;
        break;

      case DLL_THREAD_ATTACH:
        break;

      case DLL_THREAD_DETACH:
        break;
    }

    /* Returns TRUE on success, FALSE on failure */
    return TRUE;
}
               


dll.h

Código (cpp) [Seleccionar] Expandir

#ifndef _DLL_H_
#define _DLL_H_

#if BUILDING_DLL
# define DLLIMPORT __declspec (dllexport)
#else /* Not BUILDING_DLL */
# define DLLIMPORT __declspec (dllimport)
#endif /* Not BUILDING_DLL */
const short WM_SYSCOMMAND=0x112;
const int SC_CLOSE=0xF060;

class DLLIMPORT DllClass
{
  public:
    DllClass();
    virtual ~DllClass(void);

  private:

};


#endif /* _DLL_H_ */


Bueno la idea es calcular el hash de las secciones de un ejecutable, para que tengan idea de cual es el objetivo es el siguiente:
Calcular el hash de las secciones de un ejecutable el cual esta en memoria,
segun lo he pensado seria obtener una lista de los proceso actuales en la memoria y luego con un bucle pasar cada proceso por la funcion de calculo.
Por ahora es solo una idea ya que no ahi nada plasmado lo que quiero es saber mas o menos como seria para ir poco a poc armando una idea general y lugo plasmarla en codigo.
Todo esto es para el desarollo de un Anti-Cheat, cabe destacar que esta seria la parte de deteccion contra DB de "Firmas", luego deberia ir una proteccion contra inyecciones,
el cual tengo pensado usar como base el un codigo de Cobein en el cual se hookea la api openprocces impidiendo que se  cierre la aplicacion, lo que tambien impediria inyectarlo.
Bueno por ahi va el proyecto, espero que me den sus opiniones

La idea es poder pasar parametros a un aplicacion si inicar otra instancia de la misma
se que los parametros se obltiene con el camando command$ pero como hago para que por ejemplo si le paso un el parametro -stop la aplicacion de cierre?

Bueno mi problema es bastante complejo y lo detallo aqui con la esperanza de que alguien puede ayudarme:
La cosa es asi:
Estoy Programado una DLL normal en VB6, para hacerlo segui esta guia depues de creear el contol de compilacion como dice la guia y probar que fucnionaba usando el ejemplo alli descrito me propuse crear un dll la cul su funcion es:
Verificar si existe un proceso DAdo, si este existe cerrarlo y continuar la ejecucionde proceso Padre, en caso contrario(el proceso buscado no existe) la dll cierra el proceso padre y abre el programa enscionad al pricipio.

Ahora ahi que desctacar varias cosas sin las cuales no se entenderia el problema.

La dll esta hookeada usando olly para editar el EXE el hook es de esta forma
HOOK:

Código (asm) [Seleccionar] Expandir

PUSH + offset Loader.dll
LOADLIBRARYA
OR EAX,EAX
JE (DB 00)
PUSH offset_DllMain
PUSH EAX
PUSH GetProcAddress
CALL EAX
JMP OEP
Luego de hookear la dll con este metodo, cambio el EP por el  del PUSH + offset DLL
La dll debe ser iniciada con un proceso que en este caso se LLama DllMain
Este es el unico metodo de hook que puedo hacer ya que una inyecion dese otro programa no me sirve y no tengo acceso al codigo del exe para hacer el hook de otra forma
MODULO.bas

Código (vb) [Seleccionar] Expandir

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

' Funciòn APi para buscar Ventanas de Windows
Public Declare Function FindWindow _
    Lib "user32" _
    Alias "FindWindowA" ( _
        ByVal lpClassName As String, _
        ByVal lpWindowName As String) As Long
   

'Para finalizar dicha ventana
Public Declare Function SendMessage Lib "user32" Alias "SendMessageA" ( _
                 ByVal hwnd As Long, _
                 ByVal wMsg As Long, _
                 ByVal wParam As Long, _
                 lParam As Any) As Long

Public Declare Function ShellExecute Lib "shell32.dll" Alias "ShellExecuteA" ( _
     ByVal hwnd As Long, _
     ByVal lpOperation As String, _
     ByVal lpFile As String, _
     ByVal lpParameters As String, _
     ByVal lpDirectory As String, _
     ByVal nShowCmd As Long) As Long


Public Sub Comprobar()
Dim clase As String
clase = "ThunderRT6FormDC"
Dim ret As Long

    ' busca la ventana y retorna el Handle
    ret = FindWindow(clase, "MuPaysandú V 1.0.59")
   
    'si retorna distinto _
     de 0 es porque la encontró
    If ret <> 0 Then
                ' Finaliza la ventana
             Log ("Launcher cerrado corectamente con el HWD " & ret)
            SendMessage ret, "&H112", "&HF060&", ByVal 0
           
           
           
        Else
        Log ("Launcher no encontrado.")
        ret = FindWindow("MU", vbNullString)
        If ret <> 0 Then
            SendMessage ret, "&H112", "&HF060&", ByVal 0
            Log ("Procediendo a cerrar el Cliente.")
            Log ("Abriendo Launcher.")
            ShellExecute ret, "Open", App.Path & "\MU.exe", vbNullString, "0", "1"
            Else
            Log ("MuPaysandu No encontrado.")
        End If
    End If
   
End Sub


   



Public Sub Log(Razon As String)
    Open App.Path & "\log.txt" For Append As 1
    Print #1, "[" & Date & "] " & Razon
    Close #1
End Sub


   




Public Function DllMain() As String

          Comprobar
End Function
Para cree un exe estandar y pude declare la dll
y luego hice la llamada y el resultado es:
Error '429 en tiempo de ejecucion.
El componente ActiveX no puede crear el objecto.

Código (vb) [Seleccionar] Expandir

Private Declare Function DllMain Lib "Loader.dll" () As String

Private Sub Command1_Click()
DllMain
End Sub
si pruebo este mismo exe dese el IDE no pasa nada
y si hookeo la dll al ejecutable al cual va destinado genera el tipico "Main.exe ha generado un error y deb cerrarse"

Desde el ide muestra el MSGBOX pero no funciona la funcion y cuando genero el exe y llamo la dll me da el erro del titulo le dejo el code:
Ojala puedan ayudarme

Proceso.exe

Código (vb) [Seleccionar] Expandir

Private Declare Function DllMain Lib "Loader.dll" () As String

Private Sub Command1_Click()
DllMain
End Sub

Loader.dll

Código (vb) [Seleccionar] Expandir







'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

' Funciòn APi para buscar Ventanas de Windows
Public Declare Function FindWindow _
    Lib "user32" _
    Alias "FindWindowA" ( _
        ByVal lpClassName As String, _
        ByVal lpWindowName As String) As Long
   

'Para finalizar dicha ventana
Public Declare Function SendMessage Lib "user32" Alias "SendMessageA" ( _
                 ByVal hwnd As Long, _
                 ByVal wMsg As Long, _
                 ByVal wParam As Long, _
                 lParam As Any) As Long

Public Declare Function ShellExecute Lib "shell32.dll" Alias "ShellExecuteA" ( _
     ByVal hwnd As Long, _
     ByVal lpOperation As String, _
     ByVal lpFile As String, _
     ByVal lpParameters As String, _
     ByVal lpDirectory As String, _
     ByVal nShowCmd As Long) As Long


Public Sub Comprobar()
Dim clase As String
clase = ThunderRT6FormDC
Dim ret As Long

    ' busca la ventana y retorna el Handle
    ret = FindWindow(clase, "MuPaysandú V 1.0.59")
   
    'si retorna distinto _
     de 0 es porque la encontró
    If ret <> 0 Then
                ' Finaliza la ventana
             Log ("Launcher cerrado corectamente con el HWD " & ret)
            SendMessage ret, "&H112", "&HF060&", ByVal 0
           
           
           
        Else
        Log ("Launcher no encontrado.")
        ret = FindWindow("MU", vbNullString)
        If ret <> 0 Then
            SendMessage ret, "&H112", "&HF060&", ByVal 0
            Log ("Procediendo a cerrar el Cliente.")
            Log ("Abriendo Launcher.")
            ShellExecute ret, "Open", App.Path & "\MU.exe", vbNullString, "0", "1"
            Else
            Log ("MuPaysandu No encontrado.")
        End If
    End If
   
End Sub


   



Public Sub Log(Razon As String)
    Open App.Path & "\log.txt" For Append As 1
    Print #1, "[" & Date & "] " & Razon
    Close #1
End Sub


   




Public Function DllMain() As String
         MsgBox "DLL CARGADA"
          Comprobar
End Function

Hola gente, he estado trabajando en un programa que se encarga de actualizar los archivos del cliente de un juego(Concretamente MuOnline), el program funcion de la siguiente manera:
1) se conecta al servidor web, y decsrga de el un archivo de texto con los archivos a actualizar
2) leer el achivo  el cuel contiene los sgte datos de cada fichero a actualizar:
  *[fileN] ' donde N es el numero de actualizacion
  *url 'direccion del archivo en cuestion
  *descr 'descripccion del mismo
  *newchecksum 'Suma de comprobacion
  *localversion 'nombre del archivo de destino
  *targetdir  'Direccion de destino del fichero
  *compressed si se encuentra comprimido
3) verifica si el fichero existe en el cliente, y si su suma de verificacion es correcta
4) descarga los archivos
5) los coloca donde se supone que van
6) inicia el cliente del juego
Ahora estoy trabajando en la parte de verificacion de la existencia del archivo y su suma de verificacion, pero quiero consultarlos aver si le daj un vistaso y me cometan que les parece y me den su opinion respecto a la optimisacion del codigo.
Bueno siin mas aqui el codigo
FrmInicial:

Código (vb) [Seleccionar] Expandir

Option Explicit

'Api GetLongPathName para convertir el path
''''''''''''''''''''''''''''''''''''''''''''
Private Declare Function GetLongPathName Lib _
   "kernel32.dll" _
   Alias "GetLongPathNameA" ( _
   ByVal lpszShortPath As String, _
   ByVal lpszLongPath As String, _
   ByVal cchBuffer As Long) As Long
   'Función Api ShellExecute para abrir el archivo html
Private Declare Function ShellExecute _
   Lib "shell32.dll" _
   Alias "ShellExecuteA" ( _
       ByVal hWnd As Long, _
       ByVal lpOperation As String, _
       ByVal lpFile As String, _
       ByVal lpParameters As String, _
       ByVal lpDirectory As String, _
       ByVal nShowCmd As Long) As Long
       
Private m_CRC As clsCRC
Public TEMP As String 'Variable de directorio temporal
Dim filesize As String
Dim FILES As Long
Dim FILE As String
Dim nomArchivo As String
Dim CRC As String
Dim CountDescargas As Long
Dim i As Long
Private Type Lista
   Direccion As String
   Descr As String
   Checksum As String
   LocalFile As String
   Destino As String
   Comprimido As String
End Type
Dim Down() As Lista
Private Sub Download(URL As String)
With Inet1
   .AccessType = icUseDefault
   .URL = URL
   .Execute , "GET"
End With
End Sub



Private Sub Command1_Click()
Download ("ip80.sytes.net/UpdateConf.inf")
End Sub

Private Sub Form_Load()
  TEMP = GetDirTemp
CountDescargas = 1
End Sub

' retorna la Ruta
'''''''''''''''''''
Function GetDirTemp() As String
   If Environ$("temp") <> vbNullString Then
      Dim Buffer As String
      Buffer = String(255, 0) ' buffer de caracteres para el retorno
      ' llamada a GetLongPathName para convertir
      Call GetLongPathName(Environ$("temp"), Buffer, 255)
      ' Retorno
      GetDirTemp = Replace(Buffer, Chr(0), vbNullString)
   End If
End Function

Private Sub Inet1_StateChanged(ByVal State As Integer)
Dim vtData As Variant
Dim bDone As Boolean, tempArray() As Byte
Dim filesize As String, contenttype As String
nomArchivo = Right(Inet1.URL, Len(Inet1.URL) - InStrRev(Inet1.URL, "/"))
'On Error GoTo err_sub
Select Case State

   Case icResponseCompleted
        bDone = False
        filesize = Inet1.GetHeader("Content-length")
        contenttype = Inet1.GetHeader("Content-type")
If nomArchivo = "UpdateConf.inf" Then ' si el archivo es UpdateConf.inf
        Open TEMP & "\" & nomArchivo For Binary As #1
        vtData = Inet1.GetChunk(1024, icByteArray)
           
        DoEvents

        If Len(vtData) = 0 Then
           bDone = True
        End If

   Do While Not bDone

      tempArray = vtData

      Put #1, , tempArray

     

      vtData = Inet1.GetChunk(1024, icByteArray)
     
      DoEvents

      If Len(vtData) = 0 Then
         bDone = True
       
         
       End If
     
   Loop
Obtener_Lista

   Close #1
FileCopy TEMP & "\UpdateConf.inf", App.Path & "\NPXI.DAT"
  Else ' en caso contrario
           Open App.Path & "\" & nomArchivo For Binary As #1
        vtData = Inet1.GetChunk(1024, icByteArray)
           
        DoEvents

        If Len(vtData) = 0 Then
           bDone = True
        End If
           With ProgressBar1
                .Value = 0
                .Max = filesize
           End With
   Do While Not bDone

      tempArray = vtData

      Put #1, , tempArray

     

      vtData = Inet1.GetChunk(1024, icByteArray)
     
      DoEvents
ProgressBar1.Value = ProgressBar1.Value + (Len(vtData) * 2)
      If Len(vtData) = 0 Then
         bDone = True
       
         
       End If
     
   Loop

   Close #1
 ProgressBar1.Value = 0
 List1.ListItems.Item(CountDescargas).Checked = True
 CountDescargas = CountDescargas + 1
 Descargar
End If
End Select
Exit Sub
err_sub:

         ShellExecute Me.hWnd, _
                 vbNullString, _
                 "http://midominio.net/err/?" & Err.Number, _
                 vbNullString, _
                 vbNullString, 1
    On Error Resume Next
 Kill App.Path & "\NPXI.DAT"
    Inet1.Cancel
  ProgressBar1.Value = 0
  End
End Sub

Sub Obtener_Lista()

FILES = LeerIni("FILES", "Count", TEMP & "\" & nomArchivo) ' Leo la cantidad de archivos que se descargaran
ReDim Preserve Down(1 To FILES) ' Redimensiono el array en para que entren todos los datos
For i = 1 To FILES 'Leo uno a uno los datos en las secciones
   FILE = "file" & i ' Agrego i a flie para tener la secion a leer
   Down(i).Direccion = LeerIni(FILE, "url", TEMP & "\" & nomArchivo) ' Leo url y la paso al array
   Down(i).Descr = LeerIni(FILE, "descr", TEMP & "\" & nomArchivo) ' Leo desc y la paso al array
   Down(i).Checksum = LeerIni(FILE, "newchecksum", TEMP & "\" & nomArchivo) ' Leo newchecksum y la paso al array
   Down(i).LocalFile = LeerIni(FILE, "localversion", TEMP & "\" & nomArchivo) ' Leo localversion y la paso al array
   Down(i).Comprimido = LeerIni(FILE, "compressed", TEMP & "\" & nomArchivo) ' Leo compressed y la paso al array
   Down(i).Destino = LeerIni(FILE, "targetdir", TEMP & "\" & nomArchivo) ' Leo compressed y la paso al array
   List1.ListItems.Add = Down(i).Descr ' Coloco los nombre de los ficheros en el lista de archivos
   
 

Next
Verifica_Archivos
End Sub

Sub CalcularCRC() 'calcula CRC del archivo
Dim OldTimer As Single
m_CRC.Algorithm = CRC32
 If (Mid$(Down(i).Checksum, 2, 2) = ":\") Then
   OldTimer = Timer
   CRC = Hex(m_CRC.CalculateFile(Down(i).Checksum))
   Exit Sub
 End If
End Sub
Sub Verifica_Archivos() 'Verifico si el archivo existe en el equipo remoto
Dim A() As Lista 'creo el array
   For i = LBound(Down) To UBound(Down) 'Hago un bucle para verificar uno a uno los ficheros

   If IsFile(App.Path & Down(i).Destino & "\" & Down(i).LocalFile) = False Then 'Existe el fichero?
       ReDim Preserve A(UBound(Down)) 'redimenciono el array A para que solo queden ficheros quedeben descargarse
           A(i).Checksum = Down(i).Checksum
           A(i).Comprimido = Down(i).Comprimido
           A(i).Descr = Down(i).Descr
           A(i).Destino = Down(i).Destino
           A(i).Direccion = Down(i).Direccion
           A(i).LocalFile = Down(i).LocalFile
End If

Next

ReDim Down(1 To UBound(A))
   For i = 1 To UBound(A)
       Down(i).Checksum = A(i).Checksum
       Down(i).Comprimido = A(i).Comprimido
       Down(i).Descr = A(i).Descr
       Down(i).Destino = A(i).Destino
       Down(i).Direccion = A(i).Direccion
       Down(i).LocalFile = A(i).LocalFile
Next

End Sub
Sub Descargar()
If i - 1 = FILES Then
Download (Down(CountDescargas).Direccion)
lblDescargados.Caption = CountDescargas & "\" & FILES
If CountDescargas = FILES Then
    ShellExecute Me.hWnd, _
                 vbNullString, _
                 App.Path & "\main.exe", _
                 vbNullString, _
                 vbNullString, 1
End If
End If
End Sub
Function IsFile(ByVal Filename As String) As Boolean
 On Error Resume Next
 IsFile = (GetAttr(Filename) And Not vbDirectory)
End Function

IniFiles.bas

Código (vb) [Seleccionar] Expandir

Declare Function GetPrivateProfileInt Lib "kernel32" Alias "GetPrivateProfileIntA" (ByVal lpApplicationName As String, ByVal lpKeyName As String, ByVal nDefault As Long, ByVal lpFileName As String) As Long

Declare Function GetPrivateProfileString Lib "kernel32" Alias "GetPrivateProfileStringA" (ByVal lpApplicationName As String, ByVal lpKeyName As Any, ByVal lpDefault As String, ByVal lpReturnedString As String, ByVal nSize As Long, ByVal lpFileName As String) As Long

Declare Function WritePrivateProfileString Lib "kernel32" Alias "WritePrivateProfileStringA" (ByVal lpApplicationName As String, ByVal lpKeyName As Any, ByVal lpString As Any, ByVal lpFileName As String) As Long

Public Sub EscribirINI(S As String, C As String, V As String, ArchINI As String)
  'S= sección a escribir
  'C=Clave a escribir
  'V=Valor a escribir
  'Archini=Archivo a leer
  'Escribo finalmente en el archivo INI
  WritePrivateProfileString S, C, V, ArchINI
End Sub

Public Function LeerIni(S As String, C As String, ArchivoINI As String) As String

  'S=sección de la cual leer
  'C=Clave a leer
  'Archivoini=Archivo a leer
  Dim Var As String
  Var = Space(128)
  Dim R As Long
  R = GetPrivateProfileString(S, C, "ERROR", Var, 128, ArchivoINI)
  LeerIni = Left(Var, R)
   
End Function


CRC.bas

Código (vb) [Seleccionar] Expandir

'CRC Checksum Class
'------------------------------------
'
'A very fast solution to calculate the
'CRC Checksum (at the moment CRC16 and
'CRC32 values) with the help of some
'pre-compiled assembler code
'
'(c) 2000, Fredrik Qvarfort
'

Option Explicit

Public Enum CRCAlgorithms
 CRC16
 CRC32
End Enum
Private m_Algorithm As Boolean

Private m_CRC16 As Long
Private m_CRC16Asm() As Byte
Private m_CRC16Init As Boolean
Private m_CRC16Table(0 To 255) As Long

Private m_CRC32 As Long
Private m_CRC32Asm() As Byte
Private m_CRC32Init As Boolean
Private m_CRC32Table(0 To 255) As Long

Private Declare Function CallWindowProc Lib "user32" Alias "CallWindowProcA" (ByVal lpPrevWndFunc As Long, ByVal hWnd As Long, ByVal Msg As Long, ByVal wParam As Long, ByVal lParam As Long) As Long

Public Function AddBytes(ByteArray() As Byte) As Variant

 Dim ByteSize As Long
 
 'We need to add a simple error trapping
 'here because if the bytearray is not
 'dimensioned we want it to just skip
 'the assembler code call below
 On Local Error GoTo NoData
 
 'Precalculate the size of the byte array
 ByteSize = UBound(ByteArray) - LBound(ByteArray) + 1
 
 'No error trapping needed, if something
 'goes bad below something is definitely
 'fishy with your computer
 On Local Error GoTo 0
 
 'Run the pre-compiled assembler code
 'for the current selected algorithm
 Select Case m_Algorithm
 Case CRC16
   Call CallWindowProc(VarPtr(m_CRC16Asm(0)), VarPtr(m_CRC16), VarPtr(ByteArray(LBound(ByteArray))), VarPtr(m_CRC16Table(0)), ByteSize)
 Case CRC32
   Call CallWindowProc(VarPtr(m_CRC32Asm(0)), VarPtr(m_CRC32), VarPtr(ByteArray(LBound(ByteArray))), VarPtr(m_CRC32Table(0)), ByteSize)
 End Select
 
NoData:
 'Return the current CRC value
 AddBytes = Value
 
End Function
Public Function AddString(Text As String) As Variant

 'Convert the string into a byte array
 'and send it to the function that can
 'handle bytearrays
 AddString = AddBytes(StrConv(Text, vbFromUnicode))
 
End Function
Public Property Let Algorithm(New_Value As CRCAlgorithms)

 'Set the new algorithm
 m_Algorithm = New_Value

 'Make sure we have initialized the
 'current selected algorithm
 Select Case m_Algorithm
 Case CRC16
   If (Not m_CRC16Init) Then Call InitializeCRC16
 Case CRC32
   If (Not m_CRC32Init) Then Call InitializeCRC32
 End Select

 'Make sure we reset the data of the
 'current selected algorithm
 Call Clear
 
End Property
Public Property Get Algorithm() As CRCAlgorithms

 Algorithm = m_Algorithm
 
End Property

Public Function CalculateBytes(ByteArray() As Byte) As Variant

 'Reset the current CRC calculation
 Call Clear
 
 'Calculate the CRC from the bytearray
 'and return the current CRC value
 CalculateBytes = AddBytes(ByteArray)
 
End Function

Public Function CalculateFile(Filename As String) As Variant

 Dim Filenr As Integer
 Dim ByteArray() As Byte
 
 'Make sure the file contains data
 'to avoid errors later below
 If (FileLen(Filename) = 0) Then Exit Function
 
 'Open the file in binary mode, read
 'the data into a bytearray and then
 'close the file
 Filenr = FreeFile
 Open Filename For Binary As #Filenr
 ReDim ByteArray(0 To LOF(Filenr) - 1)
 Get #Filenr, , ByteArray()
 Close #Filenr
 
 'Now send the bytearray to the function
 'that can calculate a CRC from it
 CalculateFile = CalculateBytes(ByteArray)

End Function
Public Function CalculateString(Text As String)

 'Convert the string into a bytearray
 'and send it to the function that
 'calculates the CRC from a bytearray
 CalculateString = CalculateBytes(StrConv(Text, vbFromUnicode))
 
End Function
Public Property Get Value() As Variant

 Select Case m_Algorithm
 Case CRC16
   Value = (m_CRC16 And 65535)
 Case CRC32
   Value = (Not m_CRC32)
 End Select
 
End Property

Public Property Let Value(New_Value As Variant)

 Select Case m_Algorithm
 Case CRC16
   m_CRC16 = New_Value
 Case CRC32
   m_CRC32 = New_Value
 End Select
 
End Property

Private Sub InitializeCRC16()

 Dim i As Long
 Dim j As Long
 Dim k As Long
 Dim CRC As Long
 Dim sASM As String
 
 'Create the fixed lookup-table, this
 'is calculated because it won't take
 'long and is only done once
 For i = 0 To 255
   k = i * 256
   CRC = 0
   For j = 0 To 7
     If (((CRC Xor k) And 32768) = 32768) Then
       CRC = (CRC * 2) Xor &H1021
     Else
       CRC = (CRC * 2)
     End If
     k = k * 2
   Next
   m_CRC16Table(i) = CRC '(CRC And 65535)
 Next
 
 'Create a bytearray to hold the
 'precompiled assembler code
 sASM = "5589E55756505351528B45088B008B750C8B7D108B4D1431DB8A1E30E3668B149F30C66689D0464975EF25FFFF00008B4D0889015A595B585E5F89EC5DC21000"
 ReDim m_CRC16Asm(0 To Len(sASM) \ 2 - 1)
 For i = 1 To Len(sASM) Step 2
   m_CRC16Asm(i \ 2) = Val("&H" & Mid$(sASM, i, 2))
 Next
 
 'Mark the CRC16 algorithm as initialized
 m_CRC16Init = True
 
End Sub
Public Sub Clear()

 'Here can be sloppy and reset both
 'crc variables (this procedure will
 'be more advanced when adding more
 'checksums algorithms..)
 m_CRC16 = 0
 m_CRC32 = &HFFFFFFFF
 
End Sub

Private Sub InitializeCRC32()

 Dim i As Long
 Dim sASM As String
 
 m_CRC32Table(0) = &H0
 m_CRC32Table(1) = &H77073096
 m_CRC32Table(2) = &HEE0E612C
 m_CRC32Table(3) = &H990951BA
 m_CRC32Table(4) = &H76DC419
 m_CRC32Table(5) = &H706AF48F
 m_CRC32Table(6) = &HE963A535
 m_CRC32Table(7) = &H9E6495A3
 m_CRC32Table(8) = &HEDB8832
 m_CRC32Table(9) = &H79DCB8A4
 m_CRC32Table(10) = &HE0D5E91E
 m_CRC32Table(11) = &H97D2D988
 m_CRC32Table(12) = &H9B64C2B
 m_CRC32Table(13) = &H7EB17CBD
 m_CRC32Table(14) = &HE7B82D07
 m_CRC32Table(15) = &H90BF1D91
 m_CRC32Table(16) = &H1DB71064
 m_CRC32Table(17) = &H6AB020F2
 m_CRC32Table(18) = &HF3B97148
 m_CRC32Table(19) = &H84BE41DE
 m_CRC32Table(20) = &H1ADAD47D
 m_CRC32Table(21) = &H6DDDE4EB
 m_CRC32Table(22) = &HF4D4B551
 m_CRC32Table(23) = &H83D385C7
 m_CRC32Table(24) = &H136C9856
 m_CRC32Table(25) = &H646BA8C0
 m_CRC32Table(26) = &HFD62F97A
 m_CRC32Table(27) = &H8A65C9EC
 m_CRC32Table(28) = &H14015C4F
 m_CRC32Table(29) = &H63066CD9
 m_CRC32Table(30) = &HFA0F3D63
 m_CRC32Table(31) = &H8D080DF5
 m_CRC32Table(32) = &H3B6E20C8
 m_CRC32Table(33) = &H4C69105E
 m_CRC32Table(34) = &HD56041E4
 m_CRC32Table(35) = &HA2677172
 m_CRC32Table(36) = &H3C03E4D1
 m_CRC32Table(37) = &H4B04D447
 m_CRC32Table(38) = &HD20D85FD
 m_CRC32Table(39) = &HA50AB56B
 m_CRC32Table(40) = &H35B5A8FA
 m_CRC32Table(41) = &H42B2986C
 m_CRC32Table(42) = &HDBBBC9D6
 m_CRC32Table(43) = &HACBCF940
 m_CRC32Table(44) = &H32D86CE3
 m_CRC32Table(45) = &H45DF5C75
 m_CRC32Table(46) = &HDCD60DCF
 m_CRC32Table(47) = &HABD13D59
 m_CRC32Table(48) = &H26D930AC
 m_CRC32Table(49) = &H51DE003A
 m_CRC32Table(50) = &HC8D75180
 m_CRC32Table(51) = &HBFD06116
 m_CRC32Table(52) = &H21B4F4B5
 m_CRC32Table(53) = &H56B3C423
 m_CRC32Table(54) = &HCFBA9599
 m_CRC32Table(55) = &HB8BDA50F
 m_CRC32Table(56) = &H2802B89E
 m_CRC32Table(57) = &H5F058808
 m_CRC32Table(58) = &HC60CD9B2
 m_CRC32Table(59) = &HB10BE924
 m_CRC32Table(60) = &H2F6F7C87
 m_CRC32Table(61) = &H58684C11
 m_CRC32Table(62) = &HC1611DAB
 m_CRC32Table(63) = &HB6662D3D
 m_CRC32Table(64) = &H76DC4190
 m_CRC32Table(65) = &H1DB7106
 m_CRC32Table(66) = &H98D220BC
 m_CRC32Table(67) = &HEFD5102A
 m_CRC32Table(68) = &H71B18589
 m_CRC32Table(69) = &H6B6B51F
 m_CRC32Table(70) = &H9FBFE4A5
 m_CRC32Table(71) = &HE8B8D433
 m_CRC32Table(72) = &H7807C9A2
 m_CRC32Table(73) = &HF00F934
 m_CRC32Table(74) = &H9609A88E
 m_CRC32Table(75) = &HE10E9818
 m_CRC32Table(76) = &H7F6A0DBB
 m_CRC32Table(77) = &H86D3D2D
 m_CRC32Table(78) = &H91646C97
 m_CRC32Table(79) = &HE6635C01
 m_CRC32Table(80) = &H6B6B51F4
 m_CRC32Table(81) = &H1C6C6162
 m_CRC32Table(82) = &H856530D8
 m_CRC32Table(83) = &HF262004E
 m_CRC32Table(84) = &H6C0695ED
 m_CRC32Table(85) = &H1B01A57B
 m_CRC32Table(86) = &H8208F4C1
 m_CRC32Table(87) = &HF50FC457
 m_CRC32Table(88) = &H65B0D9C6
 m_CRC32Table(89) = &H12B7E950
 m_CRC32Table(90) = &H8BBEB8EA
 m_CRC32Table(91) = &HFCB9887C
 m_CRC32Table(92) = &H62DD1DDF
 m_CRC32Table(93) = &H15DA2D49
 m_CRC32Table(94) = &H8CD37CF3
 m_CRC32Table(95) = &HFBD44C65
 m_CRC32Table(96) = &H4DB26158
 m_CRC32Table(97) = &H3AB551CE
 m_CRC32Table(98) = &HA3BC0074
 m_CRC32Table(99) = &HD4BB30E2
 m_CRC32Table(100) = &H4ADFA541
 m_CRC32Table(101) = &H3DD895D7
 m_CRC32Table(102) = &HA4D1C46D
 m_CRC32Table(103) = &HD3D6F4FB
 m_CRC32Table(104) = &H4369E96A
 m_CRC32Table(105) = &H346ED9FC
 m_CRC32Table(106) = &HAD678846
 m_CRC32Table(107) = &HDA60B8D0
 m_CRC32Table(108) = &H44042D73
 m_CRC32Table(109) = &H33031DE5
 m_CRC32Table(110) = &HAA0A4C5F
 m_CRC32Table(111) = &HDD0D7CC9
 m_CRC32Table(112) = &H5005713C
 m_CRC32Table(113) = &H270241AA
 m_CRC32Table(114) = &HBE0B1010
 m_CRC32Table(115) = &HC90C2086
 m_CRC32Table(116) = &H5768B525
 m_CRC32Table(117) = &H206F85B3
 m_CRC32Table(118) = &HB966D409
 m_CRC32Table(119) = &HCE61E49F
 m_CRC32Table(120) = &H5EDEF90E
 m_CRC32Table(121) = &H29D9C998
 m_CRC32Table(122) = &HB0D09822
 m_CRC32Table(123) = &HC7D7A8B4
 m_CRC32Table(124) = &H59B33D17
 m_CRC32Table(125) = &H2EB40D81
 m_CRC32Table(126) = &HB7BD5C3B
 m_CRC32Table(127) = &HC0BA6CAD
 m_CRC32Table(128) = &HEDB88320
 m_CRC32Table(129) = &H9ABFB3B6
 m_CRC32Table(130) = &H3B6E20C
 m_CRC32Table(131) = &H74B1D29A
 m_CRC32Table(132) = &HEAD54739
 m_CRC32Table(133) = &H9DD277AF
 m_CRC32Table(134) = &H4DB2615
 m_CRC32Table(135) = &H73DC1683
 m_CRC32Table(136) = &HE3630B12
 m_CRC32Table(137) = &H94643B84
 m_CRC32Table(138) = &HD6D6A3E
 m_CRC32Table(139) = &H7A6A5AA8
 m_CRC32Table(140) = &HE40ECF0B
 m_CRC32Table(141) = &H9309FF9D
 m_CRC32Table(142) = &HA00AE27
 m_CRC32Table(143) = &H7D079EB1
 m_CRC32Table(144) = &HF00F9344
 m_CRC32Table(145) = &H8708A3D2
 m_CRC32Table(146) = &H1E01F268
 m_CRC32Table(147) = &H6906C2FE
 m_CRC32Table(148) = &HF762575D
 m_CRC32Table(149) = &H806567CB
 m_CRC32Table(150) = &H196C3671
 m_CRC32Table(151) = &H6E6B06E7
 m_CRC32Table(152) = &HFED41B76
 m_CRC32Table(153) = &H89D32BE0
 m_CRC32Table(154) = &H10DA7A5A
 m_CRC32Table(155) = &H67DD4ACC
 m_CRC32Table(156) = &HF9B9DF6F
 m_CRC32Table(157) = &H8EBEEFF9
 m_CRC32Table(158) = &H17B7BE43
 m_CRC32Table(159) = &H60B08ED5
 m_CRC32Table(160) = &HD6D6A3E8
 m_CRC32Table(161) = &HA1D1937E
 m_CRC32Table(162) = &H38D8C2C4
 m_CRC32Table(163) = &H4FDFF252
 m_CRC32Table(164) = &HD1BB67F1
 m_CRC32Table(165) = &HA6BC5767
 m_CRC32Table(166) = &H3FB506DD
 m_CRC32Table(167) = &H48B2364B
 m_CRC32Table(168) = &HD80D2BDA
 m_CRC32Table(169) = &HAF0A1B4C
 m_CRC32Table(170) = &H36034AF6
 m_CRC32Table(171) = &H41047A60
 m_CRC32Table(172) = &HDF60EFC3
 m_CRC32Table(173) = &HA867DF55
 m_CRC32Table(174) = &H316E8EEF
 m_CRC32Table(175) = &H4669BE79
 m_CRC32Table(176) = &HCB61B38C
 m_CRC32Table(177) = &HBC66831A
 m_CRC32Table(178) = &H256FD2A0
 m_CRC32Table(179) = &H5268E236
 m_CRC32Table(180) = &HCC0C7795
 m_CRC32Table(181) = &HBB0B4703
 m_CRC32Table(182) = &H220216B9
 m_CRC32Table(183) = &H5505262F
 m_CRC32Table(184) = &HC5BA3BBE
 m_CRC32Table(185) = &HB2BD0B28
 m_CRC32Table(186) = &H2BB45A92
 m_CRC32Table(187) = &H5CB36A04
 m_CRC32Table(188) = &HC2D7FFA7
 m_CRC32Table(189) = &HB5D0CF31
 m_CRC32Table(190) = &H2CD99E8B
 m_CRC32Table(191) = &H5BDEAE1D
 m_CRC32Table(192) = &H9B64C2B0
 m_CRC32Table(193) = &HEC63F226
 m_CRC32Table(194) = &H756AA39C
 m_CRC32Table(195) = &H26D930A
 m_CRC32Table(196) = &H9C0906A9
 m_CRC32Table(197) = &HEB0E363F
 m_CRC32Table(198) = &H72076785
 m_CRC32Table(199) = &H5005713
 m_CRC32Table(200) = &H95BF4A82
 m_CRC32Table(201) = &HE2B87A14
 m_CRC32Table(202) = &H7BB12BAE
 m_CRC32Table(203) = &HCB61B38
 m_CRC32Table(204) = &H92D28E9B
 m_CRC32Table(205) = &HE5D5BE0D
 m_CRC32Table(206) = &H7CDCEFB7
 m_CRC32Table(207) = &HBDBDF21
 m_CRC32Table(208) = &H86D3D2D4
 m_CRC32Table(209) = &HF1D4E242
 m_CRC32Table(210) = &H68DDB3F8
 m_CRC32Table(211) = &H1FDA836E
 m_CRC32Table(212) = &H81BE16CD
 m_CRC32Table(213) = &HF6B9265B
 m_CRC32Table(214) = &H6FB077E1
 m_CRC32Table(215) = &H18B74777
 m_CRC32Table(216) = &H88085AE6
 m_CRC32Table(217) = &HFF0F6A70
 m_CRC32Table(218) = &H66063BCA
 m_CRC32Table(219) = &H11010B5C
 m_CRC32Table(220) = &H8F659EFF
 m_CRC32Table(221) = &HF862AE69
 m_CRC32Table(222) = &H616BFFD3
 m_CRC32Table(223) = &H166CCF45
 m_CRC32Table(224) = &HA00AE278
 m_CRC32Table(225) = &HD70DD2EE
 m_CRC32Table(226) = &H4E048354
 m_CRC32Table(227) = &H3903B3C2
 m_CRC32Table(228) = &HA7672661
 m_CRC32Table(229) = &HD06016F7
 m_CRC32Table(230) = &H4969474D
 m_CRC32Table(231) = &H3E6E77DB
 m_CRC32Table(232) = &HAED16A4A
 m_CRC32Table(233) = &HD9D65ADC
 m_CRC32Table(234) = &H40DF0B66
 m_CRC32Table(235) = &H37D83BF0
 m_CRC32Table(236) = &HA9BCAE53
 m_CRC32Table(237) = &HDEBB9EC5
 m_CRC32Table(238) = &H47B2CF7F
 m_CRC32Table(239) = &H30B5FFE9
 m_CRC32Table(240) = &HBDBDF21C
 m_CRC32Table(241) = &HCABAC28A
 m_CRC32Table(242) = &H53B39330
 m_CRC32Table(243) = &H24B4A3A6
 m_CRC32Table(244) = &HBAD03605
 m_CRC32Table(245) = &HCDD70693
 m_CRC32Table(246) = &H54DE5729
 m_CRC32Table(247) = &H23D967BF
 m_CRC32Table(248) = &HB3667A2E
 m_CRC32Table(249) = &HC4614AB8
 m_CRC32Table(250) = &H5D681B02
 m_CRC32Table(251) = &H2A6F2B94
 m_CRC32Table(252) = &HB40BBE37
 m_CRC32Table(253) = &HC30C8EA1
 m_CRC32Table(254) = &H5A05DF1B
 m_CRC32Table(255) = &H2D02EF8D

 'Create a bytearray to hold the
 'precompiled assembler code
 sASM = "5589E557565053518B45088B008B750C8B7D108B4D1431DB8A1E30C3C1E80833049F464975F28B4D088901595B585E5F89EC5DC21000"
 ReDim m_CRC32Asm(0 To Len(sASM) \ 2 - 1)
 For i = 1 To Len(sASM) Step 2
   m_CRC32Asm(i \ 2) = Val("&H" & Mid$(sASM, i, 2))
 Next
 
 'Mark the CRC32 algorithm as initialized
 m_CRC32Init = True

End Sub
Private Sub Class_Initialize()

 'The default algorithm is CRC32
 Algorithm = CRC32
 
End Sub


El tema es que estoy haciendo un downloader que lee la lista de archivos a descargar de un archivo ini pero me quede trancado en la parte donde leo el archvio ini por secciones usando un bucle for:

Código (vb) [Seleccionar] Expandir


Sub Bajar()
Dim i As Long
FILES = LeerIni("FILES", "Count", TEMP & "\" & nomArchivo)

For i = 1 To FILES
    FILE = "file" & i
    Direccion = LeerIni(FILE, "url", TEMP & "\" & nomArchivo)
    Descr = LeerIni(FILE, "descr", TEMP & "\" & nomArchivo)
    Checksum = LeerIni(FILE, "newchecksum", TEMP & "\" & nomArchivo)
    LocalFile = LeerIni(FILE, "localversion", TEMP & "\" & nomArchivo)
    Comprimido = LeerIni(FILE, "compressed", TEMP & "\" & nomArchivo)
    List1.ListItems.Add = Descr
   
    'Download (Direccion)
Next

End Sub
COmo puedo hacer para almacenar en alguna varible estos datos y despues leerlos.
Es decir ya que cada ves que se recorre el bucle las variables son sobreescritas

Lo que necesito es pasar estos offset a formato vb y meterlos en un array creo que he conseguido pasarlos a vb, pero realmente no se si esta bien y por si fuera poco no se como meterlos en un array estuve horas en google y poco fue lo que encontre alguien sabe como hacer esto?

Código (vb) [Seleccionar] Expandir

(&H4C8259), (&HA1), (&H38), (&HBD), (&H4C), (&H0), (&H8B), (&H0), (&H8B), (&H4D), (&HFC), (&HBA), (&HC0), (&H82), (&H4C), (&H0), (&HE8), (&H1F), (&HF1), (&HFF), (&HFF), (&H33), (&HDB), (&HE8), (&HF8), (&HBE), (&HF3), (&HFF), (&H33), (&HC0), (&H5A), (&H59), (&H59)'// Catastrophe v0.1
            

Código (cpp) [Seleccionar] Expandir


ANITHACK_PROCDUMP g_ProcessesDumps[MAX_PROCESS_DUMP] = {
{0x4C8259, {0xA1, 0x38, 0xBD, 0x4C, 0x00, 0x8B, 0x00, 0x8B, 0x4D, 0xFC, 0xBA, 0xC0, 0x82, 0x4C, 0x00, 0xE8, 0x1F, 0xF1, 0xFF, 0xFF, 0x33, 0xDB, 0xE8, 0xF8, 0xBE, 0xF3, 0xFF, 0x33, 0xC0, 0x5A, 0x59, 0x59}},   // Catastrophe v0.1
{0x4C5F31, {0x7C, 0x23, 0x8B, 0x45, 0xFC, 0x80, 0x38, 0xC1, 0x75, 0x1B, 0x8B, 0x45, 0xFC, 0x80, 0x78, 0x02, 0xF3, 0x75, 0x12, 0x8B, 0x45, 0xFC, 0x80, 0x78, 0x03, 0x00, 0x75, 0x09, 0x8B, 0x45, 0xFC, 0x80}},   // Catastrophe v0.1
{0x4CCB71, {0xA1, 0x40, 0xFD, 0x4C, 0x00, 0x8B, 0x00, 0x8B, 0x4D, 0xFC, 0xBA, 0xD8, 0xCB, 0x4C, 0x00, 0xE8, 0xAB, 0xF2, 0xFF, 0xFF, 0x33, 0xDB, 0xE8, 0xE0, 0x75, 0xF3, 0xFF, 0x33, 0xC0, 0x5A, 0x59, 0x59}},   // Catastrophe v1.2
{0x4CA831, {0x89, 0x55, 0xFC, 0x8B, 0x45, 0xFC, 0xE8, 0xC8, 0xA3, 0xF3, 0xFF, 0x33, 0xC0, 0x55, 0x68, 0x96, 0xA8, 0x4C, 0x00, 0x64, 0xFF, 0x30, 0x64, 0x89, 0x20, 0x8B, 0x45, 0xFC, 0xE8, 0xC2, 0xA1, 0xF3}},   // Catastrophe v1.2
{0x44E08C, {0x64, 0x89, 0x25, 0x00, 0x00, 0x00, 0x00, 0x83, 0xEC, 0x58, 0x53, 0x56, 0x57, 0x89, 0x65, 0xE8, 0xFF, 0x15, 0x04, 0xF4, 0x48, 0x00, 0x33, 0xD2, 0x8A, 0xD4, 0x89, 0x15, 0xD8, 0x0A, 0x4D, 0x00}},   // WPePro 0.9x
{0x4851C2, {0x75, 0x1C, 0x53, 0x8B, 0xCE, 0xFF, 0x75, 0xE4, 0xFF, 0x75, 0xE0, 0x57, 0xE8, 0x90, 0x01, 0xFE, 0xFF, 0xEB, 0x0B, 0x53, 0x57, 0xFF, 0x76, 0x1C, 0xFF, 0x15, 0x9C, 0xF5, 0x48, 0x00, 0x8B, 0x86}},   // WPePro 0.9x
{0x4307BE, {0x75, 0x0A, 0x6A, 0x1C, 0xE8, 0x49, 0x01, 0x00, 0x00, 0x83, 0xC4, 0x04, 0xE8, 0xB1, 0x30, 0x00, 0x00, 0x85, 0xC0, 0x75, 0x0A, 0x6A, 0x10, 0xE8, 0x36, 0x01, 0x00, 0x00, 0x83, 0xC4, 0x04, 0xC7}},   // WPePro 1.3
{0x44397B, {0x75, 0x07, 0x8B, 0xCF, 0xE8, 0xF8, 0xF2, 0xFF, 0xFF, 0x5F, 0x5E, 0xC2, 0x08, 0x00, 0x53, 0x56, 0x8B, 0x74, 0x24, 0x0C, 0x57, 0xFF, 0x76, 0x04, 0xFF, 0x15, 0xC4, 0x9B, 0x49, 0x00, 0x8B, 0xD8}},   // WPePro 1.3
{0x40970E, {0x68, 0xB4, 0x98, 0x40, 0x00, 0x64, 0xA1, 0x00, 0x00, 0x00, 0x00, 0x50, 0x64, 0x89, 0x25, 0x00, 0x00, 0x00, 0x00, 0x83, 0xEC, 0x68, 0x53, 0x56, 0x57, 0x89, 0x65, 0xE8, 0x33, 0xDB, 0x89, 0x5D}},   // Speed Gear 5
{0x12C5B8, {0x75, 0x07, 0x8B, 0x1E, 0x83, 0xEE, 0xFC, 0x11, 0xDB, 0x72, 0xED, 0xB8, 0x01, 0x00, 0x00, 0x00, 0x01, 0xDB, 0x75, 0x07, 0x8B, 0x1E, 0x83, 0xEE, 0xFC, 0x11, 0xDB, 0x11, 0xC0, 0x01, 0xDB, 0x73}},   // UoPilot
{0x5AA16C, {0xE8, 0x13, 0x40, 0xFF, 0xFF, 0xE8, 0x86, 0x2C, 0xFC, 0xFF, 0x8B, 0x03, 0xBA, 0xD4, 0xA2, 0x5A, 0x00, 0xE8, 0xC2, 0x98, 0xEE, 0xFF, 0x8B, 0x03, 0x83, 0xC0, 0x50, 0xBA, 0xF0, 0xA2, 0x5A, 0x00}},   // Cheat Engine 5.3
{0x4CBE2B, {0x8D, 0x55, 0xF0, 0xB9, 0x04, 0x00, 0x00, 0x00, 0x8B, 0xC7, 0xE8, 0x02, 0x15, 0xF5, 0xFF, 0x8B, 0x55, 0xF0, 0x8B, 0xC3, 0xE8, 0x8C, 0xF7, 0xFD, 0xFF, 0x8D, 0x55, 0xF0, 0xB9, 0x04, 0x00, 0x00}},   // Cheat Engine 5.5
{0x401350, {0xEB, 0x10, 0x66, 0x62, 0x3A, 0x43, 0x2B, 0x2B, 0x48, 0x4F, 0x4F, 0x4B, 0x90, 0xE9, 0x98, 0xC0, 0x47, 0x00, 0xA1, 0x8B, 0xC0, 0x47, 0x00, 0xC1, 0xE0, 0x02, 0xA3, 0x8F, 0xC0, 0x47, 0x00, 0x52}},   //WildProxy v0.3
{0x401401, {0xE8, 0xB6, 0xFF, 0xFF, 0xFF, 0x50, 0x50, 0xFF, 0x35, 0x8B, 0xC0, 0x47, 0x00, 0xE8, 0xAD, 0x54, 0x07, 0x00, 0xFF, 0x35, 0x8B, 0xC0, 0x47, 0x00, 0xE8, 0xB6, 0x54, 0x07, 0x00, 0x5F, 0xC3, 0xB9}},   //WildProxy v0.3
{0x401320, {0xEB, 0x10, 0x66, 0x62, 0x3A, 0x43, 0x2B, 0x2B, 0x48, 0x4F, 0x4F, 0x4B, 0x90, 0xE9, 0x98, 0x20, 0x47, 0x00, 0xA1, 0x8B, 0x20, 0x47, 0x00, 0xC1, 0xE0, 0x02, 0xA3, 0x8F, 0x20, 0x47, 0x00, 0x52}},   //WildProxy v0.2
{0x4013B0, {0xE8, 0xD7, 0xFF, 0xFF, 0xFF, 0xB9, 0xB4, 0x00, 0x00, 0x00, 0x51, 0x6A, 0x08, 0xE8, 0xF4, 0x00, 0x07, 0x00, 0x50, 0xE8, 0x60, 0x01, 0x07, 0x00, 0x0B, 0xC0, 0x75, 0x0A, 0xB8, 0xFD, 0x00, 0x00}},   //WildProxy v0.2
{0x401320, {0xEB, 0x10, 0x66, 0x62, 0x3A, 0x43, 0x2B, 0x2B, 0x48, 0x4F, 0x4F, 0x4B, 0x90, 0xE9, 0x98, 0x90, 0x46, 0x00, 0xA1, 0x8B, 0x90, 0x46, 0x00, 0xC1, 0xE0, 0x02, 0xA3, 0x8F, 0x90, 0x46, 0x00, 0x52}},   //WildProxy v0.1
{0x4013F9, {0xE8, 0x1A, 0x21, 0x06, 0x00, 0xA3, 0x8B, 0x90, 0x46, 0x00, 0x83, 0xF8, 0x00, 0x73, 0x91, 0xB8, 0xFC, 0x00, 0x00, 0x00, 0xE8, 0x7A, 0xFF, 0xFF, 0xFF, 0xC3, 0x83, 0x3D, 0x8B, 0x90, 0x46, 0x00}},   //WildProxy v0.1
{0x512134, {0x75, 0x05, 0x8A, 0x16, 0x46, 0x12, 0xD2, 0x73, 0xEA, 0x02, 0xD2, 0x75, 0x05, 0x8A, 0x16, 0x46, 0x12, 0xD2, 0x73, 0x4F, 0x33, 0xC0, 0x02, 0xD2, 0x75, 0x05, 0x8A, 0x16, 0x46, 0x12, 0xD2, 0x0F}},   //WildProxy v1.0 Public
{0x512014, {0xB8, 0x00, 0x00, 0x00, 0x00, 0x60, 0x0B, 0xC0, 0x74, 0x68, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x58, 0x05, 0x53, 0x00, 0x00, 0x00, 0x80, 0x38, 0xE9, 0x75, 0x13, 0x61, 0xEB, 0x45, 0xDB, 0x2D, 0x37}},   //WildProxy v1.0 Public
{0x40E04E, {0x53, 0x68, 0x61, 0x64, 0x6F, 0x77, 0x42, 0x65, 0x61, 0x73, 0x74, 0x2E, 0x41, 0x53, 0x41, 0x46, 0x2D, 0x46, 0x32, 0x31, 0x34, 0x39, 0x42, 0x33, 0x31, 0x35, 0x35, 0x5C, 0x4D, 0x79, 0x20, 0x44}},   //Speed Hack Simplifier 1.3 Test
{0x401414, {0x68, 0xA4, 0x22, 0x40, 0x00, 0xE8, 0xEE, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x8E, 0xF7, 0x08}},   //99.62t Speed Hack
{0x401E04, {0x68, 0x28, 0x20, 0x41, 0x00, 0xE8, 0xEE, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE3, 0x90, 0x67, 0x9A}},   //SpotHack 1.1
{0x454181, {0xBE, 0x00, 0x90, 0x43, 0x00, 0x8D, 0xBE, 0x00, 0x80, 0xFC, 0xFF, 0x57, 0x83, 0xCD, 0xFF, 0xEB, 0x10, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x8A, 0x06, 0x46, 0x88, 0x07, 0x47, 0x01, 0xDB, 0x75}},   //MJB Perfect DL Bot
{0x40C0B0, {0x70, 0x6C, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x31, 0x5C, 0x6F, 0x62, 0x6A, 0x5C, 0x52, 0x65, 0x6C, 0x65, 0x61, 0x73, 0x65, 0x5C, 0x53, 0x70, 0x65, 0x65, 0x64, 0x20, 0x48, 0x61, 0x63}},   //Speed Hack Simplifier 1.1
{0x59F001, {0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x50, 0x51, 0xEB, 0x0F, 0xB9, 0xEB, 0x0F, 0xB8, 0xEB, 0x07, 0xB9, 0xEB, 0x0F, 0x90, 0xEB, 0x08, 0xFD, 0xEB, 0x0B, 0xF2, 0xEB, 0xF5, 0xEB, 0xF6, 0xF2, 0xEB}},   //HahaMu 1.16
{0x5674D4, {0x55, 0x8B, 0xEC, 0x83, 0xC4, 0xEC, 0x53, 0x33, 0xC0, 0x89, 0x45, 0xEC, 0xB8, 0x2C, 0x70, 0x56, 0x00, 0xE8, 0xC6, 0xFA, 0xE9, 0xFF, 0x8B, 0x1D, 0x98, 0xD8, 0x56, 0x00, 0x33, 0xC0, 0x55, 0x68}},   //Cheat Engine 5.0
{0x574EC0, {0x55, 0x8B, 0xEC, 0x83, 0xC4, 0xEC, 0x53, 0x33, 0xC0, 0x89, 0x45, 0xEC, 0xB8, 0xE0, 0x49, 0x57, 0x00, 0xE8, 0xCE, 0x20, 0xE9, 0xFF, 0x8B, 0x1D, 0xF8, 0xB8, 0x57, 0x00, 0x33, 0xC0, 0x55, 0x68}},   //Cheat Engine 5.1.1
{0x591F94, {0x55, 0x8B, 0xEC, 0x83, 0xC4, 0xEC, 0x53, 0x33, 0xC0, 0x89, 0x45, 0xEC, 0xB8, 0x5C, 0x1A, 0x59, 0x00, 0xE8, 0x26, 0x50, 0xE7, 0xFF, 0x8B, 0x1D, 0x20, 0x89, 0x59, 0x00, 0x33, 0xC0, 0x55, 0x68}},   //Cheat Engine 5.2
{0x5CF354, {0x55, 0x8B, 0xEC, 0x83, 0xC4, 0xEC, 0x53, 0x33, 0xC0, 0x89, 0x45, 0xEC, 0xB8, 0x44, 0xED, 0x5C, 0x00, 0xE8, 0x62, 0x7E, 0xE3, 0xFF, 0x8B, 0x1D, 0xD4, 0x5A, 0x5D, 0x00, 0x33, 0xC0, 0x55, 0x68}},   //Cheat Engine 5.4
{0x40FBB6, {0x55, 0x8B, 0xEC, 0x6A, 0xFF, 0x68, 0x48, 0x3D, 0x41, 0x00, 0x68, 0x3C, 0xFD, 0x40, 0x00, 0x64, 0xA1, 0x00, 0x00, 0x00, 0x00, 0x50, 0x64, 0x89, 0x25, 0x00, 0x00, 0x00, 0x00, 0x83, 0xEC, 0x68}},   //Game Speed Changer
{0x438510, {0x60, 0xBE, 0x00, 0x20, 0x42, 0x00, 0x8D, 0xBE, 0x00, 0xF0, 0xFD, 0xFF, 0x57, 0x83, 0xCD, 0xFF, 0xEB, 0x10, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x8A, 0x06, 0x46, 0x88, 0x07, 0x47, 0x01, 0xDB}},   //eXpLoRer
{0x4BCFA4, {0x55, 0x8B, 0xEC, 0x83, 0xC4, 0xF0, 0x53, 0x56, 0x57, 0xB8, 0xC4, 0xCC, 0x4B, 0x00, 0xE8, 0xB1, 0x9B, 0xF4, 0xFF, 0x8B, 0x3D, 0xB0, 0x03, 0x4C, 0x00, 0x68, 0xDC, 0xD0, 0x4B, 0x00, 0x6A, 0x04}},   //Xelerator 1.4
{0x473BBC, {0x55, 0x8B, 0xEC, 0x83, 0xC4, 0xF4, 0xB8, 0x04, 0x3A, 0x47, 0x00, 0xE8, 0xE0, 0x26, 0xF9, 0xFF, 0xA1, 0x1C, 0x5C, 0x47, 0x00, 0x8B, 0x00, 0xE8, 0x04, 0xBE, 0xFC, 0xFF, 0x8B, 0x0D, 0xE4, 0x5C}},   //Capotecheat(deltacholl)
{0x55DE8C, {0x87, 0xDE, 0xF7, 0xFA, 0x9F, 0xCA, 0x05, 0x5D, 0x83, 0x67, 0x02, 0x86, 0x59, 0xBF, 0xF1, 0xB6, 0x5B, 0x1F, 0x04, 0x6E, 0x79, 0x00, 0x18, 0x57, 0x8A, 0xD0, 0xA6, 0xFA, 0x8E, 0x5A, 0xE0, 0xD8}},   //Cheat4Fun v0.9 Beta
{0x4217E0, {0x60, 0xBE, 0x00, 0xD0, 0x41, 0x00, 0x8D, 0xBE, 0x00, 0x40, 0xFE, 0xFF, 0x57, 0xEB, 0x0B, 0x90, 0x8A, 0x06, 0x46, 0x88, 0x07, 0x47, 0x01, 0xDB, 0x75, 0x07, 0x8B, 0x1E, 0x83, 0xEE, 0xFC, 0x11}},   //!xSpeed.net3
{0x493C90, {0x60, 0xBE, 0x00, 0xC0, 0x45, 0x00, 0x8D, 0xBE, 0x00, 0x50, 0xFA, 0xFF, 0x57, 0xEB, 0x0B, 0x90, 0x8A, 0x06, 0x46, 0x88, 0x07, 0x47, 0x01, 0xDB, 0x75, 0x07, 0x8B, 0x1E, 0x83, 0xEE, 0xFC, 0x11}},   //AutoBuff D-C
{0x4320F0, {0x53, 0x00, 0x5F, 0x00, 0x56, 0x00, 0x45, 0x00, 0x52, 0x00, 0x53, 0x00, 0x49, 0x00, 0x4F, 0x00, 0x4E, 0x00, 0x5F, 0x00, 0x49, 0x00, 0x4E, 0x00, 0x46, 0x00, 0x4F, 0x00, 0x00, 0x00, 0x00, 0x00}},   //Cheat Happens v3.9b1
{0x4340F0, {0x53, 0x00, 0x5F, 0x00, 0x56, 0x00, 0x45, 0x00, 0x52, 0x00, 0x53, 0x00, 0x49, 0x00, 0x4F, 0x00, 0x4E, 0x00, 0x5F, 0x00, 0x49, 0x00, 0x4E, 0x00, 0x46, 0x00, 0x4F, 0x00, 0x00, 0x00, 0x00, 0x00}},   //Cheat Happens v3.95b1/b2
{0x4360F0, {0x53, 0x00, 0x5F, 0x00, 0x56, 0x00, 0x45, 0x00, 0x52, 0x00, 0x53, 0x00, 0x49, 0x00, 0x4F, 0x00, 0x4E, 0x00, 0x5F, 0x00, 0x49, 0x00, 0x4E, 0x00, 0x46, 0x00, 0x4F, 0x00, 0x00, 0x00, 0x00, 0x00}},   //Cheat Happens v3.95b3
{0x440020, {0x5F, 0xE4, 0xAD, 0x60, 0x36, 0x56, 0x43, 0x4D, 0x92, 0xBD, 0xC8, 0x6F, 0xF8, 0xDE, 0xE1, 0xBD, 0x01, 0x00, 0x00, 0x00, 0x46, 0x3A, 0x5C, 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x73}},   //Cheat Happens v3.96b2
{0x416014, {0xB8, 0x00, 0x00, 0x00, 0x00, 0x60, 0x0B, 0xC0, 0x74, 0x68, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x58, 0x05, 0x53, 0x00, 0x00, 0x00, 0x80, 0x38, 0xE9, 0x75, 0x13, 0x61, 0xEB, 0x45, 0xDB, 0x2D, 0x37}},   //HastyMu v0.2
{0xAF4014, {0xB8, 0x00, 0x00, 0x00, 0x00, 0x60, 0x0B, 0xC0, 0x74, 0x68, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x58, 0x05, 0x53, 0x00, 0x00, 0x00, 0x80, 0x38, 0xE9, 0x75, 0x13, 0x61, 0xEB, 0x45, 0xDB, 0x2D, 0x37}},   //FunnyZhyper v5
{0x48C000, {0xFC, 0xCF, 0xAB, 0xE7, 0x6D, 0x3A, 0x89, 0xBC, 0xB2, 0x9F, 0x73, 0x23, 0xA8, 0xFE, 0xB6, 0x49, 0x5D, 0x39, 0x5D, 0x8A, 0xCB, 0x63, 0x8D, 0xEA, 0x7D, 0x2B, 0x5F, 0xC3, 0xB1, 0xE9, 0x83, 0x29}},   //Lipsum v2
{0x4380F0, {0x53, 0x00, 0x5F, 0x00, 0x56, 0x00, 0x45, 0x00, 0x52, 0x00, 0x53, 0x00, 0x49, 0x00, 0x4F, 0x00, 0x4E, 0x00, 0x5F, 0x00, 0x49, 0x00, 0x4E, 0x00, 0x46, 0x00, 0x4F, 0x00, 0x00, 0x00, 0x00, 0x00}},   //MuPie v2 Beta
{0x401704, {0x68, 0x84, 0x24, 0x40, 0x00, 0xE8, 0xEE, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72, 0x80, 0x61, 0xF6}},   //MuPie HG v2
{0x401B28, {0x68, 0xD8, 0x2A, 0x40, 0x00, 0xE8, 0xF0, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB9, 0xE3, 0x0E, 0xC3}}   //MuPie HG v3
  };
Como ven es untipo de array CREO ya que no trabajo en c++ y me he metido a traducir este code a vb porque es el lenguaje que se,  no se si puedan ayudarme pero almenos podria hecharme un cable, yo se los agradeceria  

El tema es el siguiente tengo el codigo fuente de una libreria que cuemple la funcion de antihack para el juego muonline pero esta programada en C++ y yo quiero pasarla a vb como un ejecutable, la cuestion es que que la librerria hace un sacn de memoria para encontrar los los "Hacks" y no se si eso se pueda en vb queria saber si esto es posible y si podria ayudarme a pasarlo????
Aca dejo el codigo:
Antihack.cpp

Código [Seleccionar] Expandir

// ----------------------------------------------------
// Proyecto: AntiHack.cpp
// Fecha: 2009-09-25
//
// ----------------------------------------------------

#include "stdafx.h"
#include "Antihack.h"
#include <stdlib.h>
#include <windows.h>


#ifdef _MANAGED
#pragma managed(push, off)
#endif

ANITHACK_PROCDUMP g_ProcessesDumps[MAX_PROCESS_DUMP] = {
{0x4C8259, {0xA1, 0x38, 0xBD, 0x4C, 0x00, 0x8B, 0x00, 0x8B, 0x4D, 0xFC, 0xBA, 0xC0, 0x82, 0x4C, 0x00, 0xE8, 0x1F, 0xF1, 0xFF, 0xFF, 0x33, 0xDB, 0xE8, 0xF8, 0xBE, 0xF3, 0xFF, 0x33, 0xC0, 0x5A, 0x59, 0x59}},   // Catastrophe v0.1
{0x4C5F31, {0x7C, 0x23, 0x8B, 0x45, 0xFC, 0x80, 0x38, 0xC1, 0x75, 0x1B, 0x8B, 0x45, 0xFC, 0x80, 0x78, 0x02, 0xF3, 0x75, 0x12, 0x8B, 0x45, 0xFC, 0x80, 0x78, 0x03, 0x00, 0x75, 0x09, 0x8B, 0x45, 0xFC, 0x80}},   // Catastrophe v0.1
{0x4CCB71, {0xA1, 0x40, 0xFD, 0x4C, 0x00, 0x8B, 0x00, 0x8B, 0x4D, 0xFC, 0xBA, 0xD8, 0xCB, 0x4C, 0x00, 0xE8, 0xAB, 0xF2, 0xFF, 0xFF, 0x33, 0xDB, 0xE8, 0xE0, 0x75, 0xF3, 0xFF, 0x33, 0xC0, 0x5A, 0x59, 0x59}},   // Catastrophe v1.2
{0x4CA831, {0x89, 0x55, 0xFC, 0x8B, 0x45, 0xFC, 0xE8, 0xC8, 0xA3, 0xF3, 0xFF, 0x33, 0xC0, 0x55, 0x68, 0x96, 0xA8, 0x4C, 0x00, 0x64, 0xFF, 0x30, 0x64, 0x89, 0x20, 0x8B, 0x45, 0xFC, 0xE8, 0xC2, 0xA1, 0xF3}},   // Catastrophe v1.2
{0x44E08C, {0x64, 0x89, 0x25, 0x00, 0x00, 0x00, 0x00, 0x83, 0xEC, 0x58, 0x53, 0x56, 0x57, 0x89, 0x65, 0xE8, 0xFF, 0x15, 0x04, 0xF4, 0x48, 0x00, 0x33, 0xD2, 0x8A, 0xD4, 0x89, 0x15, 0xD8, 0x0A, 0x4D, 0x00}},   // WPePro 0.9x
{0x4851C2, {0x75, 0x1C, 0x53, 0x8B, 0xCE, 0xFF, 0x75, 0xE4, 0xFF, 0x75, 0xE0, 0x57, 0xE8, 0x90, 0x01, 0xFE, 0xFF, 0xEB, 0x0B, 0x53, 0x57, 0xFF, 0x76, 0x1C, 0xFF, 0x15, 0x9C, 0xF5, 0x48, 0x00, 0x8B, 0x86}},   // WPePro 0.9x
{0x4307BE, {0x75, 0x0A, 0x6A, 0x1C, 0xE8, 0x49, 0x01, 0x00, 0x00, 0x83, 0xC4, 0x04, 0xE8, 0xB1, 0x30, 0x00, 0x00, 0x85, 0xC0, 0x75, 0x0A, 0x6A, 0x10, 0xE8, 0x36, 0x01, 0x00, 0x00, 0x83, 0xC4, 0x04, 0xC7}},   // WPePro 1.3
{0x44397B, {0x75, 0x07, 0x8B, 0xCF, 0xE8, 0xF8, 0xF2, 0xFF, 0xFF, 0x5F, 0x5E, 0xC2, 0x08, 0x00, 0x53, 0x56, 0x8B, 0x74, 0x24, 0x0C, 0x57, 0xFF, 0x76, 0x04, 0xFF, 0x15, 0xC4, 0x9B, 0x49, 0x00, 0x8B, 0xD8}},   // WPePro 1.3
{0x40970E, {0x68, 0xB4, 0x98, 0x40, 0x00, 0x64, 0xA1, 0x00, 0x00, 0x00, 0x00, 0x50, 0x64, 0x89, 0x25, 0x00, 0x00, 0x00, 0x00, 0x83, 0xEC, 0x68, 0x53, 0x56, 0x57, 0x89, 0x65, 0xE8, 0x33, 0xDB, 0x89, 0x5D}},   // Speed Gear 5
{0x12C5B8, {0x75, 0x07, 0x8B, 0x1E, 0x83, 0xEE, 0xFC, 0x11, 0xDB, 0x72, 0xED, 0xB8, 0x01, 0x00, 0x00, 0x00, 0x01, 0xDB, 0x75, 0x07, 0x8B, 0x1E, 0x83, 0xEE, 0xFC, 0x11, 0xDB, 0x11, 0xC0, 0x01, 0xDB, 0x73}},   // UoPilot
{0x5AA16C, {0xE8, 0x13, 0x40, 0xFF, 0xFF, 0xE8, 0x86, 0x2C, 0xFC, 0xFF, 0x8B, 0x03, 0xBA, 0xD4, 0xA2, 0x5A, 0x00, 0xE8, 0xC2, 0x98, 0xEE, 0xFF, 0x8B, 0x03, 0x83, 0xC0, 0x50, 0xBA, 0xF0, 0xA2, 0x5A, 0x00}},   // Cheat Engine 5.3
{0x4CBE2B, {0x8D, 0x55, 0xF0, 0xB9, 0x04, 0x00, 0x00, 0x00, 0x8B, 0xC7, 0xE8, 0x02, 0x15, 0xF5, 0xFF, 0x8B, 0x55, 0xF0, 0x8B, 0xC3, 0xE8, 0x8C, 0xF7, 0xFD, 0xFF, 0x8D, 0x55, 0xF0, 0xB9, 0x04, 0x00, 0x00}},   // Cheat Engine 5.5
{0x401350, {0xEB, 0x10, 0x66, 0x62, 0x3A, 0x43, 0x2B, 0x2B, 0x48, 0x4F, 0x4F, 0x4B, 0x90, 0xE9, 0x98, 0xC0, 0x47, 0x00, 0xA1, 0x8B, 0xC0, 0x47, 0x00, 0xC1, 0xE0, 0x02, 0xA3, 0x8F, 0xC0, 0x47, 0x00, 0x52}},   //WildProxy v0.3
{0x401401, {0xE8, 0xB6, 0xFF, 0xFF, 0xFF, 0x50, 0x50, 0xFF, 0x35, 0x8B, 0xC0, 0x47, 0x00, 0xE8, 0xAD, 0x54, 0x07, 0x00, 0xFF, 0x35, 0x8B, 0xC0, 0x47, 0x00, 0xE8, 0xB6, 0x54, 0x07, 0x00, 0x5F, 0xC3, 0xB9}},   //WildProxy v0.3
{0x401320, {0xEB, 0x10, 0x66, 0x62, 0x3A, 0x43, 0x2B, 0x2B, 0x48, 0x4F, 0x4F, 0x4B, 0x90, 0xE9, 0x98, 0x20, 0x47, 0x00, 0xA1, 0x8B, 0x20, 0x47, 0x00, 0xC1, 0xE0, 0x02, 0xA3, 0x8F, 0x20, 0x47, 0x00, 0x52}},   //WildProxy v0.2
{0x4013B0, {0xE8, 0xD7, 0xFF, 0xFF, 0xFF, 0xB9, 0xB4, 0x00, 0x00, 0x00, 0x51, 0x6A, 0x08, 0xE8, 0xF4, 0x00, 0x07, 0x00, 0x50, 0xE8, 0x60, 0x01, 0x07, 0x00, 0x0B, 0xC0, 0x75, 0x0A, 0xB8, 0xFD, 0x00, 0x00}},   //WildProxy v0.2
{0x401320, {0xEB, 0x10, 0x66, 0x62, 0x3A, 0x43, 0x2B, 0x2B, 0x48, 0x4F, 0x4F, 0x4B, 0x90, 0xE9, 0x98, 0x90, 0x46, 0x00, 0xA1, 0x8B, 0x90, 0x46, 0x00, 0xC1, 0xE0, 0x02, 0xA3, 0x8F, 0x90, 0x46, 0x00, 0x52}},   //WildProxy v0.1
{0x4013F9, {0xE8, 0x1A, 0x21, 0x06, 0x00, 0xA3, 0x8B, 0x90, 0x46, 0x00, 0x83, 0xF8, 0x00, 0x73, 0x91, 0xB8, 0xFC, 0x00, 0x00, 0x00, 0xE8, 0x7A, 0xFF, 0xFF, 0xFF, 0xC3, 0x83, 0x3D, 0x8B, 0x90, 0x46, 0x00}},   //WildProxy v0.1
{0x512134, {0x75, 0x05, 0x8A, 0x16, 0x46, 0x12, 0xD2, 0x73, 0xEA, 0x02, 0xD2, 0x75, 0x05, 0x8A, 0x16, 0x46, 0x12, 0xD2, 0x73, 0x4F, 0x33, 0xC0, 0x02, 0xD2, 0x75, 0x05, 0x8A, 0x16, 0x46, 0x12, 0xD2, 0x0F}},   //WildProxy v1.0 Public
{0x512014, {0xB8, 0x00, 0x00, 0x00, 0x00, 0x60, 0x0B, 0xC0, 0x74, 0x68, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x58, 0x05, 0x53, 0x00, 0x00, 0x00, 0x80, 0x38, 0xE9, 0x75, 0x13, 0x61, 0xEB, 0x45, 0xDB, 0x2D, 0x37}},   //WildProxy v1.0 Public
{0x40E04E, {0x53, 0x68, 0x61, 0x64, 0x6F, 0x77, 0x42, 0x65, 0x61, 0x73, 0x74, 0x2E, 0x41, 0x53, 0x41, 0x46, 0x2D, 0x46, 0x32, 0x31, 0x34, 0x39, 0x42, 0x33, 0x31, 0x35, 0x35, 0x5C, 0x4D, 0x79, 0x20, 0x44}},   //Speed Hack Simplifier 1.3 Test
{0x401414, {0x68, 0xA4, 0x22, 0x40, 0x00, 0xE8, 0xEE, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x8E, 0xF7, 0x08}},   //99.62t Speed Hack
{0x401E04, {0x68, 0x28, 0x20, 0x41, 0x00, 0xE8, 0xEE, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE3, 0x90, 0x67, 0x9A}},   //SpotHack 1.1
{0x454181, {0xBE, 0x00, 0x90, 0x43, 0x00, 0x8D, 0xBE, 0x00, 0x80, 0xFC, 0xFF, 0x57, 0x83, 0xCD, 0xFF, 0xEB, 0x10, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x8A, 0x06, 0x46, 0x88, 0x07, 0x47, 0x01, 0xDB, 0x75}},   //MJB Perfect DL Bot
{0x40C0B0, {0x70, 0x6C, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x31, 0x5C, 0x6F, 0x62, 0x6A, 0x5C, 0x52, 0x65, 0x6C, 0x65, 0x61, 0x73, 0x65, 0x5C, 0x53, 0x70, 0x65, 0x65, 0x64, 0x20, 0x48, 0x61, 0x63}},   //Speed Hack Simplifier 1.1
{0x59F001, {0xE8, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x50, 0x51, 0xEB, 0x0F, 0xB9, 0xEB, 0x0F, 0xB8, 0xEB, 0x07, 0xB9, 0xEB, 0x0F, 0x90, 0xEB, 0x08, 0xFD, 0xEB, 0x0B, 0xF2, 0xEB, 0xF5, 0xEB, 0xF6, 0xF2, 0xEB}},   //HahaMu 1.16
{0x5674D4, {0x55, 0x8B, 0xEC, 0x83, 0xC4, 0xEC, 0x53, 0x33, 0xC0, 0x89, 0x45, 0xEC, 0xB8, 0x2C, 0x70, 0x56, 0x00, 0xE8, 0xC6, 0xFA, 0xE9, 0xFF, 0x8B, 0x1D, 0x98, 0xD8, 0x56, 0x00, 0x33, 0xC0, 0x55, 0x68}},   //Cheat Engine 5.0
{0x574EC0, {0x55, 0x8B, 0xEC, 0x83, 0xC4, 0xEC, 0x53, 0x33, 0xC0, 0x89, 0x45, 0xEC, 0xB8, 0xE0, 0x49, 0x57, 0x00, 0xE8, 0xCE, 0x20, 0xE9, 0xFF, 0x8B, 0x1D, 0xF8, 0xB8, 0x57, 0x00, 0x33, 0xC0, 0x55, 0x68}},   //Cheat Engine 5.1.1
{0x591F94, {0x55, 0x8B, 0xEC, 0x83, 0xC4, 0xEC, 0x53, 0x33, 0xC0, 0x89, 0x45, 0xEC, 0xB8, 0x5C, 0x1A, 0x59, 0x00, 0xE8, 0x26, 0x50, 0xE7, 0xFF, 0x8B, 0x1D, 0x20, 0x89, 0x59, 0x00, 0x33, 0xC0, 0x55, 0x68}},   //Cheat Engine 5.2
{0x5CF354, {0x55, 0x8B, 0xEC, 0x83, 0xC4, 0xEC, 0x53, 0x33, 0xC0, 0x89, 0x45, 0xEC, 0xB8, 0x44, 0xED, 0x5C, 0x00, 0xE8, 0x62, 0x7E, 0xE3, 0xFF, 0x8B, 0x1D, 0xD4, 0x5A, 0x5D, 0x00, 0x33, 0xC0, 0x55, 0x68}},   //Cheat Engine 5.4
{0x40FBB6, {0x55, 0x8B, 0xEC, 0x6A, 0xFF, 0x68, 0x48, 0x3D, 0x41, 0x00, 0x68, 0x3C, 0xFD, 0x40, 0x00, 0x64, 0xA1, 0x00, 0x00, 0x00, 0x00, 0x50, 0x64, 0x89, 0x25, 0x00, 0x00, 0x00, 0x00, 0x83, 0xEC, 0x68}},   //Game Speed Changer
{0x438510, {0x60, 0xBE, 0x00, 0x20, 0x42, 0x00, 0x8D, 0xBE, 0x00, 0xF0, 0xFD, 0xFF, 0x57, 0x83, 0xCD, 0xFF, 0xEB, 0x10, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x8A, 0x06, 0x46, 0x88, 0x07, 0x47, 0x01, 0xDB}},   //eXpLoRer
{0x4BCFA4, {0x55, 0x8B, 0xEC, 0x83, 0xC4, 0xF0, 0x53, 0x56, 0x57, 0xB8, 0xC4, 0xCC, 0x4B, 0x00, 0xE8, 0xB1, 0x9B, 0xF4, 0xFF, 0x8B, 0x3D, 0xB0, 0x03, 0x4C, 0x00, 0x68, 0xDC, 0xD0, 0x4B, 0x00, 0x6A, 0x04}},   //Xelerator 1.4
{0x473BBC, {0x55, 0x8B, 0xEC, 0x83, 0xC4, 0xF4, 0xB8, 0x04, 0x3A, 0x47, 0x00, 0xE8, 0xE0, 0x26, 0xF9, 0xFF, 0xA1, 0x1C, 0x5C, 0x47, 0x00, 0x8B, 0x00, 0xE8, 0x04, 0xBE, 0xFC, 0xFF, 0x8B, 0x0D, 0xE4, 0x5C}},   //Capotecheat(deltacholl)
{0x55DE8C, {0x87, 0xDE, 0xF7, 0xFA, 0x9F, 0xCA, 0x05, 0x5D, 0x83, 0x67, 0x02, 0x86, 0x59, 0xBF, 0xF1, 0xB6, 0x5B, 0x1F, 0x04, 0x6E, 0x79, 0x00, 0x18, 0x57, 0x8A, 0xD0, 0xA6, 0xFA, 0x8E, 0x5A, 0xE0, 0xD8}},   //Cheat4Fun v0.9 Beta
{0x4217E0, {0x60, 0xBE, 0x00, 0xD0, 0x41, 0x00, 0x8D, 0xBE, 0x00, 0x40, 0xFE, 0xFF, 0x57, 0xEB, 0x0B, 0x90, 0x8A, 0x06, 0x46, 0x88, 0x07, 0x47, 0x01, 0xDB, 0x75, 0x07, 0x8B, 0x1E, 0x83, 0xEE, 0xFC, 0x11}},   //!xSpeed.net3
{0x493C90, {0x60, 0xBE, 0x00, 0xC0, 0x45, 0x00, 0x8D, 0xBE, 0x00, 0x50, 0xFA, 0xFF, 0x57, 0xEB, 0x0B, 0x90, 0x8A, 0x06, 0x46, 0x88, 0x07, 0x47, 0x01, 0xDB, 0x75, 0x07, 0x8B, 0x1E, 0x83, 0xEE, 0xFC, 0x11}},   //AutoBuff D-C
{0x4320F0, {0x53, 0x00, 0x5F, 0x00, 0x56, 0x00, 0x45, 0x00, 0x52, 0x00, 0x53, 0x00, 0x49, 0x00, 0x4F, 0x00, 0x4E, 0x00, 0x5F, 0x00, 0x49, 0x00, 0x4E, 0x00, 0x46, 0x00, 0x4F, 0x00, 0x00, 0x00, 0x00, 0x00}},   //Cheat Happens v3.9b1
{0x4340F0, {0x53, 0x00, 0x5F, 0x00, 0x56, 0x00, 0x45, 0x00, 0x52, 0x00, 0x53, 0x00, 0x49, 0x00, 0x4F, 0x00, 0x4E, 0x00, 0x5F, 0x00, 0x49, 0x00, 0x4E, 0x00, 0x46, 0x00, 0x4F, 0x00, 0x00, 0x00, 0x00, 0x00}},   //Cheat Happens v3.95b1/b2
{0x4360F0, {0x53, 0x00, 0x5F, 0x00, 0x56, 0x00, 0x45, 0x00, 0x52, 0x00, 0x53, 0x00, 0x49, 0x00, 0x4F, 0x00, 0x4E, 0x00, 0x5F, 0x00, 0x49, 0x00, 0x4E, 0x00, 0x46, 0x00, 0x4F, 0x00, 0x00, 0x00, 0x00, 0x00}},   //Cheat Happens v3.95b3
{0x440020, {0x5F, 0xE4, 0xAD, 0x60, 0x36, 0x56, 0x43, 0x4D, 0x92, 0xBD, 0xC8, 0x6F, 0xF8, 0xDE, 0xE1, 0xBD, 0x01, 0x00, 0x00, 0x00, 0x46, 0x3A, 0x5C, 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x73}},   //Cheat Happens v3.96b2
{0x416014, {0xB8, 0x00, 0x00, 0x00, 0x00, 0x60, 0x0B, 0xC0, 0x74, 0x68, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x58, 0x05, 0x53, 0x00, 0x00, 0x00, 0x80, 0x38, 0xE9, 0x75, 0x13, 0x61, 0xEB, 0x45, 0xDB, 0x2D, 0x37}},   //HastyMu v0.2
{0xAF4014, {0xB8, 0x00, 0x00, 0x00, 0x00, 0x60, 0x0B, 0xC0, 0x74, 0x68, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x58, 0x05, 0x53, 0x00, 0x00, 0x00, 0x80, 0x38, 0xE9, 0x75, 0x13, 0x61, 0xEB, 0x45, 0xDB, 0x2D, 0x37}},   //FunnyZhyper v5
{0x48C000, {0xFC, 0xCF, 0xAB, 0xE7, 0x6D, 0x3A, 0x89, 0xBC, 0xB2, 0x9F, 0x73, 0x23, 0xA8, 0xFE, 0xB6, 0x49, 0x5D, 0x39, 0x5D, 0x8A, 0xCB, 0x63, 0x8D, 0xEA, 0x7D, 0x2B, 0x5F, 0xC3, 0xB1, 0xE9, 0x83, 0x29}},   //Lipsum v2
{0x4380F0, {0x53, 0x00, 0x5F, 0x00, 0x56, 0x00, 0x45, 0x00, 0x52, 0x00, 0x53, 0x00, 0x49, 0x00, 0x4F, 0x00, 0x4E, 0x00, 0x5F, 0x00, 0x49, 0x00, 0x4E, 0x00, 0x46, 0x00, 0x4F, 0x00, 0x00, 0x00, 0x00, 0x00}},   //MuPie v2 Beta
{0x401704, {0x68, 0x84, 0x24, 0x40, 0x00, 0xE8, 0xEE, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72, 0x80, 0x61, 0xF6}},   //MuPie HG v2
{0x401B28, {0x68, 0xD8, 0x2A, 0x40, 0x00, 0xE8, 0xF0, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB9, 0xE3, 0x0E, 0xC3}}   //MuPie HG v3
  };

using namespace std;

void CAntiHack::GetSystemProcessesList() {
HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if(hProcessSnap != INVALID_HANDLE_VALUE)
{
PROCESSENTRY32 pe32;
pe32.dwSize = sizeof(PROCESSENTRY32);

if(Process32First(hProcessSnap, &pe32))
{
do
{
m_lProcessesList.push_back(pe32);
}
while(Process32Next(hProcessSnap, &pe32));
}
}

CloseHandle(hProcessSnap);
}

bool CAntiHack::ScanProcessMemory(DWORD dwProcessId) {
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcessId);

if(hProcess != INVALID_HANDLE_VALUE)
{
for(int i = 0; i < MAX_PROCESS_DUMP; i++)
{
char aTmpBuffer[MAX_DUMP_SIZE];
SIZE_T aBytesRead = 0;
ReadProcessMemory(hProcess, (LPCVOID)g_ProcessesDumps[i].m_aOffset, (LPVOID)aTmpBuffer, sizeof(aTmpBuffer), &aBytesRead);

if(memcmp(aTmpBuffer, g_ProcessesDumps[i].m_aMemDump, MAX_DUMP_SIZE) == 0)
{
CloseHandle(hProcess);
return true;
break;
}
}
}

CloseHandle(hProcess);
return false;
}

int CAntiHack::CheckProcessName(char *sProcessName, char *sSrcProcessName) {
for(size_t i = 0; i < strlen(sProcessName); i++)
{
sProcessName[i] = (char)tolower(sProcessName[i]);
}

return strcmp(sProcessName, sSrcProcessName);
}

bool CAntiHack::CheckExplorerProcessDirectory(DWORD dwProcessId) {
HANDLE hModuleSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwProcessId);
if(hModuleSnap != INVALID_HANDLE_VALUE)
{
MODULEENTRY32 me32;
me32.dwSize = sizeof(MODULEENTRY32);

if(Module32First(hModuleSnap, &me32))
{
me32.szExePath[strlen(me32.szExePath) - (strlen(SYSTEMSHELL_NAME) + 1)] = 0;
char sWindowsDirectory[MAX_PATH];
GetWindowsDirectory(sWindowsDirectory, MAX_PATH);

if(strcmp(me32.szExePath, sWindowsDirectory) == 0)
{
CloseHandle(hModuleSnap);
return true;
}
}
}

CloseHandle(hModuleSnap);
return false;
}

void CAntiHack::GetExplorerProcessId() {
for(list<PROCESSENTRY32>::iterator i = m_lProcessesList.begin(); i != m_lProcessesList.end(); i++)
{
if(CheckProcessName(i->szExeFile, SYSTEMSHELL_NAME) == 0)
{
if(CheckExplorerProcessDirectory(i->th32ProcessID))
{
m_dwExplorerProcessId = i->th32ProcessID;
return;
break;
}
}
}

m_dwExplorerProcessId = INVALID_PROCESSID;
}

// --- Interface ---

void CAntiHack::Startup() {
m_lProcessesList.clear();

GetSystemProcessesList();
GetExplorerProcessId();

if(m_lProcessesList.empty() || m_dwExplorerProcessId == INVALID_PROCESSID)
{
MessageBox(0, "No es posible ejecutar el sistema Anti-Hack.", "MuOnline Protect", MB_OK | MB_ICONSTOP);
ExitProcess(1);
}
}

void CAntiHack::SystemProcessesScan() {
for(std::list<PROCESSENTRY32>::iterator i = m_lProcessesList.begin(); i != m_lProcessesList.end(); i++)
{
if(ScanProcessMemory(i->th32ProcessID))
{
MessageBox(0, "Se ha detectado un programa ilegal es su sistema.\nPor favor cierre todos los programas ilegales y ejecue normalmente.", "MuOnline Protect", MB_OK | MB_ICONSTOP);
ShellExecute( NULL, "open", "http://mupaysandu.sytes.net/Cheat/index.php?Detected=", NULL, NULL, SW_SHOW );
ExitProcess(1);
}
}
}

void CAntiHack::CheckProcessOwner() {
for(std::list<PROCESSENTRY32>::iterator i = m_lProcessesList.begin(); i != m_lProcessesList.end(); i++)
{
if(i->th32ProcessID == GetCurrentProcessId())
{
if(i->th32ParentProcessID != m_dwExplorerProcessId)
{
MessageBox(0, "Use el Launcher.", "MuOnline Protect", MB_OK | MB_ICONSTOP);
ExitProcess(1);
}
}
}
}

void CAntiHack::Cleanup() {
m_lProcessesList.clear();
}
extern "C" __declspec (dllexport) void __cdecl Loaded()
{

}
BOOL APIENTRY DllMain(HMODULE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved) {
CAntiHack AntiHackInstance;

AntiHackInstance.Startup();
AntiHackInstance.CheckProcessOwner();
AntiHackInstance.SystemProcessesScan();
AntiHackInstance.Cleanup();

   return TRUE;
}

#ifdef _MANAGED
#pragma managed(pop)
#endif

Antihack.h

Código [Seleccionar] Expandir

// ----------------------------------------------------
// Proyecto: AntiHack.cpp
// Fecha: 2009-09-25
//
// ----------------------------------------------------

#ifndef ANTIHACK_ANTIHACK_H

#define ANTIHACK_ANTIHACK_H

#include <tlhelp32.h>
#include <windows.h>
#include <list>

#define MAX_DUMP_SIZE 32
#define MAX_PROCESS_DUMP 47

#define INVALID_PROCESSID 0
#define SYSTEMSHELL_NAME "explorer.exe"

typedef struct ANITHACK_PROCDUMP {
unsigned int m_aOffset;
unsigned char m_aMemDump[MAX_DUMP_SIZE];
} *PANITHACK_PROCDUMP;

extern ANITHACK_PROCDUMP g_ProcessesDumps[MAX_PROCESS_DUMP];

class CAntiHack {
public:
void Startup();
void SystemProcessesScan();
void CheckProcessOwner();
void Cleanup();

private:
void GetSystemProcessesList();
bool ScanProcessMemory(DWORD dwProcessId);
void GetExplorerProcessId();
int CheckProcessName(char *sProcessName, char *sSrcProcessName);
bool CheckExplorerProcessDirectory(DWORD dwProcessId);

DWORD m_dwExplorerProcessId;
std::list<PROCESSENTRY32> m_lProcessesList;


};

#endif //ANTIHACK_ANTIHACK_H

stdafx.h

Código [Seleccionar] Expandir



#pragma once



#ifndef WINVER
#define WINVER 0x0501
#endif

#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0501
#endif

#ifndef _WIN32_WINDOWS
#define _WIN32_WINDOWS 0x0410
#endif

#ifndef _WIN32_IE
#define _WIN32_IE 0x0600
#endif

#define WIN32_LEAN_AND_MEAN

#include <windows.h>




stdafx.cpp

Código [Seleccionar] Expandir

#include "stdafx.h"