From a28780859782b71990fe362ba922ec25f6f25c0b Mon Sep 17 00:00:00 2001 From: ttommybot Date: Thu, 23 Jul 2026 15:25:21 +0800 Subject: [PATCH] fix: prevent API keys from assigning owner role --- .../application/service/tenant_invitation.go | 6 +++ .../service/tenant_invitation_test.go | 32 +++++++++++++++ internal/application/service/tenant_member.go | 29 ++++++++++++++ .../application/service/tenant_member_test.go | 40 +++++++++++++++++++ internal/handler/tenant_invitation.go | 2 + internal/handler/tenant_invite_link.go | 6 +++ internal/handler/tenant_member.go | 4 ++ 7 files changed, 119 insertions(+) diff --git a/internal/application/service/tenant_invitation.go b/internal/application/service/tenant_invitation.go index aa60504e..cc3c11e8 100644 --- a/internal/application/service/tenant_invitation.go +++ b/internal/application/service/tenant_invitation.go @@ -151,6 +151,9 @@ func (s *tenantInvitationService) Create( if !role.IsValid() { return nil, ErrInvalidTenantRole } + if err := rejectAPIKeyOwnerAssignment(ctx, role); err != nil { + return nil, err + } // Reject early if the invitee is already an active member; the // handler renders this as "they're already in" rather than the // generic conflict. @@ -472,6 +475,9 @@ func (s *tenantInvitationService) CreateShareLink( if !role.IsValid() { return nil, "", ErrInvalidTenantRole } + if err := rejectAPIKeyOwnerAssignment(ctx, role); err != nil { + return nil, "", err + } token, err := generateShareLinkToken() if err != nil { return nil, "", err diff --git a/internal/application/service/tenant_invitation_test.go b/internal/application/service/tenant_invitation_test.go index 2960fedc..1a0b3c2a 100644 --- a/internal/application/service/tenant_invitation_test.go +++ b/internal/application/service/tenant_invitation_test.go @@ -232,6 +232,22 @@ func TestInvitationService_Create_RejectsInvalidRole(t *testing.T) { } } +func TestInvitationService_Create_APIKeyCannotInviteOwner(t *testing.T) { + svc, repo, _ := newInvitationSvc() + ctx := types.WithTenantAPIKeyScope(context.Background(), types.TenantAPIKeyScope{ + KeyID: 1, + Capabilities: types.StringArray{string(types.APIKeyCapabilityManageMembers)}, + }) + + _, err := svc.Create(ctx, 1, "u-bob", types.TenantRoleOwner, nil, "") + if !errors.Is(err, ErrAPIKeyCannotAssignOwner) { + t.Fatalf("want ErrAPIKeyCannotAssignOwner, got %v", err) + } + if len(repo.rows) != 0 { + t.Fatalf("API key owner invitation must not be persisted, got %d rows", len(repo.rows)) + } +} + func TestInvitationService_Create_RejectsAlreadyActiveMember(t *testing.T) { svc, _, memberSvc := newInvitationSvc() ctx := context.Background() @@ -461,6 +477,22 @@ func TestInvitationService_CreateShareLink_RejectsInvalidRole(t *testing.T) { } } +func TestInvitationService_CreateShareLink_APIKeyCannotAssignOwner(t *testing.T) { + svc, repo, _ := newInvitationSvc() + ctx := types.WithTenantAPIKeyScope(context.Background(), types.TenantAPIKeyScope{ + KeyID: 1, + Capabilities: types.StringArray{string(types.APIKeyCapabilityManageMembers)}, + }) + + _, _, err := svc.CreateShareLink(ctx, 1, types.TenantRoleOwner, nil, "") + if !errors.Is(err, ErrAPIKeyCannotAssignOwner) { + t.Fatalf("want ErrAPIKeyCannotAssignOwner, got %v", err) + } + if len(repo.rows) != 0 { + t.Fatalf("API key owner invite link must not be persisted, got %d rows", len(repo.rows)) + } +} + func TestInvitationService_LookupByToken_RejectsUnknownToken(t *testing.T) { svc, _, _ := newInvitationSvc() if _, err := svc.LookupByToken(context.Background(), "nonexistent"); !errors.Is(err, ErrInvitationTokenInvalid) { diff --git a/internal/application/service/tenant_member.go b/internal/application/service/tenant_member.go index 6936b291..06e610a7 100644 --- a/internal/application/service/tenant_member.go +++ b/internal/application/service/tenant_member.go @@ -54,6 +54,14 @@ var ( // value that is not one of the four defined TenantRole constants. ErrInvalidTenantRole = errors.New("invalid tenant role") + // ErrAPIKeyCannotAssignOwner is returned when an API-key principal + // attempts to persist the Owner role through member or invitation + // management. manage_members deliberately excludes ownership transfer: + // a machine principal may manage lower roles, but must never mint a + // durable human Owner who could subsequently manage API keys or delete + // the tenant. + ErrAPIKeyCannotAssignOwner = errors.New("API keys cannot assign the owner role") + // ErrLastOwner is returned when an operation would leave the tenant // without an active Owner. Demoting the last Owner or removing them // is forbidden; an explicit ownership transfer must happen first. @@ -111,6 +119,21 @@ func auditActor(ctx context.Context) string { return uid } +// rejectAPIKeyOwnerAssignment is the service-layer boundary shared by +// direct membership writes and both invitation creation paths. Route RBAC +// intentionally defers API-key authorization to APIKeyGate, so checking the +// authenticated principal in the service is required to preserve the +// manage_members "no ownership transfer" contract across every caller. +func rejectAPIKeyOwnerAssignment(ctx context.Context, role types.TenantRole) error { + if role != types.TenantRoleOwner { + return nil + } + if _, ok := types.TenantAPIKeyScopeFromContext(ctx); ok { + return ErrAPIKeyCannotAssignOwner + } + return nil +} + // AddMember inserts a new active membership row. Returns // ErrMembershipAlreadyExists if the user is already an active member of // the tenant, and ErrInvalidTenantRole for unknown roles. @@ -124,6 +147,9 @@ func (s *tenantMemberService) AddMember( if !role.IsValid() { return nil, ErrInvalidTenantRole } + if err := rejectAPIKeyOwnerAssignment(ctx, role); err != nil { + return nil, err + } existing, err := s.repo.Get(ctx, userID, tenantID) if err != nil { return nil, err @@ -273,6 +299,9 @@ func (s *tenantMemberService) UpdateRole( if !newRole.IsValid() { return ErrInvalidTenantRole } + if err := rejectAPIKeyOwnerAssignment(ctx, newRole); err != nil { + return err + } current, err := s.repo.Get(ctx, userID, tenantID) if err != nil { return err diff --git a/internal/application/service/tenant_member_test.go b/internal/application/service/tenant_member_test.go index 151d6e73..9dc0807e 100644 --- a/internal/application/service/tenant_member_test.go +++ b/internal/application/service/tenant_member_test.go @@ -268,6 +268,22 @@ func TestTenantMemberService_AddMember_RejectsInvalidRole(t *testing.T) { } } +func TestTenantMemberService_AddMember_APIKeyCannotAssignOwner(t *testing.T) { + svc, repo := newServiceWithRepo() + ctx := types.WithTenantAPIKeyScope(context.Background(), types.TenantAPIKeyScope{ + KeyID: 1, + Capabilities: types.StringArray{string(types.APIKeyCapabilityManageMembers)}, + }) + + _, err := svc.AddMember(ctx, "u1", 1, types.TenantRoleOwner, nil) + if !errors.Is(err, ErrAPIKeyCannotAssignOwner) { + t.Fatalf("want ErrAPIKeyCannotAssignOwner, got %v", err) + } + if len(repo.rows) != 0 { + t.Fatalf("API key owner assignment must not create a membership, got %d rows", len(repo.rows)) + } +} + func TestTenantMemberService_AddMember_RejectsDuplicate(t *testing.T) { svc, _ := newServiceWithRepo() ctx := context.Background() @@ -326,6 +342,30 @@ func TestTenantMemberService_UpdateRole_BlocksDemotingLastOwner(t *testing.T) { } } +func TestTenantMemberService_UpdateRole_APIKeyCannotPromoteOwner(t *testing.T) { + svc, _ := newServiceWithRepo() + humanCtx := context.Background() + if _, err := svc.AddMember(humanCtx, "u1", 1, types.TenantRoleAdmin, nil); err != nil { + t.Fatalf("seed: %v", err) + } + apiKeyCtx := types.WithTenantAPIKeyScope(humanCtx, types.TenantAPIKeyScope{ + KeyID: 1, + Capabilities: types.StringArray{string(types.APIKeyCapabilityManageMembers)}, + }) + + err := svc.UpdateRole(apiKeyCtx, "u1", 1, types.TenantRoleOwner) + if !errors.Is(err, ErrAPIKeyCannotAssignOwner) { + t.Fatalf("want ErrAPIKeyCannotAssignOwner, got %v", err) + } + member, getErr := svc.GetMembership(humanCtx, "u1", 1) + if getErr != nil { + t.Fatalf("get membership: %v", getErr) + } + if member == nil || member.Role != types.TenantRoleAdmin { + t.Fatalf("API key promotion must leave role unchanged, got %+v", member) + } +} + func TestTenantMemberService_UpdateRole_AllowsDemotionWhenOtherOwnerExists(t *testing.T) { svc, _ := newServiceWithRepo() ctx := context.Background() diff --git a/internal/handler/tenant_invitation.go b/internal/handler/tenant_invitation.go index ed75c167..73beadb7 100644 --- a/internal/handler/tenant_invitation.go +++ b/internal/handler/tenant_invitation.go @@ -295,6 +295,8 @@ func (h *TenantInvitationHandler) CreateInvitation(c *gin.Context) { switch { case errors.Is(err, service.ErrInvalidTenantRole): c.Error(apperrors.NewValidationError(err.Error())) + case errors.Is(err, service.ErrAPIKeyCannotAssignOwner): + c.Error(apperrors.NewForbiddenError(err.Error())) case errors.Is(err, service.ErrPendingInvitationExists): c.Error(apperrors.NewConflictError(err.Error())) case errors.Is(err, service.ErrAlreadyMember): diff --git a/internal/handler/tenant_invite_link.go b/internal/handler/tenant_invite_link.go index 057d97d6..2741b2d6 100644 --- a/internal/handler/tenant_invite_link.go +++ b/internal/handler/tenant_invite_link.go @@ -1,12 +1,14 @@ package handler import ( + "errors" "net/http" "os" "strings" "github.com/gin-gonic/gin" + "github.com/Tencent/WeKnora/internal/application/service" "github.com/Tencent/WeKnora/internal/config" apperrors "github.com/Tencent/WeKnora/internal/errors" "github.com/Tencent/WeKnora/internal/logger" @@ -88,6 +90,10 @@ func (h *TenantInvitationHandler) CreateInviteLink(c *gin.Context) { inv, _, err := h.invitationService.CreateShareLink(ctx, tenantID, req.Role, invitedBy, req.Message) if err != nil { + if errors.Is(err, service.ErrAPIKeyCannotAssignOwner) { + c.Error(apperrors.NewForbiddenError(err.Error())) + return + } logger.Errorf(ctx, "CreateShareLink failed: tenant=%d err=%v", tenantID, err) c.Error(apperrors.NewInternalServerError("failed to create share link").WithDetails(err.Error())) return diff --git a/internal/handler/tenant_member.go b/internal/handler/tenant_member.go index 8daff12d..445dd63f 100644 --- a/internal/handler/tenant_member.go +++ b/internal/handler/tenant_member.go @@ -239,6 +239,8 @@ func (h *TenantMemberHandler) AddMember(c *gin.Context) { switch { case errors.Is(err, service.ErrInvalidTenantRole): c.Error(apperrors.NewValidationError(err.Error())) + case errors.Is(err, service.ErrAPIKeyCannotAssignOwner): + c.Error(apperrors.NewForbiddenError(err.Error())) case errors.Is(err, service.ErrMembershipAlreadyExists): // 409 reads better than 400 here: the request was syntactically // fine, the conflict is semantic ("already a member"). @@ -312,6 +314,8 @@ func (h *TenantMemberHandler) UpdateMemberRole(c *gin.Context) { c.Error(apperrors.NewConflictError(err.Error())) case errors.Is(err, service.ErrInvalidTenantRole): c.Error(apperrors.NewValidationError(err.Error())) + case errors.Is(err, service.ErrAPIKeyCannotAssignOwner): + c.Error(apperrors.NewForbiddenError(err.Error())) default: logger.Errorf(ctx, "UpdateRole failed: user=%s tenant=%d err=%v", userID, tenantID, err)