final client

main.go

@@ -1,88 +1,210 @@
+// 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"
 )
 
-// ---------- Linux ----------
+type iaidInfo struct {
+	Source string // Pfad oder Registry-Key
+	IAID   uint32
+}
 
-func duidsLinux() (map[string][]byte, error) {
+// ---------- 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",
 	}
-	out := map[string][]byte{}
+	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
 			}
-
-			// lease/duid files are small, read entire file
 			buf, err := os.ReadFile(path)
 			if err != nil {
 				return nil
 			}
-
+			if duid := extractDUID(buf); len(duid) > 0 {
-			duid := extractDUID(buf)
+				out = append(out, duid)
-			if len(duid) > 0 {
-				out[path] = duid
 			}
 			return nil
 		})
 	}
 	if len(out) == 0 {
-		return nil, errors.New("keine DUID-Datei gefunden")
+		return nil, errors.New("keine DUID gefunden")
 	}
 	return out, nil
 }
 
-// very tolerant parser: tries common patterns
-func extractDUID(b []byte) []byte {
-	// Pattern „default-duid "\x00\x03\x00\x01\xaa…"“
-	if bytes.Contains(b, []byte("default-duid")) || bytes.Contains(b, []byte("dhclient.duid")) {
-		start := bytes.IndexByte(b, '"')
-		end := bytes.LastIndexByte(b, '"')
-		if start >= 0 && end > start {
-			hexEsc := b[start+1 : end]
-			hexEsc = bytes.ReplaceAll(hexEsc, []byte(`\x`), nil)
-			duid, _ := hex.DecodeString(string(hexEsc))
-			return duid
-		}
-	}
-	// systemd-networkd file: plain hex without 0x
-	if allHex(b) {
-		duid, _ := hex.DecodeString(strings.TrimSpace(string(b)))
-		return duid
-	}
-	return nil
-}
-
-func allHex(b []byte) bool {
-	for _, c := range bytes.TrimSpace(b) {
-		if !strings.ContainsRune("0123456789abcdefABCDEF", rune(c)) {
-			return false
-		}
-	}
-	return true
-}
-
 // ---------- Windows ----------
-
+func duidsWindows() ([][]byte, error) {
-func duidsWindows() (map[string][]byte, error) {
 	k, err := registry.OpenKey(registry.LOCAL_MACHINE,
 		`SYSTEM\CurrentControlSet\Services\Tcpip6\Parameters`,
 		registry.READ)
@@ -95,35 +217,91 @@ func duidsWindows() (map[string][]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-	return map[string][]byte{"registry": val}, nil
+	return [][]byte{val}, nil
 }
 
-// ---------- macOS (scutil) ----------
+// ---------- Hilfsfunktionen ----------
-// (Beispielskizze – nicht implementiert)
+func extractDUID(b []byte) []byte {
-// func duidsDarwin() ...
+	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 duids map[string][]byte
+	var raw [][]byte
+	var all []iaidInfo
 	var err error
-
+	var err1 error
 	switch runtime.GOOS {
 	case "windows":
-		duids, err = duidsWindows()
+		raw, err = duidsWindows()
-	default: // linux, darwin, ...
+		all, err1 = iaidsWindows()
-		duids, err = duidsLinux()
+	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, "Fehler:", err)
+		fmt.Fprintln(os.Stderr, "HTTP-Fehler:", err)
 		os.Exit(1)
 	}
-
+	defer resp.Body.Close()
-	hostName, _ := os.Hostname()
+	fmt.Println("Server-Antwort:", resp.Status)
-
-	for _, d := range duids {
-		fmt.Printf("%s", hex.EncodeToString(d))
-		fmt.Printf("%s", hostName)
-	}
 }