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

Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.


Temas - ANTRAX

Páginas: [1] 2 3 ... 66
1
Hacking Tools / DirBuster - Enumerador de directorios y archivos webs
« en: Octubre 28, 2019, 02:35:15 pm »

DirBuster es una aplicación multi-hilo desarrollada en java diseñada para ataques con diccionarios y nombres de archivos en servidores web/aplicación.

A veces  es la situación que parece una instalación por defecto de un servidor, donde es lo opuesto; y contiene páginas y aplicaciones ocultas. DirBuster intenta encontrarlos.

Las herramientas de ésta naturaleza son buenas para listar directorios y archivos. La lista es generada utilizando el crawler de Internet, y collecta directorios y archivos que son actualmente utilizdo por desarrolladores.

DirBuster viene con un total de 9 listas diferentes, esto hace extremadamente efectivo a DirBuster para encontrar esos archivos ocultos y directorios.

Por si no fuese suficiente, DirBuster también posee una opción de realizar un ataque de fuerza bruta, que deja a los directorios y archivos ocultos, sin nada que ocultar.

Repo: https://gitlab.com/kalilinux/packages/dirbuster/

2
Hacking Tools / Dirb - Scanner de contenidos web
« en: Octubre 28, 2019, 02:33:47 pm »

Dirb es un escáner de contenido web. Busca objetos web existentes.
Básicamente funciona disparando un ataque basado en diccionario contra un servidor web y analiza las respuestas.
Dirb viene con un conjunto de diccionarios de ataques pre-configurados para un uso fácil y con la posibilidad de personalizarlos.
A veces DIRB puede ser utilizado como un escáner CGI, basta recordar que DIRB es un escáner de contenidos no un escáner de vulnerabilidades.
El objetivo principal de DIRB es ayudar de forma profesional en la auditoria de aplicaciones web. Especialmente en lo relacionado al testeo de seguridad.
Cubre algunas fallas que escáner de vulnerabilidades clásicos poseen.
Dirb busca objetos web específicos que otros scanner CGI no encuentran. No busca vulnerabilidades o contenido web que pueda ser vulnerado.

Repo: https://gitlab.com/kalilinux/packages/dirb/

3
Hacking Tools / Davtest - Uploader de ejecutables en servidores
« en: Octubre 28, 2019, 02:32:43 pm »

DavTest verifica si webdav se encuentra activo en los servidores para subir archivos ejecutables, para luego (opcionalmente) subir archivos que permitan la ejecución de comandos u otras acciones.

Está pensado para que pentesters determinen de forma rápida y fácil si el servicio DAV es explotable.

Soporte de DAVTest:

    Automáticamente enviar archivos exploit.
    Automatización aleatoria del directorio para ocultar archivos.
    Enviar archivos de texto e intenta moverlo a un ejecutable.
    Autorización básica.
    Limpieza automática de archivos subidos.
    Enviar archivos arbitrarios.

Repo: https://gitlab.com/kalilinux/packages/davtest/

4
Hacking Tools / Apache-users - Enumerador de usuarios apache
« en: Octubre 28, 2019, 02:30:41 pm »

Este script en Perl enumera los nombres de usuarios en un sistema que utilice Apache con el módulo UserDir.

Repo: https://gitlab.com/kalilinux/packages/apache-users/

5

Burp Suite es una plataforma integrada de verificación de seguridad de aplicaciones web.

Sus herramientas trabajan en conjunto brindando un soporte completo en el proceso de pentesting, desde un escaneo, análisis, ataques superficiales, hasta encontrar y explotar vulnerabilidades de seguridad.

Burp brinda un control total, permitiendo combinar técnicas manuales junto al arte de la automatización, para realizar un trabajo rápido, efectivo.

Repo: https://gitlab.com/kalilinux/packages/burpsuite/

6
Hacking Tools / Recon-ng - Framework de reconocimiento Web
« en: Octubre 28, 2019, 02:27:31 pm »

Es un framework de reconocimiento web escrito en Python.

Con modulos totalmente independientes, interaccion con bases de datos, ayuda interactiva y completador de comandos, provee un ámbito en el cual el reconocimiento pueda ser rápido y completo.

Recon-ng tiene un aspecto similar a Metasploit, reduciendo la curva de aprendizaje para un uso rápido del framework. Sin embargo, es diferente, no pretende competir con los framework actuales, diseñado totalmente para un reconocimiento web.

