Mostrar Mensajes

Esta sección te permite ver todos los mensajes hechos por este usuario, recuerda que solo puedes ver los mensajes en áreas en donde tu tienes acceso.


Mensajes - sanko

Páginas: [1] 2
1
Otros lenguajes / Cifrado cesar - haskell
« : diciembre 30, 2013, 02:47:05 pm »
Gracias a overxfl0w que me estuvo ayudando con la recursividad de haskell pude acabar el cifrado:

Código: [Seleccionar]
import Data.Char

xEnc x y = ['a'..'z'] !! (((x + y) `mod` 26 ))
xDec x y = ['a'..'z'] !! (((x - y) `mod` 26 ))

encFinal :: String -> Int -> String
encFinal [] y = ""
encFinal (x:xs) y = (xEnc ((ord x)-97) y):(encFinal xs y)

decFinal :: String -> Int -> String
decFinal [] y = ""
decFinal (x:xs) y = (xDec ((ord x)-97) y):(decFinal xs y)

Saludos.
PD : Over, maquina


2
Python / Cifrado RSA
« : diciembre 30, 2013, 02:40:37 pm »
Solución al reto de programación "cifrado RSA" de overxflow en udtools/underc0de

Código: python [Seleccionar]
class RSA:
   
    #initializing
    def __init__(self, p, q):
        self.p = p
        self.q = q
       
        #defining n and z to resolve ops
        self.n = p * q
        self.z = (p-1) * (q-1)
        self.e = self.z - 1
       
        """
        def _extD():
            for self.d in range(1, 100):
                if (self.e * self.d) % self.z == 1:
                    return self.d
               
            return self.d
                   
        _extD()
        """
       
        self.encoded = []
        self.decoded = []
   
    # func to extract chars from a string
    def _extChar(self, text):
        self.text = text
        if text:
            self._encode(text[0])
            self._encode(self._extChar(text[1:]))
           
           
   
    #recive a char from extChar
    def _encode(self, m):
        self.m = m
        if m:
            m = ord(m)
            c = (m ^ self.e) % self.n
            self.encoded.append(c)
       
    """   
    def _decode(self, m):
        self.m = m
        if m:
            c = (m ^ self.d) % self.n
            self.decoded.append(c)
    """
 
#ejemplo de uso   
obj = RSA(3, 5)
obj._extChar("hola sanko")
print obj.encoded #output: [6, 14, 2, 12, 9, 11, 12, 0, 3, 14]


He comentado las func del decode porque tiraban algunos problemas y no quiero matarme la cabeza demasiado.
Saludos

3
Python / Cuadrado de Polibio
« : diciembre 30, 2013, 02:39:59 pm »
Script para cifrar usando polybios

Código: python [Seleccionar]
alphabet = "abcdefghiklmnopqrstuvwxyz"
encoded = []
 
def extChar(texto):
    if texto:
        encode(texto[0])
        encode(extChar(texto[1:]))
 
def encode(char):
    if char:
        if alphabet.find(char) <= 5:
            encoded.append((1, alphabet.find(char) + 1))
         
        elif alphabet.find(char) <= 10:
            encoded.append((2, (alphabet.find(char) + 1) - 5))
             
        elif alphabet.find(char) <= 15:
            encoded.append((3, (alphabet.find(char) + 1) - 10))
             
        elif alphabet.find(char) <= 20:
            encoded.append((4, (alphabet.find(char) + 1) - 15))
             
        elif alphabet.find(char) <= 25:
            encoded.append((5, (alphabet.find(char) + 1) - 20))
         
 
def main():
    data = raw_input("> ")
     
    if data == "j":
        data = "i"
         
    extChar(data)
    print encoded
 
 
if __name__ == '__main__':
    main()

4
Python / Cifrado cesar
« : diciembre 30, 2013, 02:38:41 pm »
Código: python [Seleccionar]
class cesar:
    def __init__(self):
        self.abecedario = "abcdefghijklmnopqrstuvwxyz"
           
    def _enc(self, sText, nDespl):
        self.sText = sText
        self.nDespl = nDespl
        self.encoded = ''
       
        sText = sText.lower()
        if sText != '':
            for i in sText:
                self.encoded += self.abecedario[(self.abecedario.find(i) + nDespl) % 26]
               
            return self.encoded
           
    def _dec(self, sText, nDespl):
        self.sText = sText
        self.nDespl = nDespl
        self.decoded = ''
       
        sText = sText.lower()
        if sText != '':
            for i in sText:
                self.decoded += self.abecedario[(self.abecedario.find(i) - nDespl) % 26]
               
            return self.decoded

