Using Goroutines for Concurrent Network Scans in Go

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setting Up Go Environment
  4. Overview of Goroutines
  5. Concurrent Network Scanning
  6. Putting it All Together
  7. Recap and Conclusion

Introduction

In this tutorial, we will explore how to utilize Goroutines for concurrent network scans in Go. Goroutines allow us to execute functions asynchronously and concurrently, enabling faster network scanning by utilizing multiple threads. By the end of this tutorial, you will understand the basics of Goroutines and how to apply them in the context of network scanning.

Prerequisites

Before starting this tutorial, you should have a basic understanding of the Go programming language. Familiarity with networking concepts such as IP addresses, ports, and sockets will also be helpful.

Setting Up Go Environment

To get started, ensure you have Go installed on your system. You can download and install the latest stable release from the official Go website (https://golang.org/dl/).

Once Go is installed, set up the necessary environment variables. Add the following lines to your ~/.bash_profile (Linux/Mac) or Environment Variables (Windows):

export GOPATH=$HOME/go
export GOBIN=$GOPATH/bin
export PATH=$PATH:$GOBIN

Save the changes and reload the shell configuration. Verify the Go installation by running go version command in the terminal.

Overview of Goroutines

Goroutines are lightweight threads managed by the Go runtime. They enable concurrent execution of functions, allowing us to perform multiple tasks concurrently. Being lightweight, Goroutines have minimal memory overhead compared to traditional threads.

To create a Goroutine, we need to prefix the function call with the go keyword. Let’s consider a simple example to illustrate this:

package main

import (
    "fmt"
    "time"
)

func count(id int) {
    for i := 1; i <= 5; i++ {
        fmt.Println("Goroutine", id, "Count:", i)
        time.Sleep(time.Millisecond * 500)
    }
}

func main() {
    go count(1)
    go count(2)

    time.Sleep(time.Second * 3)
}

In the above example, we define a function count that prints the count value. We create two Goroutines by calling count(1) and count(2) using the go keyword. The main function sleeps for 3 seconds to allow the Goroutines to complete their execution.

When you run the above program, you will see that both Goroutines are executing concurrently, printing the count values interleaved.

Concurrent Network Scanning

Now, let’s apply the concept of Goroutines to perform concurrent network scanning. We assume that you have a basic understanding of network scanning techniques.

We will use the net package in Go to demonstrate network scanning. The net package provides functionality to perform network I/O, including TCP/IP operations.

Here’s an example of a basic network scanner that scans a range of IP addresses for open ports:

package main

import (
    "fmt"
    "net"
    "time"
)

func scanPort(ip string, port int, results chan int) {
    address := fmt.Sprintf("%s:%d", ip, port)

    conn, err := net.DialTimeout("tcp", address, time.Second)
    if err == nil {
        conn.Close()
        results <- port
    } else {
        results <- 0
    }
}

func main() {
    ip := "127.0.0.1"
    ports := []int{80, 443, 8080, 22, 3306}

    results := make(chan int)

    for _, port := range ports {
        go scanPort(ip, port, results)
    }

    for i := 0; i < len(ports); i++ {
        port := <-results
        if port != 0 {
            fmt.Println("Port", port, "is open")
        }
    }
}

In the above example, we define a function scanPort that takes an IP address and a port number to scan. We use net.DialTimeout to establish a TCP connection to the specified address and port. If the connection is successful, we assume the port is open and send the port number through the results channel. Otherwise, we send a value of 0.

In the main function, we create a Goroutine for each port we want to scan. The results from each Goroutine are received through the results channel, and if the port is not zero, we print a message indicating that the port is open.

Putting it All Together

Let’s put all the concepts together and create a fully functional network scanner that scans a range of IP addresses and ports concurrently. This scanner will use Goroutines to parallelize the scanning process and provide faster results.

package main

import (
    "fmt"
    "net"
    "sync"
    "time"
)

func scanPort(ip string, port int, wg *sync.WaitGroup) {
    defer wg.Done()

    address := fmt.Sprintf("%s:%d", ip, port)

    conn, err := net.DialTimeout("tcp", address, time.Second)
    if err == nil {
        conn.Close()
        fmt.Println("Port", port, "is open")
    }
}

func scanIP(ip string, ports []int) {
    var wg sync.WaitGroup

    for _, port := range ports {
        wg.Add(1)
        go scanPort(ip, port, &wg)
    }

    wg.Wait()
}

func main() {
    ips := []string{"127.0.0.1", "192.168.1.1"}
    ports := []int{80, 443, 8080, 22, 3306}

    for _, ip := range ips {
        go scanIP(ip, ports)
    }

    time.Sleep(time.Second * 5)
}

In this final example, we introduce a new function scanIP that takes an IP address and a list of ports to scan. Inside this function, we create a sync.WaitGroup to synchronize the Goroutines. For each port, we increment the WaitGroup counter and launch a Goroutine to scan that port using the scanPort function. Once a Goroutine finishes scanning a port, it calls wg.Done() to signal that it has completed its execution.

By using the WaitGroup and the wg.Wait() call in the main function, we ensure that all the Goroutines have completed before exiting the program.

Recap and Conclusion

In this tutorial, we learned how to utilize Goroutines for concurrent network scanning in Go. We started with an overview of Goroutines and their benefits in terms of concurrency. Then, we applied the concept of Goroutines to perform concurrent network scanning using the net package in Go. Finally, we put everything together to create a fully functional network scanner that scans multiple IP addresses and ports concurrently.

By leveraging Goroutines, we can significantly improve the efficiency and speed of network scanning operations. Go’s built-in support for concurrency makes it an excellent choice for such tasks.

Feel free to experiment further with the examples provided and explore other networking-related functionalities available in Go. With the knowledge gained from this tutorial, you should be well-equipped to develop your own network scanning applications using Goroutines in Go.

Happy coding!

Published:

Related Articles