整理前后端与测试构建目录并完善配置和安全引导
Security Checks / security (push) Waiting to run

统一 frontend、backend、test、test-log 和 out 目录,更新构建、部署及测试入口;纳入配置管理兼容与首次安全引导修复;排除本机配置、密钥和测试产物。
This commit is contained in:
xuans committed 2026-09-05 19:19:52 +08:00
1 parent 28cd9d3406
commit f60d3b0880
603 files changed
+2351 -660

No files matched your search

+554
View File
@@ -0,0 +1,554 @@
package webauthnservice
import (
"bytes"
"crypto/rand"
"encoding/base64"
"encoding/json"
"errors"
"fmt"
"net/http"
"strconv"
"strings"
"sync"
"time"
"git.pcux.cn/xuans/Smail/models"
"git.pcux.cn/xuans/Smail/utils/credential"
"github.com/go-webauthn/webauthn/protocol"
webauthn "github.com/go-webauthn/webauthn/webauthn"
"xorm.io/xorm"
)
var (
ErrUnavailable = errors.New("webauthn service unavailable")
ErrInvalidRequest = errors.New("webauthn request is invalid")
ErrSessionNotFound = errors.New("webauthn ceremony session is invalid")
ErrSessionExpired = errors.New("webauthn ceremony session expired")
ErrCredentialMissing = errors.New("webauthn credential is missing")
ErrCredentialExists = errors.New("webauthn credential already exists")
)
const (
ceremonyTTL = 5 * time.Minute
maxSessions = 1024
)
// Config 保存 WebAuthn 信赖方和凭据加密存储配置。
type Config struct {
RPID string
RPDisplayName string
RPOrigins []string
VaultRoot string
}
// Service 管理 WebAuthn 注册、登录和凭据生命周期。
type Service struct {
engine *xorm.Engine
vault string
authn *webauthn.WebAuthn
mu sync.Mutex
credentialMu sync.Mutex
sessions map[string]ceremony
now func() time.Time
}
type ceremony struct {
userID int
kind ceremonyKind
data webauthn.SessionData
expiresAt time.Time
}
type ceremonyKind uint8
const (
registrationCeremony ceremonyKind = iota + 1
loginCeremony
discoverableLoginCeremony
)
// NewService 创建 WebAuthn 服务并校验必要配置。
func NewService(engine *xorm.Engine, cfg Config) (*Service, error) {
if engine == nil || strings.TrimSpace(cfg.RPID) == "" || strings.TrimSpace(cfg.RPDisplayName) == "" || len(cfg.RPOrigins) == 0 || strings.TrimSpace(cfg.VaultRoot) == "" {
return nil, ErrUnavailable
}
authn, err := webauthn.New(&webauthn.Config{
RPID: strings.TrimSpace(cfg.RPID),
RPDisplayName: strings.TrimSpace(cfg.RPDisplayName),
RPOrigins: append([]string(nil), cfg.RPOrigins...),
AttestationPreference: protocol.PreferNoAttestation,
})
if err != nil {
return nil, fmt.Errorf("create webauthn configuration: %w", err)
}
return &Service{engine: engine, vault: cfg.VaultRoot, authn: authn, sessions: make(map[string]ceremony), now: time.Now}, nil
}
// BeginRegistration 开始指定用户的 WebAuthn 注册流程。
func (s *Service) BeginRegistration(userID int) (*protocol.CredentialCreation, string, error) {
user, err := s.loadUser(userID)
if err != nil {
return nil, "", err
}
adapter, err := s.loadWebAuthnUser(user)
if err != nil {
return nil, "", err
}
creation, data, err := s.authn.BeginRegistration(adapter, webauthn.WithResidentKeyRequirement(protocol.ResidentKeyRequirementRequired))
if err != nil {
return nil, "", fmt.Errorf("begin webauthn registration: %w", err)
}
sessionID, err := s.putSession(ceremony{userID: user.ID, kind: registrationCeremony, data: *data, expiresAt: s.now().Add(ceremonyTTL)})
if err != nil {
return nil, "", err
}
return creation, sessionID, nil
}
// FinishRegistration 完成指定用户的 WebAuthn 注册流程。
func (s *Service) FinishRegistration(userID int, sessionID string, request *http.Request, displayName string) (*models.WebAuthnCredential, error) {
item, err := s.takeSession(sessionID, registrationCeremony, userID)
if err != nil {
return nil, err
}
if request == nil || strings.TrimSpace(displayName) == "" || len([]byte(displayName)) > 128 {
return nil, ErrInvalidRequest
}
user, err := s.loadUser(userID)
if err != nil {
return nil, err
}
adapter, err := s.loadWebAuthnUser(user)
if err != nil {
return nil, err
}
validated, err := s.authn.FinishRegistration(adapter, item.data, request)
if err != nil {
return nil, fmt.Errorf("finish webauthn registration: %w", err)
}
credentialID := base64.RawURLEncoding.EncodeToString(validated.ID)
if credentialID == "" {
return nil, ErrInvalidRequest
}
var existing models.WebAuthnCredential
has, err := s.engine.Where("credential_id = ?", credentialID).Get(&existing)
if err != nil {
return nil, fmt.Errorf("check webauthn credential: %w", err)
}
if has {
return nil, ErrCredentialExists
}
encoded, err := json.Marshal(validated)
if err != nil {
return nil, fmt.Errorf("encode webauthn credential: %w", err)
}
protected, err := credential.Encrypt(s.vault, string(encoded))
if err != nil {
return nil, fmt.Errorf("protect webauthn credential: %w", err)
}
record := &models.WebAuthnCredential{
UserID: userID,
CredentialID: credentialID,
CredentialData: protected,
DisplayName: strings.TrimSpace(displayName),
Discoverable: true,
CreatedAt: s.now(),
}
if _, err := s.engine.Insert(record); err != nil {
return nil, fmt.Errorf("save webauthn credential: %w", err)
}
return record, nil
}
// BeginLogin 开始指定用户的 WebAuthn 登录流程。
func (s *Service) BeginLogin(userID int) (*protocol.CredentialAssertion, string, error) {
user, err := s.loadUser(userID)
if err != nil {
return nil, "", err
}
adapter, err := s.loadWebAuthnUser(user)
if err != nil {
return nil, "", err
}
assertion, data, err := s.authn.BeginLogin(adapter)
if err != nil {
return nil, "", fmt.Errorf("begin webauthn login: %w", err)
}
sessionID, err := s.putSession(ceremony{userID: user.ID, kind: loginCeremony, data: *data, expiresAt: s.now().Add(ceremonyTTL)})
if err != nil {
return nil, "", err
}
return assertion, sessionID, nil
}
// FinishLogin 完成指定用户的 WebAuthn 登录流程。
func (s *Service) FinishLogin(userID int, sessionID string, request *http.Request) (*models.WebAuthnCredential, error) {
item, err := s.takeSession(sessionID, loginCeremony, userID)
if err != nil {
return nil, err
}
if request == nil {
return nil, ErrInvalidRequest
}
user, err := s.loadUser(userID)
if err != nil {
return nil, err
}
adapter, err := s.loadWebAuthnUser(user)
if err != nil {
return nil, err
}
validated, err := s.authn.FinishLogin(adapter, item.data, request)
if err != nil {
return nil, fmt.Errorf("finish webauthn login: %w", err)
}
credentialID := base64.RawURLEncoding.EncodeToString(validated.ID)
s.credentialMu.Lock()
defer s.credentialMu.Unlock()
var record models.WebAuthnCredential
has, err := s.engine.Where("user_id = ? AND credential_id = ? AND revoked_at IS NULL AND discoverable = ?", userID, credentialID, true).Get(&record)
if err != nil {
return nil, fmt.Errorf("load webauthn login credential: %w", err)
}
if !has {
return nil, ErrCredentialMissing
}
currentPlain, err := credential.Decrypt(s.vault, record.CredentialData)
if err != nil {
return nil, fmt.Errorf("decrypt current webauthn credential: %w", err)
}
var current webauthn.Credential
if err := json.Unmarshal([]byte(currentPlain), &current); err != nil {
return nil, fmt.Errorf("decode current webauthn credential: %w", err)
}
if validated.Authenticator.SignCount < current.Authenticator.SignCount {
return nil, ErrInvalidRequest
}
encoded, err := json.Marshal(validated)
if err != nil {
return nil, fmt.Errorf("encode webauthn login credential: %w", err)
}
protected, err := credential.Encrypt(s.vault, string(encoded))
if err != nil {
return nil, fmt.Errorf("protect webauthn login credential: %w", err)
}
now := s.now()
updated := &models.WebAuthnCredential{CredentialData: protected, LastUsedAt: &now}
if affected, err := s.engine.ID(record.ID).Cols("credential_data", "last_used_at").Update(updated); err != nil {
return nil, fmt.Errorf("update webauthn login credential: %w", err)
} else if affected != 1 {
return nil, ErrCredentialMissing
}
record.CredentialData = protected
record.LastUsedAt = &now
return &record, nil
}
func (s *Service) BeginDiscoverableLogin() (*protocol.CredentialAssertion, string, error) {
if s == nil || s.authn == nil {
return nil, "", ErrUnavailable
}
assertion, data, err := s.authn.BeginDiscoverableLogin()
if err != nil {
return nil, "", fmt.Errorf("begin discoverable webauthn login: %w", err)
}
sessionID, err := s.putSession(ceremony{kind: discoverableLoginCeremony, data: *data, expiresAt: s.now().Add(ceremonyTTL)})
if err != nil {
return nil, "", err
}
return assertion, sessionID, nil
}
func (s *Service) FinishDiscoverableLogin(sessionID string, request *http.Request) (*models.User, *models.WebAuthnCredential, error) {
item, err := s.takeDiscoverableSession(sessionID)
if err != nil {
return nil, nil, err
}
if request == nil {
return nil, nil, ErrInvalidRequest
}
var selected *webAuthnUser
validated, err := s.authn.FinishDiscoverableLogin(func(rawID, userHandle []byte) (webauthn.User, error) {
adapter, loadErr := s.loadDiscoverableUser(rawID, userHandle)
if loadErr != nil {
return nil, loadErr
}
selected = adapter
return adapter, nil
}, item.data, request)
if err != nil || selected == nil {
return nil, nil, ErrCredentialMissing
}
record, err := s.persistLoginCredential(selected.user.ID, validated)
if err != nil {
return nil, nil, err
}
user := selected.user
return &user, record, nil
}
// ListCredentials 列出指定用户的非敏感 WebAuthn 凭据摘要。
func (s *Service) ListCredentials(userID int) ([]models.WebAuthnCredential, error) {
if s == nil || s.engine == nil || userID <= 0 {
return nil, ErrInvalidRequest
}
var records []models.WebAuthnCredential
if err := s.engine.Where("user_id = ?", userID).Cols("id", "user_id", "credential_id", "display_name", "discoverable", "created_at", "last_used_at", "revoked_at").Find(&records); err != nil {
return nil, fmt.Errorf("list webauthn credentials: %w", err)
}
for index := range records {
records[index].CredentialData = ""
}
return records, nil
}
// RenameCredential 修改指定用户凭据的显示名称。
func (s *Service) RenameCredential(userID, credentialID int, displayName string) error {
if userID <= 0 || credentialID <= 0 || strings.TrimSpace(displayName) == "" || len([]byte(displayName)) > 128 {
return ErrInvalidRequest
}
if affected, err := s.engine.ID(credentialID).Where("user_id = ? AND revoked_at IS NULL", userID).Cols("display_name").Update(&models.WebAuthnCredential{DisplayName: strings.TrimSpace(displayName)}); err != nil {
return fmt.Errorf("rename webauthn credential: %w", err)
} else if affected != 1 {
return ErrCredentialMissing
}
return nil
}
// RevokeCredential 撤销指定用户的一项 WebAuthn 凭据。
func (s *Service) RevokeCredential(userID, credentialID int) error {
if userID <= 0 || credentialID <= 0 {
return ErrInvalidRequest
}
now := s.now()
if affected, err := s.engine.ID(credentialID).Where("user_id = ? AND revoked_at IS NULL", userID).Cols("revoked_at").Update(&models.WebAuthnCredential{RevokedAt: &now}); err != nil {
return fmt.Errorf("revoke webauthn credential: %w", err)
} else if affected != 1 {
return ErrCredentialMissing
}
return nil
}
// RevokeAllCredentials 撤销指定用户的全部 WebAuthn 凭据。
func (s *Service) RevokeAllCredentials(userID int) error {
if userID <= 0 {
return ErrInvalidRequest
}
now := s.now()
if _, err := s.engine.Where("user_id = ? AND revoked_at IS NULL", userID).Cols("revoked_at").Update(&models.WebAuthnCredential{RevokedAt: &now}); err != nil {
return fmt.Errorf("revoke all webauthn credentials: %w", err)
}
return nil
}
func (s *Service) loadUser(userID int) (*models.User, error) {
if s == nil || s.engine == nil || s.authn == nil || userID <= 0 {
return nil, ErrUnavailable
}
var user models.User
has, err := s.engine.Where("id = ? AND disabled = 0", userID).Get(&user)
if err != nil {
return nil, fmt.Errorf("load webauthn user: %w", err)
}
if !has {
return nil, ErrCredentialMissing
}
return &user, nil
}
func (s *Service) loadWebAuthnUser(user *models.User) (*webAuthnUser, error) {
if user == nil {
return nil, ErrInvalidRequest
}
var records []models.WebAuthnCredential
if err := s.engine.Where("user_id = ? AND revoked_at IS NULL AND discoverable = ?", user.ID, true).Find(&records); err != nil {
return nil, fmt.Errorf("load webauthn credentials: %w", err)
}
result := make([]webauthn.Credential, 0, len(records))
for _, record := range records {
plain, err := credential.Decrypt(s.vault, record.CredentialData)
if err != nil {
return nil, fmt.Errorf("decrypt webauthn credential: %w", err)
}
var item webauthn.Credential
if err := json.Unmarshal([]byte(plain), &item); err != nil {
return nil, fmt.Errorf("decode webauthn credential: %w", err)
}
if base64.RawURLEncoding.EncodeToString(item.ID) != record.CredentialID {
return nil, ErrCredentialMissing
}
result = append(result, item)
}
return &webAuthnUser{user: *user, credentials: result}, nil
}
func (s *Service) loadDiscoverableUser(rawID, userHandle []byte) (*webAuthnUser, error) {
const prefix = "smail-user-"
if !bytes.HasPrefix(userHandle, []byte(prefix)) || len(rawID) == 0 {
return nil, ErrCredentialMissing
}
userID, err := strconv.Atoi(string(userHandle[len(prefix):]))
if err != nil || userID <= 0 {
return nil, ErrCredentialMissing
}
user, err := s.loadUser(userID)
if err != nil {
return nil, ErrCredentialMissing
}
adapter, err := s.loadWebAuthnUser(user)
if err != nil {
return nil, ErrCredentialMissing
}
for _, item := range adapter.credentials {
if bytes.Equal(item.ID, rawID) {
return adapter, nil
}
}
return nil, ErrCredentialMissing
}
func (s *Service) persistLoginCredential(userID int, validated *webauthn.Credential) (*models.WebAuthnCredential, error) {
if validated == nil || userID <= 0 {
return nil, ErrInvalidRequest
}
credentialID := base64.RawURLEncoding.EncodeToString(validated.ID)
s.credentialMu.Lock()
defer s.credentialMu.Unlock()
var record models.WebAuthnCredential
has, err := s.engine.Where("user_id = ? AND credential_id = ? AND revoked_at IS NULL", userID, credentialID).Get(&record)
if err != nil {
return nil, fmt.Errorf("load webauthn login credential: %w", err)
}
if !has {
return nil, ErrCredentialMissing
}
currentPlain, err := credential.Decrypt(s.vault, record.CredentialData)
if err != nil {
return nil, fmt.Errorf("decrypt current webauthn credential: %w", err)
}
var current webauthn.Credential
if err := json.Unmarshal([]byte(currentPlain), &current); err != nil {
return nil, fmt.Errorf("decode current webauthn credential: %w", err)
}
if validated.Authenticator.SignCount < current.Authenticator.SignCount {
return nil, ErrInvalidRequest
}
encoded, err := json.Marshal(validated)
if err != nil {
return nil, fmt.Errorf("encode webauthn login credential: %w", err)
}
protected, err := credential.Encrypt(s.vault, string(encoded))
if err != nil {
return nil, fmt.Errorf("protect webauthn login credential: %w", err)
}
now := s.now()
updated := &models.WebAuthnCredential{CredentialData: protected, LastUsedAt: &now}
if affected, err := s.engine.ID(record.ID).Cols("credential_data", "last_used_at").Update(updated); err != nil {
return nil, fmt.Errorf("update webauthn login credential: %w", err)
} else if affected != 1 {
return nil, ErrCredentialMissing
}
record.CredentialData = protected
record.LastUsedAt = &now
return &record, nil
}
func (s *Service) putSession(item ceremony) (string, error) {
if s == nil {
return "", ErrUnavailable
}
tokenBytes := make([]byte, 32)
if _, err := rand.Read(tokenBytes); err != nil {
return "", fmt.Errorf("create webauthn session: %w", err)
}
token := base64.RawURLEncoding.EncodeToString(tokenBytes)
s.mu.Lock()
defer s.mu.Unlock()
s.pruneSessionsLocked(s.now())
if len(s.sessions) >= maxSessions {
return "", ErrUnavailable
}
s.sessions[token] = item
return token, nil
}
func (s *Service) takeDiscoverableSession(token string) (ceremony, error) {
if s == nil || strings.TrimSpace(token) == "" {
return ceremony{}, ErrSessionNotFound
}
s.mu.Lock()
defer s.mu.Unlock()
item, ok := s.sessions[token]
if !ok {
return ceremony{}, ErrSessionNotFound
}
delete(s.sessions, token)
if item.kind != discoverableLoginCeremony {
return ceremony{}, ErrSessionNotFound
}
now := s.now()
if !item.expiresAt.After(now) || (!item.data.Expires.IsZero() && !item.data.Expires.After(now)) {
return ceremony{}, ErrSessionExpired
}
return item, nil
}
func (s *Service) takeSession(token string, kind ceremonyKind, userID int) (ceremony, error) {
if s == nil || strings.TrimSpace(token) == "" || userID <= 0 {
return ceremony{}, ErrSessionNotFound
}
s.mu.Lock()
defer s.mu.Unlock()
item, ok := s.sessions[token]
if !ok {
return ceremony{}, ErrSessionNotFound
}
delete(s.sessions, token)
if item.kind != kind || item.userID != userID {
return ceremony{}, ErrSessionNotFound
}
now := s.now()
if !item.expiresAt.After(now) || (!item.data.Expires.IsZero() && !item.data.Expires.After(now)) {
return ceremony{}, ErrSessionExpired
}
return item, nil
}
// InvalidateUser 删除指定用户尚未完成的全部 WebAuthn 仪式会话。
func (s *Service) InvalidateUser(userID int) {
if s == nil || userID <= 0 {
return
}
s.mu.Lock()
defer s.mu.Unlock()
for token, item := range s.sessions {
if item.userID == userID {
delete(s.sessions, token)
}
}
}
func (s *Service) pruneSessionsLocked(now time.Time) {
for token, item := range s.sessions {
if !item.expiresAt.After(now) || (!item.data.Expires.IsZero() && !item.data.Expires.After(now)) {
delete(s.sessions, token)
}
}
}
type webAuthnUser struct {
user models.User
credentials []webauthn.Credential
}
func (u *webAuthnUser) WebAuthnID() []byte { return []byte(fmt.Sprintf("smail-user-%d", u.user.ID)) }
func (u *webAuthnUser) WebAuthnName() string { return u.user.Account }
func (u *webAuthnUser) WebAuthnDisplayName() string { return u.user.Name }
func (u *webAuthnUser) WebAuthnCredentials() []webauthn.Credential { return u.credentials }
+311
View File
@@ -0,0 +1,311 @@
package webauthnservice
import (
"bytes"
"encoding/base64"
"encoding/json"
"errors"
"path/filepath"
"sync"
"testing"
"time"
"git.pcux.cn/xuans/Smail/models"
"git.pcux.cn/xuans/Smail/utils/credential"
webauthn "github.com/go-webauthn/webauthn/webauthn"
_ "modernc.org/sqlite"
"xorm.io/xorm"
)
func newServiceFixture(t *testing.T) (*Service, *xorm.Engine, *models.User) {
t.Helper()
engine, err := xorm.NewEngine("sqlite", filepath.Join(t.TempDir(), "webauthn.db"))
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = engine.Close() })
if err := engine.Sync2(&models.User{}, &models.WebAuthnCredential{}); err != nil {
t.Fatal(err)
}
user := &models.User{Account: "alice", Name: "Alice"}
if _, err := engine.Insert(user); err != nil {
t.Fatal(err)
}
service, err := NewService(engine, Config{
RPID: "example.com",
RPDisplayName: "Smail",
RPOrigins: []string{"https://example.com"},
VaultRoot: t.TempDir(),
})
if err != nil {
t.Fatal(err)
}
return service, engine, user
}
func TestCeremonySessionIsInMemoryAndOneTime(t *testing.T) {
service, engine, user := newServiceFixture(t)
if _, sessionID, err := service.BeginRegistration(user.ID); err != nil {
t.Fatal(err)
} else {
if sessionID == "" {
t.Fatal("empty ceremony session id")
}
if len(service.sessions) != 1 {
t.Fatalf("in-memory session count = %d, want 1", len(service.sessions))
}
var count int64
count, err = engine.Where("user_id = ?", user.ID).Count(&models.WebAuthnCredential{})
if err != nil {
t.Fatal(err)
}
if count != 0 {
t.Fatalf("ceremony session was persisted as credential rows: %d", count)
}
if _, err := service.takeSession(sessionID, registrationCeremony, user.ID); err != nil {
t.Fatal(err)
}
if _, err := service.takeSession(sessionID, registrationCeremony, user.ID); !errors.Is(err, ErrSessionNotFound) {
t.Fatalf("replayed ceremony session error = %v", err)
}
}
}
func TestPublicWebAuthnUsesDiscoverableCredentialsWithoutIdentifierList(t *testing.T) {
service, _, user := newServiceFixture(t)
creation, registrationSession, err := service.BeginRegistration(user.ID)
if err != nil {
t.Fatal(err)
}
if registrationSession == "" {
t.Fatal("empty registration session")
}
selection := creation.Response.AuthenticatorSelection
if selection.ResidentKey != "required" || selection.RequireResidentKey == nil || !*selection.RequireResidentKey {
t.Fatalf("discoverable credential requirement resident=%q legacy=%v", selection.ResidentKey, selection.RequireResidentKey)
}
assertion, sessionID, err := service.BeginDiscoverableLogin()
if err != nil {
t.Fatal(err)
}
if sessionID == "" || len(assertion.Response.Challenge) == 0 {
t.Fatalf("invalid discoverable login response session=%q challenge=%d", sessionID, len(assertion.Response.Challenge))
}
if len(assertion.Response.AllowedCredentials) != 0 {
t.Fatalf("discoverable login exposed credential identifiers: %d", len(assertion.Response.AllowedCredentials))
}
if _, err := service.takeDiscoverableSession(sessionID); err != nil {
t.Fatal(err)
}
if _, err := service.takeDiscoverableSession(sessionID); !errors.Is(err, ErrSessionNotFound) {
t.Fatalf("replayed discoverable session error=%v", err)
}
}
func TestExpiredCeremonySessionIsRemoved(t *testing.T) {
service, _, user := newServiceFixture(t)
service.now = func() time.Time { return time.Unix(100, 0) }
_, sessionID, err := service.BeginRegistration(user.ID)
if err != nil {
t.Fatal(err)
}
service.now = func() time.Time { return time.Unix(100, 0).Add(ceremonyTTL + time.Second) }
if _, err := service.takeSession(sessionID, registrationCeremony, user.ID); !errors.Is(err, ErrSessionExpired) {
t.Fatalf("expired ceremony error = %v", err)
}
if len(service.sessions) != 0 {
t.Fatal("expired ceremony session was retained")
}
}
func TestInvalidateUserOnlyRemovesTargetCeremonySessions(t *testing.T) {
service, _, user := newServiceFixture(t)
targetToken, err := service.putSession(ceremony{userID: user.ID, kind: loginCeremony, expiresAt: time.Now().Add(time.Minute)})
if err != nil {
t.Fatal(err)
}
otherToken, err := service.putSession(ceremony{userID: user.ID + 1, kind: loginCeremony, expiresAt: time.Now().Add(time.Minute)})
if err != nil {
t.Fatal(err)
}
service.InvalidateUser(user.ID)
service.mu.Lock()
_, targetExists := service.sessions[targetToken]
_, otherExists := service.sessions[otherToken]
service.mu.Unlock()
if targetExists || !otherExists {
t.Fatalf("unexpected ceremony state: target=%v other=%v", targetExists, otherExists)
}
}
func TestCredentialDataIsEncryptedAndNeverReturnedByList(t *testing.T) {
service, engine, user := newServiceFixture(t)
plain := `{"id":"public-id","publicKey":"public-key"}`
protected, err := credential.Encrypt(service.vault, plain)
if err != nil {
t.Fatal(err)
}
record := &models.WebAuthnCredential{UserID: user.ID, CredentialID: "public-id", CredentialData: protected, DisplayName: "主密钥", CreatedAt: time.Now()}
if _, err := engine.Insert(record); err != nil {
t.Fatal(err)
}
var row struct {
CredentialData string `xorm:"credential_data"`
}
if ok, err := engine.SQL("SELECT credential_data FROM webauthn_credential WHERE id = ?", record.ID).Get(&row); err != nil || !ok {
t.Fatal(err)
}
raw := row.CredentialData
if raw == plain || !credential.IsEncrypted(raw) {
t.Fatalf("credential data is not encrypted at rest: %q", raw)
}
items, err := service.ListCredentials(user.ID)
if err != nil {
t.Fatal(err)
}
if len(items) != 1 || items[0].CredentialData != "" {
t.Fatalf("credential list leaked protected data: %+v", items)
}
}
func TestRevokedCredentialIsExcludedFromLoginAndCannotBeRevokedTwice(t *testing.T) {
service, engine, user := newServiceFixture(t)
record := &models.WebAuthnCredential{UserID: user.ID, CredentialID: "revoked-id", CredentialData: "enc:v1:opaque", DisplayName: "旧密钥", CreatedAt: time.Now()}
if _, err := engine.Insert(record); err != nil {
t.Fatal(err)
}
if err := service.RevokeCredential(user.ID, record.ID); err != nil {
t.Fatal(err)
}
if err := service.RevokeCredential(user.ID, record.ID); !errors.Is(err, ErrCredentialMissing) {
t.Fatalf("second revoke error = %v", err)
}
if _, _, err := service.BeginLogin(user.ID); err == nil {
t.Fatal("revoked credential was accepted for login")
}
}
func TestWebAuthnAdapterUsesStableUserHandleAndOnlyOwnedCredentials(t *testing.T) {
service, _, user := newServiceFixture(t)
adapter, err := service.loadWebAuthnUser(user)
if err != nil {
t.Fatal(err)
}
if string(adapter.WebAuthnID()) != "smail-user-1" {
t.Fatalf("unexpected user handle: %q", adapter.WebAuthnID())
}
if len(adapter.WebAuthnCredentials()) != 0 {
t.Fatal("adapter loaded credentials from another user")
}
}
var _ webauthn.User = (*webAuthnUser)(nil)
func TestDiscoverableCredentialFilterAndMigrationMetadata(t *testing.T) {
service, engine, user := newServiceFixture(t)
legacy := webauthn.Credential{ID: []byte("legacy-id")}
current := webauthn.Credential{ID: []byte("current-id")}
legacyJSON, err := json.Marshal(legacy)
if err != nil {
t.Fatal(err)
}
currentJSON, err := json.Marshal(current)
if err != nil {
t.Fatal(err)
}
legacyProtected, err := credential.Encrypt(service.vault, string(legacyJSON))
if err != nil {
t.Fatal(err)
}
currentProtected, err := credential.Encrypt(service.vault, string(currentJSON))
if err != nil {
t.Fatal(err)
}
legacyRecord := &models.WebAuthnCredential{
UserID: user.ID, CredentialID: base64.RawURLEncoding.EncodeToString(legacy.ID),
CredentialData: legacyProtected, DisplayName: "legacy", CreatedAt: time.Now(), Discoverable: false,
}
currentRecord := &models.WebAuthnCredential{
UserID: user.ID, CredentialID: base64.RawURLEncoding.EncodeToString(current.ID),
CredentialData: currentProtected, DisplayName: "current", CreatedAt: time.Now(), Discoverable: true,
}
if _, err := engine.Insert(legacyRecord, currentRecord); err != nil {
t.Fatal(err)
}
items, err := service.ListCredentials(user.ID)
if err != nil {
t.Fatal(err)
}
if len(items) != 2 || items[0].Discoverable || !items[1].Discoverable {
t.Fatalf("credential discoverability metadata = %+v", items)
}
if _, err := service.loadDiscoverableUser(legacy.ID, []byte("smail-user-1")); !errors.Is(err, ErrCredentialMissing) {
t.Fatalf("legacy credential was accepted for discoverable login: %v", err)
}
adapter, err := service.loadDiscoverableUser(current.ID, []byte("smail-user-1"))
if err != nil {
t.Fatal(err)
}
if len(adapter.WebAuthnCredentials()) != 1 || !bytes.Equal(adapter.WebAuthnCredentials()[0].ID, current.ID) {
t.Fatalf("discoverable adapter credentials = %+v", adapter.WebAuthnCredentials())
}
}
func TestCeremonySessionCapacityAndExpiredPruning(t *testing.T) {
service, _, user := newServiceFixture(t)
service.now = func() time.Time { return time.Unix(100, 0) }
for index := 0; index < maxSessions; index++ {
if _, err := service.putSession(ceremony{userID: user.ID, kind: registrationCeremony, expiresAt: service.now().Add(time.Minute)}); err != nil {
t.Fatalf("put session %d: %v", index, err)
}
}
if _, err := service.putSession(ceremony{userID: user.ID, kind: registrationCeremony, expiresAt: service.now().Add(time.Minute)}); !errors.Is(err, ErrUnavailable) {
t.Fatalf("capacity error = %v", err)
}
service.now = func() time.Time { return time.Unix(100, 0).Add(time.Minute + time.Second) }
if _, err := service.putSession(ceremony{userID: user.ID, kind: registrationCeremony, expiresAt: service.now().Add(time.Minute)}); err != nil {
t.Fatalf("expired sessions were not pruned: %v", err)
}
}
func TestDiscoverableCeremonyIsConsumedOnceUnderConcurrency(t *testing.T) {
service, _, _ := newServiceFixture(t)
token, err := service.putSession(ceremony{kind: discoverableLoginCeremony, expiresAt: time.Now().Add(time.Minute)})
if err != nil {
t.Fatal(err)
}
const workers = 32
var wg sync.WaitGroup
var mu sync.Mutex
successes := 0
for index := 0; index < workers; index++ {
wg.Add(1)
go func() {
defer wg.Done()
if _, takeErr := service.takeDiscoverableSession(token); takeErr == nil {
mu.Lock()
successes++
mu.Unlock()
}
}()
}
wg.Wait()
if successes != 1 {
t.Fatalf("concurrent ceremony consumption successes = %d, want 1", successes)
}
}
func TestCeremonyTypeMismatchStillConsumesSession(t *testing.T) {
service, _, user := newServiceFixture(t)
token, err := service.putSession(ceremony{userID: user.ID, kind: registrationCeremony, expiresAt: time.Now().Add(time.Minute)})
if err != nil {
t.Fatal(err)
}
if _, err := service.takeSession(token, loginCeremony, user.ID); !errors.Is(err, ErrSessionNotFound) {
t.Fatalf("wrong ceremony type error = %v", err)
}
if _, err := service.takeSession(token, registrationCeremony, user.ID); !errors.Is(err, ErrSessionNotFound) {
t.Fatalf("wrong ceremony type left a replayable session: %v", err)
}
}