package postgres import ( "context" "crypto/rand" "encoding/base64" "encoding/json" "errors" "net" "net/url" "strings" "time" "github.com/go-webauthn/webauthn/protocol" "github.com/go-webauthn/webauthn/webauthn" "github.com/jackc/pgx/v5" "github.com/samcharles93/archie-core/internal/domain/access" "github.com/samcharles93/archie-core/internal/domain/identity" "github.com/samcharles93/archie-core/internal/infrastructure/postgres/postgresdb" ) type passkeyUser struct { value identity.Identity credentials []webauthn.Credential } func (u passkeyUser) WebAuthnID() []byte { return []byte(u.value.ID) } func (u passkeyUser) WebAuthnName() string { return u.value.DisplayName } func (u passkeyUser) WebAuthnDisplayName() string { return u.value.DisplayName } func (u passkeyUser) WebAuthnCredentials() []webauthn.Credential { return u.credentials } func (s *Store) webAuthn(ctx context.Context) (*webauthn.WebAuthn, error) { settings, err := s.AuthenticationSettings(ctx) if err != nil { return nil, err } u, err := url.Parse(settings.PublicURL) secure := err == nil && (u.Scheme == "https" || (u.Scheme == "http" && u.Hostname() == "localhost")) if !secure || u.Hostname() == "" || net.ParseIP(u.Hostname()) != nil { return nil, identity.ErrInvalid } return webauthn.New(&webauthn.Config{RPDisplayName: "Archie", RPID: u.Hostname(), RPOrigins: []string{strings.TrimRight(settings.PublicURL, "/")}, AuthenticatorSelection: protocol.AuthenticatorSelection{UserVerification: protocol.VerificationRequired, ResidentKey: protocol.ResidentKeyRequirementRequired}}) } func loadPasskeyUser(ctx context.Context, q *postgresdb.Queries, db interface { Query(context.Context, string, ...any) (pgx.Rows, error) }, id string, ) (passkeyUser, error) { row, err := q.GetIdentity(ctx, id) if err != nil { return passkeyUser{}, err } user := passkeyUser{value: identityFromRow(row)} if user.value.Kind != identity.KindUser || !user.value.CanAct() { return passkeyUser{}, identity.ErrCredentialRejected } rows, err := db.Query(ctx, `SELECT credential FROM passkeys WHERE identity_id=$1`, id) if err != nil { return passkeyUser{}, err } defer rows.Close() for rows.Next() { var data []byte if err = rows.Scan(&data); err != nil { return passkeyUser{}, err } var credential webauthn.Credential if err = json.Unmarshal(data, &credential); err != nil { return passkeyUser{}, err } user.credentials = append(user.credentials, credential) } return user, rows.Err() } func (s *Store) BeginPasskey(ctx context.Context, registration bool) (identity.PasskeyCeremony, error) { wa, err := s.webAuthn(ctx) if err != nil { return identity.PasskeyCeremony{}, err } var options any var session *webauthn.SessionData var owner string if registration { p, ok := access.PrincipalFromContext(ctx) if !ok { return identity.PasskeyCeremony{}, identity.ErrCredentialRejected } owner = string(p.IdentityID) user, loadErr := loadPasskeyUser(ctx, s.queries(), s.pool, owner) if loadErr != nil { return identity.PasskeyCeremony{}, loadErr } options, session, err = wa.BeginRegistration(user) } else { options, session, err = wa.BeginDiscoverableLogin(webauthn.WithUserVerification(protocol.VerificationRequired)) } if err != nil { return identity.PasskeyCeremony{}, err } data, err := json.Marshal(session) if err != nil { return identity.PasskeyCeremony{}, err } encoded, err := json.Marshal(options) if err != nil { return identity.PasskeyCeremony{}, err } token := rand.Text() if _, err = s.pool.Exec(ctx, `DELETE FROM passkey_ceremonies WHERE expires_at<=now()`); err != nil { return identity.PasskeyCeremony{}, err } _, err = s.pool.Exec(ctx, `INSERT INTO passkey_ceremonies (token_hash,identity_id,registration,session_data,expires_at) VALUES ($1,$2,$3,$4,now()+interval '5 minutes')`, sessionHash(token), owner, registration, data) return identity.PasskeyCeremony{Token: token, Options: encoded}, err } func (s *Store) FinishPasskey(ctx context.Context, token string, response []byte, registration bool, name string) (identity.AccountSession, error) { wa, err := s.webAuthn(ctx) if err != nil { return identity.AccountSession{}, err } var owner string var data []byte // Consume before verification: failed and successful attempts are single-use. err = s.pool.QueryRow(ctx, `DELETE FROM passkey_ceremonies WHERE token_hash=$1 AND registration=$2 AND expires_at>now() RETURNING identity_id,session_data`, sessionHash(token), registration).Scan(&owner, &data) if errors.Is(err, pgx.ErrNoRows) { return identity.AccountSession{}, identity.ErrCredentialRejected } if err != nil { return identity.AccountSession{}, err } var session webauthn.SessionData if err = json.Unmarshal(data, &session); err != nil { return identity.AccountSession{}, err } tx, err := s.pool.Begin(ctx) if err != nil { return identity.AccountSession{}, err } defer func() { _ = tx.Rollback(ctx) }() credential, user, err := verifyPasskey(ctx, tx, wa, owner, session, response, registration) if err != nil || credential == nil || credential.Authenticator.CloneWarning { return identity.AccountSession{}, identity.ErrCredentialRejected } owner = string(user.value.ID) if err := persistPasskey(ctx, tx, credential, owner, name, registration); err != nil { return identity.AccountSession{}, err } result := identity.AccountSession{Identity: user.value} if !registration { result.Token = rand.Text() result.Expires = time.Now().UTC().Add(identity.AccountSessionLifetime) _, err = tx.Exec(ctx, `INSERT INTO account_sessions (token_hash,identity_id,expires_at) VALUES ($1,$2,$3)`, sessionHash(result.Token), owner, result.Expires) if err != nil { return identity.AccountSession{}, err } } if err = tx.Commit(ctx); err != nil { return identity.AccountSession{}, err } return result, nil } func (s *Store) ListPasskeys(ctx context.Context) ([]identity.Passkey, error) { p, ok := access.PrincipalFromContext(ctx) if !ok { return nil, identity.ErrCredentialRejected } rows, err := s.pool.Query(ctx, `SELECT credential_id,name FROM passkeys WHERE identity_id=$1 ORDER BY created_at`, string(p.IdentityID)) if err != nil { return nil, err } defer rows.Close() out := []identity.Passkey{} for rows.Next() { var value identity.Passkey if err = rows.Scan(&value.ID, &value.Name); err != nil { return nil, err } out = append(out, value) } return out, rows.Err() } func (s *Store) DeletePasskey(ctx context.Context, id string) error { p, ok := access.PrincipalFromContext(ctx) if !ok { return identity.ErrCredentialRejected } result, err := s.pool.Exec(ctx, `DELETE FROM passkeys WHERE credential_id=$1 AND identity_id=$2`, id, string(p.IdentityID)) if err != nil { return err } if result.RowsAffected() != 1 { return identity.ErrNotFound } return nil } func verifyPasskey(ctx context.Context, tx pgx.Tx, wa *webauthn.WebAuthn, owner string, session webauthn.SessionData, response []byte, registration bool) (*webauthn.Credential, passkeyUser, error) { if registration { return verifyPasskeyRegistration(ctx, tx, wa, owner, session, response) } var user passkeyUser parsed, err := protocol.ParseCredentialRequestResponseBytes(response) if err != nil { return nil, user, identity.ErrCredentialRejected } credential, err := wa.ValidateDiscoverableLogin(func(rawID, userHandle []byte) (webauthn.User, error) { if err = tx.QueryRow(ctx, `SELECT identity_id FROM passkeys WHERE credential_id=$1 FOR UPDATE`, base64.RawURLEncoding.EncodeToString(rawID)).Scan(&owner); err != nil { return nil, identity.ErrCredentialRejected } if owner != string(userHandle) { return nil, identity.ErrCredentialRejected } user, err = loadPasskeyUser(ctx, postgresdb.New(tx), tx, owner) return user, err }, session, parsed) return credential, user, err } func verifyPasskeyRegistration(ctx context.Context, tx pgx.Tx, wa *webauthn.WebAuthn, owner string, session webauthn.SessionData, response []byte) (*webauthn.Credential, passkeyUser, error) { p, ok := access.PrincipalFromContext(ctx) if !ok || string(p.IdentityID) != owner { return nil, passkeyUser{}, identity.ErrCredentialRejected } user, err := loadPasskeyUser(ctx, postgresdb.New(tx), tx, owner) if err != nil { return nil, user, err } parsed, err := protocol.ParseCredentialCreationResponseBytes(response) if err != nil { return nil, user, identity.ErrCredentialRejected } credential, err := wa.CreateCredential(user, session, parsed) return credential, user, err } func persistPasskey(ctx context.Context, tx pgx.Tx, credential *webauthn.Credential, owner, name string, registration bool) error { encoded, err := json.Marshal(credential) if err != nil { return err } credentialID := base64.RawURLEncoding.EncodeToString(credential.ID) if registration { name = strings.TrimSpace(name) if name == "" { name = "Passkey" } if len(name) > 200 { return identity.ErrInvalid } _, err = tx.Exec(ctx, `INSERT INTO passkeys (credential_id,identity_id,name,credential) VALUES ($1,$2,$3,$4)`, credentialID, owner, name, encoded) } else { _, err = tx.Exec(ctx, `UPDATE passkeys SET credential=$2 WHERE credential_id=$1`, credentialID, encoded) } if err != nil { return err } return nil }