Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion .env.example
Original file line number Diff line number Diff line change
Expand Up @@ -50,7 +50,7 @@
# FANOUT_ALERTS_HISTORY_DAYS=

# FANOUT_AUTH_CODE_SECRET; string; secret
# Signs local sign-in codes; required in local mode with at least 32 characters.
# Signs sign-in codes and login links; needs at least 32 characters in local mode and to issue or redeem OIDC break-glass links.
# Default: (empty)
# FANOUT_AUTH_CODE_SECRET=
# Alternatively set FANOUT_AUTH_CODE_SECRET_FILE to a secret file path; do not set both.
Expand Down
2 changes: 1 addition & 1 deletion README.md
Original file line number Diff line number Diff line change
Expand Up @@ -147,7 +147,7 @@ change requires a restart.
| `FANOUT_ADDR` | `127.0.0.1:7520` | UI, API, MCP, and both OTLP transports |
| `FANOUT_DATA_DIR` | `./data` | Parquet, query state, and control SQLite |
| `FANOUT_AUTH_MODE` | `local` | Login link or SMTP, or `oidc` |
| `FANOUT_AUTH_CODE_SECRET` | — | Required in local mode, 32+ characters |
| `FANOUT_AUTH_CODE_SECRET` | — | Required in local mode and for OIDC break-glass links, 32+ characters |
| `FANOUT_AI_PROVIDER` | — | Empty disables chat; `anthropic` or `openai` enables it |
| `ANTHROPIC_API_KEY` | — | Required for Anthropic chat |
| `OPENAI_API_KEY` | — | Required for OpenAI chat |
Expand Down
78 changes: 59 additions & 19 deletions cmd/fanout/main.go
Original file line number Diff line number Diff line change
Expand Up @@ -61,8 +61,13 @@ type repairCommand struct {
batch string
}

type loginLinkCommand struct {
email string
breakGlass bool
}

