BlueGit

timfa bluegit

Files

bluegit / internal / store / store.go

store.go

feat: webhook-formulier per preset
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
Failed 934ba1ea History
store.go 22.5 KiB Download Raw
1// Package store bewaart BlueGit in één SQLite-bestand op de datadisk.
2package store
3
4import (
5 "context"
6 "crypto/rand"
7 "crypto/sha256"
8 "database/sql"
9 "encoding/hex"
10 "encoding/json"
11 "errors"
12 "fmt"
13 "strings"
14 "time"
15
16 "gitlab.com/Timfa/bluegit/internal/i18n"
17 "gitlab.com/Timfa/bluegit/internal/names"
18 "gitlab.com/Timfa/bluegit/internal/secretbox"
19
20 _ "modernc.org/sqlite"
21)
22
23// Store is de metadata van deze installatie.
24type Store struct {
25 db *sql.DB
26 key []byte
27}
28
29// Open opent of maakt het databasebestand. key is 32 bytes voor geheimen.
30func Open(path string, key []byte) (*Store, error) {
31 if len(key) != 32 {
32 return nil, fmt.Errorf("geheime sleutel moet 32 bytes zijn")
33 }
34 dsn := "file:" + path + "?_pragma=busy_timeout(5000)&_pragma=foreign_keys(1)"
35 db, err := sql.Open("sqlite", dsn)
36 if err != nil {
37 return nil, err
38 }
39 db.SetMaxOpenConns(8)
40 s := &Store{db: db, key: key}
41 if _, err := db.Exec(`PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON;`); err != nil {
42 _ = db.Close()
43 return nil, err
44 }
45 if err := s.migrate(); err != nil {
46 _ = db.Close()
47 return nil, err
48 }
49 return s, nil
50}
51
52// Close sluit de database.
53func (s *Store) Close() error { return s.db.Close() }
54
55func (s *Store) migrate() error {
56 if _, err := s.db.Exec(schema); err != nil {
57 return err
58 }
59 alters := []string{
60 `ALTER TABLE users ADD COLUMN language TEXT NOT NULL DEFAULT 'en'`,
61 `ALTER TABLE groups ADD COLUMN visibility TEXT NOT NULL DEFAULT 'private'`,
62 `ALTER TABLE groups ADD COLUMN default_role TEXT NOT NULL DEFAULT 'developer'`,
63 `ALTER TABLE groups ADD COLUMN logo_mime TEXT NOT NULL DEFAULT ''`,
64 `ALTER TABLE repos ADD COLUMN logo_mime TEXT NOT NULL DEFAULT ''`,
65 `ALTER TABLE webhooks ADD COLUMN method TEXT NOT NULL DEFAULT 'POST'`,
66 }
67 for _, q := range alters {
68 if _, err := s.db.Exec(q); err != nil && !strings.Contains(strings.ToLower(err.Error()), "duplicate column") {
69 return err
70 }
71 }
72 return nil
73}
74
75const schema = `
76CREATE TABLE IF NOT EXISTS users (
77 id INTEGER PRIMARY KEY,
78 auth_id INTEGER NOT NULL UNIQUE,
79 username TEXT NOT NULL UNIQUE,
80 avatar_url TEXT NOT NULL DEFAULT '',
81 auth_admin INTEGER NOT NULL DEFAULT 0,
82 instance_admin INTEGER NOT NULL DEFAULT 0,
83 language TEXT NOT NULL DEFAULT 'en',
84 created_at TEXT NOT NULL,
85 updated_at TEXT NOT NULL
86);
87CREATE TABLE IF NOT EXISTS sessions (
88 id TEXT PRIMARY KEY,
89 user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
90 access_token TEXT NOT NULL,
91 expires_at TEXT NOT NULL,
92 csrf TEXT NOT NULL,
93 created_at TEXT NOT NULL
94);
95CREATE TABLE IF NOT EXISTS access_tokens (
96 id INTEGER PRIMARY KEY,
97 user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
98 name TEXT NOT NULL,
99 token_hash TEXT NOT NULL UNIQUE,
100 prefix TEXT NOT NULL,
101 created_at TEXT NOT NULL,
102 last_used_at TEXT,
103 expires_at TEXT
104);
105CREATE TABLE IF NOT EXISTS ssh_keys (
106 id INTEGER PRIMARY KEY,
107 user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
108 name TEXT NOT NULL,
109 public_key TEXT NOT NULL,
110 fingerprint TEXT NOT NULL UNIQUE,
111 created_at TEXT NOT NULL
112);
113CREATE TABLE IF NOT EXISTS groups (
114 id INTEGER PRIMARY KEY,
115 name TEXT NOT NULL,
116 path TEXT NOT NULL UNIQUE,
117 description TEXT NOT NULL DEFAULT '',
118 visibility TEXT NOT NULL DEFAULT 'private',
119 default_role TEXT NOT NULL DEFAULT 'developer',
120 logo_mime TEXT NOT NULL DEFAULT '',
121 created_by INTEGER NOT NULL,
122 created_at TEXT NOT NULL
123);
124CREATE TABLE IF NOT EXISTS group_members (
125 group_id INTEGER NOT NULL REFERENCES groups(id) ON DELETE CASCADE,
126 user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
127 role TEXT NOT NULL,
128 PRIMARY KEY (group_id, user_id)
129);
130CREATE TABLE IF NOT EXISTS repos (
131 id INTEGER PRIMARY KEY,
132 owner_kind TEXT NOT NULL,
133 owner_id INTEGER NOT NULL,
134 name TEXT NOT NULL,
135 description TEXT NOT NULL DEFAULT '',
136 default_branch TEXT NOT NULL,
137 visibility TEXT NOT NULL DEFAULT 'private',
138 logo_mime TEXT NOT NULL DEFAULT '',
139 created_at TEXT NOT NULL,
140 UNIQUE(owner_kind, owner_id, name)
141);
142CREATE TABLE IF NOT EXISTS repo_members (
143 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
144 user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
145 role TEXT NOT NULL,
146 PRIMARY KEY (repo_id, user_id)
147);
148CREATE TABLE IF NOT EXISTS pending_members (
149 id INTEGER PRIMARY KEY,
150 scope_kind TEXT NOT NULL,
151 scope_id INTEGER NOT NULL,
152 username TEXT NOT NULL,
153 role TEXT NOT NULL,
154 UNIQUE(scope_kind, scope_id, username)
155);
156CREATE TABLE IF NOT EXISTS protected_branches (
157 id INTEGER PRIMARY KEY,
158 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
159 pattern TEXT NOT NULL,
160 UNIQUE(repo_id, pattern)
161);
162CREATE TABLE IF NOT EXISTS secrets (
163 id INTEGER PRIMARY KEY,
164 scope_kind TEXT NOT NULL,
165 scope_id INTEGER NOT NULL,
166 name TEXT NOT NULL,
167 ciphertext BLOB NOT NULL,
168 nonce BLOB NOT NULL,
169 protected INTEGER NOT NULL DEFAULT 0,
170 created_at TEXT NOT NULL,
171 UNIQUE(scope_kind, scope_id, name)
172);
173CREATE TABLE IF NOT EXISTS webhooks (
174 id INTEGER PRIMARY KEY,
175 scope_kind TEXT NOT NULL,
176 scope_id INTEGER NOT NULL,
177 name TEXT NOT NULL,
178 preset TEXT NOT NULL,
179 url_template TEXT NOT NULL,
180 headers_json TEXT NOT NULL,
181 body_template TEXT NOT NULL,
182 events_json TEXT NOT NULL,
183 branch_filter TEXT NOT NULL DEFAULT '',
184 active INTEGER NOT NULL DEFAULT 1,
185 method TEXT NOT NULL DEFAULT 'POST',
186 created_at TEXT NOT NULL
187);
188CREATE TABLE IF NOT EXISTS webhook_deliveries (
189 id INTEGER PRIMARY KEY,
190 webhook_id INTEGER NOT NULL REFERENCES webhooks(id) ON DELETE CASCADE,
191 event_type TEXT NOT NULL,
192 status_code INTEGER NOT NULL DEFAULT 0,
193 error TEXT NOT NULL DEFAULT '',
194 created_at TEXT NOT NULL
195);
196CREATE TABLE IF NOT EXISTS merge_requests (
197 id INTEGER PRIMARY KEY,
198 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
199 number INTEGER NOT NULL,
200 title TEXT NOT NULL,
201 description TEXT NOT NULL DEFAULT '',
202 source_branch TEXT NOT NULL,
203 target_branch TEXT NOT NULL,
204 author_id INTEGER NOT NULL,
205 status TEXT NOT NULL,
206 created_at TEXT NOT NULL,
207 updated_at TEXT NOT NULL,
208 UNIQUE(repo_id, number)
209);
210CREATE TABLE IF NOT EXISTS pipelines (
211 id INTEGER PRIMARY KEY,
212 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
213 commit_sha TEXT NOT NULL,
214 ref TEXT NOT NULL,
215 status TEXT NOT NULL,
216 created_at TEXT NOT NULL,
217 finished_at TEXT
218);
219CREATE TABLE IF NOT EXISTS jobs (
220 id INTEGER PRIMARY KEY,
221 pipeline_id INTEGER NOT NULL REFERENCES pipelines(id) ON DELETE CASCADE,
222 repo_id INTEGER NOT NULL,
223 name TEXT NOT NULL,
224 stage TEXT NOT NULL,
225 position INTEGER NOT NULL,
226 status TEXT NOT NULL,
227 image TEXT NOT NULL,
228 script TEXT NOT NULL,
229 needs_json TEXT NOT NULL,
230 needs_set INTEGER NOT NULL,
231 variables_json TEXT NOT NULL,
232 artifact_paths TEXT NOT NULL,
233 artifact_expire_seconds INTEGER NOT NULL DEFAULT 0,
234 allow_failure INTEGER NOT NULL DEFAULT 0,
235 log TEXT NOT NULL DEFAULT '',
236 started_at TEXT,
237 finished_at TEXT,
238 UNIQUE(pipeline_id, name)
239);
240CREATE TABLE IF NOT EXISTS artifacts (
241 id INTEGER PRIMARY KEY,
242 job_id INTEGER NOT NULL REFERENCES jobs(id) ON DELETE CASCADE,
243 path TEXT NOT NULL,
244 storage_path TEXT NOT NULL,
245 size INTEGER NOT NULL,
246 expires_at TEXT
247);
248CREATE TABLE IF NOT EXISTS job_tokens (
249 job_id INTEGER PRIMARY KEY REFERENCES jobs(id) ON DELETE CASCADE,
250 token_hash TEXT NOT NULL UNIQUE,
251 created_at TEXT NOT NULL
252);
253CREATE TABLE IF NOT EXISTS releases (
254 id INTEGER PRIMARY KEY,
255 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
256 tag TEXT NOT NULL,
257 commit_sha TEXT NOT NULL,
258 name TEXT NOT NULL,
259 body TEXT NOT NULL DEFAULT '',
260 author_id INTEGER,
261 job_id INTEGER,
262 created_at TEXT NOT NULL,
263 UNIQUE(repo_id, tag)
264);
265CREATE TABLE IF NOT EXISTS release_assets (
266 id INTEGER PRIMARY KEY,
267 release_id INTEGER NOT NULL REFERENCES releases(id) ON DELETE CASCADE,
268 name TEXT NOT NULL,
269 storage_path TEXT NOT NULL,
270 size INTEGER NOT NULL,
271 UNIQUE(release_id, name)
272);
273CREATE TABLE IF NOT EXISTS contributions (
274 id INTEGER PRIMARY KEY,
275 user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
276 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
277 kind TEXT NOT NULL,
278 ref TEXT NOT NULL,
279 occurred_at TEXT NOT NULL,
280 UNIQUE(repo_id, kind, ref)
281);
282CREATE INDEX IF NOT EXISTS contributions_repo_time ON contributions(repo_id, occurred_at);
283CREATE INDEX IF NOT EXISTS contributions_user_time ON contributions(user_id, occurred_at);
284CREATE TABLE IF NOT EXISTS contribution_sync (
285 repo_id INTEGER PRIMARY KEY REFERENCES repos(id) ON DELETE CASCADE,
286 synced_at TEXT NOT NULL
287);
288CREATE TABLE IF NOT EXISTS stars (
289 user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
290 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
291 created_at TEXT NOT NULL,
292 PRIMARY KEY (user_id, repo_id)
293);
294CREATE TABLE IF NOT EXISTS notes (
295 id INTEGER PRIMARY KEY,
296 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
297 mr_id INTEGER NOT NULL REFERENCES merge_requests(id) ON DELETE CASCADE,
298 author_id INTEGER NOT NULL REFERENCES users(id),
299 body TEXT NOT NULL,
300 created_at TEXT NOT NULL
301);
302CREATE TABLE IF NOT EXISTS commit_pushers (
303 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
304 sha TEXT NOT NULL,
305 user_id INTEGER NOT NULL REFERENCES users(id),
306 author_name TEXT NOT NULL,
307 author_email TEXT NOT NULL,
308 created_at TEXT NOT NULL,
309 PRIMARY KEY (repo_id, sha)
310);
311`
312
313func now() string { return time.Now().UTC().Format(time.RFC3339) }
314
315func parseTime(s string) time.Time {
316 t, err := time.Parse(time.RFC3339, s)
317 if err != nil {
318 return time.Time{}
319 }
320 return t
321}
322
323// User is een ingelogd account van de auth-server.
324type User struct {
325 ID int64
326 AuthID int64
327 Username string
328 AvatarURL string
329 AuthAdmin bool
330 InstanceAdmin bool
331 Language string
332 CreatedAt time.Time
333}
334
335// UpsertUser maakt of ververst een account. De eerste gebruiker wordt
336// installatiebeheerder. Wachtende lidmaatschappen op deze naam worden gekoppeld.
337func (s *Store) UpsertUser(ctx context.Context, authID int64, username, avatar string, authAdmin bool) (User, error) {
338 username = strings.ToLower(strings.TrimSpace(username))
339 if err := names.ValidUsername(username); err != nil {
340 return User{}, err
341 }
342 tx, err := s.db.BeginTx(ctx, nil)
343 if err != nil {
344 return User{}, err
345 }
346 defer func() { _ = tx.Rollback() }()
347
348 var count int
349 if err := tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM users`).Scan(&count); err != nil {
350 return User{}, err
351 }
352 ts := now()
353 var existingID int64
354 err = tx.QueryRowContext(ctx, `SELECT id FROM users WHERE auth_id = ?`, authID).Scan(&existingID)
355 if errors.Is(err, sql.ErrNoRows) {
356 var nameTaken int
357 if err := tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM users WHERE username = ?`, username).Scan(&nameTaken); err != nil {
358 return User{}, err
359 }
360 if nameTaken > 0 {
361 return User{}, i18n.E("err.userTaken", username)
362 }
363 admin := 0
364 if count == 0 {
365 admin = 1
366 }
367 res, err := tx.ExecContext(ctx, `INSERT INTO users (auth_id, username, avatar_url, auth_admin, instance_admin, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)`,
368 authID, username, avatar, boolInt(authAdmin), admin, ts, ts)
369 if err != nil {
370 return User{}, err
371 }
372 existingID, _ = res.LastInsertId()
373 } else if err != nil {
374 return User{}, err
375 } else {
376 if _, err := tx.ExecContext(ctx, `UPDATE users SET username = ?, avatar_url = ?, auth_admin = ?, updated_at = ? WHERE id = ? AND username = ?`,
377 username, avatar, boolInt(authAdmin), ts, existingID, username); err != nil {
378 return User{}, err
379 }
380 // Naamwijziging alleen als de nieuwe naam vrij is en gelijk blijft als hij botst.
381 var current string
382 if err := tx.QueryRowContext(ctx, `SELECT username FROM users WHERE id = ?`, existingID).Scan(&current); err != nil {
383 return User{}, err
384 }
385 if current != username {
386 var taken int
387 if err := tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM users WHERE username = ? AND id <> ?`, username, existingID).Scan(&taken); err != nil {
388 return User{}, err
389 }
390 var groupTaken int
391 if err := tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM groups WHERE path = ?`, username).Scan(&groupTaken); err != nil {
392 return User{}, err
393 }
394 if taken == 0 && groupTaken == 0 {
395 if _, err := tx.ExecContext(ctx, `UPDATE users SET username = ?, avatar_url = ?, auth_admin = ?, updated_at = ? WHERE id = ?`,
396 username, avatar, boolInt(authAdmin), ts, existingID); err != nil {
397 return User{}, err
398 }
399 } else if _, err := tx.ExecContext(ctx, `UPDATE users SET avatar_url = ?, auth_admin = ?, updated_at = ? WHERE id = ?`,
400 avatar, boolInt(authAdmin), ts, existingID); err != nil {
401 return User{}, err
402 }
403 }
404 }
405 if err := claimPending(ctx, tx, existingID, username); err != nil {
406 return User{}, err
407 }
408 if err := tx.Commit(); err != nil {
409 return User{}, err
410 }
411 return s.UserByID(ctx, existingID)
412}
413
414func claimPending(ctx context.Context, tx *sql.Tx, userID int64, username string) error {
415 rows, err := tx.QueryContext(ctx, `SELECT id, scope_kind, scope_id, role FROM pending_members WHERE username = ?`, username)
416 if err != nil {
417 return err
418 }
419 defer rows.Close()
420 type pend struct {
421 id, scopeID int64
422 kind, role string
423 }
424 var all []pend
425 for rows.Next() {
426 var p pend
427 if err := rows.Scan(&p.id, &p.kind, &p.scopeID, &p.role); err != nil {
428 return err
429 }
430 all = append(all, p)
431 }
432 if err := rows.Err(); err != nil {
433 return err
434 }
435 for _, p := range all {
436 switch p.kind {
437 case "group":
438 if _, err := tx.ExecContext(ctx, `INSERT OR IGNORE INTO group_members (group_id, user_id, role) VALUES (?, ?, ?)`, p.scopeID, userID, p.role); err != nil {
439 return err
440 }
441 case "repo":
442 if _, err := tx.ExecContext(ctx, `INSERT OR IGNORE INTO repo_members (repo_id, user_id, role) VALUES (?, ?, ?)`, p.scopeID, userID, p.role); err != nil {
443 return err
444 }
445 }
446 if _, err := tx.ExecContext(ctx, `DELETE FROM pending_members WHERE id = ?`, p.id); err != nil {
447 return err
448 }
449 }
450 return nil
451}
452
453// UserByID leest één account.
454func (s *Store) UserByID(ctx context.Context, id int64) (User, error) {
455 row := s.db.QueryRowContext(ctx, `SELECT id, auth_id, username, avatar_url, auth_admin, instance_admin, language, created_at FROM users WHERE id = ?`, id)
456 return scanUser(row)
457}
458
459// UserByUsername leest op naam.
460func (s *Store) UserByUsername(ctx context.Context, username string) (User, error) {
461 row := s.db.QueryRowContext(ctx, `SELECT id, auth_id, username, avatar_url, auth_admin, instance_admin, language, created_at FROM users WHERE username = ?`, strings.ToLower(username))
462 return scanUser(row)
463}
464
465func scanUser(row *sql.Row) (User, error) {
466 var u User
467 var admin, inst int
468 var created string
469 if err := row.Scan(&u.ID, &u.AuthID, &u.Username, &u.AvatarURL, &admin, &inst, &u.Language, &created); err != nil {
470 if errors.Is(err, sql.ErrNoRows) {
471 return User{}, errNotFound
472 }
473 return User{}, err
474 }
475 u.AuthAdmin = admin == 1
476 u.InstanceAdmin = inst == 1
477 if u.Language == "" {
478 u.Language = "en"
479 }
480 u.CreatedAt = parseTime(created)
481 return u, nil
482}
483
484// Session is een browsersessie.
485type Session struct {
486 ID string
487 UserID int64
488 AccessToken string
489 ExpiresAt time.Time
490 CSRF string
491 User User
492}
493
494// CreateSession bewaart het bearer-token van de auth-server.
495func (s *Store) CreateSession(ctx context.Context, userID int64, accessToken string, expiresAt time.Time) (Session, error) {
496 id, err := randomID()
497 if err != nil {
498 return Session{}, err
499 }
500 csrf, err := randomID()
501 if err != nil {
502 return Session{}, err
503 }
504 _, err = s.db.ExecContext(ctx, `INSERT INTO sessions (id, user_id, access_token, expires_at, csrf, created_at) VALUES (?, ?, ?, ?, ?, ?)`,
505 id, userID, accessToken, expiresAt.UTC().Format(time.RFC3339), csrf, now())
506 if err != nil {
507 return Session{}, err
508 }
509 return s.Session(ctx, id)
510}
511
512// Session leest een sessie met de gebruiker.
513func (s *Store) Session(ctx context.Context, id string) (Session, error) {
514 var sess Session
515 var exp string
516 err := s.db.QueryRowContext(ctx, `SELECT id, user_id, access_token, expires_at, csrf FROM sessions WHERE id = ?`, id).
517 Scan(&sess.ID, &sess.UserID, &sess.AccessToken, &exp, &sess.CSRF)
518 if errors.Is(err, sql.ErrNoRows) {
519 return Session{}, errNotFound
520 }
521 if err != nil {
522 return Session{}, err
523 }
524 sess.ExpiresAt = parseTime(exp)
525 u, err := s.UserByID(ctx, sess.UserID)
526 if err != nil {
527 return Session{}, err
528 }
529 sess.User = u
530 return sess, nil
531}
532
533// UpdateSessionExpiry schuift de lokale kopie van de auth-sessie op.
534func (s *Store) UpdateSessionExpiry(ctx context.Context, id string, expiresAt time.Time) error {
535 _, err := s.db.ExecContext(ctx, `UPDATE sessions SET expires_at = ? WHERE id = ?`, expiresAt.UTC().Format(time.RFC3339), id)
536 return err
537}
538
539// DeleteSession verwijdert de lokale sessie.
540func (s *Store) DeleteSession(ctx context.Context, id string) error {
541 _, err := s.db.ExecContext(ctx, `DELETE FROM sessions WHERE id = ?`, id)
542 return err
543}
544
545// TokenInfo is een persoonlijk toegangstoken zonder het geheim.
546type TokenInfo struct {
547 ID int64
548 Name string
549 Prefix string
550 CreatedAt time.Time
551 LastUsedAt time.Time
552}
553
554// CreateToken maakt een bg_-token. De tekst wordt één keer teruggegeven.
555func (s *Store) CreateToken(ctx context.Context, userID int64, name string) (string, error) {
556 name = strings.TrimSpace(name)
557 if name == "" || len(name) > 80 {
558 return "", i18n.E("err.tokenNeedsName")
559 }
560 plain, err := newToken("bg_")
561 if err != nil {
562 return "", err
563 }
564 _, err = s.db.ExecContext(ctx, `INSERT INTO access_tokens (user_id, name, token_hash, prefix, created_at) VALUES (?, ?, ?, ?, ?)`,
565 userID, name, hashToken(plain), plain[:10], now())
566 if err != nil {
567 return "", err
568 }
569 return plain, nil
570}
571
572// ListTokens toont de tokens van een gebruiker.
573func (s *Store) ListTokens(ctx context.Context, userID int64) ([]TokenInfo, error) {
574 rows, err := s.db.QueryContext(ctx, `SELECT id, name, prefix, created_at, COALESCE(last_used_at, '') FROM access_tokens WHERE user_id = ? ORDER BY id DESC`, userID)
575 if err != nil {
576 return nil, err
577 }
578 defer rows.Close()
579 var out []TokenInfo
580 for rows.Next() {
581 var t TokenInfo
582 var created, used string
583 if err := rows.Scan(&t.ID, &t.Name, &t.Prefix, &created, &used); err != nil {
584 return nil, err
585 }
586 t.CreatedAt = parseTime(created)
587 t.LastUsedAt = parseTime(used)
588 out = append(out, t)
589 }
590 return out, rows.Err()
591}
592
593// DeleteToken verwijdert een token van deze gebruiker.
594func (s *Store) DeleteToken(ctx context.Context, userID, id int64) error {
595 res, err := s.db.ExecContext(ctx, `DELETE FROM access_tokens WHERE id = ? AND user_id = ?`, id, userID)
596 if err != nil {
597 return err
598 }
599 n, _ := res.RowsAffected()
600 if n == 0 {
601 return errNotFound
602 }
603 return nil
604}
605
606// UserByToken zoekt de eigenaar van een persoonlijk token.
607func (s *Store) UserByToken(ctx context.Context, token string) (User, error) {
608 if !strings.HasPrefix(token, "bg_") {
609 return User{}, errNotFound
610 }
611 var userID, tokenID int64
612 err := s.db.QueryRowContext(ctx, `SELECT id, user_id FROM access_tokens WHERE token_hash = ?`, hashToken(token)).Scan(&tokenID, &userID)
613 if errors.Is(err, sql.ErrNoRows) {
614 return User{}, errNotFound
615 }
616 if err != nil {
617 return User{}, err
618 }
619 _, _ = s.db.ExecContext(ctx, `UPDATE access_tokens SET last_used_at = ? WHERE id = ?`, now(), tokenID)
620 return s.UserByID(ctx, userID)
621}
622
623// SSHKey is een publieke sleutel voor git-over-SSH.
624type SSHKey struct {
625 ID int64
626 UserID int64
627 Name string
628 PublicKey string
629 Fingerprint string
630 CreatedAt time.Time
631}
632
633// AddSSHKey bewaart één OpenSSH-regel.
634func (s *Store) AddSSHKey(ctx context.Context, userID int64, name, line, fingerprint string) error {
635 name = strings.TrimSpace(name)
636 if name == "" {
637 name = "sleutel"
638 }
639 _, err := s.db.ExecContext(ctx, `INSERT INTO ssh_keys (user_id, name, public_key, fingerprint, created_at) VALUES (?, ?, ?, ?, ?)`,
640 userID, name, strings.TrimSpace(line), fingerprint, now())
641 if err != nil && strings.Contains(err.Error(), "UNIQUE") {
642 return i18n.E("err.sshDup")
643 }
644 return err
645}
646
647// ListSSHKeys toont de sleutels van een gebruiker.
648func (s *Store) ListSSHKeys(ctx context.Context, userID int64) ([]SSHKey, error) {
649 rows, err := s.db.QueryContext(ctx, `SELECT id, user_id, name, public_key, fingerprint, created_at FROM ssh_keys WHERE user_id = ? ORDER BY id`, userID)
650 if err != nil {
651 return nil, err
652 }
653 defer rows.Close()
654 return scanKeys(rows)
655}
656
657// SSHKeyByFingerprint zoekt een sleutel voor de SSH-server.
658func (s *Store) SSHKeyByFingerprint(ctx context.Context, fingerprint string) (SSHKey, error) {
659 row := s.db.QueryRowContext(ctx, `SELECT id, user_id, name, public_key, fingerprint, created_at FROM ssh_keys WHERE fingerprint = ?`, fingerprint)
660 var k SSHKey
661 var created string
662 if err := row.Scan(&k.ID, &k.UserID, &k.Name, &k.PublicKey, &k.Fingerprint, &created); err != nil {
663 if errors.Is(err, sql.ErrNoRows) {
664 return SSHKey{}, errNotFound
665 }
666 return SSHKey{}, err
667 }
668 k.CreatedAt = parseTime(created)
669 return k, nil
670}
671
672// DeleteSSHKey verwijdert een sleutel van deze gebruiker.
673func (s *Store) DeleteSSHKey(ctx context.Context, userID, id int64) error {
674 res, err := s.db.ExecContext(ctx, `DELETE FROM ssh_keys WHERE id = ? AND user_id = ?`, id, userID)
675 if err != nil {
676 return err
677 }
678 n, _ := res.RowsAffected()
679 if n == 0 {
680 return errNotFound
681 }
682 return nil
683}
684
685func scanKeys(rows *sql.Rows) ([]SSHKey, error) {
686 var out []SSHKey
687 for rows.Next() {
688 var k SSHKey
689 var created string
690 if err := rows.Scan(&k.ID, &k.UserID, &k.Name, &k.PublicKey, &k.Fingerprint, &created); err != nil {
691 return nil, err
692 }
693 k.CreatedAt = parseTime(created)
694 out = append(out, k)
695 }
696 return out, rows.Err()
697}
698
699func randomID() (string, error) {
700 b := make([]byte, 32)
701 if _, err := rand.Read(b); err != nil {
702 return "", err
703 }
704 return hex.EncodeToString(b), nil
705}
706
707func newToken(prefix string) (string, error) {
708 b := make([]byte, 32)
709 if _, err := rand.Read(b); err != nil {
710 return "", err
711 }
712 return prefix + hex.EncodeToString(b), nil
713}
714
715func hashToken(token string) string {
716 sum := sha256.Sum256([]byte(token))
717 return hex.EncodeToString(sum[:])
718}
719
720func boolInt(b bool) int {
721 if b {
722 return 1
723 }
724 return 0
725}
726
727var errNotFound = fmt.Errorf("niet gevonden")
728
729// ErrNotFound is het resultaat als een rij ontbreekt.
730func ErrNotFound() error { return errNotFound }
731
732// IsNotFound meldt of err een ontbrekende rij is.
733func IsNotFound(err error) bool { return errors.Is(err, errNotFound) }
734
735func mustJSON(v any) string {
736 b, _ := json.Marshal(v)
737 if b == nil {
738 return "null"
739 }
740 return string(b)
741}
742
743// EncryptSecret versleutelt een geheim met de installatiesleutel.
744func (s *Store) encrypt(plain string) (nonce, ct []byte, err error) {
745 return secretbox.Encrypt(s.key, plain)
746}
747
748func (s *Store) decrypt(nonce, ct []byte) (string, error) {
749 return secretbox.Decrypt(s.key, nonce, ct)
750}