Files
Enterprise-Knowledge-Base/internal/application/service/tenant_api_key.go
T
wizardchen d2ffc1b973 refactor(api-keys): simplify authorization to a single-role gate
Redesign tenant API key authorization around one dimension (role) plus a
central default-deny gate, replacing the previous role + KB-scoped flag model.

- Add APIKeyGate as the single authority for API-key authorization: routes
  declare one policy (MinRole) via apiKeyGroup/apiKeyRoute helpers; undeclared
  routes are denied by default. JWT principals short-circuit the gate and the
  JWT-centric RBAC guards short-circuit for API-key principals.
- Roles: viewer/contributor/admin are knowledge-base data-plane only (KB scope
  is a pure downstream data filter); owner is a full-access tenant tier that
  unlocks tenant-level infrastructure routes and is required for every method.
- Drop the KBScoped policy flag and the KB-restricted-vs-tenant branching.
- Security hardening: never disclose HMAC secret (return presence only), abort
  writes on API-key encryption failure, deny KB-restricted keys on /files, and
  backfill legacy key hashes at startup instead of O(N) plaintext scans.
- Frontend: two-level create dialog (access type -> permission level), rename
  role labels to reflect actual scope, sync en/zh/ko/ru locales.
- Fix startup self-check false-positive on trailing-slash routes and normalize
  gin paths before comparison; add regression tests.
2026-07-07 12:00:13 +08:00

203 lines
5.2 KiB
Go

