BlueGit

timfa bluegit

Files

bluegit / internal / store / store.go

store.go

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