Grabar login screen en Fedora 18

En esta entrada vamos a ver como grabar la pantalla de login, en mí caso que uso XFCE, el login screen esta gestionado por lightdm. Para ello vamos a usar el programa recordmydesktop, ya que nos permite lanzar grabaciones desde linea de comandos.

$ sudo yum install recordmydesktop

Ahora, ya tenemos lo necesario para grabar la pantalla de login, así que nos vamos a ella.
Una vez que estamos en la pantalla de login pulsamos Control+Alt+F2, el F2, puede variar, la cuestión es abrir una sesión en modo texto. Una vez nos hemos logeado, nos identificamos como root.

$ su
# export DISPLAY=:0.0
# export XAUTHORITY=/var/run/lightdm/root/:0
# recordmydesktop --display ":0" -x 1 -y 1 --no-sound -o /home/sink/grabacion_login.ogv

:)

Python y Dropbox

Hace unos días descubrí la API que proporciona Dropbox para Python, así que me dispuse a hacer una pequeña herramienta para subir archivos,descargar o listar directorios de nuestra cuenta dropbox. Sobre todo me interesaba automatizar el proceso de comprimir un directorio y subirlo a Dropbox, como haciamos en la entrada anterior, pero esta vez usando como servidor remoto Dropbox. 

Documentación sobre la API -> https://www.dropbox.com/static/developers/dropbox-python-sdk-1.5.1-docs/index.html 

Descarga e instalación -> https://www.dropbox.com/developers/core/sdk
Una vez descomprimido el zip, instalamos:

$ unzip dropbox-python-sdk-1.5.1.zip
$ cd dropbox-python-sdk-1.5.1
$ python setup.py install

En definitiva, aquí tenéis el código:

#!/usr/bin/env python

from optparse import OptionParser
from dropbox import client, rest, session
import sys
import json
import tarfile
import os

APP_KEY = 'your app_key'
APP_SECRET = 'your app_secret'
ACCESS_TYPE = 'dropbox'

def save_token(token,archivo):
 fich = open(archivo,"w")
 fich.write("|".join([token.key, token.secret]))
 fich.close()

def load_token(archivo):
        try:
  fich = open(archivo,'r')
  token = fich.read() 
  fich.close()
             return (token.split('|')[0],token.split('|')[1])
        except IOError:
             print "[-] Error. No token file"
  exit(0)

def comprimeD(path,tarball):
 path_file = path+tarball.split('/')[len(tarball.split('/'))-1]
 tar = tarfile.open(path_file, "w:gz")
 tar.add(path)
 tar.close()
 print "[*] Compress in: %s"%path_file
 return path_file

def print_info(informacion):
 print "referral_link: %s\nNombre:  %s\nuid:  %s\ncountry: %s\nemail:  %s"%(informacion['referral_link'],informacion['display_name'],informacion['uid'],informacion['country'],informacion['email'])

def make_token(archivo,*argumentos):
 sess = session.DropboxSession(argumentos[0],argumentos[1],ACCESS_TYPE) 
 request_token = sess.obtain_request_token()
 url = sess.build_authorize_url(request_token)
 print "url:", url
 print "Please visit this website and press the 'Allow' button, then hit 'Enter' here."
 raw_input()
 access_token = sess.obtain_access_token(request_token)
 save_token(access_token,archivo)


