Updating Folder Organization

Programas/Fedora/bruteforce_reduction.py

@@ -0,0 +1,111 @@
+#Itera a la vez el sip y el dip y guarda en un hash los puertos
+
+from silk import *
+
+
+startDate = "2009/04/20"
+endDate = "2009/04/22"
+#Para filtrar por puertos. Pero no queremos todavia
+#minPort = 20
+#maxPort = 5000
+
+
+def ipConversion(number, position):
+    mystr = ''
+    ipadd = number.split(".") #Devuelve un arreglo
+    for i in range(position+1):
+        if i ==position:
+            mystr = mystr + ipadd[i]
+        else:
+            mystr = mystr + ipadd[i] + '.'
+    return mystr #devuelve los numeros en notacion string
+
+
+def PrimerAnalisis(flowHash, num):
+    dportHash={}
+    flow_Counter=0
+    for filename in FGlob(classname="all", type="all", start_date=startDate, end_date=endDate, site_config_file="/data/silk.conf", data_rootdir="/data"):
+        for rec in silkfile_open(filename, READ):#reading the flow file
+
+            if (':' in str(rec.sip)) or (num != 0 and ipConversion(str(rec.sip), num-1) not in flowHash): #Si en el paso anterior se vio que no
+                                                                         #tiene el length de puertos requerido, se ignora
+                continue
+            else: #agrega a un hash cada puerto con un counter de sus destination ips
+                dip = ipConversion(str(rec.dip), num)
+                sip = ipConversion(str(rec.sip), num)
+                dport= rec.dport
+                if sip in dportHash:
+                    if dip in dportHash[sip]:
+                        dportHash[sip][dip] += 1
+                    else:
+                        dportHash[sip][dip] = 1
+                else:
+                    dportHash[sip] = { dip: 1 }
+
+    #print flow_Counter
+    return dportHash
+
+
+def UltimoAnalisis(flowHash, num):
+    dportHash={}
+    flow_Counter=0
+    for filename in FGlob(classname="all", type="all", start_date=startDate, end_date=endDate, site_config_file="/data/silk.conf", data_rootdir="/data"):
+        for rec in silkfile_open(filename, READ):#reading the flow file
+            if (':' in str(rec.sip)) or (num != 0 and ipConversion(str(rec.sip), num-1) not in flowHash): #Si en el paso anterior se vio que no
+                                                                         #tiene el length de puertos requerido, se ignora
+                continue
+            else: #agrega a un hash cada puerto con un counter de sus destination ips
+                dip = ipConversion(str(rec.dip), num)
+                sip = ipConversion(str(rec.sip), num)
+                dport= rec.dport
+                if sip in dportHash:
+                    if dip in dportHash[sip]:
+                        dportHash[sip][dip].append(dport)
+                    else:
+                        dportHash[sip][dip] = [dport]
+                else:
+                    dportHash[sip] = { dip: [dport] }
+
+    #print flow_Counter
+    return dportHash
+
+
+
+
+#main
+
+myNum = 0
+otherHash = {}
+while myNum <3: #Se itera las cuatro veces de acuerdo con la notacion de ipv4
+    flowHash= PrimerAnalisis(otherHash, myNum)
+    otherHash = {} #Se borra el hash para agregar elementos nuevos con la nueva etapa de la busqueda
+    for sips in flowHash: #se itera por todos los dip y sus counters o puertos
+        for dips, dports in flowHash[sips].items():
+            if dports >= 100: #si la cantidad de puertos es mayor o igual a 100, nos interesan
+                                    #y por lo tanto se guardan en un hash
+                if sips in otherHash:
+                    otherHash[sips][dips] = dports
+                else:
+                    otherHash[sips] = {dips: dports}
+    myNum += 1
+
+    #print (flowHash)
+
+#print otherHash
+#Ultimo chequeo, utilizando el ip completo
+counter = 0
+flowHash = UltimoAnalisis(otherHash, myNum)
+otherHash = {} #Se borra el hash para agregar elementos nuevos con la nueva etapa de la busqueda
+for sips in flowHash: #se itera por todos los dip y sus counters o puertos
+    for dips, dports in flowHash[sips].items():
+        if len(dports) >= 100: #si la cantidad de puertos es mayor o igual a 100, nos interesan
+                                #y por lo tanto se guardan en un hash
+            if sips in otherHash:
+                otherHash[sips][dips] = dports
+            else:
+                otherHash[sips] = {dips: dports}
+
+for dips, dports in otherHash.items():
+    counter +=1 #para contar los elementos del hash
+
+print (counter)

