internal/auth/session.go · GitClone

GameOver1337 / GitClone Public К репозиторию

internal/auth/session.go

3.8 KB

    package auth
 
import (
	"crypto/rand"
	"crypto/subtle"
	"encoding/base64"
	"net/http"
	"strings"
	"sync"
	"time"
)
 
const sessionCookie = "clancore_session"
const csrfCookie = "clancore_csrf"
const sessionTTL = 72 * time.Hour
const csrfTTL = 7 * 24 * time.Hour
 
type session struct {
	userID int
	expiry time.Time
}
 
var (
	mu       sync.RWMutex
	sessions = map[string]*session{}
)
 
func newToken() string {
	b := make([]byte, 32)
	if _, err := rand.Read(b); err != nil {
		return ""
	}
	return base64.RawURLEncoding.EncodeToString(b)
}
 
// StartSessionCleanup периодически удаляет просроченные сессии.
func StartSessionCleanup() {
	go func() {
		ticker := time.NewTicker(30 * time.Minute)
		defer ticker.Stop()
		for range ticker.C {
			now := time.Now()
			mu.Lock()
			for token, s := range sessions {
				if now.After(s.expiry) {
					delete(sessions, token)
				}
			}
			mu.Unlock()
		}
	}()
}
 
// CreateSession регистрирует новую сессию для пользователя и ставит cookie.
func CreateSession(w http.ResponseWriter, userID int) {
	token := newToken()
	if token == "" {
		return
	}
	mu.Lock()
	sessions[token] = &session{userID: userID, expiry: time.Now().Add(sessionTTL)}
	mu.Unlock()
 
	http.SetCookie(w, &http.Cookie{
		Name:     sessionCookie,
		Value:    token,
		Path:     "/",
		Expires:  time.Now().Add(sessionTTL),
		HttpOnly: true,
		SameSite: http.SameSiteLaxMode,
		MaxAge:   int(sessionTTL.Seconds()),
	})
}
 
// DestroySession удаляет сессию и чистит cookie.
func DestroySession(r *http.Request, w http.ResponseWriter) {
	if c, err := r.Cookie(sessionCookie); err == nil {
		mu.Lock()
		delete(sessions, c.Value)
		mu.Unlock()
	}
	http.SetCookie(w, &http.Cookie{
		Name:     sessionCookie,
		Value:    "",
		Path:     "/",
		HttpOnly: true,
		SameSite: http.SameSiteLaxMode,
		MaxAge:   -1,
	})
}
 
// SessionUserID возвращает id пользователя по активной сессии, либо 0.
func SessionUserID(r *http.Request) int {
	c, err := r.Cookie(sessionCookie)
	if err != nil || c.Value == "" {
		return 0
	}
	mu.RLock()
	s, ok := sessions[c.Value]
	mu.RUnlock()
	if !ok {
		return 0
	}
	if time.Now().After(s.expiry) {
		mu.Lock()
		delete(sessions, c.Value)
		mu.Unlock()
		return 0
	}
	return s.userID
}
 
// CSRFToken возвращает CSRF-токен из cookie, создавая его при необходимости.
func CSRFToken(w http.ResponseWriter, r *http.Request) string {
	if c, err := r.Cookie(csrfCookie); err == nil && c.Value != "" {
		return c.Value
	}
	token := newToken()
	if token == "" {
		return ""
	}
	http.SetCookie(w, &http.Cookie{
		Name:     csrfCookie,
		Value:    token,
		Path:     "/",
		Expires:  time.Now().Add(csrfTTL),
		HttpOnly: true,
		SameSite: http.SameSiteLaxMode,
		MaxAge:   int(csrfTTL.Seconds()),
	})
	return token
}
 
// CheckCSRF сверяет токен из формы/заголовка с cookie (double-submit).
func CheckCSRF(r *http.Request) bool {
	c, err := r.Cookie(csrfCookie)
	if err != nil || c.Value == "" {
		return false
	}
	token := r.FormValue("csrf_token")
	if token == "" {
		token = r.Header.Get("X-CSRF-Token")
	}
	if token == "" {
		return false
	}
	return subtle.ConstantTimeCompare([]byte(token), []byte(c.Value)) == 1
}
 
// CheckBasicAuth разбирает заголовок Authorization: Basic ...
func CheckBasicAuth(r *http.Request) (user, pass string, ok bool) {
	h := r.Header.Get("Authorization")
	if h == "" || !strings.HasPrefix(h, "Basic ") {
		return "", "", false
	}
	decoded, err := base64.StdEncoding.DecodeString(strings.TrimPrefix(h, "Basic "))
	if err != nil {
		return "", "", false
	}
	pair := strings.SplitN(string(decoded), ":", 2)
	if len(pair) != 2 {
		return "", "", false
	}
	return pair[0], pair[1], true
}

  

