Forerunner

La biblioteca Forerunner es una biblioteca de red rápida, ligera y extensible creada para ayudar en el desarrollo de aplicaciones robustas centradas en la red, tales como: Escáneres de IP, Golpeadores de Puertos, Clientes, Servidores, etc. En su estado actual, la biblioteca Forerunner es capaz de escanear y golpear puertos de direcciones IP tanto de forma síncrona como asíncrona para obtener información sobre el dispositivo ubicado en ese punto final, como: si la IP está en línea, la dirección MAC física, etc. La biblioteca es completamente orientada a objetos y basada en eventos, lo que significa que los datos de escaneo están contenidos dentro de objetos de "escaneo" especialmente diseñados que están construidos para manejar todos los datos, desde resultados hasta excepciones.

Requisitos

• .NET Framework 4.6.1

Características

Método	Descripción	Uso
Scan	Escanea una sola IP en busca de información	Scan("192.168.1.1");
ScanRange	Escanea un rango de IPs en busca de información	ScanRange("192.168.1.1", "192.168.1.255")
ScanList	Escanea una lista de IPs en busca de información	ScanList("192.168.1.1, 192.168.1.2, 192.168.1.3")
PortKnock	Hace ping a cada puerto de una sola IP	PortKnock("192.168.1.1");
PortKnockRange	Hace ping a cada puerto en un rango de IPs	PortKnockRange("192.168.1.1", "192.168.1.255");
PortKnockList	Hace ping a cada puerto usando una lista de IPs	PortKnockList("192.198.1.1, 192.168.1.2, 192.168.1.3");
IsHostAlive	Hace ping a un host N veces durante X milisegundos	IsHostAlive("192.168.1.1", 5, 1000);
GetAveragePingResponse	Obtiene la respuesta de ping promedio para un host	GetAveragePingResponse("192.168.1.1", 5, 1000);
IsPortOpen	Hace ping a puertos individuales a través de TCP y UDP	IsPortOpen("192.168.1.1", 45000, new TimeSpan(1000), false);

Ejemplos

Escaneo de IP

Escanear una red es una tarea común en esta era digital, por lo que me he tomado la libertad de hacerlo lo más simple posible para cualquier programador futuro que desee hacer algo así de manera sencilla. La biblioteca Forerunner es completamente orientada a objetos, lo que la hace ideal para situaciones de plug and play; el objeto para el escaneo de IP se llama IPScanObject y en realidad contiene bastantes propiedades:

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

Teniendo el objeto en mente, intentemos crear un nuevo objeto y realizar un escaneo utilizándolo. Hay varias formas de hacerlo, sin embargo, la forma más simple de empezar es primero crear un nuevo objeto Scanner para poder acceder a nuestros métodos de escaneo. A continuación, crea un IPScanObject y luego asígnelo al método Scan con la IP que desees enumerar; por ejemplo:

Síncrono

using System;
using Forerunner; // Recuerda importar nuestra biblioteca.

namespace Example
{
    class Program
    {
        static void Main(string[] args)
        {
            // Nuestra IP que queremos escanear.
            string ip = "192.168.1.1";

            // Crear un nuevo objeto scanner.
            Scanner s = new Scanner();

            // Crear un nuevo objeto de escaneo y realizar un escaneo.
            IPScanObject result = s.Scan(ip);

            // Mostrar que hemos terminado el escaneo.
            if (result.Errors != null)
                Console.WriteLine("[x] Ocurrió un error durante el escaneo.");
            else
                Console.WriteLine("[+] " + ip + " ha sido escaneado exitosamente!")

            // Permitir al usuario salir en cualquier momento.
            Console.Read();
        }
    }
}

Otra forma, que es mi método preferido de operación, es crear un objeto Scanner y suscribirse a los Manejadores de Eventos de cosas como ScanAsyncProgressChanged o ScanAsyncComplete, de esa manera tengo control total sobre mis métodos asíncronos; puedo controlar cómo sus estados de progreso afectan mi aplicación y así sucesivamente; por ejemplo:

Asíncrono

using System;
using System.Threading.Tasks;
using Forerunner; // Recuerda importar nuestra biblioteca.

namespace Example
{
    class Program
    {
        static void Main(string[] args)
        {
            // Nuestra IP que queremos escanear.
            string ip = "192.168.1.1";

            // Configurar nuestro objeto scanner.
            Scanner s = new Scanner();
            s.ScanAsyncProgressChanged += new ScanAsyncProgressChangedHandler(ScanAsyncProgressChanged);
            s.ScanAsyncComplete += new ScanAsyncCompleteHandler(ScanAsyncComplete);

            // Iniciar una nueva tarea de escaneo con nuestra ip.
            TaskFactory task = new TaskFactory();
            task.StartNew(() => s.ScanAsync(ip));

            // Permitir al usuario salir en cualquier momento.
            Console.Read();
        }

        static void ScanAsyncProgressChanged(object sender, ScanAsyncProgressChangedEventArgs e)
        {
            // Hacer algo aquí con e.Progress, o podrías dejar este evento
            // sin suscribir para no tener que hacer nada.
        }

        static void ScanAsyncComplete(object sender, ScanAsyncCompleteEventArgs e)
        {
           // Hacer algo con el IPScanObject, es decir, e.Result.
            if (e.Result.Errors != null)
                Console.WriteLine("[x] Ocurrió un error durante el escaneo.");
            else
                Console.WriteLine("[+] " + e.Result.IP + " ha sido escaneado exitosamente!")
        }
    }
}

Golpeo de Puertos

Ya sé lo que estás pensando. ¿Golpeo de puertos? Sí y no. El término no significa golpeo de puertos en el sentido tradicional de conectarse a través de un conjunto predefinido de puertos, sino más bien solo verificar si algún puerto está realmente abierto. Literalmente es "golpear" un puerto en todos los sentidos de la palabra al intentar conectarse a cada puerto y enviar datos. Al igual que con el escaneo de IP, el golpeo de puertos utiliza un objeto personalizado llamado "Port Knock Scan Object" o PKScanObject para abreviar. El PKScanObject en realidad contiene una lista de PKServiceObjects que a su vez contienen los datos de nuestros puertos; el objeto de servicio contiene las siguientes propiedades:

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

El golpeo de puertos es similar al escaneo de IP. Primero, crea un objeto Scanner. A continuación, crea un nuevo PKScanObject y asígnelo al método PortKnock con la IP de tu elección, luego muestra tus resultados; por ejemplo:

Síncrono

using System;
using Forerunner; // Recuerda importar nuestra biblioteca.

namespace Example
{
    class Program
    {
        static void Main(string[] args)
        {
            // Nuestra IP que queremos escanear.
            string ip = "192.168.1.1";

            // Crear un nuevo objeto scanner.
            Scanner s = new Scanner();