5
Python / Anonfiles uploader
« : diciembre 30, 2013, 02:37:57 pm »
Estaba codeando esta clase para incluir en el bot del reto de underc0de hasta que me di cuenta de que esta solo iba a poder ser usada por aquel que tuviese el bot corriendo en su PC, digamos que soy un distraido, así que nada, os la dejo aqui por si a alguien le es de utilidad, no tiene nada de especial.

Código: python [Seleccionar]
import pycurl, cStringIO, json
class Anonfiles:
     
    def _upload(self, sFilename):
        self.sFilename = sFilename
         
        storage = cStringIO.StringIO()
        PostFileStorage = cStringIO.StringIO()
 
        curl = pycurl.Curl()
        postData=[('file', (pycurl.FORM_FILE, sFilename))]
         
        try:
            curl.setopt(curl.WRITEFUNCTION, storage.write)
            curl.setopt(curl.COOKIEFILE, '')
            curl.setopt(curl.URL, 'https://anonfiles.com/api')
            curl.setopt(curl.HTTPPOST, postData)
            curl.setopt(curl.WRITEFUNCTION, PostFileStorage.write)
            curl.perform()
             
        except:
            self.upload_data = "An error has ocurred uploading the file"
             
        self.upload_data = json.loads(PostFileStorage.getvalue())
        print self.upload_data["url"]


Saludos

6
Python / bytescanner api improved
« : septiembre 20, 2013, 11:25:41 am »
Hace unos dias me dio por pegarle una ojeada a la "api" en python de bytescanner y le hice unas cuantas mejoras al code, aqui les dejo el mio y abajo el code original:

Código: python [Seleccionar]
#ByteScanner "API" coded by YAKIT
#code debugging / improved code / by Sanko

import pycurl, cStringIO, errno, sys, hashlib, json

#Defining Buffers
storage = cStringIO.StringIO()
PostFileStorage = cStringIO.StringIO()
ScanResultStorage = cStringIO.StringIO()
ScanHistoryStorage = cStringIO.StringIO()
ChangeLogStorage = cStringIO.StringIO()
AVersionStorage = cStringIO.StringIO()

#Defining curl
curl = pycurl.Curl()
curl.setopt(curl.WRITEFUNCTION, storage.write)
curl.setopt(curl.COOKIEFILE, '')

class bs_Api():

def __init__(self):
"""
self.__login('yourmail@hotmail.com', 'yourpassword')
self.__upload_file('test.exe')
self.__Result_ID(id)
self.__Scan_History()
self.__Change_Log()
self.__Check_AV_Version()
self.__Export_to('extension', id)
"""
def __login(self, email, password):
#trying to log in
try:
curl.setopt(curl.URL, 'http://www.bytescanner.com/client2api.php')
curl.setopt(curl.POSTFIELDS, 'action=Auth&email=%s&password=%s'%(email, password))
curl.perform()
#storing the json data returned like login_data
self.login_data = json.loads(storage.getvalue())

except:
print "An error has ocurred triying to log in bytescanner"

#checking if you are logged
if self.login_data['success'] == False:
print ("[x] "+self.login_data['error']['title'] + "\tReason: " + self.login_data['error']['reason'])
sys.exit(errno.EACCES)

self.dicc_login = {"ID":self.login_data['root'][0]['id'],
   "Email":self.login_data['root'][0]['email'],
   "Creation Date":self.login_data['root'][0]['created'],
   "Last Login":self.login_data['root'][0]['lastlogin'],
   "Last IP Logged":self.login_data['root'][0]['lastloginip']}
#print self.dicc_login

def __upload_file(self, sFilename):
#reading the file to upload
try:
with open(sFilename): pass

except IOError:
print "Unable to open %s" % sFilename

postData=[('action', 'BinaryFileTransfer'),
  ('binaryFile', (pycurl.FORM_FILE, sFilename))]
 
try:
curl.setopt(curl.URL, 'http://www.bytescanner.com/startup.php')
curl.setopt(curl.HTTPPOST, postData)
curl.setopt(curl.WRITEFUNCTION, PostFileStorage.write)
curl.perform()
self.upload_data = json.loads(PostFileStorage.getvalue())

except:
print "An error has ocurred uploading the file"

#checking
if self.upload_data['success'] != True:
print ("[x] "+self.upload_data['error']['title'] + "\tReason: " + self.upload_data['error']['reason'])
sys.exit(errno.EACCES)

self.dicc_upload = {"Result ID":str(self.upload_data['root']),
"MD5":hashlib.md5(open(sFilename).read()).hexdigest(),
"SHA1":hashlib.sha1(open(sFilename).read()).hexdigest()}
#print self.dicc_upload

