BlueGit

timfa bluegit

Files

bluegit / internal / store / store.go

store.go

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