def conecta(archivo,action,*argumentos):
 
 sess = session.DropboxSession(APP_KEY,APP_SECRET,ACCESS_TYPE)
 print "[*] Conected"

 try :
  sess.set_token(*load_token(archivo))
  print "[*] Token loaded: %s"%archivo
 except Exception,e:
  print "[-] Fail Loading token. Error: %s"%e
  exit(0)
 cliente = client.DropboxClient(sess)
 print "[*] Linked account: %s"%cliente.account_info()['email']
 
 if (action == 1):
  print_info(cliente.account_info())
 elif (action == 2):
  print "[*] Listing directory."
  try:
   folder_metadata = cliente.metadata(argumentos[0])
   for s in folder_metadata['contents']:
    if (s['is_dir']):
     print s['path'],s['size'],s['modified']
    else:
     print s['path'],s['size'],s['modified']
  except Exception,e:
   print "[-] Error: %s"%e
 elif (action == 3):
  path_file = comprimeD(argumentos[0],argumentos[1])
  f = open(path_file,"rb")
  response = cliente.put_file(argumentos[1],f)
  print "[+] Backup uploaded."
  print " [*] Info remote file:\n [*] path: %s\n [*] size: %s (%s bytes)\n [*] mtime: %s\n [*] modified: %s"%(response['path'],response['size'],response['bytes'],response['client_mtime'],response['modified'])
  print "[*] Remove local file: %s"%path_file
  os.remove(path_file)
 elif (action == 4):
  response = cliente.file_delete(argumentos[0])
  print "[*] Deleted remote file: %s"%argumentos[0]
  print " [*] Info remote file:\n [*] path: %s\n [*] size: %s (%s bytes)\n [*] mtime: %s\n [*] modified: %s"%(response['path'],response['size'],response['bytes'],response['client_mtime'],response['modified'])
 elif (action == 5):
  out = open(argumentos[1], 'wb')
  f, response = cliente.get_file_and_metadata(argumentos[0])
  out.write(f.read())
  out.close()
  print "[+] File downloaded."
  print " [*] Info remote file:\n [*] path: %s\n [*] size: %s (%s bytes)\n [*] mtime: %s\n [*] modified: %s"%(response['path'],response['size'],response['bytes'],response['client_mtime'],response['modified'])
 elif (action == 6):
  f = open(argumentos[0],"rb")
  response = cliente.put_file(argumentos[1],f)
  f.close()
  print "[+] File uploaded."
  print " [*] Info remote file:\n [*] path: %s\n [*] size: %s (%s bytes)\n [*] mtime: %s\n [*] modified: %s"%(response['path'],response['size'],response['bytes'],response['client_mtime'],response['modified'])

  
def opciones():
 parser = OptionParser("usage: %prog [options] \nExample: ./BackupON.py -t token_dropbox.txt -c -d /home/sink/files -o /Backups/files.tar.gz\nExample: ./BackupON.py --create-token token_dropbox.txt -k  -s \nExample: ./BackupON.py -t token_dropbox.txt -g /Backups/files.tar.gz -o /home/sink/files_dropbox.tar.gz\nExample: ./BackupON.py -t token_dropbox.txt -l /\nExample: ./BackupON.py -t token_dropbox.txt -r /Backups/files.tar.gz")
 parser.add_option("-i", "--info",
                  action="store_true", dest="info", help="Get account info")
 parser.add_option("-c","--compress",
                  action="store_true", dest="compress", help="Compress directory.")
 parser.add_option("-t", "--token",
                  action="store", type="string", dest="token", help="Token para la conexion")
 parser.add_option("--create-token",
                  action="store", type="string", dest="file_dest", help="Crear un token.")
 parser.add_option("-k","--app-key",
                  action="store", type="string", dest="app_key", help="App key.")
 parser.add_option("-s","--secret-key",
                  action="store", type="string", dest="secret_key", help="Secret key.")
 parser.add_option("-l", "--ls",
                  action="store", type="string", dest="directory", help="Listing the folder")
 parser.add_option("-d", "--directory",
                  action="store", type="string", dest="path", help="Directorio/fichero local a copiar")
 parser.add_option("-g", "--get",
                  action="store", type="string", dest="file", help="Download remote file.")
 parser.add_option("-o", "--output",
                  action="store", type="string", dest="output", help="Directorio/archivo de salida donde guardar el backup.")
 parser.add_option("-r", "--remove",
                  action="store", type="string", dest="remove", help="Elimina archivo/directorio remoto.")

 (options, args) = parser.parse_args()


 if (len(sys.argv) == 1):
  parser.print_help()
 elif (options.token != None):
  if (options.info): 
   conecta(options.token,1,None)
  elif (options.directory != None):
   conecta(options.token,2,options.directory)
  elif (options.path != None) and (options.output != None) and (options.compress):
   conecta(options.token,3,options.path,options.output)
  elif (options.path != None) and (options.output != None) and (not options.compress):
   conecta(options.token,6,options.path,options.output)
  elif (options.remove != None):
   conecta(options.token,4,options.remove)
  elif (options.file != None) and (options.output != None):
   conecta(options.token,5,options.file,options.output)
 elif (options.file_dest != None) and (options.secret_key != None) and (options.app_key != None):
  make_token(options.file_dest,options.app_key,options.secret_key)
 else:
  print "[-] Error: Need a token."

