Skip to content

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

refactor(auth): extract shared token infrastructure (#18637)

p0ny3f924f8e1de9
diff --git a/backend/api/auth/auth.go b/backend/api/auth/auth.go
index 1c534c3c17..afa8797509 100644
--- a/backend/api/auth/auth.go
+++ b/backend/api/auth/auth.go
@@ -293,57 +293,6 @@ func audienceContains(audience jwt.ClaimStrings, token string) bool {
return slices.Contains(audience, token)
}
-type claimsMessage struct {
- Name string `json:"name"`
- jwt.RegisteredClaims
-}
-
-// GenerateAPIToken generates an API token.
-func GenerateAPIToken(userEmail string, mode common.ReleaseMode, secret string) (string, error) {
- expirationTime := time.Now().Add(apiTokenDuration)
- return generateToken(userEmail, fmt.Sprintf(AccessTokenAudienceFmt, mode), expirationTime, []byte(secret))
-}
-
-// GenerateAccessToken generates an access token for web.
-func GenerateAccessToken(userEmail string, mode common.ReleaseMode, secret string, tokenDuration time.Duration) (string, error) {
- expirationTime := time.Now().Add(tokenDuration)
- return generateToken(userEmail, fmt.Sprintf(AccessTokenAudienceFmt, mode), expirationTime, []byte(secret))
-}
-
-// GenerateMFATempToken generates a temporary token for MFA.
-func GenerateMFATempToken(userEmail string, mode common.ReleaseMode, secret string, tokenDuration time.Duration) (string, error) {
- expirationTime := time.Now().Add(tokenDuration)
- return generateToken(userEmail, fmt.Sprintf(MFATempTokenAudienceFmt, mode), expirationTime, []byte(secret))
-}
-
-// Pay attention to this function. It holds the main JWT token generation logic.
-func generateToken(userEmail string, aud string, expirationTime time.Time, secret []byte) (string, error) {
- // Create the JWT claims, which includes the user email and expiry time.
- claims := &claimsMessage{
- Name: userEmail,
- RegisteredClaims: jwt.RegisteredClaims{
- Audience: jwt.ClaimStrings{aud},
- // In JWT, the expiry time is expressed as unix milliseconds.
- ExpiresAt: jwt.NewNumericDate(expirationTime),
- IssuedAt: jwt.NewNumericDate(time.Now()),
- Issuer: issuer,
- Subject: userEmail,
- },
- }
-
- // Declare the token with the HS256 algorithm used for signing, and the claims.
- token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
- token.Header["kid"] = keyID
-
- // Create the JWT string.
- tokenString, err := token.SignedString(secret)
- if err != nil {
- return "", err
- }
-
- return tokenString, nil
-}
-
func getAuthContext(fullMethod string) (*common.AuthContext, error) {
methodTokens := strings.Split(fullMethod, "/")
if len(methodTokens) != 3 {
diff --git a/backend/api/auth/tokens.go b/backend/api/auth/tokens.go
new file mode 100644
index 0000000000..a2e407703e
--- /dev/null
+++ b/backend/api/auth/tokens.go
@@ -0,0 +1,108 @@
+package auth
+
+import (
+ "crypto/rand"
+ "crypto/sha256"
+ "encoding/base64"
+ "fmt"
+ "time"
+
+ "github.com/golang-jwt/jwt/v5"
+
+ "github.com/bytebase/bytebase/backend/common"
+)
+
+// GenerateOpaqueToken creates a cryptographically random opaque token.
+// Returns 32 bytes encoded as base64url (43 characters).
+func GenerateOpaqueToken() (string, error) {
+ bytes := make([]byte, 32)
+ if _, err := rand.Read(bytes); err != nil {
+ return "", err
+ }
+ return base64.RawURLEncoding.EncodeToString(bytes), nil
+}
+
+// HashToken returns the SHA256 hash of a token, encoded as base64url.
+// Used for secure storage of opaque tokens in the database.
+func HashToken(token string) string {
+ hash := sha256.Sum256([]byte(token))
+ return base64.RawURLEncoding.EncodeToString(hash[:])
+}
+
+// claimsMessage is the JWT claims structure for web authentication tokens.
+type claimsMessage struct {
+ Name string `json:"name"`
+ jwt.RegisteredClaims
+}
+
+// oauth2ClaimsMessage extends claimsMessage with OAuth2-specific fields.
+type oauth2ClaimsMessage struct {
+ claimsMessage
+ ClientID string `json:"client_id,omitempty"`
+}
+
+// GenerateAPIToken generates an API token.
+func GenerateAPIToken(userEmail string, mode common.ReleaseMode, secret string) (string, error) {
+ expirationTime := time.Now().Add(apiTokenDuration)
+ return generateToken(userEmail, fmt.Sprintf(AccessTokenAudienceFmt, mode), expirationTime, []byte(secret))
+}
+
+// GenerateAccessToken generates an access token for web.
+func GenerateAccessToken(userEmail string, mode common.ReleaseMode, secret string, tokenDuration time.Duration) (string, error) {
+ expirationTime := time.Now().Add(tokenDuration)
+ return generateToken(userEmail, fmt.Sprintf(AccessTokenAudienceFmt, mode), expirationTime, []byte(secret))
+}
+
+// GenerateMFATempToken generates a temporary token for MFA.
+func GenerateMFATempToken(userEmail string, mode common.ReleaseMode, secret string, tokenDuration time.Duration) (string, error) {
+ expirationTime := time.Now().Add(tokenDuration)
+ return generateToken(userEmail, fmt.Sprintf(MFATempTokenAudienceFmt, mode), expirationTime, []byte(secret))
+}
+
+// generateToken creates a JWT token for web authentication.
+func generateToken(userEmail string, aud string, expirationTime time.Time, secret []byte) (string, error) {
+ claims := &claimsMessage{
+ Name: userEmail,
+ RegisteredClaims: jwt.RegisteredClaims{
+ Audience: jwt.ClaimStrings{aud},
+ ExpiresAt: jwt.NewNumericDate(expirationTime),
+ IssuedAt: jwt.NewNumericDate(time.Now()),
+ Issuer: issuer,
+ Subject: userEmail,
+ },
+ }
+
+ token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+ token.Header["kid"] = keyID
+
+ return token.SignedString(secret)
+}
+
+// GenerateOAuth2AccessToken generates an access token for OAuth2 clients.
+// The clientID is included in the token claims for audit purposes.
+func GenerateOAuth2AccessToken(userEmail, clientID, secret string, duration time.Duration) (string, error) {
+ expirationTime := time.Now().Add(duration)
+ return generateOAuth2Token(userEmail, clientID, OAuth2AccessTokenAudience, expirationTime, []byte(secret))
+}
+
+// generateOAuth2Token creates a JWT token with OAuth2-specific claims including client_id.
+func generateOAuth2Token(userEmail, clientID, aud string, expirationTime time.Time, secret []byte) (string, error) {
+ claims := &oauth2ClaimsMessage{
+ ClientID: clientID,
+ claimsMessage: claimsMessage{
+ Name: userEmail,
+ RegisteredClaims: jwt.RegisteredClaims{
+ Audience: jwt.ClaimStrings{aud},
+ ExpiresAt: jwt.NewNumericDate(expirationTime),
+ IssuedAt: jwt.NewNumericDate(time.Now()),
+ Issuer: issuer,
+ Subject: userEmail,
+ },
+ },
+ }
+
+ token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+ token.Header["kid"] = keyID
+
+ return token.SignedString(secret)
+}
diff --git a/backend/api/oauth2/oauth2.go b/backend/api/oauth2/oauth2.go
index 909fc058a5..2b16fd6e16 100644
--- a/backend/api/oauth2/oauth2.go
+++ b/backend/api/oauth2/oauth2.go
@@ -16,6 +16,7 @@ import (
"github.com/labstack/echo/v4"
"golang.org/x/crypto/bcrypt"
+ "github.com/bytebase/bytebase/backend/api/auth"
"github.com/bytebase/bytebase/backend/common"
"github.com/bytebase/bytebase/backend/common/log"
"github.com/bytebase/bytebase/backend/component/config"
@@ -94,44 +95,37 @@ func (s *Service) handleGetClient(c echo.Context) error {
})
}
-func generateRandomString(length int) (string, error) {
- bytes := make([]byte, length)
- if _, err := rand.Read(bytes); err != nil {
- return "", err
- }
- return base64.RawURLEncoding.EncodeToString(bytes), nil
-}
-
func generateClientID() (string, error) {
- random, err := generateRandomString(24)
- if err != nil {
+ // Use 24 bytes for client ID (shorter than refresh tokens)
+ bytes := make([]byte, 24)
+ if _, err := rand.Read(bytes); err != nil {
return "", err
}
- return clientIDPrefix + random, nil
+ return clientIDPrefix + base64.RawURLEncoding.EncodeToString(bytes), nil
}
func generateClientSecret() (string, error) {
- random, err := generateRandomString(32)
+ token, err := auth.GenerateOpaqueToken()
if err != nil {
return "", err
}
- return clientSecretPrefix + random, nil
+ return clientSecretPrefix + token, nil
}
func generateAuthCode() (string, error) {
- random, err := generateRandomString(32)
+ token, err := auth.GenerateOpaqueToken()
if err != nil {
return "", err
}
- return authCodePrefix + random, nil
+ return authCodePrefix + token, nil
}
func generateRefreshToken() (string, error) {
- random, err := generateRandomString(32)
+ token, err := auth.GenerateOpaqueToken()
if err != nil {
return "", err
}
- return refreshTokenPrefix + random, nil
+ return refreshTokenPrefix + token, nil
}
func hashSecret(secret string) (string, error) {
@@ -146,11 +140,6 @@ func verifySecret(hash, secret string) bool {
return bcrypt.CompareHashAndPassword([]byte(hash), []byte(secret)) == nil
}
-func hashToken(token string) string {
- hash := sha256.Sum256([]byte(token))
- return base64.RawURLEncoding.EncodeToString(hash[:])
-}
-
func verifyPKCE(codeVerifier, codeChallenge, method string) bool {
if method != "S256" {
return false
diff --git a/backend/api/oauth2/revoke.go b/backend/api/oauth2/revoke.go
index 7a9cd33a9c..5b554699dc 100644
--- a/backend/api/oauth2/revoke.go
+++ b/backend/api/oauth2/revoke.go
@@ -8,6 +8,7 @@ import (
"github.com/labstack/echo/v4"
+ "github.com/bytebase/bytebase/backend/api/auth"
"github.com/bytebase/bytebase/backend/common/log"
)
@@ -55,7 +56,7 @@ func (s *Service) handleRevoke(c echo.Context) error {
// Try to revoke as refresh token
// RFC 7009 says to return 200 even if token is invalid, but we log errors for debugging
- tokenHash := hashToken(req.Token)
+ tokenHash := auth.HashToken(req.Token)
if err := s.store.DeleteOAuth2RefreshToken(ctx, tokenHash); err != nil {
slog.Warn("failed to delete OAuth2 refresh token during revocation", log.BBError(err))
}
diff --git a/backend/api/oauth2/token.go b/backend/api/oauth2/token.go
index 3a315c6e73..dc8d795aec 100644
--- a/backend/api/oauth2/token.go
+++ b/backend/api/oauth2/token.go
@@ -8,7 +8,6 @@ import (
"strings"
"time"
- "github.com/golang-jwt/jwt/v5"
"github.com/labstack/echo/v4"
"github.com/bytebase/bytebase/backend/api/auth"
@@ -167,7 +166,7 @@ func (s *Service) handleRefreshTokenGrant(c echo.Context, client *store.OAuth2Cl
return oauth2Error(c, http.StatusBadRequest, "invalid_request", "refresh_token is required")
}
- tokenHash := hashToken(req.RefreshToken)
+ tokenHash := auth.HashToken(req.RefreshToken)
refreshToken, err := s.store.GetOAuth2RefreshToken(ctx, tokenHash)
if err != nil {
return oauth2Error(c, http.StatusInternalServerError, "server_error", "failed to lookup refresh token")
@@ -210,22 +209,13 @@ func (s *Service) issueTokens(c echo.Context, client *store.OAuth2ClientMessage,
ctx := c.Request().Context()
// Generate access token (JWT)
- now := time.Now()
- claims := jwt.MapClaims{
- "iss": "bytebase",
- "sub": userEmail,
- "aud": auth.OAuth2AccessTokenAudience,
- "exp": now.Add(accessTokenExpiry).Unix(),
- "iat": now.Unix(),
- "client_id": client.ClientID,
- }
- token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
- token.Header["kid"] = "v1"
- accessToken, err := token.SignedString([]byte(s.secret))
+ accessToken, err := auth.GenerateOAuth2AccessToken(userEmail, client.ClientID, s.secret, accessTokenExpiry)
if err != nil {
return oauth2Error(c, http.StatusInternalServerError, "server_error", "failed to generate access token")
}
+ now := time.Now()
+
// Generate refresh token if allowed
var refreshTokenStr string
if slices.Contains(client.Config.GrantTypes, "refresh_token") {
@@ -236,7 +226,7 @@ func (s *Service) issueTokens(c echo.Context, client *store.OAuth2ClientMessage,
// Store refresh token
if _, err := s.store.CreateOAuth2RefreshToken(ctx, &store.OAuth2RefreshTokenMessage{
- TokenHash: hashToken(refreshTokenStr),
+ TokenHash: auth.HashToken(refreshTokenStr),
ClientID: client.ClientID,
UserEmail: userEmail,
ExpiresAt: now.Add(refreshTokenExpiry),