134 lines
3.5 KiB
Go
134 lines
3.5 KiB
Go
package scan
|
|
|
|
import (
|
|
"bufio"
|
|
"fmt"
|
|
"net"
|
|
"net/netip"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
var (
|
|
reIPv4 = regexp.MustCompile(`^((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$`)
|
|
reIPv4Range = regexp.MustCompile(`^((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)-((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$`)
|
|
reCIDR = regexp.MustCompile(`^((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)/(0?[0-9]|1[0-9]|2[0-9]|3[0-2])$`)
|
|
reIPv6 = regexp.MustCompile(`^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$`)
|
|
reDomain = regexp.MustCompile(`^([a-zA-Z0-9]+(-[a-zA-Z0-9]+)*\.)+[a-zA-Z]{2,}$`)
|
|
rePort = regexp.MustCompile(`^(0|[1-9][0-9]{0,3}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5])$`)
|
|
)
|
|
|
|
func ParseIPs(text string) ([]string, error) {
|
|
var ips []string
|
|
sc := bufio.NewScanner(strings.NewReader(text))
|
|
for sc.Scan() {
|
|
line := strings.TrimSpace(sc.Text())
|
|
if line == "" {
|
|
continue
|
|
}
|
|
switch {
|
|
case reIPv4.MatchString(line):
|
|
ips = append(ips, line)
|
|
case reIPv4Range.MatchString(line):
|
|
parts := strings.SplitN(line, "-", 2)
|
|
a, err := netip.ParseAddr(parts[0])
|
|
if err != nil {
|
|
return nil, fmt.Errorf("无效IP段: %s", line)
|
|
}
|
|
b, err := netip.ParseAddr(parts[1])
|
|
if err != nil {
|
|
return nil, fmt.Errorf("无效IP段: %s", line)
|
|
}
|
|
ai := a.As4()
|
|
bi := b.As4()
|
|
aInt := uint32(ai[0])<<24 | uint32(ai[1])<<16 | uint32(ai[2])<<8 | uint32(ai[3])
|
|
bInt := uint32(bi[0])<<24 | uint32(bi[1])<<16 | uint32(bi[2])<<8 | uint32(bi[3])
|
|
if aInt > bInt {
|
|
aInt, bInt = bInt, aInt
|
|
}
|
|
for i := aInt; i <= bInt; i++ {
|
|
ip := netip.AddrFrom4([4]byte{byte(i >> 24), byte(i >> 16), byte(i >> 8), byte(i)})
|
|
ips = append(ips, ip.String())
|
|
}
|
|
case reCIDR.MatchString(line):
|
|
baseIP, ipNet, err := net.ParseCIDR(line)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("无效CIDR: %s", line)
|
|
}
|
|
if baseIP.To4() == nil {
|
|
return nil, fmt.Errorf("仅支持IPv4 CIDR: %s", line)
|
|
}
|
|
ips = append(ips, cidrIPs(ipNet)...)
|
|
case reIPv6.MatchString(line):
|
|
ips = append(ips, line)
|
|
case reDomain.MatchString(line):
|
|
ips = append(ips, line)
|
|
default:
|
|
return nil, fmt.Errorf("无法识别的目标: %s", line)
|
|
}
|
|
}
|
|
return ips, sc.Err()
|
|
}
|
|
|
|
func cidrIPs(ipNet *net.IPNet) []string {
|
|
var ips []string
|
|
for ip := ipNet.IP.Mask(ipNet.Mask); ipNet.Contains(ip); inc(ip) {
|
|
ips = append(ips, ip.String())
|
|
}
|
|
if len(ips) > 0 {
|
|
ips = ips[1:]
|
|
}
|
|
if len(ips) > 0 {
|
|
ips = ips[:len(ips)-1]
|
|
}
|
|
return ips
|
|
}
|
|
|
|
func inc(ip net.IP) {
|
|
for j := len(ip) - 1; j >= 0; j-- {
|
|
ip[j]++
|
|
if ip[j] > 0 {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
func ParsePorts(text string) ([]int, error) {
|
|
var ports []int
|
|
sc := bufio.NewScanner(strings.NewReader(text))
|
|
for sc.Scan() {
|
|
line := strings.TrimSpace(sc.Text())
|
|
if line == "" {
|
|
continue
|
|
}
|
|
for _, seg := range strings.Split(line, ";") {
|
|
seg = strings.TrimSpace(seg)
|
|
if seg == "" {
|
|
continue
|
|
}
|
|
if strings.Contains(seg, "-") {
|
|
parts := strings.SplitN(seg, "-", 2)
|
|
a, err1 := strconv.Atoi(strings.TrimSpace(parts[0]))
|
|
b, err2 := strconv.Atoi(strings.TrimSpace(parts[1]))
|
|
if err1 != nil || err2 != nil || a < 0 || a > 65535 || b < 0 || b > 65535 {
|
|
return nil, fmt.Errorf("无效端口范围: %s", seg)
|
|
}
|
|
if a > b {
|
|
a, b = b, a
|
|
}
|
|
for p := a; p <= b; p++ {
|
|
ports = append(ports, p)
|
|
}
|
|
} else {
|
|
if !rePort.MatchString(seg) {
|
|
return nil, fmt.Errorf("无效端口: %s", seg)
|
|
}
|
|
p, _ := strconv.Atoi(seg)
|
|
ports = append(ports, p)
|
|
}
|
|
}
|
|
}
|
|
return ports, sc.Err()
|
|
}
|