fritzbox_dyndns/main.go

package main

import (
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"os/signal"
	"strings"
	"syscall"
	"time"

	"github.com/miekg/dns"
)

type DB map[string]dns_entry

var D map[string]dns_entry

type dns_entry struct {
	Dns      string `json:"dns"`
	Ipv4     string `json:"ipv4"`
	Ipv6     string `json:"ipv6"`
	User     string `json:"user"`
	Token    string `json:"token"`
	LastSeen string `json:"lastseen"`
}

// Daten in eine Datei schreiben
func writeToFile(filename string, data DB) error {
	// JSON konvertieren
	jsonData, err := json.MarshalIndent(data, "", "  ")
	if err != nil {
		fmt.Println("Fehler beim Serialisieren: ", err)
		return err
	}

	// Datei öffnen/erstellen
	err = os.WriteFile(filename, jsonData, 0644)
	if err != nil {
		fmt.Println("Fehler beim Schreiben der Datei: ", err)
		return err
	}

	return nil
}

// Daten aus einer Datei lesen
func readFromFile(filename string) (DB, error) {
	// Datei lesen
	jsonData, err := os.ReadFile(filename)
	if err != nil {
		fmt.Println("Fehler beim Lesen der Datei: ", err)
		return nil, err
	}

	// JSON in DB parsen
	var data DB
	err = json.Unmarshal(jsonData, &data)
	if err != nil {
		fmt.Println("Fehler beim Parsen von JSON: ", err)
		return nil, err
	}

	return data, nil
}

// HashToken hashes a token using SHA-256.
func HashToken(token string) string {
	hash := sha256.Sum256([]byte(token))
	return hex.EncodeToString(hash[:])
}

// VerifyToken compares a plaintext token with a stored hash.
func VerifyToken(token, storedHash string) bool {
	return HashToken(token) == storedHash
}

func handler(w http.ResponseWriter, r *http.Request) {
	Dns := r.URL.Query().Get("DDNS")
	Ip := r.URL.Query().Get("IP")
	Ip6 := r.URL.Query().Get("IPv6")
	User := r.URL.Query().Get("USER")
	Token := r.URL.Query().Get("TOKEN")

	if D == nil {
		D = make(map[string]dns_entry)
	}

	if strings.EqualFold(Dns, "") || strings.EqualFold(Ip, "") || strings.EqualFold(User, "") || strings.EqualFold(Token, "") {
		/* strings.ToLower(Dns) != strings.ToLower("") && strings.ToLower(Ip) != strings.ToLower("") && strings.ToLower(User) != strings.ToLower("") && strings.ToLower(Token) != strings.ToLower("")*/
		fmt.Println("Eintrag unvollständig: ", D[Dns])
		w.WriteHeader(200)
		w.Write([]byte("nochg"))

	} else {

		if entry, exists := D[Dns+"."]; exists {
			if User == entry.User && VerifyToken(Token, entry.Token) {
				D[Dns+"."] = dns_entry{Dns: Dns, Ipv4: Ip, Ipv6: Ip6, User: User, Token: entry.Token, LastSeen: time.Now().String()}
				fmt.Println("Eintrag aktualisiert: ", entry, D[Dns+"."])
				// Datei speichern
				filename := "data/data.json"
				err := writeToFile(filename, D)
				if err != nil {
					fmt.Println("Fehler beim Schreiben:", err)
					return
				}
				fmt.Println("Daten erfolgreich in Datei geschrieben.")
				w.WriteHeader(200)
				w.Write([]byte("good"))
			} else {
				fmt.Println("Eintrag aktualisieren abgelehnt (Benutzer/Passwort ungültig): ", entry, D[Dns])
				w.WriteHeader(200)
				w.Write([]byte("nochg"))
			}
		} else {
			D[Dns+"."] = dns_entry{Dns: Dns, Ipv4: Ip, Ipv6: Ip6, User: User, Token: HashToken(Token), LastSeen: time.Now().String()}
			fmt.Println("Eintrag erstellt: ", entry, D[Dns+"."])
			// Datei speichern
			filename := "data/data.json"
			err := writeToFile(filename, D)
			if err != nil {
				fmt.Println("Fehler beim Schreiben:", err)
				return
			}
			fmt.Println("Daten erfolgreich in Datei geschrieben.")
			w.WriteHeader(200)
			w.Write([]byte("good"))
		}
	}

}

func handlerIP(w http.ResponseWriter, r *http.Request) {

}

