Golang API 文档

go get github.com/cyberspacesec/go-port-rocket

import (
    "github.com/cyberspacesec/go-port-rocket/pkg/scanner"
    "github.com/cyberspacesec/go-port-rocket/pkg/fingerprint"
    "github.com/cyberspacesec/go-port-rocket/pkg/output"
)

package main

import (
    "fmt"
    "log"
    "time"

    "github.com/cyberspacesec/go-port-rocket/pkg/scanner"
)

func main() {
    // 创建简单的扫描配置
    scanOpts := &scanner.ScanOptions{
        Target:   "scanme.nmap.org",    // 扫描目标
        Ports:    "22,80,443",          // 要扫描的端口
        ScanType: scanner.ScanTypeTCP,  // 使用TCP扫描
        Timeout:  5 * time.Second,      // 连接超时时间
        Workers:  10,                   // 并发工作线程数
    }

    // 执行扫描
    fmt.Println("开始扫描目标:", scanOpts.Target)
    results, err := scanner.ExecuteScan(scanOpts)
    if err != nil {
        log.Fatalf("扫描失败: %v", err)
    }

    // 输出结果
    fmt.Println("扫描结果:")
    for _, result := range results {
        state := "关闭"
        if result.State == scanner.PortStateOpen {
            state = "开放"
        }
        fmt.Printf("端口 %d: %s\n", result.Port, state)
    }
}

import "github.com/cyberspacesec/go-port-rocket/pkg/scanner"

// 创建扫描器实例
s, err := scanner.NewScanner(&scanner.Options{
    Target:           "scanme.nmap.org",
    Ports:            "21-25,80,443",
    ScanType:         scanner.ScanTypeTCP,
    Timeout:          "5s",
    Workers:          100,
    ServiceDetection: true,
    OSDetection:      true,
    VersionIntensity: 7,
})
if err != nil {
    log.Fatalf("Failed to create scanner: %v", err)
}

// 开始扫描
result, err := s.Scan()
if err != nil {
    log.Fatalf("Scan failed: %v", err)
}

// 处理扫描结果
for _, port := range result {
    fmt.Printf("Port %d/%s: %s\n", port.Port, port.Type, port.State)
    if port.ServiceName != "" {
        fmt.Printf("  Service: %s\n", port.ServiceName)
    }
    if port.Version != "" {
        fmt.Printf("  Version: %s\n", port.Version)
    }
    if port.Banner != "" {
        fmt.Printf("  Banner: %s\n", port.Banner)
    }
}

// 处理操作系统检测结果
if port.OS != nil {
    fmt.Printf("OS: %s %s (Confidence: %.2f%%)\n", 
        port.OS.Name, port.OS.Version, port.OS.Confidence*100)
}

import "github.com/cyberspacesec/go-port-rocket/pkg/fingerprint"

// 创建服务检测器
detector := fingerprint.NewServiceDetector(&fingerprint.ServiceOptions{
    Intensity: 7,
    Timeout:   time.Second * 2,
})

// 对特定端口执行服务检测
serviceInfo, err := detector.Detect("192.168.1.1", 80, "tcp")
if err != nil {
    log.Printf("Service detection failed: %v", err)
} else {
    fmt.Printf("检测到的服务: %s\n", serviceInfo.Name)
    fmt.Printf("版本: %s\n", serviceInfo.Version)
    fmt.Printf("产品: %s\n", serviceInfo.Product)
    if serviceInfo.Banner != "" {
        fmt.Printf("Banner: %s\n", serviceInfo.Banner)
    }
}

import "github.com/cyberspacesec/go-port-rocket/pkg/fingerprint"

// 创建操作系统检测器
osDetector := fingerprint.NewOSDetector(&fingerprint.OSOptions{
    GuessOS:    true,  // 即使信息不充分也尝试猜测
    LimitOSScan: false, // 不限制操作系统扫描范围
    Timeout:    time.Second * 3,
})

// 需要提供一些开放端口以获得更准确的结果
openPorts := []int{22, 80, 443} 

// 执行操作系统检测
osInfo, err := osDetector.Detect("192.168.1.1", openPorts)
if err != nil {
    log.Printf("OS detection failed: %v", err)
} else {
    fmt.Printf("检测到的操作系统: %s\n", osInfo.Name)
    if osInfo.Version != "" {
        fmt.Printf("版本: %s\n", osInfo.Version)
    }
    if osInfo.Family != "" {
        fmt.Printf("系统家族: %s\n", osInfo.Family)
    }
    fmt.Printf("置信度: %.2f%%\n", osInfo.Confidence * 100)
}

import "github.com/cyberspacesec/go-port-rocket/pkg/output"

// 创建输出处理器
outputter, err := output.NewOutputter(&output.Options{
    Format:     "json",  // 输出格式：json, text, xml, html, csv
    OutputFile: "result.json",  // 输出文件路径
    Pretty:     true,  // 美化输出
})
if err != nil {
    log.Fatalf("Failed to create outputter: %v", err)
}

// 处理并保存扫描结果
err = outputter.Process(scanResult)
if err != nil {
    log.Fatalf("Failed to process output: %v", err)
}

