Try Dualstack Update

main.go

@@ -54,27 +54,33 @@ func main() {
 
 	if blocklistMode == "master" {
 		redisAddr := os.Getenv("REDIS_ADDR")
+		redisPass := os.Getenv("REDIS_PASS")
 		if redisAddr == "" {
 			redisAddr = "localhost:6379"
 		}
 		log.Println("✅ Redis Connection set to:", redisAddr)
 		redisClient = redis.NewClient(&redis.Options{
-			Addr: redisAddr,
-			DB:   0,
+			Addr:     redisAddr,
+			DB:       0,
+			Username: os.Getenv("REDIS_USER"),
+			Password: redisPass,
 		})
 		if err := redisClient.Ping(ctx).Err(); err != nil {
 			log.Fatalf("❌ No connection to redis-server: %v", err)
 		}
 	}
 
-	portsTCP := []string{"135", "139", "445", "389", "636", "3268", "3269", "88", "3389", "3306", "27017", "5432", "25", "123", "5900"}
+	portsTCP := []string{"135", "139", "445", "389", "636", "3268", "3269", "88", "3389", "3306", "27017", "5432", "25", "123", "5900", "143", "993", "1723", "21"}
 	for _, port := range portsTCP {
-		go startTCPListener(port)
+		//go startTCPListener(port)
+		go startTCPListenerWithNet("tcp4", port)
+		go startTCPListenerWithNet("tcp6", port)
 	}
 
 	portsUDP := []string{"135", "137", "138", "389", "3389", "88"}
 	for _, port := range portsUDP {
-		go startUDPListener(port)
+		go startUDPListener("udp4", port)
+		go startUDPListener("udp6", port)
 	}
 
 	http.HandleFunc("/", handleRoot)
@@ -89,7 +95,7 @@ func main() {
 	}
 }
 
-func startTCPListener(port string) {
+/*func startTCPListener(port string) {
 	ln, err := net.Listen("tcp", ":"+port)
 	if err != nil {
 		log.Fatalf("❌ Could not listen on TCP port %s: %v", port, err)
@@ -105,9 +111,51 @@ func startTCPListener(port string) {
 		processIP(ip, port, "TCP", nil)
 		conn.Close()
 	}
+}*/
+
+func startTCPListenerWithNet(network, port string) {
+	ln, err := net.Listen(network, ":"+port)
+	if err != nil {
+		log.Fatalf("❌ Could not listen on %s port %s: %v", network, port, err)
+	}
+	log.Printf("🚀 TCP Honeypot listening on %s port %s", network, port)
+	for {
+		conn, err := ln.Accept()
+		if err != nil {
+			log.Printf("⚠️ Error accepting TCP connection: %v", err)
+			continue
+		}
+		ip, _, _ := net.SplitHostPort(conn.RemoteAddr().String())
+		processIP(ip, port, "TCP", nil)
+		conn.Close()
+	}
 }
 
-func startUDPListener(port string) {
+func startUDPListener(network, port string) {
+	addr := net.UDPAddr{
+		Port: portInt(port),
+		IP:   nil, // nil bedeutet: alle Interfaces (IPv4 oder IPv6 je nach Netzwerktyp)
+	}
+	conn, err := net.ListenUDP(network, &addr)
+	if err != nil {
+		log.Fatalf("❌ Could not listen on %s port %s: %v", network, port, err)
+	}
+	log.Printf("🚀 UDP Honeypot listening on %s port %s", network, port)
+	buf := make([]byte, 1024)
+	for {
+		n, remoteAddr, err := conn.ReadFromUDP(buf)
+		if err != nil {
+			log.Printf("⚠️ Error reading UDP packet: %v", err)
+			continue
+		}
+		if n > 0 {
+			ip := remoteAddr.IP.String()
+			processIP(ip, port, "UDP", nil)
+		}
+	}
+}
+
+/*func startUDPListener(port string) {
 	addr := net.UDPAddr{
 		Port: portInt(port),
 		IP:   net.ParseIP("0.0.0.0"),
@@ -131,6 +179,30 @@ func startUDPListener(port string) {
 	}
 }
 
+func startUDP6Listener(port string) {
+	addr := net.UDPAddr{
+		Port: portInt(port),
+		IP:   net.ParseIP("::"),
+	}
+	conn, err := net.ListenUDP("udp", &addr)
+	if err != nil {
+		log.Fatalf("❌ Could not listen on UDP port %s: %v", port, err)
+	}
+	log.Printf("🚀 UDP Honeypod listening on port %s", port)
+	buf := make([]byte, 1024)
+	for {
+		n, remoteAddr, err := conn.ReadFromUDP(buf)
+		if err != nil {
+			log.Printf("⚠️ Error reading UDP packet: %v", err)
+			continue
+		}
+		if n > 0 {
+			ip := remoteAddr.IP.String()
+			processIP(ip, port, "UDP", nil)
+		}
+	}
+}*/
+
 func handleRoot(w http.ResponseWriter, r *http.Request) {
 	ip := getClientIP(r)
 	if ip == "" {
@@ -175,6 +247,7 @@ func processIP(ip, port, proto string, w http.ResponseWriter) {
 			}
 			return
 		}
+		log.Printf("✅ IP %s relayed with port %s/%s", ipKey, port, proto)
 		defer resp.Body.Close()
 		if w != nil {
 			w.WriteHeader(resp.StatusCode)
@@ -189,15 +262,23 @@ func handleMetrics(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "text/plain")
 	w.Write([]byte(fmt.Sprintf("honeypod_blocked_ips_total %d\n", totalIPs)))
 
+	// Map zum Zählen
+	portHitCounter := make(map[string]int)
+
 	for _, ip := range keys {
 		ports, _ := redisClient.SMembers(ctx, "bl:manual:"+ip).Result()
 		for _, p := range ports {
-			parts := strings.Split(p, "/")
-			if len(parts) == 2 {
-				port, proto := parts[0], parts[1]
-				metricName := fmt.Sprintf("honeypod_port_hits{port=\"%s\",protocol=\"%s\"}", port, proto)
-				w.Write([]byte(metricName + " 1\n")) // hier 1 pro IP/Port-Protokoll
-			}
+			portHitCounter[p]++
+		}
+	}
+
+	// Jetzt pro Port+Proto Metriken ausgeben
+	for p, count := range portHitCounter {
+		parts := strings.Split(p, "/")
+		if len(parts) == 2 {
+			port, proto := parts[0], parts[1]
+			metricName := fmt.Sprintf("honeypod_port_hits{port=\"%s\",protocol=\"%s\"} %d\n", port, proto, count)
+			w.Write([]byte(metricName))
 		}
 	}
 }
@@ -247,6 +328,8 @@ func handleDashboardJSON(w http.ResponseWriter, r *http.Request) {
 
 func getClientIP(r *http.Request) string {
 	xff := r.Header.Get("X-Forwarded-For")
+	xrip := r.Header.Get("X-Real-Ip")
+	log.Printf("X-Forwarded-For: %s, X-Real-Ip: %s, RemoteAddr: %s", xff, xrip, r.RemoteAddr)
 	if xff != "" {
 		parts := strings.Split(xff, ",")
 		ip := strings.TrimSpace(parts[0])
@@ -254,7 +337,7 @@ func getClientIP(r *http.Request) string {
 			return ip
 		}
 	}
-	xrip := r.Header.Get("X-Real-Ip")
+
 	if xrip != "" && isValidIP(xrip) {
 		return xrip
 	}