@@ -0,0 +1,320 @@
1+package main
2+
3+import (
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+
19+const (
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 = 4000
29+)
30+
31+func 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+
39+func 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+
48+func 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+
62+func (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+
68+func (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+
81+func (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+
102+func (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+
123+func (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+
134+type loginRequest struct {
135+ Username string `json:"username"`
136+ Password string `json:"password"`
137+}
138+
139+func (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+
161+func (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+
171+func (s *Server) handleMe(c *gin.Context) {
172+ c.JSON(http.StatusOK, c.MustGet("user").(User))
173+}
174+
175+type userSummary struct {
176+ ID int64 `json:"id"`
177+ Username string `json:"username"`
178+}
179+
180+func (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+
199+type claimRequest struct {
200+ Token string `json:"token"`
201+ Username string `json:"username"`
202+ Password string `json:"password"`
203+}
204+
205+func 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+
218+func (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+
269+func (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+
282+type rateLimiter struct {
283+ mu sync.Mutex
284+ hits map[string][]time.Time
285+ limit int
286+ window time.Duration
287+}
288+
289+func newRateLimiter(limit int, window time.Duration) *rateLimiter {
290+ return &rateLimiter{hits: map[string][]time.Time{}, limit: limit, window: window}
291+}
292+
293+func (rl *rateLimiter) allow(key string) bool {
294+ rl.mu.Lock()
295+ defer rl.mu.Unlock()
296+ now := time.Now()
297+ cutoff := now.Add(-rl.window)
298+ kept := rl.hits[key][:0]
299+ for _, t := range rl.hits[key] {
300+ if t.After(cutoff) {
301+ kept = append(kept, t)
302+ }
303+ }
304+ rl.hits[key] = kept
305+ if len(kept) >= rl.limit {
306+ return false
307+ }
308+ rl.hits[key] = append(kept, now)
309+ return true
310+}
311+
312+func (s *Server) rateLimited(rl *rateLimiter) gin.HandlerFunc {
313+ return func(c *gin.Context) {
314+ if !rl.allow(c.ClientIP()) {
315+ c.AbortWithStatusJSON(http.StatusTooManyRequests, gin.H{"error": "too many requests"})
316+ return
317+ }
318+ c.Next()
319+ }
320+}