Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

fix(auth): lsp handler (#17912)

p0ny2bedbb3c01f1
diff --git a/backend/api/auth/auth.go b/backend/api/auth/auth.go
index a92eda7f44..92bbcbd901 100644
--- a/backend/api/auth/auth.go
+++ b/backend/api/auth/auth.go
@@ -138,14 +138,16 @@ func (in *APIAuthInterceptor) WrapStreamingHandler(next connect.StreamingHandler
}
}
-// authenticateConnect is a ConnectRPC-specific version that returns ConnectRPC errors.
-func (in *APIAuthInterceptor) authenticateConnect(ctx context.Context, accessTokenStr string) (*store.UserMessage, error) {
+// authenticate is the shared authentication logic that validates JWT tokens.
+// Returns the user and claims, or an error. This is the single source of truth for token validation.
+func (in *APIAuthInterceptor) authenticate(ctx context.Context, accessTokenStr string) (*store.UserMessage, *claimsMessage, error) {
if accessTokenStr == "" {
- return nil, connect.NewError(connect.CodeUnauthenticated, errs.New("access token not found"))
+ return nil, nil, errs.New("access token not found")
}
if _, ok := in.stateCfg.ExpireCache.Get(accessTokenStr); ok {
- return nil, connect.NewError(connect.CodeUnauthenticated, errs.New("access token expired"))
+ return nil, nil, errs.New("access token expired")
}
+
claims := &claimsMessage{}
if _, err := jwt.ParseWithClaims(accessTokenStr, claims, func(t *jwt.Token) (any, error) {
if t.Method.Alg() != jwt.SigningMethodHS256.Name {
@@ -159,33 +161,43 @@ func (in *APIAuthInterceptor) authenticateConnect(ctx context.Context, accessTok
return nil, errs.Errorf("unexpected access token kid=%v", t.Header["kid"])
}); err != nil {
if errors.Is(err, jwt.ErrTokenExpired) {
- return nil, connect.NewError(connect.CodeUnauthenticated, errs.New("access token expired"))
+ return nil, nil, errs.New("access token expired")
}
- return nil, connect.NewError(connect.CodeUnauthenticated, errs.New("failed to parse claim"))
+ return nil, nil, errs.New("failed to parse claim")
}
+
if !audienceContains(claims.Audience, fmt.Sprintf(AccessTokenAudienceFmt, in.profile.Mode)) {
- return nil, connect.NewError(connect.CodeUnauthenticated, errs.Errorf(
+ return nil, nil, errs.Errorf(
"invalid access token, audience mismatch, got %q, expected %q. you may send request to the wrong environment",
claims.Audience,
fmt.Sprintf(AccessTokenAudienceFmt, in.profile.Mode),
- ))
+ )
}
principalID, err := strconv.Atoi(claims.Subject)
if err != nil {
- return nil, connect.NewError(connect.CodeUnauthenticated, errs.Errorf("malformed ID %q in the access token", claims.Subject))
+ return nil, nil, errs.Errorf("malformed ID %q in the access token", claims.Subject)
}
user, err := in.store.GetUserByID(ctx, principalID)
if err != nil {
- return nil, connect.NewError(connect.CodeUnauthenticated, errs.Errorf("failed to find user ID %q in the access token", principalID))
+ return nil, nil, errs.Errorf("failed to find user ID %q in the access token", principalID)
}
if user == nil {
- return nil, connect.NewError(connect.CodeUnauthenticated, errs.Errorf("user ID %q not exists in the access token", principalID))
+ return nil, nil, errs.Errorf("user ID %q not exists in the access token", principalID)
}
if user.MemberDeleted {
- return nil, connect.NewError(connect.CodeUnauthenticated, errs.Errorf("user ID %q has been deactivated by administrators", user.ID))
+ return nil, nil, errs.Errorf("user ID %q has been deactivated by administrators", user.ID)
}
+ return user, claims, nil
+}
+
+// authenticateConnect is a ConnectRPC-specific version that returns ConnectRPC errors.
+func (in *APIAuthInterceptor) authenticateConnect(ctx context.Context, accessTokenStr string) (*store.UserMessage, error) {
+ user, _, err := in.authenticate(ctx, accessTokenStr)
+ if err != nil {
+ return nil, connect.NewError(connect.CodeUnauthenticated, err)
+ }
return user, nil
}
@@ -228,6 +240,22 @@ func GetUserIDFromMFATempToken(token string, mode common.ReleaseMode, secret str
return userID, nil
}
+// AuthenticateToken validates a JWT access token and returns the user and token expiry.
+// This is a non-ConnectRPC version that returns regular errors instead of ConnectRPC errors.
+func (in *APIAuthInterceptor) AuthenticateToken(ctx context.Context, accessTokenStr string) (*store.UserMessage, time.Time, error) {
+ user, claims, err := in.authenticate(ctx, accessTokenStr)
+ if err != nil {
+ return nil, time.Time{}, err
+ }
+
+ var tokenExpiry time.Time
+ if claims.ExpiresAt != nil {
+ tokenExpiry = claims.ExpiresAt.Time
+ }
+
+ return user, tokenExpiry, nil
+}
+
// GetTokenFromHeaders extracts the access token from HTTP headers for ConnectRPC.
func GetTokenFromHeaders(headers http.Header) (string, error) {
// Check Authorization header first
diff --git a/backend/api/lsp/handler.go b/backend/api/lsp/handler.go
index db758f9dd7..a8c92a11ff 100644
--- a/backend/api/lsp/handler.go
+++ b/backend/api/lsp/handler.go
@@ -15,6 +15,7 @@ import (
"github.com/bytebase/bytebase/backend/common"
"github.com/bytebase/bytebase/backend/common/log"
"github.com/bytebase/bytebase/backend/component/config"
+ "github.com/bytebase/bytebase/backend/component/iam"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
"github.com/bytebase/bytebase/backend/store"
@@ -46,11 +47,14 @@ const (
LSPCustomMethodSQLStatementRanges Method = "$/textDocument/statementRanges"
)
-// NewHandler creates a new Language Server Protocol handler.
-func NewHandler(s *store.Store, profile *config.Profile) jsonrpc2.Handler {
+// NewHandlerWithAuth creates a new Language Server Protocol handler with authentication.
+func NewHandlerWithAuth(s *store.Store, profile *config.Profile, iamManager *iam.Manager, user *store.UserMessage, tokenExpiry time.Time) jsonrpc2.Handler {
handler := &Handler{
store: s,
profile: profile,
+ user: user,
+ tokenExpiry: tokenExpiry,
+ iamManager: iamManager,
diagnosticsDebouncer: NewDiagnosticsDebouncer(500 * time.Millisecond), // 500ms debounce
contentCache: NewContentCache(100), // Cache up to 100 documents
perfMonitor: NewPerformanceMonitor(),
@@ -78,6 +82,11 @@ type Handler struct {
metadata *SetMetadataCommandArguments
store *store.Store
+ // Auth-related fields
+ user *store.UserMessage
+ tokenExpiry time.Time
+ iamManager *iam.Manager
+
shutDown bool
profile *config.Profile
cancelF sync.Map // map[jsonrpc2.ID]context.CancelFunc
@@ -189,6 +198,59 @@ func (h *Handler) checkReady() error {
return nil
}
+func (h *Handler) checkTokenExpiry() error {
+ if !h.tokenExpiry.IsZero() && time.Now().After(h.tokenExpiry) {
+ return errors.New("access token expired, please reconnect")
+ }
+ return nil
+}
+
+func (h *Handler) checkMetadataPermissions(ctx context.Context, metadata SetMetadataCommandArguments) error {
+ if h.user == nil {
+ return errors.New("user not authenticated")
+ }
+
+ // If database is specified, check database schema permission
+ if metadata.DatabaseName != "" && metadata.InstanceID != "" {
+ // Need to get database to find its project
+ instanceID, err := common.GetInstanceID(metadata.InstanceID)
+ if err != nil {
+ return err
+ }
+
+ database, err := h.store.GetDatabaseV2(ctx, &store.FindDatabaseMessage{
+ InstanceID: &instanceID,
+ DatabaseName: &metadata.DatabaseName,
+ })
+ if err != nil {
+ return errors.Wrap(err, "failed to get database")
+ }
+ if database == nil {
+ return errors.Errorf("database %q not found", metadata.DatabaseName)
+ }
+
+ // Check bb.databases.getSchema permission
+ ok, err := h.iamManager.CheckPermission(ctx, iam.PermissionDatabasesGetSchema, h.user, database.ProjectID)
+ if err != nil {
+ return errors.Wrap(err, "failed to check permission")
+ }
+ if !ok {
+ return errors.Errorf("no permission to access database %q", metadata.DatabaseName)
+ }
+ } else if metadata.InstanceID != "" && metadata.DatabaseName == "" {
+ // If only instance is specified, check instance get permission
+ ok, err := h.iamManager.CheckPermission(ctx, iam.PermissionInstancesGet, h.user)
+ if err != nil {
+ return errors.Wrap(err, "failed to check permission")
+ }
+ if !ok {
+ return errors.Errorf("no permission to access instance %q", metadata.InstanceID)
+ }
+ }
+
+ return nil
+}
+
func (h *Handler) reset(params *lsp.InitializeParams) error {
h.mu.Lock()
defer h.mu.Unlock()
@@ -212,6 +274,12 @@ func (h *Handler) handle(ctx context.Context, conn *jsonrpc2.Conn, req *jsonrpc2
}
}()
+ // Check token expiry before processing any request
+ if err := h.checkTokenExpiry(); err != nil {
+ conn.Close()
+ return nil, err
+ }
+
// Handle ping request before checking if the server is initialized.
if Method(req.Method) == LSPMethodPing {
return PingResult{Result: "pong"}, nil
@@ -307,6 +375,13 @@ func (h *Handler) handle(ctx context.Context, conn *jsonrpc2.Conn, req *jsonrpc2
if len(setMetadataParams.Arguments) != 1 {
return nil, &jsonrpc2.Error{Code: jsonrpc2.CodeInvalidParams, Message: "expected exactly one argument"}
}
+ // Check RBAC permissions before setting metadata
+ if err := h.checkMetadataPermissions(ctx, setMetadataParams.Arguments[0]); err != nil {
+ return nil, &jsonrpc2.Error{
+ Code: jsonrpc2.CodeInvalidRequest,
+ Message: fmt.Sprintf("permission denied: %v", err),
+ }
+ }
h.setMetadata(setMetadataParams.Arguments[0])
return nil, nil
default:
diff --git a/backend/api/lsp/lsp.go b/backend/api/lsp/lsp.go
index a03057df90..eed8444556 100644
--- a/backend/api/lsp/lsp.go
+++ b/backend/api/lsp/lsp.go
@@ -5,6 +5,7 @@ import (
"log/slog"
"net/http"
"strings"
+ "time"
"github.com/gorilla/websocket"
"github.com/labstack/echo/v4"
@@ -13,20 +14,34 @@ import (
wsjsonrpc2 "github.com/sourcegraph/jsonrpc2/websocket"
+ "github.com/bytebase/bytebase/backend/api/auth"
"github.com/bytebase/bytebase/backend/common/log"
"github.com/bytebase/bytebase/backend/common/stacktrace"
"github.com/bytebase/bytebase/backend/component/config"
+ "github.com/bytebase/bytebase/backend/component/iam"
"github.com/bytebase/bytebase/backend/store"
)
var (
upgrader = websocket.Upgrader{CheckOrigin: func(_ *http.Request) bool { return true }}
- newHandler = func(s *store.Store, profile *config.Profile) (jsonrpc2.Handler, io.Closer) {
- return NewHandler(s, profile), io.NopCloser(strings.NewReader(""))
+ newHandler = func(s *store.Store, profile *config.Profile, iamManager *iam.Manager, user *store.UserMessage, tokenExpiry time.Time) (jsonrpc2.Handler, io.Closer) {
+ return NewHandlerWithAuth(s, profile, iamManager, user, tokenExpiry), io.NopCloser(strings.NewReader(""))
}
)
func (s *Server) Router(c echo.Context) error {
+ // Authenticate user before upgrading WebSocket connection
+ accessTokenStr, err := auth.GetTokenFromHeaders(c.Request().Header)
+ if err != nil {
+ return echo.NewHTTPError(http.StatusUnauthorized, "missing access token")
+ }
+
+ // Authenticate user using server's auth interceptor
+ user, tokenExpiry, err := s.authInterceptor.AuthenticateToken(c.Request().Context(), accessTokenStr)
+ if err != nil {
+ return echo.NewHTTPError(http.StatusUnauthorized, err.Error())
+ }
+
connection, err := upgrader.Upgrade(c.Response(), c.Request(), nil)
if err != nil {
slog.Error("Failed to upgrade websocket connection", log.BBError(errors.Errorf("errors: %v\n%s", err, stacktrace.TakeStacktrace(20 /* n */, 5 /* skip */))))
@@ -42,7 +57,7 @@ func (s *Server) Router(c echo.Context) error {
})
connectionID := s.connectionCount.Add(1)
- handler, closer := newHandler(s.store, s.profile)
+ handler, closer := newHandler(s.store, s.profile, s.iamManager, user, tokenExpiry)
ctx := c.Request().Context()
<-jsonrpc2.NewConn(ctx, wsjsonrpc2.NewObjectStream(connection), handler, nil /* connOpt */).DisconnectNotify()
err = closer.Close()
diff --git a/backend/api/lsp/server.go b/backend/api/lsp/server.go
index b24bb573ce..81ddc502eb 100644
--- a/backend/api/lsp/server.go
+++ b/backend/api/lsp/server.go
@@ -3,7 +3,11 @@ package lsp
import (
"sync/atomic"
+ "github.com/bytebase/bytebase/backend/api/auth"
"github.com/bytebase/bytebase/backend/component/config"
+ "github.com/bytebase/bytebase/backend/component/iam"
+ "github.com/bytebase/bytebase/backend/component/state"
+ "github.com/bytebase/bytebase/backend/enterprise"
"github.com/bytebase/bytebase/backend/store"
)
@@ -11,17 +15,31 @@ import (
type Server struct {
connectionCount atomic.Uint64
- store *store.Store
- profile *config.Profile
+ store *store.Store
+ profile *config.Profile
+ secret string
+ stateCfg *state.State
+ iamManager *iam.Manager
+ licenseService *enterprise.LicenseService
+ authInterceptor *auth.APIAuthInterceptor
}
// NewServer creates a Language Server Protocol service.
func NewServer(
store *store.Store,
profile *config.Profile,
+ secret string,
+ stateCfg *state.State,
+ iamManager *iam.Manager,
+ licenseService *enterprise.LicenseService,
) *Server {
return &Server{
- store: store,
- profile: profile,
+ store: store,
+ profile: profile,
+ secret: secret,
+ stateCfg: stateCfg,
+ iamManager: iamManager,
+ licenseService: licenseService,
+ authInterceptor: auth.New(store, secret, licenseService, stateCfg, profile),
}
}
diff --git a/backend/server/server.go b/backend/server/server.go
index bfce7a4de6..496b8211c6 100644
--- a/backend/server/server.go
+++ b/backend/server/server.go
@@ -210,7 +210,7 @@ func NewServer(ctx context.Context, profile *config.Profile) (*Server, error) {
s.initMetricReporter()
// LSP server.
- s.lspServer = lsp.NewServer(s.store, profile)
+ s.lspServer = lsp.NewServer(s.store, profile, secret, s.stateCfg, s.iamManager, s.licenseService)
directorySyncServer := directorysync.NewService(s.store, s.licenseService, s.iamManager)