0
0
package remote
import (
"context"
"crypto/tls"
"errors"
"fmt"
"maps"
"net/http"
"strings"
"sync"
"time"
commonv1 "github.com/johnandersen777/socialweb-computer-kcp/api/common/v1alpha1"
pdsv1alpha1 "github.com/johnandersen777/socialweb-computer-kcp/api/pds/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/internal/atproto/pdsclient"
"github.com/johnandersen777/socialweb-computer-kcp/internal/atproto/xrpc"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/lease"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/strs"
)
var ErrSessionExpired = errors.New("remote: the RemotePDS session expired and its refresh token is refused")
var (
accessKeys = []string{"accessJwt", "accessToken", "access_token", "jwt", "token", "value"}
refreshKeys = []string{"refreshJwt", "refreshToken", "refresh_token"}
)
const refreshTimeout = 30 * time.Second
type SecretWriter func(ctx context.Context, ref commonv1.SecretRef, data map[string]any) error
type SessionConfig struct {
Auth pdsv1alpha1.RemotePDSAuth
URL string
TLS *tls.Config
Read Secrets
Write SecretWriter
}
type Session struct {
cfg SessionConfig
access *commonv1.SecretRef
refresh *commonv1.SecretRef
tokens *lease.Source[string]
auth xrpc.Auth
mu sync.Mutex
rejected string
dead string
}
var (
_ pdsclient.TokenSource = (*Session)(nil)
_ pdsclient.TokenRefresher = (*Session)(nil)
)
func NewSession(ctx context.Context, cfg SessionConfig) (*Session, error) {
access, refresh, keyRef := usable(cfg.Auth.AccessTokenRef), usable(cfg.Auth.RefreshTokenRef), usable(cfg.Auth.DPoPKeyRef)
if access == nil {
access = refresh
}
if access == nil && keyRef == nil {
return nil, nil
}
if access == nil {
return nil, errors.New("remote: the RemotePDS auth names a dpop key but no session token ref")
}
if cfg.Read == nil {
return nil, errors.New("remote: the RemotePDS auth names refs but no secret reader is configured")
}
s := &Session{cfg: cfg, access: access, refresh: refresh}
s.tokens = lease.New(s.fetch)
data, err := cfg.Read(ctx, *access)
if err != nil {
return nil, fmt.Errorf("remote: reading the session ref %s: %w", refName(*access), err)
}
var dpop pdsclient.DPoPSource
if _, ok := data["session"]; ok {
return nil, errors.New("remote: an atproto OAuth session belongs to its MarketIdentity; name the MarketIdentity in the RemoteRepo credentialsRef, not in RemotePDS spec.auth")
}
if keyRef != nil {
keyData, err := cfg.Read(ctx, *keyRef)
if err != nil {
return nil, fmt.Errorf("remote: resolving the dpop key ref %s: %w", refName(*keyRef), err)
}
if dpop, err = pdsclient.DPoPSourceFromData(keyData); err != nil {
return nil, err
}
}
s.auth = pdsclient.TokenAuth(s, dpop)
return s, nil
}
func (s *Session) Auth() xrpc.Auth {
if s == nil {
return nil
}
return s.auth
}
func (s *Session) Check(ctx context.Context) error {
_, err := s.AccessToken(ctx)
return err
}
func (s *Session) AccessToken(ctx context.Context) (string, error) {
return s.tokens.Get(ctx)
}
func (s *Session) RefreshAccessToken(ctx context.Context) (string, error) {
if held, _, ok := s.tokens.Peek(); ok {
s.mu.Lock()
s.rejected = held
s.mu.Unlock()
}
s.tokens.Invalidate()
return s.tokens.Get(ctx)
}
func (s *Session) fetch(ctx context.Context) (string, time.Time, error) {
s.mu.Lock()
rejected := s.rejected
s.mu.Unlock()
token, err := s.fetchBearer(ctx, rejected)
if err != nil {
return "", time.Time{}, err
}
s.mu.Lock()
s.rejected = ""
s.mu.Unlock()
expires, ok := pdsclient.TokenExpiry(token)
if !ok {
return token, time.Time{}, nil
}
return token, expires.Add(-pdsclient.TokenExpirySkew), nil
}
func (s *Session) fetchBearer(ctx context.Context, rejected string) (string, error) {
data, err := s.cfg.Read(ctx, *s.access)
if err != nil {
return "", fmt.Errorf("remote: resolving the token ref %s: %w", refName(*s.access), err)
}
access := lookup(data, s.access.Key, accessKeys)
if access != "" && access != rejected && pdsclient.TokenLive(access) {
return access, nil
}
if s.refresh == nil {
return "", fmt.Errorf("%w: the RemotePDS session holds no live token and names no refreshTokenRef", pdsclient.ErrAuthenticationRequired)
}
refreshData := data
if !sameRef(*s.access, *s.refresh) {
if refreshData, err = s.cfg.Read(ctx, *s.refresh); err != nil {
return "", fmt.Errorf("remote: resolving the refresh token ref %s: %w", refName(*s.refresh), err)
}
}
refresh := lookup(refreshData, s.refresh.Key, refreshKeys)
if refresh == "" {
return "", fmt.Errorf("%w: the RemotePDS session holds no live token and no refresh token", pdsclient.ErrAuthenticationRequired)
}
if s.isDead(refresh) {
return "", ErrSessionExpired
}
client, err := pdsclient.NewRemote(pdsclient.RemoteConfig{BaseURL: s.cfg.URL, TLS: s.cfg.TLS, Timeout: refreshTimeout})
if err != nil {
return "", err
}
session, err := client.RefreshSession(ctx, refresh)
if err != nil {
if refused(err) {
s.markDead(refresh)
return "", fmt.Errorf("%w: %v", ErrSessionExpired, err)
}
return "", fmt.Errorf("remote: refreshing the RemotePDS session: %w", err)
}
if s.cfg.Write == nil {
return "", errors.New("remote: the refreshed RemotePDS session has no secret writer")
}
if err := s.cfg.Write(ctx, *s.refresh, withTokens(refreshData, s.refresh.Key, refreshKeys[0], session)); err != nil {
return "", fmt.Errorf("remote: storing the refreshed RemotePDS session: %w", err)
}
if !sameRef(*s.access, *s.refresh) {
if err := s.cfg.Write(ctx, *s.access, withTokens(data, s.access.Key, accessKeys[0], session)); err != nil {
return "", fmt.Errorf("remote: storing the refreshed RemotePDS access token: %w", err)
}
}
return session.AccessJWT, nil
}
func (s *Session) isDead(refresh string) bool {
s.mu.Lock()
defer s.mu.Unlock()
return refresh != "" && s.dead == refresh
}
func (s *Session) markDead(refresh string) {
s.mu.Lock()
s.dead = refresh
s.mu.Unlock()
}
func refused(err error) bool {
var failure *pdsclient.XRPCError
if !errors.As(err, &failure) {
return false
}
switch failure.Code {
case "ExpiredToken", "InvalidToken", "AuthenticationRequired", "AccountTakedown":
return true
}
return failure.StatusCode == http.StatusUnauthorized
}
func withTokens(data map[string]any, key, primary string, session pdsclient.Session) map[string]any {
out := maps.Clone(data)
if out == nil {
out = map[string]any{}
}
out["accessJwt"] = session.AccessJWT
out["refreshJwt"] = session.RefreshJWT
out["access_token"] = session.AccessJWT
out["refresh_token"] = session.RefreshJWT
if key = strings.TrimSpace(key); key != "" {
if primary == refreshKeys[0] {
out[key] = session.RefreshJWT
} else {
out[key] = session.AccessJWT
}
}
return out
}
func lookup(data map[string]any, key string, keys []string) string {
if key = strings.TrimSpace(key); key != "" {
keys = []string{key}
}
return strings.TrimSpace(strs.Lookup(data, keys...))
}
func sameRef(a, b commonv1.SecretRef) bool {
vault := func(r commonv1.SecretRef) string {
if r.Vault == nil {
return ""
}
return r.Vault.String()
}
return vault(a) == vault(b) && refName(a) == refName(b)
}
func usable(ref *commonv1.SecretRef) *commonv1.SecretRef {
if ref == nil || strings.Trim(strings.TrimSpace(ref.Path), "/") == "" {
return nil
}
return ref
}
func refName(ref commonv1.SecretRef) string {
return strings.Trim(strings.TrimSpace(ref.Mount)+"/"+strings.TrimSpace(ref.Path), "/")
}