109 lines
3.2 KiB
Go
109 lines
3.2 KiB
Go
package governance
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"encoding/json"
|
|
"errors"
|
|
|
|
"github.com/go-webauthn/webauthn/protocol"
|
|
"github.com/go-webauthn/webauthn/webauthn"
|
|
|
|
"github.com/samcharles93/archie-core/modules/governance/internal/store"
|
|
)
|
|
|
|
// ErrNoPasskey means the signed-in person has no passkey to confirm with.
|
|
var ErrNoPasskey = errors.New("no passkey is registered for this account")
|
|
|
|
// BeginConfirmation starts a passkey assertion for the signed-in person. It
|
|
// can be finished only by Confirm with the same subject, and only by that
|
|
// person: a sign-in ceremony can't stand in for it, nor it for a sign-in.
|
|
func (m *Module) BeginConfirmation(ctx context.Context, subject string) (PasskeyCeremony, error) {
|
|
p, ok := PrincipalFromContext(ctx)
|
|
if !ok || subject == "" {
|
|
return PasskeyCeremony{}, ErrCredentialRejected
|
|
}
|
|
wa, err := m.webAuthn(ctx)
|
|
if err != nil {
|
|
return PasskeyCeremony{}, err
|
|
}
|
|
owner := string(p.IdentityID)
|
|
row, creds, err := m.store.LoadPasskeyUser(ctx, owner)
|
|
if err != nil {
|
|
return PasskeyCeremony{}, mapIdentityErr(err)
|
|
}
|
|
user, err := decodePasskeyUser(row, creds)
|
|
if err != nil {
|
|
return PasskeyCeremony{}, err
|
|
}
|
|
if len(user.credentials) == 0 {
|
|
return PasskeyCeremony{}, ErrNoPasskey
|
|
}
|
|
options, session, err := wa.BeginLogin(user, webauthn.WithUserVerification(protocol.VerificationRequired))
|
|
if err != nil {
|
|
return PasskeyCeremony{}, err
|
|
}
|
|
data, err := json.Marshal(session)
|
|
if err != nil {
|
|
return PasskeyCeremony{}, err
|
|
}
|
|
encoded, err := json.Marshal(options)
|
|
if err != nil {
|
|
return PasskeyCeremony{}, err
|
|
}
|
|
token := rand.Text()
|
|
if err := m.store.InsertPasskeyCeremony(ctx, sessionHash(token), owner, false, subject, data); err != nil {
|
|
return PasskeyCeremony{}, err
|
|
}
|
|
return PasskeyCeremony{Token: token, Options: encoded}, nil
|
|
}
|
|
|
|
// Confirm verifies the signed-in person's passkey assertion for subject and
|
|
// uses up its ceremony. A missing, expired or used ceremony, another person's
|
|
// assertion or a cloned authenticator is ErrCredentialRejected.
|
|
func (m *Module) Confirm(ctx context.Context, token string, response []byte, subject string) error {
|
|
p, ok := PrincipalFromContext(ctx)
|
|
if !ok || subject == "" {
|
|
return ErrCredentialRejected
|
|
}
|
|
wa, err := m.webAuthn(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ceremony, err := m.store.TakePasskeyCeremony(ctx, sessionHash(token), false, subject)
|
|
if errors.Is(err, store.ErrNotFound) {
|
|
return ErrCredentialRejected
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
owner := string(p.IdentityID)
|
|
if ceremony.IdentityID != owner {
|
|
return ErrCredentialRejected
|
|
}
|
|
var session webauthn.SessionData
|
|
if err := json.Unmarshal(ceremony.SessionData, &session); err != nil {
|
|
return err
|
|
}
|
|
parsed, err := protocol.ParseCredentialRequestResponseBytes(response)
|
|
if err != nil {
|
|
return ErrCredentialRejected
|
|
}
|
|
err = m.store.WithPasskeyTx(ctx, func(pt *store.PasskeyTx) error {
|
|
row, creds, err := pt.LoadUser(ctx, owner)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
user, err := decodePasskeyUser(row, creds)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
cred, err := wa.ValidateLogin(user, session, parsed)
|
|
if err != nil || cred.Authenticator.CloneWarning {
|
|
return ErrCredentialRejected
|
|
}
|
|
return persistPasskeyTx(ctx, pt, cred, owner, "", false)
|
|
})
|
|
return mapIdentityErr(err)
|
|
}
|