Programas/Fedora/bruteforce_reduction_sip.py

@@ -0,0 +1,114 @@
+#Itera por sip /16 y cuenta numero de puertos por cada dip
+
+from silk import *
+
+
+startDate = "2009/04/20"
+endDate = "2009/04/22"
+#Para filtrar por puertos. Pero no queremos todavia
+#minPort = 20
+#maxPort = 5000
+
+
+def ipConversion(number, position):
+    mystr = ''
+    ipadd = number.split(".") #Devuelve un arreglo
+    for i in range(position+1):
+        if i ==position:
+            mystr = mystr + ipadd[i]
+        else:
+            mystr = mystr + ipadd[i] + '.'
+    return mystr #devuelve los numeros en notacion string
+
+
+def PrimerAnalisis(flowHash, num):
+    dportHash={}
+    flow_Counter=0
+    for filename in FGlob(classname="all", type="all", start_date=startDate, end_date=endDate, site_config_file="/data/silk.conf", data_rootdir="/data"):
+        for rec in silkfile_open(filename, READ):#reading the flow file
+            if (':' in str(rec.sip)) or (num != 0 and ipConversion(str(rec.sip), num-1) not in flowHash): #Si en el paso anterior se vio que no
+                                                                         #tiene el length de puertos requerido, se ignora
+                continue
+            else: #agrega a un hash cada puerto con un counter de sus destination ips
+                dip = str(rec.dip)
+                sip = ipConversion(str(rec.sip), num)
+                dport= rec.dport
+                if sip in dportHash:
+                    if dip in dportHash[sip]:
+                        dportHash[sip][dip] += 1
+                    else:
+                        dportHash[sip][dip] = 1
+                else:
+                    dportHash[sip] = { dip: 1 }
+
+    #print flow_Counter
+    return dportHash
+
+
+def UltimoAnalisis(flowHash, num):
+    dportHash={}
+    flow_Counter=0
+    for filename in FGlob(classname="all", type="all", start_date=startDate, end_date=endDate, site_config_file="/data/silk.conf", data_rootdir="/data"):
+        for rec in silkfile_open(filename, READ):#reading the flow file
+            if (':' in str(rec.sip)) or (num != 0 and ipConversion(str(rec.sip), num-1) not in flowHash): #Si en el paso anterior se vio que no
+                                                                         #tiene el length de puertos requerido, se ignora
+                continue
+            else: #agrega a un hash cada puerto con un counter de sus destination ips
+                dip = ipConversion(str(rec.dip), num)
+                sip = ipConversion(str(rec.sip), num)
+                dport= rec.dport
+                if sip in dportHash:
+                    if dip in dportHash[sip]:
+                        dportHash[sip][dip].append(dport)
+                    else:
+                        dportHash[sip][dip] = [dport]
+                else:
+                    dportHash[sip] = { dip: [dport] }
+
+    #print flow_Counter
+    return dportHash
+
+
+
+
+
+
+
+
+#main
+
+myNum = 0
+otherHash = {}
+while myNum <3: #Se itera las cuatro veces de acuerdo con la notacion de ipv4
+    flowHash= PrimerAnalisis(otherHash, myNum)
+    otherHash = {} #Se borra el hash para agregar elementos nuevos con la nueva etapa de la busqueda
+    for sips in flowHash: #se itera por todos los dip y sus counters o puertos
+        for dips, dports in flowHash[sips].items():
+            if dports >= 100: #si la cantidad de puertos es mayor o igual a 100, nos interesan
+                                    #y por lo tanto se guardan en un hash
+                if sips in otherHash:
+                    otherHash[sips][dips] = dports
+                else:
+                    otherHash[sips] = {dips: dports}
+    myNum += 1
+
+    #print (flowHash)
+
+#print otherHash
+#Ultimo chequeo, utilizando el ip completo
+counter = 0
+flowHash = UltimoAnalisis(otherHash, myNum)
+otherHash = {} #Se borra el hash para agregar elementos nuevos con la nueva etapa de la busqueda
+for sips in flowHash: #se itera por todos los dip y sus counters o puertos
+    for dips, dports in flowHash[sips].items():
+        if len(dports) >= 100: #si la cantidad de puertos es mayor o igual a 100, nos interesan
+                                #y por lo tanto se guardan en un hash
+            if sips in otherHash:
+                otherHash[sips][dips] = dports
+            else:
+                otherHash[sips] = {dips: dports}
+
+for dips, dports in otherHash.items():
+    counter +=1 #para contar los elementos del hash
+
+print counter

