359 lines
9.3 KiB
Go
359 lines
9.3 KiB
Go
package services
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"net/url"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/dusiburg/kotosoft-id/internal/models"
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
type OAuthSession struct {
|
|
ClientID string `json:"client_id"`
|
|
ClientName string `json:"client_name"`
|
|
RedirectURI string `json:"redirect_uri"`
|
|
Scopes []string `json:"scopes"`
|
|
State string `json:"state"`
|
|
CodeChallenge string `json:"code_challenge"`
|
|
CodeChallengeMethod string `json:"code_challenge_method"`
|
|
UserID uuid.UUID `json:"user_id,omitempty"`
|
|
}
|
|
|
|
type TokenPair struct {
|
|
AccessToken string `json:"access_token"`
|
|
RefreshToken string `json:"refresh_token,omitempty"`
|
|
TokenType string `json:"token_type"`
|
|
ExpiresIn int64 `json:"expires_in"`
|
|
Scope string `json:"scope,omitempty"`
|
|
User *models.User `json:"user,omitempty"`
|
|
}
|
|
|
|
func (s *Service) CreateOAuthSession(
|
|
ctx context.Context,
|
|
clientID, redirectURI, scope, state, codeChallenge, codeChallengeMethod string,
|
|
) (string, error) {
|
|
if clientID == "" || redirectURI == "" || codeChallenge == "" {
|
|
return "", ErrInvalidRequest
|
|
}
|
|
if codeChallengeMethod != "" && codeChallengeMethod != "S256" {
|
|
return "", ErrInvalidRequest
|
|
}
|
|
|
|
client, err := s.oauth.GetOAuthClientByClientID(ctx, clientID)
|
|
if err != nil {
|
|
return "", ErrUnauthorizedClient
|
|
}
|
|
if !redirectURIMatches(client.RedirectURIs, redirectURI) {
|
|
return "", ErrInvalidRequest
|
|
}
|
|
|
|
scopes := parseScopes(scope)
|
|
if len(scopes) > 0 && !ScopesAllowed(client.Scopes, scopes) {
|
|
return "", ErrInvalidRequest
|
|
}
|
|
|
|
token, err := newOpaqueToken(24)
|
|
if err != nil {
|
|
return "", models.ErrInternal
|
|
}
|
|
|
|
sess := OAuthSession{
|
|
ClientID: client.ClientID,
|
|
ClientName: client.Name,
|
|
RedirectURI: redirectURI,
|
|
Scopes: scopes,
|
|
State: state,
|
|
CodeChallenge: codeChallenge,
|
|
CodeChallengeMethod: "S256",
|
|
}
|
|
|
|
if err := s.saveSession(ctx, token, &sess); err != nil {
|
|
return "", models.ErrInternal
|
|
}
|
|
return token, nil
|
|
}
|
|
|
|
func (s *Service) GetOAuthSession(ctx context.Context, token string) (*OAuthSession, error) {
|
|
data, err := s.redis.Get(ctx, oauthSessionPrefix+token).Bytes()
|
|
if err != nil {
|
|
return nil, ErrInvalidGrant
|
|
}
|
|
var sess OAuthSession
|
|
if err := json.Unmarshal(data, &sess); err != nil {
|
|
return nil, ErrInvalidGrant
|
|
}
|
|
return &sess, nil
|
|
}
|
|
|
|
func (s *Service) saveSession(ctx context.Context, token string, sess *OAuthSession) error {
|
|
data, _ := json.Marshal(sess)
|
|
return s.redis.Set(ctx, oauthSessionPrefix+token, data, oauthSessionTTL).Err()
|
|
}
|
|
|
|
func (s *Service) SessionLogin(ctx context.Context, token, email, password string) (string, error) {
|
|
sess, err := s.GetOAuthSession(ctx, token)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
user, err := s.users.GetUserByEmail(ctx, email)
|
|
if err != nil || bcryptCompare(user.PasswordHash, password) != nil {
|
|
return "", models.ErrUnauthorized
|
|
}
|
|
|
|
sess.UserID = user.ID
|
|
if err := s.saveSession(ctx, token, sess); err != nil {
|
|
return "", models.ErrInternal
|
|
}
|
|
|
|
client, err := s.oauth.GetOAuthClientByClientID(ctx, sess.ClientID)
|
|
if err != nil {
|
|
return "", ErrInvalidClient
|
|
}
|
|
|
|
if client.Trusted {
|
|
return s.SessionApprove(ctx, token)
|
|
}
|
|
|
|
hasUserConsents := s.HasUserConsent(ctx, sess.UserID, client.ID, sess.Scopes)
|
|
if hasUserConsents {
|
|
return s.SessionApprove(ctx, token)
|
|
}
|
|
|
|
return "", nil
|
|
}
|
|
|
|
func (s *Service) SessionAttach(ctx context.Context, sessionToken, accessToken string) (string, error) {
|
|
info, err := s.ValidateAccessToken(ctx, accessToken)
|
|
if err != nil {
|
|
return "", models.ErrUnauthorized
|
|
}
|
|
|
|
sess, err := s.GetOAuthSession(ctx, sessionToken)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
sess.UserID = info.UserID
|
|
if err := s.saveSession(ctx, sessionToken, sess); err != nil {
|
|
return "", models.ErrInternal
|
|
}
|
|
|
|
client, err := s.oauth.GetOAuthClientByClientID(ctx, sess.ClientID)
|
|
if err != nil {
|
|
return "", ErrInvalidClient
|
|
}
|
|
if client.Trusted {
|
|
return s.SessionApprove(ctx, sessionToken)
|
|
}
|
|
|
|
hasUserConsents := s.HasUserConsent(ctx, sess.UserID, client.ID, sess.Scopes)
|
|
if hasUserConsents {
|
|
return s.SessionApprove(ctx, sessionToken)
|
|
}
|
|
|
|
return "", nil
|
|
}
|
|
|
|
func (s *Service) SessionApprove(ctx context.Context, token string) (string, error) {
|
|
sess, err := s.GetOAuthSession(ctx, token)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if sess.UserID == uuid.Nil {
|
|
return "", ErrInvalidGrant
|
|
}
|
|
|
|
client, err := s.oauth.GetOAuthClientByClientID(ctx, sess.ClientID)
|
|
if err != nil {
|
|
return "", ErrInvalidClient
|
|
}
|
|
|
|
code, err := s.createAuthCode(ctx, sess.UserID, client.ID, sess.RedirectURI, sess.Scopes, sess.CodeChallenge)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
_ = s.redis.Del(ctx, oauthSessionPrefix+token)
|
|
s.oauth.RecordUserConsent(ctx, sess.UserID, client.ID, sess.Scopes)
|
|
|
|
redirectURL, _ := url.Parse(sess.RedirectURI)
|
|
q := redirectURL.Query()
|
|
q.Set("code", code)
|
|
if sess.State != "" {
|
|
q.Set("state", sess.State)
|
|
}
|
|
redirectURL.RawQuery = q.Encode()
|
|
|
|
return redirectURL.String(), nil
|
|
}
|
|
|
|
func (s *Service) ExchangeCode(ctx context.Context, auth ClientAuth, code, redirectURI, codeVerifier string) (*TokenPair, error) {
|
|
if auth.ClientID == "" || code == "" || redirectURI == "" || codeVerifier == "" {
|
|
return nil, ErrInvalidRequest
|
|
}
|
|
|
|
client, err := s.AuthenticateClient(ctx, auth)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
row, err := s.oauth.GetAuthorizationCodeByHash(ctx, sha256Hex(code))
|
|
if err != nil || row.ConsumedAt != nil || time.Now().After(row.ExpiresAt) {
|
|
return nil, ErrInvalidGrant
|
|
}
|
|
if row.ClientID != client.ID || row.RedirectURI != redirectURI {
|
|
return nil, ErrInvalidGrant
|
|
}
|
|
if !pkceVerifyS256(codeVerifier, row.CodeChallenge) {
|
|
return nil, ErrInvalidGrant
|
|
}
|
|
|
|
if err := s.oauth.ConsumeAuthorizationCodeByID(ctx, row.ID); err != nil {
|
|
return nil, models.ErrInternal
|
|
}
|
|
|
|
user, err := s.users.GetUserByID(ctx, row.UserID)
|
|
if err != nil {
|
|
return nil, models.ErrInternal
|
|
}
|
|
|
|
s.oauth.UpdateConsentLastUsed(ctx, row.UserID, client.ID)
|
|
|
|
return s.issuePair(ctx, user, client.ID, scopesFromJSON(row.Scopes))
|
|
}
|
|
|
|
func (s *Service) ExchangeRefreshToken(ctx context.Context, auth ClientAuth, rawToken string) (*TokenPair, error) {
|
|
if auth.ClientID == "" || rawToken == "" {
|
|
return nil, ErrInvalidRequest
|
|
}
|
|
|
|
client, err := s.AuthenticateClient(ctx, auth)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
row, err := s.oauth.GetRefreshTokenByHash(ctx, sha256Hex(rawToken))
|
|
if err != nil || time.Now().After(row.ExpiresAt) || row.ClientID != client.ID {
|
|
return nil, ErrInvalidGrant
|
|
}
|
|
|
|
if err := s.oauth.DeleteRefreshTokenByID(ctx, row.ID); err != nil {
|
|
return nil, models.ErrInternal
|
|
}
|
|
|
|
s.oauth.UpdateConsentLastUsed(ctx, row.UserID, client.ID)
|
|
|
|
user, err := s.users.GetUserByID(ctx, row.UserID)
|
|
if err != nil {
|
|
return nil, models.ErrInternal
|
|
}
|
|
|
|
scopes := scopesFromJSON(row.Scopes)
|
|
if !ScopesAllowed(client.Scopes, scopes) {
|
|
return nil, ErrInvalidGrant
|
|
}
|
|
|
|
return s.issuePair(ctx, user, client.ID, scopes)
|
|
}
|
|
|
|
func (s *Service) RevokeToken(ctx context.Context, auth ClientAuth, rawToken string) error {
|
|
client, err := s.AuthenticateClient(ctx, auth)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
row, err := s.oauth.GetRefreshTokenByHash(ctx, sha256Hex(rawToken))
|
|
if err != nil || row.ClientID != client.ID {
|
|
return nil
|
|
}
|
|
|
|
_ = s.oauth.DeleteRefreshTokenByID(ctx, row.ID)
|
|
return nil
|
|
}
|
|
|
|
func (s *Service) createAuthCode(
|
|
ctx context.Context,
|
|
userID, clientID uuid.UUID,
|
|
redirectURI string,
|
|
scopes []string,
|
|
codeChallenge string,
|
|
) (string, error) {
|
|
rawCode, err := newOpaqueToken(32)
|
|
if err != nil {
|
|
return "", models.ErrInternal
|
|
}
|
|
|
|
scopeJSON, _ := json.Marshal(scopes)
|
|
now := time.Now()
|
|
|
|
_, err = s.oauth.CreateAuthorizationCode(ctx, models.AuthorizationCodeRow{
|
|
CodeHash: sha256Hex(rawCode),
|
|
UserID: userID,
|
|
ClientID: clientID,
|
|
RedirectURI: redirectURI,
|
|
Scopes: scopeJSON,
|
|
CodeChallenge: codeChallenge,
|
|
CodeChallengeMethod: "S256",
|
|
ExpiresAt: now.Add(5 * time.Minute),
|
|
CreatedAt: now,
|
|
})
|
|
if err != nil {
|
|
return "", models.ErrInternal
|
|
}
|
|
|
|
return rawCode, nil
|
|
}
|
|
|
|
func (s *Service) issuePair(ctx context.Context, user *models.User, clientID uuid.UUID, scopes []string) (*TokenPair, error) {
|
|
accessToken, err := newOpaqueToken(32)
|
|
if err != nil {
|
|
return nil, models.ErrInternal
|
|
}
|
|
rawRefresh, err := newOpaqueToken(32)
|
|
if err != nil {
|
|
return nil, models.ErrInternal
|
|
}
|
|
|
|
scopeJSON, _ := json.Marshal(scopes)
|
|
now := time.Now()
|
|
|
|
accessData := struct {
|
|
UserID uuid.UUID `json:"user_id"`
|
|
Scopes []string `json:"scopes"`
|
|
ClientID uuid.UUID `json:"client_id"`
|
|
}{
|
|
UserID: user.ID,
|
|
Scopes: scopes,
|
|
ClientID: clientID,
|
|
}
|
|
data, _ := json.Marshal(accessData)
|
|
if err := s.redis.Set(ctx, accessTokenPrefix+accessToken, data, s.tokens.AccessTTL).Err(); err != nil {
|
|
return nil, models.ErrInternal
|
|
}
|
|
|
|
_, err = s.oauth.CreateRefreshToken(ctx, models.RefreshTokenRow{
|
|
TokenHash: sha256Hex(rawRefresh),
|
|
UserID: user.ID,
|
|
ClientID: clientID,
|
|
Scopes: scopeJSON,
|
|
ExpiresAt: now.Add(s.tokens.RefreshTTL),
|
|
CreatedAt: now,
|
|
})
|
|
if err != nil {
|
|
return nil, models.ErrInternal
|
|
}
|
|
|
|
return &TokenPair{
|
|
AccessToken: accessToken,
|
|
RefreshToken: rawRefresh,
|
|
TokenType: "Bearer",
|
|
ExpiresIn: int64(s.tokens.AccessTTL.Seconds()),
|
|
Scope: strings.Join(scopes, " "),
|
|
User: user,
|
|
}, nil
|
|
}
|