Concurrencia en Go: Escáner de Puertos Eficiente y Personalizable

Clase 15 de 19 • Curso de Go Avanzado: Concurrencia y Patrones de Diseño

Resumen

¿Cómo mejorar el rendimiento del escáner de puertos implementando Go rutinas?

Optimizar el rendimiento del escáner de puertos utilizando Go puede ser un desafío, especialmente cuando se busca escanear una cantidad considerable de puertos con rapidez. La clave radica en implementar Go rutinas adecuadamente para obtener mejor concurrencia. En este artículo, exploraremos cómo puedes usar Go rutinas, junto con WaitGroups, para maximizar la eficiencia de tu escáner de puertos.

¿Qué cambios se realizan en el código existente?

Para empezar, se necesita crear un WaitGroup que funcione junto con las Go rutinas. Esto permitirá dividir el escaneo en varias tareas pequeñas que se ejecutan de manera concurrente.

Definir un WaitGroup: Este se utilizará para manejar el ciclo de vida de las Go rutinas.
Anidar el código en una función anónima: Introducir una función anónima que reciba el puerto a escanear como parámetro.

var wg sync.WaitGroup
for i := 1; i <= 100; i++ {
    wg.Add(1)
    go func(port int) {
        defer wg.Done()
        // Código de escaneo del puerto
        ...
    }(i)
}
wg.Wait()

¿Cuáles son los errores comunes en la implementación de Go rutinas?

Un error común al implementar Go rutinas es no gestionar correctamente el WaitGroup dentro del bucle for, colocando el wg.Wait() dentro de este. Esto bloquea la ejecución de las rutinas concurrentes.

¿Cómo evitarlo?

Mueve wg.Wait() fuera del bucle for: Esto garantiza que todas las rutinas se ejecuten de manera concurrente sin bloqueos.

for i := 1; i <= 100; i++ {
    ...
}
wg.Wait() // Fuera del bucle

¿Cómo introducir parámetros en el programa usando flags?

Go proporciona un paquete flag que permite introducir parámetros dinámicos, ofreciendo así más flexibilidad al programa. Por ejemplo, puedes establecer el sitio web a escanear como un argumento del programa.

Implementación de `flag`:

Crear una nueva variable site para almacenar el flag.

site := flag.String("site", "defaultsite.com", "URL del sitio web a escanear")

Parsear los flags antes de utilizar la variable site.

flag.Parse()

Utilizar *site cada vez que se necesite el valor del flag.

¿Cómo ejecutar el programa con nuevos parámetros?

Puedes ejecutar tu programa pasando el parámetro de sitio web deseado de la siguiente manera:

go run netyport.go -site=scanme.webscantest.com

Con estas mejoras, se logra no solo un escaneo concurrente, sino también la capacidad de personalizar dinámicamente la URL que se quiere analizar. Este enfoque no solo ofrece rapidez y eficiencia al escáner de puertos, sino que también lo hace extensible y adaptable para escanear diferentes sitios web a través de un simple flag de configuración. Sigue experimentando con Go y sus poderosas herramientas de concurrencia.

Arturo Francesco Negreiros Samanez

student•

Le agregué expresiones regulares en la función checkEnviron par saber si por el ttl estamos en una máquina Linux o una caja windows xd

package main

import (
	"flag"
	"fmt"
	"net"
	"os/exec"
	"regexp"
	"strconv"
	"strings"
	"sync"
)

var (
	host = flag.String("host", "scanme.nmap.org", "host to be scanned")
)

func checkEnviron() (string, error) {

	out, err := exec.Command("ping", "-c", "1", *host).Output()
	if err != nil {
		return "", err
	}
	re := regexp.MustCompile(`ttl=(.?).[\S]`)
	ttl := fmt.Sprintf("%s", re.FindString(string(out)))
	ttl = strings.Split(ttl, "=")[1]
	ttlNum, err := strconv.Atoi(ttl)
	if err != nil {
		return "", err
	}
	if ttlNum <= 64 {
		return "\n\t[+] Linux system\n", nil
	} else if ttlNum >= 127 {
		return "\n\t[+] Windows system\n", nil
	} else {
		return "\n\t[-] the time to the life of the target system doesn't exists\n", nil
	}

}

func main() {

	flag.Parse()

	environ, _ := checkEnviron()
	fmt.Println(environ)

	var wg sync.WaitGroup
	//wg.Add(1000)
	for i := 0; i < 65535; i++ {
		wg.Add(1)
		go func(j int) {
			defer wg.Done()
			conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", *host, j))
			if err != nil {
				return
			}
			conn.Close()
			fmt.Printf("[+] port %d open!!\n", j)
		}(i)
	}
	wg.Wait()
}

Sergio Fernández Salazar

student•

Gracias, tengo mi entorno de desarollo de go montado en ubuntu wsl y al ejecutar los ejemplos de la clase, no me mostraba ningun puerto activo, pero implemete tu codigo y si me mostro los puertos que estaban activos.

Marlos Rodriguez

student•

Lo seguí probando con solo 100 ciclos, el cambio se nota mucho más.

José Antonio De La Paz Fonseca

student•

Para aquellos que aman go y toman el curso en la actualidad, por alguna razón (supongo que el otro sitio de pruebas usado en la flag está caído o descontinuado) les dejo éste sitio: testssl.sh

go run main.go -sitio testssl.sh

Recordandoles que es solo un guión y sin simbolos adicioanales

Eliaz Bobadilla

student•

Mi codigo:

package main

import (
	"flag"
	"fmt"
	"net"
	"sync"
)

func PortOpen(port int, site string, wg sync.WaitGroup) {
	conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", site, port))

	if err != nil {
		return
	}

	wg.Done()
	conn.Close()

	fmt.Printf("Port %d is open.\n", port)

}

