flux-dns/main.go

package main

import (
	"FluxDNS/database"
	"embed"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"
	"io/fs"
	"net/http"
	"strings"
	"sync"
	"time"
)

//go:embed frontend/dist/*
var staticFiles embed.FS

var l4 string = ""
var l6 string = ""

var LastAddress4 = ""
var LastAddress6 = ""

var (
	loginAttempts = make(map[string]int)
	mu            sync.Mutex
)

// AuthMiddleware is a middleware function that checks for basic authentication
func AuthMiddleware(username, password string, maxAttempts int, lockoutDuration time.Duration) func(http.Handler) http.Handler {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			ip := r.RemoteAddr // Track login attempts by IP address

			mu.Lock()
			attempts := loginAttempts[ip]
			mu.Unlock()

			// If the number of attempts exceeds the max, return a lockout response
			if attempts >= maxAttempts {
				http.Error(w, "Too many failed attempts. Try again later.", http.StatusTooManyRequests)
				return
			}

			auth := r.Header.Get("Authorization")
			if auth == "" {
				w.Header().Set("WWW-Authenticate", `Basic realm="Restricted Access"`)
				http.Error(w, "Unauthorized", http.StatusUnauthorized)
				return
			}

			// Expected format: "Basic <base64-encoded-username:password>"
			const prefix = "Basic "
			if !strings.HasPrefix(auth, prefix) {
				w.Header().Set("WWW-Authenticate", `Basic realm="Restricted Access"`)
				http.Error(w, "Unauthorized", http.StatusUnauthorized)
				return
			}

			// Decode the base64 string
			decoded, err := base64.StdEncoding.DecodeString(auth[len(prefix):])
			if err != nil {
				w.Header().Set("WWW-Authenticate", `Basic realm="Restricted Access"`)
				http.Error(w, "Unauthorized", http.StatusUnauthorized)
				return
			}

			// Split the decoded string into username and password
			creds := strings.SplitN(string(decoded), ":", 2)
			if len(creds) != 2 || creds[0] != username || creds[1] != password {
				mu.Lock()
				loginAttempts[ip]++
				mu.Unlock()

				// Reset the attempt counter after lockout duration
				go func() {
					time.Sleep(lockoutDuration)
					mu.Lock()
					delete(loginAttempts, ip)
					mu.Unlock()
				}()

				w.Header().Set("WWW-Authenticate", `Basic realm="Restricted Access"`)
				http.Error(w, "Unauthorized", http.StatusUnauthorized)
				return
			}

			// Clear failed attempts on successful login
			mu.Lock()
			delete(loginAttempts, ip)
			mu.Unlock()

			// Call the next handler if authenticated
			next.ServeHTTP(w, r)
		})
	}
}

