Port balayages multiples en utilisant l'outil externe, et les fils subprocess.Popen

Question

J'utilise un scanner de port pour analyser mon sous-réseau. Le scanner de port ne peut malheureusement scanner un port d'un seul hôte à la fois. De plus, le scanner est équipé d'une temporisation de 1 seconde d'hôtes inaccessibles. Le scanner (étant un programme à l'extérieur) doit être exécuté à partir subprocess.Popen () et pour l'accélérer - pour que je puisse envoyer plusieurs sondes alors que certains précédents attendent les discussions replies- d'utilisation I. Le problème se pose pour un scan / 24 complet sous-réseau avec un grand nombre de threads. Somé des ports ouverts en fait sont affichés sous forme fermée. Je soupçonne une certaine façon, la sortie est brouillée. Notez que cela ne se produit pas si je scanne moins d'hôtes ou un hôte à un moment

Le code suivant est ma tentative de créer un pool de threads qui prennent une adresse IP et exécuter scan de port « séquentiel » pour le port défini. Une fois que tous les ports spécifiés sont numérisés, il récupère à côté IP de la liste.

        while True:
            if not thread_queue.empty():
                try:
                    hst = ip_iter.next()
                except StopIteration:
                    break
                m=thread_queue.get()
                l=ThreadWork(self,hst,m)
                l.start()
        while open_threads != 0:
            pass      

Lorsque la présente ensembles de fragments jusqu'à fil file d'attente

        thread_list = [x for x in range(num_threads)]
        for t in thread_list:
            thread_queue.put(str(t))
        ip_iter=iter(self.final_target)

Dans la fonction ThreadWork je garde un onglet de fils ouverts (depuis thread_queue.empty se sont avérés être peu fiables, je devais utiliser cette façon brute)

class ThreadWork(threading.Thread):
    def __init__(self,i,hst,thread_no):
        global open_threads
        threading.Thread.__init__(self)
        self.host = hst
        self.ptr = i
        self.t = thread_no
        lock.acquire()
        open_threads = open_threads + 1
        lock.release() 

    def run(self):
        global thread_queue
        global open_threads
        global lock
        user_log.info("Executing sinfp for IP Address : %s"%self.host)
        self.ptr.result.append(SinFpRes(self.host,self.ptr.init_ports,self.ptr.all_ports,self.ptr.options,self.ptr.cf))
        lock.acquire()
        open_threads = open_threads - 1
        lock.release()
        thread_queue.put(self.t)

L'appel à SinFpRes crée un objet résultat pour un IP et lancer une analyse séquentielle des ports pour que seul IP. L'analyse réelle par port est tel que représenté

        com_string = '/usr/local/sinfp/bin/sinfp.pl '+self.options+' -ai '+str(self.ip)+' -p '+str(p)
        args = shlex.split(com_string) 
        self.result=subprocess.Popen(args,stdout=subprocess.PIPE).communicate()[0]
        self.parse(p)

La fonction parse utilise ensuite résultat stocké dans self.result à la sortie du magasin pour ce port. Un total de tous les ports est ce qui constitue l'un résultat d'analyse pour une adresse IP.

L'appel de cette code à l'aide de 10 threads donne précis o / p (par rapport à la sortie nmap). En donnant 15 fils de discussion un port ouvert occasionnelle est manquée. En donnant 20 fils de discussion, les ports plus ouverts sont manqués. En donnant 50 fils de discussion de nombreux ports sont manqués.

P.S. - En tant que premier temporisateur, ce code est très alambiqué. Toutes mes excuses aux puritains.

P.P.S. - Même un scan de port fileté prend 15 minutes pour un sous-réseau toute la classe C avec à peine 20 ports scannés. Je me demandais si je devais déplacer ce code à une autre langue et utiliser Python pour analyser uniquement les résultats. Quelqu'un pourrait-il me suggérer une langue? Remarque -J'ai explore l'option Shell comme indiqué par S. Lott, mais le traitement manuel est nécessaire avant de le déverser dans le fichier.

Answer 1

Utiliser la coquille

 for h in host1 host2 host3
 do
     scan $h >$h.scan &
 done
 cat *.scan >all.scan

scannera la liste complète des hôtes tout en même temps, chacun dans un processus séparé. Aucun fils.

Chaque scan produira un fichier .scan. Vous pouvez ensuite chat tous les fichiers de .scan dans un fichier all.scan massif pour un traitement ultérieur ou quoi que ce soit que vous faites.

Answer 2

Pourquoi ne pas essayer?

(Réponse: Non, ils auront leur propre pipe)

Answer 3

Utiliser Perl au lieu de Python. Le programme (SinFP) est écrit en Perl, vous pouvez modifier le code pour satisfaire vos besoins.