1	package auth
2
3	import (
4	"crypto/rand"
5	"crypto/subtle"
6	"encoding/base64"
7	"net/http"
8	"strings"
9	"sync"
10	"time"
11	)
12
13	const sessionCookie = "clancore_session"
14	const csrfCookie = "clancore_csrf"
15	const sessionTTL = 72 * time.Hour
16	const csrfTTL = 7 * 24 * time.Hour
17
18	type session struct {
19	userID int
20	expiry time.Time
21	}
22
23	var (
24	mu sync.RWMutex
25	sessions = map[string]*session{}
26	)
27
28	func newToken() string {
29	b := make([]byte, 32)
30	if _, err := rand.Read(b); err != nil {
31	return ""
32	}
33	return base64.RawURLEncoding.EncodeToString(b)
34	}
35
36	// StartSessionCleanup периодически удаляет просроченные сессии.
37	func StartSessionCleanup() {
38	go func() {
39	ticker := time.NewTicker(30 * time.Minute)
40	defer ticker.Stop()
41	for range ticker.C {
42	now := time.Now()
43	mu.Lock()
44	for token, s := range sessions {
45	if now.After(s.expiry) {
46	delete(sessions, token)
47	}
48	}
49	mu.Unlock()
50	}
51	}()
52	}
53
54	// CreateSession регистрирует новую сессию для пользователя и ставит cookie.
55	func CreateSession(w http.ResponseWriter, userID int) {
56	token := newToken()
57	if token == "" {
58	return
59	}
60	mu.Lock()
61	sessions[token] = &session{userID: userID, expiry: time.Now().Add(sessionTTL)}
62	mu.Unlock()
63
64	http.SetCookie(w, &http.Cookie{
65	Name: sessionCookie,
66	Value: token,
67	Path: "/",
68	Expires: time.Now().Add(sessionTTL),
69	HttpOnly: true,
70	SameSite: http.SameSiteLaxMode,
71	MaxAge: int(sessionTTL.Seconds()),
72	})
73	}
74
75	// DestroySession удаляет сессию и чистит cookie.
76	func DestroySession(r *http.Request, w http.ResponseWriter) {
77	if c, err := r.Cookie(sessionCookie); err == nil {
78	mu.Lock()
79	delete(sessions, c.Value)
80	mu.Unlock()
81	}
82	http.SetCookie(w, &http.Cookie{
83	Name: sessionCookie,
84	Value: "",
85	Path: "/",
86	HttpOnly: true,
87	SameSite: http.SameSiteLaxMode,
88	MaxAge: -1,
89	})
90	}
91
92	// SessionUserID возвращает id пользователя по активной сессии, либо 0.
93	func SessionUserID(r *http.Request) int {
94	c, err := r.Cookie(sessionCookie)
95	if err != nil \|\| c.Value == "" {
96	return 0
97	}
98	mu.RLock()
99	s, ok := sessions[c.Value]
100	mu.RUnlock()
101	if !ok {
102	return 0
103	}
104	if time.Now().After(s.expiry) {
105	mu.Lock()
106	delete(sessions, c.Value)
107	mu.Unlock()
108	return 0
109	}
110	return s.userID
111	}
112
113	// CSRFToken возвращает CSRF-токен из cookie, создавая его при необходимости.
114	func CSRFToken(w http.ResponseWriter, r *http.Request) string {
115	if c, err := r.Cookie(csrfCookie); err == nil && c.Value != "" {
116	return c.Value
117	}
118	token := newToken()
119	if token == "" {
120	return ""
121	}
122	http.SetCookie(w, &http.Cookie{
123	Name: csrfCookie,
124	Value: token,
125	Path: "/",
126	Expires: time.Now().Add(csrfTTL),
127	HttpOnly: true,
128	SameSite: http.SameSiteLaxMode,
129	MaxAge: int(csrfTTL.Seconds()),
130	})
131	return token
132	}
133
134	// CheckCSRF сверяет токен из формы/заголовка с cookie (double-submit).
135	func CheckCSRF(r *http.Request) bool {
136	c, err := r.Cookie(csrfCookie)
137	if err != nil \|\| c.Value == "" {
138	return false
139	}
140	token := r.FormValue("csrf_token")
141	if token == "" {
142	token = r.Header.Get("X-CSRF-Token")
143	}
144	if token == "" {
145	return false
146	}
147	return subtle.ConstantTimeCompare([]byte(token), []byte(c.Value)) == 1
148	}
149
150	// CheckBasicAuth разбирает заголовок Authorization: Basic ...
151	func CheckBasicAuth(r *http.Request) (user, pass string, ok bool) {
152	h := r.Header.Get("Authorization")
153	if h == "" \|\| !strings.HasPrefix(h, "Basic ") {
154	return "", "", false
155	}
156	decoded, err := base64.StdEncoding.DecodeString(strings.TrimPrefix(h, "Basic "))
157	if err != nil {
158	return "", "", false
159	}
160	pair := strings.SplitN(string(decoded), ":", 2)
161	if len(pair) != 2 {
162	return "", "", false
163	}
164	return pair[0], pair[1], true
165	}