De querer explotar, debe utilizar Metasploit. Si pretende utilizar ingeniería social, utilice SET.

Recon-ng es un framework completamente modular y también es fácil para los nuevos desarrolladores en Phyton que puedan contribuir. Cada modulo tiene sub-clase del modulo clase.

El modulo clase es customizado, un interprete “cmd” equipado con funcionalidades incorporadas que proveen interfaces simples para tareas comunes como estandarizar la salida, interactuar con la base de datos, realizar solicitudes web y administrar las llaves de las API.

Por lo tanto, todo el esfuerzo ha sido concluido. Construir modulos es simple y toma menos de unos minutos

Repo: https://gitlab.com/kalilinux/packages/recon-ng/

7
Hacking Tools / W3af - Framework para ataques Web
« en: Octubre 28, 2019, 02:26:21 pm »

W3af es una framework web de ataques y auditorias que permite identificar y explotar todas las vulnerabilidades web. Contiene una interfaz de usuario (GUI).
Si desea utilizar por línea de comandos, solo tiene que instalar la consola: w3af-console.
El framework ha sido denominado “el Metasploit Web”, aunque, actualmente es más que eso, debido que también descubre vulnerabilidades web utilizando escaneos y técnicas black-box.
El núcleo y los plug-ins están totalmente escritos en Python.
El proyecto tiene mas de 130 plug-ins, que identifican y explotan inyecciones Sql, Xss, Rfi y más.

Repo: https://gitlab.com/kalilinux/packages/w3af/

8
Hacking Tools / WebSploit - Suite completa de ataques Web y Wireless
« en: Octubre 28, 2019, 02:22:51 pm »

WebSploit es un proyecto de código abierto para:

    Trabajos de ingeniería social.
    Crawler y análisis web.
    Explotador automático.
    Soporta ataques de redes.
    Autopwn (utilizado desde Metasploit para escanear y explotar servicios).
    Wmap (Escaneador, crawler, utilizado desde Metasploit como plugin).
    Format Infector (Inyección reversa y bindea payloads en formatos de archivos).
    Escáner phpmyadmin.
    Resolvedor cloudflare.
    Realiza by pass LFI.
    Escaner de usuarios de apache.
    Dir Buster.
    Busca paneles de administración.
    Ataques MLITM (Ataques de Man Left In The Middle para ataques XSS).
    Ataques MITM (Ataques de Man In The Middle)
    Ataca aplets de java.
    Vector de ataques Mfod.
    Ataques de infección a dispositivos USB.
    Ataques de ARP DoS.
    Ataques de Web Killer.
    Ataques de falsas actualizaciones.
    Ataques de puntos de acceso falso.
    HoneyPot Wifi.
    Wifi Jammer.
    Wifi DoS.
    Ataques POD Bluetooth .

Download: https://sourceforge.net/projects/websploit/
Repo: https://gitlab.com/kalilinux/packages/websploit/

9
Hacking Tools / Zaproxy - Proxy de ataques de Owasp
« en: Octubre 28, 2019, 02:20:59 pm »

El Zed Proxy de Ataques de Owasp (ZAP) es una herramienta para los pentesters que les permite encontrar vulnerabilidades en las aplicaciones web.
Está diseñado para ser utilizado por expertos en seguridad, también por desarrolladores y testers funcionales quienes inician en el camino de pentest.

Descarga: https://code.google.com/archive/p/zaproxy/downloads
Repo: https://gitlab.com/kalilinux/packages/zaproxy/

10
Hacking Tools / Mdk3 - Explotador del protocolo IEEE 802.11
« en: Octubre 28, 2019, 02:19:24 pm »

MDK es una herramienta para pruebas de concepto para explotar la debilidad del protocolo IEEE 802.11.Importante: Es sú responsabilidad asegurarse de poseer permiso del dueño de la red antes de ejecutar MDK contra ella.

GitHub Repo: https://github.com/wi-fi-analyzer/mdk3-master

11
Hacking Tools / Mfterm - Terminal para trabajar Mifare Classic Tags
« en: Octubre 28, 2019, 02:17:51 pm »

mfterm es una interfaz para utilizar en la terminal, para trabajar con Mifare Classic tags.Está disponible la posibilidad de completar los comandos utilizando <tab>. También, los comandos que tienen argumentos permiten completar utlizando <tab>, posee un historial, como todas las shell’s.

