package main

import (
	"errors"
	"fmt"
	"net/http"
	"strings"
	"time"

	"github.com/golang-jwt/jwt/v4"
)

// Define a secret key for signing tokens - in production, use an environment variable
var jwtKey = []byte("my_secret_key")

// Claims represents the JWT claims
type Claims struct {
	UserID   string `json:"user_id"`
	Username string `json:"username"`
	Role     string `json:"role"`
	jwt.RegisteredClaims
}

// GenerateJWT creates a new JWT token
func GenerateJWT(userID, username, role string) (string, error) {
	// Set expiration time to 24 hours
	expirationTime := time.Now().Add(24 * time.Hour)
	
	// Create the JWT claims
	claims := &Claims{
		UserID:   userID,
		Username: username,
		Role:     role,
		RegisteredClaims: jwt.RegisteredClaims{
			ExpiresAt: jwt.NewNumericDate(expirationTime),
			IssuedAt:  jwt.NewNumericDate(time.Now()),
			NotBefore: jwt.NewNumericDate(time.Now()),
			Issuer:    "go-auth-service",
			Subject:   userID,
		},
	}
	
	// Create token with claims
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	
	// Sign the token with our secret key
	tokenString, err := token.SignedString(jwtKey)
	if err != nil {
		return "", err
	}
	
	return tokenString, nil
}

// ValidateJWT validates the JWT token and returns the claims
func ValidateJWT(tokenString string) (*Claims, error) {
	// Parse the JWT token
	claims := &Claims{}
	token, err := jwt.ParseWithClaims(tokenString, claims, func(token *jwt.Token) (interface{}, error) {
		// Validate the signing method
		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
			return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
		}
		return jwtKey, nil
	})
	
	if err != nil {
		return nil, err
	}
	
	if !token.Valid {
		return nil, errors.New("invalid token")
	}
	
	return claims, nil
}

// JWTMiddleware is a middleware function for protecting routes with JWT
func JWTMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		// Get the Authorization header
		authHeader := r.Header.Get("Authorization")
		if authHeader == "" {
			http.Error(w, "Authorization header is required", http.StatusUnauthorized)
			return
		}
		
		// Check if the Authorization header has the correct format
		bearerToken := strings.Split(authHeader, " ")
		if len(bearerToken) != 2 || bearerToken[0] != "Bearer" {
			http.Error(w, "Invalid authorization format", http.StatusUnauthorized)
			return
		}
		
		// Extract the token
		tokenString := bearerToken[1]
		
		// Validate the token
		claims, err := ValidateJWT(tokenString)
		if err != nil {
			http.Error(w, "Invalid or expired token", http.StatusUnauthorized)
			return
		}
		
		// Add claims to the request context for use in handlers
		ctx := r.Context()
		ctx = context.WithValue(ctx, "user_id", claims.UserID)
		ctx = context.WithValue(ctx, "username", claims.Username)
		ctx = context.WithValue(ctx, "role", claims.Role)
		
		// Call the next handler with the updated context
		next.ServeHTTP(w, r.WithContext(ctx))
	})
}

// Example handler protected by JWT middleware
func protectedHandler(w http.ResponseWriter, r *http.Request) {
	// Get user information from the context
	userID := r.Context().Value("user_id").(string)
	username := r.Context().Value("username").(string)
	
	// Respond with the protected resource
	fmt.Fprintf(w, "Protected resource accessed by user %s (ID: %s)", username, userID)
}

func main() {
	// Create a sample token
	token, err := GenerateJWT("123", "johndoe", "admin")
	if err != nil {
		fmt.Printf("Error generating token: %v\n", err)
		return
	}
	
	fmt.Printf("Generated token: %s\n", token)
	
	// Setup routes
	http.Handle("/api/protected", JWTMiddleware(http.HandlerFunc(protectedHandler)))
	
	// Start the server
	http.ListenAndServe(":8080", nil)
}

package main

