ip

IP - IP地址管理模块

📋 功能概述

IP模块提供了全面的IP地址管理功能，包括公网IPv4/IPv6地址获取、本地网络地址分析、IP范围计算和网段管理等。支持获取本机公网地址、指定网卡的IP地址，以及计算IP范围等实用功能。

✨ 核心功能

🌍 公网IP获取

• IPv4公网地址: 多API服务支持，确保获取成功率
• IPv6公网地址: 自动过滤本地和临时地址
• 指定网卡: 支持获取特定网卡的公网地址
• 容错机制: 多个API服务依次尝试，提高可靠性

🏠 本地网络管理

• 默认网段: 获取本机默认网卡的网段信息
• 网段遍历: 列出网段内的所有IP地址
• 网络接口: 集成eth模块的网络接口管理

🔢 IP范围计算

• CIDR解析: 支持CIDR表示法的IP范围生成
• 掩码计算: 根据IP和子网掩码生成IP列表
• 范围限制: 智能限制防止过大范围导致性能问题
• 批量生成: 一次性生成完整的IP列表

🔧 统一管理

• IPManager: 统一管理所有IP相关功能
• 标准化接口: 一致的API设计和使用方式
• 错误处理: 完善的错误信息和异常处理

📁 文件结构

info.go - 核心数据结构

// ipv4IPW - IPv4查询结果结构
type ipv4IPW struct {
    Result    bool   `json:"result"`    // 查询是否成功
    Code      string `json:"code"`      // 返回码
    Message   string `json:"message"`   // 返回信息
    IP        string `json:"IP"`        // IP地址
    IPVersion string `json:"IPVersion"` // IP版本
}

// ipv4Uomg - IPv4用户操作信息
type ipv4Uomg struct {
    Code    string `json:"code"`    // 返回码
    System  string `json:"system"`  // 系统信息
    IP      string `json:"ip"`      // IP地址
    Browser string `json:"browser"` // 浏览器信息
    Time    string `json:"time"`    // 时间
}

// IPManager - IP统一管理器
type IPManager struct{}

ipv4.go - IPv4功能实现

// 获取本机公网IPv4地址
func GetPublicIpv4() (string, error)

// 获取指定网卡的公网IPv4地址
func GetPublicIpv4Eth(ethName string) (net.IP, error)

// 创建绑定客户端
func createBoundClient(bindIP net.IP) *http.Client

ipv6.go - IPv6功能实现

// 获取公网IPv6地址列表
func GetPublicIpv6() ([]net.IP, error)

// 获取所有IPv6地址
func GetIpv6() ([]net.IP, error)

// 获取指定网卡的公网IPv6地址
func GetPublicIpv6Eth(ethName string) ([]net.IP, error)

local.go - 本地网络功能

// 获取默认网卡的网段
func GetDefaultNetworkSubnet() ([]net.IP, error)

// 打印默认网段内所有IP
func PrintDefaultNetworkSubnet() error

range.go - IP范围计算

// CIDR转IP范围
func CIDRToIPRange(cidr string) ([]net.IP, error)

// IP+掩码转IP范围
func IPsInSubnet(baseIP, subnetMask string) ([]net.IP, error)

// 打印IP范围
func PrintIPRange(cidr string) error

ipv4_utils.go - IPv4工具函数

// 通过uomg.com获取公网IP
func getPublicIpv4Sb(client *http.Client) (string, error)

// 通过uomg API获取IP信息
func getIpv4Uomg(client *http.Client) (string, error)

// 通过ipw.cn获取公网IP
func getPublicIP1Ipw(client *http.Client) (string, error)

🚀 使用示例

公网IPv4地址获取

package main

import (
    "fmt"
    "gitee.com/liumou_site/gns/ip"
)

func main() {
    // 获取本机公网IPv4地址
    publicIP, err := ip.GetPublicIpv4()
    if err != nil {
        fmt.Printf("获取公网IP失败: %v\n", err)
        return
    }
    fmt.Printf("✓ 本机公网IPv4地址: %s\n", publicIP)
    
    // 使用IP管理器获取
    manager := ip.NewIPManager()
    publicIP2, err := manager.GetPublicIPv4()
    if err != nil {
        fmt.Printf("IP管理器获取失败: %v\n", err)
        return
    }
    fmt.Printf("✓ IP管理器获取的公网IP: %s\n", publicIP2)
}

指定网卡公网IP获取