if __name__ == '__main__':
    opciones()

[sink@Hardcore ~/Scripts]$ ./BackupOn.py -h
Usage: BackupOn.py [options]
Example: ./BackupON.py -t token_dropbox.txt -c -d /home/sink/files -o /Backups/files.tar.gz
Example: ./BackupON.py --create-token=token_dropbox.txt -k <app key> -s <secret key>
Example: ./BackupON.py -t token_dropbox.txt -g /Backups/files.tar.gz -o /home/sink/files_dropbox.tar.gz
Example: ./BackupON.py -t token_dropbox.txt -l /
Example: ./BackupON.py -t token_dropbox.txt -r /Backups/files.tar.gz

Options:
  -h, --help            show this help message and exit
  -i, --info            Get account info
  -c, --compress        Compress directory.
  -t TOKEN, --token=TOKEN
                        Token para la conexion
  --create-token=FILE_DEST
                        Crear un token.
  -k APP_KEY, --app-key=APP_KEY
                        App key.
  -s SECRET_KEY, --secret-key=SECRET_KEY
                        Secret key.
  -l DIRECTORY, --ls=DIRECTORY
                        Listing the folder
  -d PATH, --directory=PATH
                        Directorio/fichero local a copiar
  -g FILE, --get=FILE   Download remote file.
  -o OUTPUT, --output=OUTPUT
                        Directorio/archivo de salida donde guardar el backup.
  -r REMOVE, --remove=REMOVE
                        Elimina archivo/directorio remoto.

:-)

Python: Comprimir archivos y enviarlos por SSH.

Hoy mientras hacía un backup de mi directorio de trabajo, el cual suelo hacer copia en tres sitios distintos, en una de estas lo que hago es subirlo a mi servidor por SSH, para lo cual lo empaqueto y comprimo y ya lo subo usando scp, y después compruebo su hash.

$ tar -zcvf /home/manu/file_20042013.tar.gz /home/manu/files
$ scp -P 22 /home/manu/file_20042013.tar.gz sink@192.168.1.10:/home/sink/file_20042013.tar.gz

Para hacer más ágil y rápido esto, decidí hacer un script en python el cual pasandole los parámetros necesarios te hace esto y además te comprueba el hash de ambos archivos.

Aquí os pongo el script en cuestion:

#!/usr/bin/env python


from optparse import OptionParser
import sys
import getpass
import string
import pexpect
import gzip
import tarfile
import hashlib

def md5_file(filepath):
 fi = open(filepath, 'rb')
 m = hashlib.md5()
 while True:
  data = fi.read(8192)
  if not data:
   break
  m.update(data)
 return m.hexdigest()

def comprimeD(path,tarball):
 tar = tarfile.open(path+tarball.split('/')[3], "w:gz")
 tar.add(path)
 tar.close()
 print "Compress in: %s      md5 checksum:%s"%(path+tarball.split('/')[3],md5_file(path+tarball.split('/')[3]))
 return path+tarball.split('/')[3]

def comprime(path,tarball):
 if (tarball.split(".")[1] == "gz"):
  f_in = open(path, 'rb')
  f_out = gzip.open(path+'.gz', 'wb')
  f_out.writelines(f_in)
  f_out.close()
  f_in.close()
  print "Compress in: %s.gz      md5 checksum:%s"%(path,md5_file(path+'.gz'))
  path = path+'.gz'
 elif (tarball.split(".")[1] == "tar"):
  tar = tarfile.open(path+'.tar.gz', "w:gz")
  tar.add(path)
  tar.close()
  print "Compress in: %s.tar.gz      md5 checksum:%s"%(path,md5_file(path+'.tar.gz'))
  path = path+ '.tar.gz'
 return path

