-
Notifications
You must be signed in to change notification settings - Fork 16
/
OXID.go
102 lines (86 loc) · 2.22 KB
/
OXID.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
package main
import (
"bytes"
"encoding/hex"
"flag"
"fmt"
"net"
"sync"
"time"
)
var (
buffer1, _ = hex.DecodeString("05000b03100000004800000001000000b810b810000000000100000000000100c4fefc9960521b10bbcb00aa0021347a00000000045d888aeb1cc9119fe808002b10486002000000")
buffer2, _ = hex.DecodeString("050000031000000018000000010000000000000000000500")
begin, _ = hex.DecodeString("0700")
end, _ = hex.DecodeString("00000900")
)
func getAddres(ip string, timeout time.Duration) {
conn, err := net.DialTimeout("tcp", ip+":135", time.Second*timeout)
if err != nil {
return
}
defer conn.Close()
conn.SetDeadline(time.Now().Add(time.Second * timeout))
conn.Write(buffer1)
reply := make([]byte, 1024)
if n, err := conn.Read(reply); err != nil || n != 60 {
return
}
conn.Write(buffer2)
n, err := conn.Read(reply)
if err != nil || n == 0 {
return
}
start := bytes.Index(reply, begin)
last := bytes.LastIndex(reply, end)
datas := bytes.Split(reply[start:last], begin)
fmt.Println("--------------------------------------\r\n[*] Retrieving network interface of", ip)
for i := range datas {
if i < 2 {
continue
}
address := bytes.ReplaceAll(datas[i], []byte{0}, []byte{})
fmt.Println("Address:", string(address))
}
}
func incIP(ip net.IP) {
for j := len(ip) - 1; j >= 0; j-- {
ip[j]++
if ip[j] > 0 {
break
}
}
}
func main() {
host := flag.String("i", "", "single ip address")
thread := flag.Int("t", 2000, "thread num")
timeout := flag.Duration("time", 2, "timeout on connection, in seconds")
netCIDR := flag.String("n", "", "CIDR notation of a network")
flag.Parse()
if *host == "" && *netCIDR == "" {
flag.Usage()
}
if *host != "" {
getAddres(*host, *timeout)
return
}
c := make(chan struct{}, *thread)
if *netCIDR != "" && *host == "" {
ip, ipNet, err := net.ParseCIDR(*netCIDR)
if err != nil {
fmt.Println("invalid CIDR")
return
}
var wg sync.WaitGroup
for ip := ip.Mask(ipNet.Mask); ipNet.Contains(ip); incIP(ip) {
wg.Add(1)
go func(ip string) {
c <- struct{}{}
defer wg.Done()
getAddres(ip, *timeout)
<-c
}(ip.String())
}
wg.Wait()
}
}