Programas/Fedora/bruteforce_sip-dip-ports.py

@@ -0,0 +1,50 @@
+# Guarda lista de puertos de cada dip por cada sip
+
+from silk import *
+
+
+startDate = "2009/04/20"
+endDate = "2009/04/22"
+#Para filtrar por puertos. Pero no queremos todavia
+#minPort = 20
+#maxPort = 5000
+
+
+def verify_type():
+    dportHash = {} #contains amount of dport per each sip
+    for filename in FGlob(classname="all", type="all", start_date=startDate, end_date=endDate, site_config_file="/data/silk.conf", data_rootdir="/data"):
+        for rec in silkfile_open(filename, READ):#reading the flow file
+            sip = str(rec.sip)
+            dip = str(rec.dip)
+            dport = rec.dport
+            if (':' in sip): #Si en el paso anterior se vio que no
+                                                                #tiene el length de puertos requerido, se ignora
+                continue
+            else:
+                if sip in dportHash:
+                    if dip in dportHash[sip]:
+                        dportHash[sip][dip].append(dport)
+                    else:
+                        dportHash[sip][dip] = [dport]
+                else:
+                    dportHash[sip] = { dip: [dport] }
+    return dportHash
+
+
+#MAIN
+otherHash = {}
+counter = 0
+flowHash = verify_type()
+for sips in flowHash: #se itera por todos los dip y sus counters o puertos
+    for dips, dports in flowHash[sips].items():
+        if len(dports) >= 100: #si la cantidad de puertos es mayor o igual a 100, nos interesan
+                                #y por lo tanto se guardan en un hash
+            if sips in otherHash:
+                otherHash[sips][dips] = dports
+            else:
+                otherHash[sips] = {dips: dports}
+
+for dips, dports in otherHash.items():
+    counter +=1 #para contar los elementos del hash
+
+print (counter)

Programas/Fedora/fedora_code_ps_no_reduc.py

@@ -0,0 +1,50 @@
+###########################################################
+#    Port Scanner
+#    Cuenta total de puertos desinatarios por cada sip
+#     Despliega lista de puertos por cada destination ip
+############################################################
+from silk import *
+
+
+startDate = "2009/04/20"
+endDate = "2009/04/22"
+minPort = 20
+maxPort = 60000
+counter = 0
+
+def UltimoAnalisis():
+    sampleHash = {}
+    flow_Counter = 0
+    for filename in FGlob(classname="all", type="all", start_date=startDate, end_date=endDate, site_config_file="/data/silk.conf", data_rootdir="/data"):
+        for rec in silkfile_open(filename, READ):#reading the flow file
+            flow_Counter +=1
+            dport = rec.dport
+	    posA = str(rec.dip)
+           # print posA, dport
+            if (dport >= 1 and dport < minPort) or dport > maxPort: #verifica que sean puertos validos (creo que se dice asi)
+               # print "Im here"
+                continue
+            else: # Como es el caso de la ultima busqueda, se agrega una lista de los puertos
+                if posA in sampleHash:
+                    sampleHash[posA].append(dport)
+                else:
+                    sampleHash[posA] = [dport]
+                #print sampleHash
+    #print flow_Counter
+    return sampleHash
+
+dip_hash = UltimoAnalisis()
+#print dip_hash
+otherHash = {} #Se borra el hash para agregar elementos nuevos con la nueva etapa de la busqueda
+for dips, dports in dip_hash.items():
+    if len(dports)>= 100: #si la cantidad de puertos es mayor o igual a 100, nos interesan
+                                #y por lo tanto se guardan en un hash
+        otherHash[dips] = dports
+
+
+for dips, dports in otherHash.items():
+    counter +=1 #para contar los elementos del hash
+
+    #print otherHash
+
+#print counter