import (
	"encoding/base64"
	"fmt"
	"net/http"
	"strings"
)

// User represents a user in our system
type User struct {
	Username string
	Password string
	Role     string
}

// UsersDB is a simple in-memory user database
var UsersDB = map[string]User{
	"alice": {
		Username: "alice",
		Password: "password123", // In a real app, store hashed passwords!
		Role:     "admin",
	},
	"bob": {
		Username: "bob",
		Password: "securepass",
		Role:     "user",
	},
}

// BasicAuthMiddleware performs basic authentication
func BasicAuthMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		// Get the Authorization header
		authHeader := r.Header.Get("Authorization")
		if authHeader == "" {
			w.Header().Set("WWW-Authenticate", `Basic realm="Restricted"`)
			http.Error(w, "Unauthorized", http.StatusUnauthorized)
			return
		}
		
		// Check if it's a Basic auth header
		if !strings.HasPrefix(authHeader, "Basic ") {
			http.Error(w, "Invalid authorization type", http.StatusUnauthorized)
			return
		}
		
		// Extract the credentials
		credentials := strings.TrimPrefix(authHeader, "Basic ")
		decodedCredentials, err := base64.StdEncoding.DecodeString(credentials)
		if err != nil {
			http.Error(w, "Invalid credentials format", http.StatusUnauthorized)
			return
		}
		
		// Split username and password
		parts := strings.SplitN(string(decodedCredentials), ":", 2)
		if len(parts) != 2 {
			http.Error(w, "Invalid credentials format", http.StatusUnauthorized)
			return
		}
		
		username, password := parts[0], parts[1]
		
		// Verify credentials
		user, exists := UsersDB[username]
		if !exists || user.Password != password {
			http.Error(w, "Invalid credentials", http.StatusUnauthorized)
			return
		}
		
		// Add user information to the request context
		ctx := r.Context()
		ctx = context.WithValue(ctx, "username", username)
		ctx = context.WithValue(ctx, "role", user.Role)
		
		// Call the next handler with the updated context
		next.ServeHTTP(w, r.WithContext(ctx))
	})
}

// Protected handler that requires authentication
func protectedHandler(w http.ResponseWriter, r *http.Request) {
	username := r.Context().Value("username").(string)
	role := r.Context().Value("role").(string)
	fmt.Fprintf(w, "Hello, %s! Your role is: %s", username, role)
}

func main() {
	// Setup route with Basic Authentication
	http.Handle("/api/protected", BasicAuthMiddleware(http.HandlerFunc(protectedHandler)))
	
	// Start the server
	http.ListenAndServe(":8080", nil)
}

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"os"

	"golang.org/x/oauth2"
	"golang.org/x/oauth2/google"
)

// Google OAuth configuration
var googleOauthConfig = &oauth2.Config{
	RedirectURL:  "http://localhost:8080/auth/google/callback",
	ClientID:     os.Getenv("GOOGLE_CLIENT_ID"),     // Set these in environment variables
	ClientSecret: os.Getenv("GOOGLE_CLIENT_SECRET"), // Set these in environment variables
	Scopes:       []string{"https://www.googleapis.com/auth/userinfo.email", "https://www.googleapis.com/auth/userinfo.profile"},
	Endpoint:     google.Endpoint,
}

// State string for OAuth 2.0 flow (should be randomly generated in real apps)
const oauthStateString = "random-state-string"

// Home page handler
func homeHandler(w http.ResponseWriter, r *http.Request) {
	html := `
		<html>
			<body>
				<h1>Google OAuth 2.0 Example</h1>
				<a href="/auth/google/login">Login with Google</a>
			</body>
		</html>
	`
	fmt.Fprintf(w, html)
}