def __Result_ID(self, r_ID):
#obtaining json result
try:
curl.setopt(curl.URL, 'http://www.bytescanner.com/api2client.php?action=scanResult&ResultID=%s'% r_ID)
curl.setopt(curl.WRITEFUNCTION, ScanResultStorage.write)
curl.perform()
self.result_data = json.loads(ScanResultStorage.getvalue())

except:
print "An error has ocurred obtaining the json data"

#checking
if self.result_data['success'] != True:
print ("[x] "+self.result_data['error']['title'] + "\tReason: " + self.result_data['error']['reason'])
sys.exit(errno.EACCES)

#print self.result_data

def __Scan_History(self):
try:
curl.setopt(curl.URL, 'http://www.bytescanner.com/api2client.php?action=ScanHistory')
curl.setopt(curl.WRITEFUNCTION, ScanHistoryStorage.write)
curl.perform()
self.history_data = json.loads(ScanHistoryStorage.getvalue())

except:
print "An error has ocurred obtaining your Scan History"

#print self.history_data

def __Change_Log(self):
try:
curl.setopt(curl.URL, 'http://www.bytescanner.com/api2client.php?action=ChangeLog')
curl.setopt(curl.WRITEFUNCTION, ChangeLogStorage.write)
curl.perform()
self.ChangeLog_data = json.loads(ChangeLogStorage.getvalue())

except:
print "An error has ocurred obtaining the ChangeLog"

#print self.ChangeLog_data

def __Check_AV_Version(self):
try:
curl.setopt(curl.URL, 'http://www.bytescanner.com/api2client.php?action=AvVersion')
curl.setopt(curl.WRITEFUNCTION, AVersionStorage.write)
curl.perform()
self.AVersion_data = json.loads(AVersionStorage.getvalue())

except:
print "An error has ocurred obtaining the ChangeLog"

#print self.AVersion_data

def __Export_to(self, ext_to, r_ID):
buf = cStringIO.StringIO()
ext_dicc = {'png':'Png', 'xls':'Excel', 'pdf':'Pdf'}

try:
curl.setopt(curl.URL, 'http://www.bytescanner.com/export4client.php?action=Export2%s&ResultID=%s' %(ext_dicc[ext_to], r_ID))
curl.setopt(curl.WRITEFUNCTION, buf.write)
f = open('bs_report.%s'%(ext_to), 'w')
f.write(curl.perform())
f.close()

except:
print "An error has ocurred saving the %s report" % ext_dicc[ext_to]


code original:
Código: python [Seleccionar]
#Author: Ersan YAKIT
#Email : ersanyakit@yahoo.com.tr

import pycurl, json
import cStringIO
import errno, sys

storage = cStringIO.StringIO()
PostFileStorage = cStringIO.StringIO()
ScanResultStorage = cStringIO.StringIO()

BYTESCANNER_EMAIL= "youremailaddress@bytescanner.com"
BYTESCANNER_PASSWORD= "yourbytescannerpassword"

c = pycurl.Curl()
c.setopt(c.WRITEFUNCTION, storage.write)
c.setopt(c.COOKIEFILE, '') #we want to store cookie into memory

#STEP I ( Login into system )
c.setopt(c.URL, 'http://www.bytescanner.com/client2api.php')
c.setopt(c.POSTFIELDS, 'action=Auth&email='+BYTESCANNER_EMAIL+'&password='+ BYTESCANNER_PASSWORD)
c.perform()

data = json.loads(storage.getvalue())

if data['success'] != True:
print ("[x] "+data['error']['title'] + "\tReason: " + data['error']['reason'])
sys.exit(errno.EACCES)

print ("[+] Logged In\n")
print("Welcome, "+data['root'][0]['email']+"\nLast Login: "+ data['root'][0]['lastlogin']+"\nLast Login Ip: "+ data['root'][0]['lastloginip']+"\n" )


#STEP II ( Get File Name from user. )
scanFile= raw_input("Enter Scan File Path: ")
try:
with open(scanFile): pass
except IOError:
print 'Unable to open :'+scanFile
print("[+] Transfering file "+ scanFile +"\n")
## sending File To server!
postData=[
('action', 'BinaryFileTransfer'),
('binaryFile', (pycurl.FORM_FILE, scanFile))
]
c.setopt(c.URL, 'http://www.bytescanner.com/startup.php')
c.setopt(c.HTTPPOST, postData)
c.setopt(c.WRITEFUNCTION, PostFileStorage.write)
c.perform()
data = json.loads(PostFileStorage.getvalue())
if data['success'] != True:
print ("[x] "+data['error']['title'] + "\tReason: " + data['error']['reason'])
sys.exit(errno.EACCES)
print("[+] File transfer completed. Result ID: "+str(data['root']) )