def conexion(host,port,user,password,filebackup,path):
 child = pexpect.spawn('scp -P %s %s %s@%s:%s'%(port,filebackup,user,host,path))
 child.expect ('assword:',timeout=10)
     child.sendline (password)
 data = child.read()
 print data

 child = pexpect.spawn('ssh %s@%s -p %s \'md5sum %s\''%(user,host,port,path))
 child.expect ('assword:',timeout=10)
 child.sendline (password)
 data = child.read()
 child.close()
 if (data.replace('\r\n','').split(' ')[1] == md5_file(filebackup)):
  print "Backup complete (md5sum OK)"
 else:
  print "Error: bad checksum"

def opciones():
 parser = OptionParser("usage: %prog [options] \nExample: ./backupSSH.py -f /home/manu/file -u sink -s 192.168.1.10:22 -o /home/sink/file2 \nExample: ./backupSSH.py -c -d /home/manu/ -u sink -s 192.168.1.10:22 -o /home/sink/home_manu.tar.gz \nExample: ./backupSSH.py -c -u sink -f /home/manu/file -s 192.168.1.10:22 -o /home/sink/file.tar.gz")
 parser.add_option("-u", "--user",
                  action="store", type="string", dest="user", help="Nombre del usuario")
 parser.add_option("-d", "--directory",
                  action="store", type="string", dest="directory", help="Directorio del cual queremos hacer backup")
 parser.add_option("-f", "--file",
                  action="store", type="string", dest="file", help="Fichero del cual queremos hacer backup")
 parser.add_option("-o", "--output",
                  action="store", type="string", dest="output", help="Fichero o directorio destino en el servidor remoto")
 parser.add_option("-c", "--compress",
                  action="store_true", dest="compress", help="Comprimir el backup usando gzip")
 parser.add_option("-s", "--server",
                  action="store", type="string", dest="server", help="Servidor SSH y puerto. Sintaxis server:port")
 

 (options, args) = parser.parse_args()


 if (len(sys.argv) == 1):
  parser.print_help()
 elif (options.compress):
  if (options.user != None) and (options.server != None) and ((options.directory != None) or (options.file != None)) and (options.output != None):
   if (options.directory != None):
    password = getpass.getpass()
    conexion(options.server.split(":")[0],options.server.split(":")[1],options.user,password,comprimeD(options.directory,options.output),options.output)
   elif (options.file != None):
    password = getpass.getpass()
    conexion(options.server.split(":")[0],options.server.split(":")[1],options.user,password,comprime(options.file,options.output),options.output)
 elif (options.user != None) and (options.server != None) and ((options.directory != None) or (options.file != None)) and (options.output != None):
  password = getpass.getpass()
  conexion(options.server.split(":")[0],options.server.split(":")[1],options.user,password,options.file,options.output)

if __name__=="__main__":
 opciones()

Espero que os sirva. :)

Wireless: Crear punto de acceso falso

Para ello vamos a utilizar SET (Social Engineering Toolkit), el cual una vez creado el AP nos proporcionara DHCP y DNS, los cuales estarán manipulados por nosotros (el atacante), ya que entregaremos nuestra dirección IP como dirección IP del servidor DNS y de la puerta de enlace. 

En primer lugar necesitamos saber las rutas de donde tenemos airbase-ng y dnsspoof, ya que SET las usará.

Las rutas las podemos obtener con el comando whereis <filename>.

$ whereis airbase-ng
$ whereis dnsspoof

Una vez que tenemos las rutas, debemos configurar el fichero set_config con estas rutas en las variables AIRBASE_NG_PATH y DNSSPOOF_PATH.

En mi caso:

AIRBASE_NG_PATH=/usr/sbin/airbase-ng
DNSSPOOF_PATH=/usr/sbin/dnsspoof