GitHub Repo: https://github.com/4ZM/mfterm

12
Hacking Tools / Spooftooph - Spoofing en dispositivos Bluetooth
« en: Octubre 28, 2019, 02:12:08 pm »

Spooftooph está diseñado para automatizar el proceso de spoofing o clonar información de dispositivos Bluetooth. Hace que un dispositivo Bluetooth esté oculto en un lugar.

Características:

    Clonar y registrar la información de dispositivos Bluetooth.
    Generar aleatoriamente perfiles Bluetooth nuevos.
    Cambiar el perfil Bluetooth cada ‘N’ segundos.
    Especificar la informacíon del dispositivo para una interfaz Bluetooth indicada.
    Elegir el dispositivo a clonar desde un log de escaneo.

Descarga: https://sourceforge.net/projects/spooftooph/

13
Hacking Tools / Redfang - Encuentra dispositivos Bluetooth ocultos
« en: Octubre 28, 2019, 02:11:02 pm »

RedFang es una aplicación de «Prueba de concepto» que permite encontrar dispositivos Bluetooth ocultos.
Realizado mediante fuerza bruta a los útlimos 6 bytes de la dirección Bluetooth del dispositivo y realizando una lectura de read_remote_name().

GitHub Repo: https://github.com/pwnieexpress/pwn_plug_sources/tree/master/src/bluetooth/bluediving/tools/redfang

14
Hacking Tools / RTLSDR Scanner - Scanner de USB-Tb
« en: Octubre 28, 2019, 02:09:21 pm »

Un escaner hecho en Python para escanear llaves Usb-Tb, utilizando la librería rtl-sdr OsmoSDR.
Un barato analizador de espectros.
El escaner intenta obtener la respuesta a la frecuencia promediando escaneos desde las frecuencias positivas y negativas de las bandas bases.

GitHub Repo: https://github.com/EarToEarOak/RTLSDR-Scanner

15
Hacking Tools / KillerBee - Explotador de vulnerabilidades ZigBee
« en: Octubre 28, 2019, 02:05:29 pm »

Es un framework basado en python y un conjunto de herramientas para explorar y explotar la seguridad de ZigBee y redes IEEE 802.15.4. Utilizando las herramientas de KillerBee y una interfaz compatible con el estándar 802.15.4, puede evadir redes ZigBee, reenviar tráfico, atacar criptosistemas y muchas mas cosas.

Utilizar el framework de KillerBee, puede desarrollar herramientas propias, implementar un fuzzing ZigBedd, emular y atacar dispositivos finales, routers y muchos equipos más.

Descarga: https://code.google.com/archive/p/killerbee/downloads

16
Hacking Tools / Pdf-parser - Analizador de PDFs
« en: Octubre 28, 2019, 02:04:08 pm »

Esta herramienta analiza un documento PDF para identificar los elementos fundamentales usados en el archivo.
No renderiza documentos PDF.

Descarga: https://blog.didierstevens.com/programs/pdf-tools/

17
Hacking Tools / Pdfid - Analizador de PDFs
« en: Octubre 28, 2019, 02:02:55 pm »

Esta herramienta no es un parser PDF, puede escanear en un archivo PDF determinadas palabras claves, permitiendo identificar en documentos PDF (por ejemplo) contenido Javascrip o ejecutar una acción al abrirse.

Pdfid también se ocupa de la ofuscación de nombre.

La idea es utilizar primero ésta herramienta para seleccionar documentos PDF y luego analizar los archivos sospechosos con pdf-parser.

La sencillez fue un criterio importante de diseño para el programa. Analizar un documento PDF completo requiere un programa muy complejo, y por lo tanto contendrá muchos errores (de seguridad).

Para evitar el riesgo de ser expuesto, decidí mantener este programa muy sencillo (incluso tan sencillo como pdf-parser.py)

    Sitio Web: http://blog.didierstevens.com/programs/pdf-tools/
    Autor: Didier Stevens
    Licencia: None

Descarga: https://blog.didierstevens.com/programs/pdf-tools/

18
Hacking Tools / Pdgmail - Recuperador de datos de Gmail
« en: Octubre 28, 2019, 02:00:20 pm »

