nodejs/hanko
1
0
Fork 0
mirror of https://github.com/teamhanko/hanko.git synced 2025-10-27 06:06:54 +08:00
Code Issues Packages Projects Releases Wiki Activity

chore: rename audit log client

Browse Source
This commit is contained in:
Frederic Jahn
2022-09-27 09:51:13 +02:00
parent 326c9aecb9
commit b73067b07e
12 changed files with 115 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
backend/audit_log/client.go → backend/audit_log/logger.go
View File

@ -12,23 +12,23 @@ import (
"time"
)
type Client interface {
type Logger interface {
Create(echo.Context, models.AuditLogType, *models.User, error) error
}
type client struct {
type logger struct {
persister persistence.Persister
storageEnabled bool
}
func NewClient(persister persistence.Persister, config config.AuditLog) Client {
return &client{
func NewLogger(persister persistence.Persister, config config.AuditLog) Logger {
return &logger{
persister: persister,
storageEnabled: config.Storage.Enabled,
}
}
func (c *client) Create(context echo.Context, auditLogType models.AuditLogType, user *models.User, logError error) error {
func (c *logger) Create(context echo.Context, auditLogType models.AuditLogType, user *models.User, logError error) error {
var err error = nil
if c.storageEnabled {
err = c.store(context, auditLogType, user, logError)
@ -58,7 +58,7 @@ func (c *client) Create(context echo.Context, auditLogType models.AuditLogType,
return nil
}
func (c *client) store(context echo.Context, auditLogType models.AuditLogType, user *models.User, logError error) error {
func (c *logger) store(context echo.Context, auditLogType models.AuditLogType, user *models.User, logError error) error {
id, err := uuid.NewV4()
if err != nil {
return fmt.Errorf("failed to create id: %w", err)

20
backend/handler/passcode.go
View File

@ -30,12 +30,12 @@ type PasscodeHandler struct {
TTL int
sessionManager session.Manager
cfg *config.Config
auditLogClient auditlog.Client
auditLogger auditlog.Logger
}
var maxPasscodeTries = 3
func NewPasscodeHandler(cfg *config.Config, persister persistence.Persister, sessionManager session.Manager, mailer mail.Mailer, auditLogClient auditlog.Client) (*PasscodeHandler, error) {
func NewPasscodeHandler(cfg *config.Config, persister persistence.Persister, sessionManager session.Manager, mailer mail.Mailer, auditLogger auditlog.Logger) (*PasscodeHandler, error) {
renderer, err := mail.NewRenderer()
if err != nil {
return nil, fmt.Errorf("failed to create new renderer: %w", err)
@ -50,7 +50,7 @@ func NewPasscodeHandler(cfg *config.Config, persister persistence.Persister, ses
TTL: cfg.Passcode.TTL,
sessionManager: sessionManager,
cfg: cfg,
auditLogClient: auditLogClient,
auditLogger: auditLogger,
}, nil
}
@ -74,7 +74,7 @@ func (h *PasscodeHandler) Init(c echo.Context) error {
return fmt.Errorf("failed to get user: %w", err)
}
if user == nil {
err = h.auditLogClient.Create(c, models.AuditLogPasscodeLoginInitFailed, nil, fmt.Errorf("unknown user"))
err = h.auditLogger.Create(c, models.AuditLogPasscodeLoginInitFailed, nil, fmt.Errorf("unknown user"))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -135,7 +135,7 @@ func (h *PasscodeHandler) Init(c echo.Context) error {
return fmt.Errorf("failed to send passcode: %w", err)
}
err = h.auditLogClient.Create(c, models.AuditLogPasscodeLoginInitSucceeded, user, nil)
err = h.auditLogger.Create(c, models.AuditLogPasscodeLoginInitSucceeded, user, nil)
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -173,7 +173,7 @@ func (h *PasscodeHandler) Finish(c echo.Context) error {
return fmt.Errorf("failed to get passcode: %w", err)
}
if passcode == nil {
err = h.auditLogClient.Create(c, models.AuditLogPasscodeLoginFinalFailed, nil, fmt.Errorf("unknown passcode"))
err = h.auditLogger.Create(c, models.AuditLogPasscodeLoginFinalFailed, nil, fmt.Errorf("unknown passcode"))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -188,7 +188,7 @@ func (h *PasscodeHandler) Finish(c echo.Context) error {
lastVerificationTime := passcode.CreatedAt.Add(time.Duration(passcode.Ttl) * time.Second)
if lastVerificationTime.Before(startTime) {
err = h.auditLogClient.Create(c, models.AuditLogPasscodeLoginFinalFailed, user, fmt.Errorf("timed out passcode"))
err = h.auditLogger.Create(c, models.AuditLogPasscodeLoginFinalFailed, user, fmt.Errorf("timed out passcode"))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -205,7 +205,7 @@ func (h *PasscodeHandler) Finish(c echo.Context) error {
if err != nil {
return fmt.Errorf("failed to delete passcode: %w", err)
}
err = h.auditLogClient.Create(c, models.AuditLogPasscodeLoginFinalFailed, user, fmt.Errorf("max attempts reached"))
err = h.auditLogger.Create(c, models.AuditLogPasscodeLoginFinalFailed, user, fmt.Errorf("max attempts reached"))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -218,7 +218,7 @@ func (h *PasscodeHandler) Finish(c echo.Context) error {
return fmt.Errorf("failed to update passcode: %w", err)
}
err = h.auditLogClient.Create(c, models.AuditLogPasscodeLoginFinalFailed, user, fmt.Errorf("passcode invalid"))
err = h.auditLogger.Create(c, models.AuditLogPasscodeLoginFinalFailed, user, fmt.Errorf("passcode invalid"))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -255,7 +255,7 @@ func (h *PasscodeHandler) Finish(c echo.Context) error {
c.Response().Header().Set("X-Auth-Token", token)
}
err = h.auditLogClient.Create(c, models.AuditLogPasscodeLoginFinalSucceeded, user, nil)
err = h.auditLogger.Create(c, models.AuditLogPasscodeLoginFinalSucceeded, user, nil)
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}

14
backend/handler/passcode_test.go
View File

@ -19,13 +19,13 @@ import (
)
func TestNewPasscodeHandler(t *testing.T) {
passcodeHandler, err := NewPasscodeHandler(&config.Config{}, test.NewPersister(nil, nil, nil, nil, nil, nil, nil), sessionManager{}, mailer{}, test.NewAuditLogClient())
passcodeHandler, err := NewPasscodeHandler(&config.Config{}, test.NewPersister(nil, nil, nil, nil, nil, nil, nil), sessionManager{}, mailer{}, test.NewAuditLogger())
assert.NoError(t, err)
assert.NotEmpty(t, passcodeHandler)
}
func TestPasscodeHandler_Init(t *testing.T) {
passcodeHandler, err := NewPasscodeHandler(&config.Config{}, test.NewPersister(users, nil, nil, nil, nil, nil, nil), sessionManager{}, mailer{}, test.NewAuditLogClient())
passcodeHandler, err := NewPasscodeHandler(&config.Config{}, test.NewPersister(users, nil, nil, nil, nil, nil, nil), sessionManager{}, mailer{}, test.NewAuditLogger())
require.NoError(t, err)
body := dto.PasscodeInitRequest{
@ -47,7 +47,7 @@ func TestPasscodeHandler_Init(t *testing.T) {
}
func TestPasscodeHandler_Init_UnknownUserId(t *testing.T) {
passcodeHandler, err := NewPasscodeHandler(&config.Config{}, test.NewPersister(users, nil, nil, nil, nil, nil, nil), sessionManager{}, mailer{}, test.NewAuditLogClient())
passcodeHandler, err := NewPasscodeHandler(&config.Config{}, test.NewPersister(users, nil, nil, nil, nil, nil, nil), sessionManager{}, mailer{}, test.NewAuditLogger())
require.NoError(t, err)
body := dto.PasscodeInitRequest{
@ -71,7 +71,7 @@ func TestPasscodeHandler_Init_UnknownUserId(t *testing.T) {
}
func TestPasscodeHandler_Finish(t *testing.T) {
passcodeHandler, err := NewPasscodeHandler(&config.Config{}, test.NewPersister(users, passcodes(), nil, nil, nil, nil, nil), sessionManager{}, mailer{}, test.NewAuditLogClient())
passcodeHandler, err := NewPasscodeHandler(&config.Config{}, test.NewPersister(users, passcodes(), nil, nil, nil, nil, nil), sessionManager{}, mailer{}, test.NewAuditLogger())
require.NoError(t, err)
body := dto.PasscodeFinishRequest{
@ -94,7 +94,7 @@ func TestPasscodeHandler_Finish(t *testing.T) {
}
func TestPasscodeHandler_Finish_WrongCode(t *testing.T) {
passcodeHandler, err := NewPasscodeHandler(&config.Config{}, test.NewPersister(users, passcodes(), nil, nil, nil, nil, nil), sessionManager{}, mailer{}, test.NewAuditLogClient())
passcodeHandler, err := NewPasscodeHandler(&config.Config{}, test.NewPersister(users, passcodes(), nil, nil, nil, nil, nil), sessionManager{}, mailer{}, test.NewAuditLogger())
require.NoError(t, err)
body := dto.PasscodeFinishRequest{
@ -119,7 +119,7 @@ func TestPasscodeHandler_Finish_WrongCode(t *testing.T) {
}
func TestPasscodeHandler_Finish_WrongCode_3_Times(t *testing.T) {
passcodeHandler, err := NewPasscodeHandler(&config.Config{}, test.NewPersister(users, passcodes(), nil, nil, nil, nil, nil), sessionManager{}, mailer{}, test.NewAuditLogClient())
passcodeHandler, err := NewPasscodeHandler(&config.Config{}, test.NewPersister(users, passcodes(), nil, nil, nil, nil, nil), sessionManager{}, mailer{}, test.NewAuditLogger())
require.NoError(t, err)
body := dto.PasscodeFinishRequest{
@ -153,7 +153,7 @@ func TestPasscodeHandler_Finish_WrongCode_3_Times(t *testing.T) {
}
func TestPasscodeHandler_Finish_WrongId(t *testing.T) {
passcodeHandler, err := NewPasscodeHandler(&config.Config{}, test.NewPersister(users, passcodes(), nil, nil, nil, nil, nil), sessionManager{}, mailer{}, test.NewAuditLogClient())
passcodeHandler, err := NewPasscodeHandler(&config.Config{}, test.NewPersister(users, passcodes(), nil, nil, nil, nil, nil), sessionManager{}, mailer{}, test.NewAuditLogger())
require.NoError(t, err)
body := dto.PasscodeFinishRequest{

28
backend/handler/password.go
View File

@ -22,15 +22,15 @@ type PasswordHandler struct {
persister persistence.Persister
sessionManager session.Manager
cfg *config.Config
auditLogClient auditlog.Client
auditLogger auditlog.Logger
}
func NewPasswordHandler(persister persistence.Persister, sessionManager session.Manager, cfg *config.Config, auditLogClient auditlog.Client) *PasswordHandler {
func NewPasswordHandler(persister persistence.Persister, sessionManager session.Manager, cfg *config.Config, auditLogger auditlog.Logger) *PasswordHandler {
return &PasswordHandler{
persister: persister,
sessionManager: sessionManager,
cfg: cfg,
auditLogClient: auditLogClient,
auditLogger: auditLogger,
}
}
@ -66,7 +66,7 @@ func (h *PasswordHandler) Set(c echo.Context) error {
pwBytes := []byte(body.Password)
if utf8.RuneCountInString(body.Password) < h.cfg.Password.MinPasswordLength { // use utf8.RuneCountInString, so utf8 characters would count as 1
err = h.auditLogClient.Create(c, models.AuditLogPasswordSetFailed, user, fmt.Errorf("password too short"))
err = h.auditLogger.Create(c, models.AuditLogPasswordSetFailed, user, fmt.Errorf("password too short"))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -74,7 +74,7 @@ func (h *PasswordHandler) Set(c echo.Context) error {
}
if len(pwBytes) > 72 {
err = h.auditLogClient.Create(c, models.AuditLogPasswordSetFailed, user, fmt.Errorf("password too long"))
err = h.auditLogger.Create(c, models.AuditLogPasswordSetFailed, user, fmt.Errorf("password too long"))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -82,7 +82,7 @@ func (h *PasswordHandler) Set(c echo.Context) error {
}
if user == nil {
err = h.auditLogClient.Create(c, models.AuditLogPasswordSetFailed, user, fmt.Errorf("unknown user: %s", body.UserID))
err = h.auditLogger.Create(c, models.AuditLogPasswordSetFailed, user, fmt.Errorf("unknown user: %s", body.UserID))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -90,7 +90,7 @@ func (h *PasswordHandler) Set(c echo.Context) error {
}
if sessionUserId != user.ID {
err = h.auditLogClient.Create(c, models.AuditLogPasswordSetFailed, user, fmt.Errorf("wrong user: expected %s -> got %s", sessionUserId, user.ID))
err = h.auditLogger.Create(c, models.AuditLogPasswordSetFailed, user, fmt.Errorf("wrong user: expected %s -> got %s", sessionUserId, user.ID))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -119,7 +119,7 @@ func (h *PasswordHandler) Set(c echo.Context) error {
if err != nil {
return fmt.Errorf("failed to create password: %w", err)
} else {
err = h.auditLogClient.Create(c, models.AuditLogPasswordSetSucceeded, user, nil)
err = h.auditLogger.Create(c, models.AuditLogPasswordSetSucceeded, user, nil)
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -131,7 +131,7 @@ func (h *PasswordHandler) Set(c echo.Context) error {
if err != nil {
return fmt.Errorf("failed to set password: %w", err)
} else {
err = h.auditLogClient.Create(c, models.AuditLogPasswordSetSucceeded, user, nil)
err = h.auditLogger.Create(c, models.AuditLogPasswordSetSucceeded, user, nil)
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -166,7 +166,7 @@ func (h *PasswordHandler) Login(c echo.Context) error {
return fmt.Errorf("failed to get user: %w", err)
}
if user == nil {
err = h.auditLogClient.Create(c, models.AuditLogPasswordLoginFailed, nil, fmt.Errorf("unknown user: %s", userId))
err = h.auditLogger.Create(c, models.AuditLogPasswordLoginFailed, nil, fmt.Errorf("unknown user: %s", userId))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -175,7 +175,7 @@ func (h *PasswordHandler) Login(c echo.Context) error {
pwBytes := []byte(body.Password)
if len(pwBytes) > 72 {
err = h.auditLogClient.Create(c, models.AuditLogPasswordLoginFailed, user, errors.New("password too long"))
err = h.auditLogger.Create(c, models.AuditLogPasswordLoginFailed, user, errors.New("password too long"))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -184,7 +184,7 @@ func (h *PasswordHandler) Login(c echo.Context) error {
pw, err := h.persister.GetPasswordCredentialPersister().GetByUserID(uuid.FromStringOrNil(body.UserId))
if pw == nil {
err = h.auditLogClient.Create(c, models.AuditLogPasswordLoginFailed, user, fmt.Errorf("user has no password credential"))
err = h.auditLogger.Create(c, models.AuditLogPasswordLoginFailed, user, fmt.Errorf("user has no password credential"))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -196,7 +196,7 @@ func (h *PasswordHandler) Login(c echo.Context) error {
}
if err = bcrypt.CompareHashAndPassword([]byte(pw.Password), pwBytes); err != nil {
err = h.auditLogClient.Create(c, models.AuditLogPasswordLoginFailed, user, fmt.Errorf("password hash not equal"))
err = h.auditLogger.Create(c, models.AuditLogPasswordLoginFailed, user, fmt.Errorf("password hash not equal"))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -219,7 +219,7 @@ func (h *PasswordHandler) Login(c echo.Context) error {
c.Response().Header().Set("X-Auth-Token", token)
}
err = h.auditLogClient.Create(c, models.AuditLogPasswordLoginSucceeded, user, nil)
err = h.auditLogger.Create(c, models.AuditLogPasswordLoginSucceeded, user, nil)
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}

20
backend/handler/password_test.go
View File

@ -48,7 +48,7 @@ func TestPasswordHandler_Set_Create(t *testing.T) {
c.Set("session", token)
p := test.NewPersister(users, nil, nil, nil, nil, []models.PasswordCredential{}, nil)
handler := NewPasswordHandler(p, sessionManager{}, &config.Config{}, test.NewAuditLogClient())
handler := NewPasswordHandler(p, sessionManager{}, &config.Config{}, test.NewAuditLogger())
if assert.NoError(t, handler.Set(c)) {
assert.Equal(t, http.StatusCreated, rec.Code)
@ -83,7 +83,7 @@ func TestPasswordHandler_Set_Create_PasswordTooShort(t *testing.T) {
c.Set("session", token)
p := test.NewPersister(users, nil, nil, nil, nil, []models.PasswordCredential{}, nil)
handler := NewPasswordHandler(p, sessionManager{}, &config.Config{Password: config.Password{MinPasswordLength: 8}}, test.NewAuditLogClient())
handler := NewPasswordHandler(p, sessionManager{}, &config.Config{Password: config.Password{MinPasswordLength: 8}}, test.NewAuditLogger())
err = handler.Set(c)
if assert.Error(t, err) {
@ -120,7 +120,7 @@ func TestPasswordHandler_Set_Create_PasswordTooLong(t *testing.T) {
c.Set("session", token)
p := test.NewPersister(users, nil, nil, nil, nil, []models.PasswordCredential{}, nil)
handler := NewPasswordHandler(p, sessionManager{}, &config.Config{Password: config.Password{MinPasswordLength: 8}}, test.NewAuditLogClient())
handler := NewPasswordHandler(p, sessionManager{}, &config.Config{Password: config.Password{MinPasswordLength: 8}}, test.NewAuditLogger())
err = handler.Set(c)
if assert.Error(t, err) {
@ -173,7 +173,7 @@ func TestPasswordHandler_Set_Update(t *testing.T) {
c.Set("session", token)
p := test.NewPersister(users, nil, nil, nil, nil, passwords, nil)
handler := NewPasswordHandler(p, sessionManager{}, &config.Config{}, test.NewAuditLogClient())
handler := NewPasswordHandler(p, sessionManager{}, &config.Config{}, test.NewAuditLogger())
if assert.NoError(t, handler.Set(c)) {
assert.Equal(t, http.StatusOK, rec.Code)
@ -198,7 +198,7 @@ func TestPasswordHandler_Set_UserNotFound(t *testing.T) {
c.Set("session", token)
p := test.NewPersister([]models.User{}, nil, nil, nil, nil, []models.PasswordCredential{}, nil)
handler := NewPasswordHandler(p, sessionManager{}, &config.Config{}, test.NewAuditLogClient())
handler := NewPasswordHandler(p, sessionManager{}, &config.Config{}, test.NewAuditLogger())
err = handler.Set(c)
if assert.Error(t, err) {
@ -251,7 +251,7 @@ func TestPasswordHandler_Set_TokenHasWrongSubject(t *testing.T) {
c.Set("session", token)
p := test.NewPersister(users, nil, nil, nil, nil, passwords, nil)
handler := NewPasswordHandler(p, sessionManager{}, &config.Config{}, test.NewAuditLogClient())
handler := NewPasswordHandler(p, sessionManager{}, &config.Config{}, test.NewAuditLogger())
err = handler.Set(c)
if assert.Error(t, err) {
@ -276,7 +276,7 @@ func TestPasswordHandler_Set_BadRequestBody(t *testing.T) {
c.Set("session", token)
p := test.NewPersister(nil, nil, nil, nil, nil, nil, nil)
handler := NewPasswordHandler(p, sessionManager{}, &config.Config{}, test.NewAuditLogClient())
handler := NewPasswordHandler(p, sessionManager{}, &config.Config{}, test.NewAuditLogger())
err = handler.Set(c)
if assert.Error(t, err) {
@ -323,7 +323,7 @@ func TestPasswordHandler_Login(t *testing.T) {
c := e.NewContext(req, rec)
p := test.NewPersister(users, nil, nil, nil, nil, passwords, nil)
handler := NewPasswordHandler(p, sessionManager{}, &config.Config{}, test.NewAuditLogClient())
handler := NewPasswordHandler(p, sessionManager{}, &config.Config{}, test.NewAuditLogger())
if assert.NoError(t, handler.Login(c)) {
assert.Equal(t, http.StatusOK, rec.Code)
@ -376,7 +376,7 @@ func TestPasswordHandler_Login_WrongPassword(t *testing.T) {
c := e.NewContext(req, rec)
p := test.NewPersister(users, nil, nil, nil, nil, passwords, nil)
handler := NewPasswordHandler(p, sessionManager{}, &config.Config{}, test.NewAuditLogClient())
handler := NewPasswordHandler(p, sessionManager{}, &config.Config{}, test.NewAuditLogger())
err = handler.Login(c)
if assert.Error(t, err) {
@ -396,7 +396,7 @@ func TestPasswordHandler_Login_NonExistingUser(t *testing.T) {
c := e.NewContext(req, rec)
p := test.NewPersister([]models.User{}, nil, nil, nil, nil, []models.PasswordCredential{}, nil)
handler := NewPasswordHandler(p, sessionManager{}, &config.Config{}, test.NewAuditLogClient())
handler := NewPasswordHandler(p, sessionManager{}, &config.Config{}, test.NewAuditLogger())
err := handler.Login(c)
if assert.Error(t, err) {

12
backend/handler/user.go
View File

@ -16,14 +16,14 @@ import (
)
type UserHandler struct {
persister persistence.Persister
auditLogClient auditlog.Client
persister persistence.Persister
auditLogger auditlog.Logger
}
func NewUserHandler(persister persistence.Persister, auditLogClient auditlog.Client) *UserHandler {
func NewUserHandler(persister persistence.Persister, auditLogger auditlog.Logger) *UserHandler {
return &UserHandler{
persister: persister,
auditLogClient: auditLogClient,
persister: persister,
auditLogger: auditLogger,
}
}
@ -59,7 +59,7 @@ func (h *UserHandler) Create(c echo.Context) error {
return fmt.Errorf("failed to store user: %w", err)
}
_ = h.auditLogClient.Create(c, models.AuditLogUserCreated, &newUser, nil) // TODO: what to do on error
_ = h.auditLogger.Create(c, models.AuditLogUserCreated, &newUser, nil) // TODO: what to do on error
return c.JSON(http.StatusOK, newUser)
})

30
backend/handler/user_test.go
View File

@ -43,7 +43,7 @@ func TestUserHandler_Create(t *testing.T) {
c := e.NewContext(req, rec)
p := test.NewPersister(users, nil, nil, nil, nil, nil, nil)
handler := NewUserHandler(p, test.NewAuditLogClient())
handler := NewUserHandler(p, test.NewAuditLogger())
if assert.NoError(t, handler.Create(c)) {
user := models.User{}
@ -79,7 +79,7 @@ func TestUserHandler_Create_CaseInsensitive(t *testing.T) {
c := e.NewContext(req, rec)
p := test.NewPersister(users, nil, nil, nil, nil, nil, nil)
handler := NewUserHandler(p, test.NewAuditLogClient())
handler := NewUserHandler(p, test.NewAuditLogger())
if assert.NoError(t, handler.Create(c)) {
user := models.User{}
@ -114,7 +114,7 @@ func TestUserHandler_Create_UserExists(t *testing.T) {
c := e.NewContext(req, rec)
p := test.NewPersister(users, nil, nil, nil, nil, nil, nil)
handler := NewUserHandler(p, test.NewAuditLogClient())
handler := NewUserHandler(p, test.NewAuditLogger())
err = handler.Create(c)
if assert.Error(t, err) {
@ -147,7 +147,7 @@ func TestUserHandler_Create_UserExists_CaseInsensitive(t *testing.T) {
c := e.NewContext(req, rec)
p := test.NewPersister(users, nil, nil, nil, nil, nil, nil)
handler := NewUserHandler(p, test.NewAuditLogClient())
handler := NewUserHandler(p, test.NewAuditLogger())
err = handler.Create(c)
if assert.Error(t, err) {
@ -166,7 +166,7 @@ func TestUserHandler_Create_InvalidEmail(t *testing.T) {
c := e.NewContext(req, rec)
p := test.NewPersister(nil, nil, nil, nil, nil, nil, nil)
handler := NewUserHandler(p, test.NewAuditLogClient())
handler := NewUserHandler(p, test.NewAuditLogger())
err := handler.Create(c)
if assert.Error(t, err) {
@ -185,7 +185,7 @@ func TestUserHandler_Create_EmailMissing(t *testing.T) {
c := e.NewContext(req, rec)
p := test.NewPersister(nil, nil, nil, nil, nil, nil, nil)
handler := NewUserHandler(p, test.NewAuditLogClient())
handler := NewUserHandler(p, test.NewAuditLogger())
err := handler.Create(c)
if assert.Error(t, err) {
@ -221,7 +221,7 @@ func TestUserHandler_Get(t *testing.T) {
c.Set("session", token)
p := test.NewPersister(users, nil, nil, nil, nil, nil, nil)
handler := NewUserHandler(p, test.NewAuditLogClient())
handler := NewUserHandler(p, test.NewAuditLogger())
if assert.NoError(t, handler.Get(c)) {
assert.Equal(t, rec.Code, http.StatusOK)
@ -271,7 +271,7 @@ func TestUserHandler_GetUserWithWebAuthnCredential(t *testing.T) {
c.Set("session", token)
p := test.NewPersister(users, nil, nil, nil, nil, nil, nil)
handler := NewUserHandler(p, test.NewAuditLogClient())
handler := NewUserHandler(p, test.NewAuditLogger())
if assert.NoError(t, handler.Get(c)) {
assert.Equal(t, rec.Code, http.StatusOK)
@ -296,7 +296,7 @@ func TestUserHandler_Get_InvalidUserId(t *testing.T) {
c.Set("session", token)
p := test.NewPersister(nil, nil, nil, nil, nil, nil, nil)
handler := NewUserHandler(p, test.NewAuditLogClient())
handler := NewUserHandler(p, test.NewAuditLogger())
err = handler.Get(c)
if assert.Error(t, err) {
@ -314,7 +314,7 @@ func TestUserHandler_GetUserIdByEmail_InvalidEmail(t *testing.T) {
c := e.NewContext(req, rec)
p := test.NewPersister(nil, nil, nil, nil, nil, nil, nil)
handler := NewUserHandler(p, test.NewAuditLogClient())
handler := NewUserHandler(p, test.NewAuditLogger())
err := handler.GetUserIdByEmail(c)
if assert.Error(t, err) {
@ -331,7 +331,7 @@ func TestUserHandler_GetUserIdByEmail_InvalidJson(t *testing.T) {
c := e.NewContext(req, rec)
p := test.NewPersister(nil, nil, nil, nil, nil, nil, nil)
handler := NewUserHandler(p, test.NewAuditLogClient())
handler := NewUserHandler(p, test.NewAuditLogger())
assert.Error(t, handler.GetUserIdByEmail(c))
}
@ -345,7 +345,7 @@ func TestUserHandler_GetUserIdByEmail_UserNotFound(t *testing.T) {
c := e.NewContext(req, rec)
p := test.NewPersister(nil, nil, nil, nil, nil, nil, nil)
handler := NewUserHandler(p, test.NewAuditLogClient())
handler := NewUserHandler(p, test.NewAuditLogger())
err := handler.GetUserIdByEmail(c)
if assert.Error(t, err) {
@ -373,7 +373,7 @@ func TestUserHandler_GetUserIdByEmail(t *testing.T) {
c := e.NewContext(req, rec)
p := test.NewPersister(users, nil, nil, nil, nil, nil, nil)
handler := NewUserHandler(p, test.NewAuditLogClient())
handler := NewUserHandler(p, test.NewAuditLogger())
if assert.NoError(t, handler.GetUserIdByEmail(c)) {
assert.Equal(t, http.StatusOK, rec.Code)
@ -407,7 +407,7 @@ func TestUserHandler_GetUserIdByEmail_CaseInsensitive(t *testing.T) {
c := e.NewContext(req, rec)
p := test.NewPersister(users, nil, nil, nil, nil, nil, nil)
handler := NewUserHandler(p, test.NewAuditLogClient())
handler := NewUserHandler(p, test.NewAuditLogger())
if assert.NoError(t, handler.GetUserIdByEmail(c)) {
assert.Equal(t, http.StatusOK, rec.Code)
@ -437,7 +437,7 @@ func TestUserHandler_Me(t *testing.T) {
c.Set("session", token)
p := test.NewPersister(users, nil, nil, nil, nil, nil, nil)
handler := NewUserHandler(p, test.NewAuditLogClient())
handler := NewUserHandler(p, test.NewAuditLogger())
if assert.NoError(t, handler.Me(c)) {
assert.Equal(t, http.StatusOK, rec.Code)

38
backend/handler/webauthn.go
View File

@ -25,11 +25,11 @@ type WebauthnHandler struct {
webauthn *webauthn.WebAuthn
sessionManager session.Manager
cfg *config.Config
auditLogClient auditlog.Client
auditLogger auditlog.Logger
}
// NewWebauthnHandler creates a new handler which handles all webauthn related routes
func NewWebauthnHandler(cfg *config.Config, persister persistence.Persister, sessionManager session.Manager, auditLogClient auditlog.Client) (*WebauthnHandler, error) {
func NewWebauthnHandler(cfg *config.Config, persister persistence.Persister, sessionManager session.Manager, auditLogger auditlog.Logger) (*WebauthnHandler, error) {
f := false
wa, err := webauthn.New(&webauthn.Config{
RPDisplayName: cfg.Webauthn.RelyingParty.DisplayName,
@ -54,7 +54,7 @@ func NewWebauthnHandler(cfg *config.Config, persister persistence.Persister, ses
webauthn: wa,
sessionManager: sessionManager,
cfg: cfg,
auditLogClient: auditLogClient,
auditLogger: auditLogger,
}, nil
}
@ -73,7 +73,7 @@ func (h *WebauthnHandler) BeginRegistration(c echo.Context) error {
return fmt.Errorf("failed to get user: %w", err)
}
if webauthnUser == nil {
err = h.auditLogClient.Create(c, models.AuditLogWebAuthnRegistrationInitFailed, nil, fmt.Errorf("unknown user"))
err = h.auditLogger.Create(c, models.AuditLogWebAuthnRegistrationInitFailed, nil, fmt.Errorf("unknown user"))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -102,7 +102,7 @@ func (h *WebauthnHandler) BeginRegistration(c echo.Context) error {
return fmt.Errorf("failed to store creation options session data: %w", err)
}
err = h.auditLogClient.Create(c, models.AuditLogWebAuthnRegistrationInitSucceeded, user, nil)
err = h.auditLogger.Create(c, models.AuditLogWebAuthnRegistrationInitSucceeded, user, nil)
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -133,7 +133,7 @@ func (h *WebauthnHandler) FinishRegistration(c echo.Context) error {
}
if sessionData == nil {
err = h.auditLogClient.Create(c, models.AuditLogWebAuthnRegistrationFinalFailed, nil, fmt.Errorf("received unkown challenge"))
err = h.auditLogger.Create(c, models.AuditLogWebAuthnRegistrationFinalFailed, nil, fmt.Errorf("received unkown challenge"))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -141,7 +141,7 @@ func (h *WebauthnHandler) FinishRegistration(c echo.Context) error {
}
if sessionToken.Subject() != sessionData.UserId.String() {
err = h.auditLogClient.Create(c, models.AuditLogWebAuthnRegistrationFinalFailed, nil, fmt.Errorf("user session does not match sessionData subject"))
err = h.auditLogger.Create(c, models.AuditLogWebAuthnRegistrationFinalFailed, nil, fmt.Errorf("user session does not match sessionData subject"))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -154,7 +154,7 @@ func (h *WebauthnHandler) FinishRegistration(c echo.Context) error {
}
if webauthnUser == nil {
err = h.auditLogClient.Create(c, models.AuditLogWebAuthnRegistrationFinalFailed, nil, fmt.Errorf("unkown user"))
err = h.auditLogger.Create(c, models.AuditLogWebAuthnRegistrationFinalFailed, nil, fmt.Errorf("unkown user"))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -163,7 +163,7 @@ func (h *WebauthnHandler) FinishRegistration(c echo.Context) error {
credential, err := h.webauthn.CreateCredential(webauthnUser, *intern.WebauthnSessionDataFromModel(sessionData), request)
if err != nil {
err = h.auditLogClient.Create(c, models.AuditLogWebAuthnRegistrationFinalFailed, user, fmt.Errorf("attestation validation failed"))
err = h.auditLogger.Create(c, models.AuditLogWebAuthnRegistrationFinalFailed, user, fmt.Errorf("attestation validation failed"))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -181,7 +181,7 @@ func (h *WebauthnHandler) FinishRegistration(c echo.Context) error {
c.Logger().Errorf("failed to delete attestation session data: %w", err)
}
err = h.auditLogClient.Create(c, models.AuditLogWebAuthnRegistrationFinalSucceeded, user, nil)
err = h.auditLogger.Create(c, models.AuditLogWebAuthnRegistrationFinalSucceeded, user, nil)
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -209,7 +209,7 @@ func (h *WebauthnHandler) BeginAuthentication(c echo.Context) error {
// non discoverable login initialization
userId, err := uuid.FromString(*request.UserID)
if err != nil {
err = h.auditLogClient.Create(c, models.AuditLogWebAuthnAuthenticationInitFailed, nil, fmt.Errorf("user_id is not a uuid"))
err = h.auditLogger.Create(c, models.AuditLogWebAuthnAuthenticationInitFailed, nil, fmt.Errorf("user_id is not a uuid"))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -221,7 +221,7 @@ func (h *WebauthnHandler) BeginAuthentication(c echo.Context) error {
return dto.NewHTTPError(http.StatusInternalServerError).SetInternal(fmt.Errorf("failed to get user: %w", err))
}
if webauthnUser == nil {
err = h.auditLogClient.Create(c, models.AuditLogWebAuthnAuthenticationInitFailed, nil, fmt.Errorf("unkown user"))
err = h.auditLogger.Create(c, models.AuditLogWebAuthnAuthenticationInitFailed, nil, fmt.Errorf("unkown user"))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -254,7 +254,7 @@ func (h *WebauthnHandler) BeginAuthentication(c echo.Context) error {
options.Response.AllowedCredentials[i].Transport = nil
}
err = h.auditLogClient.Create(c, models.AuditLogWebAuthnAuthenticationInitSucceeded, user, nil)
err = h.auditLogger.Create(c, models.AuditLogWebAuthnAuthenticationInitSucceeded, user, nil)
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -281,7 +281,7 @@ func (h *WebauthnHandler) FinishAuthentication(c echo.Context) error {
}
if sessionData == nil {
err = h.auditLogClient.Create(c, models.AuditLogWebAuthnAuthenticationFinalFailed, nil, fmt.Errorf("received unkown challenge"))
err = h.auditLogger.Create(c, models.AuditLogWebAuthnAuthenticationFinalFailed, nil, fmt.Errorf("received unkown challenge"))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -305,7 +305,7 @@ func (h *WebauthnHandler) FinishAuthentication(c echo.Context) error {
}
if webauthnUser == nil {
err = h.auditLogClient.Create(c, models.AuditLogWebAuthnAuthenticationFinalFailed, nil, fmt.Errorf("unkown user"))
err = h.auditLogger.Create(c, models.AuditLogWebAuthnAuthenticationFinalFailed, nil, fmt.Errorf("unkown user"))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -316,7 +316,7 @@ func (h *WebauthnHandler) FinishAuthentication(c echo.Context) error {
return webauthnUser, nil
}, *model, request)
if err != nil {
err = h.auditLogClient.Create(c, models.AuditLogWebAuthnAuthenticationFinalFailed, user, fmt.Errorf("assertion validation failed"))
err = h.auditLogger.Create(c, models.AuditLogWebAuthnAuthenticationFinalFailed, user, fmt.Errorf("assertion validation failed"))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -329,7 +329,7 @@ func (h *WebauthnHandler) FinishAuthentication(c echo.Context) error {
return fmt.Errorf("failed to get user: %w", err)
}
if webauthnUser == nil {
err = h.auditLogClient.Create(c, models.AuditLogWebAuthnAuthenticationFinalFailed, nil, fmt.Errorf("unkown user"))
err = h.auditLogger.Create(c, models.AuditLogWebAuthnAuthenticationFinalFailed, nil, fmt.Errorf("unkown user"))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -337,7 +337,7 @@ func (h *WebauthnHandler) FinishAuthentication(c echo.Context) error {
}
credential, err = h.webauthn.ValidateLogin(webauthnUser, *model, request)
if err != nil {
err = h.auditLogClient.Create(c, models.AuditLogWebAuthnAuthenticationFinalFailed, user, fmt.Errorf("assertion validation failed"))
err = h.auditLogger.Create(c, models.AuditLogWebAuthnAuthenticationFinalFailed, user, fmt.Errorf("assertion validation failed"))
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}
@ -366,7 +366,7 @@ func (h *WebauthnHandler) FinishAuthentication(c echo.Context) error {
c.Response().Header().Set("X-Auth-Token", token)
}
err = h.auditLogClient.Create(c, models.AuditLogWebAuthnAuthenticationFinalSucceeded, user, nil)
err = h.auditLogger.Create(c, models.AuditLogWebAuthnAuthenticationFinalSucceeded, user, nil)
if err != nil {
return fmt.Errorf("failed to create audit log: %w", err)
}

10
backend/handler/webauthn_test.go
View File

@ -24,7 +24,7 @@ var userIdBytes = []byte{0xec, 0x4e, 0xf0, 0x49, 0x5b, 0x88, 0x43, 0x21, 0xa1, 0
func TestNewWebauthnHandler(t *testing.T) {
p := test.NewPersister(nil, nil, nil, nil, nil, nil, nil)
handler, err := NewWebauthnHandler(&defaultConfig, p, sessionManager{}, test.NewAuditLogClient())
handler, err := NewWebauthnHandler(&defaultConfig, p, sessionManager{}, test.NewAuditLogger())
assert.NoError(t, err)
assert.NotEmpty(t, handler)
}
@ -40,7 +40,7 @@ func TestWebauthnHandler_BeginRegistration(t *testing.T) {
c.Set("session", token)
p := test.NewPersister(users, nil, nil, credentials, sessionData, nil, nil)
handler, err := NewWebauthnHandler(&defaultConfig, p, sessionManager{}, test.NewAuditLogClient())
handler, err := NewWebauthnHandler(&defaultConfig, p, sessionManager{}, test.NewAuditLogger())
require.NoError(t, err)
if assert.NoError(t, handler.BeginRegistration(c)) {
@ -76,7 +76,7 @@ func TestWebauthnHandler_FinishRegistration(t *testing.T) {
c.Set("session", token)
p := test.NewPersister(users, nil, nil, nil, sessionData, nil, nil)
handler, err := NewWebauthnHandler(&defaultConfig, p, sessionManager{}, test.NewAuditLogClient())
handler, err := NewWebauthnHandler(&defaultConfig, p, sessionManager{}, test.NewAuditLogger())
require.NoError(t, err)
if assert.NoError(t, handler.FinishRegistration(c)) {
@ -107,7 +107,7 @@ func TestWebauthnHandler_BeginAuthentication(t *testing.T) {
c := e.NewContext(req, rec)
p := test.NewPersister(users, nil, nil, nil, sessionData, nil, nil)
handler, err := NewWebauthnHandler(&defaultConfig, p, sessionManager{}, test.NewAuditLogClient())
handler, err := NewWebauthnHandler(&defaultConfig, p, sessionManager{}, test.NewAuditLogger())
require.NoError(t, err)
if assert.NoError(t, handler.BeginAuthentication(c)) {
@ -139,7 +139,7 @@ func TestWebauthnHandler_FinishAuthentication(t *testing.T) {
c := e.NewContext(req, rec)
p := test.NewPersister(users, nil, nil, credentials, sessionData, nil, nil)
handler, err := NewWebauthnHandler(&defaultConfig, p, sessionManager{}, test.NewAuditLogClient())
handler, err := NewWebauthnHandler(&defaultConfig, p, sessionManager{}, test.NewAuditLogger())
require.NoError(t, err)
if assert.NoError(t, handler.FinishAuthentication(c)) {

10
backend/server/public_router.go
View File

@ -50,17 +50,17 @@ func NewPublicRouter(cfg *config.Config, persister persistence.Persister) *echo.
panic(fmt.Errorf("failed to create mailer: %w", err))
}
auditLogClient := auditlog.NewClient(persister, cfg.AuditLog)
auditLogger := auditlog.NewLogger(persister, cfg.AuditLog)
if cfg.Password.Enabled {
passwordHandler := handler.NewPasswordHandler(persister, sessionManager, cfg, auditLogClient)
passwordHandler := handler.NewPasswordHandler(persister, sessionManager, cfg, auditLogger)
password := e.Group("/password")
password.PUT("", passwordHandler.Set, hankoMiddleware.Session(sessionManager))
password.POST("/login", passwordHandler.Login)
}
userHandler := handler.NewUserHandler(persister, auditLogClient)
userHandler := handler.NewUserHandler(persister, auditLogger)
e.GET("/me", userHandler.Me, hankoMiddleware.Session(sessionManager))
@ -71,11 +71,11 @@ func NewPublicRouter(cfg *config.Config, persister persistence.Persister) *echo.
e.POST("/user", userHandler.GetUserIdByEmail)
healthHandler := handler.NewHealthHandler()
webauthnHandler, err := handler.NewWebauthnHandler(cfg, persister, sessionManager, auditLogClient)
webauthnHandler, err := handler.NewWebauthnHandler(cfg, persister, sessionManager, auditLogger)
if err != nil {
panic(fmt.Errorf("failed to create public webauthn handler: %w", err))
}
passcodeHandler, err := handler.NewPasscodeHandler(cfg, persister, sessionManager, mailer, auditLogClient)
passcodeHandler, err := handler.NewPasscodeHandler(cfg, persister, sessionManager, mailer, auditLogger)
if err != nil {
panic(fmt.Errorf("failed to create public passcode handler: %w", err))
}

18
backend/test/audit_log_client.go
View File

@ -1,18 +0,0 @@
package test
import (
"github.com/labstack/echo/v4"
"github.com/teamhanko/hanko/backend/audit_log"
"github.com/teamhanko/hanko/backend/persistence/models"
)
func NewAuditLogClient() auditlog.Client {
return &auditLogClient{}
}
type auditLogClient struct {
}
func (a *auditLogClient) Create(context echo.Context, logType models.AuditLogType, user *models.User, err error) error {
return nil
}

18
backend/test/audit_loggger.go Normal file
View File

@ -0,0 +1,18 @@
package test
import (
"github.com/labstack/echo/v4"
"github.com/teamhanko/hanko/backend/audit_log"
"github.com/teamhanko/hanko/backend/persistence/models"
)
func NewAuditLogger() auditlog.Logger {
return &auditLogger{}
}
type auditLogger struct {
}
func (a *auditLogger) Create(context echo.Context, logType models.AuditLogType, user *models.User, err error) error {
return nil
}