Skip to content

Modern Docker Management, Designed for Everyone

5.8 KB
Raw Blame
package admin

import (
	"context"
	"errors"
	"fmt"
	"io"
	"log/slog"
	"os"
	"strings"

	"github.com/spf13/cobra"
	kit "go.getarcane.app/kit/pkg"
	"golang.org/x/term"

	"github.com/getarcaneapp/arcane/backend/v2/internal/common"
	"github.com/getarcaneapp/arcane/backend/v2/internal/config"
	"github.com/getarcaneapp/arcane/backend/v2/internal/database"
	"github.com/getarcaneapp/arcane/backend/v2/internal/role"
	"github.com/getarcaneapp/arcane/backend/v2/internal/session"
	"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
	"github.com/getarcaneapp/arcane/backend/v2/internal/user"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/validation"
)

const defaultAdminUsername = "arcane"

var resetPasswordUsername string

// AdminCmd contains administration commands that run inside the Arcane
// container without starting the HTTP server.
var AdminCmd = &cobra.Command{
	Use:   "admin",
	Short: "Manage Arcane administration",
}

var resetPasswordCmd = &cobra.Command{
	Use:          "reset-password",
	Short:        "Reset the password for a global administrator",
	Long:         "Reset the password for a global administrator. This command must be explicitly enabled with ALLOW_CLI_PASSWORD_RESET=true.",
	Args:         cobra.NoArgs,
	SilenceUsage: true,
	RunE:         runResetPasswordCommandInternal,
}

func init() {
	resetPasswordCmd.Flags().StringVar(&resetPasswordUsername, "username", defaultAdminUsername, "Username of the global administrator")
	AdminCmd.AddCommand(resetPasswordCmd)
}

func runResetPasswordCommandInternal(cmd *cobra.Command, _ []string) error {
	cfg := config.Load()
	if err := ensurePasswordResetEnabledInternal(cfg); err != nil {
		return err
	}

	username := strings.TrimSpace(resetPasswordUsername)
	if username == "" {
		return errors.New("username cannot be empty")
	}

	db, err := database.Initialize(cmd.Context(), cfg.DatabaseURL, database.MigrationOptions{
		AllowDowngrade: cfg.AllowDowngrade,
	})
	if err != nil {
		return fmt.Errorf("failed to initialize database: %w", err)
	}
	defer func() {
		if closeErr := db.Close(); closeErr != nil {
			slog.WarnContext(cmd.Context(), "Failed to close database after password reset", "error", closeErr)
		}
	}()

	policy := passwordPolicyFromDBInternal(cmd.Context(), db)

	password, err := readNewPasswordInternal(cmd.OutOrStdout(), policy)
	if err != nil {
		return err
	}

	if resetPasswordErr := resetPasswordInternal(cmd.Context(), db, username, password, policy); resetPasswordErr != nil {
		return resetPasswordErr
	}

	if _, fprintfErr := fmt.Fprintf(cmd.OutOrStdout(), "Password reset successfully for global administrator %q\n", username); fprintfErr != nil {
		return fmt.Errorf("failed to write password reset result: %w", fprintfErr)
	}
	return nil
}

func ensurePasswordResetEnabledInternal(cfg *config.Config) error {
	if cfg == nil {
		return errors.New("password reset config is nil")
	}
	if !cfg.AllowCLIPasswordReset {
		return errors.New("CLI password reset is disabled; set ALLOW_CLI_PASSWORD_RESET=true to enable it")
	}
	return nil
}

func readNewPasswordInternal(out io.Writer, policy string) (string, error) {
	password, err := readPasswordInternal(out, "New password: ")
	if err != nil {
		return "", fmt.Errorf("failed to read new password: %w", err)
	}

	confirmation, err := readPasswordInternal(out, "Confirm new password: ")
	if err != nil {
		return "", fmt.Errorf("failed to read password confirmation: %w", err)
	}

	if validatePasswordPairErr := validatePasswordPairInternal(password, confirmation, policy); validatePasswordPairErr != nil {
		return "", validatePasswordPairErr
	}
	return password, nil
}

func readPasswordInternal(out io.Writer, prompt string) (string, error) {
	if _, err := fmt.Fprint(out, prompt); err != nil {
		return "", err
	}
	password, err := term.ReadPassword(int(os.Stdin.Fd()))
	if _, printErr := fmt.Fprintln(out); err == nil {
		err = printErr
	}
	if err != nil {
		return "", err
	}
	return string(password), nil
}

func validatePasswordPairInternal(password, confirmation, policy string) error {
	if err := validation.ValidatePasswordPolicy(password, policy); err != nil {
		return err
	}
	if password != confirmation {
		return errors.New("passwords do not match")
	}
	return nil
}

func passwordPolicyFromDBInternal(ctx context.Context, db *database.DB) string {
	var setting settings.SettingVariable
	err := db.WithContext(ctx).First(&setting, "key = ?", "authPasswordPolicy").Error
	return kit.Ternary(err != nil || strings.TrimSpace(setting.Value) == "", validation.PasswordPolicyStrong, setting.Value)
}

func resetPasswordInternal(ctx context.Context, db *database.DB, username, password, policy string) error {
	if db == nil {
		return errors.New("database is nil")
	}

	username = strings.TrimSpace(username)
	if username == "" {
		return errors.New("username cannot be empty")
	}
	if err := validation.ValidatePasswordPolicy(password, policy); err != nil {
		return err
	}

	roleService := role.NewRoleService(db)
	userService := user.NewUserService(db, roleService, session.RevokeAllUserSessionsExceptInDB)
	target, err := userService.GetUserByUsername(ctx, username)
	if err != nil {
		if errors.Is(err, common.ErrUserNotFound) {
			return fmt.Errorf("global administrator %q not found", username)
		}
		return fmt.Errorf("failed to find user: %w", err)
	}

	permissions, err := roleService.ResolvePermissions(ctx, target.ID)
	if err != nil {
		return fmt.Errorf("failed to resolve user permissions: %w", err)
	}
	if permissions == nil || !permissions.IsGlobalAdmin() {
		return fmt.Errorf("user %q does not have effective global administrator permissions", username)
	}

	if _, setPasswordAndRevokeSessionsExceptErr := userService.SetPasswordAndRevokeSessionsExcept(ctx, target, password, "", nil); setPasswordAndRevokeSessionsExceptErr != nil {
		return fmt.Errorf("failed to reset password: %w", setPasswordAndRevokeSessionsExceptErr)
	}

	return nil
}