// 获取指定网卡的公网IPv4地址
func getEthPublicIP() {
    // 先获取网卡列表
    ethManager := eth.NewEth(false)
    ethList := ethManager.GetEthList()
    
    if len(ethList) == 0 {
        fmt.Println("未找到网络接口")
        return
    }
    
    // 获取第一个网卡的公网IP
    firstEth := ethList[0]
    fmt.Printf("正在获取 %s 网卡的公网IP...\n", firstEth)
    
    publicIP, err := ip.GetPublicIpv4Eth(firstEth)
    if err != nil {
        fmt.Printf("获取 %s 网卡公网IP失败: %v\n", firstEth, err)
        return
    }
    
    fmt.Printf("✓ %s 网卡公网IP: %s\n", firstEth, publicIP.String())
}

IPv6地址管理

// 获取所有IPv6地址
func getAllIPv6() {
    ipv6List, err := ip.GetIpv6()
    if err != nil {
        fmt.Printf("获取IPv6地址失败: %v\n", err)
        return
    }
    
    fmt.Printf("找到 %d 个IPv6地址:\n", len(ipv6List))
    for i, ipv6 := range ipv6List {
        fmt.Printf("  IPv6 #%d: %s\n", i+1, ipv6.String())
    }
}

// 获取公网IPv6地址
func getPublicIPv6() {
    publicIPv6, err := ip.GetPublicIpv6()
    if err != nil {
        fmt.Printf("获取公网IPv6失败: %v\n", err)
        return
    }
    
    fmt.Printf("找到 %d 个公网IPv6地址:\n", len(publicIPv6))
    for i, ipv6 := range publicIPv6 {
        fmt.Printf("  公网IPv6 #%d: %s\n", i+1, ipv6.String())
    }
}

本地网段管理

// 获取默认网段信息
func getDefaultSubnet() {
    ips, err := ip.GetDefaultNetworkSubnet()
    if err != nil {
        fmt.Printf("获取默认网段失败: %v\n", err)
        return
    }
    
    fmt.Printf("默认网段包含 %d 个IP:\n", len(ips))
    for i, ipAddr := range ips {
        if i < 10 { // 只显示前10个
            fmt.Printf("  IP #%d: %s\n", i+1, ipAddr.String())
        } else if i == 10 {
            fmt.Printf("  ... (还有 %d 个IP)\n", len(ips)-10)
            break
        }
    }
}

// 打印默认网段所有IP
func printDefaultSubnetIPs() {
    fmt.Println("=== 打印默认网段所有IP ===")
    err := ip.PrintDefaultNetworkSubnet()
    if err != nil {
        fmt.Printf("打印失败: %v\n", err)
    }
}

IP范围计算

// CIDR范围计算
func calculateCIDRRange() {
    cidrExamples := []string{
        "192.168.1.0/24",
        "10.0.0.0/28",
        "172.16.0.0/16",
    }
    
    for _, cidr := range cidrExamples {
        fmt.Printf("\n计算 %s 范围内的IP:\n", cidr)
        ips, err := ip.CIDRToIPRange(cidr)
        if err != nil {
            fmt.Printf("  计算失败: %v\n", err)
            continue
        }
        
        fmt.Printf("  找到 %d 个IP地址:\n", len(ips))
        for i, ipAddr := range ips {
            if i < 5 { // 只显示前5个
                fmt.Printf("    IP #%d: %s\n", i+1, ipAddr.String())
            } else if i == 5 {
                fmt.Printf("    ... (还有 %d 个IP)\n", len(ips)-5)
                break
            }
        }
    }
}

// IP+掩码范围计算
func calculateSubnetRange() {
    examples := []struct {
        ip       string
        mask     string
        desc     string
    }{
        {"192.168.1.100", "255.255.255.0", "C类网络"},
        {"10.0.0.50", "255.255.0.0", "B类网络"},
        {"172.16.5.10", "255.255.255.252", "点对点网络"},
    }
    
    for _, example := range examples {
        fmt.Printf("\n计算 %s (%s) 网络范围:\n", example.ip, example.desc)
        ips, err := ip.IPsInSubnet(example.ip, example.mask)
        if err != nil {
            fmt.Printf("  计算失败: %v\n", err)
            continue
        }
        
        fmt.Printf("  网络范围: %s\n", ips[0].String())
        fmt.Printf("  广播地址: %s\n", ips[len(ips)-1].String())
        fmt.Printf("  总IP数: %d\n", len(ips))
        
        if len(ips) <= 10 {
            for i, ipAddr := range ips {
                fmt.Printf("    IP #%d: %s\n", i+1, ipAddr.String())
            }
        }
    }
}

// 打印IP范围
func printIPRangeExamples() {
    cidr := "192.168.1.0/30" // /30网络，只有4个IP
    fmt.Printf("打印 %s 范围内的所有IP:\n", cidr)
    err := ip.PrintIPRange(cidr)
    if err != nil {
        fmt.Printf("打印失败: %v\n", err)
    }
}

综合IP管理