También podemos cambiar el nombre de la red con la variable ACCESS_POINT_SSID

 Una vez tenemos configurado correctamente SET, lo ejecutamos y seleccionamos en este orden.

1) Social-Engineering Attacks -> 8) Wireless Access Point Attack Vector -> 1) Start the SET Wireless Attack Vector Access Point

Después de esto, ya solo nos quedará sniffar la red, además de poder proporcionar las direcciones que queramos para las peticiones DNS que nos haga la victima.

Lista de acrónimos con LaTeX

Finalizando la memoria del Proyecto Fin de Carrera, deje para el final la lista de acrónimos, había estado usando glossaries , pero cuando procedí a poner la lista con /printglossaries (justo antes de la lista de figuras y de la bibliografia) no salia la lista de acrónimos.

Para empezar, si no tenemos xindy o glossaries, vamos a descargarlos desde http://www.ctan.org/pkg/xindy y http://www.ctan.org/pkg/glossaries
Al descargarlos tenemos dos archivos comprimidos *.zip, de los cuales, el de glossaries lo descomprimimos en /usr/share/texmf/ y el de xindy  en /opt/xindy-2.2/
Añadimos al PATH los directorios donde se encuentran estos dos binarios. En el caso que usamos xindy.

En mi caso uso Texmaker, así que lo que hice fue añadir un nuevo comando de usuario llamado makeglossaries, cuyo comando es /usr/share/texmf/scripts/glossaries/makeglossaries %

Una vez tenemos esto, tendremos que ejecutar PDFLaTeX , makeglossaries, y PDFLaTeX.

Ejemplo de documento: 

\documentclass[12pt,a4paper]{book}

\usepackage[utf8]{inputenc}
\usepackage[spanish]{babel}
\usepackage{graphicx}
\usepackage{amsmath,amssymb}
\usepackage{listings}
\usepackage{eurosym}
\usepackage{pdfpages}

\usepackage[acronym,shortcuts]{glossaries}

\makeglossaries
\input{./acronimos.tex}

\usepackage[left=2.5cm,top=3.5cm,right=2.5cm,bottom=3cm]{geometry}

\begin{document}
 

%Glosario de terminos
\printglossaries


\end{document}



En acronimos.tex tendremos los acrónimos. Por ejemplo:

\newacronym{AES}{AES}{Anvanced Encryption Standard}
\newacronym{CBC}{CBC}{Cipher-block chaining}
\newacronym{PFC}{PFC}{Proyecto Fin de Carrera}
\newacronym{SSL}{SSL}{Secure Socket Layer}
\newacronym{ANSI}{ANSI}{American National Standards Institute}
\newacronym{CNRI}{CNRI}{Corporation for National Research Initiatives}
\newacronym{PSF}{PSF}{Python Software Foundation}
\newacronym{PSFL}{PSFL}{Python Software Foundation Licence}
\newacronym{FSF}{FSF}{Free Software Foundation}
\newacronym{AP}{AP}{Access Point}
\newacronym{NIST}{NIST}{Instituto Nacional de Estándares y Tecnología}
\newacronym{LR-WPAN}{LR-WPAN}{Low-Rate Wireless Personal Area Network}
\newacronym{PAM}{PAM}{Pluggable Authentication Modules}
\newacronym{IDE}{IDE}{Integrated Development Environment}
\newacronym{CA}{CA}{Certificate Authority}
\newacronym{CSR}{CSR}{Certificate Signing Request}



En ambos documentos he suprimido bastante texto, de todos modos, cuando lo finalice completamente espero subirlo. 

Más información en los enlaces puestos anteriormente y en http://en.wikibooks.org/wiki/LaTeX/Glossary 

:)

Ataque a WPA