func main() {
showVersion, loginEmail, healthURL, derivedProbe, repair, err := parseCommandLine(os.Args[1:], os.Stderr)
showVersion, loginLink, healthURL, derivedProbe, repair, err := parseCommandLine(os.Args[1:], os.Stderr)
if errors.Is(err, flag.ErrHelp) {
return
}
Expand Down Expand Up @@ -103,8 +108,8 @@ func main() {
}
return
}
if loginEmail != "" {
if err := createLoginLink(cfg, loginEmail, os.Stderr); err != nil {
if loginLink != nil {
if err := createLoginLink(cfg, loginLink.email, loginLink.breakGlass, os.Stderr); err != nil {
slog.Error("create login link failed", "err", err)
os.Exit(1)
}
Expand Down Expand Up @@ -483,23 +488,23 @@ func main() {
}
}

func parseCommandLine(args []string, output io.Writer) (showVersion bool, loginEmail, healthURL string, derivedProbe bool, repair *repairCommand, err error) {
func parseCommandLine(args []string, output io.Writer) (showVersion bool, loginLink *loginLinkCommand, healthURL string, derivedProbe bool, repair *repairCommand, err error) {
if len(args) == 1 && args[0] == "version" {
return true, "", "", false, nil, nil
return true, nil, "", false, nil, nil
}
if len(args) >= 1 && len(args) <= 2 && args[0] == "healthcheck" {
if len(args) == 2 {
return false, "", args[1], false, nil, nil
return false, nil, args[1], false, nil, nil
}
return false, "", "", true, nil, nil
return false, nil, "", true, nil, nil
}

flags := flag.NewFlagSet("fanout", flag.ContinueOnError)
flags.SetOutput(output)
flags.Usage = func() {
fmt.Fprintln(output, "Usage of fanout:")
fmt.Fprintln(output, " fanout [flags]")
fmt.Fprintln(output, " fanout login-link <email>")
fmt.Fprintln(output, " fanout login-link <email> [--break-glass]")
fmt.Fprintln(output, " fanout repair verify")
fmt.Fprintln(output, " fanout repair quarantine --batch <id>")
fmt.Fprintln(output, " fanout healthcheck [url]")
Expand All @@ -510,22 +515,41 @@ func parseCommandLine(args []string, output io.Writer) (showVersion bool, loginE
flags.BoolVar(&showVersion, "version", false, "print the Fanout version")
flags.BoolVar(&showVersion, "v", false, "print the Fanout version")
if err := flags.Parse(args); err != nil {
return false, "", "", false, nil, err
return false, nil, "", false, nil, err
}
if flags.NArg() == 2 && flags.Arg(0) == "login-link" {
return false, flags.Arg(1), "", false, nil, nil
if flags.NArg() > 0 && flags.Arg(0) == "login-link" {
if command, ok := parseLoginLinkCommand(flags.Args()[1:]); ok {
return false, &command, "", false, nil, nil
}
}
if flags.NArg() > 0 && flags.Arg(0) == "repair" {
repair, err := parseRepairCommand(flags.Args()[1:], output)
return false, "", "", false, repair, err
return false, nil, "", false, repair, err
}
if flags.NArg() != 0 {
err := fmt.Errorf("unexpected arguments: %s", strings.Join(flags.Args(), " "))
fmt.Fprintln(output, err)
flags.Usage()
return false, "", "", false, nil, err
return false, nil, "", false, nil, err
}
return showVersion, "", "", false, nil, nil
return showVersion, nil, "", false, nil, nil
}

// parseLoginLinkCommand accepts --break-glass on either side of the email,
// which the standard flag package cannot do once parsing reaches an operand.
func parseLoginLinkCommand(args []string) (loginLinkCommand, bool) {
var command loginLinkCommand
for _, arg := range args {
switch {
case arg == "--break-glass":
command.breakGlass = true
case strings.HasPrefix(arg, "-") || command.email != "":
return loginLinkCommand{}, false
default:
command.email = arg
}
}
return command, command.email != ""
}

func parseRepairCommand(args []string, output io.Writer) (*repairCommand, error) {
Expand Down Expand Up @@ -673,8 +697,16 @@ func checkHealth(healthURL string, derivedProbe bool, certFile, clientCertFile,
return nil
}

func createLoginLink(cfg config.Config, rawEmail string, output io.Writer) error {
if strings.ToLower(strings.TrimSpace(cfg.AuthMode)) != "local" {
func createLoginLink(cfg config.Config, rawEmail string, breakGlass bool, output io.Writer) error {
mode := strings.ToLower(strings.TrimSpace(cfg.AuthMode))
if breakGlass {
if mode != "oidc" {
return fmt.Errorf("--break-glass is available only in oidc auth mode; use fanout login-link <email> in local mode")
}
if err := cfg.ValidateLoginLinkSecret(); err != nil {
return fmt.Errorf("break-glass login links need a configured secret: %w", err)
}
} else if mode != "local" {
return fmt.Errorf("login links are available only in local auth mode")
}
email, err := auth.NormalizeEmail(rawEmail)
Expand All @@ -699,12 +731,20 @@ func createLoginLink(cfg config.Config, rawEmail string, output io.Writer) error
if user.Status != auth.UserStatusActive {
return fmt.Errorf("user %s is suspended", email)
}
token, err := auth.NewCodeStore(sqlite.DB, cfg.AuthCodeSecret).CreateLoginLink(email)
if breakGlass && user.Role != auth.RoleAdmin {
return fmt.Errorf("user %s is not an administrator; break-glass links are limited to active administrators", email)
}
codes := auth.NewCodeStore(sqlite.DB, cfg.AuthCodeSecret)
createLink, issuedEvent, label := codes.CreateLoginLink, auth.AuditEventType("login_link.issued"), "login link"
if breakGlass {
createLink, issuedEvent, label = codes.CreateBreakGlassLoginLink, auth.AuditEventType("login_link.break_glass_issued"), "break-glass login link"
}
token, err := createLink(email)
if err != nil {
return err
}
if err := auth.NewAuditStore(sqlite.DB).Record(context.Background(), auth.AuditEvent{
EventType: "login_link.issued",
EventType: issuedEvent,
Outcome: "success",
TargetType: "user",
TargetID: user.ID,
Expand All @@ -715,7 +755,7 @@ func createLoginLink(cfg config.Config, rawEmail string, output io.Writer) error
query := loginURL.Query()
query.Set("login_token", token)
loginURL.RawQuery = query.Encode()
fmt.Fprintf(output, "fanout: login link for %s (valid 15 minutes, single use)\n %s\n", email, loginURL.String())
fmt.Fprintf(output, "fanout: %s for %s (valid 15 minutes, single use)\n %s\n", label, email, loginURL.String())
return nil
}

Expand Down
156 changes: 150 additions & 6 deletions cmd/fanout/main_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -43,7 +43,7 @@ func TestParseCommandLine(t *testing.T) {
name string
args []string
wantVersion bool
wantEmail string
wantLink *loginLinkCommand
wantHealth string
wantDerived bool
wantRepair *repairCommand
Expand All @@ -53,7 +53,12 @@ func TestParseCommandLine(t *testing.T) {
{name: "version command", args: []string{"version"}, wantVersion: true},
{name: "version flag", args: []string{"--version"}, wantVersion: true},
{name: "short version flag", args: []string{"-v"}, wantVersion: true},
{name: "login link", args: []string{"login-link", "admin@example.com"}, wantEmail: "admin@example.com"},
{name: "login link", args: []string{"login-link", "admin@example.com"}, wantLink: &loginLinkCommand{email: "admin@example.com"}},
{name: "break-glass login link", args: []string{"login-link", "--break-glass", "admin@example.com"}, wantLink: &loginLinkCommand{email: "admin@example.com", breakGlass: true}},
{name: "break-glass flag after email", args: []string{"login-link", "admin@example.com", "--break-glass"}, wantLink: &loginLinkCommand{email: "admin@example.com", breakGlass: true}},
{name: "login link break-glass without email", args: []string{"login-link", "--break-glass"}, wantErr: true},
{name: "login link unknown flag", args: []string{"login-link", "--force", "admin@example.com"}, wantErr: true},
{name: "login link two emails", args: []string{"login-link", "a@example.com", "b@example.com"}, wantErr: true},
{name: "default healthcheck", args: []string{"healthcheck"}, wantDerived: true},
{name: "custom healthcheck", args: []string{"healthcheck", "http://fanout:8080/healthz"}, wantHealth: "http://fanout:8080/healthz"},
{name: "repair verify", args: []string{"repair", "verify"}, wantRepair: &repairCommand{action: "verify"}},
Expand All @@ -66,12 +71,15 @@ func TestParseCommandLine(t *testing.T) {

for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
showVersion, email, healthURL, derivedProbe, repair, err := parseCommandLine(test.args, io.Discard)
showVersion, loginLink, healthURL, derivedProbe, repair, err := parseCommandLine(test.args, io.Discard)
if (err != nil) != test.wantErr {
t.Fatalf("error = %v, wantErr %v", err, test.wantErr)
}
if showVersion != test.wantVersion || email != test.wantEmail || healthURL != test.wantHealth || derivedProbe != test.wantDerived {
t.Fatalf("result = (%v, %q, %q, %v), want (%v, %q, %q, %v)", showVersion, email, healthURL, derivedProbe, test.wantVersion, test.wantEmail, test.wantHealth, test.wantDerived)
if showVersion != test.wantVersion || healthURL != test.wantHealth || derivedProbe != test.wantDerived {
t.Fatalf("result = (%v, %q, %v), want (%v, %q, %v)", showVersion, healthURL, derivedProbe, test.wantVersion, test.wantHealth, test.wantDerived)
}
if loginLink == nil != (test.wantLink == nil) || loginLink != nil && *loginLink != *test.wantLink {
t.Fatalf("login link = %#v, want %#v", loginLink, test.wantLink)
}
if repair == nil != (test.wantRepair == nil) || repair != nil && *repair != *test.wantRepair {
t.Fatalf("repair = %#v, want %#v", repair, test.wantRepair)
Expand Down Expand Up @@ -191,7 +199,7 @@ func TestCreateLoginLink(t *testing.T) {
}

var output bytes.Buffer
if err := createLoginLink(cfg, " ADMIN@example.com ", &output); err != nil {
if err := createLoginLink(cfg, " ADMIN@example.com ", false, &output); err != nil {
t.Fatalf("createLoginLink: %v", err)
}
line := strings.TrimSpace(strings.Split(output.String(), "\n")[1])
Expand Down Expand Up @@ -221,6 +229,142 @@ func TestCreateLoginLink(t *testing.T) {
}
}

func breakGlassTestConfig(t *testing.T, role auth.Role, status auth.UserStatus) config.Config {
t.Helper()
cfg := config.Config{
AuthMode: "oidc",
AuthCodeSecret: "0123456789abcdef0123456789abcdef",
DataDir: t.TempDir(),
Addr: ":7520",
PublicURL: "https://fanout.example.com",
}
if err := os.MkdirAll(cfg.ControlDir(), 0o755); err != nil {
t.Fatalf("MkdirAll: %v", err)
}
sqlite, err := store.NewSQLite(cfg.ControlSQLitePath())
if err != nil {
t.Fatalf("NewSQLite: %v", err)
}
defer sqlite.Close()
users := auth.NewUserStore(sqlite.DB)
if _, err := users.CreateWithAudit("keeper@example.com", "", auth.RoleAdmin, auth.AuditEvent{EventType: "user.created", Outcome: "success"}); err != nil {
t.Fatalf("Create keeper: %v", err)
}
user, err := users.CreateWithAudit("user@example.com", "", auth.RoleAdmin, auth.AuditEvent{EventType: "user.created", Outcome: "success"})
if err != nil {
t.Fatalf("Create user: %v", err)
}
if _, err := users.UpdateWithAudit(user.ID, nil, nil, &role, &status, auth.AuditEvent{EventType: "user.updated", Outcome: "success"}); err != nil {
t.Fatalf("Update user: %v", err)
}
return cfg
}

func loginLinkState(t *testing.T, cfg config.Config) (links, issued, breakGlassIssued int) {
t.Helper()
sqlite, err := store.NewSQLite(cfg.ControlSQLitePath())
if err != nil {
t.Fatalf("reopen SQLite: %v", err)
}
defer sqlite.Close()
if err := sqlite.DB.QueryRow(`SELECT COUNT(*) FROM verifications`).Scan(&links); err != nil {
t.Fatalf("count verifications: %v", err)
}
if err := sqlite.DB.QueryRow(`SELECT COUNT(*) FROM auth_audit_events WHERE event_type = 'login_link.issued'`).Scan(&issued); err != nil {
t.Fatalf("count issued: %v", err)
}
if err := sqlite.DB.QueryRow(`SELECT COUNT(*) FROM auth_audit_events WHERE event_type = 'login_link.break_glass_issued'`).Scan(&breakGlassIssued); err != nil {
t.Fatalf("count break-glass issued: %v", err)
}
return links, issued, breakGlassIssued
}

func TestCreateBreakGlassLoginLinkForActiveAdministrator(t *testing.T) {
cfg := breakGlassTestConfig(t, auth.RoleAdmin, auth.UserStatusActive)
var output bytes.Buffer
if err := createLoginLink(cfg, "user@example.com", true, &output); err != nil {
t.Fatalf("createLoginLink: %v", err)
}
if !strings.Contains(output.String(), "break-glass") {
t.Fatalf("output = %q, want it to identify a break-glass link", output.String())
}
loginURL, err := url.Parse(strings.TrimSpace(strings.Split(output.String(), "\n")[1]))
if err != nil {
t.Fatalf("parse URL: %v", err)
}
sqlite, err := store.NewSQLite(cfg.ControlSQLitePath())
if err != nil {
t.Fatalf("reopen SQLite: %v", err)
}
defer sqlite.Close()
codes := auth.NewCodeStore(sqlite.DB, cfg.AuthCodeSecret)
if _, ok, err := codes.VerifyLoginLink(loginURL.Query().Get("login_token")); err != nil || ok {
t.Fatalf("VerifyLoginLink(break-glass) = (%v, %v), want (false, nil)", ok, err)
}
if email, ok, err := codes.VerifyBreakGlassLoginLink(loginURL.Query().Get("login_token")); err != nil || !ok || email != "user@example.com" {
t.Fatalf("VerifyBreakGlassLoginLink = (%q, %v, %v)", email, ok, err)
}
var issued, breakGlassIssued int
if err := sqlite.DB.QueryRow(`SELECT
COUNT(*) FILTER (WHERE event_type = 'login_link.issued'),
COUNT(*) FILTER (WHERE event_type = 'login_link.break_glass_issued')
FROM auth_audit_events`).Scan(&issued, &breakGlassIssued); err != nil {
t.Fatalf("query audit: %v", err)
}
if issued != 0 || breakGlassIssued != 1 {
t.Fatalf("issued = %d, break-glass issued = %d, want 0 and 1", issued, breakGlassIssued)
}
}

func TestCreateBreakGlassLoginLinkRefusals(t *testing.T) {
const email = "user@example.com"
for _, tc := range []struct {
name string
role auth.Role
status auth.UserStatus
mutate func(*config.Config)
email string
wantErr string
}{
{name: "viewer", role: auth.RoleViewer, status: auth.UserStatusActive, email: email, wantErr: "administrator"},
{name: "operator", role: auth.RoleOperator, status: auth.UserStatusActive, email: email, wantErr: "administrator"},
{name: "suspended administrator", role: auth.RoleAdmin, status: auth.UserStatusSuspended, email: email, wantErr: "suspended"},
{name: "empty secret", role: auth.RoleAdmin, status: auth.UserStatusActive, email: email, mutate: func(c *config.Config) { c.AuthCodeSecret = "" }, wantErr: "FANOUT_AUTH_CODE_SECRET"},
{name: "short secret", role: auth.RoleAdmin, status: auth.UserStatusActive, email: email, mutate: func(c *config.Config) { c.AuthCodeSecret = "short" }, wantErr: "FANOUT_AUTH_CODE_SECRET"},
{name: "local mode", role: auth.RoleAdmin, status: auth.UserStatusActive, email: email, mutate: func(c *config.Config) { c.AuthMode = "local" }, wantErr: "oidc"},
} {
t.Run(tc.name, func(t *testing.T) {
cfg := breakGlassTestConfig(t, tc.role, tc.status)
if tc.mutate != nil {
tc.mutate(&cfg)
}
var output bytes.Buffer
err := createLoginLink(cfg, tc.email, true, &output)
if err == nil || !strings.Contains(err.Error(), tc.wantErr) {
t.Fatalf("error = %v, want it to mention %q", err, tc.wantErr)
}
if output.Len() != 0 {
t.Fatalf("output = %q, want none", output.String())
}
if links, issued, breakGlassIssued := loginLinkState(t, cfg); links != 0 || issued != 0 || breakGlassIssued != 0 {
t.Fatalf("state = %d links, %d issued, %d break-glass issued; want none", links, issued, breakGlassIssued)
}
})
}
}

func TestCreateLoginLinkWithoutFlagStillRefusesOIDCMode(t *testing.T) {
cfg := breakGlassTestConfig(t, auth.RoleAdmin, auth.UserStatusActive)
var output bytes.Buffer
err := createLoginLink(cfg, "user@example.com", false, &output)
if err == nil || err.Error() != "login links are available only in local auth mode" {
t.Fatalf("error = %v", err)
}
if links, issued, breakGlassIssued := loginLinkState(t, cfg); links != 0 || issued != 0 || breakGlassIssued != 0 {
t.Fatalf("state = %d links, %d issued, %d break-glass issued; want none", links, issued, breakGlassIssued)
}
}

func TestHealthcheckURL(t *testing.T) {
for _, tc := range []struct{ addr, cert, want string }{
{"", "", "http://127.0.0.1:7520/healthz"},
Expand Down
Loading
Loading