Skip to content
KitploitKITPLOIT
OutilsBlog
Soumettre
OutilsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

··Flux·Contact·Confidentialité·© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
Forerunner — Bibliothèque de scan réseau rapide et extensible, avec multithreading, sondage ping et récupérateurs de scan. | Kitploit
Outils/GitHubGitHub/jasondrawdy/forerunner
ReconnaissanceCartographie RéseauScan de PortsCollecte d'InformationsUtilitaires et Frameworks
GitHubjasondrawdy/forerunner

Forerunner

Bibliothèque de scan réseau rapide et extensible, avec multithreading, sondage ping et récupérateurs de scan.

Voir le dépôt
3914il y a 6 ansVérifié par Kitploit

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager

Forerunner

La bibliothèque Forerunner est une bibliothèque réseau rapide, légère et extensible créée pour faciliter le développement d'applications robustes centrées sur le réseau telles que : scanners IP, port knockers, clients, serveurs, etc. Dans son état actuel, la bibliothèque Forerunner est capable de scanner et de effectuer du port knocking de manière synchrone et asynchrone sur des adresses IP afin d'obtenir des informations sur le périphérique situé à ce point de terminaison, comme : si l'IP est en ligne, l'adresse MAC physique, etc. La bibliothèque est entièrement orientée objet et basée sur les événements, ce qui signifie que les données de scan sont contenues dans des objets "scan" spécialement conçus pour gérer toutes les données, des résultats aux exceptions.

Prérequis

  • .NET Framework 4.6.1

Fonctionnalités

MéthodeDescriptionUtilisation
ScanScanner une seule IP pour obtenir des informationsScan("192.168.1.1");
ScanRangeScanner une plage d'IP pour obtenir des informationsScanRange("192.168.1.1", "192.168.1.255")
ScanListScanner une liste d'IP pour obtenir des informationsScanList("192.168.1.1, 192.168.1.2, 192.168.1.3")
PortKnockPinger chaque port d'une seule IPPortKnock("192.168.1.1");
PortKnockRangePinger chaque port d'une plage d'IPPortKnockRange("192.168.1.1", "192.168.1.255");
PortKnockListPinger chaque port en utilisant une liste d'IPPortKnockList("192.198.1.1, 192.168.1.2, 192.168.1.3");
IsHostAlivePinger un hôte N fois pendant X millisecondesIsHostAlive("192.168.1.1", 5, 1000);
GetAveragePingResponseObtenir la réponse ping moyenne pour un hôteGetAveragePingResponse("192.168.1.1", 5, 1000);
IsPortOpenPinger des ports individuels via TCP et UDPIsPortOpen("192.168.1.1", 45000, new TimeSpan(1000), false);

Exemples

Scan IP

Scanner un réseau est une tâche courante à l'ère numérique et j'ai donc pris la liberté de rendre cela aussi simple que possible pour tout futur programmeur qui souhaiterait faire une telle chose de manière facile. La bibliothèque Forerunner est entièrement orientée objet, ce qui la rend idéale pour les situations de type plug and play ; l'objet pour le scan IP s'appelle IPScanObject et il contient en fait plusieurs propriétés :

  • Address (String)
  • IP (IPAddress)
  • Ping (Long)
  • Hostname (String)
  • MAC (String)
  • isOnline (Bool)
  • Errors (Exception)

Avec cet objet en tête, essayons de créer un nouvel objet et d'effectuer un scan en l'utilisant. Il existe plusieurs façons de procéder, mais la manière la plus simple pour commencer est d'abord de créer un nouvel objet Scanner afin d'accéder à nos méthodes de scan. Ensuite, créez un IPScanObject puis affectez-le à la méthode Scan avec l'IP que vous souhaitez énumérer ; par exemple :

Synchrone
root@kitploit:~
using System;
using Forerunner; // Remember to import our library.

namespace Example
{
    class Program
    {
        static void Main(string[] args)
        {
            // Our IP we would like to scan.
            string ip = "192.168.1.1";

            // Create a new scanner object.
            Scanner s = new Scanner();

            // Create a new scan object and perform a scan.
            IPScanObject result = s.Scan(ip);

            // Output that we have finished the scan.
            if (result.Errors != null)
                Console.WriteLine("[x] An error occurred during the scan.");
            else
                Console.WriteLine("[+] " + ip + " has been successfully scanned!")

            // Allow the user to exit at any time.
            Console.Read();
        }
    }
}

Une autre manière, qui est ma méthode de prédilection, est de créer un objet Scanner et de s'abonner aux gestionnaires d'événements comme ScanAsyncProgressChanged ou ScanAsyncComplete, afin d'avoir un contrôle total sur mes méthodes asynchrones ; je peux contrôler comment leurs états de progression affectent mon application, etc. ; par exemple :

Asynchrone
root@kitploit:~
using System;
using System.Threading.Tasks;
using Forerunner; // Remember to import our library.

namespace Example
{
    class Program
    {
        static void Main(string[] args)
        {
            // Our IP we would like to scan.
            string ip = "192.168.1.1";

            // Setup our scanner object.
            Scanner s = new Scanner();
            s.ScanAsyncProgressChanged += new ScanAsyncProgressChangedHandler(ScanAsyncProgressChanged);
            s.ScanAsyncComplete += new ScanAsyncCompleteHandler(ScanAsyncComplete);

            // Start a new scan task with our ip.
            TaskFactory task = new TaskFactory();
            task.StartNew(() => s.ScanAsync(ip));

            // Allow the user to exit at any time.
            Console.Read();
        }

