265 lines
9.2 KiB
Go
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
|
|
}
|