Programas/Fedora/fedora_code_ps_reduc.py

@@ -0,0 +1,119 @@
+###########################################################
+#    Reduction Port Scanner
+#    Cuenta total de puertos desinatarios por cada sip
+#     Despliega lista de puertos por cada destination ip
+############################################################
+
+from silk import *
+
+
+startDate = "2009/04/20"
+endDate = "2009/04/22"
+minPort = 20
+maxPort= 60000
+flowHash={}
+otherHash= {}
+myNum = 0
+counter = 0
+
+
+
+#Funcion que convierte el int ipaddress en notacion string y devuelve los numeros
+#hasta la posicion del punto dada en los parametros
+def ipConversion(number, position):
+    mystr = ''
+    ipadd = number.split(".") #Devuelve un arreglo
+    for i in range(position+1):
+        if i ==position:
+            mystr = mystr + ipadd[i]
+        else:
+            mystr = mystr + ipadd[i] + '.'
+    return mystr #devuelve los numeros en notacion string
+
+
+#Funcion que verifica los flows y guarda su dip y, primero un counter de sus puertos,
+#y luego los puertos, en un hash. Recibe dos parametros, un hash para verificar
+#si ignorar o no el flow (dado en el main), y un numero para la idea de reduccion
+def PrimerAnalisis(flowHash, num):
+    sampleHash={}
+    flow_Counter=0
+    for filename in FGlob(classname="all", type="all", start_date=startDate, end_date=endDate, site_config_file="/data/silk.conf", data_rootdir="/data"):
+        for rec in silkfile_open(filename, READ):#reading the flow file
+            flow_Counter+=1
+            dport= rec.dport
+            #print "First", str(rec.sip), str(rec.dip)
+            if (':' in str(rec.dip)) or (num != 0 and ipConversion(str(rec.dip), num-1) not in flowHash): #Si en el paso anterior se vio que no
+                                                                         #tiene el length de puertos requerido, se ignora
+                continue
+
+            elif (dport >= 1 and dport < minPort) or dport > maxPort: #verifica que sean puertos validos (creo que se dice asi)
+                continue
+            else: #agrega a un hash cada puerto con un counter de sus destination ips
+                posA = ipConversion(str(rec.dip), num) #devuelve la primera clase del ip en notacion string
+                if posA in sampleHash:
+                    sampleHash[posA] += 1
+                    #print (posA)
+                else:
+                    sampleHash[posA] = 1
+                    #print (posA)
+
+    print flow_Counter
+    return sampleHash
+
+
+def UltimoAnalisis(flowHash, num):
+    sampleHash = {}
+    flow_counter = 0
+    #print flowHash
+    for filename in FGlob(classname="all", type="all", start_date=startDate, end_date=endDate, site_config_file="/data/silk.conf", data_rootdir="/data"):
+        for rec in silkfile_open(filename, READ):#reading the flow file
+            flow_counter +=1
+            dport = rec.dport
+	    print "Ultimo", str(rec.sip), str(rec.dip)
+
+            if (':' in str(rec.dip)) or (num != 0 and ipConversion(str(rec.dip), num-1) not in flowHash): #Si en el paso anterior se vio que no
+                                                                             #tiene el length de puertos requerido, se ignora
+
+                continue
+            elif (dport >= 1 and dport < minPort) or dport > maxPort: #verifica que sean puertos validos (creo que se dice asi)
+                continue
+            else: # Como es el caso de la ultima busqueda, se agrega una lista de los puertos
+                posA = ipConversion(str(rec.dip), num) #devuelve la primera clase del ip en notacion string
+                print posA
+                if posA in sampleHash:
+                    sampleHash[posA].append(dport)
+                else:
+                    sampleHash[posA] = [dport]
+    print flow_counter
+    return sampleHash
+
+
+
+#MAIN:
+
+while myNum <3: #Se itera las cuatro veces de acuerdo con la notacion de ipv4
+    flowHash= PrimerAnalisis(otherHash, myNum)
+    otherHash = {} #Se borra el hash para agregar elementos nuevos con la nueva etapa de la busqueda
+    for dips, dports in flowHash.items(): #se itera por todos los dip y sus counters o puertos
+        if dports >= 100: #si la cantidad de puertos es mayor o igual a 100, nos interesan
+                                    #y por lo tanto se guardan en un hash
+            otherHash[dips] = dports
+    myNum += 1
+
+    #print (flowHash)
+
+print otherHash
+#Ultimo chequeo, utilizando el ip completo
+
+flowHash = UltimoAnalisis(otherHash, myNum)
+otherHash = {} #Se borra el hash para agregar elementos nuevos con la nueva etapa de la busqueda
+for dips, dports in flowHash.items():
+    print dports
+    if len(dports)>= 1: #si la cantidad de puertos es mayor o igual a 100, nos interesan
+                                #y por lo tanto se guardan en un hash
+        otherHash[dips] = dports
+
+for dips, dports in otherHash.items():
+    counter +=1 #para contar los elementos del hash
+
+print (counter)

