mirror of
https://github.com/warmbly/warmbly.git
synced 2026-11-17 08:18:51 +00:00
208 lines
5.9 KiB
Go
208 lines
5.9 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/warmbly/warmbly/internal/app/keystatus"
|
|
)
|
|
|
|
func runKeys(ctx context.Context, args []string) error {
|
|
if len(args) == 0 {
|
|
keysUsage(os.Stderr)
|
|
return errors.New("`keys` needs a subcommand. Pick one from the list above.")
|
|
}
|
|
switch args[0] {
|
|
case "help", "-h", "--help":
|
|
keysUsage(os.Stdout)
|
|
return nil
|
|
case "status":
|
|
return runKeysScan(ctx, "keys status", args[1:], false)
|
|
case "reseal":
|
|
return runKeysScan(ctx, "keys reseal", args[1:], true)
|
|
case "generate":
|
|
return runKeysGenerate(args[1:])
|
|
}
|
|
keysUsage(os.Stderr)
|
|
return fmt.Errorf("unknown subcommand `keys %s`. Pick one from the list above.", args[0])
|
|
}
|
|
|
|
func keysUsage(w *os.File) {
|
|
fmt.Fprint(w, "Rotate the instance-wide encryption keys without losing what they seal.\n\nUsage:\n warmblyctl keys <subcommand> [flags]\n\nSubcommands:\n")
|
|
for _, c := range commands {
|
|
if !strings.HasPrefix(c.name, "keys ") {
|
|
continue
|
|
}
|
|
fmt.Fprintf(w, " %-28s %s\n %s\n", strings.TrimPrefix(c.name, "keys "), c.summary, c.example)
|
|
}
|
|
}
|
|
|
|
func runKeysScan(ctx context.Context, name string, args []string, reseal bool) error {
|
|
fs := newFlagSet(name)
|
|
asJSON := fs.Bool("json", false, "print the report as JSON")
|
|
var apply, requirePrimary *bool
|
|
var batch *int
|
|
if !reseal {
|
|
requirePrimary = fs.Bool("require-primary", false, "also exit non-zero while any value opens only under a read key")
|
|
}
|
|
if reseal {
|
|
apply = fs.Bool("apply", false, "write the resealed values; without it nothing is written")
|
|
batch = fs.Int("batch", 500, "rows read per query")
|
|
}
|
|
if err := fs.Parse(args); err != nil {
|
|
return err
|
|
}
|
|
if err := noExtraArgs(fs); err != nil {
|
|
return err
|
|
}
|
|
size := 500
|
|
if batch != nil {
|
|
if *batch < 1 || *batch > 10000 {
|
|
return errors.New("--batch must be between 1 and 10000")
|
|
}
|
|
size = *batch
|
|
}
|
|
write := apply != nil && *apply
|
|
|
|
keys, err := keystatus.LoadKeyring(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c, err := connect(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer c.close()
|
|
|
|
report, err := keystatus.Scan(ctx, c.db.Pool, keys, keystatus.Options{Batch: size, Write: write})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if *asJSON {
|
|
if err := json.NewEncoder(os.Stdout).Encode(report); err != nil {
|
|
return err
|
|
}
|
|
} else {
|
|
printKeyReport(report, reseal)
|
|
}
|
|
if report.Unreadable() > 0 {
|
|
return keystatus.ErrUnreadable
|
|
}
|
|
if requirePrimary != nil && *requirePrimary && report.OnReadKey() > 0 {
|
|
return keystatus.ErrOnReadKey
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func printKeyReport(r keystatus.Report, reseal bool) {
|
|
if reseal && !r.Applied {
|
|
fmt.Print("Dry run: nothing will be written. Pass --apply to reseal.\n\n")
|
|
}
|
|
fmt.Printf("Instance credential key: primary plus %s.\n", counted(r.InstanceReadKeys, "read key", "read keys"))
|
|
if r.MFAConfigured {
|
|
fmt.Printf("MFA key: primary plus %s.\n", counted(r.MFAReadKeys, "read key", "read keys"))
|
|
} else {
|
|
fmt.Println("MFA key: not configured here, so TOTP enrollments are not checked.")
|
|
}
|
|
fmt.Printf("\n %-44s %8s %9s %10s %9s %11s\n", "column", "primary", "read key", "workspace", "unsealed", "unreadable")
|
|
var onRead, unreadable, resealed, raced int
|
|
cols := append([]keystatus.Count(nil), r.Columns...)
|
|
sort.SliceStable(cols, func(i, j int) bool { return cols[i].Domain < cols[j].Domain })
|
|
for _, c := range cols {
|
|
label := c.Table + "." + c.Column
|
|
if c.Missing {
|
|
fmt.Printf(" %-44s %s\n", label, "table not present")
|
|
continue
|
|
}
|
|
fmt.Printf(" %-44s %8d %9d %10d %9d %11d\n", label, c.Primary, c.ReadKey, c.Workspace, c.Unsealed, c.Unreadable)
|
|
onRead += c.ReadKey
|
|
unreadable += c.Unreadable
|
|
resealed += c.Resealed
|
|
raced += c.Raced
|
|
}
|
|
for _, w := range r.Windows {
|
|
state := "closed"
|
|
if w.Open {
|
|
state = "open until " + w.Until.UTC().Format(time.RFC3339)
|
|
}
|
|
fmt.Printf("\n%s: %s, %s", w.Name, state, counted(w.Entries, "previous value", "previous values"))
|
|
}
|
|
if len(r.Windows) > 0 {
|
|
fmt.Println()
|
|
}
|
|
fmt.Println()
|
|
switch {
|
|
case r.Applied:
|
|
fmt.Printf("Resealed %s under the primary key.", counted(resealed, "value", "values"))
|
|
if raced > 0 {
|
|
fmt.Printf(" %s changed while this ran; run it again to finish them.", counted(raced, "value", "values"))
|
|
}
|
|
fmt.Println()
|
|
case onRead > 0:
|
|
fmt.Printf("%s still open only under a read key. `warmblyctl keys reseal --apply` moves them to the primary.\n", counted(onRead, "value is", "values are"))
|
|
default:
|
|
fmt.Println("Every sealed value opens under the primary key. Retire a read key only once no rollback target, pending job or retained backup still needs it.")
|
|
}
|
|
if unreadable > 0 {
|
|
fmt.Printf("%s under no configured key. They were left untouched: restore the key that sealed them as a read key before retiring anything.\n", counted(unreadable, "value opens", "values open"))
|
|
}
|
|
}
|
|
|
|
func counted(n int, one, many string) string {
|
|
return fmt.Sprintf("%d %s", n, plural(n, one, many))
|
|
}
|
|
|
|
// generatedKeys are the instance-wide values `keys generate` can mint, with their byte length.
|
|
var generatedKeys = []struct {
|
|
name string
|
|
bytes int
|
|
}{
|
|
{"CREDENTIALS_ENCRYPTION_KEY", 32},
|
|
{"AUTH_SECRET", 32},
|
|
{"TWOFA_SECRET", 32},
|
|
{"UNSUBSCRIBE_SIGNING_SECRET", 32},
|
|
{"DOMAIN_PROOF_SECRET", 32},
|
|
{"INTERNAL_API_TOKEN", 32},
|
|
{"NODE_BROKER_TOKEN", 32},
|
|
{"SECRET_KEY_BASE", 64},
|
|
}
|
|
|
|
func runKeysGenerate(args []string) error {
|
|
fs := newFlagSet("keys generate")
|
|
if err := fs.Parse(args); err != nil {
|
|
return err
|
|
}
|
|
want := map[string]bool{}
|
|
for _, name := range fs.Args() {
|
|
want[strings.ToUpper(name)] = true
|
|
}
|
|
known := map[string]bool{}
|
|
for _, k := range generatedKeys {
|
|
known[k.name] = true
|
|
}
|
|
for name := range want {
|
|
if !known[name] {
|
|
return fmt.Errorf("%s is not a key this command generates", name)
|
|
}
|
|
}
|
|
for _, k := range generatedKeys {
|
|
if len(want) > 0 && !want[k.name] {
|
|
continue
|
|
}
|
|
buf := make([]byte, k.bytes)
|
|
if _, err := rand.Read(buf); err != nil {
|
|
return err
|
|
}
|
|
fmt.Printf("%s=%s\n", k.name, hex.EncodeToString(buf))
|
|
}
|
|
return nil
|
|
}
|