xonecas.io
8058
Ir

irvc / files

irvc / auth.go

8.7 KB
1package main
2
3import (
4	"crypto/hmac"
5	"crypto/rand"
6	"crypto/sha256"
7	"crypto/subtle"
8	"database/sql"
9	"encoding/base64"
10	"net/http"
11	"strings"
12	"sync"
13	"time"
14
15	"github.com/gin-gonic/gin"
16	"golang.org/x/crypto/argon2"
17)
18
19const (
20	cookieName    = "irvc_session"
21	sessionTTL    = 30 * 24 * time.Hour
22	inviteTTL     = 14 * 24 * time.Hour
23	argonTime     = 1
24	argonMemory   = 64 * 1024
25	argonThreads  = 4
26	argonKeyLen   = 32
27	minPassword   = 8
28	maxMessageLen = 40000
29)
30
31func randToken() string {
32	b := make([]byte, 32)
33	if _, err := rand.Read(b); err != nil {
34		panic(err)
35	}
36	return base64.RawURLEncoding.EncodeToString(b)
37}
38
39func hashPassword(pw string) string {
40	salt := make([]byte, 16)
41	if _, err := rand.Read(salt); err != nil {
42		panic(err)
43	}
44	key := argon2.IDKey([]byte(pw), salt, argonTime, argonMemory, argonThreads, argonKeyLen)
45	return base64.RawStdEncoding.EncodeToString(salt) + "$" + base64.RawStdEncoding.EncodeToString(key)
46}
47
48func checkPassword(pw, encoded string) bool {
49	saltB64, keyB64, ok := strings.Cut(encoded, "$")
50	if !ok {
51		return false
52	}
53	salt, err1 := base64.RawStdEncoding.DecodeString(saltB64)
54	want, err2 := base64.RawStdEncoding.DecodeString(keyB64)
55	if err1 != nil || err2 != nil {
56		return false
57	}
58	got := argon2.IDKey([]byte(pw), salt, argonTime, argonMemory, argonThreads, argonKeyLen)
59	return subtle.ConstantTimeCompare(got, want) == 1
60}
61
62func (s *Server) sign(token string) string {
63	mac := hmac.New(sha256.New, []byte(s.cfg.SessionSecret))
64	mac.Write([]byte(token))
65	return token + "." + base64.RawURLEncoding.EncodeToString(mac.Sum(nil))
66}
67
68func (s *Server) verifyToken(signed string) (string, bool) {
69	token, sig, ok := strings.Cut(signed, ".")
70	if !ok {
71		return "", false
72	}
73	mac := hmac.New(sha256.New, []byte(s.cfg.SessionSecret))
74	mac.Write([]byte(token))
75	if subtle.ConstantTimeCompare([]byte(sig), []byte(base64.RawURLEncoding.EncodeToString(mac.Sum(nil)))) != 1 {
76		return "", false
77	}
78	return token, true
79}
80
81func (s *Server) setSession(c *gin.Context, userID int64) error {
82	token := randToken()
83	expires := time.Now().Add(sessionTTL)
84	if _, err := s.db.Exec(
85		`INSERT INTO sessions (id, user_id, expires_at) VALUES (?, ?, ?)`,
86		token, userID, expires.Unix(),
87	); err != nil {
88		return err
89	}
90	http.SetCookie(c.Writer, &http.Cookie{
91		Name:     cookieName,
92		Value:    s.sign(token),
93		Path:     "/",
94		Expires:  expires,
95		HttpOnly: true,
96		Secure:   true,
97		SameSite: http.SameSiteLaxMode,
98	})
99	return nil
100}
101
102func (s *Server) currentUser(c *gin.Context) (User, bool) {
103	cookie, err := c.Cookie(cookieName)
104	if err != nil {
105		return User{}, false
106	}
107	token, ok := s.verifyToken(cookie)
108	if !ok {
109		return User{}, false
110	}
111	var u User
112	err = s.db.QueryRow(
113		`SELECT u.id, u.username, u.created_at FROM sessions s JOIN users u ON u.id = s.user_id
114		 WHERE s.id = ? AND s.expires_at > ?`,
115		token, time.Now().Unix(),
116	).Scan(&u.ID, &u.Username, &u.CreatedAt)
117	if err != nil {
118		return User{}, false
119	}
120	return u, true
121}
122
123func (s *Server) requireAuth(c *gin.Context) {
124	u, ok := s.currentUser(c)
125	if !ok {
126		c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "unauthorized"})
127		return
128	}
129	c.Set("user", u)
130	s.db.Exec(`DELETE FROM sessions WHERE expires_at <= ?`, time.Now().Unix())
131	c.Next()
132}
133
134type loginRequest struct {
135	Username string `json:"username"`
136	Password string `json:"password"`
137}
138
139func (s *Server) handleLogin(c *gin.Context) {
140	var req loginRequest
141	if err := c.ShouldBindJSON(&req); err != nil {
142		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"})
143		return
144	}
145	var u User
146	err := s.db.QueryRow(
147		`SELECT id, username, pass_hash, created_at FROM users WHERE username = ?`,
148		req.Username,
149	).Scan(&u.ID, &u.Username, &u.PassHash, &u.CreatedAt)
150	if err != nil || !checkPassword(req.Password, u.PassHash) {
151		c.JSON(http.StatusUnauthorized, gin.H{"error": "invalid username or password"})
152		return
153	}
154	if err := s.setSession(c, u.ID); err != nil {
155		c.JSON(http.StatusInternalServerError, gin.H{"error": "session"})
156		return
157	}
158	c.JSON(http.StatusOK, u)
159}
160
161func (s *Server) handleLogout(c *gin.Context) {
162	if cookie, err := c.Cookie(cookieName); err == nil {
163		if token, ok := s.verifyToken(cookie); ok {
164			s.db.Exec(`DELETE FROM sessions WHERE id = ?`, token)
165		}
166	}
167	http.SetCookie(c.Writer, &http.Cookie{Name: cookieName, Value: "", Path: "/", MaxAge: -1})
168	c.Status(http.StatusNoContent)
169}
170
171func (s *Server) handleMe(c *gin.Context) {
172	c.JSON(http.StatusOK, c.MustGet("user").(User))
173}
174
175type userSummary struct {
176	ID       int64  `json:"id"`
177	Username string `json:"username"`
178}
179
180func (s *Server) handleUsers(c *gin.Context) {
181	rows, err := s.db.Query(`SELECT id, username FROM users ORDER BY username`)
182	if err != nil {
183		c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
184		return
185	}
186	defer rows.Close()
187	users := []userSummary{}
188	for rows.Next() {
189		var u userSummary
190		if err := rows.Scan(&u.ID, &u.Username); err != nil {
191			c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
192			return
193		}
194		users = append(users, u)
195	}
196	c.JSON(http.StatusOK, users)
197}
198
199type claimRequest struct {
200	Token    string `json:"token"`
201	Username string `json:"username"`
202	Password string `json:"password"`
203}
204
205func validUsername(name string) bool {
206	if len(name) < 3 || len(name) > 32 {
207		return false
208	}
209	for _, r := range name {
210		ok := r == '_' || r == '-' || (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9')
211		if !ok {
212			return false
213		}
214	}
215	return true
216}
217
218func (s *Server) handleClaim(c *gin.Context) {
219	var req claimRequest
220	if err := c.ShouldBindJSON(&req); err != nil {
221		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"})
222		return
223	}
224	if !validUsername(req.Username) || len(req.Password) < minPassword {
225		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid username or password too short"})
226		return
227	}
228	tx, err := s.db.Begin()
229	if err != nil {
230		c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
231		return
232	}
233	defer tx.Rollback()
234
235	var usedBy sql.NullInt64
236	var expires int64
237	err = tx.QueryRow(`SELECT used_by, expires_at FROM invites WHERE token = ?`, req.Token).Scan(&usedBy, &expires)
238	if err != nil || usedBy.Valid || expires < time.Now().Unix() {
239		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid or expired invite"})
240		return
241	}
242	res, err := tx.Exec(
243		`INSERT INTO users (username, pass_hash, created_at) VALUES (?, ?, ?)`,
244		req.Username, hashPassword(req.Password), time.Now().Unix(),
245	)
246	if err != nil {
247		c.JSON(http.StatusConflict, gin.H{"error": "username taken"})
248		return
249	}
250	userID, _ := res.LastInsertId()
251	if _, err := tx.Exec(
252		`UPDATE invites SET used_by = ?, used_at = ? WHERE token = ?`,
253		userID, time.Now().Unix(), req.Token,
254	); err != nil {
255		c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
256		return
257	}
258	if err := tx.Commit(); err != nil {
259		c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
260		return
261	}
262	if err := s.setSession(c, userID); err != nil {
263		c.JSON(http.StatusInternalServerError, gin.H{"error": "session"})
264		return
265	}
266	c.JSON(http.StatusOK, User{ID: userID, Username: req.Username, CreatedAt: time.Now().Unix()})
267}
268
269func (s *Server) handleInviteInfo(c *gin.Context) {
270	var usedBy sql.NullInt64
271	var expires int64
272	err := s.db.QueryRow(
273		`SELECT used_by, expires_at FROM invites WHERE token = ?`, c.Param("token"),
274	).Scan(&usedBy, &expires)
275	if err != nil || usedBy.Valid || expires < time.Now().Unix() {
276		c.JSON(http.StatusNotFound, gin.H{"error": "invalid or expired invite"})
277		return
278	}
279	c.JSON(http.StatusOK, gin.H{"valid": true})
280}
281
282func (s *Server) handleCreateInvite(c *gin.Context) {
283	user := c.MustGet("user").(User)
284	token := randToken()
285	expires := time.Now().Add(inviteTTL).Unix()
286	if _, err := s.db.Exec(
287		`INSERT INTO invites (token, created_by, expires_at) VALUES (?, ?, ?)`,
288		token, user.ID, expires,
289	); err != nil {
290		c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
291		return
292	}
293	c.JSON(http.StatusOK, gin.H{"token": token, "expiresAt": expires})
294}
295
296type rateLimiter struct {
297	mu     sync.Mutex
298	hits   map[string][]time.Time
299	limit  int
300	window time.Duration
301}
302
303func newRateLimiter(limit int, window time.Duration) *rateLimiter {
304	return &rateLimiter{hits: map[string][]time.Time{}, limit: limit, window: window}
305}
306
307func (rl *rateLimiter) allow(key string) bool {
308	rl.mu.Lock()
309	defer rl.mu.Unlock()
310	now := time.Now()
311	cutoff := now.Add(-rl.window)
312	kept := rl.hits[key][:0]
313	for _, t := range rl.hits[key] {
314		if t.After(cutoff) {
315			kept = append(kept, t)
316		}
317	}
318	rl.hits[key] = kept
319	if len(kept) >= rl.limit {
320		return false
321	}
322	rl.hits[key] = append(kept, now)
323	return true
324}
325
326func (s *Server) rateLimited(rl *rateLimiter) gin.HandlerFunc {
327	return func(c *gin.Context) {
328		if !rl.allow(c.ClientIP()) {
329			c.AbortWithStatusJSON(http.StatusTooManyRequests, gin.H{"error": "too many requests"})
330			return
331		}
332		c.Next()
333	}
334}