// 综合IP信息获取
func comprehensiveIPInfo() {
    fmt.Println("=== 综合IP信息获取 ===")
    
    // 1. 公网IPv4
    fmt.Println("\n1. 公网IPv4地址:")
    publicIPv4, err := ip.GetPublicIpv4()
    if err != nil {
        fmt.Printf("   获取失败: %v\n", err)
    } else {
        fmt.Printf("   ✓ %s\n", publicIPv4)
    }
    
    // 2. 公网IPv6
    fmt.Println("\n2. 公网IPv6地址:")
    publicIPv6, err := ip.GetPublicIpv6()
    if err != nil {
        fmt.Printf("   获取失败: %v\n", err)
    } else {
        for i, ipv6 := range publicIPv6 {
            fmt.Printf("   ✓ IPv6 #%d: %s\n", i+1, ipv6.String())
        }
    }
    
    // 3. 默认网段
    fmt.Println("\n3. 默认网段信息:")
    defaultIPs, err := ip.GetDefaultNetworkSubnet()
    if err != nil {
        fmt.Printf("   获取失败: %v\n", err)
    } else {
        fmt.Printf("   网段大小: %d 个IP\n", len(defaultIPs))
        if len(defaultIPs) > 0 {
            fmt.Printf("   网络地址: %s\n", defaultIPs[0].String())
            fmt.Printf("   广播地址: %s\n", defaultIPs[len(defaultIPs)-1].String())
        }
    }
    
    // 4. 本地IPv6
    fmt.Println("\n4. 本地IPv6地址:")
    localIPv6, err := ip.GetIpv6()
    if err != nil {
        fmt.Printf("   获取失败: %v\n", err)
    } else {
        for i, ipv6 := range localIPv6 {
            fmt.Printf("   ✓ IPv6 #%d: %s\n", i+1, ipv6.String())
        }
    }
}

网络扫描准备

// 为网络扫描准备IP列表
func prepareNetworkScan() {
    // 获取默认网段
    defaultIPs, err := ip.GetDefaultNetworkSubnet()
    if err != nil {
        fmt.Printf("获取默认网段失败: %v\n", err)
        return
    }
    
    fmt.Printf("准备扫描 %d 个IP地址\n", len(defaultIPs))
    
    // 可以将IP列表传递给其他模块进行扫描
    // 比如传递给ARP扫描器或端口扫描器
    
    // 示例：过滤特定IP范围
    scanTargets := []net.IP{}
    for _, ipAddr := range defaultIPs {
        // 排除网络地址和广播地址
        if ipAddr.String() != defaultIPs[0].String() && 
           ipAddr.String() != defaultIPs[len(defaultIPs)-1].String() {
            scanTargets = append(scanTargets, ipAddr)
        }
    }
    
    fmt.Printf("实际可扫描IP数量: %d\n", len(scanTargets))
    
    // 显示前10个扫描目标
    for i, target := range scanTargets {
        if i < 10 {
            fmt.Printf("  扫描目标 #%d: %s\n", i+1, target.String())
        } else {
            break
        }
    }
}

🔧 配置说明

IP范围限制

• 最大支持4096个IP地址的生成
• 超过限制会返回错误以保护系统性能
• 建议合理设置CIDR范围

公网IP获取策略

• 多个API服务依次尝试
• 支持绑定到特定网卡的HTTP客户端
• 3秒超时设置，避免长时间等待

IPv6筛选规则

• 排除回环地址 (127.0.0.1, ::1)
• 排除链路本地地址 (fe80::/10)
• 排除临时地址 (2001:db8::/32)
• 只保留公网地址 (240.0.0.0/4)

⚠️ 注意事项

1. 网络权限:

   • 获取公网IP需要网络连接
   • 某些网络环境可能限制外部API访问

2. API依赖:

   • 公网IP获取依赖外部API服务
   • API服务可用性可能影响获取成功率

3. 性能考虑:

   • 大范围IP生成可能消耗较多内存
   • 建议控制CIDR范围大小

4. IPv6支持:

   • IPv6功能可能在某些系统上不可用
   • 需要系统支持IPv6协议栈

5. 并发安全:

   • IP模块不是并发安全的
   • 多线程使用需要适当的同步机制

📊 API参考

主要函数

IPManager方法

🔗 相关模块

• eth - 网络接口管理
• arp - ARP协议支持
• detect - 综合网络检测
• gns - 核心网络工具集成

📖 相关文档

• 主项目文档
• 网络接口文档
• 网络检测文档
• API参考文档

💡 使用技巧

1. API容错: 利用多个API服务提高公网IP获取成功率
2. 范围控制: 合理设置CIDR范围，避免过大范围影响性能
3. IPv6过滤: 理解IPv6地址筛选规则，获得准确的公网地址
4. 网络诊断: 结合本地网段信息进行网络故障诊断
5. 扫描准备: 使用IP范围功能为网络扫描准备目标列表