package service
import (
"context"
"crypto/rand"
"crypto/sha256"
"crypto/subtle"
"encoding/base64"
"encoding/hex"
"errors"
"strings"
"time"
apprepo "github.com/Tencent/WeKnora/internal/application/repository"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
)
type tenantAPIKeyService struct {
repo interfaces.TenantAPIKeyRepository
}
func NewTenantAPIKeyService(repo interfaces.TenantAPIKeyRepository) interfaces.TenantAPIKeyService {
return &tenantAPIKeyService{repo: repo}
}
func (s *tenantAPIKeyService) CreateAPIKey(
ctx context.Context, req interfaces.TenantAPIKeyCreateRequest,
) (*interfaces.TenantAPIKeyCreateResult, error) {
if req.TenantID == 0 {
return nil, errors.New("tenant_id is required")
}
name := strings.TrimSpace(req.Name)
if name == "" {
return nil, errors.New("name is required")
}
token, err := generateTenantAPIKeyToken()
if err != nil {
return nil, err
}
key := &types.TenantAPIKey{
TenantID: req.TenantID,
Name: name,
KeyHash: hashTenantAPIKey(token),
APIKey: token,
Role: types.NormalizeTenantAPIKeyRole(req.Role),
KnowledgeBaseIDs: normalizeAPIKeyIDs(req.KnowledgeBaseIDs),
ExpiresAt: req.ExpiresAt,
}
if key.Role == "" {
key.Role = types.TenantRoleViewer
}
if err := s.repo.CreateAPIKey(ctx, key); err != nil {
return nil, err
}
return &interfaces.TenantAPIKeyCreateResult{APIKey: key, Token: token}, nil
}
func (s *tenantAPIKeyService) AuthenticateAPIKey(ctx context.Context, token string) (*types.TenantAPIKey, error) {
token = strings.TrimSpace(token)
if token == "" {
return nil, apprepo.ErrTenantAPIKeyNotFound
}
key, err := s.repo.GetAPIKeyByHash(ctx, hashTenantAPIKey(token))
if err != nil {
return nil, err
}
if key.RevokedAt != nil {
return nil, apprepo.ErrTenantAPIKeyNotFound
}
if key.ExpiresAt != nil && time.Now().After(*key.ExpiresAt) {
return nil, apprepo.ErrTenantAPIKeyNotFound
}
_ = s.repo.UpdateAPIKeyLastUsed(ctx, key.ID, time.Now())
return key, nil
}
func (s *tenantAPIKeyService) AuthenticateTenantAPIKey(
ctx context.Context, tenantID uint64, token string,
) (*types.TenantAPIKey, error) {
token = strings.TrimSpace(token)
if tenantID == 0 || token == "" {
return nil, apprepo.ErrTenantAPIKeyNotFound
}
if key, err := s.AuthenticateAPIKey(ctx, token); err == nil && key != nil {
if key.TenantID != tenantID {
return nil, apprepo.ErrTenantAPIKeyNotFound
}
return key, nil
} else if err != nil && !errors.Is(err, apprepo.ErrTenantAPIKeyNotFound) {
return nil, err
}
keys, err := s.repo.ListAPIKeys(ctx, tenantID)
if err != nil {
return nil, err
}
for _, key := range keys {
if key == nil || subtle.ConstantTimeCompare([]byte(key.APIKey), []byte(token)) != 1 {
continue
}
if key.ExpiresAt != nil && time.Now().After(*key.ExpiresAt) {
return nil, apprepo.ErrTenantAPIKeyNotFound
}
if err := s.ensureAPIKeyHash(ctx, key); err != nil {
return nil, err
}
_ = s.repo.UpdateAPIKeyLastUsed(ctx, key.ID, time.Now())
return key, nil
}
return nil, apprepo.ErrTenantAPIKeyNotFound
}
func (s *tenantAPIKeyService) ListAPIKeys(ctx context.Context, tenantID uint64) ([]*types.TenantAPIKey, error) {
keys, err := s.repo.ListAPIKeys(ctx, tenantID)
if err != nil {
return nil, err
}
for _, key := range keys {
if err := s.ensureAPIKeyHash(ctx, key); err != nil {
return nil, err
}
}
return keys, nil
}
func (s *tenantAPIKeyService) RevokeAPIKey(ctx context.Context, tenantID uint64, id uint64) error {
return s.repo.RevokeAPIKey(ctx, tenantID, id)
}
func (s *tenantAPIKeyService) RevokeAllAPIKeys(ctx context.Context, tenantID uint64) error {
if tenantID == 0 {
return nil
}
return s.repo.RevokeAllAPIKeys(ctx, tenantID)
}
func (s *tenantAPIKeyService) BackfillMissingKeyHashes(ctx context.Context) (int, error) {
keys, err := s.repo.ListKeysWithPlaceholderHash(ctx)
if err != nil {
return 0, err
}
backfilled := 0
for _, key := range keys {
if key == nil || strings.TrimSpace(key.APIKey) == "" {
continue
}
hash := hashTenantAPIKey(key.APIKey)
if key.KeyHash == hash {
continue
}
if err := s.repo.UpdateAPIKeyHash(ctx, key.ID, hash); err != nil {
return backfilled, err
}
backfilled++
}
return backfilled, nil
}
func generateTenantAPIKeyToken() (string, error) {
var b [32]byte
if _, err := rand.Read(b[:]); err != nil {
return "", err
}
return "sk-" + base64.RawURLEncoding.EncodeToString(b[:]), nil
}
func hashTenantAPIKey(token string) string {
sum := sha256.Sum256([]byte(token))
return hex.EncodeToString(sum[:])
}
func (s *tenantAPIKeyService) ensureAPIKeyHash(ctx context.Context, key *types.TenantAPIKey) error {
if key == nil || strings.TrimSpace(key.APIKey) == "" {
return nil
}
hash := hashTenantAPIKey(key.APIKey)
if key.KeyHash == hash {
return nil
}
if err := s.repo.UpdateAPIKeyHash(ctx, key.ID, hash); err != nil {
return err
}
key.KeyHash = hash
return nil
}
func normalizeAPIKeyIDs(in []string) types.StringArray {
out := types.StringArray{}
seen := map[string]struct{}{}
for _, id := range in {
id = strings.TrimSpace(id)
if id == "" {
continue
}
if _, ok := seen[id]; ok {
continue
}
seen[id] = struct{}{}
out = append(out, id)
}
return out
}