#STEP III recieve scan results
print("[+] Starting request for scan results...\n");

c.setopt(c.URL, 'http://www.bytescanner.com/api2client.php?action=scanResult&ResultID='+str(data['root']) )
c.setopt(c.WRITEFUNCTION, ScanResultStorage.write)
c.perform()

data = json.loads(ScanResultStorage.getvalue())
if data['success'] != True:
print ("[x] "+data['error']['title'] + "\tReason: " + data['error']['reason'])
sys.exit(errno.EACCES)
print ('{0:30}\t{1:40}\t{2:30}\t{3:30}\n'.format("Antivirus Provider", "Antivirus Ver", "Scan Time", "Scan Result"))

for tmpIndex in data['root']:
print ('{0:30}\t{1:40}\t{2:30}\t{3:30}'.format(
tmpIndex['malwareScanProvider'], 
tmpIndex['malwareScanProviderVer'],
tmpIndex['malwareScanProviderResultTime'], tmpIndex['malwareScanProviderResult']
))

storage.close()
PostFileStorage.close()
ScanResultStorage.close()
print("[+] Scan Completed...\n")


PD : EL retorno se almacena en un diccionario, asi que cuando importen la clase acuerdense de parsear la informacion.
Saludos

7
Python / Cifrado de Vigenère
« : septiembre 09, 2013, 09:58:02 pm »
Buenas, otra solución a un reto de udtools : http://foro.udtools.net/showthread.php?11264-Reto-Programaci%F3n-Sobre-Cifrado-de-Vigen%E8re&p=79093

Code :

Código: python [Seleccionar]
#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Cifrado Vigenere en Python - Sanko
# Yi = (Xi + Zi) % 27

class cif_Vigenere():

def __init__(self):
self.abecedario = 'ABCDEFGHIJKLMNÑOPQRSTUVWXYZ'
self.__encode("P A R I S  V A U T  B I E N", "L O U P L  O U P L  O U P L")
self.__decode("A O N X D  L U L E  P C T W", "L O U P L  O U P L  O U P L")

def __encode(self, text, key):
encoded = ''
counter = 0

text = text.upper()
key = key.upper()

for i in range(len(text)):

if counter > len(key) - 1:
counter = 0

if text[i] == ' ':
encoded += '5'.replace('5', ' ')
counter += 1

else:
resultado = (self.abecedario.index(text[i]) + self.abecedario.index(key[counter]) + 1) % len(self.abecedario) - 1
encoded += self.abecedario[resultado]
counter += 1

print encoded


def __decode(self, enc_text, key):
decoded = ''
counter = 0

key = key.upper()

for i in range(len(enc_text)):
if counter > len(key) - 1:
counter = 0

if enc_text[i] == ' ':
decoded += '5'.replace('5', ' ')
counter +=1

else:
resultado = (self.abecedario.index(enc_text[i]) - self.abecedario.index(key[counter]) + 1) % len(self.abecedario) - 1
decoded += self.abecedario[resultado]
counter += 1

print decoded

cif_Vigenere()


Imágen :

8
Python / Enc/Dec Morse
« : septiembre 09, 2013, 09:57:04 pm »
Bueno, este cifrado fue realizado con fin de resolver un reto de programación en UDTOOLS.

Código :

Código: python [Seleccionar]
# Cifrado Morse.py - Sanko
# -*- coding: utf-8 -*-

