package main import ( "bytes" "database/sql" "errors" "fmt" "log" "os" "os/exec" "strconv" "strings" "git.tilde.town/tildetown/town/codes" "git.tilde.town/tildetown/town/external/lockingwriter" "git.tilde.town/tildetown/town/sshkey" "github.com/charmbracelet/lipgloss" _ "github.com/mattn/go-sqlite3" "github.com/mattn/go-tty" ) // TODO consider local-only help command for renaming, email mgmt, deleting account // TODO put colorscheme, prompting stuff into own packages for use in the other commands. would be good to get off of survey. // TODO use new lockingwriter for logging in the other external commands func connectDB() (*sql.DB, error) { db, err := sql.Open("sqlite3", "/town/var/codes/codes.db?mode=rw") if err != nil { return nil, err } return db, nil } type colorScheme struct { Header func(string) string Subtitle func(string) string Prompt func(string) string Email func(string) string Option func(string) string Error func(string) string } func newColorScheme() colorScheme { s2r := func(s lipgloss.Style) func(string) string { return s.Render } c := func(s string) lipgloss.Color { return lipgloss.Color(s) } s := lipgloss.NewStyle return colorScheme{ Header: s2r(s().Bold(true).Foreground(c("#E0B0FF"))), Subtitle: s2r(s().Italic(true).Foreground(c("gray"))), Email: s2r(s().Bold(true).Underline(true)), Prompt: s2r(s().Bold(true).Foreground(c("#00752d"))), Option: s2r(s().Bold(true).Foreground(c("#38747a"))), Error: s2r(s().Bold(true).Foreground(c("#f43124"))), } } type Prompter struct { cs colorScheme tty *tty.TTY } func NewPrompter(tty *tty.TTY, cs colorScheme) *Prompter { return &Prompter{ cs: cs, tty: tty, } } func (p *Prompter) String(prompt string) (string, error) { // TODO assumes blank is no bueno var err error var answer string for answer == "" { fmt.Println("") fmt.Println(p.cs.Prompt(prompt)) fmt.Println(p.cs.Subtitle("(press enter to submit)")) answer, err = p.tty.ReadString() if err != nil { return "", fmt.Errorf("couldn't collect input: %w", err) } } return answer, nil } func (p *Prompter) Select(prompt string, opts []string) (int, error) { fmt.Println() fmt.Println(p.cs.Prompt(prompt)) fmt.Println(p.cs.Subtitle("(pick an option using the corresponding number)")) chosen := -1 for chosen < 0 { fmt.Println() for ix, o := range opts { fmt.Printf("%s: %s\n", p.cs.Option(fmt.Sprintf("%d", ix+1)), o) } r, err := p.tty.ReadRune() if err != nil { return -1, fmt.Errorf("could not collect answer for '%s': %w", prompt, err) } c, err := strconv.Atoi(string(r)) if err != nil { fmt.Println() fmt.Printf("I could not understand '%s'. Try again, please.\n", string(r)) continue } if c > len(opts) || c == 0 { fmt.Println() fmt.Printf("%s is not an option. Try again, please.\n", string(r)) continue } chosen = c - 1 } fmt.Println("") return chosen, nil } func _main(cs colorScheme) error { lw := lockingwriter.New() l := log.New(lw, "help: ", log.Ldate|log.Ltime|log.LUTC|log.Lshortfile|log.Lmsgprefix) db, err := connectDB() if err != nil { return fmt.Errorf("could not connect to database. please let root@tilde.town know about this.") } fmt.Println(cs.Header("Hi, you have reached the tilde town help desk.")) fmt.Println() fmt.Println("Please check out the options below.") fmt.Printf("If none of them apply to your case, you can email %s. \n", cs.Email("root@tilde.town")) tty, err := tty.Open() if err != nil { return fmt.Errorf("could not open tty: %w", err) } defer tty.Close() p := NewPrompter(tty, cs) options := []string{ "I need to request that a new SSH key be added to my account.", "I have a code from my e-mail to redeem for a new SSH key", "I just want out of here", } c, err := p.Select("What do you need help with?", options) defer func() { }() switch c { case 0: return collectEmail(l, db, cs, p) case 1: return redeemCode(l, db, cs, p) case 2: return nil } return nil } func emailToUsername(email string) (string, error) { cmd := exec.Command("sudo", "/town/bin/emailtouser", email) stderrBuff := bytes.NewBuffer([]byte{}) stdoutBuff := bytes.NewBuffer([]byte{}) cmd.Stderr = stderrBuff cmd.Stdout = stdoutBuff if err := cmd.Run(); err != nil { return "", fmt.Errorf("emailtouser failed with '%s': %w", stderrBuff.String(), err) } return strings.TrimSpace(stdoutBuff.String()), nil } func collectEmail(l *log.Logger, db *sql.DB, cs colorScheme, p *Prompter) error { fmt.Println(cs.Header("We can send a authorization code to an email associated with your town account.")) email, err := p.String("email to send reset code to?") if err != nil { return err } fmt.Println() fmt.Println(cs.Header("thanks!")) fmt.Println() fmt.Printf("If %s is associated with a town account we'll email an authorization code.\n", cs.Email(email)) mustHave := []string{"@", "."} found := 0 for _, s := range mustHave { if strings.Contains(email, s) { found++ } } if found != len(mustHave) { l.Printf("corrupt email '%s'", email) return nil } if _, err = emailToUsername(email); err != nil { l.Printf("no user for '%s'", email) return nil } code := codes.NewCode(email) ac := &AuthCode{ Code: code, Email: email, } if err = ac.Insert(db); err != nil { l.Printf("database error: %s", err.Error()) return errors.New("the database was sad") } if err = sendAuthCodeEmail(*ac); err != nil { l.Printf("mail send error: %s", err.Error()) return errors.New("email sending failed") } return nil } func redeemCode(l *log.Logger, db *sql.DB, cs colorScheme, p *Prompter) error { fmt.Println(cs.Header("redeem an auth code and add a new public key")) c, err := p.String("paste your auth code:") if err != nil { l.Printf("failed to prompt: %s", err.Error()) fmt.Println(cs.Error("sorry, I couldn't read that.")) return nil } parts, err := codes.Decode(c) if err != nil { l.Printf("failed to decode auth code: %s", err.Error()) fmt.Println(cs.Error("sorry, that doesn't look like an auth code...")) return nil } code := &AuthCode{ Code: c, Email: parts[1], } err = code.Hydrate(db) if err != nil { l.Printf("hydrate failed: %s", err.Error()) return errors.New("the database is sad") } if code.Used { fmt.Println(cs.Error("That code has already been redeemed. You'll have to request a new one.")) return nil } username, err := emailToUsername(code.Email) if err != nil { l.Printf("could not find user: %s", err.Error()) fmt.Println(cs.Error("That code doesn't seem to match an account.")) return nil } fmt.Println() fmt.Printf("hi, ~%s", username) key, err := p.String("paste your new public key:") if err != nil { l.Printf("failed to prompt: %s", err.Error()) fmt.Println(cs.Error("sorry, I couldn't read that.")) return nil } valid, err := sshkey.ValidKey(key) if err != nil { return fmt.Errorf("failed to validate key: %w", err) } if !valid { errMsg := fmt.Sprintf("that key is invalid: %s", err.Error()) fmt.Println(cs.Error(errMsg)) return nil } cmd := exec.Command("sudo", "--user", username, "/town/bin/appendkeyfile") cmd.Stdin = bytes.NewBufferString(key + "\n") stdoutBuff := bytes.NewBuffer([]byte{}) cmd.Stdout = stdoutBuff stderrBuff := bytes.NewBuffer([]byte{}) cmd.Stderr = stderrBuff if err = cmd.Run(); err != nil { l.Printf("appendkeyfile failed with '%s', '%s': %s", stderrBuff.String(), stdoutBuff.String(), err.Error()) return errors.New("adding to keys file failed") } err = code.MarkUsed(db) if err != nil { l.Printf("failed to mark used: %s", err.Error()) return errors.New("database was sad") } fmt.Println() fmt.Println("new key added! you should be able to use it to log in.") return nil } func main() { cs := newColorScheme() err := _main(cs) defer func() { fmt.Println() fmt.Println(cs.Header("bye~")) }() if err != nil { fmt.Println( cs.Error(fmt.Sprintf("sorry, something went wrong: %s", err.Error()))) fmt.Println("Please let an admin know by emailing a copy of this error to root@tilde.town") os.Exit(1) } } type AuthCode struct { ID int64 Code string Email string Used bool } func (c *AuthCode) Insert(db *sql.DB) error { stmt, err := db.Prepare(` INSERT INTO auth_codes (code, email) VALUES (?, ?)`) if err != nil { return err } defer stmt.Close() result, err := stmt.Exec(c.Code, c.Email) if err != nil { return err } liid, err := result.LastInsertId() if err != nil { return err } c.ID = liid return nil } func (c *AuthCode) Hydrate(db *sql.DB) error { stmt, err := db.Prepare(` SELECT id, used FROM auth_codes WHERE code = ? AND email = ?`) if err != nil { return err } defer stmt.Close() return stmt.QueryRow(c.Code, c.Email).Scan(&c.ID, &c.Used) } func (c *AuthCode) MarkUsed(db *sql.DB) error { if c.ID == 0 { return errors.New("not hydrated") } stmt, err := db.Prepare(` UPDATE auth_codes SET used = 1 WHERE id = ?`) if err != nil { return err } defer stmt.Close() result, err := stmt.Exec(c.ID) if err != nil { return err } var rowsAffected int64 if rowsAffected, err = result.RowsAffected(); err != nil { return err } if rowsAffected == 0 { return errors.New("no rows affected") } return nil }