308 lines
7.3 KiB
Go
308 lines
7.3 KiB
Go
// client.go
|
|
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"encoding/binary"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io/fs"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"regexp"
|
|
"runtime"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"golang.org/x/sys/windows/registry"
|
|
)
|
|
|
|
type iaidInfo struct {
|
|
Source string // Pfad oder Registry-Key
|
|
IAID uint32
|
|
}
|
|
|
|
// ---------- Linux ----------
|
|
var (
|
|
reDhclientIAID = regexp.MustCompile(`\biaid\s+(\d+);`) // dhclient, NM
|
|
reKVIAID = regexp.MustCompile(`^IAID=(\d+)`) // systemd-networkd
|
|
)
|
|
|
|
func iaidsLinux() ([]iaidInfo, error) {
|
|
candidates := []string{
|
|
"/var/lib/NetworkManager",
|
|
"/var/lib/dhclient", // manche Distros
|
|
"/run/systemd/netif/leases", // systemd-networkd
|
|
"/var/lib/dhcpcd", "/var/lib/dhcpcd5",
|
|
}
|
|
|
|
var out []iaidInfo
|
|
|
|
visit := func(path string, d fs.DirEntry, err error) error {
|
|
if err != nil || d.IsDir() {
|
|
return nil
|
|
}
|
|
f, err := os.Open(path)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
defer f.Close()
|
|
|
|
sc := bufio.NewScanner(f)
|
|
for sc.Scan() {
|
|
line := sc.Text()
|
|
|
|
if m := reDhclientIAID.FindStringSubmatch(line); len(m) == 2 {
|
|
if v, _ := strconv.ParseUint(m[1], 10, 32); v != 0 {
|
|
out = append(out, iaidInfo{path, uint32(v)})
|
|
break
|
|
}
|
|
}
|
|
if m := reKVIAID.FindStringSubmatch(line); len(m) == 2 {
|
|
if v, _ := strconv.ParseUint(m[1], 10, 32); v != 0 {
|
|
out = append(out, iaidInfo{path, uint32(v)})
|
|
break
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
for _, dir := range candidates {
|
|
_ = filepath.WalkDir(dir, visit)
|
|
}
|
|
if len(out) == 0 {
|
|
return nil, fmt.Errorf("keine IAID-Datei gefunden (root-Rechte?)")
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// ---------- Windows ----------
|
|
/*func iaidsWindows() ([]iaidInfo, error) {
|
|
base := `SYSTEM\CurrentControlSet\Services\Tcpip6\Parameters\Interfaces`
|
|
root, err := registry.OpenKey(registry.LOCAL_MACHINE, base, registry.READ)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer root.Close()
|
|
|
|
names, _ := root.ReadSubKeyNames(-1)
|
|
var out []iaidInfo
|
|
|
|
for _, n := range names {
|
|
k, err := registry.OpenKey(root, n, registry.READ)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
val, _, err := k.GetIntegerValue("IAID")
|
|
k.Close()
|
|
if err == nil {
|
|
out = append(out, iaidInfo{
|
|
Source: base + `\` + n + `\IAID`,
|
|
IAID: uint32(val),
|
|
})
|
|
}
|
|
}
|
|
if len(out) == 0 {
|
|
return nil, fmt.Errorf("kein IAID-Wert in der Registry")
|
|
}
|
|
return out, nil
|
|
}*/
|
|
|
|
func iaidsWindows() ([]iaidInfo, error) {
|
|
const base = `SYSTEM\CurrentControlSet\Services\Tcpip6\Parameters\Interfaces`
|
|
|
|
root, err := registry.OpenKey(registry.LOCAL_MACHINE, base, registry.READ)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer root.Close()
|
|
|
|
var out []iaidInfo
|
|
|
|
guidKeys, _ := root.ReadSubKeyNames(-1)
|
|
for _, g := range guidKeys {
|
|
k, err := registry.OpenKey(root, g, registry.READ)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
if v, _, err := k.GetIntegerValue("Dhcpv6Iaid"); err == nil {
|
|
out = append(out, iaidInfo{Source: base + `\` + g, IAID: uint32(v)})
|
|
k.Close()
|
|
continue
|
|
}
|
|
|
|
// --- Fallback: MAC → IAID (letzte 3 Bytes), falls DWORD fehlt ---
|
|
if mac, _, err := k.GetBinaryValue("NetworkAddress"); err == nil && len(mac) >= 6 {
|
|
iaid := uint32(mac[3])<<16 | uint32(mac[4])<<8 | uint32(mac[5])
|
|
out = append(out, iaidInfo{Source: base + `\` + g + " (computed)", IAID: iaid})
|
|
}
|
|
k.Close()
|
|
}
|
|
if len(out) == 0 {
|
|
return nil, fmt.Errorf("weder Dhcpv6Iaid noch MAC-basierten Fallback gefunden - nutzt der Client überhaupt DHCPv6?")
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// ---------- Fallback: IAID selbst ableiten (MAC → 3 Byte) ----------
|
|
func iaidFromMAC(mac []byte, ifindex int) uint32 {
|
|
if len(mac) >= 3 {
|
|
return binary.BigEndian.Uint32([]byte{0, mac[len(mac)-3], mac[len(mac)-2], mac[len(mac)-1]})
|
|
}
|
|
// Notlösung: Interface-Index + 0xA0 im obersten Byte
|
|
return uint32(0xA0000000 | (ifindex & 0x00FFFFFF))
|
|
}
|
|
|
|
/*######################################################################################################*/
|
|
/*######################################################################################################*/
|
|
/*######################################################################################################*/
|
|
/*######################################################################################################*/
|
|
/*######################################################################################################*/
|
|
|
|
// ---------- Datentyp, der an den Server geschickt wird ----------
|
|
type payload struct {
|
|
Hostname string `json:"hostname"`
|
|
DUIDs []string `json:"duids"` // hex-codiert
|
|
IAIDs []uint32
|
|
}
|
|
|
|
// ---------- Linux ----------
|
|
func duidsLinux() ([][]byte, error) {
|
|
candidates := []string{
|
|
"/var/lib/NetworkManager",
|
|
"/var/lib/dhcp",
|
|
"/var/lib/systemd/network",
|
|
"/run/systemd/netif/leases",
|
|
}
|
|
var out [][]byte
|
|
for _, dir := range candidates {
|
|
_ = filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
|
|
if err != nil || d.IsDir() {
|
|
return nil
|
|
}
|
|
buf, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
if duid := extractDUID(buf); len(duid) > 0 {
|
|
out = append(out, duid)
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
if len(out) == 0 {
|
|
return nil, errors.New("keine DUID gefunden")
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// ---------- Windows ----------
|
|
func duidsWindows() ([][]byte, error) {
|
|
k, err := registry.OpenKey(registry.LOCAL_MACHINE,
|
|
`SYSTEM\CurrentControlSet\Services\Tcpip6\Parameters`,
|
|
registry.READ)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer k.Close()
|
|
|
|
val, _, err := k.GetBinaryValue("Dhcpv6DUID")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return [][]byte{val}, nil
|
|
}
|
|
|
|
// ---------- Hilfsfunktionen ----------
|
|
func extractDUID(b []byte) []byte {
|
|
if idx := bytes.Index(b, []byte("default-duid")); idx >= 0 {
|
|
start := bytes.IndexByte(b[idx:], '"') + idx + 1
|
|
end := bytes.IndexByte(b[start:], '"') + start
|
|
hexEsc := bytes.ReplaceAll(b[start:end], []byte(`\x`), nil)
|
|
duid, _ := hex.DecodeString(string(hexEsc))
|
|
return duid
|
|
}
|
|
hexOnly := strings.TrimSpace(string(b))
|
|
if len(hexOnly) >= 28 && allHex(hexOnly) { // plausibel?
|
|
duid, _ := hex.DecodeString(hexOnly)
|
|
return duid
|
|
}
|
|
return nil
|
|
}
|
|
func allHex(s string) bool {
|
|
for _, c := range s {
|
|
if !strings.ContainsRune("0123456789abcdefABCDEF", c) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// ---------- main ----------
|
|
func main() {
|
|
var raw [][]byte
|
|
var all []iaidInfo
|
|
var err error
|
|
var err1 error
|
|
switch runtime.GOOS {
|
|
case "windows":
|
|
raw, err = duidsWindows()
|
|
all, err1 = iaidsWindows()
|
|
default:
|
|
raw, err = duidsLinux()
|
|
all, err1 = iaidsLinux()
|
|
}
|
|
if err != nil {
|
|
fmt.Fprintln(os.Stderr, err)
|
|
}
|
|
|
|
if err1 != nil {
|
|
fmt.Fprintln(os.Stderr, err1)
|
|
}
|
|
|
|
for _, ia := range all {
|
|
fmt.Printf("%-60s 0x%08x (%d)\n", ia.Source, ia.IAID, ia.IAID)
|
|
}
|
|
|
|
var gh []uint32
|
|
|
|
for _, bh := range all {
|
|
gh = append(gh, bh.IAID)
|
|
}
|
|
|
|
//host, _ := os.Hostname()
|
|
host := "PC1020"
|
|
p := payload{
|
|
Hostname: host,
|
|
DUIDs: make([]string, len(raw)),
|
|
IAIDs: gh,
|
|
}
|
|
for i, d := range raw {
|
|
p.DUIDs[i] = hex.EncodeToString(d)
|
|
}
|
|
|
|
// --- JSON kodieren ---
|
|
body, _ := json.Marshal(p)
|
|
|
|
// --- HTTP senden ---
|
|
url := "http://localhost:8080/register" // <-- ggf. anpassen
|
|
req, _ := http.NewRequest(http.MethodPost, url, bytes.NewReader(body))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
client := &http.Client{Timeout: 5 * time.Second}
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
fmt.Fprintln(os.Stderr, "HTTP-Fehler:", err)
|
|
os.Exit(1)
|
|
}
|
|
defer resp.Body.Close()
|
|
fmt.Println("Server-Antwort:", resp.Status)
|
|
}
|