class cif_morse():
   
    def __init__(self):
        self.table = {'A':'.-', 'B':'-...', 'C':'-.-.',
                      'D':'-..', 'E':'.', 'F':'..-.', 'G':'--.',
                      'H':'....', 'I':'..', 'J':'.---', 'K':'-.-',
                      'L':'.-..', 'M':'--', 'N':'-.', 'Ñ':'--.--',
                      'O':'---', 'P':'.--.', 'Q':'--.-', 'R':'.-.',
                      'S':'...', 'T':'-', 'U':'..-', 'V':'...-',
                      'W':'.--', 'X':'-..-', 'Y':'-.--', 'Z':'--..',
                      'Ä':'.-.-', 'Ö':'---.', 'Ü':'..--', '0':'-----',
                      '1':'.----', '2':'..---', '3':'...--', '4':'....-',
                      '5':'.....', '6':'-....', '7':'--...', '8':'---..',
                      '9':'----.', '.':'.-.-.-', ',':'--..--', '?':'..--..',
                      '!':'..--.', ':':'---...', '"':'.-..-.', "'":".----.",
                      '=':'-...-', ' ':' '}
       
        self.table2 = {}
       
        # Inicializar desde aqui
        self.__encode('Sanko os saluda')
        self.__decode('... .- -. -.- ---  --- ...  ... .- .-.. ..- -.. .- ') 


       
    def __encode(self, text):
        self.text = text
        self.encoded = ''
       
        if self.text != '':
            self.text = self.text.upper()
           
            for i in self.text:
                self.encoded += self.table[i] + ' '
               
            print "Encoded: %s"% self.encoded.replace('   ','  ')
           

       
    def __decode(self, en_text):       
        self.en_text = en_text
        self.decoded = ''
        for i in self.table:
            self.table2[self.table[i]] = i
           
        self.en_text = self.en_text.split(' ')   
        for x in self.en_text:
         if x == '':
            x = ' ' 
         self.decoded += self.table2[x]
        print "Decoded: %s"% self.decoded
                       
cif_morse()


Imágen:

9
Python / Cifrado Kamasutra
« : agosto 31, 2013, 09:14:43 am »
Buenas, vengo a traerles la solución a un reto de UDT

Código: python [Seleccionar]
#Cifrado Kamasutra en Python - Sanko
#Reto UDT - Cifrado Kamasutra

# -*- coding: utf-8 -*-
from random import randint
from string import maketrans

class cif_Kamasutra():

def __init__(self):
self.text = raw_input("Write the text to encode|> ")
self.text = self.text.upper()
self._gen_alfabeto()

def _gen_alfabeto(self):
#This func has been coded by Pink
self.alfabeto = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
letra1=""
letra2=""
self.retorno=""

for n in range(len(self.alfabeto)):
ram = randint(0,len(self.alfabeto)-1)
letra1 = self.alfabeto[ram]
letra2 = self.alfabeto[n]
self.alfabeto[n] = letra1
self.alfabeto[ram] = letra2

for n in range(len(self.alfabeto)):
self.retorno+=self.alfabeto[n]

#extra code
print "\nDict: %s"% self.retorno
self.new_alphabet = self.retorno[::-1]

self.__encode()
self.__decode()

def __encode(self):
self.encoded = maketrans(self.retorno, self.new_alphabet)
self.final_str = self.text.translate(self.encoded)
print "Encoded: ", self.text.translate(self.encoded)

def __decode(self):
decoded = maketrans(self.new_alphabet, self.retorno)
print "Decoded: ", self.final_str.translate(decoded)


cif_Kamasutra()


Una imágen vale más que mil palabras:


Saludos

10
Python / Cifrado Escitala
« : agosto 31, 2013, 09:14:14 am »
Buenas, hoy les traigo mi solución a un reto de programación en UDT

Código: python [Seleccionar]
#Cifrado escitala en python - Sanko
#Reto cifrado escitala - udtools.net

# -*- coding: utf-8 -*-

from math import ceil

class cif_escitala():

def __init__(self):
self.table = []
self.main()

def main(self):
print "Escitala cipher Python\n"
self.text = raw_input("Write the text to encode|> ")
self.n_col = input("\nWrite the number of columns|> ")

if self.text != '' and self.n_col != '':
self.__encode(self.text, self.n_col)
self.__decode()

print "\nNumber of columns: %s" % self.n_col
print "Encoded: %s" % self.encoded
print "Decoded: %s" % self.decoded

def __encode(self, text, n_col):
longitud = len(self.text)
if longitud > self.n_col:
h = ceil(longitud / self.n_col)
while h:
self.table.append(self.text[:self.n_col])
self.text = self.text[self.n_col:]
h -= 1

self.table.append(self.text.ljust(self.n_col))
self.text = ''.join(map(''.join, zip(*self.table)))
else:
print "n_col is bigger than longitud"

self.encoded = self.text.rstrip()

def __decode(self):
self.decoded = self.__encode(self.encoded, ceil(len(self.encoded) / self.n_col))


cif_escitala()


Una imágen vale más que mil palabras :


Saludos

11
Análisis forense / La orca desembarca! - Grampus v.beta
« : julio 11, 2013, 08:23:38 pm »


Despues de mucho tiempo de espera, al menos por parte del equipo de desarrollo, Grampus Beta sale a la luz.
Para los que desconozcais el proyecto, Grampus es una herramienta dirigida especialmente a analistas forenses y a pentesters en general.
La herramienta facilita la recopilación de información a traves de la extracción de metadatos de diferentes documentos y tareas de finger/foot printing

