A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
feat(rexctl): first-run setup with admin, email and recovery kit
Hampusa21c19d76c37
diff --git a/fluxer_rexctl/internal/setup/captcha.go b/fluxer_rexctl/internal/setup/captcha.gonew file mode 100644index 000000000..de3e540c1--- /dev/null+++ b/fluxer_rexctl/internal/setup/captcha.go@@ -0,0 +1,146 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package setup++import (+ "bytes"+ "context"+ "crypto/pbkdf2"+ "crypto/sha256"+ "encoding/base64"+ "encoding/binary"+ "encoding/hex"+ "encoding/json"+ "errors"+ "math"+ "net/http"+ "runtime"+ "sync"+ "sync/atomic"++ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/adminapi"+)++const (+ captchaHeader = "X-Captcha-Token"+ altchaAlgorithm = "PBKDF2/SHA-256"+ maxCaptchaRounds = 3+)++var ErrCaptcha = errors.New("setup: couldn't solve the sign-up challenge")++type altchaChallenge struct {+ Parameters struct {+ Algorithm string `json:"algorithm"`+ Nonce string `json:"nonce"`+ Salt string `json:"salt"`+ Cost int `json:"cost"`+ KeyLength int `json:"keyLength"`+ KeyPrefix string `json:"keyPrefix"`+ } `json:"parameters"`+}++type altchaSolution struct {+ Counter uint32 `json:"counter"`+ DerivedKey string `json:"derivedKey"`+}++func register(ctx context.Context, c *adminapi.Client, account map[string]any, out any) error {+ var headers map[string]string+ for range maxCaptchaRounds {+ err := c.Loopback(ctx, http.MethodPost, "/auth/register", headers, account, out)+ raw, ok := captchaChallenge(err)+ if !ok {+ return err+ }+ token, serr := solveAltcha(ctx, raw)+ if serr != nil {+ return serr+ }+ headers = map[string]string{captchaHeader: token}+ }+ return ErrCaptcha+}++func captchaChallenge(err error) (json.RawMessage, bool) {+ var apiErr *adminapi.APIError+ if !errors.As(err, &apiErr) || (apiErr.Code != "CAPTCHA_REQUIRED" && apiErr.Code != "INVALID_CAPTCHA") {+ return nil, false+ }+ var body struct {+ Provider string `json:"captcha_provider"`+ Challenge json.RawMessage `json:"altcha_challenge"`+ }+ if json.Unmarshal(apiErr.Body, &body) != nil || body.Provider != "altcha" || len(body.Challenge) == 0 {+ return nil, false+ }+ return body.Challenge, true+}++func solveAltcha(ctx context.Context, raw json.RawMessage) (string, error) {+ var ch altchaChallenge+ if err := json.Unmarshal(raw, &ch); err != nil {+ return "", err+ }+ p := ch.Parameters+ nonce, nerr := hex.DecodeString(p.Nonce)+ salt, serr := hex.DecodeString(p.Salt)+ prefix, perr := hex.DecodeString(p.KeyPrefix)+ if p.Algorithm != altchaAlgorithm || nerr != nil || serr != nil || perr != nil || p.Cost <= 0 || p.KeyLength <= 0 || len(prefix) == 0 {+ return "", ErrCaptcha+ }+ sol, err := searchAltcha(ctx, nonce, salt, prefix, p.Cost, p.KeyLength)+ if err != nil {+ return "", err+ }+ payload, err := json.Marshal(struct {+ Challenge json.RawMessage `json:"challenge"`+ Solution altchaSolution `json:"solution"`+ }{raw, *sol})+ if err != nil {+ return "", err+ }+ return base64.StdEncoding.EncodeToString(payload), nil+}++func searchAltcha(parent context.Context, nonce, salt, prefix []byte, cost, keyLength int) (*altchaSolution, error) {+ ctx, cancel := context.WithCancel(parent)+ defer cancel()+ workers := runtime.NumCPU()+ var next atomic.Uint64+ var once sync.Once+ var found *altchaSolution+ var wg sync.WaitGroup+ for range workers {+ wg.Go(func() {+ password := make([]byte, len(nonce)+4)+ copy(password, nonce)+ for ctx.Err() == nil {+ n := next.Add(1) - 1+ if n > math.MaxUint32 {+ return+ }+ binary.BigEndian.PutUint32(password[len(nonce):], uint32(n))+ key, err := pbkdf2.Key(sha256.New, string(password), salt, cost, keyLength)+ if err != nil {+ return+ }+ if bytes.HasPrefix(key, prefix) {+ once.Do(func() {+ found = &altchaSolution{Counter: uint32(n), DerivedKey: hex.EncodeToString(key)}+ cancel()+ })+ return+ }+ }+ })+ }+ wg.Wait()+ if found != nil {+ return found, nil+ }+ if err := parent.Err(); err != nil {+ return nil, err+ }+ return nil, ErrCaptcha+}diff --git a/fluxer_rexctl/internal/setup/setup.go b/fluxer_rexctl/internal/setup/setup.gonew file mode 100644index 000000000..a7a4cd917--- /dev/null+++ b/fluxer_rexctl/internal/setup/setup.go@@ -0,0 +1,333 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package setup++import (+ "context"+ "errors"+ "fmt"+ "net/http"+ "net/mail"+ "path/filepath"+ "regexp"+ "strings"+ "time"++ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/adminapi"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/envfile"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/secrets"+)++const TokenKey = "FLUXER_SETUP_TOKEN"++type SignIn string++const (+ SignInEmail SignIn = "email"+ SignInUsername SignIn = "username"+)++type Registration string++const (+ RegistrationOpen Registration = "open"+ RegistrationApproval Registration = "approval"+ RegistrationInvite Registration = "invite"+ RegistrationClosed Registration = "closed"+)++type SMTP struct {+ Host string+ Port int+ TLS string+ Username string+ Password string+ From string+}++type Answers struct {+ SignIn SignIn+ Email string+ Username string+ Password string+ Name string+ Registration Registration+ SMTP *SMTP+}++type Result struct {+ UserID string+ RecoveryKitPath string+ TestEmailSentTo string+}++var (+ ErrNoToken = errors.New("setup: no setup token")+ ErrAlreadyDone = errors.New("setup: already finished")+ ErrPendingSignup = errors.New("setup: the account is waiting for approval")+ ErrRecoveryKit = errors.New("setup: couldn't save the recovery kit")+)++type SMTPError struct {+ Message string+}++func (e *SMTPError) Error() string { return e.Message }++func Token(values map[string]string) string {+ if t := strings.TrimSpace(values[TokenKey]); t != "CHANGE_ME" {+ return t+ }+ return ""+}++func EnsureToken(values map[string]string) (string, error) {+ if t := Token(values); t != "" {+ return t, nil+ }+ t, err := secrets.Hex(16)+ if err != nil {+ return "", err+ }+ values[TokenKey] = t+ return t, nil+}++type discovery struct {+ AppPublic struct {+ Setup struct {+ Configured bool `json:"configured"`+ LockReason string `json:"account_identity_lock_reason"`+ } `json:"setup"`+ } `json:"app_public"`+}++func Done(ctx context.Context, c *adminapi.Client) (bool, error) {+ var d discovery+ if err := c.Loopback(ctx, http.MethodGet, "/.well-known/fluxer", nil, nil, &d); err != nil {+ return false, err+ }+ return d.AppPublic.Setup.Configured, nil+}++func AccountsExist(ctx context.Context, c *adminapi.Client) (admin bool, exists bool, err error) {+ var d discovery+ if err := c.Loopback(ctx, http.MethodGet, "/.well-known/fluxer", nil, nil, &d); err != nil {+ return false, false, err+ }+ switch d.AppPublic.Setup.LockReason {+ case "admin_exists":+ return true, true, nil+ case "accounts_exist", "existing_instance":+ return false, true, nil+ }+ return false, false, nil+}++type registerResponse struct {+ Token string `json:"token"`+ UserID string `json:"user_id"`+}++type recoveryKitResponse struct {+ RecoveryKey string `json:"recovery_key"`+ CreatedAt string `json:"created_at"`+}++func Run(ctx context.Context, c *adminapi.Client, token, origin, dir string, a Answers) (*Result, error) {+ token = strings.TrimSpace(token)+ if token == "" {+ return nil, ErrNoToken+ }+ patch := map[string]any{+ "app_public": map[string]any{"branding": map[string]any{"product_name": a.Name}},+ "registration": registrationPatch(a.Registration),+ }+ if a.SMTP != nil {+ email, err := emailPatch(*a.SMTP, a.Name)+ if err != nil {+ return nil, err+ }+ patch["integrations"] = map[string]any{"email": email}+ }+ done, err := Done(ctx, c)+ if err != nil {+ return nil, err+ }+ if done {+ return nil, ErrAlreadyDone+ }+ if err := c.Loopback(ctx, http.MethodPost, "/instance/setup/token-checks", nil, map[string]any{"setup_token": token}, nil); err != nil {+ return nil, err+ }+ identity := map[string]any{"mode": string(a.SignIn), "setup_token": token}+ if err := c.Loopback(ctx, http.MethodPut, "/instance/setup/account-identity", nil, identity, nil); err != nil {+ return nil, err+ }+ account := map[string]any{"username": a.Username, "password": a.Password, "setup_token": token}+ if a.SignIn == SignInEmail {+ account["email"] = a.Email+ }+ var reg registerResponse+ if err := register(ctx, c, account, ®); err != nil {+ return nil, err+ }+ if reg.Token == "" {+ return nil, ErrPendingSignup+ }+ auth := map[string]string{"Authorization": reg.Token}+ res := &Result{UserID: reg.UserID}++ if err := c.Call(ctx, http.MethodPatch, "/admin/instance/config", nil, patch, nil); err != nil {+ return res, err+ }++ var kitErr error+ if a.SignIn == SignInUsername {+ res.RecoveryKitPath, kitErr = saveRecoveryKit(ctx, c, auth, origin, dir, a)+ }++ finish := map[string]any{"app_public": map[string]any{"setup": map[string]any{"configured": true}}}+ if err := c.Call(ctx, http.MethodPatch, "/admin/instance/config", nil, finish, nil); err != nil {+ return res, err+ }+ if kitErr != nil {+ return res, fmt.Errorf("%w: %w", ErrRecoveryKit, kitErr)+ }+ return res, nil+}++func registrationPatch(r Registration) map[string]any {+ switch r {+ case RegistrationOpen:+ return map[string]any{"mode": "open", "admin_registration_urls_enabled": true}+ case RegistrationApproval:+ return map[string]any{"mode": "approval", "admin_registration_urls_enabled": true}+ case RegistrationClosed:+ return map[string]any{"mode": "closed", "admin_registration_urls_enabled": false}+ default:+ return map[string]any{"mode": "closed", "admin_registration_urls_enabled": true}+ }+}++func tlsMode(s SMTP) string {+ if s.TLS != "" {+ return s.TLS+ }+ return adminapi.TLSModeFor(s.Port)+}++func emailPatch(s SMTP, name string) (map[string]any, error) {+ addr, err := mail.ParseAddress(s.From)+ if err != nil {+ return nil, err+ }+ fromName := addr.Name+ if fromName == "" {+ fromName = name+ }+ return map[string]any{+ "enabled": true,+ "provider": "smtp",+ "from_email": addr.Address,+ "from_name": fromName,+ "smtp": map[string]any{+ "host": s.Host,+ "port": s.Port,+ "username": s.Username,+ "password": s.Password,+ "tls_mode": tlsMode(s),+ },+ }, nil+}++type smtpTestResponse struct {+ OK bool `json:"ok"`+ Error *string `json:"error"`+}++func TestSMTP(ctx context.Context, c *adminapi.Client, s SMTP, name, to string) error {+ patch, err := emailPatch(s, name)+ if err != nil {+ return err+ }+ body := map[string]any{+ "host": s.Host,+ "port": s.Port,+ "tls_mode": tlsMode(s),+ "username": nil,+ "password": nil,+ "from_email": patch["from_email"],+ "from_name": nil,+ }+ if fromName, _ := patch["from_name"].(string); strings.TrimSpace(fromName) != "" {+ body["from_name"] = fromName+ }+ if s.Username != "" {+ body["username"] = s.Username+ }+ if s.Password != "" {+ body["password"] = s.Password+ }+ if to != "" {+ body["send_to"] = to+ }+ var out smtpTestResponse+ if err := c.Call(ctx, http.MethodPost, "/admin/instance/config/smtp-tests", nil, body, &out); err != nil {+ return err+ }+ if !out.OK {+ msg := "The SMTP server refused the connection."+ if out.Error != nil && strings.TrimSpace(*out.Error) != "" {+ msg = strings.TrimSpace(*out.Error)+ }+ return &SMTPError{Message: msg}+ }+ return nil+}++func saveRecoveryKit(ctx context.Context, c *adminapi.Client, auth map[string]string, origin, dir string, a Answers) (string, error) {+ var kit recoveryKitResponse+ if err := c.Loopback(ctx, http.MethodPost, "/users/@me/recovery-kit", auth, map[string]any{"password": a.Password}, &kit); err != nil {+ return "", err+ }+ path := filepath.Join(dir, "recovery-kit-"+slug(a.Username)+".txt")+ data := recoveryKitText(strings.TrimRight(origin, "/"), a.Name, a.Username, kit)+ if err := envfile.WriteFileAtomic(path, []byte(data), true); err != nil {+ return "", err+ }+ return path, nil+}++func recoveryKitText(origin, name, username string, kit recoveryKitResponse) string {+ created := kit.CreatedAt+ if t, err := time.Parse(time.RFC3339Nano, kit.CreatedAt); err == nil {+ created = t.UTC().Format("2 January 2006 15:04 UTC")+ }+ title := "Fluxer recovery kit"+ if name != "" {+ title = name + " recovery kit"+ }+ var b strings.Builder+ b.WriteString(title + "\n\n")+ b.WriteString("Keep this file somewhere safe. If you forget your password, you can use it to get back into your account. Anyone with this recovery key can reset your password. Never share it.\n\n")+ fmt.Fprintf(&b, "Instance %s\n", origin)+ fmt.Fprintf(&b, "Username %s\n", username)+ fmt.Fprintf(&b, "Recovery key %s\n", kit.RecoveryKey)+ fmt.Fprintf(&b, "Created %s\n\n", created)+ b.WriteString("How to recover your account\n\n")+ fmt.Fprintf(&b, "1. Go to %s/recover.\n", origin)+ b.WriteString("2. Enter your username and this recovery key.\n")+ b.WriteString("3. Choose a new password. You get a new recovery kit and this one stops working.\n")+ return b.String()+}++var slugPattern = regexp.MustCompile(`[^a-z0-9]+`)++func slug(s string) string {+ out := strings.Trim(slugPattern.ReplaceAllString(strings.ToLower(s), "-"), "-")+ if out == "" {+ return "admin"+ }+ return out+}