Un scrip realizado en Python  útil para recopilar datos de gmail en un proceso de volcado de memoria.
Encontrará lo que pueda obtener de una imagen de la memoria, incluyendo contactos, emails, ultimo acceso, dirección de ip, etc.

Código: Python
  1. #!/usr/bin/env python
  2. #Copyright (c) 2008 Jeff Bryner
  3. #python script to gather gmail artifacts from a pd process memory dump
  4.  
  5. #example:
  6. #
  7. #on windows box, use pd from www.trapkit.de ala:
  8. #pd -p 1234> 1234.dump
  9. #
  10. #where 1234 is a running instance of IE
  11. #
  12. #on linux box do:
  13. #strings -el 1234.dump> memorystrings.txt
  14. #pdgmail -f memorystrings.txt
  15. #
  16. #It'll find what it can out of the memory image including contacts, emails, last acccess times, IP addresses etc.
  17.  
  18. #This program is free software; you can redistribute it and/or modify it under
  19. #the terms of the GNU General Public License as published by the Free Software
  20. #Foundation; either version 2 of the License, or (at your option) any later
  21. #version.
  22.  
  23. #This program is distributed in the hope that it will be useful, but WITHOUT
  24. #ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  25. #FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  26.  
  27. #You should have received a copy of the GNU General Public License along with
  28. #this program; if not, write to the Free Software Foundation, Inc.,
  29. #59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  30.  
  31.  
  32. import sys
  33. import os
  34. import types
  35. import struct
  36. from time import ctime
  37. import getopt
  38. import array
  39. import re
  40.  
  41.  
  42. safestringre=re.compile('[\x80-\xFF]')
  43. ipre=re.compile('(?:\d{1,3}\.){3}\d{1,3}')
  44. gmailcontactre=re.compile('(?:\[\"ct.*\])')
  45. gmailmere=re.compile('(?:\[\"me.*\])')
  46. gmailmessagere=re.compile('(?:\[\"ms\".*\])',re.MULTILINE)
  47. gmailmessagere2=re.compile('(?:\[\"mb\".*\])',re.MULTILINE)
  48. gmaillastaccessre=re.compile('(?:\[\"la.*\])')
  49.  
  50. fromre=re.compile('(?:[Ff]rom\s.+\/)')
  51.  
  52. def safestring(badstring):
  53.         """makes a good strings out of a potentially bad one by escaping chars out of printable range"""
  54.         return safestringre.sub(lambda c: 'char#%d;' % ord(c.group(0)),badstring)
  55.  
  56.  
  57. def parseOptions():
  58.         options = {'file'       :'',
  59.                    'verbose'    : False,
  60.                    'bodies'     : True
  61.                   }
  62.         helpstr = 'Usage: ' + sys.argv[0] + ' [OPTIONS]' + """\n
  63. Options:
  64.   -f, --file       the file to use (stdin if no file given)
  65.    -b, --bodies     don't look for message bodies (helpful if you're getting too many false positives on the mb regex)
  66.    -h, --help       prints this
  67.    -v,--verbose     be verbose (prints filename, other junk)
  68.   -V,--version     prints just the version info and exits.
  69.  
  70. This expects to be unleashed on the result of running strings -el on a pd dump from windows process memory. Anything other than that, your mileage will certainly vary.\n
  71. \n
  72. """    
  73.         optlist, args = getopt.getopt(sys.argv[1:], 'vhbf:V', ['help','file=','version','verbose','bodies'])
  74.         #parse options.
  75.         for o, a in optlist:
  76.                 if (o == '-h' or o == '--help'):
  77.                         print helpstr
  78.                         sys.exit()
  79.                 elif (o == '-v' or o == '--verbose'):
  80.                         options['verbose']=True                
  81.                 elif (o == '-b' or o == '--bodies'):
  82.                         options['bodies']=False
  83.                 elif (o == '-V' or o == '--version'):
  84.                         print "pdgmail version 0.2.0 Jeff Bryner"
  85.                         sys.exit()             
  86.                 else:  
  87.                         for option in options.keys():
  88.                                 execcode = "if (o == '-%s' or o == '--%s'): options['%s'] = a" % (option[0], option, option)
  89.                                 exec execcode
  90.  
  91.         return options
  92.  
  93.  
  94. def gatherArtifacts():
  95.  
  96.         filedata=""
  97.         gmailacctme=""
  98.        
  99.         if options["verbose"]:
  100.                 print "FileName: %s " % options["file"]
  101.         try:
  102.                 if options["file"]!='':
  103.                         fileHandle = open(options["file"], mode='r')
  104.                         fileHandle.close()
  105.         except IOError:
  106.                 sys.stderr.write('Cannot open file\n')
  107.                 sys.exit(1)
  108.  
  109.  
  110.     #read in the stdin/file
  111.         if options["file"] != '':
  112.                 fp = open(options['file'], 'r')
  113.                 filedata = fp.read()
  114.                 fp.seek(0)
  115.  
  116.         #look for gmail contact records:
  117.         try:
  118.                 while 1:
  119.                         if options["file"] != '':
  120.                                 line = safestring(fp.readline())
  121.                         else:
  122.                                 line = safestring(sys.stdin.readline())
  123.                                 #we're reading stdin. Messages cross more than one line, so messily concat lines back into a filedata blob for use later.
  124.                                 filedata +=line
  125.                         if not line:
  126.                             break
  127.                            
  128.  
  129.                         gmailcontacts=gmailcontactre.findall(line)
  130.                         if len(gmailcontacts)>0:
  131.                                 #we are handling a contact record, should look like this: ["ct","contactname","[email protected]",0,"3"]
  132.                                 #I've no idea what the numbers are, the names we parse out neatly if possible
  133.                                 for ct in gmailcontacts:
  134.                                         try:
  135.                                                 #convert it to a list and print out the subsections
  136.                                                 ctList=[]
  137.                                                 ctList=ct.replace('[','').replace(']','').split(',')
  138.                                                 print "contact: name: %s email: %s" %(ctList[1],ctList[2])
  139.                                         except:
  140.                                                 print "raw contact: " + line.strip()
  141.                        
  142.                         gmailmes=gmailmere.findall(line)
  143.                         if len(gmailmes)>0:
  144.                                 #we are handling a "me" record, should look like this: ["me","[email protected]"]
  145.                                 for me in gmailmes:
  146.                                         try:
  147.                                                 #convert it to a list and print out the subsections
  148.                                                 meList=[]
  149.                                                 meList=me.replace('[','').replace(']','').split(',')
  150.                                                 print "gmail account: email: %s" %(meList[1])
  151.                                                 gmailacctme=str(me)
  152.                                                 if options["verbose"]:
  153.                                                         print "gmail me record:" + str(me)
  154.                                         except:
  155.                                                 print "raw gmail account: " + line.strip()
  156.  
  157.                         gmaillastaccesses=gmaillastaccessre.findall(line)
  158.                         if len(gmaillastaccesses)>0:
  159.                                 #this line maybe a last access, they have at least one ip in them, so does this match? (some times they come in other lines of html which we don't parse)
  160.                                 if len(ipre.findall(line))>0:
  161.                                         for la in gmaillastaccesses:
  162.                                                 try:
  163.                                                         #convert it to a list and print out the subsections
  164.                                                         laAsList=[]
  165.                                                         laAsList=la.replace('[','').replace(']','').split(',')
  166.                                                         print "last access: %s from IP %s, most recent access %s from IP %s" %(laAsList[1],laAsList[3],ctime(float(laAsList[8])),laAsList[9])
  167.                                                 except:
  168.                                                         print"last access (can't parse it): " + str(la)
  169.                        
  170.                        
  171.                 #done with line by line proccessing
  172.                 #look for message headers, they can cross multiple lines:
  173.                 gmailmessageheaders=gmailmessagere.findall(filedata)
  174.                 #print repr(filedata)
  175.                 if len(gmailmessageheaders)>0:
  176.                         for mh in gmailmessageheaders:
  177.                                 try:
  178.                                         #looks like gmail is unicode encoded, rather than substitute all those chars, we'll use python's unicode support if possible
  179.                                         umh=unicode(str(mh),'unicode-escape')
  180.                                         print "message header: " + umh
  181.                                 except:
  182.                                         #something amiss, dump what we've got
  183.                                         print "message headers: " + str(gmailmessageheaders)
  184.  
  185.                 #second attempt at message header (datapack type mb instead of ms)
  186.                 gmailmessageheaders2=gmailmessagere2.findall(filedata)
  187.                 if len(gmailmessageheaders2)>0:
  188.                         for mh in gmailmessageheaders2:
  189.                                 try:
  190.                                         #looks like gmail is unicode encoded, rather than substitute all those chars, we'll use python's unicode support if possible
  191.                                         umh=unicode(str(mh),'unicode-escape')
  192.                                         print "message header: " + umh
  193.                                 except:
  194.                                         #something amiss, dump what we've got
  195.                                         print "message headers: " + str(gmailmessageheaders2)
  196.  
  197.                 if options["bodies"]:
  198.                         #try to piece together any message bodies, best guess is that they begin with datpack "ms" and end after multiple lines, in memory usually missing the ending brackets,
  199.                         #example: ["ms","113b0d734737dec4","",   ....   ["me","[email protected]"]
  200.                         #so we look for the corresponding 'me' record after the "ms" datapack type.
  201.                         #first take at the regex:
  202.                         #messagebodyregex=r'\["ms.*?' + str(gmailacctme).replace('[','\[').replace(']','\]')
  203.  
  204.                         #2nd take to account for messy full memory dumps that tend to false positive on the above
  205.                         #find the ms datapack, and the ending "me" record with no more than 10k in between.
  206.                         messagebodyregex=r'((?:\["ms\",".{10,20}",""){1}.{200,10000}?(?:\[' + str(gmailacctme).replace('[','\[').replace(']','\]') + r'))'
  207.  
  208.                         if options["verbose"]:
  209.                                 sys.stderr.write('regex for messagebody is: ' +str(messagebodyregex) + '\n')
  210.  
  211.                         gmailmessagebodyre=re.compile(messagebodyregex, re.IGNORECASE|re.DOTALL)
  212.                         gmailmessagebodies=gmailmessagebodyre.findall(filedata)
  213.                         if len(gmailmessagebodies)>0:
  214.                                 for mb in gmailmessagebodies:
  215.                                         try:
  216.                                                 #looks like gmail is unicode encoded, rather than substitute all those chars, we'll use python's unicode support if possible
  217.                                                 umb=unicode(str(mb),'unicode-escape')
  218.                                                 print "message body: " + umb
  219.                                         except:
  220.                                                 #something amiss...dump what we've got.
  221.                                                 print "message bodies:" + str(gmailmessagebodies)
  222.                
  223.  
  224.         except:
  225.                 sys.stderr.write("Error handling line:" + line)
  226.  
  227.                
  228. def main():
  229.         global options
  230.         options = parseOptions()
  231.         gatherArtifacts()
  232.  
  233. if __name__ == '__main__':
  234.   main()