Características :
- Extracción de metadatos de documentos e imágenes, formatos soportados : Openoffice/Libreoffice, Office 2007, Office 2003, PDF, jpg, flv y gif.
- Eliminación de metadatos extraidos de diferentes documentos e imágenes.
- Tres tipos de Crawlers, entre los que se encuentra un crawler de documentos (por extensión) usando Google hacking.
- Para la tarea del fingerprinting contamos con un server banner y un escaneo mediante Shodan usando su api


Objetivos :
Como desarrolladores nuestro objetivo sería la implementación de nuevas tareas para la recopilación de información y el mantenimiento de los bugs que vayan saliendo.
Fuera de eso, queremos incentivar el desarrollo colectivo para que esta herramienta pueda ir automanteniendose y autorenovandose gracias a la colaboración de desarrolladores que usen la herramienta y así conseguir el objetivo común de una herramienta multiplataforma, estable y eficiente.


Download :
Aqui os acerco el enlace de nuestro grupo en bitbucket, donde podreis ir viendo los repositorios de los proyectos que vayamos iniciando : https://bitbucket.org/grampusteam/
Este sería el enlace de descarga del software : https://bitbucket.org/grampusteam/grampus/downloads/Grampus%20Beta.zip
Y este sería el user-guide : https://www.mediafire.com/view/ocz5j3hxex6br41/userguide_grampus.pdf

12
Python / Remover FIles - Python
« : julio 06, 2013, 12:40:36 pm »
Buenas, he visto un tema de pedrodf007 -> http://www.corp-51.net/forum/viewtopic.php?f=51&t=2942

Me comentaban que andaba un poco lento, seguramente por el tema de una GUI con form personalizado y demas.
Se me ocurrio hacer uno en python, que para tareas administrativas es bastante ágil y su interprete no come nada.

Aqui el código :

Código: python [Seleccionar]
#Files remover - sanko
# basado en Corp 51 remover files


import os

class files_Remover():
    def __init__(self):
        self.__first_dir_checker('directorio1')
        self.__second_dir_checker('directorio2')

    def __first_dir_checker(self, sPath):
        self.sPath = sPath
        try:
            self.first_dir_files = os.listdir(sPath)
        except:
            print "An error has ocurred listing the files"

    def __second_dir_checker(self, secondPath):
        self.secondPath = secondPath
        try:
            self.second_dir_files = os.listdir(secondPath)
        except:
            print "An error has ocurred listing the files"

        for i in self.first_dir_files:
            try:
                self.second_dir_files.remove(i)
            except:
                print "%s couldn't be excepted of the list"% i

        for x in self.second_dir_files:
            try:
                os.remove("%s/%s"%(self.secondPath, x))
                print "%s has been removed"% x
            except:
                print "An error has ocurred removing %s"% x
                pass

files_Remover()


Aqui un video trabajando :
https://vimeo.com/69800644


Si eso cuando vuelva a tener un rato libre toco otra vez el code, así le añado multiprocessing para que aun sea más ágil cuando la cantidad de archivos sea muy grande.

Saludos.

13
Python / Re:Whatsapp Metadata Extractor
« : junio 08, 2013, 09:43:15 pm »

Código: [Seleccionar]
obj = exif.extract_EXIF('Profile Pictures/%s' % i)


El script importado lo hicimos para grampus, usamos pyexiv y lo podeis encontrar en su repo -> https://bitbucket.org/grampusteam/grampus/src/3ba1273572c71c8ba88c6ed902848fa693c246b5/Grampus/Clases/Exif.py?at=master

14
Análisis forense / Forense automatizado a un whatsapp
« : mayo 14, 2013, 12:18:53 pm »


Buenas a todos, ya hace un tiempo que no escribo algún que otro articulo y hoy aburrido hablando con unos amigos por whatsapp me quedo la duda de si whatsapp guardaba los logs de todo lo que hicíera y efectivamente whatsapp lo hacia.

Viendo la de cositas que se estaban guardando :
      - Conversaciones de tlfn a tlfn
      - Chats activos
      - Fotos de los perfiles que mire
      - Imágenes, audios, videos que me pasarón o que pase

      (Por ejemplo).

Pues me apetecio hacerle un forense y al tiempo que lo hago os haré una demo del forense a un whatsapp y vereís todos los datos que podemos sacar de utilidad.

Recrearemos un entorno en el que dispongo de acceso físico a un terminal.
El whatsapp es una buena forma de extraer información sobre el día día de la persona, se podría aplicar algo como "Dime con quien andas y te diré quien eres" pero convertido al método geek.


Empezamos con la DEMO :

