d2ffc1b973
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.
203 lines
5.2 KiB
Go
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
|
|
}
|