func main() {

	Start()

	username := "admin"    // Load from env
	password := "password" // Load from env
	maxAttempts := 3
	lockoutDuration := 1 * time.Minute

	mux := http.NewServeMux()

	// Create a subdirectory to strip the "static" prefix
	subFS, err := fs.Sub(staticFiles, "frontend/dist")
	if err != nil {
		panic(err) // Handle error appropriately in production code
	}

	// Serve the embedded static files without the "static" prefix
	fileServer := http.FileServer(http.FS(subFS))
	mux.Handle("/", fileServer)

	// Database
	db := database.Create("./database.json")

	l4 = db.GetIPv4Address()
	l6 = db.GetIPv6Address()

	// API - Add Entry
	mux.HandleFunc("/api/add-entry", func(w http.ResponseWriter, r *http.Request) {
		// Ensure the request method is POST
		if r.Method != http.MethodPost {
			http.Error(w, "Invalid request method", http.StatusMethodNotAllowed)
			return
		}

		// Read the body of the request
		body, err := io.ReadAll(r.Body)
		if err != nil {
			http.Error(w, "Failed to read request body", http.StatusBadRequest)
			return
		}
		defer r.Body.Close()

		fmt.Println(string(body))

		// Parse the JSON
		var entry database.DatabaseDataDDNSEntry
		var entryData database.DatabaseDataDDNSEntryProviderDataCloudflare

		if err := json.Unmarshal(body, &entry); err != nil {
			http.Error(w, "Failed to parse JSON", http.StatusBadRequest)
			return
		}

		dat, err := json.Marshal(entry.ProviderData)
		if err != nil {
			panic(err)
		}

		if err := json.Unmarshal(dat, &entryData); err != nil {
			panic(err)
		}
		entry.ProviderData = entryData

		// Print the received data (or handle it as needed)
		fmt.Printf("Received entry: %+v\n", entry)

		// Save
		db.AddEntry(entry)

		// Respond with a success message
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusOK)
		w.Write([]byte(`{"success": true}`))
	})

	// API - Get Addresses
	mux.HandleFunc("/api/get-addresses", func(w http.ResponseWriter, r *http.Request) {

		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusOK)
		w.Write([]byte(fmt.Sprintf(`{"ipv4": "%s","ipv6": "%s"}`, LastAddress4, LastAddress6)))
	})

	// API - Get Entries
	mux.HandleFunc("/api/get-entries", func(w http.ResponseWriter, r *http.Request) {

		// Define the struct
		type Ent struct {
			Provider string `json:"provider"`
			Record   string `json:"record"`
		}

		// Fill the ents slice with data from entries
		dat := db.GetEntries()

		var ents []Ent
		for _, entry := range dat {

			ents = append(ents, Ent{
				Provider: entry.Provider,
				Record:   entry.Record,
			})
		}

		// Convert the ents slice to JSON and write it to the response
		w.Header().Set("Content-Type", "application/json")
		if err := json.NewEncoder(w).Encode(ents); err != nil {
			http.Error(w, "Failed to encode entries", http.StatusInternalServerError)
			return
		}
	})

	// API - Delete Record
	mux.HandleFunc("/api/delete-record", func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodPost {
			http.Error(w, "Invalid request method", http.StatusMethodNotAllowed)
			return
		}

		// Parse JSON from the request body
		var requestData struct {
			RecordName string `json:"recordName"`
			Provider   string `json:"provider"`
		}

		err := json.NewDecoder(r.Body).Decode(&requestData)
		if err != nil {
			http.Error(w, "Failed to parse request body", http.StatusBadRequest)
			return
		}
		defer r.Body.Close()

		// Find and remove the entry

		err = db.DeleteEntry(requestData.RecordName)

		if err == nil {
			w.WriteHeader(http.StatusOK)
			w.Write([]byte(`{"message": "Record deleted successfully"}`))
		} else {
			http.Error(w, "Record not found", http.StatusNotFound)
		}
	})

	// Update
	go func(l4, l42, l6, l62 *string) {
		time.Sleep(5 * time.Second)
		for true {
			entries := db.GetEntries()
			if *l4 != *l42 {
				*l4 = *l42

				err = db.SetIPv4Address(*l4)

				if err != nil {
					panic(err)
				}

				for _, entry := range entries {
					if entry.Provider == "Cloudflare" {
						// Assert that entry.Data is of type CloudflareData
						data, ok := entry.ProviderData.(database.DatabaseDataDDNSEntryProviderDataCloudflare)
						if !ok {
							fmt.Println("ERROR")
							continue
						}

						fmt.Println("4")
						err := OverwriteDNSRecord(data.APIToken, data.ZoneID, entry.Record, "A", *l4, 1)
						if err != nil {
							fmt.Println(err)
						} else {
							db.UpdateEntry(entry.Record)
						}
					}
				}

			}

			if *l6 != *l62 {
				*l6 = *l62
				db.SetIPv6Address(*l6)

				for _, entry := range entries {
					if entry.Provider == "Cloudflare" {
						// Assert that entry.Data is of type CloudflareData
						data, ok := entry.ProviderData.(database.DatabaseDataDDNSEntryProviderDataCloudflare)
						if !ok {
							fmt.Println("ERROR")
							continue
						}

						fmt.Println("6")
						err := OverwriteDNSRecord(data.APIToken, data.ZoneID, entry.Record, "AAAA", *l6, 1)
						if err != nil {
							fmt.Println(err)
						} else {
							db.UpdateEntry(entry.Record)
						}
					}
				}

			}

			time.Sleep(2 * time.Second)
		}
	}(&l4, &LastAddress4, &l6, &LastAddress6)

	// Wrap all handlers with the AuthMiddleware
	http.Handle("/", AuthMiddleware(username, password, maxAttempts, lockoutDuration)(mux))

	port := "9008" // Replace with an environment variable if needed
	println("Server running on port", port)
	http.ListenAndServe(":"+port, nil)
}

func FetchAddress(addressType string) (string, error) {
	response, err := http.Get(fmt.Sprintf("http://%s.getmyip.dev", addressType))
	if err != nil {
		return "", err
	}
	defer response.Body.Close()

	// Read the response body
	body, err := io.ReadAll(response.Body)
	if err != nil {
		return "", err
	}

	return string(body), nil
}

// Start function to get the IP address and print it
func Start() {

	go func() {
		for true {
			r, err := FetchAddress("ipv4")
			if err != nil {
				fmt.Println(err.Error())
			} else {
				if r != LastAddress4 {
					// UPDATE 4
					LastAddress4 = r
					fmt.Println("IPV4 Updated: " + r)
				}
			}
			r, err = FetchAddress("ipv6")
			if err != nil {
				fmt.Println(err.Error())
			} else {
				if r != LastAddress6 {
					// UPDATE 6
					LastAddress6 = r
					fmt.Println("IPV6 Updated: " + r)
				}
			}
			time.Sleep(5 * time.Second)
		}
	}()

}