Bueno, los ficheros de whatsapp se guardan por defecto en /storage/sdcard0/WhatsApp/ , y yo me enviaré los ficheros con Airdroid, una estupenda app para compartir archivos PC - Smartphone vía wifi.




Para pasar a estar conectados en "Modo de conexión remota" como ahí podeís ver solo hay que acceder a web.android.com
y te logueas con tu cuenta.




Y tan solo te queda acceder al directorio y descargar los arhivos de los que extraeremos los metadatos.



Una vez descargados los ficheros voy a proceder a comentaros que podemos encontrar en cada uno de los directorios y cómo podríamos extraerles el jugo.

Tenemos "Databases", "Media" y "Profile Pictures", he hecho un script para que extraiga los metadatos de los db.crypt, tambien extrae los ficheros de la carpeta media(imágenes, audios, videos) y tambien extrae las imágenes encontradas en Profile Pictures.

Databases : Aqui podremos encontrarnos una serie de ficheros con extensión "db.crypt", Whatsapp cifra los archivos SQLite con AES pero siempre usa la misma key "346a23652a46392b4d73257c67317e352e3372482177652c" y de este modo podré decodificarlos.

Media : Aqui nos encontramos con una seríe de archivos (imágenes, audios, videos y wallpapers).

Profile Pictures : Aqui nos encontraremos con todas las imágenes de perfil(de usuario) que hemos mirado desde nuestro whatsapp.


NOTA IMPORTANTE : Para extraer la información de todos estos archivos que hemos obtenido he codeado un script que automatiza todo el proceso (a excepción del proceso de obtención de los ficheros , puesto que se supone que tenemos acceso físico al terminal.)




Ahora os mostraré un esquema en forma de arbol para comprender un poco como funciona el script que he preparado:

· WhatsApp Metadata Extractor :
       - main_manage.py (main de consola en forma de cliente)
       - DB_Extractor.py (extrae los metadatos de la BD)
       - metaimg_extractor.py (extrae los metadatos de los .jpg encontrados)


He dividido el proyecto en 3 scripts, main_manage es el encargado de interactuar con el cliente (el que debemos ejecutar), DB_Extractor es el encargado de realizar las consultas con la BD para extraer toda la información(la que nos interesa) y metaimg_extractor es el encargado de buscar en "Media" y en "Profile Pictures" en busca de metadatos en los archivos .jpg (La mayoria vienen con ellos eliminados por defecto pero no me digas por qué algunas imágenes no se filtran y son subidas sin filtrarse).


Sin más os dejo los codes :

main_manage.py :
Código: python [Seleccionar]
# -*- coding: utf-8 *-*
import DB_Extractor, metaimg_extractor

class WhatsApp_Extractor():

    def __init__(self):
        self.__opt()

    def __opt(self):
        #Uncomment the OPTION that you want to use

        #self.__opt1()  #-> DB METADATA EXTRACTOR
        self.__opt2()  #-> IMG METADATA EXTRACTOR
        #self.__opt3()  #-> BOTH, OPT1 AND OPT2

    def __opt1(self):
        print "DB METADATA"
        print "------------"
        DB_Extractor.DB_Extractor()
        print "------------"

    def __opt2(self):
        print "IMG META"
        print "------------"
        metaimg_extractor.IMG_Meta()
        print "------------"

    def __opt3(self):
        print "DB METADATA"
        print "------------"
        DB_Extractor.DB_Extractor()
        print "------------"
        print "\nIMG META"
        print "------------"
        metaimg_extractor.IMG_Meta()
        print "------------"

WhatsApp_Extractor()
[/spoiler]


DB_Extractor.py :
[spoiler]
Código: python [Seleccionar]
# -*- coding: utf-8 *-*
#Script to extract the metadata from the WhatsApp crypted DB

import sqlite3
from Crypto.Cipher import AES