Este ataque es completamente distinto al que se usa para contra redes con seguridad inalámbrica WEP. Estos ataques no consisten en obtener un gran número de paquetes de datos cifrados y después lanzar un ataque de predicción contra estos con aircrack-ng, sino obtener un paquete específico y por fuerza bruta mediante el uso de un diccionario obtener la clave.
Para este ataque es necesario que exista un cliente legitimo conectado al AP, en caso contrario este ataque no es posible. Para obtener correctamente estos paquetes será necesario tanto tener un cliente legitimo asociado al AP como la buena alineación de nuestra antena con respecto al AP.
El ataque consiste en forzar una desautenticación del cliente legitimo conectado al AP (lo cual genera un DoS al cliente) .
Tras desconectarse el usuario del sistema, este volverá a conectarse al AP y realizar de nuevo el proceso de autenticación, durante ese proceso de autenticación hay un intercambio de paquetes entre el cliente y el AP, estos paquetes serán los que debemos obtener si queremos lanzar el ataque de diccionario, ya que en ellos se encuentra la clave única de sesion, conocido como handshake . No es fácil obtener estos paquetes, ya que se producen de forma muy rápida, de ahí la importancia de la antena.

Prueba de concepto para obtener el handshake y realizar el ataque de diccionario.

En primer lugar, vamos a spoofear la  MAC. (En caso de que exista filtrado por MAC, esto se convierte en algo necesario)

# ifconfig wlan0 down
# macchanger wlan0 -m 00:01:02:03:FF:EE
# ifconfig wlan0 up

Ponemos la interfaz de nuestro adaptador inalambrico en modo monitor.

# airmon-ng start wlan0

  
Lanzamos airodump-ng para localizar el AP. una vez localizado comenzamos a capturar los paquetes solo asociados a su bssid. 

# airodump-ng -c <canal> --bssid <bssid> mon0 -w salida

Una vez tenemos el AP y su cliente conectado, procedemos a lanzar la desautenticación del cliente.

# aireplay-ng -0 1 -a <bssid> -c <MAC cliente> mon0

Si se produce correctamente la desautenticación y posteriormente capturamos los paquetes, aparecerá en la barra de estado "WPA handshake".

Una vez tenemos capturado el handshake, solo nos hará falta realizar el ataque de diccionario contra los paquetes capturados.

# aircrack-ng -w diccionario salida

PD: El diccionario se puede descargar desde numerosas webs, o incluso lo podeis hacer vosotros mismos descargando la wiki o cualquier web y un poco de perl o python. :)

:-)

Router OBSERVA TELECOM (firmware AW4062) de movistar

No hace mucho que tengo este router, justo nada más traermelo el operario de movistar (o de la empresa que trabaja para movistar en esta zona), me puse a configurarlo, configurando la NAT para que vaya correctamente a los servidores, añadiendo filtros de acceso por WiFi, etc.

Al final de todo, procedí a hacer un backup de esta configuración, y me lleve una sorpresa al ver que en el código de este archivo xml había un usuario y una clave de más (adsl/realtek), además con permisos de superusuario. Edite el archivo de configuración cambiado la pass y el usuario, pero no ocurría nada, ese usuario no se podía modificar. Seguramente estuviese ahí para que los técnicos de movistar puedan entrar por telnet y actualizarlo y/o configurarlo (además de poder controlarte y espiarte). Como ya había configurado el router para que solo se pudiese entrar a sus servicios (http, ftp y telnet) desde la red interna, y había quitado las IPs que trae por defecto desde las cuales se pueden acceder desde el exterior, ya que ese usuario y contraseña anteriormente vistos no se podía quitar. 

Así que me propuse quitar este usuario, o al menos quitarle permisos para que pueda entrar a los servicios del sistema. Por web no sé podía hacer nada (estuve mirando donde poder ejecutar código y configurar el fichero passwd, pero no vi nada, y como tenia un servidor ftp, tampoco es que pusiese mucho empeño en el servidor web), así que entre por ftp con el usuario adsl/realtek.

Una vez dentro, me fui directo a /etc/passwd y me lo descargue en mi equipo, una vez descargado, le edite al usuario adsl la consola por defecto, poniendosela a /bin/false y de camino dandole al usuario root un terminal de verdad, donde el router sea totalmente configurable, y no el servicio que ofrece el router por defecto /bin/cli 

