Buncha fixes and binaries

bank/main.go

@@ -7,8 +7,11 @@ import (
 	"html/template"
 	"io/fs"
 	"log"
+	"net"
 	"net/http"
+	"os"
 	"sync"
+	"time"
 )
 
 //go:embed templates/*
@@ -58,6 +61,7 @@ func addUser(username, password, email, fullName string) {
 func main() {
 	// Nastavimo port preko command line argumenta
 	var port = flag.String("port", "8080", "Port na katerem se bo zagnal server")
+	var rateLimit = flag.Int("rate-limit", 3000, "Maksimalno število zahtev na sekundo")
 	flag.Parse()
 
 	// Naložimo HTML predloge iz embedded FS
@@ -67,29 +71,140 @@ func main() {
 		log.Fatal("Napaka pri nalaganju embedded predlog:", err)
 	}
 
+	// Create rate killer first
+	killer := newRateKiller(*rateLimit)
+
+	// Start network attack monitors with direct access to killer
+	go monitorTCP(killer)
+	go monitorUDP(killer)
+
 	// Statične datoteke iz embedded FS
 	staticSubFS, err := fs.Sub(staticFS, "static")
 	if err != nil {
 		log.Fatal("Napaka pri ustvarjanju static subFS:", err)
 	}
-	http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.FS(staticSubFS))))
+	mux := http.NewServeMux()
+	mux.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.FS(staticSubFS))))
 
 	// Routes
-	http.HandleFunc("/", homeHandler)
-	http.HandleFunc("/register", registerHandler)
-	http.HandleFunc("/login", loginHandler)
-	http.HandleFunc("/dashboard", dashboardHandler)
-	http.HandleFunc("/logout", logoutHandler)
+	mux.HandleFunc("/", homeHandler)
+	mux.HandleFunc("/register", registerHandler)
+	mux.HandleFunc("/login", loginHandler)
+	mux.HandleFunc("/dashboard", dashboardHandler)
+	mux.HandleFunc("/logout", logoutHandler)
 
 	// Zagon strežnika
 	fmt.Printf("🏦 SecureBank aplikacija (embedded build)\n")
 	fmt.Printf("Port: %s\n", *port)
 	fmt.Printf("HTTP: http://localhost:%s\n", *port)
+	fmt.Printf("Rate Limit: %d req/sec\n", *rateLimit)
 	fmt.Printf("📦 Vsi fajli so vključeni v binary!\n")
 	fmt.Println()
 
 	serverAddr := ":" + *port
-	log.Fatal(http.ListenAndServe(serverAddr, nil))
+	log.Fatal(http.ListenAndServe(serverAddr, killer.wrap(mux)))
+}
+
+type rateKiller struct {
+	limit  int
+	mu     sync.Mutex
+	window time.Time
+	count  int
+}
+
+func newRateKiller(limit int) *rateKiller {
+	rk := &rateKiller{
+		limit:  limit,
+		window: time.Now().Truncate(time.Second),
+	}
+	// Reset counter every second
+	go rk.resetCounter()
+	return rk
+}
+
+func (rk *rateKiller) wrap(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		rk.mu.Lock()
+		nowWindow := time.Now().Truncate(time.Second)
+		if nowWindow.After(rk.window) {
+			rk.window = nowWindow
+			rk.count = 0
+		}
+		rk.count++
+		exceeded := rk.count > rk.limit
+		rk.mu.Unlock()
+
+		if exceeded {
+			log.Printf("CRITICAL: request rate exceeded %d req/s - shutting down", rk.limit)
+			os.Exit(1)
+		}
+
+		next.ServeHTTP(w, r)
+	})
+}
+
+func (rk *rateKiller) recordPacket() {
+	rk.mu.Lock()
+	rk.count++
+	current := rk.count
+	rk.mu.Unlock()
+
+	if current > rk.limit {
+		log.Printf("CRITICAL: attack detected - %d packets/sec exceeded limit of %d - SHUTTING DOWN", current, rk.limit)
+		os.Exit(1)
+	}
+}
+
+func (rk *rateKiller) resetCounter() {
+	ticker := time.NewTicker(time.Second)
+	defer ticker.Stop()
+	for range ticker.C {
+		rk.mu.Lock()
+		if rk.count > 0 {
+			log.Printf("📊 Rate: %d packets/sec (limit: %d)", rk.count, rk.limit)
+		}
+		rk.count = 0
+		rk.window = time.Now().Truncate(time.Second)
+		rk.mu.Unlock()
+	}
+}
+
+func monitorTCP(killer *rateKiller) {
+	listener, err := net.Listen("tcp", ":80")
+	if err != nil {
+		log.Printf("Warning: TCP monitor on :80 failed: %v", err)
+		return
+	}
+	defer listener.Close()
+	log.Println("🔍 TCP attack monitor active on :80")
+
+	for {
+		conn, err := listener.Accept()
+		if err != nil {
+			continue
+		}
+		killer.recordPacket()
+		conn.Close()
+	}
+}
+
+func monitorUDP(killer *rateKiller) {
+	conn, err := net.ListenPacket("udp", ":53")
+	if err != nil {
+		log.Printf("Warning: UDP monitor on :53 failed: %v", err)
+		return
+	}
+	defer conn.Close()
+	log.Println("🔍 UDP attack monitor active on :53")
+
+	buf := make([]byte, 1024)
+	for {
+		_, _, err := conn.ReadFrom(buf)
+		if err != nil {
+			continue
+		}
+		killer.recordPacket()
+	}
 }
 
 func homeHandler(w http.ResponseWriter, r *http.Request) {