class DB_Extractor():

    def __init__(self):
        self._manage_do()

    def _manage_do(self):
        try:
            self.__DB_Breaker('msgstore.db.crypt')
            self.__DB_conn()
            self.__SQL_Consulter()
            #Log exporter
        except:
            print "Error starting the script"

    def __DB_Breaker(self, DBPath):
        self.DBPath = DBPath
        #breaking the hash
        f = open(self.DBPath, 'rb')
        key = "346a23652a46392b4d73257c67317e352e3372482177652c"
        #triying to break the hash
        try:
            key = key.decode('hex')
            cipher = AES.new(key, 1)
            decoded = cipher.decrypt(f.read())
            #Saving into a new db file
            try:
                decoded_DB = open('metadb.db', 'wb')
                decoded_DB.write(decoded)
                decoded_DB.close()
                print "metadb.db has been created in the same directory"
            except:
                print "An error has ocurred creating the decoded DB"
        except:
            print "Error decoding the hash"


    def __DB_conn(self):
        #triying to connect with the sqlite database
        try:
            self.conn = sqlite3.connect('metadb.db')
            self.consult = self.conn.cursor()
        except:
            print "An error has ocurred connecting with the SQLite DB"


    def __SQL_Consulter(self):
        #Divided in :
            # Messages
            # Chat_list

        def __Messages():
            #SQLConsult
            try:
                self.consult.execute("SELECT key_remote_jid, key_from_me, \
                remote_resource, status, datetime(timestamp), data, media_url, media_mime_type, \
                media_size, latitude, longitude FROM messages;")

            except:
                print "An error has ocurred doing the SQL Consult"

            def __Shower():
                #Message details
                #nota : parsear status, comprobar si yo envio o recivo

                for data in self.consult:
                    try:
                        print "\nMessages Details:"
                        print "----------------------"

                        if str(data[2]):
                            if str(data[1]) == '1':
                                print "From: me"
                                print "To: %s(group), integrant: %s"%(str(data[0]), str(data[2]))
                            else:
                                print "From: %s(group), integrant: %s"%(str(data[0]), str(data[2]))
                                print "To: me"
                        else:
                            if str(data[1]) == '1':
                                print "From: me"
                                print "To: " + str(data[0])
                            else:
                                print "From: " + str(data[0])
                                print "To: me"

                        print "Status: " + str(data[3])
                        print "Timestamp: " + str(data[4])
                        print "Message: " + str(data[5])
                        print "Media content: %s, type: %s, size: %s"%(str(data[6]), str(data[7]), str(data[8]))
                        print "Location(Lat: %s, Long: %s)"%(str(data[9]), str(data[10]))
                        print "----------------------"

                    except:
                        continue
                        print "ERROR showing message details"

            __Shower()


        def __Chat_list():
            #SQLConsult
            try:
                self.consult.execute("SELECT id, \
                key_remote_jid FROM chat_list;")

            except:
                print "An error has ocurred doing the SQL Consult"

            def __Shower():
                #Chat list details
                for data in self.consult:
                    try:
                        print "\nChat_list"
                        print "ID: " + str(data[0])
                        print "Number: " + str(data[1])
                        print "----------------------"
                    except:
                        continue
                        print "ERROR showing chat list details"

            __Shower()

        #Initializing
        __Messages()
        __Chat_list()


metaimg_extractor.py :
Código: python [Seleccionar]
# -*- coding: utf-8 *-*
import os, exif

class IMG_Meta():

    def __init__(self):
        try:
            self.__Media_extractor()
            print "------------------------------------------------------\n"
            self.__Profile_extractor()
        except:
            print "An error has ocurred starting the script"
    def __Media_extractor(self):
        try:
            images = os.listdir('Media/WhatsApp Images/')
        except:
            print "An error has ocurred listing the files into the directory"

        def __Shower():
            for i in images:
                print "-------------"
                print i
                obj = exif.extract_EXIF('Media/WhatsApp Images/%s' % i)
                print "-------------"

        __Shower()

    def __Profile_extractor(self):
        try:
            images = os.listdir('Profile Pictures/')
        except:
            print "An error has ocurred listing the files into the directory"

        def __Shower():
            for i in images:
                print "-------------"
                print i
                obj = exif.extract_EXIF('Profile Pictures/%s' % i)
                print "-------------"

        __Shower()




Unas imágenes trabajando :

DB_Extractor :


IMG extractor :



El archivo "Exif" que importamos en el metaimg_extractor podemos encontrarlo en el proyecto de grampus en bitbucket -> https://bitbucket.org/grampusteam/grampus/src/3ba1273572c71c8ba88c6ed902848fa693c246b5/Grampus/Clases/Exif.py?at=master

PD : El Forense podría llegar a hacerse en mayor profundidad, en este caso solo tratamos los datos que podrían ser más relevantes como conversaciones, envio de archivos y el análisis de los metadatos de las imágenes.
En fin, esto es todo, el script os automatizará todo el trabajo "duro"


Saludos !! , Sanko.



PD : Post original
PD2 : No hay sección forense así que creo que esta es la más adecuada.

15
Python / Re:Whatsapp Metadata Extractor
« : mayo 14, 2013, 12:17:20 pm »
Si algún moderador/admin pudiera revisar por qué el DB_Extractor no sale coloreado pues mejor, si no, no hay problema

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