// Handler for initiating the OAuth flow
func googleLoginHandler(w http.ResponseWriter, r *http.Request) {
	// Create the OAuth state cookie
	expiration := time.Now().Add(20 * time.Minute)
	cookie := http.Cookie{
		Name:     "oauthstate",
		Value:    oauthStateString,
		Expires:  expiration,
		HttpOnly: true,
	}
	http.SetCookie(w, &cookie)
	
	// Redirect to Google's OAuth page
	url := googleOauthConfig.AuthCodeURL(oauthStateString)
	http.Redirect(w, r, url, http.StatusTemporaryRedirect)
}

// Callback handler for the OAuth flow
func googleCallbackHandler(w http.ResponseWriter, r *http.Request) {
	// Verify the state to prevent CSRF
	state := r.FormValue("state")
	oauthCookie, err := r.Cookie("oauthstate")
	if err != nil || state != oauthCookie.Value {
		http.Error(w, "Invalid OAuth state", http.StatusBadRequest)
		return
	}
	
	// Exchange the authorization code for a token
	code := r.FormValue("code")
	token, err := googleOauthConfig.Exchange(context.Background(), code)
	if err != nil {
		http.Error(w, "Failed to exchange token", http.StatusInternalServerError)
		return
	}
	
	// Get user info using the token
	userInfo, err := getUserInfo(token)
	if err != nil {
		http.Error(w, "Failed to get user info", http.StatusInternalServerError)
		return
	}
	
	// Here you would typically:
	// 1. Check if the user exists in your database
	// 2. Create a new user if they don't exist
	// 3. Create a session or JWT token for the user
	// 4. Redirect to the application
	
	// For this example, just display the user info
	response, _ := json.MarshalIndent(userInfo, "", "  ")
	w.Header().Set("Content-Type", "application/json")
	w.Write(response)
}

// Helper function to get user info from Google
func getUserInfo(token *oauth2.Token) (map[string]interface{}, error) {
	// Create HTTP client with the token
	client := googleOauthConfig.Client(context.Background(), token)
	
	// Make the request to Google's user info API
	resp, err := client.Get("https://www.googleapis.com/oauth2/v3/userinfo")
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	
	// Read and parse the response
	data, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}
	
	var userInfo map[string]interface{}
	err = json.Unmarshal(data, &userInfo)
	if err != nil {
		return nil, err
	}
	
	return userInfo, nil
}

func main() {
	// Check if environment variables are set
	if os.Getenv("GOOGLE_CLIENT_ID") == "" || os.Getenv("GOOGLE_CLIENT_SECRET") == "" {
		log.Fatal("Please set GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET environment variables")
	}
	
	// Setup routes
	http.HandleFunc("/", homeHandler)
	http.HandleFunc("/auth/google/login", googleLoginHandler)
	http.HandleFunc("/auth/google/callback", googleCallbackHandler)
	
	// Start the server
	log.Println("Server starting on http://localhost:8080")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

package main

import (
	"errors"
	"fmt"
	"net/http"
)

// Role represents a role in the system
type Role string

// Permission represents an action that can be performed
type Permission string

const (
	// Roles
	RoleAdmin  Role = "admin"
	RoleEditor Role = "editor"
	RoleViewer Role = "viewer"
	
	// Permissions
	PermissionCreate Permission = "create"
	PermissionRead   Permission = "read"
	PermissionUpdate Permission = "update"
	PermissionDelete Permission = "delete"
)

// RolePermissions maps roles to their allowed permissions
var RolePermissions = map[Role][]Permission{
	RoleAdmin:  {PermissionCreate, PermissionRead, PermissionUpdate, PermissionDelete},
	RoleEditor: {PermissionCreate, PermissionRead, PermissionUpdate},
	RoleViewer: {PermissionRead},
}

// HasPermission checks if a role has a specific permission
func HasPermission(role Role, permission Permission) bool {
	permissions, exists := RolePermissions[role]
	if !exists {
		return false
	}
	
	for _, p := range permissions {
		if p == permission {
			return true
		}
	}
	
	return false
}

// RequirePermission is a middleware that checks if the user has the required permission
func RequirePermission(permission Permission) func(http.Handler) http.Handler {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			// Get the user's role from the request context
			// (This would be set by your authentication middleware)
			roleValue := r.Context().Value("role")
			if roleValue == nil {
				http.Error(w, "Unauthorized", http.StatusUnauthorized)
				return
			}
			
			role := Role(roleValue.(string))
			
			// Check if the role has the required permission
			if !HasPermission(role, permission) {
				http.Error(w, "Forbidden", http.StatusForbidden)
				return
			}
			
			// User has permission, proceed to the handler
			next.ServeHTTP(w, r)
		})
	}
}