func handleDNSRequest(w dns.ResponseWriter, r *dns.Msg) {
	// Bereite die Antwort vor
	msg := new(dns.Msg)
	msg.SetReply(r)
	msg.Authoritative = true

	// Durchlaufe alle Fragen in der Anfrage
	for _, q := range r.Question {
		switch q.Qtype {
		case dns.TypeA: // IPv4-Anfrage
			ip, exists := D[q.Name]
			if exists {
				rr, err := dns.NewRR(q.Name + " A " + ip.Ipv4)
				if err == nil {
					fmt.Println("Antwort (IPv4):", rr, q.Name)
					msg.Answer = append(msg.Answer, rr)
				} else {
					fmt.Println("Fehler beim Erstellen der Antwort (4):", err)
				}
			}
		case dns.TypeAAAA: // IPv6-Anfrage
			// Beispielhafte IPv6-Adresse für Demonstration
			ip, exists := D[q.Name]
			if exists && !strings.EqualFold(ip.Ipv6, "") {
				rr, err := dns.NewRR(q.Name + " AAAA " + ip.Ipv6)
				if err == nil {
					fmt.Println("Antwort (IPv6):", rr, q.Name)
					msg.Answer = append(msg.Answer, rr)
				} else {
					fmt.Println("Fehler beim Erstellen der Antwort (6):", err)
				}
			}
		default:
			// Ignoriere nicht unterstützte Typen
		}
	}

	// Antwort senden
	w.WriteMsg(msg)
}

func prepareExit() {
	fmt.Println("Running exit tasks...")

	fmt.Println("Exit completed.")
}

func StopServer(e error) {
	fmt.Println("Stopping server...")
	prepareExit()
	fmt.Println("Server stopped!")
}

func main() {

	HTTP_PORT := os.Getenv("HTTP_PORT")
	HTTP_TLS := os.Getenv("HTTP_TLS") /* 1/0 */
	HTTP_TLS_PRIVATEKEY := os.Getenv("HTTP_TLS_PRIVATEKEY")
	HTTP_TLS_CERTIFICATE := os.Getenv("HTTP_TLS_CERTIFICATE")

	if strings.EqualFold(HTTP_TLS, "") || strings.EqualFold(HTTP_PORT, "") || strings.EqualFold(HTTP_TLS_PRIVATEKEY, "") || strings.EqualFold(HTTP_TLS_CERTIFICATE, "") {
		fmt.Println("No port or mode defined. Fallback to TLS=0 & Port=8080")
		fmt.Println("ENV's: [HTTP_PORT=8080|443], [HTTP_TLS=0|1],[HTTP_TLS_PRIVATEKEY=#],[HTTP_TLS_CERTIFICATE=#]")
		fmt.Println("Remember to set unused ENVs like [HTTP_TLS_PRIVATEKEY] or [HTTP_TLS_CERTIFICATE] to '#'")
		HTTP_PORT = "8080"
		HTTP_TLS = "0"
		HTTP_TLS_CERTIFICATE = ""
		HTTP_TLS_PRIVATEKEY = ""
	} else {
		fmt.Println("Port and mode defined.")
	}

	// Signal-Kanal einrichten
	stop := make(chan os.Signal, 1)
	signal.Notify(stop, syscall.SIGINT, syscall.SIGTERM)

	// Goroutine, die auf Signale wartet
	go func() {
		<-stop
		fmt.Println("Received stop signal")
		prepareExit()
		os.Exit(0)
	}()

	D = make(map[string]dns_entry)
	// Datei lesen
	filename := "data/data.json"
	readData, err := readFromFile(filename)
	if err != nil {
		fmt.Println("Fehler beim Lesen:", err)
	} else {
		fmt.Println("Daten erfolgreich aus Datei gelesen.")
		D = readData
	}

	http.HandleFunc("/", handler)
	http.HandleFunc("/ip", handlerIP)

	/* DNS-PART */

	dns.HandleFunc(".", handleDNSRequest)

	serverUDP := &dns.Server{Addr: ":53", Net: "udp"}
	go func() {
		log.Println("Starting DNS server on UDP :53")
		if err := serverUDP.ListenAndServe(); err != nil {
			log.Fatalf("Failed to start UDP server: %v", err)
		}
	}()

	serverTCP := &dns.Server{Addr: ":53", Net: "tcp"}
	go func() {
		log.Println("Starting DNS server on TCP :53")
		if err := serverTCP.ListenAndServe(); err != nil {
			log.Fatalf("Failed to start TCP server: %v", err)
		}
	}()

	/* HTTP-PART */

	fmt.Println("Server listening on port :" + HTTP_PORT)
	if HTTP_TLS == "0" {
		fmt.Println("Protocol is http (insecure)")
		StopServer(http.ListenAndServe(":"+HTTP_PORT, nil))
	}
	if HTTP_TLS == "1" {
		fmt.Println("Protocol is https (secure)")
		StopServer(http.ListenAndServeTLS(":"+HTTP_PORT, HTTP_TLS_CERTIFICATE, HTTP_TLS_PRIVATEKEY, nil))
	}

	/*srv_err := http.ListenAndServe(":8080", nil)
	if srv_err != nil {
		fmt.Println("Starten des Servers fehlgeschlagen!", srv_err)
	}*/
}