mangaBookmark/backend/internal/web/discord.go

package web

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"log"
	"net/http"
	"net/url"
	"strconv"
	"strings"
	"sync"
	"time"

	"bookmarkmanager/backend/internal/session"
)

const (
	// oauthStateTTL bounds how long a started sign-in stays valid. Ten
	// minutes is generous for Discord's round trip and short enough that a
	// captured state is stale before it is worth replaying.
	oauthStateTTL = 10 * time.Minute
	// maxStates caps the state map so a flood of /auth/discord hits cannot
	// grow memory; past the cap the oldest state is evicted, which at worst
	// invalidates an in-flight sign-in.
	maxStates = 256
	// maxResponseBytes caps Discord API bodies; they are small, and an
	// unbounded read is an OOM handed to Discord's CDN.
	maxResponseBytes = 1 << 20
	// discordTimeout keeps a hung Discord request from hanging the login
	// callback forever.
	discordTimeout = 15 * time.Second
)

// DiscordConfig is the OAuth application this service registers as, plus the
// guild that gates access.
type DiscordConfig struct {
	ClientID     string
	ClientSecret string
	GuildID      string
	// RequiredRole, when non-empty, is a role ID a member must hold on top of
	// guild membership. Empty by default: membership alone suffices.
	RequiredRole string
	// APIBBase is the Discord API root; configurable so tests run the whole
	// flow against a local stub.
	APIBBase string
	// RedirectURI is the full public URL of the callback — Discord requires
	// the exact string, so it is configured, never derived from headers.
	RedirectURI string
	// OwnerDiscordID is the only Discord identity allowed to sign in until
	// registration exists (issue #23).
	OwnerDiscordID string
}

// oauthStates stores one-time sign-in states. A state is generated at
// /auth/discord, echoed back by Discord at the callback, and consumed there.
type oauthStates struct {
	mu     sync.Mutex
	expiry map[string]time.Time
	order  []string // FIFO for eviction when the map is full
}

func newOAuthStates() *oauthStates {
	return &oauthStates{expiry: make(map[string]time.Time)}
}

func (s *oauthStates) put(state string, expires time.Time) {
	s.mu.Lock()
	defer s.mu.Unlock()
	now := time.Now()
	for k, at := range s.expiry {
		if !at.After(now) {
			delete(s.expiry, k)
		}
	}
	if len(s.expiry) >= maxStates {
		// Evict from the front until under the cap. The front may already
		// have been consumed by take (which removes from the map, not the
		// order slice), so pop until the count actually drops.
		for len(s.expiry) >= maxStates && len(s.order) > 0 {
			oldest := s.order[0]
			s.order = s.order[1:]
			delete(s.expiry, oldest)
		}
	}
	s.expiry[state] = expires
	s.order = append(s.order, state)
}

// take validates and consumes a state in one step: a state works exactly
// once, which is what makes a replayed callback useless.
func (s *oauthStates) take(state string) bool {
	s.mu.Lock()
	defer s.mu.Unlock()
	expires, ok := s.expiry[state]
	if !ok || !expires.After(time.Now()) {
		return false
	}
	delete(s.expiry, state)
	return true
}

// discordStart begins the authorization code grant: a fresh state, then a
// redirect to Discord's authorize page.
func (h *Handler) discordStart(w http.ResponseWriter, r *http.Request) {
	state := session.NewID()
	h.states.put(state, time.Now().Add(oauthStateTTL))
	u := h.discord.APIBBase + "/oauth2/authorize?" + url.Values{
		"client_id":     {h.discord.ClientID},
		"redirect_uri":  {h.discord.RedirectURI},
		"response_type": {"code"},
		"scope":         {"identify guilds.members.read"},
		"state":         {state},
	}.Encode()
	http.Redirect(w, r, u, http.StatusSeeOther)
}

// discordCallback completes the grant: exchange the code, verify identity,
// membership and role, then mint a session. Every failure path renders the
// login page with an author-written message — nothing Discord supplied is
// ever interpolated into a page, and no secret reaches a log line.
func (h *Handler) discordCallback(w http.ResponseWriter, r *http.Request) {
	ip := session.ClientIP(r)
	if wait := h.limiter.RetryAfter(ip, time.Now()); wait > 0 {
		secs := int(wait.Seconds()) + 1
		w.Header().Set("Retry-After", strconv.Itoa(secs))
		h.renderLogin(w, http.StatusTooManyRequests,
			"Too many attempts. Try again in "+strconv.Itoa((secs+59)/60)+" min.")
		return
	}

	// Discord refuses the grant (the reader hit cancel, or the application
	// was misconfigured). The state is consumed so the flow is cleanly over;
	// this makes no Discord calls, so it is not a failure the limiter counts.
	if oerr := r.URL.Query().Get("error"); oerr != "" {
		h.states.take(r.URL.Query().Get("state"))
		h.renderLogin(w, http.StatusBadRequest, "Sign-in was cancelled.")
		return
	}

	code := r.URL.Query().Get("code")
	if code == "" || !h.states.take(r.URL.Query().Get("state")) {
		h.limiter.Fail(ip, time.Now())
		h.renderLogin(w, http.StatusBadRequest,
			"This sign-in link was invalid or already used. Start again.")
		return
	}

	tok, err := h.exchangeToken(r.Context(), code)
	if err != nil {
		h.limiter.Fail(ip, time.Now())
		log.Printf("discord token exchange: %v", err)
		h.renderLogin(w, http.StatusBadGateway,
			"Discord sign-in is unavailable right now. Try again in a moment.")
		return
	}

	userID, err := h.discordUserID(r.Context(), tok.AccessToken)
	if err != nil {
		h.limiter.Fail(ip, time.Now())
		log.Printf("discord users/@me: %v", err)
		h.renderLogin(w, http.StatusBadGateway,
			"Discord sign-in is unavailable right now. Try again in a moment.")
		return
	}

	if userID != h.discord.OwnerDiscordID {
		h.limiter.Fail(ip, time.Now())
		h.renderLogin(w, http.StatusForbidden,
			"This Discord account is not the library owner.")
		return
	}

	member, isMember, err := h.discordMember(r.Context(), tok.AccessToken, userID)
	if err != nil {
		h.limiter.Fail(ip, time.Now())
		log.Printf("discord member check: %v", err)
		h.renderLogin(w, http.StatusBadGateway,
			"Discord sign-in is unavailable right now. Try again in a moment.")
		return
	}
	// The refusal is the same for a non-member and a member without the
	// required role, and it names neither the guild nor its id: an outsider
	// cannot tell whether the guild exists, let alone which one gates.
	if !isMember || (h.discord.RequiredRole != "" && !contains(member.Roles, h.discord.RequiredRole)) {
		h.limiter.Fail(ip, time.Now())
		h.renderLogin(w, http.StatusForbidden,
			"This Discord account is not a member of this community.")
		return
	}

	h.limiter.Reset(ip)
	sess, err := h.store.CreateSession(session.NewID(), h.readerID, session.SessionTTL)
	if err != nil {
		log.Printf("create session: %v", err)
		http.Error(w, "internal error", http.StatusInternalServerError)
		return
	}
	session.SetCookie(w, r, sess.ID)
	http.Redirect(w, r, "/", http.StatusSeeOther)
}