// Example handlers for different operations
func createHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintln(w, "Resource created successfully")
}

func readHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintln(w, "Here is the resource data")
}

func updateHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintln(w, "Resource updated successfully")
}

func deleteHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintln(w, "Resource deleted successfully")
}

func main() {
	// Setup routes with required permissions
	http.Handle("/api/resource/create", RequirePermission(PermissionCreate)(http.HandlerFunc(createHandler)))
	http.Handle("/api/resource/read", RequirePermission(PermissionRead)(http.HandlerFunc(readHandler)))
	http.Handle("/api/resource/update", RequirePermission(PermissionUpdate)(http.HandlerFunc(updateHandler)))
	http.Handle("/api/resource/delete", RequirePermission(PermissionDelete)(http.HandlerFunc(deleteHandler)))
	
	// Start the server
	http.ListenAndServe(":8080", nil)
}

package main

import (
	"fmt"
	"net/http"
	"time"
)

// User represents a user in the system
type User struct {
	ID         string
	Department string
	Role       string
	Location   string
	JoinedAt   time.Time
}

// Resource represents a protected resource
type Resource struct {
	ID            string
	OwnerID       string
	Department    string
	Classification string
	CreatedAt     time.Time
}

// AccessRequest represents a request to access a resource
type AccessRequest struct {
	User      User
	Resource  Resource
	Action    string
	Timestamp time.Time
}

// PolicyEngine evaluates access policies
type PolicyEngine struct{}

// Evaluate determines if access should be granted
func (pe *PolicyEngine) Evaluate(request AccessRequest) bool {
	// Example policies:
	
	// 1. Admins can do anything
	if request.User.Role == "admin" {
		return true
	}
	
	// 2. Users can access resources in their own department
	if request.User.Department == request.Resource.Department {
		// But with restrictions based on classification and action
		if request.Resource.Classification == "public" {
			return true
		}
		
		if request.Resource.Classification == "internal" && 
		   (request.Action == "read" || request.Action == "list") {
			return true
		}
		
		if request.Resource.Classification == "confidential" && 
		   request.Action == "read" && 
		   time.Since(request.User.JoinedAt) > 90*24*time.Hour { // 90 days
			return true
		}
	}
	
	// 3. Resource owners can do anything with their resources
	if request.User.ID == request.Resource.OwnerID {
		return true
	}
	
	// 4. Time-based restrictions
	currentHour := request.Timestamp.Hour()
	if request.Resource.Classification == "confidential" && 
	   (currentHour < 9 || currentHour > 17) { // Outside business hours
		return false
	}
	
	// Default deny
	return false
}

// ABACMiddleware applies ABAC policies to requests
func ABACMiddleware(engine *PolicyEngine, resourceProvider func(*http.Request) Resource) func(http.Handler) http.Handler {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			// Get user from the context (set by authentication middleware)
			userValue := r.Context().Value("user")
			if userValue == nil {
				http.Error(w, "Unauthorized", http.StatusUnauthorized)
				return
			}
			user := userValue.(User)
			
			// Get the resource being accessed
			resource := resourceProvider(r)
			
			// Determine the action from the request method
			action := "read"
			switch r.Method {
			case "POST":
				action = "create"
			case "PUT", "PATCH":
				action = "update"
			case "DELETE":
				action = "delete"
			}
			
			// Create access request
			accessRequest := AccessRequest{
				User:      user,
				Resource:  resource,
				Action:    action,
				Timestamp: time.Now(),
			}
			
			// Evaluate policies
			if !engine.Evaluate(accessRequest) {
				http.Error(w, "Forbidden", http.StatusForbidden)
				return
			}
			
			// Access granted, proceed to handler
			next.ServeHTTP(w, r)
		})
	}
}