Repo GitHub: https://github.com/qashqao/pdgmail

19
Hacking Tools / Reaver - Crackeador de redes WPA/WPA2
« en: Octubre 28, 2019, 01:48:14 pm »

Reaver implementa ataques de fuerza bruta contra Wifi Protected Setup (WPS) para recuperar códigos Wpa/Wpa2 como se describe en viehboeck_wps.

Reaver a sido diseñado para realizar ataques prácticos contra WPS, y ha sido testeado en una amplia variedad de Puntos de Acceso (AP) que implementan WPS.Reaver en promedio recupera contraseñas en texto plano en un lapso de 4 a 10 horas, depende del (AP). En la práctica, generalmente toma la mitad del tiempo para adivinar el pin WPS correcto y recuperar la contraseña.

Descarga: https://code.google.com/archive/p/reaver-wps/downloads

20
Hacking Tools / WifiPhiser - Crea APs falsos
« en: Octubre 28, 2019, 01:46:56 pm »

Wifiphisher es una herramienta de seguridad que monta puntos de acceso falsos cerca de redes Wi-Fi para obtener credenciales o infectar a las victimas con malware.

Utiliza ataques de ingeniería social para obtener claves Wpa/Wpa2, sin utilizar fuerza bruta.

Luego de realizar los ataques MITM y Evil-Twin,  Wifiphiser redirecciona todas las solicitudes Http al portal cautivo.
Desde la perspectiva de la victima, el ataque toma lugar en tres fases:

    La victima es desautenticada desde sú Punto de Acceso (AP).
    Se une al Rogue AP. Wifiphiser esnifea el área y copia las configuraciones del AP.
    Es enviada a una página web real y altamente personalizable.

Repo GitHub: https://github.com/wifiphisher/wifiphisher

Páginas: [1] 2 3 ... 66