// 获取格式化后的输出字符串
formattedOutput, err := outputter.Format(scanResult)
if err != nil {
    log.Fatalf("Failed to format output: %v", err)
}
fmt.Println(formattedOutput)

{
  "target": "scanme.nmap.org",
  "scan_time": "2023-04-20T15:30:45Z",
  "scan_duration": "5.2s",
  "ports": [
    {
      "port": 22,
      "protocol": "tcp",
      "state": "open",
      "service": {
        "name": "ssh",
        "product": "OpenSSH",
        "version": "8.2p1 Ubuntu 4ubuntu0.5",
        "confidence": 0.95
      }
    },
    {
      "port": 80,
      "protocol": "tcp",
      "state": "open",
      "service": {
        "name": "http",
        "product": "Apache httpd",
        "version": "2.4.41",
        "confidence": 0.98
      }
    }
  ],
  "os": {
    "name": "Linux",
    "family": "Ubuntu",
    "version": "20.04 LTS",
    "confidence": 0.92
  },
  "stats": {
    "open_ports": 2,
    "closed_ports": 45,
    "filtered_ports": 3,
    "total_ports": 50
  }
}

package main

import (
    "fmt"
    "log"
    "time"

    "github.com/cyberspacesec/go-port-rocket/pkg/scanner"
    "github.com/cyberspacesec/go-port-rocket/pkg/output"
)

func main() {
    // 创建扫描器
    s, err := scanner.NewScanner(&scanner.ScanOptions{
        Target:   "example.com",
        Ports:    "80,443",
        ScanType: scanner.ScanTypeTCP,
        Timeout:  5 * time.Second,
        Workers:  100,
    })
    if err != nil {
        log.Fatalf("Failed to create scanner: %v", err)
    }

    // 执行扫描
    result, err := s.Scan()
    if err != nil {
        log.Fatalf("Scan failed: %v", err)
    }

    // 创建输出处理器
    outputter, err := output.NewOutputter(&output.Options{
        Format: "text",
    })
    if err != nil {
        log.Fatalf("Failed to create outputter: %v", err)
    }

    // 处理输出
    err = outputter.Process(result)
    if err != nil {
        log.Fatalf("Failed to process output: %v", err)
    }
}

package main

import (
    "fmt"
    "log"
    "time"

    "github.com/cyberspacesec/go-port-rocket/pkg/scanner"
    "github.com/cyberspacesec/go-port-rocket/pkg/output"
)

func main() {
    // 创建扫描器
    s, err := scanner.NewScanner(&scanner.ScanOptions{
        Target:           "scanme.nmap.org",
        Ports:            "21-25,80,443",
        ScanType:         scanner.ScanTypeTCP,
        Timeout:          "5s",
        Workers:          100,
        ServiceDetection: true,
        VersionIntensity: 7,
    })
    if err != nil {
        log.Fatalf("Failed to create scanner: %v", err)
    }

    // 执行扫描
    result, err := s.Scan()
    if err != nil {
        log.Fatalf("Scan failed: %v", err)
    }

    // 创建输出处理器
    outputter, err := output.NewOutputter(&output.Options{
        Format:     "json",
        OutputFile: "result.json",
        Pretty:     true,
    })
    if err != nil {
        log.Fatalf("Failed to create outputter: %v", err)
    }

    // 处理输出
    err = outputter.Process(result)
    if err != nil {
        log.Fatalf("Failed to process output: %v", err)
    }

    fmt.Println("扫描完成，结果已保存到 result.json")
}

package main

import (
    "fmt"
    "log"
    "time"

    "github.com/cyberspacesec/go-port-rocket/pkg/scanner"
)

func main() {
    // 创建扫描器
    s, err := scanner.NewScanner(&scanner.ScanOptions{
        Target:           "example.com",
        Ports:            "1-1000",
        ScanType:         scanner.ScanTypeTCP,
        Workers:          200,
        EnableService:    true,
    })
    if err != nil {
        log.Fatalf("Failed to create scanner: %v", err)
    }

    // 启动异步扫描
    portChan, resultChan, errChan := s.ScanAsync()

    // 显示进度条
    fmt.Println("正在扫描，请稍候...")
    fmt.Println("[                    ]")
    fmt.Print("\033[1A") // 光标上移一行
    fmt.Print("\033[2C") // 光标右移两列

    // 处理端口结果
    var openPorts int
    go func() {
        for port := range portChan {
            if port.State == scanner.PortStateOpen {
                openPorts++
                fmt.Printf("发现开放端口 %d/%s", port.Port, port.Type)
                if port.ServiceName != "" {
                    fmt.Printf(" (%s %s)", port.ServiceName, port.Version)
                }
                fmt.Println()
                // 更新进度条
                fmt.Print("=")
            }
        }
    }()

    // 处理错误
    go func() {
        for err := range errChan {
            log.Printf("错误: %v", err)
        }
    }()

    // 获取最终结果
    result := <-resultChan
    fmt.Printf("\n\n扫描完成，耗时 %s\n", result.ScanTime)
    fmt.Printf("共找到 %d 个开放端口\n\n", openPorts)
    
    // 等待所有处理完成
    time.Sleep(time.Second)
}