        static void ScanAsyncProgressChanged(object sender, ScanAsyncProgressChangedEventArgs e)
        {
            // Do something here with e.Progress, or you could leave this event
            // unsubscribed so you wouldn't have to do anything.
        }

        static void ScanAsyncComplete(object sender, ScanAsyncCompleteEventArgs e)
        {
           // Do something with the IPScanObject aka e.Result.
            if (e.Result.Errors != null)
                Console.WriteLine("[x] An error occurred during the scan.");
            else
                Console.WriteLine("[+] " + e.Result.IP + " has been successfully scanned!")
        }
    }
}

Port Knocking

Je sais ce que vous pensez. Port knocking ? Oui, et non. Le terme ne signifie pas port knocking dans le sens traditionnel de se connecter via un ensemble prédéfini de ports, mais plutôt de simplement vérifier si des ports sont réellement ouverts. C'est littéralement "frapper" à un port dans tous les sens du terme en essayant de se connecter à chaque port et en envoyant des données. Tout comme pour le scan IP, le port knocking utilise un objet personnalisé appelé "Port Knock Scan Object" ou PKScanObject en abrégé. Le PKScanObject contient en fait une liste de PKServiceObject qui contiennent à leur tour nos données de port ; l'objet de service possède les propriétés suivantes :

  • IP (String)
  • Port (Int)
  • Protocol (PortType)
  • Status (Bool)

Le port knocking se déroule de manière similaire au scan IP. D'abord, créez un objet Scanner. Ensuite, créez un nouveau PKScanObject et affectez-le à la méthode PortKnock avec l'IP de votre choix, puis affichez vos résultats ; par exemple :

Synchrone
root@kitploit:~
using System;
using Forerunner; // Remember to import our library.

namespace Example
{
    class Program
    {
        static void Main(string[] args)
        {
            // Our IP we would like to scan.
            string ip = "192.168.1.1";

            // Create a new scanner object.
            Scanner s = new Scanner();

            // Create a new scan object and perform a scan.
            PKScanObject result = s.PortKnock(ip);

            // Output that we have finished the scan.
            if (result.Errors != null)
                Console.WriteLine("[x] An error occurred during the scan.");
            else
                Console.WriteLine("[+] " + ip + " has been successfully scanned!")

           // Display our results.
           foreach (PKServiceObject port in result.Services)
           {
                Console.WriteLine("[+] IP: " + port.IP + " | " +
                                  "Port: " + port.Port.ToString() + " | " +
                                  "Protocol: " + port.Protocol.ToString() + " | " +
                                  "Status: " + port.Status.ToString());
           }

           // Allow the user to exit at any time.
           Console.Read();
        }
    }
}

Enfin, je vais vous montrer un exemple simple de port knocking asynchrone. C'est essentiellement la même chose que le port knocking synchrone, à l'exception du fait que vous pouvez utiliser les événements à votre avantage. Vous pouvez obtenir des mises à jour de progression sans avoir à vous soucier du crash des interfaces utilisateur ou du verrouillage des systèmes ; par exemple :

Asynchrone
root@kitploit:~
using System;
using System.Threading.Tasks;
using Forerunner; // Remember to import our library.

namespace Example
{
    class Program
    {
        static void Main(string[] args)
        {
            // Our IP we would like to scan.
            string ip = "192.168.1.1";

            // Setup our scanner object.
            Scanner s = new Scanner();
            s.PortKnockAsyncProgressChanged += new PortKnockAsyncProgressChangedHandler(PortKnockAsyncProgressChanged);
            s.PortKnockAsyncComplete += new PortKnockAsyncCompleteHandler(PortKnockAsyncComplete);

            // Start a new scan task with our ip.
            TaskFactory task = new TaskFactory();
            task.StartNew(() => s.PortKnockAsync(ip));

            // Allow the user to exit at any time.
            Console.Read();
        }

        static void PortKnockAsyncProgressChanged(object sender, PortKnockAsyncProgressChangedEventArgs e)
        {
            // Display our progress so we know the ETA.
            if (e.Progress == 99)
            {
                Console.Write(e.Progress.ToString() + "%...");
                Console.WriteLine("100%!");
            }
            else
                Console.Write(e.Progress.ToString() + "%...");
        }

        static void PortKnockAsyncComplete(object sender, PortKnockAsyncCompleteEventArgs e)
        {
            // Tell the user that the port knock was complete.
            Console.WriteLine("[+] Port Knock Complete!");

            // Check if we resolved an error.
            if (e.Result == null)
                Console.WriteLine("[X] The port knock did not return any data!");
            else
            {
                // Check if we have any ports recorded.
                if (e.Result.Services.Count == 0)
                    Console.WriteLine("[!] No ports were open during the knock.");
                else
                {
                    // Display our ports and their details.
                    foreach (PKServiceObject port in e.Result.Services)
                    {
                        Console.WriteLine("[+] IP: " + port.IP + " | " +
                                          "Port: " + port.Port.ToString() + " | " +
                                          "Protocol: " + port.Protocol.ToString() + " | " +
                                          "Status: " + port.Status.ToString());
                    }
                }
            }
        }
    }
}

Crédits

Icône : monkik
https://www.flaticon.com/authors/monkik

Licence

Copyright © ∞ Jason Drawdy

Tous droits réservés.

The MIT License (MIT)

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Sauf indication contraire dans le présent avis, le nom du titulaire du droit d'auteur ci-dessus ne pourra être utilisé à des fins publicitaires ou pour promouvoir la vente, l'utilisation ou autre exploitation de ce logiciel sans autorisation écrite préalable.

Télécharger l’outil