def __init__(self):
self.stats = "resume"
self.log = LogDeErros()
self.nomecoletor = ""
self.contaSemIP = 0
self.contaUDP = 0
self.contaTCP = 0
self.contaPacote = 0
self.fluxo = {}
self.timer = {}
self.time = 5
self.producer = Produtor()
def __init__(self):
self.stats = "resume"
self.log = LogDeErros()
self.nomecoletor = ""
self.contaSemIP = 0
self.contaUDP = 0
self.contaTCP = 0
self.contaPacote=0
self.fluxo={}
self.timer={}
self.time=5
self.producer = Produtor()
class Captura():
"""Classe que ira capturar pacotes"""
def __init__(self):
self.stats = "resume"
self.log = LogDeErros()
self.nomecoletor = ""
self.contaSemIP = 0
self.contaUDP = 0
self.contaTCP = 0
self.contaPacote=0
self.fluxo={}
self.timer={}
self.time=5
self.producer = Produtor()
def nomedocoletor(self,nome):
self.nomecoletor = nome
def status(self, arg):
self.stats = arg
print "Mudou status de captura para:", arg
def assinar(self):
file = open('l7-pat/dns.pat').readlines()
expr = file[0]
dns = re.compile(expr)
file = open('l7-pat/ftp.pat').readlines()
expr = file[0]
ftp = re.compile(expr)
file = open('l7-pat/http.pat').readlines()
expr = file[0]
http = re.compile(expr)
file = open('l7-pat/ssh.pat').readlines()
expr = file[0]
ssh = re.compile(expr)
file = open('l7-pat/bittorrent.pat').readlines()
expr = file[0]
bittorrent = re.compile(expr)
file = open('l7-pat/dhcp.pat').readlines()
expr = file[0]
dhcp = re.compile(expr)
file = open('l7-pat/ssdp.pat').readlines()
expr = file[0]
ssdp = re.compile(expr)
file = open('l7-pat/ssl.pat').readlines()
expr = file[0]
ssl = re.compile(expr)
assinaturas = {"dns":dns,"ftp":ftp,"http":http,"ssh":ssh,"bittorrent":bittorrent,"dhcp":dhcp,"ssdp":ssdp,"ssl":ssl}
return assinaturas
def capturateste(self):
try:
for ts, pkt in pcap.pcap("test-capture.pcap"):
if self.stats == "teste":
eth = dpkt.ethernet.Ethernet(pkt)
ip = eth.data
if isinstance(ip,dpkt.ip.IP):
ipsrc = ip.src
ipdst = ip.dst
protocolo = ip.p
transp = ip.data
if isinstance(transp,dpkt.tcp.TCP) or isinstance(transp,dpkt.udp.UDP):
if isinstance(ip.data,dpkt.tcp.TCP):
self.contaTCP += 1
elif isinstance(ip.data,dpkt.udp.UDP):
self.contaUDP += 1
portsrc = transp.dport
portdest = transp.sport
key=str(ipsrc)+str(portsrc)+str(ipdst)+str(portdest)+str(protocolo)
if not key in self.fluxo:
self.fluxo[key] = [(ts,ip)]
self.conta_timeout_fluxo(key)
else:
self.fluxo[key].append((ts,ip))
self.conta_timeout_fluxo(key)
else:
self.contaSemIP += 1
print "Pacote sem IP"
if self.stats == "resume":
self.captura()
if self.stats == "":
print "Coletor suspenso"
system("clear")
self.status("stop")
except (KeyboardInterrupt, SystemExit):
self.log.setErro(sys.exc_info()[1],self.nomecoletor)
print "Erro ao fazer captura de teste."
self.status("stop")
os._exit(0)
def captura(self):
try:
for ts, pkt in pcap.pcap():
if self.stats == "resume":
eth = dpkt.ethernet.Ethernet(pkt)
ip = eth.data
if isinstance(ip,dpkt.ip.IP):
ipsrc = ip.src
ipdst = ip.dst
protocolo = ip.p
transp = ip.data
if isinstance(transp,dpkt.tcp.TCP) or isinstance(transp,dpkt.udp.UDP):
if isinstance(ip.data,dpkt.tcp.TCP):
self.contaTCP += 1
elif isinstance(ip.data,dpkt.udp.UDP):
self.contaUDP += 1
portsrc = transp.dport
portdest = transp.sport
key=str(ipsrc)+str(portsrc)+str(ipdst)+str(portdest)+str(protocolo)
if not key in self.fluxo:
self.fluxo[key] = [(ts,ip)]
self.conta_timeout_fluxo(key)
else:
self.fluxo[key].append((ts,ip))
self.conta_timeout_fluxo(key)
print key
else:
self.contaSemIP += 1
print "Pacote sem IP"
if self.stats == "teste":
self.capturateste()
if self.stats == "stop":
for i in self.timer:
self.timer[i].cancel()
print "Coletor suspenso"
break
except (KeyboardInterrupt, SystemExit):
self.log.setErro(sys.exc_info()[1],self.nomecoletor)
print "Erro ao fazer captura."
os._exit(0)
def classifica_fluxo(self, fluxo): # recebe uma lista no formato: [(ts,pkt),(ts,pkt)]
self.protocols = self.assinar()
achou=False
for item in fluxo:
app = item[1].data.data.lower()
for p in self.protocols.items():
if p[1].search(app):
achou = True
protocolo = p[0]
if achou:
return protocolo
else:
return "nenhum"
def calcula_tempo_fluxo(self, fluxo): # recebe uma lista no formato: [(ts,pkt),(ts,pkt)]
tempo_inicial = fluxo[0][0]
tempo_final = fluxo[-1][0]
duracao = tempo_final - tempo_inicial
return duracao
def calcula_tamanho_fluxo(self, fluxo): # recebe uma lista no formato: [(ts,pkt),(ts,pkt)]
tamanho=0
for pacote in fluxo:
tamanho+=pacote[1].len
return tamanho
def conta_timeout_fluxo(self, key): # recebe uma string que é key de um fluxo em um dicionário
if key in self.timer:
self.timer[key].cancel()
self.timer[key] = Timer(self.time,self.finaliza_fluxo,args=[key])
self.timer[key].start()
def finaliza_fluxo(self, key): # recebe uma string que é key de um fluxo em um dicionário
self.cria_tupla(self.fluxo[key])
del(self.fluxo[key])
def cria_tupla (self, fluxo):
protocolo = self.classifica_fluxo(fluxo)
tempo = self.calcula_tempo_fluxo(fluxo)
tempo = tempo * 0.001
tamanho = self.calcula_tamanho_fluxo(fluxo)
tamanho = tamanho / 1024.0
if tempo > 0 and tamanho > 0:
taxa = tamanho / tempo
tupla = (protocolo,"%.6f" % tamanho,"%.6f" % tempo,"%.6f" % taxa)
print "Tupla gerada:", tupla
#self.enviarTupla(tupla)
def enviarTupla(self,tupla):
credencial = pika.PlainCredentials('luiz', '113211')
connection = pika.BlockingConnection(pika.ConnectionParameters('192.168.56.103', 5672, 'filas', credencial))
channel = connection.channel()
channel.queue_declare(queue='HTTP')
channel.queue_declare(queue='DNS')
channel.queue_declare(queue='SSH')
channel.queue_declare(queue='FTP')
channel.queue_declare(queue='Unknown')
channel.queue_declare(queue='All')
if('http' in tupla or 'HTTP' in tupla):
channel.basic_publish(exchange='', routing_key='HTTP', body=str(tupla))
elif('dns' in tupla or 'DNS' in tupla):
channel.basic_publish(exchange='', routing_key='DNS', body=str(tupla))
elif('ssh' in tupla or 'SSH' in tupla):
channel.basic_publish(exchange='', routing_key='SSH', body=str(tupla))
elif('ftp' in tupla or 'FTP' in tupla):
channel.basic_publish(exchange='', routing_key='FTP', body=str(tupla))
elif(('dns' in tupla or 'DNS' in tupla) or ('http' in tupla or 'HTTP' in tupla) or ('ssh' in tupla or 'SSH' in tupla) or ('ftp' in tupla or 'FTP' in tupla)):
channel.basic_publish(exchange='', routing_key='All', body=str(tupla))
else:
channel.basic_publish(exchange='', routing_key='Unknown', body=str(tupla))
channel.basic_publish(exchange='', routing_key='All', body=str(tupla))
print "[x] Mensagem Enviada!"
class Captura():
"""Classe que ira capturar pacotes"""
def __init__(self):
self.stats = "resume"
self.log = LogDeErros()
self.nomecoletor = ""
self.contaSemIP = 0
self.contaUDP = 0
self.contaTCP = 0
self.contaPacote = 0
self.fluxo = {}
self.timer = {}
self.time = 5
self.producer = Produtor()
def nomedocoletor(self, nome):
self.nomecoletor = nome
def status(self, arg):
self.stats = arg
print "Mudou status de captura para:", arg
def assinar(self):
file = open('l7-pat/dns.pat').readlines()
expr = file[0]
dns = re.compile(expr)
file = open('l7-pat/ftp.pat').readlines()
expr = file[0]
ftp = re.compile(expr)
file = open('l7-pat/http.pat').readlines()
expr = file[0]
http = re.compile(expr)
file = open('l7-pat/ssh.pat').readlines()
expr = file[0]
ssh = re.compile(expr)
file = open('l7-pat/bittorrent.pat').readlines()
expr = file[0]
bittorrent = re.compile(expr)
file = open('l7-pat/dhcp.pat').readlines()
expr = file[0]
dhcp = re.compile(expr)
file = open('l7-pat/ssdp.pat').readlines()
expr = file[0]
ssdp = re.compile(expr)
file = open('l7-pat/ssl.pat').readlines()
expr = file[0]
ssl = re.compile(expr)
assinaturas = {
"dns": dns,
"ftp": ftp,
"http": http,
"ssh": ssh,
"bittorrent": bittorrent,
"dhcp": dhcp,
"ssdp": ssdp,
"ssl": ssl
}
return assinaturas
def capturateste(self):
try:
for ts, pkt in pcap.pcap("test-capture.pcap"):
if self.stats == "teste":
eth = dpkt.ethernet.Ethernet(pkt)
ip = eth.data
if isinstance(ip, dpkt.ip.IP):
ipsrc = ip.src
ipdst = ip.dst
protocolo = ip.p
transp = ip.data
if isinstance(transp, dpkt.tcp.TCP) or isinstance(
transp, dpkt.udp.UDP):
if isinstance(ip.data, dpkt.tcp.TCP):
self.contaTCP += 1
elif isinstance(ip.data, dpkt.udp.UDP):
self.contaUDP += 1
portsrc = transp.dport
portdest = transp.sport
key = str(ipsrc) + str(portsrc) + str(ipdst) + str(
portdest) + str(protocolo)
if not key in self.fluxo:
self.fluxo[key] = [(ts, ip)]
self.conta_timeout_fluxo(key)
else:
self.fluxo[key].append((ts, ip))
self.conta_timeout_fluxo(key)
else:
self.contaSemIP += 1
print "Pacote sem IP"
if self.stats == "resume":
self.captura()
if self.stats == "":
print "Coletor suspenso"
system("clear")
self.status("stop")
except (KeyboardInterrupt, SystemExit):
self.log.setErro(sys.exc_info()[1], self.nomecoletor)
print "Erro ao fazer captura de teste."
self.status("stop")
os._exit(0)
def captura(self):
try:
for ts, pkt in pcap.pcap():
if self.stats == "resume":
eth = dpkt.ethernet.Ethernet(pkt)
ip = eth.data
if isinstance(ip, dpkt.ip.IP):
ipsrc = ip.src
ipdst = ip.dst
protocolo = ip.p
transp = ip.data
if isinstance(transp, dpkt.tcp.TCP) or isinstance(
transp, dpkt.udp.UDP):
if isinstance(ip.data, dpkt.tcp.TCP):
self.contaTCP += 1
elif isinstance(ip.data, dpkt.udp.UDP):
self.contaUDP += 1
portsrc = transp.dport
portdest = transp.sport
key = str(ipsrc) + str(portsrc) + str(ipdst) + str(
portdest) + str(protocolo)
if not key in self.fluxo:
self.fluxo[key] = [(ts, ip)]
self.conta_timeout_fluxo(key)
else:
self.fluxo[key].append((ts, ip))
self.conta_timeout_fluxo(key)
print key
else:
self.contaSemIP += 1
print "Pacote sem IP"
if self.stats == "teste":
self.capturateste()
if self.stats == "stop":
for i in self.timer:
self.timer[i].cancel()
print "Coletor suspenso"
break
except (KeyboardInterrupt, SystemExit):
self.log.setErro(sys.exc_info()[1], self.nomecoletor)
print "Erro ao fazer captura."
os._exit(0)
def classifica_fluxo(
self, fluxo): # recebe uma lista no formato: [(ts,pkt),(ts,pkt)]
self.protocols = self.assinar()
achou = False
for item in fluxo:
app = item[1].data.data.lower()
for p in self.protocols.items():
if p[1].search(app):
achou = True
protocolo = p[0]
if achou:
return protocolo
else:
return "nenhum"
def calcula_tempo_fluxo(
self, fluxo): # recebe uma lista no formato: [(ts,pkt),(ts,pkt)]
tempo_inicial = fluxo[0][0]
tempo_final = fluxo[-1][0]
duracao = tempo_final - tempo_inicial
return duracao
def calcula_tamanho_fluxo(
self, fluxo): # recebe uma lista no formato: [(ts,pkt),(ts,pkt)]
tamanho = 0
for pacote in fluxo:
tamanho += pacote[1].len
return tamanho
def conta_timeout_fluxo(
self,
key): # recebe uma string que é key de um fluxo em um dicionário
if key in self.timer:
self.timer[key].cancel()
self.timer[key] = Timer(self.time, self.finaliza_fluxo, args=[key])
self.timer[key].start()
def finaliza_fluxo(
self,
key): # recebe uma string que é key de um fluxo em um dicionário
self.cria_tupla(self.fluxo[key])
del (self.fluxo[key])
def cria_tupla(self, fluxo):
protocolo = self.classifica_fluxo(fluxo)
tempo = self.calcula_tempo_fluxo(fluxo)
tempo = tempo * 0.001
tamanho = self.calcula_tamanho_fluxo(fluxo)
tamanho = tamanho / 1024.0
if tempo > 0 and tamanho > 0:
taxa = tamanho / tempo
tupla = (protocolo, "%.6f" % tamanho, "%.6f" % tempo,
"%.6f" % taxa)
print "Tupla gerada:", tupla
#self.enviarTupla(tupla)
def enviarTupla(self, tupla):
credencial = pika.PlainCredentials('luiz', '113211')
connection = pika.BlockingConnection(
pika.ConnectionParameters('192.168.56.103', 5672, 'filas',
credencial))
channel = connection.channel()
channel.queue_declare(queue='HTTP')
channel.queue_declare(queue='DNS')
channel.queue_declare(queue='SSH')
channel.queue_declare(queue='FTP')
channel.queue_declare(queue='Unknown')
channel.queue_declare(queue='All')
if ('http' in tupla or 'HTTP' in tupla):
channel.basic_publish(exchange='',
routing_key='HTTP',
body=str(tupla))
elif ('dns' in tupla or 'DNS' in tupla):
channel.basic_publish(exchange='',
routing_key='DNS',
body=str(tupla))
elif ('ssh' in tupla or 'SSH' in tupla):
channel.basic_publish(exchange='',
routing_key='SSH',
body=str(tupla))
elif ('ftp' in tupla or 'FTP' in tupla):
channel.basic_publish(exchange='',
routing_key='FTP',
body=str(tupla))
elif (('dns' in tupla or 'DNS' in tupla)
or ('http' in tupla or 'HTTP' in tupla)
or ('ssh' in tupla or 'SSH' in tupla)
or ('ftp' in tupla or 'FTP' in tupla)):
channel.basic_publish(exchange='',
routing_key='All',
body=str(tupla))
else:
channel.basic_publish(exchange='',
routing_key='Unknown',
body=str(tupla))
channel.basic_publish(exchange='',
routing_key='All',
body=str(tupla))
print "[x] Mensagem Enviada!"
def main():
nomecoletor = "aluizio" #Para cada máquina virtual esse nome deve mudar
log = LogDeErros()
try:
coletor = Coletor()
serverPort = 12000
clientSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
clientSocket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
clientSocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
clientSocket.settimeout(3)
errorSocket = socketerror.socketError(socket.AF_INET,socket.SOCK_DGRAM)
errorSocket.setErrorProb(0.1)
errorSocket.settimeout(1)
serverAddress = ""
serverName = '<broadcast>'
message= ""
while True:
message = "adicionar"
clientSocket.sendto(message,(serverName, serverPort))
message = nomecoletor
clientSocket.sendto(message,(serverName, serverPort))
try:
returnMessage, serverAddress = clientSocket.recvfrom(2048) #Aguarda receber de retorno
if returnMessage.upper() == "ADICIONADO":
print "O coletor foi adicionado\n"
break
except socket.timeout:
print "Sem resposta, enviando nova solicitação."
#coletor.start()
while True:
print "Aguandando ordens do Monitor\n"
clientSocket.settimeout(None)
returnMessage, serverAddress = clientSocket.recvfrom(2048)
print returnMessage
if returnMessage.upper() == "COLETAR":
if coletor.stoprequest.isSet():
coletor.resume()
else:
coletor.start()
if returnMessage.upper() == "COLETARTESTE":
coletor.teste()
if returnMessage.upper() == "PARAR":
coletor.stop()
print coletor.isAlive()
if returnMessage.upper() == "LOG":
########################################## Transferência Confiável - Client ###########################################
numero_do_pacote = 0
errorSocket.connect((serverAddress))
nome_do_arquivo, serverAddress = clientSocket.recvfrom(2048) # recebe nome do arquivo de log que deve enviar
nome_do_arquivo = open(nome_do_arquivo,'r+b') # abre o Arquivo
lendo_arquivo = nome_do_arquivo.read(40) # lê um pedaço do arquivo e salva numa variável
while lendo_arquivo: # loop enquanto ainda estiver lendo o arquivo
receber = '' # inicializando valor padrão
while (receber != 'ACK'): # loop enquanto não recebe ack
enviar = lendo_arquivo+"&"+str(numero_do_pacote) # pedaço do arquivo + sequencia do pacote
errorSocket.sendWithError(enviar) # envia a variável com chance de erro
print "enviou pedaço do arquivo"
try:
print "esperando receber ack"
msg = errorSocket.recvWithError(1024) # espera 5s para receber ack, se estourar entra no except
print msg
dados = msg.split('&') # separa o ack e o número de sequência
receber = dados[0] # carrega o ack para disparar loop
if (str(numero_do_pacote) == dados[1]):
lendo_arquivo = nome_do_arquivo.read(40) # lê próxima parte do arquivo
numero_do_pacote += 1 # incrementa o número de sequência do pacote
except (socket.timeout): # tempo de resposta estourou
print "estourou o tempo"
break
nome_do_arquivo.close() # fechando arquivo
print "fechou o arquivo"
while True:
errorSocket.sendWithError("fim&*") # envia pacote final
try:
msg = errorSocket.recvWithError(1024) # espera 5s para receber ack, se estourar entra no except
break
except socket.timeout: # tempo de resposta estourou
print "estourou o tempo"
print "Enviou o fim"
##################################### ########################################### ######################################
clientSocket.close()
except (KeyboardInterrupt, SystemExit):
coletor.stoprequest.set()
log.setErro(sys.exc_info()[1],nomecoletor)
print "Um erro ocorreu!"
os._exit(0)
def main():
nomecoletor = "aluizio" #Para cada máquina virtual esse nome deve mudar
log = LogDeErros()
try:
coletor = Coletor()
serverPort = 12000
clientSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
clientSocket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
clientSocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
clientSocket.settimeout(3)
errorSocket = socketerror.socketError(socket.AF_INET,
socket.SOCK_DGRAM)
errorSocket.setErrorProb(0.1)
errorSocket.settimeout(1)
serverAddress = ""
serverName = '<broadcast>'
message = ""
while True:
message = "adicionar"
clientSocket.sendto(message, (serverName, serverPort))
message = nomecoletor
clientSocket.sendto(message, (serverName, serverPort))
try:
returnMessage, serverAddress = clientSocket.recvfrom(
2048) #Aguarda receber de retorno
if returnMessage.upper() == "ADICIONADO":
print "O coletor foi adicionado\n"
break
except socket.timeout:
print "Sem resposta, enviando nova solicitação."
#coletor.start()
while True:
print "Aguandando ordens do Monitor\n"
clientSocket.settimeout(None)
returnMessage, serverAddress = clientSocket.recvfrom(2048)
print returnMessage
if returnMessage.upper() == "COLETAR":
if coletor.stoprequest.isSet():
coletor.resume()
else:
coletor.start()
if returnMessage.upper() == "COLETARTESTE":
coletor.teste()
if returnMessage.upper() == "PARAR":
coletor.stop()
print coletor.isAlive()
if returnMessage.upper() == "LOG":
########################################## Transferência Confiável - Client ###########################################
numero_do_pacote = 0
errorSocket.connect((serverAddress))
nome_do_arquivo, serverAddress = clientSocket.recvfrom(
2048) # recebe nome do arquivo de log que deve enviar
nome_do_arquivo = open(nome_do_arquivo,
'r+b') # abre o Arquivo
lendo_arquivo = nome_do_arquivo.read(
40) # lê um pedaço do arquivo e salva numa variável
while lendo_arquivo: # loop enquanto ainda estiver lendo o arquivo
receber = '' # inicializando valor padrão
while (receber != 'ACK'): # loop enquanto não recebe ack
enviar = lendo_arquivo + "&" + str(
numero_do_pacote
) # pedaço do arquivo + sequencia do pacote
errorSocket.sendWithError(
enviar) # envia a variável com chance de erro
print "enviou pedaço do arquivo"
try:
print "esperando receber ack"
msg = errorSocket.recvWithError(
1024
) # espera 5s para receber ack, se estourar entra no except
print msg
dados = msg.split(
'&') # separa o ack e o número de sequência
receber = dados[
0] # carrega o ack para disparar loop
if (str(numero_do_pacote) == dados[1]):
lendo_arquivo = nome_do_arquivo.read(
40) # lê próxima parte do arquivo
numero_do_pacote += 1 # incrementa o número de sequência do pacote
except (socket.timeout): # tempo de resposta estourou
print "estourou o tempo"
break
nome_do_arquivo.close() # fechando arquivo
print "fechou o arquivo"
while True:
errorSocket.sendWithError("fim&*") # envia pacote final
try:
msg = errorSocket.recvWithError(
1024
) # espera 5s para receber ack, se estourar entra no except
break
except socket.timeout: # tempo de resposta estourou
print "estourou o tempo"
print "Enviou o fim"
##################################### ########################################### ######################################
clientSocket.close()
except (KeyboardInterrupt, SystemExit):
coletor.stoprequest.set()
log.setErro(sys.exc_info()[1], nomecoletor)
print "Um erro ocorreu!"
os._exit(0)
class Captura:
"""Classe que ira capturar pacotes"""
def __init__(self):
self.stats = "resume"
self.log = LogDeErros()
self.nomecoletor = ""
self.contaSemIP = 0
self.contaUDP = 0
self.contaTCP = 0
self.contaPacote = 0
self.fluxo = {}
self.timer = {}
self.time = 5
self.producer = Produtor()
def nomedocoletor(self, nome):
self.nomecoletor = nome
def status(self, arg):
self.stats = arg
print "Mudou status de captura para:", arg
def assinar(self):
file = open("l7-pat/dns.pat").readlines()
expr = file[0]
dns = re.compile(expr)
file = open("l7-pat/ftp.pat").readlines()
expr = file[0]
ftp = re.compile(expr)
file = open("l7-pat/http.pat").readlines()
expr = file[0]
http = re.compile(expr)
file = open("l7-pat/ssh.pat").readlines()
expr = file[0]
ssh = re.compile(expr)
file = open("l7-pat/bittorrent.pat").readlines()
expr = file[0]
bittorrent = re.compile(expr)
file = open("l7-pat/dhcp.pat").readlines()
expr = file[0]
dhcp = re.compile(expr)
file = open("l7-pat/ssdp.pat").readlines()
expr = file[0]
ssdp = re.compile(expr)
file = open("l7-pat/ssl.pat").readlines()
expr = file[0]
ssl = re.compile(expr)
assinaturas = {
"dns": dns,
"ftp": ftp,
"http": http,
"ssh": ssh,
"bittorrent": bittorrent,
"dhcp": dhcp,
"ssdp": ssdp,
"ssl": ssl,
}
return assinaturas
def capturateste(self):
try:
for ts, pkt in pcap.pcap("test-capture.pcap"):
if self.stats == "teste":
eth = dpkt.ethernet.Ethernet(pkt)
ip = eth.data
if isinstance(ip, dpkt.ip.IP):
ipsrc = ip.src
ipdst = ip.dst
protocolo = ip.p
transp = ip.data
if isinstance(transp, dpkt.tcp.TCP) or isinstance(transp, dpkt.udp.UDP):
if isinstance(ip.data, dpkt.tcp.TCP):
self.contaTCP += 1
elif isinstance(ip.data, dpkt.udp.UDP):
self.contaUDP += 1
portsrc = transp.dport
portdest = transp.sport
key = str(ipsrc) + str(portsrc) + str(ipdst) + str(portdest) + str(protocolo)
if not key in self.fluxo:
self.fluxo[key] = [(ts, ip)]
self.conta_timeout_fluxo(key)
else:
self.fluxo[key].append((ts, ip))
self.conta_timeout_fluxo(key)
else:
self.contaSemIP += 1
print "Pacote sem IP"
if self.stats == "resume":
self.captura()
if self.stats == "":
print "Coletor suspenso"
system("clear")
self.status("stop")
except (KeyboardInterrupt, SystemExit):
self.log.setErro(sys.exc_info()[1], self.nomecoletor)
print "Erro ao fazer captura de teste."
self.status("stop")
os._exit(0)
def captura(self):
try:
for ts, pkt in pcap.pcap():
if self.stats == "resume":
eth = dpkt.ethernet.Ethernet(pkt)
ip = eth.data
if isinstance(ip, dpkt.ip.IP):
ipsrc = ip.src
ipdst = ip.dst
protocolo = ip.p
transp = ip.data
if isinstance(transp, dpkt.tcp.TCP) or isinstance(transp, dpkt.udp.UDP):
if isinstance(ip.data, dpkt.tcp.TCP):
self.contaTCP += 1
elif isinstance(ip.data, dpkt.udp.UDP):
self.contaUDP += 1
portsrc = transp.dport
portdest = transp.sport
key = str(ipsrc) + str(portsrc) + str(ipdst) + str(portdest) + str(protocolo)
if not key in self.fluxo:
self.fluxo[key] = [(ts, ip)]
self.conta_timeout_fluxo(key)
else:
self.fluxo[key].append((ts, ip))
self.conta_timeout_fluxo(key)
print key
else:
self.contaSemIP += 1
print "Pacote sem IP"
if self.stats == "teste":
self.capturateste()
if self.stats == "stop":
for i in self.timer:
self.timer[i].cancel()
print "Coletor suspenso"
break
except (KeyboardInterrupt, SystemExit):
self.log.setErro(sys.exc_info()[1], self.nomecoletor)
print "Erro ao fazer captura."
os._exit(0)
def classifica_fluxo(self, fluxo): # recebe uma lista no formato: [(ts,pkt),(ts,pkt)]
self.protocols = self.assinar()
achou = False
for item in fluxo:
app = item[1].data.data.lower()
for p in self.protocols.items():
if p[1].search(app):
achou = True
protocolo = p[0]
if achou:
return protocolo
else:
return "nenhum"
def calcula_tempo_fluxo(self, fluxo): # recebe uma lista no formato: [(ts,pkt),(ts,pkt)]
tempo_inicial = fluxo[0][0]
tempo_final = fluxo[-1][0]
duracao = tempo_final - tempo_inicial
return duracao
def calcula_tamanho_fluxo(self, fluxo): # recebe uma lista no formato: [(ts,pkt),(ts,pkt)]
tamanho = 0
for pacote in fluxo:
tamanho += pacote[1].len
return tamanho
def conta_timeout_fluxo(self, key): # recebe uma string que é key de um fluxo em um dicionário
if key in self.timer:
self.timer[key].cancel()
self.timer[key] = Timer(self.time, self.finaliza_fluxo, args=[key])
self.timer[key].start()
def finaliza_fluxo(self, key): # recebe uma string que é key de um fluxo em um dicionário
self.cria_tupla(self.fluxo[key])
del (self.fluxo[key])
def cria_tupla(self, fluxo):
protocolo = self.classifica_fluxo(fluxo)
tempo = self.calcula_tempo_fluxo(fluxo)
tempo = tempo * 0.001
tamanho = self.calcula_tamanho_fluxo(fluxo)
tamanho = tamanho / 1024.0
if tempo > 0 and tamanho > 0:
taxa = tamanho / tempo
tupla = (protocolo, "%.6f" % tamanho, "%.6f" % tempo, "%.6f" % taxa)
print "Tupla gerada:", tupla
self.envia_tupla(tupla)
def envia_tupla(self, tupla):
try:
self.producer.enviatupla(tupla)
except:
print "servidor de filas indisponivel"
self.log.setErro(sys.exc_info()[1], self.nomecoletor)