All files

Practica/otherHash.py

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

Practica/realPs.py

@@ -0,0 +1,77 @@
+import ipaddress
+import netflows
+
+
+#Para usar Silk
+#SilkFile object (represents a channel for writing to or reading from Silk flow file)
+#FGlob object (allows retireval of filenames in a silk data store.)
+
+
+
+
+
+
+x = 20
+y = 60000
+ignoreip = []
+myHash={}
+myNum = 0
+counter = 0
+
+def ipConversion(number, position):
+    mystr = ''
+    ipadd = (str(ipaddress.IPv4Address(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
+def PrimerAnalisis(num):
+    newHash={}
+    for i in netflows.flowprinter["flows"]: #itera por cada elemento del diccionario de flows
+        posA = ipConversion(i["dip"], num)
+        if ignoreip != [] and posA[0:4*num] in ignoreip:
+            continue
+        elif (i['dport'] >= 1 and i['dport'] < x) or i['dport'] > y: #verifica que sean puertos (se me fue la palabra...)
+            continue
+        else: #agrega a un hash cada puerto con un counter de sus destination ips
+            if num ==3:
+                if posA in newHash:
+                    newHash[posA].append(i['dport'])
+                else:
+                    newHash[posA] = [i['dport']]
+            else:
+                if posA in newHash:
+                    newHash[posA] += 1
+                    #print (posA)
+                else:
+                    newHash[posA] = 1
+                    #print (posA)
+
+    return newHash
+
+#MAIN:
+while myNum <4:
+    myHash= PrimerAnalisis(myNum)
+    ignoreip =[]
+    for k, v in myHash.items():
+        if myNum != 3 and v >= 100:
+            continue
+        elif myNum == 3 and len(v)>= 100:
+            continue
+        else:
+            ignoreip.append(k)
+    myNum += 1
+
+
+for i in ignoreip:
+    myHash.pop(i)
+for k, v in myHash.items():
+    counter +=1
+#print (ignoreip)
+print (counter)
+
+
+
+#Si el valor de la llave es menos que 100, no me interesa.

Practica/trial.py

@@ -0,0 +1,39 @@
+# ratioHash = {}
+# sampleHash = {}
+#
+# sip = "sara"
+# posA = 'alexandra'
+#
+# connection = [1,1]
+#
+# print 10/5
+#
+# for i in range (0, 2):
+#     if sip in ratioHash:
+#         sampleHash[posA][0]+=connection[0]
+#         sampleHash[posA][1]+= connection[1]
+#     else:
+#         sampleHash[posA] = [connection[0], connection[1]]
+#         ratioHash[sip] = sampleHash
+#         #print (posA
+#
+# print ratioHash
+#
+# import json
+# #PATH = '/Users/Sara/Documents/Univ Classes/Investigacion/Programas/newFlow.txt'
+# PATH = '/mnt/c/Users/Sara/Documents/Univ Classes/Investigacion/Programas/newFlow.txt'
+#
+# myFile = open(PATH, 'r')
+# ip = myFile.read()
+# flow = json.loads(ip)
+#
+# for i in flow['flows']:
+#     flags = i["tcpflags"].split(",")
+#     print flags[0]
+hashi = {}
+if 'hola' in hashi:
+    hashi['hola'][0]+= 1
+else:
+    hashi = {'hola': [0, 1]}
+
+print hashi['hola']

Programas/NS_orig.py

@@ -0,0 +1,63 @@
+#Network Scan without reduction
+
+import ipaddress
+import json
+
+
+x = 20
+y = 60000
+deletevar = []
+newHash={}
+
+PATH = '/Users/Sara/Documents/Univ Classes/Investigacion/Programas/netflows.txt'
+
+myFile = open(PATH, 'r')
+ip = myFile.read()
+flow = json.loads(ip)
+
+def ipConversion(number, position):
+    mystr = ''
+    ipadd = (str(ipaddress.IPv4Address(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
+
+
+for i in flow["flows"]: #itera por cada elemento del diccionario de flows
+    #Cambiar esto al unirlo con el trw
+    if i['sip'] == 2291263257: #Este numero se lo dara el trw que verifica que sip son scanners
+        dip = ipConversion(i['dip'], 0)
+        host = ipConversion(i['dip'], 3)
+        if dip in newHash and host not in newHash[dip]:
+            newHash[dip].append(host)
+        else:
+            newHash[dip] = [host]
+
+#LO SIGUIENTE ESTA COMENTADO Y LO EXPLICO EN EL WORD
+
+
+# for k, v in newHash.items(): #itera por cada ip address y sus puertos
+#     if len(v) >= 100:
+#         #print ("something suspicious...")
+#         continue
+#     else: #Si no tiene una cantidad considerable de puertos, agrega el ip a una lista
+#         if k in deletevar:
+#             continue
+#         else:
+#             deletevar.append(k)
+
+#
+# for i in deletevar: #borra todos los elementos que estan en la lista deletevar
+#                     #del hash con todos los ip y sus puertos
+#     newHash.pop(i)
+
+counter = 0 #Para contar total de elementos en el hash
+for k, v in newHash.items(): #imprime los destination ip address con sus puertos
+    counter = counter+1
+    #k = str(ipaddress.IPv4Address(k))
+    print ("{}:{}".format(k,v))
+print (counter)
+print( "Done checking:")

Programas/PS_delete.py

@@ -0,0 +1,81 @@
+import ipaddress
+import json
+
+#Port Scanner, using a reduction method,re-reading the list the 4
+#times.
+
+PATH = '/Users/Sara/Documents/Univ Classes/Investigacion/Programas/netflows.txt'
+
+myFile = open(PATH, 'r')
+ip = myFile.read()
+flow = json.loads(ip)
+
+#Son los limites de los Puertos que queremos verificar
+x = 20
+y = 60000
+
+#Variables inicializadas
+hashbrown = {}
+myNum = 0
+
+#Esta funcion convierte la direccion de ip de un entero a un string usando la libreria de ipaddress.
+#Recibe dos parametros, la direccion de ip en entero y un numero k. Esta funcion devuelve un arreglo compuesto de cada
+#numero decimal entre los puntos del string. Dependiendo del numero k sera hasta que posision del arreglo se devolvera.
+def ipConversion(number, k):
+
+    mystr = ''
+    ipadd = (str(ipaddress.IPv4Address(number))).split(".") #Devuelve un arreglo
+    for i in range(k+1):
+        mystr = mystr + ipadd[i] + '.'
+    return mystr
+
+
+#This function returns a hash with the ip address as the key and a list of the ports asociated with
+#that ipaddress
+def PrimerAnalisis(number):
+    ps = {}
+    for i in flow["flows"]: #for each element of the value of 'flows'
+        posA = ipConversion(i["dip"], number) #change the ip address to string
+
+        if (i['dport'] >= 1 and i['dport'] < x) or i['dport'] > y: #verifica que sean puertos (se me fue la palabra...)
+            continue
+        else: #agrega a un hash cada puerto con su destination ip
+            if posA in ps:
+                ps[posA].append(i['dport'])
+
+            else:
+                ps[posA] = [i['dport']]
+
+    return ps
+
+deletevar = []
+while myNum < 4: #recorrera 4 veces la lista de flows empezando con el primer numero decimal de los ip hasta el 4to
+    hashBrown= PrimerAnalisis(myNum) #crea un hash
+
+    for k, v in hashBrown.items(): #itera por cada ip address y sus puertos
+        if len(v) >= 100:
+            #print ("something suspicious...")
+            continue
+        else: #Si no tiene una cantidad considerable de puertos, sigue verificando
+            #print  ("nothing Suspicious but: (%s:%s)" %(k, v) )
+            if myNum == 3 : #Si se llega a la ultima verificacion se agregan a una lista para luego borrarlas del hash
+                if k in deletevar:
+                    continue
+                else:
+                    deletevar.append(k)
+            else:
+                continue
+
+    myNum = myNum + 1
+
+
+for i in deletevar: #borra todos los elementos que estan en la lista deletevar
+                    #del hash con todos los ip y sus puertos
+    hashBrown.pop(i)
+
+counter = 0#Para contar total de elementos en el hash
+for k, v in hashBrown.items(): #imprime los destination ip address con los puertos
+    counter = counter+1
+    #print ("{}:{}".format(k,v))
+print (counter)
+#print( "Done checking:")

Programas/PS_orig.py

@@ -0,0 +1,55 @@
+#Port Scan without reduction
+
+import ipaddress
+import json
+
+
+#Version 1
+#Read all the flows and append to a hash their destination ip and destination port
+#Check which flows share the same destination ip though differente dports.
+
+x = 20
+y = 60000
+deletevar = []
+newHash={}
+
+PATH = '/Users/Sara/Documents/Univ Classes/Investigacion/Programas/netflows.txt'
+
+myFile = open(PATH, 'r')
+ip = myFile.read()
+flow = json.loads(ip)
+
+for i in flow["flows"]: #itera por cada elemento del diccionario de flows
+    #if (i['dport'] >= 1 and i['dport'] < x) or i['dport'] > y: #verifica que sean puertos (se me fue la palabra...)
+        #continue
+    #else: #agrega a un hash cada puerto con su destination ip
+    if i['sip'] == 2291263257:
+        if i['dip'] in newHash:
+            newHash[i['dip']].append(i['dport'])
+        else:
+            newHash[i['dip']] = [i['dport']]
+
+#LO SIGUIENTE ESTA COMENTADO Y LO EXPLICO EN EL WORD
+
+# for k, v in newHash.items(): #itera por cada ip address y sus puertos
+#     if len(v) >= 100:
+#         #print ("something suspicious...")
+#         continue
+#     else: #Si no tiene una cantidad considerable de puertos, agrega el ip a una lista
+#         if k in deletevar:
+#             continue
+#         else:
+#             deletevar.append(k)
+
+
+#for i in deletevar: #borra todos los elementos que estan en la lista deletevar
+                    #del hash con todos los ip y sus puertos
+#    newHash.pop(i)
+
+counter = 0 #Para contar total de elementos en el hash
+for k, v in newHash.items(): #imprime los destination ip address con sus puertos
+    counter = counter+1
+    k = str(ipaddress.IPv4Address(k))
+    print ("{}:{}".format(k,v))
+print (counter)
+print( "Done checking:")

Programas/PS_reduc.py

@@ -0,0 +1,102 @@
+#Reduction Port Scanner
+
+import ipaddress
+import json
+
+
+#Para usar Silk
+#SilkFile object (represents a channel for writing to or reading from Silk flow file)
+#FGlob object (allows retireval of filenames in a silk data store.)
+
+
+minPort = 20
+maxPort= 60000
+flowHash={}
+otherHash= {}
+myNum = 0
+counter = 0
+
+PATH = '/Users/Sara/Documents/Univ Classes/Investigacion/Programas/netflows.txt'
+
+myFile = open(PATH, 'r')
+ip = myFile.read()
+flow = json.loads(ip)
+
+#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 = (str(ipaddress.IPv4Address(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={}
+    for i in flow["flows"]: #itera por cada elemento del diccionario de flows
+        posA = ipConversion(i["dip"], num) #devuelve la primera clase del ip en notacion string
+        if num != 0 and ipConversion(i["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 (i['dport'] >= 1 and i['dport'] < minPort) or i['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 posA in sampleHash:
+                sampleHash[posA] += 1
+                #print (posA)
+            else:
+                sampleHash[posA] = 1
+                #print (posA)
+
+    return sampleHash
+
+def UltimoAnalisis(flowHash, num):
+    sampleHash = {}
+    for i in flow["flows"]: #itera por cada elemento del diccionario de flows
+        posA = ipConversion(i["dip"], num) #devuelve la primera clase del ip en notacion string
+        if ipConversion(i["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 (i['dport'] >= 1 and i['dport'] < minPort) or i['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
+            if posA in sampleHash:
+                sampleHash[posA].append(i['dport'])
+            else:
+                sampleHash[posA] = [i['dport']]
+    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)
+
+
+#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():
+    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
+        print (flowHash)
+
+
+
+for dips, dports in otherHash.items():
+    counter +=1 #para contar los elementos del hash
+
+print (counter)

Programas/practiceHash.py

@@ -0,0 +1,14 @@
+import socket
+import json
+import random
+
+
+s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+for i in range (5):
+    val = random.randint(1, 5)
+    dataScript = {'sara':val, 'ale':4}
+    message = json.dumps(dataScript)
+    s.sendto(message, ('localhost', 2702))
+    print "Sending %s message" % i
+
+print "Sent messages"

Programas/practiceSet.py

@@ -0,0 +1,88 @@
+import ipaddress
+import netflows
+
+
+#Port Scanner, using a reduction method, and deleting the addresses as
+#the program sees they are of no use.
+
+flow = netflows.flowprinters() #Agrega el diccionario de flows a una variable
+
+
+
+
+#Son los limites de los Puertos que queremos verificar
+x = 20
+y = 60000
+
+#Variables inicializadas
+hashbrown = {}
+myNum = 0
+
+#Esta funcion convierte la direccion de ip de un entero a un string usando la libreria de ipaddress.
+#Recibe dos parametros, la direccion de ip en entero y un numero k. Esta funcion devuelve un arreglo compuesto de cada
+#numero decimal entre los puntos del string. Dependiendo del numero k sera hasta que posision del arreglo se devolvera.
+def ipConversion(number, k):
+
+    mystr = ''
+    ipadd = (str(ipaddress.IPv4Address(number))).split(".") #Devuelve un arreglo
+    for i in range(k+1):
+        mystr = mystr + ipadd[i] + '.'
+    return mystr
+
+
+#This function returns a hash with the ip address as the key and a list of the ports asociated with
+#that ipaddress
+def PrimerAnalisis(number):
+    ps = {}
+    for i in flow["flows"]: #for each element of the value of 'flows'
+        posA = ipConversion(i["dip"], number) #change the ip address to string
+
+        if (i['dport'] >= 1 and i['dport'] < x) or i['dport'] > y: #verifica que sean puertos (se me fue la palabra...)
+            continue
+        else: #agrega a un hash cada puerto con su destination ip
+            if posA in ps:
+                ps[posA].append(i['dport'])
+
+            else:
+                ps[posA] = [i['dport']]
+
+    return ps
+
+deletevar = []
+while myNum < 4: #recorrera 4 veces la lista de flows empezando con el primer numero decimal de los ip hasta el 4to
+    hashBrown= PrimerAnalisis(myNum) #crea un hash
+
+    for k, v in hashBrown.items(): #itera por cada ip address y sus puertos
+        if len(v) >= 100:
+            #print ("something suspicious...")
+            continue
+        else: #Si no tiene una cantidad considerable de puertos, la borra de la lista sigue verificando
+            #print  ("nothing Suspicious but: (%s:%s)" %(k, v) )
+
+            for il in flow['flows']: #vuelve a iterar por la lista de flows para borrar de la lista la que
+                                    # no tiene suficiente puertos
+                newi = ipConversion(il["dip"], myNum)
+                if k == newi:
+                    #index = flow['flows'].index(newi)
+                    flow['flows'].remove(il)
+                    if myNum == 3 : #Si se llega a la ultima verificacion se agregan a una lista para luego borrarlas del hash
+                        if k in deletevar:
+                            continue
+                        else:
+                            deletevar.append(k)
+                else:
+                    continue
+
+    myNum = myNum + 1
+
+
+or i in deletevar: #borra todos los elementos que estan en la lista deletevar
+                    #del hash con todos los ip y sus puertos
+    hashBrown.pop(i)
+
+counter = 0 #Para contar total de elementos en el hash
+for k, v in hashBrown.items(): #imprime los destination ip address con los puertos
+    counter = counter+1
+    print ("{}:{}".format(k,v))
+print (counter)
+print( "Done checking:")

Programas/pythonpractice.py

@@ -0,0 +1,14 @@
+import ipaddress
+import json
+
+
+#hashbleh = [{'name':'sara', 'number':46}, {'name':'ale', 'number':6}, {'name':'ian', 'number':10},
+#{'name':'ale', 'number':32}, {'name':'sara', 'number':22}, {'name': 'marisa', 'number':90},
+#{'name':'ian', 'number':30}, {'name':'Kevin', 'number':34}]
+#lista de hashes
+
+path = '/Users/Sara/Documents/Univ Classes/Investigacion/newFlow.txt'
+myFile = open(path, 'r')
+flow = myFile.read()
+ip = json.loads(flow)
+print(type(ip))

Programas/simulate.py

@@ -0,0 +1,45 @@
+#Plan:
+
+#Create a program where it will receive a string of data
+#That string will be added to a dictionary, with the ip attributes as its keys
+#simulate a filter. Like give it a shell script input with one of the attributes
+#And have it present the thingies...
+#check in Julios visualization what is presented when filtered
+
+import socket
+
+import argparse
+import sys
+import select
+import json
+
+parser = argparse.ArgumentParser()
+parser.add_argument('filter', type = str)
+args = parser.parse_args()
+
+soc = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+#soc.setblocking(0)
+soc.bind(('localhost', 2702))
+temp = 1
+num = 0
+filterArray = []
+soc.settimeout(5)
+while temp:
+    print ("waiting to receive message")
+    num = num + 1
+    #ready = select.select([soc], [], [], timeout_in_seconds)
+    try:
+        data, address = soc.recvfrom(2702)
+        print "\nreceived %s message" %num
+        newData = json.loads(data)
+    except socket.error:
+        print "\nNo message to receive, leave loop"
+        temp = 0
+
+
+    for k, v in newData.items():
+        if k == args.filter:
+            print k
+            filterArray.append(v)
+
+print filterArray

Programas/trw.py

@@ -0,0 +1,46 @@
+import ipaddress
+import json
+
+
+#Para usar Silk
+#SilkFile object (represents a channel for writing to or reading from Silk flow file)
+#FGlob object (allows retireval of filenames in a silk data store.)
+
+
+minPort = 20
+maxPort= 60000
+flowHash={}
+otherHash= {}
+myNum = 0
+counter = 0
+
+PATH = '/Users/Sara/Documents/Univ Classes/Investigacion/netflows.txt'
+
+myFile = open(PATH, 'r')
+ip = myFile.read()
+flow = json.loads(ip)
+
+#Funcion que convierte y devuelve el int ipaddress en notacion punto-decimal
+def ipConversion(number):
+    ipadd = str(ipaddress.IPv4Address(number))
+    return ipadd
+
+
+def Analisis(flowHash):
+    sampleHash={} #hash para contener los dip con el numero de conecciones y failed coneccciones
+    connection = [0] * 2 #Lista para contener los valores de conecciones failed y conecciones buenas
+    for i in flow["flows"]: #itera por cada elemento del diccionario de flows
+        posA = ipConversion(i["sip"]) #Devuelve el ip en notacion punto-decimal
+        if i["connection"] == "synack": #No se cual es el formato de esto
+            connection[1]=1 #good conections
+        else:
+            connection [0] =1 #failed conections
+        if posA in sampleHash:
+            sampleHash[posA][0]+=connection[0]
+            sampleHash[posA][1]+= connection[1]
+            #print (posA)
+        else:
+            sampleHash[posA] = [connection[0], connection[1]]
+            #print (posA)
+
+    return sampleHash

Programas/trw_real.py

@@ -0,0 +1,72 @@
+import ipaddress
+import json
+
+
+#Para usar Silk
+#SilkFile object (represents a channel for writing to or reading from Silk flow file)
+#FGlob object (allows retireval of filenames in a silk data store.)
+
+
+#threshold of the ratio
+p = 5
+flowHash={}
+otherHash= {}
+myNum = 0
+counter = 0
+
+PATH = '/Users/Sara/Documents/Univ Classes/Investigacion/Programas/netflows.txt'
+
+myFile = open(PATH, 'r')
+ip = myFile.read()
+flow = json.loads(ip)
+
+#Funcion que convierte y devuelve el int ipaddress en notacion punto-decimal
+def ipConversion(number, position):
+    mystr = ''
+    ipadd = (str(ipaddress.IPv4Address(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 AnalisisReduciendo(flowHash, 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
+        dip = ipConversion(i["sip"], num) #Devuelve el ip en notacion punto-decimal
+        flags = i["tcpflags"].split(",")  #array of all tcp flags that are set
+        if num != 0 and ipConversion(i["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:
+            if 'A' in flags: #if the acknowledge flag is set
+            connection[1]=1 #good conections
+            else:
+                connection [0] =1 #failed conections
+            if sip in ratioHash: #si sip esta en ratioHash => que posA esta en sampleHash
+                                #por lo tanto ya se puede sumar las conecciones al ratio del dip
+                ratioHash[sip][0]+=connection[0]
+                ratioHash[sip][1] += connection[1]]
+            else: #si sip no esta en ratioHash tampoco
+                ratioHash= {sip: [connection[0], connection[1]]}
+
+
+    return ratioHash
+
+while myNum <4: #Se itera las cuatro veces de acuerdo con la notacion de ipv4
+    flowHash= AnalisisReduciendo(otherHash, myNum)
+    otherHash = {} #Se borra el hash para agregar elementos nuevos con la nueva etapa de la busqueda
+    for sip, dipHash in flowHash.items(): #se itera por todos los dip y sus counters o puertos
+        if (dipHash['dip'][0] / dipHash['dip'][1])  < 0: #si la cantidad de succesful
+                                                        #connections es mas que failed connections
+            #not scanner, ignore
+        else if (dipHash['dip'][0] / dipHash['dip'][1])  < p:
+            #not scanner, ignore
+        else:
+            #scanner, oh oh
+
+
+    myNum += 1
+    #print (flowHash)

Programas/trw_reducps.py

@@ -0,0 +1,78 @@
+import ipaddress
+import json
+
+
+#Para usar Silk
+#SilkFile object (represents a channel for writing to or reading from Silk flow file)
+#FGlob object (allows retireval of filenames in a silk data store.)
+
+
+#threshold of the ratio
+p = 5
+flowHash={}
+otherHash= {}
+myNum = 0
+counter = 0
+
+PATH = '/Users/Sara/Documents/Univ Classes/Investigacion/Programas/netflows.txt'
+
+myFile = open(PATH, 'r')
+ip = myFile.read()
+flow = json.loads(ip)
+
+#Funcion que convierte y devuelve el int ipaddress en notacion punto-decimal
+def ipConversion(number, position):
+    mystr = ''
+    ipadd = (str(ipaddress.IPv4Address(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 AnalisisReduciendo(flowHash, num):
+    connection = [0] * 2 #Lista para contener los valores de conecciones fallidas y conecciones buenas
+    ratioHash = {}
+    for i in flow["flows"]: #itera por cada elemento del diccionario de flows
+        sip = ipConversion(i["sip"], 3)
+        dip = ipConversion(i["dip"], num) #Devuelve el ip en notacion punto-decimal
+        flags = i["tcpflags"].split(",")  #array of all tcp flags that are set
+        if num != 0 and ipConversion(i["dip"], num-1) not in flowHash: #Si en el paso anterior se vio que no
+                                                                     #tiene el length de puertos requerido, se ignora
+            continue
+        else:
+            if 'A' in flags: #if the acknowledge flag is set
+            connection[1]=1 #good conections
+            else:
+                connection [0] =1 #failed conections
+            if sip in ratioHash: #si sip esta en ratioHash => que posA esta en sampleHash
+                                #por lo tanto ya se puede sumar las conecciones al ratio del dip
+                if dip in ratioHash[sip]:
+                    ratioHash[sip][dip][0]+=connection[0]
+                    ratioHash[sip][dip][1] += connection[1]]
+                else:
+                    ratioHash[sip][dip] = [connection[0], connection[1]]
+            else: #si sip no esta en ratioHash tampoco posA en sampleHash por lo
+                    #tanto se inicializa posA en sampleHash y luego sip en ratioHash con su valor de sampleHash
+                ratioHash[sip] = {dip: [connection[0], connection[1]]}
+
+
+    return ratioHash
+
+while myNum <4: #Se itera las cuatro veces de acuerdo con la notacion de ipv4
+    flowHash= AnalisisReduciendo(otherHash, myNum)
+    otherHash = {} #Se borra el hash para agregar elementos nuevos con la nueva etapa de la busqueda
+    for sip, dipHash in flowHash.items(): #se itera por todos los dip y sus counters o puertos
+        if (dipHash['dip'][0] / dipHash['dip'][1])  < 0: #si la cantidad de succesful
+                                                        #connections es mas que failed connections
+            #not scanner, ignore
+        else if (dipHash['dip'][0] / dipHash['dip'][1])  < p:
+            #not scanner, ignore
+        else:
+            #scanner, oh oh
+
+
+    myNum += 1
+    #print (flowHash)