Files
archie/internal/infrastructure/postgres/passkeys.go
T

265 lines
9.2 KiB
Go

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
}