package main

import (
    "fmt"
    "log"
    "time"

    "github.com/cyberspacesec/go-port-rocket/pkg/scanner"
    "github.com/cyberspacesec/go-port-rocket/pkg/output"
)

func main() {
    // 注意：SYN扫描需要root/管理员权限
    s, err := scanner.NewScanner(&scanner.ScanOptions{
        Target:   "192.168.1.1",
        Ports:    "1-1024",
        ScanType: scanner.ScanTypeSYN,  // 使用SYN半开放扫描
        Timeout:  2 * time.Second,
        Workers:  50,
    })
    if err != nil {
        log.Fatalf("创建扫描器失败: %v", err)
    }

    fmt.Println("开始SYN隐蔽扫描...")
    results, err := s.Scan()
    if err != nil {
        log.Fatalf("扫描失败: %v", err)
    }

    // 创建输出处理器
    outputter, err := output.NewOutputter(&output.Options{
        Format:     "text",
        Colorize:   true,  // 在终端中使用彩色输出
    })
    if err != nil {
        log.Fatalf("创建输出处理器失败: %v", err)
    }

    // 处理并输出结果
    fmt.Println("\n扫描结果:")
    formatted, err := outputter.Format(results)
    if err != nil {
        log.Fatalf("格式化结果失败: %v", err)
    }
    fmt.Println(formatted)
}

package main

import (
    "fmt"
    "log"
    "time"

    "github.com/cyberspacesec/go-port-rocket/pkg/scanner"
    "github.com/cyberspacesec/go-port-rocket/pkg/output"
)

func main() {
    // UDP扫描常用端口
    commonUdpPorts := "53,67,68,69,123,137,138,161,162,1900,5353"
    
    // 创建UDP扫描器
    s, err := scanner.NewScanner(&scanner.ScanOptions{
        Target:        "example.com",
        Ports:         commonUdpPorts,
        ScanType:      scanner.ScanTypeUDP,
        Timeout:       5 * time.Second,
        Workers:       10,            // UDP扫描通常使用较少的并发
        EnableService: true,          // 启用服务检测
        ServiceProbe:  true,          // 启用UDP服务探测
        Retries:       2,             // UDP扫描重试次数
    })
    if err != nil {
        log.Fatalf("创建扫描器失败: %v", err)
    }

    fmt.Printf("开始UDP扫描 %s 的常用端口...\n", s.Options().Target)
    startTime := time.Now()

    results, err := s.Scan()
    if err != nil {
        log.Fatalf("扫描失败: %v", err)
    }

    // 扫描耗时
    duration := time.Since(startTime)
    
    // 统计开放端口
    var openPorts int
    for _, port := range results {
        if port.State == scanner.PortStateOpen {
            openPorts++
        }
    }
    
    // 输出结果
    fmt.Printf("\n扫描完成，耗时: %.2f秒\n", duration.Seconds())
    fmt.Printf("发现 %d 个开放的UDP端口\n\n", openPorts)
    
    // 格式化输出
    outputter, _ := output.NewOutputter(&output.Options{
        Format: "text",
        Pretty: true,
    })
    
    formattedOutput, _ := outputter.Format(results)
    fmt.Println(formattedOutput)
}

package main

import (
    "fmt"
    "log"
    "time"

    "github.com/cyberspacesec/go-port-rocket/pkg/scanner"
    "github.com/cyberspacesec/go-port-rocket/pkg/utils"
)

func main() {
    target := "example.com"

    // 1. 验证目标地址
    if err := utils.ValidateTarget(target); err != nil {
        log.Fatalf("无效的目标地址: %v", err)
    }

    // 2. 验证端口范围
    ports := "1-65535"
    if err := utils.ValidatePortRange(ports); err != nil {
        log.Fatalf("无效的端口范围: %v", err)
    }

    // 3. 验证超时时间
    timeout := 5 * time.Second
    if err := utils.ValidateTimeout(timeout); err != nil {
        log.Fatalf("无效的超时时间: %v", err)
    }

    // 4. 创建扫描器时处理错误
    scanner, err := scanner.NewScanner(&scanner.ScanOptions{
        Target:   target,
        Ports:    ports,
        ScanType: scanner.ScanTypeTCP,
        Timeout:  timeout,
        Workers:  100,
    })
    if err != nil {
        log.Fatalf("创建扫描器失败: %v", err)
    }

    // 5. 执行扫描时处理错误
    results, err := scanner.Scan()
    if err != nil {
        log.Fatalf("扫描失败: %v", err)
    }

    fmt.Printf("扫描完成，发现 %d 个端口\n", len(results))
}

// 推荐的项目结构
project/
├── main.go                 // 主程序入口
├── config/
│   └── config.go          // 配置管理
├── scanner/
│   ├── scanner.go         // 扫描器封装
│   └── result.go          // 结果处理
├── output/
│   └── formatter.go       // 输出格式化
└── utils/
    └── helpers.go         // 工具函数