Programas/Fedora/fedora_code_scanner.py

@@ -0,0 +1,58 @@
+##########################################################
+
+#  NS or PS Verifier
+
+# Receives a List of Source IP Addresses, and depending on the
+
+#  ratio of dips and dports, classifies the ip address as ps or ns
+
+#########################################################
+
+
+
+from silk import *
+
+
+startDate = "2009/04/20"
+endDate = "2009/04/22"
+minPort = 20
+maxPort = 5000
+verifyHash = {}
+
+def verify_type():
+    dportHash = {} #contains amount of dport per each sip
+    for filename in FGlob(classname="all", type="all", start_date=startDate, end_date=endDate, site_config_file="/data/silk.conf", data_rootdir="/data"):
+        for rec in silkfile_open(filename, READ):#reading the flow file
+            sip = str(rec.sip)
+            dip = str(rec.dip)
+            if (rec.dport >= 1 and rec.dport < minPort) or rec.dport > maxPort: #verifica que sean puertos validos (creo que se dice asi)
+                    continue
+            else: #agrega a un hash cada puerto con un counter de sus destination ips
+                  if sip in dportHash:
+                      if dip in dportHash[sip]:
+                          dportHash[sip][dip] += 1
+                      else:
+                          dportHash[sip][dip] = 1
+                  else:
+                      dportHash[sip] = { dip: 1 }
+    return dportHash
+total_dports = 0
+total_dips = 0
+sipList = ' ' #esta lista viene de los codigos de trw
+verifyHash = verify_type()
+psList = [] #list of ip adresses of port scanners
+nsList = [] #list of ip adresses of network scanners
+for sip in verifyHash: #itera por cada ip address y sus puertos
+    for i in verifyHash[sip]:
+        total_dports = total_dports + verifyHash[sip][i]
+    total_dips = len(verifyHash[sip])
+    #check if it is network scan or port scan
+    #casoA        mas dports que dips por mucho. Que el ratio sea 100:1 o mas
+    if total_dports / total_dips >= 5:
+            #print ("something suspicious...")
+        #print "This IP Adress %s is a Port Scanner "
+        psList.append(sip)
+    #caso B mas dports que dips pero que el ratio sea 5:1 o menos
+    elif total_dports / total_dips <= 5:
+        #print "This IP Adress %s is a Network Scanner "
+        nsList.append(sip)

Programas/Fedora/fedora_code_trw.py

@@ -0,0 +1,59 @@
+##################################
+#   TRW sin reduccion           #
+#      Para Silk's Data Set     #
+################################
+
+
+
+from silk import *
+startDate = "2009/04/20"
+endDate = "2009/04/22"
+p = 2
+
+def Analisis():
+    counter = 0 # borrar luego
+    sampleHash={} #hash para contener los dip con el numero de conecciones y failed coneccciones
+    flow_counter = 0
+    for filename in FGlob(classname="all", type="all", start_date=startDate, end_date=endDate, site_config_file="/data/silk.conf", data_rootdir="/data"):
+        for rec in silkfile_open(filename, READ):#reading the flow file
+            flow_counter += 1
+            if (':' in str(rec.sip)):
+				continue
+	    	else:
+            	connection = [0] * 2 #Lista para contener los valores de conecciones failed y conecciones buenas
+            	sip = str(rec.sip) #Devuelve el ip en notacion punto-decimal
+            	flags = str(rec.tcpflags)
+            #print sip, flags
+	    #counter +=1
+            	if 'A' in flags: ####arreglar
+                	connection[1]=1 #good conections
+                else:
+                	connection [0] =1 #failed conections
+            	if sip in sampleHash:
+	                sampleHash[sip][0]+= connection[0]
+	                sampleHash[sip][1]+= connection[1]
+            	else:
+                	sampleHash[sip] = [connection[0], connection[1]]
+	    #print sampleHash
+    #print flow_counter
+    return sampleHash
+
+sip_connections_list = Analisis()
+#print sip_connections_list
+sipList = []
+for sip in sip_connections_list:
+          if (sip_connections_list[sip][1] != 0) and ((sip_connections_list[sip][0] / sip_connections_list[sip][1])  < 1) : #si la cantidad de succesful
+                                #b                #g                    #connections es mas que failed connections
+                      #not scanner, ignore
+                      continue
+          elif (sip_connections_list[sip][1] != 0) and ((sip_connections_list[sip][0] / sip_connections_list[sip][1])  < p): #mas failed que succesful, pero no llega al threshold
+                      #not scanner, ignore
+                      continue                          #se debe tener en cuenta que es suspicious pero no taaanto
+          elif (sip_connections_list[sip][1] == 0 and sip_connections_list[sip][0] > 10): #el ratio de failed a succesful llega al threshold pautado
+                            #scanner, oh oh
+                    sipList.append(sip)
+          else:
+                            #scanner, oh oh
+                    sipList.append(sip)
+
+#print len(sipList)

Programas/Fedora/fedora_code_trw_reduc.py

@@ -0,0 +1,82 @@
+from silk import *
+
+myNum = 0
+sipList=[]
+sip_hash = {}
+startDate = "2009/04/20"
+endDate = "2009/04/22"
+p = 2
+##################################
+
+#   TRW con reduccion           #
+
+#      Para Silk's Data Set     #
+
+#################################
+
+
+def ipConversion(number, position):
+    mystr = ''
+    ipadd = number.split(".") #Devuelve un arreglo
+    #print ipadd
+    for i in range(position+1):
+        if i == position:
+            #print ipadd[i]
+            mystr = mystr + ipadd[i]
+        else:
+           # print ipadd[i]
+            mystr = mystr + ipadd[i] + '.'
+    return mystr #devuelve los numeros en notacion string
+
+
+def AnalisisReduciendo(sipList, num):
+    sip_hash = {}
+    #print sipList
+    flow_counter = 0
+    for filename in FGlob(classname="all", type="all", start_date=startDate, end_date=endDate, site_config_file="/data/silk.conf", data_rootdir="/data"):
+        for rec in silkfile_open(filename, READ):#reading the flow file
+            flow_counter += 1
+            if (':' in str(rec.sip)) or (num != 0 and ipConversion(str(rec.sip), num-1) not in sipList):#Si en el paso anterior se vio que no
+                                                               #tiene el length de puertos requerido, se ignora
+		       continue
+            else:
+                connection = [0] * 2 #Lista para contener los valores de conecciones fallidas y conecciones buenas
+                sip = ipConversion(str(rec.sip), num) #Devuelve el ip en notacion punto-decimal
+                flags = str(rec.tcpflags)  #array of all tcp flags that are set
+                if 'A' in flags: #if the acknowledge flag is set
+                    connection[1]=1 #good conections
+                else:
+                    connection [0] =1 #failed conections
+                if sip in sip_hash: #si sip esta en ratioHash => que posA esta en sampleHash
+                                            #por lo tanto ya se puede sumar las conecciones al ratio del dip
+                    sip_hash[sip][0]+=connection[0]
+                    sip_hash[sip][1] += connection[1]
+                else: #si sip no esta en ratioHash tampoco
+                    sip_hash[sip] = [connection[0], connection[1]]
+                #print sip_hash
+    #print flow_counter
+    return sip_hash
+
+
+while myNum <4:
+      sip_connections_list = AnalisisReduciendo(sipList, myNum)
+      sipList = []
+      for sip in sip_connections_list:
+          if (sip_connections_list[sip][1] != 0) and ((sip_connections_list[sip][0] / sip_connections_list[sip][1])  < 1) : #si la cantidad de succesful
+                                #b                #g                    #connections es mas que failed connections
+                      #not scanner, ignore
+                      continue
+          elif (sip_connections_list[sip][1] != 0) and ((sip_connections_list[sip][0] / sip_connections_list[sip][1])  < p): #mas failed que succesful, pero no llega al threshold
+                      #not scanner, ignore
+                      continue                          #se debe tener en cuenta que es suspicious pero no taaanto
+          elif (sip_connections_list[sip][1] == 0 and sip_connections_list[sip][0] > 10): #el ratio de failed a succesful llega al threshold pautado
+                            #scanner, oh oh
+                    sipList.append(sip)
+          else:
+                            #scanner, oh oh
+                    sipList.append(sip)
+      #print sipList
+
+      #print myNum
+      myNum += 1
+#print len(sipList)