// Example resource provider based on URL parameters
func getResourceFromRequest(r *http.Request) Resource {
	resourceID := r.URL.Query().Get("id")
	// In a real application, you would fetch the resource from a database
	// This is just a simple example
	return Resource{
		ID:             resourceID,
		OwnerID:        "user123",
		Department:     "engineering",
		Classification: "internal",
		CreatedAt:      time.Now().Add(-30 * 24 * time.Hour),
	}
}

// Example handler
func resourceHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Access granted to resource")
}

func main() {
	// Initialize policy engine
	policyEngine := &PolicyEngine{}
	
	// Setup route with ABAC
	http.Handle("/api/resource", ABACMiddleware(policyEngine, getResourceFromRequest)(http.HandlerFunc(resourceHandler)))
	
	// Start the server
	http.ListenAndServe(":8080", nil)
}

// Redirect HTTP to HTTPS
go http.ListenAndServe(":80", http.HandlerFunc(redirectToHTTPS))

// Run main server with TLS
log.Fatal(http.ListenAndServeTLS(":443", "cert.pem", "key.pem", nil))

// Simple rate limiter middleware
func RateLimitMiddleware(next http.Handler) http.Handler {
    // Map to store IP addresses and their request counts
    var clients = make(map[string]client)
    var mu sync.Mutex
    
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Get the IP address
        ip := r.RemoteAddr
        
        mu.Lock()
        defer mu.Unlock()
        
        // Get or create client info
        c, exists := clients[ip]
        if !exists {
            clients[ip] = client{
                count:    0,
                lastSeen: time.Now(),
            }
            c = clients[ip]
        }
        
        // Reset count if time window has passed
        if time.Since(c.lastSeen) > time.Minute {
            c.count = 0
            c.lastSeen = time.Now()
        }
        
        // Increment request count
        c.count++
        clients[ip] = c
        
        // Check if rate limit exceeded
        if c.count > 100 { // 100 requests per minute
            http.Error(w, "Rate limit exceeded", http.StatusTooManyRequests)
            return
        }
        
        // Proceed to next handler
        next.ServeHTTP(w, r)
    })
}

import "golang.org/x/crypto/bcrypt"

// Hash a password
func HashPassword(password string) (string, error) {
    bytes, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
    return string(bytes), err
}

// Check password against hash
func CheckPasswordHash(password, hash string) bool {
    err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
    return err == nil
}

// Create a secure cookie
http.SetCookie(w, &http.Cookie{
    Name:     "session",
    Value:    token,
    Expires:  time.Now().Add(24 * time.Hour),
    HttpOnly: true,   // Prevents JavaScript access
    Secure:   true,   // Only sent over HTTPS
    SameSite: http.SameSiteStrictMode,  // CSRF protection
    Path:     "/",
})

package main

import (
	"encoding/json"
	"log"
	"net/http"
	"time"

	"github.com/golang-jwt/jwt/v4"
	"golang.org/x/crypto/bcrypt"
)

// User represents a user in the system
type User struct {
	ID       string `json:"id"`
	Username string `json:"username"`
	Password string `json:"-"` // Hash of the password, not sent in responses
	Email    string `json:"email"`
	Role     string `json:"role"`
}

// UserStore is a simple in-memory user database (use a real DB in production)
var UserStore = map[string]*User{}

// JWTSecret is the key for signing JWT tokens
var JWTSecret = []byte("your-secret-key")

// RegisterRequest represents a registration request
type RegisterRequest struct {
	Username string `json:"username"`
	Password string `json:"password"`
	Email    string `json:"email"`
}

