package oltp
import (
"crypto/rand"
"crypto/sha256"
"database/sql"
"encoding/hex"
"errors"
"time"
)
// RFC 0030, Install codes. An admin makes a code for one repository; a
// person at their own host redeems it, once, for one worker token. Only
// the code's hash is kept, with who made it and when. A redeemed code's
// row is deleted, so a live row is an unspent, unlapsed code.
//
// worker_token_proof is how the forge knows a worker token's holder
// again: the engine never lists a bearer, so the hash of the bearer the
// forge handed out is kept beside the token's id, and a token retires
// itself by presenting it.
const runnerCodeSchema = `
CREATE TABLE IF NOT EXISTS runner_code (
hash TEXT PRIMARY KEY, -- SHA-256 of the code
repo TEXT NOT NULL,
maker TEXT NOT NULL,
created TEXT NOT NULL
);
CREATE INDEX IF NOT EXISTS runner_code_repo ON runner_code (repo);
CREATE TABLE IF NOT EXISTS runner_code_fail (
repo TEXT NOT NULL,
at TEXT NOT NULL
);
CREATE INDEX IF NOT EXISTS runner_code_fail_repo ON runner_code_fail (repo, at);
CREATE TABLE IF NOT EXISTS worker_token_proof (
hash TEXT PRIMARY KEY, -- SHA-256 of the bearer
token_id TEXT NOT NULL,
repo TEXT NOT NULL
);`
// RunnerCodeLife is how long an install code, and a window of failed
// redemptions, lasts.
const RunnerCodeLife = 15 * time.Minute
// ErrRunnerCodesFull is a code refused because the repository already
// holds as many live ones as it may.
var ErrRunnerCodesFull = errors.New("oltp: too many live install codes")
func runnerCodeHash(s string) string {
sum := sha256.Sum256([]byte("runner-code:" + s))
return hex.EncodeToString(sum[:])
}
func runnerCutoff(now time.Time) string {
return now.UTC().Add(-RunnerCodeLife).Format(time.RFC3339)
}
// NewRunnerCode makes a code for repo by maker and returns it, shown
// once. Lapsed codes are removed first; past max live ones for repo it
// refuses.
func (d *DB) NewRunnerCode(repo, maker string, max int, now time.Time) (string, error) {
tx, err := d.w.Begin()
if err != nil {
return "", err
}
defer tx.Rollback()
if _, err := tx.Exec(`DELETE FROM runner_code WHERE created < ?`, runnerCutoff(now)); err != nil {
return "", err
}
var live int
if err := tx.QueryRow(`SELECT count(*) FROM runner_code WHERE repo = ?`, repo).Scan(&live); err != nil {
return "", err
}
if live >= max {
return "", ErrRunnerCodesFull
}
raw := make([]byte, 20)
if _, err := rand.Read(raw); err != nil {
return "", err
}
code := "qri_" + hex.EncodeToString(raw)
if _, err := tx.Exec(`INSERT INTO runner_code (hash, repo, maker, created) VALUES (?, ?, ?, ?)`,
runnerCodeHash(code), repo, maker, now.UTC().Format(time.RFC3339)); err != nil {
return "", err
}
return code, tx.Commit()
}
// SpendRunnerCode takes the code a caller presented for repo, for good:
// one caller gets its maker, every other and every later one gets not
// ok.
func (d *DB) SpendRunnerCode(repo, code string, now time.Time) (maker string, created time.Time, ok bool, err error) {
tx, err := d.w.Begin()
if err != nil {
return "", time.Time{}, false, err
}
defer tx.Rollback()
if _, err := tx.Exec(`DELETE FROM runner_code WHERE created < ?`, runnerCutoff(now)); err != nil {
return "", time.Time{}, false, err
}
h := runnerCodeHash(code)
var at string
err = tx.QueryRow(`SELECT maker, created FROM runner_code WHERE hash = ? AND repo = ?`, h, repo).Scan(&maker, &at)
if errors.Is(err, sql.ErrNoRows) {
return "", time.Time{}, false, tx.Commit()
}
if err != nil {
return "", time.Time{}, false, err
}
if _, err := tx.Exec(`DELETE FROM runner_code WHERE hash = ?`, h); err != nil {
return "", time.Time{}, false, err
}
created, _ = time.Parse(time.RFC3339, at)
return maker, created, true, tx.Commit()
}
// UnspendRunnerCode puts back a code SpendRunnerCode took when the token
// it was taken for could not be minted, with its own maker and creation
// time, so it lapses when it would have. A code already past its life
// is not put back.
func (d *DB) UnspendRunnerCode(repo, code, maker string, created, now time.Time) error {
if created.IsZero() || !created.After(now.UTC().Add(-RunnerCodeLife)) {
return nil
}
_, err := d.w.Exec(`INSERT OR IGNORE INTO runner_code (hash, repo, maker, created) VALUES (?, ?, ?, ?)`,
runnerCodeHash(code), repo, maker, created.UTC().Format(time.RFC3339))
return err
}
// RunnerCodeFailures is how many failed redemptions repo has met in the
// last RunnerCodeLife.
func (d *DB) RunnerCodeFailures(repo string, now time.Time) (int, error) {
var n int
err := d.db.QueryRow(`SELECT count(*) FROM runner_code_fail WHERE repo = ? AND at >= ?`, repo, runnerCutoff(now)).Scan(&n)
return n, err
}
// NoteRunnerCodeFailure records one failed redemption against repo and
// forgets the ones that have aged out.
func (d *DB) NoteRunnerCodeFailure(repo string, now time.Time) error {
if _, err := d.w.Exec(`DELETE FROM runner_code_fail WHERE at < ?`, runnerCutoff(now)); err != nil {
return err
}
_, err := d.w.Exec(`INSERT INTO runner_code_fail (repo, at) VALUES (?, ?)`, repo, now.UTC().Format(time.RFC3339))
return err
}
// NoteWorkerTokenProof remembers whose bearer a worker token is.
func (d *DB) NoteWorkerTokenProof(bearer, id, repo string) error {
_, err := d.w.Exec(`INSERT OR REPLACE INTO worker_token_proof (hash, token_id, repo) VALUES (?, ?, ?)`,
runnerCodeHash(bearer), id, repo)
return err
}
// WorkerTokenByProof is the token id and repository a bearer was handed
// out for; not ok for a bearer the forge never minted.
func (d *DB) WorkerTokenByProof(bearer string) (id, repo string, ok bool, err error) {
err = d.db.QueryRow(`SELECT token_id, repo FROM worker_token_proof WHERE hash = ?`, runnerCodeHash(bearer)).Scan(&id, &repo)
if errors.Is(err, sql.ErrNoRows) {
return "", "", false, nil
}
return id, repo, err == nil, err
}