Por ultimo subimos el archivo passwd editado a /etc/passwd por ftp y listo.

Ahora ya podemos entrar por telnet y tener un control total sobre el router, además de haber deshabilitado al usuario adsl. 

Tened en cuenta que al ser una rom, cuando apaguemos el router o lo reiniciemos, se cargará la configuración por defecto, y tendremos que hacer todo esto de nuevo.
Como podemos observar, para el usuario user le hemos dejado /bin/cli como consola por defecto.

Investigando un poco en los archivos que usa el router al iniciarse, concretamente en configd, usando strings, vemos que el usuario adsl y su contraseña realtek se encuentran en él, lo cual viene hardcodeado en el firmware de esta versión de este router, y además no se puede cambiar la contraseña. También podemos encontrar la clave que viene impresa en la parte inferior del router en un archivo llamado wpakey el cual lo encontramos en /var/ entre otras cosas interesantes.

:)

Montando servidor web con Apache y clonando un web con SET (Social Engineering Toolkit)

En esta entrada vamos a ver en primer lugar como crear un servidor web con apache y en segundo lugar clonaremos un sitio web con SET, técnica usada para recolectar credenciales.

Para montar apache, si no lo tenemos descargado:

$ sudo yum install httpd

Ya lo tenemos descargado, pero antes de activar el servicio vamos a modificar su archivo de configuración para que no de tanta información acerca de nuestro servidor. Para ello ejecutamos en el terminal:

# nano /etc/httpd/conf/httpd.conf

y editamos las lineas:
ServerTokens Prod
ServerSignature Off
FileETag None

Podemos comprobar como hay diferencia en las cabeceras con el servidor sin editar estos parametros y después de editarlo.
Antes: 

Despues:

Ahora activamos nuestro servidor:

# service httpd start

Ahora que ya tenemos nuestro servidor http con apache corriendo, vamos a clonar una página web, en mi claso voy a clonar la página de administración de un switch de la marca Dell. Esto podemos hacerlo bien desde directamente el servidor web que queremos clonar, irnos a Shodan y buscar uno igual o intitle:"dell openmanage switch administrator", etc.

Ahora si no tenemos SET en nuestro equipo, vamos a clonar el directorio con Git.
$ git clone https://github.com/trustedsec/social-engineer-toolkit/ set/
$ cd set/

Ahora vamos a configurarlo a traves de su fichero de configuraciión, ya que hay variables que deben estar bien configuradas para que funcione correctamente,
METASPLOIT_PATH=<ruta>  en esta pondremos la ruta donde tenemos instalado el framework de Mestasploit
SELF_SIGNED_APPLET=ON  Indica que el applet será firmado con el publicador que se quiera suplantar, usada para el ataque web basado en el applet de Java.
AUTO_DETECT=OFF  Para que no se configure automaticamente la dirección IP que asignara a los servidores web.
APACHE_SERVER=ON  Activar para que use el servidor Apache y no el servidor web escrito en Python que trae por defecto.
APACHE_DIRECTORY=/var/www/html/ Directorio donde tendremos nuestro servidor web.
AUTO_MIGRATE=ON Hace que cuando se realice la explotación, el payload migre automaticamente a otro proceso.

Hay muchas otras variables, de momento para nuestro proposito serán más que suficientes.

Ahora ejecutamos set:

# ./set
Y es muy fácil ya que no hay que escribir practicamente nada, solo navegar entre su menú, para clonar el sitio web, iremos a la opción 1 (Social-Engineering Attacks), opción 2 (Website Attack Vectors), opción 3 (Credential Harvester Attack Method), opción 2 (Site Cloner).

en  IP address for the POST back in Harvester/Tabnabbing: ponemos nuestra ip dentro de la red. Y en  Enter the url to clone: la url de la web que queremos clonar.


En los archivos harvester_*.txt se guardan las credenciales introducidas por los usuarios.

Esto junto a un ataque ARP Spoofing y DNS Spoofing, suele ser bastante efectivo.



:)