const PORTS_TO_SCAN = 10000

var site = flag.String("site", "scanme.nmap.org", "URL to scan.")

func main() {
	flag.Parse()

	var wg sync.WaitGroup

	for i := 0; i < PORTS_TO_SCAN; i++ {
		wg.Add(1)
		go PortOpen(i, *site, wg)
	}

	wg.Wait()
}

Angelo Monasterios

student•

alguien mas tuvo el problema: "runnable, locked to thread" ?

Jorge Luis Velasquez Venegas

student•

El error ´runtime: program exceeds 10000-thread limit´ ocurre por que el código no esta implementando un limite para la creación de subrutinas, lo que agota los recursos del sistema. En este caso es apropiado implementar un limite de concurrencia implementando un canal como un semáforo. Dejo un ejemplo del código

func main() {
	var wg sync.WaitGroup
	concurrencyLimit := 1000 // Number of concurrent goroutines
	sem := make(chan struct{}, concurrencyLimit)

	for port := 1; port <= 65535; port++ {
		wg.Add(1)
		sem <- struct{}{} // Acquire a token
		go func(port int) {
			defer wg.Done()
			defer func() { <-sem }() // Release the token
			connection, err := net.Dial("tcp", net.JoinHostPort("scanme.nmap.org", fmt.Sprintf("%d", port)))

			if err != nil {
				// fmt.Printf("Port %d is closed\n", port)
				return
			}

			defer connection.Close()
			fmt.Printf("Port %d is open\n", port)
		}(port)
	}
	wg.Wait()
}
```func main() {    var wg sync.WaitGroup    concurrencyLimit := 1000 // Number of concurrent goroutines    sem := make(chan struct{}, concurrencyLimit)
    for port := 1; port <= 65535; port++ {        wg.Add(1)        sem <- struct{}{} // Acquire a token        go func(port int) {            defer wg.Done()            defer func() { <-sem }() // Release the token            connection, err := net.Dial("tcp", net.JoinHostPort("scanme.nmap.org", fmt.Sprintf("%d", port)))
            if err != nil {                // fmt.Printf("Port %d is closed\n", port)                return            }
            defer connection.Close()            fmt.Printf("Port %d is open\n", port)        }(port)    }    wg.Wait()}

Luan de Souza

student•

A mi no me deja ejecutar el primer codigo puse desde las 65350 a 10000 a 1000 y me tira este error;

runtime: program exceeds 10000-thread limit fatal error: thread exhaustion

Jorge Luis Velasquez Venegas

student•

El error runtime: program exceeds 10000-thread limit ocurre por que el código no esta implementando un limite para la creación de subrutinas, lo que agota los recursos del sistema. En este caso es apropiado implementar un límite de concurrencia implementando un canal como un semáforo.

Dejo un ejemplo del código


func  main() {

&#x9;var  wg  sync.WaitGroup

&#x9;concurrencyLimit  :=  1000  // Number of concurrent goroutines

&#x9;sem  :=  make(chan  struct{}, concurrencyLimit)



&#x9;for  port  :=  1; port  <=  65535; port++ {

&#x9;	wg.Add(1)

&#x9;	sem  <-  struct{}{} // Acquire a token

&#x9;	go  func(port  int) {

&#x9;		defer  wg.Done()

&#x9;&#x9;

&#x9;		defer  func() { <-sem }() // Release the token

&#x9;&#x9;

&#x9;		connection, err  :=  net.Dial("tcp", net.JoinHostPort("scanme.nmap.org", fmt.Sprintf("%d", port)))&#x20;



&#x9;		if  err  !=  nil {

&#x9;			return

&#x9;		}

&#x9;		defer  connection.Close()

&#x9;&#x9;

&#x9;		fmt.Printf("Port %d is open\n", port)

&#x9;	}(port)

&#x9;}

&#x9;wg.Wait()

}

Carlos Nassif Trejo Garcia

student•

package main

import (
	"flag"
	"fmt"
	"net"
	"sync"
)

// Get variable from command line
// Usage: go run net/port.go --site=www.url.com
var site = flag.String("site", "scanme.nmap.org", "Site to scan")

func main() {
	flag.Parse() // parse the flags

	var wg sync.WaitGroup

	// Escanear cada puerto y hacer una conexión
	for i := 0; i < 65535; i++ {
		wg.Add(1)
		go func(port int) {
			defer wg.Done()

			conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", *site, port))
			if err != nil {
				return
			}
			conn.Close()
			fmt.Println("Port", port, "is open")
		}(i)
	}

	wg.Wait()
}

Oscar Jaramillo

student•

Mucho mejor!!! 😎

Concurrencia en Go: Escáner de Puertos Eficiente y Personalizable

Introducción

Concurrencia Avanzada y Patrones de Diseño en Go

Concurrencia

Condiciones de Carrera en Programación Concurrente con Go

Evitar Condiciones de Carrera en Go con Mutex y WaitGroup

Lectura y Escritura Concurrente en Go con RWMutex

Creación de un Sistema de Caché Concurrente en Go

Manejo de Condiciones de Carrera en Go: Implementación de Mutex

Cache concurrente en Go para cálculos intensivos de Fibonacci

Patrones de diseño

Patrones de Diseño en Programación Orientada a Objetos con Go

Patrón de Diseño Factory en Go: Creación y Uso Práctico

Implementación de Singleton en Go para Conexiones de Base de Datos

Patrón de Diseño Adapter en Go: Implementación Práctica

Patrón de Diseño Observer en Go: Implementación Práctica

Implementación del Patrón de Diseño Strategy en Go

Net

Escaneo de Puertos TCP con Go: Introducción Básica