// exchangeToken trades an authorization code for an access token. The body is
// form-encoded because that is what Discord accepts — it rejects a JSON
// payload — so the wire format is fixed here, not in a client library.
func (h *Handler) exchangeToken(ctx context.Context, code string) (discordToken, error) {
	form := url.Values{
		"client_id":     {h.discord.ClientID},
		"client_secret": {h.discord.ClientSecret},
		"grant_type":    {"authorization_code"},
		"code":          {code},
		"redirect_uri":  {h.discord.RedirectURI},
	}
	req, err := http.NewRequestWithContext(ctx, http.MethodPost,
		h.discord.APIBBase+"/oauth2/token", strings.NewReader(form.Encode()))
	if err != nil {
		return discordToken{}, err
	}
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	req.Header.Set("Accept", "application/json")
	resp, err := h.httpClient.Do(req)
	if err != nil {
		return discordToken{}, err
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		return discordToken{}, fmt.Errorf("status %d", resp.StatusCode)
	}
	var tok discordToken
	if err := json.NewDecoder(io.LimitReader(resp.Body, maxResponseBytes)).Decode(&tok); err != nil {
		return discordToken{}, err
	}
	if tok.AccessToken == "" {
		return discordToken{}, errors.New("empty access token")
	}
	return tok, nil
}

// discordUserID fetches the signed-in user's id via the identify scope.
func (h *Handler) discordUserID(ctx context.Context, accessToken string) (string, error) {
	req, err := http.NewRequestWithContext(ctx, http.MethodGet,
		h.discord.APIBBase+"/users/@me", nil)
	if err != nil {
		return "", err
	}
	req.Header.Set("Authorization", "Bearer "+accessToken)
	req.Header.Set("Accept", "application/json")
	resp, err := h.httpClient.Do(req)
	if err != nil {
		return "", err
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		return "", fmt.Errorf("status %d", resp.StatusCode)
	}
	var u struct {
		ID string `json:"id"`
	}
	if err := json.NewDecoder(io.LimitReader(resp.Body, maxResponseBytes)).Decode(&u); err != nil {
		return "", err
	}
	if u.ID == "" {
		return "", errors.New("empty user id")
	}
	return u.ID, nil
}

type discordMember struct {
	Roles []string `json:"roles"`
}

// discordMember fetches the user's membership in the configured guild — the
// single-guild endpoint, not the list of every guild the user is in, so the
// gate asks exactly the question it names. A 404 or 403 (not in the guild, or
// the token lacks the scope) is a non-member, not an error.
func (h *Handler) discordMember(ctx context.Context, accessToken, userID string) (discordMember, bool, error) {
	u := h.discord.APIBBase + "/guilds/" + url.PathEscape(h.discord.GuildID) +
		"/members/" + url.PathEscape(userID)
	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u, nil)
	if err != nil {
		return discordMember{}, false, err
	}
	req.Header.Set("Authorization", "Bearer "+accessToken)
	req.Header.Set("Accept", "application/json")
	resp, err := h.httpClient.Do(req)
	if err != nil {
		return discordMember{}, false, err
	}
	defer resp.Body.Close()
	if resp.StatusCode == http.StatusNotFound || resp.StatusCode == http.StatusForbidden {
		return discordMember{}, false, nil
	}
	if resp.StatusCode != http.StatusOK {
		return discordMember{}, false, fmt.Errorf("status %d", resp.StatusCode)
	}
	var m discordMember
	if err := json.NewDecoder(io.LimitReader(resp.Body, maxResponseBytes)).Decode(&m); err != nil {
		return discordMember{}, false, err
	}
	return m, true, nil
}

type discordToken struct {
	AccessToken string `json:"access_token"`
}

func contains(ss []string, want string) bool {
	for _, s := range ss {
		if s == want {
			return true
		}
	}
	return false
}