Programas/erase.py

@@ -0,0 +1,18 @@
+
+flowHash = {'hola':{'wassup':900, 'eh':9000}}
+sip = 'hola'
+dip = 'wassup'
+dport = 90
+otherHash = {}
+
+for sips in flowHash: #se itera por todos los dip y sus counters o puertos
+    for dips, dports in flowHash[sips].items():
+        if dports >= 100: #si la cantidad de puertos es mayor o igual a 100, nos interesan
+                                #y por lo tanto se guardan en un hash
+            print dports
+            if sips in otherHash:
+                otherHash[sips][dips] = dports
+            else:
+                otherHash[sips] = {dips: dports}
+
+print otherHash

Programas/otherHash.py

@@ -0,0 +1,9 @@
+newHash = {}
+
+dip = "hola"
+if dip in newHash:
+    newHash[dip] +=1
+else:
+    newHash[dip] = 1
+
+print newHash

Programas/trw_real.py

@@ -33,7 +33,6 @@ def ipConversion(number, position):
 
 
 def AnalisisReduciendo(sipList, num):
-    connection = [0] * 2 #Lista para contener los valores de conecciones fallidas y conecciones buenas
     for i in flow["flows"]: #itera por cada elemento del diccionario de flows
         sip = ipConversion(i["sip"], num) #Devuelve el ip en notacion punto-decimal
         flags = i["tcpflags"].split(",")  #array of all tcp flags that are set
@@ -41,6 +40,7 @@ def AnalisisReduciendo(sipList, num):
                                                                      #tiene el length de puertos requerido, se ignora
             continue
         else:
+            connection = [0] * 2 #Lista para contener los valores de conecciones fallidas y conecciones buenas
             if 'A' in flags: #if the acknowledge flag is set
             connection[1]=1 #good conections
             else:
@@ -51,7 +51,7 @@ def AnalisisReduciendo(sipList, num):
                 ratioHash[sip][1] += connection[1]]
             else: #si sip no esta en ratioHash tampoco
                 ratioHash= {sip: [connection[0], connection[1]]}
-
+            print (ratioHash)
 
     return ratioHash
 

flows_code.py

@@ -0,0 +1,4 @@
+import silk
+
+for filename in FGlob(classname="all", type="all", start_date=startDate, end_date=endDate, site_config_file="/data/silk.conf", data_rootdir="/data"):
+  for rec in silkfile_open(filename, READ): #reading the flow file