// LoginRequest represents a login request
type LoginRequest struct {
	Username string `json:"username"`
	Password string `json:"password"`
}

// TokenResponse is the response for successful authentication
type TokenResponse struct {
	Token        string `json:"token"`
	RefreshToken string `json:"refresh_token"`
	ExpiresIn    int    `json:"expires_in"`
	TokenType    string `json:"token_type"`
}

// RegisterHandler handles user registration
func RegisterHandler(w http.ResponseWriter, r *http.Request) {
	// Parse the request body
	var req RegisterRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, "Invalid request body", http.StatusBadRequest)
		return
	}
	
	// Validate input (simplified)
	if req.Username == "" || req.Password == "" || req.Email == "" {
		http.Error(w, "Username, password, and email are required", http.StatusBadRequest)
		return
	}
	
	// Check if username already exists
	if _, exists := UserStore[req.Username]; exists {
		http.Error(w, "Username already exists", http.StatusConflict)
		return
	}
	
	// Hash the password
	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
	if err != nil {
		log.Printf("Error hashing password: %v", err)
		http.Error(w, "Internal server error", http.StatusInternalServerError)
		return
	}
	
	// Create and store the user
	user := &User{
		ID:       generateID(), // In a real app, use a UUID
		Username: req.Username,
		Password: string(hashedPassword),
		Email:    req.Email,
		Role:     "user", // Default role
	}
	UserStore[req.Username] = user
	
	// Respond with success
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(map[string]string{
		"message": "User registered successfully",
	})
}

// LoginHandler handles user login
func LoginHandler(w http.ResponseWriter, r *http.Request) {
	// Parse the request body
	var req LoginRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, "Invalid request body", http.StatusBadRequest)
		return
	}
	
	// Find the user
	user, exists := UserStore[req.Username]
	if !exists {
		http.Error(w, "Invalid credentials", http.StatusUnauthorized)
		return
	}
	
	// Check the password
	if err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(req.Password)); err != nil {
		http.Error(w, "Invalid credentials", http.StatusUnauthorized)
		return
	}
	
	// Generate JWT token
	token, refreshToken, err := generateTokens(user)
	if err != nil {
		log.Printf("Error generating tokens: %v", err)
		http.Error(w, "Internal server error", http.StatusInternalServerError)
		return
	}
	
	// Return the tokens
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(TokenResponse{
		Token:        token,
		RefreshToken: refreshToken,
		ExpiresIn:    3600, // 1 hour
		TokenType:    "Bearer",
	})
}

// generateTokens creates an access token and refresh token
func generateTokens(user *User) (string, string, error) {
	// Create access token
	accessToken := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
		"sub":  user.ID,
		"username": user.Username,
		"role": user.Role,
		"exp":  time.Now().Add(time.Hour).Unix(),
		"iat":  time.Now().Unix(),
		"iss":  "auth-service",
	})
	
	accessTokenString, err := accessToken.SignedString(JWTSecret)
	if err != nil {
		return "", "", err
	}
	
	// Create refresh token (longer lived)
	refreshToken := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
		"sub": user.ID,
		"exp": time.Now().Add(7 * 24 * time.Hour).Unix(), // 7 days
		"iat": time.Now().Unix(),
		"iss": "auth-service",
	})
	
	refreshTokenString, err := refreshToken.SignedString(JWTSecret)
	if err != nil {
		return "", "", err
	}
	
	return accessTokenString, refreshTokenString, nil
}

// Helper function to generate ID (simplified)
func generateID() string {
	return fmt.Sprintf("%d", time.Now().UnixNano())
}

func main() {
	// Setup routes
	http.HandleFunc("/api/auth/register", RegisterHandler)
	http.HandleFunc("/api/auth/login", LoginHandler)
	
	// Start server
	log.Println("Server starting on http://localhost:8080")
	log.Fatal(http.ListenAndServe(":8080", nil))
}