ullaakut/nmapLibreria Go idiomatica per invocare un binario scanner di rete, che consente la scoperta degli host, la scansione delle porte, il rilevamento di servizi/OS e controlli di vulnerabilità tramite script per l'audit di sicurezza.
Questa libreria mira a fornire binding idiomatici di nmap per gli sviluppatori Go, al fine di rendere più semplice scrivere strumenti di security audit usando golang.
Nmap (Network Mapper) è uno scanner di rete gratuito e open-source creato da Gordon Lyon. Nmap viene utilizzato per scoprire host e servizi su una rete informatica inviando pacchetti e analizzando le risposte.
Nmap offre una serie di funzionalità per esplorare reti informatiche, tra cui la scoperta degli host e il rilevamento di servizi e sistemi operativi. Queste funzionalità sono estensibili tramite script che forniscono un rilevamento dei servizi più avanzato, l'individuazione delle vulnerabilità e altre funzionalità. Nmap può adattarsi alle condizioni della rete, inclusi latenza e congestione, durante una scansione.
La maggior parte degli strumenti di pentest è attualmente scritta in Python e non in Go, perché è facile scrivere rapidamente script, sono disponibili molte librerie ed è un linguaggio semplice da usare. Tuttavia, per scrivere applicazioni robuste e affidabili, Go è lo strumento migliore. È compilato staticamente, ha un sistema di tipi statico, prestazioni molto migliori, è anche un linguaggio molto semplice da usare e le goroutine sono fantastiche... Ma potrei essere leggermente di parte, quindi sentiti libero di non essere d'accordo.
Questa libreria esegue il binario nmap tramite il pacchetto exec di Go e analizza l'output XML.
Ciò significa che nmap deve essere installato e disponibile nel tuo PATH affinché questa libreria funzioni.
La compatibilità è confermata con l'attuale ultima versione di nmap, 7.98.
Alcuni tipi di scansione richiedono privilegi elevati (ad esempio, le scansioni SYN, il rilevamento del sistema operativo o l'uso di socket raw). Se abiliti queste opzioni, potresti dover eseguire il tuo programma con sudo o con le capacità appropriate per la tua piattaforma.
[!TIP] Per esecuzioni senza privilegi, preferisci le scansioni di connessione (ad es.
-sT).
package main
import (
"context"
"fmt"
"log"
"time"
"github.com/Ullaakut/nmap/v4"
)
func main() {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
defer cancel()
// Equivalent to `/usr/local/bin/nmap -p 80,443,843 google.com facebook.com youtube.com`,
// with a 5-minute timeout.
scanner, err := nmap.NewScanner(
nmap.WithTargets("scanme.nmap.org"),
nmap.WithPorts("80,443,843"),
)
if err != nil {
log.Fatalf("creating nmap scanner: %v", err)
}
result, err := scanner.Run(ctx)
if err != nil {
log.Fatalf("running network scan: %v", err)
}
warnings := result.Warnings()
if len(warnings) > 0 {
log.Printf("warning: %v\n", warnings) // Warnings are non-critical errors from nmap.
}
// Use the results to print an example output
for _, host := range result.Hosts {
if len(host.Ports) == 0 || len(host.Addresses) == 0 {
continue
}
fmt.Printf("Host %q:\n", host.Addresses[0])
for _, port := range host.Ports {
fmt.Printf("\tPort %d/%s %s %s\n", port.ID, port.Protocol, port.State, port.Service.Name)
}
}
fmt.Printf("Nmap done: %d hosts up scanned in %.2f seconds\n", len(result.Hosts), result.Stats.Finished.Elapsed)
}
Il programma sopra produce il seguente output:
Host "45.33.32.156":
Port 80/tcp open http
Port 443/tcp closed https
Port 843/tcp closed
Nmap done: 1 hosts up scanned in 0.42 seconds
[!IMPORTANT] Questo si basa su sequenze di escape del terminale e funziona solo quando il processo è collegato a una TTY.
[!NOTE] Non è garantito che l'avanzamento aumenti in modo monotono: nmap stima il tempo rimanente e può rivedere tale stima, il che può causare una diminuzione della percentuale riportata.
package main
import (
"context"
"log"
"time"
"github.com/Ullaakut/nmap/v4"
)
func main() {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
defer cancel()
scanner, err := nmap.NewScanner(
nmap.WithTargets("scanme.nmap.org"),
nmap.WithPorts("1-1024"),
nmap.WithTimingTemplate(nmap.TimingAggressive),
nmap.WithProgress(time.Second, handleProgress),
)
if err != nil {
log.Fatalf("creating nmap scanner: %v", err)
}
_, err = scanner.Run(ctx)
if err != nil {
log.Fatalf("running network scan: %v", err)
}
}
func handleProgress(p nmap.TaskProgress) {
log.Println("Current progress: ", p.Percent)
}
Questo esempio produce il seguente output:
2026/01/27 16:13:02 task "Connect Scan": 2.59% remaining 38
2026/01/27 16:13:02 task "Connect Scan": 21.26% remaining 4
2026/01/27 16:13:04 task "Connect Scan": 42.61% remaining 5
2026/01/27 16:13:04 task "Connect Scan": 45.51% remaining 4
2026/01/27 16:13:05 task "Connect Scan": 53.44% remaining 4
2026/01/27 16:13:07 task "Connect Scan": 59.77% remaining 5
2026/01/27 16:13:07 task "Connect Scan": 62.77% remaining 4
2026/01/27 16:13:08 task "Connect Scan": 73.24% remaining 3
2026/01/27 16:13:09 task "Connect Scan": 81.71% remaining 2
2026/01/27 16:13:10 task "Connect Scan": 92.92% remaining 1
2026/01/27 16:13:11 task "Connect Scan": 100.00% remaining 0
package main
import (
"context"
"fmt"
"log"
"time"
"github.com/Ullaakut/nmap/v4"
)
func main() {
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
defer cancel()
scanner, err := nmap.NewScanner(
nmap.WithTargets("scanme.nmap.org"),
nmap.WithPorts("1-1024"),
)
if err != nil {
log.Fatalf("creating nmap scanner: %v", err)
}
stdout, stderr, resultCh, err := scanner.RunAsync(ctx)
if err != nil {
log.Fatalf("running network scan: %v", err)
}
for {
select {
case <-ctx.Done():
log.Fatalf("scan timed out: %v", ctx.Err())
case out := <-stdout:
fmt.Printf("nmap output: %s\n", out)
case errOut := <-stderr:
fmt.Printf("nmap error output: %s\n", errOut)
case result := <-resultCh:
if result.Err != nil {
log.Fatalf("running network scan: %v", result.Err)
}
fmt.Printf("Nmap done: %d hosts up\n", len(result.Result.Hosts))
return
}
}
}
Consulta la directory examples per altri esempi di utilizzo.
Cameradar utilizza già questa libreria al suo interno per comunicare con nmap, scoprire stream RTSP e accedervi da remoto.
Altri esempi: