commit 1f0174c10525a94c6a895c9a0b3a8cf7654e24bf · bretton.dev/coves

-210

internal/api/handlers/oauth/callback.go

···

       1
       1
       -
       package oauth

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"Coves/internal/atproto/oauth"

     

       5
       5
       -
       	"log"

     

       6
       6
       -
       	"net/http"

     

       7
       7
       -
       	"os"

     

       8
       8
       -
       	"strings"

     

       9
       9
       -
       	"time"

     

       10
       10
       -
       

     

       11
       11
       -
       	oauthCore "Coves/internal/core/oauth"

     

       12
       12
       -
       )

     

       13
       13
       -
       

     

       14
       14
       -
       const (

     

       15
       15
       -
       	sessionName = "coves_session"

     

       16
       16
       -
       	sessionDID  = "did"

     

       17
       17
       -
       )

     

       18
       18
       -
       

     

       19
       19
       -
       // CallbackHandler handles OAuth callback

     

       20
       20
       -
       type CallbackHandler struct {

     

       21
       21
       -
       	sessionStore oauthCore.SessionStore

     

       22
       22
       -
       }

     

       23
       23
       -
       

     

       24
       24
       -
       // NewCallbackHandler creates a new callback handler

     

       25
       25
       -
       func NewCallbackHandler(sessionStore oauthCore.SessionStore) *CallbackHandler {

     

       26
       26
       -
       	return &CallbackHandler{

     

       27
       27
       -
       		sessionStore: sessionStore,

     

       28
       28
       -
       	}

     

       29
       29
       -
       }

     

       30
       30
       -
       

     

       31
       31
       -
       // HandleCallback processes the OAuth callback

     

       32
       32
       -
       // GET /oauth/callback?code=...&state=...&iss=...

     

       33
       33
       -
       func (h *CallbackHandler) HandleCallback(w http.ResponseWriter, r *http.Request) {

     

       34
       34
       -
       	// Extract query parameters

     

       35
       35
       -
       	code := r.URL.Query().Get("code")

     

       36
       36
       -
       	state := r.URL.Query().Get("state")

     

       37
       37
       -
       	iss := r.URL.Query().Get("iss")

     

       38
       38
       -
       	errorParam := r.URL.Query().Get("error")

     

       39
       39
       -
       	errorDesc := r.URL.Query().Get("error_description")

     

       40
       40
       -
       

     

       41
       41
       -
       	// Check for authorization errors

     

       42
       42
       -
       	if errorParam != "" {

     

       43
       43
       -
       		log.Printf("OAuth error: %s - %s", errorParam, errorDesc)

     

       44
       44
       -
       		http.Error(w, "Authorization failed", http.StatusBadRequest)

     

       45
       45
       -
       		return

     

       46
       46
       -
       	}

     

       47
       47
       -
       

     

       48
       48
       -
       	// Validate required parameters

     

       49
       49
       -
       	if code == "" || state == "" || iss == "" {

     

       50
       50
       -
       		http.Error(w, "Missing required OAuth parameters", http.StatusBadRequest)

     

       51
       51
       -
       		return

     

       52
       52
       -
       	}

     

       53
       53
       -
       

     

       54
       54
       -
       	// Retrieve and delete OAuth request atomically to prevent replay attacks

     

       55
       55
       -
       	oauthReq, err := h.sessionStore.GetAndDeleteRequest(state)

     

       56
       56
       -
       	if err != nil {

     

       57
       57
       -
       		log.Printf("Failed to retrieve OAuth request for state %s: %v", state, err)

     

       58
       58
       -
       		http.Error(w, "Invalid or expired authorization request", http.StatusBadRequest)

     

       59
       59
       -
       		return

     

       60
       60
       -
       	}

     

       61
       61
       -
       

     

       62
       62
       -
       	// Verify issuer matches

     

       63
       63
       -
       	if iss != oauthReq.AuthServerIss {

     

       64
       64
       -
       		log.Printf("Issuer mismatch: expected %s, got %s", oauthReq.AuthServerIss, iss)

     

       65
       65
       -
       		http.Error(w, "Authorization server mismatch", http.StatusBadRequest)

     

       66
       66
       -
       		return

     

       67
       67
       -
       	}

     

       68
       68
       -
       

     

       69
       69
       -
       	// Get OAuth client configuration (supports base64 encoding)

     

       70
       70
       -
       	privateJWK, err := GetEnvBase64OrPlain("OAUTH_PRIVATE_JWK")

     

       71
       71
       -
       	if err != nil {

     

       72
       72
       -
       		log.Printf("Failed to load OAuth private key: %v", err)

     

       73
       73
       -
       		http.Error(w, "OAuth configuration error", http.StatusInternalServerError)

     

       74
       74
       -
       		return

     

       75
       75
       -
       	}

     

       76
       76
       -
       	if privateJWK == "" {

     

       77
       77
       -
       		http.Error(w, "OAuth not configured", http.StatusInternalServerError)

     

       78
       78
       -
       		return

     

       79
       79
       -
       	}

     

       80
       80
       -
       

     

       81
       81
       -
       	privateKey, err := oauth.ParseJWKFromJSON([]byte(privateJWK))

     

       82
       82
       -
       	if err != nil {

     

       83
       83
       -
       		log.Printf("Failed to parse OAuth private key: %v", err)

     

       84
       84
       -
       		http.Error(w, "OAuth configuration error", http.StatusInternalServerError)

     

       85
       85
       -
       		return

     

       86
       86
       -
       	}

     

       87
       87
       -
       

     

       88
       88
       -
       	appviewURL := getAppViewURL()

     

       89
       89
       -
       	clientID := getClientID(appviewURL)

     

       90
       90
       -
       	redirectURI := appviewURL + "/oauth/callback"

     

       91
       91
       -
       

     

       92
       92
       -
       	// Create OAuth client

     

       93
       93
       -
       	client := oauth.NewClient(clientID, privateKey, redirectURI)

     

       94
       94
       -
       

     

       95
       95
       -
       	// Parse DPoP key from OAuth request

     

       96
       96
       -
       	dpopKey, err := oauth.ParseJWKFromJSON([]byte(oauthReq.DPoPPrivateJWK))

     

       97
       97
       -
       	if err != nil {

     

       98
       98
       -
       		log.Printf("Failed to parse DPoP key: %v", err)

     

       99
       99
       -
       		http.Error(w, "Failed to restore session key", http.StatusInternalServerError)

     

       100
       100
       -
       		return

     

       101
       101
       -
       	}

     

       102
       102
       -
       

     

       103
       103
       -
       	// Exchange authorization code for tokens

     

       104
       104
       -
       	tokenResp, err := client.InitialTokenRequest(

     

       105
       105
       -
       		r.Context(),

     

       106
       106
       -
       		code,

     

       107
       107
       -
       		oauthReq.AuthServerIss,

     

       108
       108
       -
       		oauthReq.PKCEVerifier,

     

       109
       109
       -
       		oauthReq.DPoPAuthServerNonce,

     

       110
       110
       -
       		dpopKey,

     

       111
       111
       -
       	)

     

       112
       112
       -
       	if err != nil {

     

       113
       113
       -
       		log.Printf("Failed to exchange code for tokens: %v", err)

     

       114
       114
       -
       		http.Error(w, "Failed to obtain access tokens", http.StatusInternalServerError)

     

       115
       115
       -
       		return

     

       116
       116
       -
       	}

     

       117
       117
       -
       

     

       118
       118
       -
       	// Verify token type is DPoP

     

       119
       119
       -
       	if tokenResp.TokenType != "DPoP" {

     

       120
       120
       -
       		log.Printf("Expected DPoP token type, got: %s", tokenResp.TokenType)

     

       121
       121
       -
       		http.Error(w, "Invalid token type", http.StatusInternalServerError)

     

       122
       122
       -
       		return

     

       123
       123
       -
       	}

     

       124
       124
       -
       

     

       125
       125
       -
       	// Verify subject (DID) matches

     

       126
       126
       -
       	if tokenResp.Sub != oauthReq.DID {

     

       127
       127
       -
       		log.Printf("DID mismatch: expected %s, got %s", oauthReq.DID, tokenResp.Sub)

     

       128
       128
       -
       		http.Error(w, "Identity verification failed", http.StatusBadRequest)

     

       129
       129
       -
       		return

     

       130
       130
       -
       	}

     

       131
       131
       -
       

     

       132
       132
       -
       	// Calculate token expiration

     

       133
       133
       -
       	expiresAt := time.Now().Add(time.Duration(tokenResp.ExpiresIn) * time.Second)

     

       134
       134
       -
       

     

       135
       135
       -
       	// Serialize DPoP key for storage

     

       136
       136
       -
       	dpopKeyJSON, err := oauth.JWKToJSON(dpopKey)

     

       137
       137
       -
       	if err != nil {

     

       138
       138
       -
       		log.Printf("Failed to serialize DPoP key: %v", err)

     

       139
       139
       -
       		http.Error(w, "Failed to store session", http.StatusInternalServerError)

     

       140
       140
       -
       		return

     

       141
       141
       -
       	}

     

       142
       142
       -
       

     

       143
       143
       -
       	// Save OAuth session to database

     

       144
       144
       -
       	session := &oauthCore.OAuthSession{

     

       145
       145
       -
       		DID:                 oauthReq.DID,

     

       146
       146
       -
       		Handle:              oauthReq.Handle,

     

       147
       147
       -
       		PDSURL:              oauthReq.PDSURL,

     

       148
       148
       -
       		AccessToken:         tokenResp.AccessToken,

     

       149
       149
       -
       		RefreshToken:        tokenResp.RefreshToken,

     

       150
       150
       -
       		DPoPPrivateJWK:      string(dpopKeyJSON),

     

       151
       151
       -
       		DPoPAuthServerNonce: tokenResp.DpopAuthserverNonce,

     

       152
       152
       -
       		DPoPPDSNonce:        "", // Will be populated on first PDS request

     

       153
       153
       -
       		AuthServerIss:       oauthReq.AuthServerIss,

     

       154
       154
       -
       		ExpiresAt:           expiresAt,

     

       155
       155
       -
       	}

     

       156
       156
       -
       

     

       157
       157
       -
       	if saveErr := h.sessionStore.SaveSession(session); saveErr != nil {

     

       158
       158
       -
       		log.Printf("Failed to save OAuth session: %v", saveErr)

     

       159
       159
       -
       		http.Error(w, "Failed to save session", http.StatusInternalServerError)

     

       160
       160
       -
       		return

     

       161
       161
       -
       	}

     

       162
       162
       -
       

     

       163
       163
       -
       	// Note: OAuth request already deleted atomically in GetAndDeleteRequest above

     

       164
       164
       -
       

     

       165
       165
       -
       	// Create HTTP session cookie

     

       166
       166
       -
       	cookieStore := GetCookieStore()

     

       167
       167
       -
       	httpSession, err := cookieStore.Get(r, sessionName)

     

       168
       168
       -
       	if err != nil {

     

       169
       169
       -
       		log.Printf("Failed to get cookie session: %v", err)

     

       170
       170
       -
       		// Try to create a new session anyway

     

       171
       171
       -
       		httpSession, err = cookieStore.New(r, sessionName)

     

       172
       172
       -
       		if err != nil {

     

       173
       173
       -
       			log.Printf("Failed to create new session: %v", err)

     

       174
       174
       -
       			http.Error(w, "Failed to create session", http.StatusInternalServerError)

     

       175
       175
       -
       			return

     

       176
       176
       -
       		}

     

       177
       177
       -
       	}

     

       178
       178
       -
       

     

       179
       179
       -
       	httpSession.Values[sessionDID] = oauthReq.DID

     

       180
       180
       -
       	httpSession.Options.MaxAge = SessionMaxAge

     

       181
       181
       -
       	httpSession.Options.HttpOnly = true

     

       182
       182
       -
       	httpSession.Options.Secure = !isDevelopment() // HTTPS only in production

     

       183
       183
       -
       	httpSession.Options.SameSite = http.SameSiteLaxMode

     

       184
       184
       -
       

     

       185
       185
       -
       	if err := httpSession.Save(r, w); err != nil {

     

       186
       186
       -
       		log.Printf("Failed to save HTTP session: %v", err)

     

       187
       187
       -
       		http.Error(w, "Failed to create session", http.StatusInternalServerError)

     

       188
       188
       -
       		return

     

       189
       189
       -
       	}

     

       190
       190
       -
       

     

       191
       191
       -
       	// Determine redirect URL

     

       192
       192
       -
       	returnURL := oauthReq.ReturnURL

     

       193
       193
       -
       	if returnURL == "" {

     

       194
       194
       -
       		returnURL = "/"

     

       195
       195
       -
       	}

     

       196
       196
       -
       

     

       197
       197
       -
       	// Redirect user back to application

     

       198
       198
       -
       	http.Redirect(w, r, returnURL, http.StatusFound)

     

       199
       199
       -
       }

     

       200
       200
       -
       

     

       201
       201
       -
       // isDevelopment checks if we're running in development mode

     

       202
       202
       -
       func isDevelopment() bool {

     

       203
       203
       -
       	// Explicitly check for localhost/127.0.0.1 on any port

     

       204
       204
       -
       	appviewURL := os.Getenv("APPVIEW_PUBLIC_URL")

     

       205
       205
       -
       	return appviewURL == "" ||

     

       206
       206
       -
       		strings.HasPrefix(appviewURL, "http://localhost:") ||

     

       207
       207
       -
       		strings.HasPrefix(appviewURL, "http://localhost/") ||

     

       208
       208
       -
       		strings.HasPrefix(appviewURL, "http://127.0.0.1:") ||

     

       209
       209
       -
       		strings.HasPrefix(appviewURL, "http://127.0.0.1/")

     

       210
       210
       -
       }

-17

internal/api/handlers/oauth/constants.go

···

       1
       1
       -
       package oauth

     

       2
       2
       -
       

     

       3
       3
       -
       import "time"

     

       4
       4
       -
       

     

       5
       5
       -
       const (

     

       6
       6
       -
       	// Session cookie configuration

     

       7
       7
       -
       	SessionMaxAge = 7 * 24 * 60 * 60 // 7 days in seconds

     

       8
       8
       -
       

     

       9
       9
       -
       	// Minimum security requirements

     

       10
       10
       -
       	MinCookieSecretLength = 32 // bytes

     

       11
       11
       -
       )

     

       12
       12
       -
       

     

       13
       13
       -
       // Time-based constants

     

       14
       14
       -
       var (

     

       15
       15
       -
       	TokenRefreshThreshold = 5 * time.Minute

     

       16
       16
       -
       	SessionDuration       = 7 * 24 * time.Hour

     

       17
       17
       -
       )

-37

internal/api/handlers/oauth/cookie.go

···

       1
       1
       -
       package oauth

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"fmt"

     

       5
       5
       -
       	"sync"

     

       6
       6
       -
       

     

       7
       7
       -
       	"github.com/gorilla/sessions"

     

       8
       8
       -
       )

     

       9
       9
       -
       

     

       10
       10
       -
       var (

     

       11
       11
       -
       	// Global singleton cookie store

     

       12
       12
       -
       	cookieStoreInstance *sessions.CookieStore

     

       13
       13
       -
       	cookieStoreOnce     sync.Once

     

       14
       14
       -
       	cookieStoreErr      error

     

       15
       15
       -
       )

     

       16
       16
       -
       

     

       17
       17
       -
       // InitCookieStore initializes the global cookie store singleton

     

       18
       18
       -
       // Must be called once at application startup before any handlers are created

     

       19
       19
       -
       func InitCookieStore(secret string) error {

     

       20
       20
       -
       	cookieStoreOnce.Do(func() {

     

       21
       21
       -
       		if len(secret) < MinCookieSecretLength {

     

       22
       22
       -
       			cookieStoreErr = fmt.Errorf("OAUTH_COOKIE_SECRET must be at least %d bytes for security", MinCookieSecretLength)

     

       23
       23
       -
       			return

     

       24
       24
       -
       		}

     

       25
       25
       -
       		cookieStoreInstance = sessions.NewCookieStore([]byte(secret))

     

       26
       26
       -
       	})

     

       27
       27
       -
       	return cookieStoreErr

     

       28
       28
       -
       }

     

       29
       29
       -
       

     

       30
       30
       -
       // GetCookieStore returns the global cookie store singleton

     

       31
       31
       -
       // Panics if InitCookieStore has not been called successfully

     

       32
       32
       -
       func GetCookieStore() *sessions.CookieStore {

     

       33
       33
       -
       	if cookieStoreInstance == nil {

     

       34
       34
       -
       		panic("cookie store not initialized - call InitCookieStore first")

     

       35
       35
       -
       	}

     

       36
       36
       -
       	return cookieStoreInstance

     

       37
       37
       -
       }

-39

internal/api/handlers/oauth/env.go

···

       1
       1
       -
       package oauth

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"encoding/base64"

     

       5
       5
       -
       	"fmt"

     

       6
       6
       -
       	"os"

     

       7
       7
       -
       	"strings"

     

       8
       8
       -
       )

     

       9
       9
       -
       

     

       10
       10
       -
       // GetEnvBase64OrPlain retrieves an environment variable that may be base64 encoded.

     

       11
       11
       -
       // If the value starts with "base64:", it will be decoded.

     

       12
       12
       -
       // Otherwise, it returns the plain value.

     

       13
       13
       -
       //

     

       14
       14
       -
       // This allows storing sensitive values like JWKs in base64 format to avoid

     

       15
       15
       -
       // shell escaping issues and newline handling problems.

     

       16
       16
       -
       //

     

       17
       17
       -
       // Example usage in .env:

     

       18
       18
       -
       //

     

       19
       19
       -
       //	OAUTH_PRIVATE_JWK={"alg":"ES256",...}  (plain JSON)

     

       20
       20
       -
       //	OAUTH_PRIVATE_JWK=base64:eyJhbGc... (base64 encoded)

     

       21
       21
       -
       func GetEnvBase64OrPlain(key string) (string, error) {

     

       22
       22
       -
       	value := os.Getenv(key)

     

       23
       23
       -
       	if value == "" {

     

       24
       24
       -
       		return "", nil

     

       25
       25
       -
       	}

     

       26
       26
       -
       

     

       27
       27
       -
       	// Check if value is base64 encoded

     

       28
       28
       -
       	if strings.HasPrefix(value, "base64:") {

     

       29
       29
       -
       		encoded := strings.TrimPrefix(value, "base64:")

     

       30
       30
       -
       		decoded, err := base64.StdEncoding.DecodeString(encoded)

     

       31
       31
       -
       		if err != nil {

     

       32
       32
       -
       			return "", fmt.Errorf("invalid base64 encoding for %s: %w", key, err)

     

       33
       33
       -
       		}

     

       34
       34
       -
       		return string(decoded), nil

     

       35
       35
       -
       	}

     

       36
       36
       -
       

     

       37
       37
       -
       	// Return plain value

     

       38
       38
       -
       	return value, nil

     

       39
       39
       -
       }

-131

internal/api/handlers/oauth/env_test.go

···

       1
       1
       -
       package oauth

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"encoding/base64"

     

       5
       5
       -
       	"os"

     

       6
       6
       -
       	"testing"

     

       7
       7
       -
       )

     

       8
       8
       -
       

     

       9
       9
       -
       func TestGetEnvBase64OrPlain(t *testing.T) {

     

       10
       10
       -
       	tests := []struct {

     

       11
       11
       -
       		name      string

     

       12
       12
       -
       		envKey    string

     

       13
       13
       -
       		envValue  string

     

       14
       14
       -
       		want      string

     

       15
       15
       -
       		wantError bool

     

       16
       16
       -
       	}{

     

       17
       17
       -
       		{

     

       18
       18
       -
       			name:      "plain JSON value",

     

       19
       19
       -
       			envKey:    "TEST_PLAIN_JSON",

     

       20
       20
       -
       			envValue:  `{"alg":"ES256","kty":"EC"}`,

     

       21
       21
       -
       			want:      `{"alg":"ES256","kty":"EC"}`,

     

       22
       22
       -
       			wantError: false,

     

       23
       23
       -
       		},

     

       24
       24
       -
       		{

     

       25
       25
       -
       			name:      "base64 encoded value",

     

       26
       26
       -
       			envKey:    "TEST_BASE64_JSON",

     

       27
       27
       -
       			envValue:  "base64:" + base64.StdEncoding.EncodeToString([]byte(`{"alg":"ES256","kty":"EC"}`)),

     

       28
       28
       -
       			want:      `{"alg":"ES256","kty":"EC"}`,

     

       29
       29
       -
       			wantError: false,

     

       30
       30
       -
       		},

     

       31
       31
       -
       		{

     

       32
       32
       -
       			name:      "empty value",

     

       33
       33
       -
       			envKey:    "TEST_EMPTY",

     

       34
       34
       -
       			envValue:  "",

     

       35
       35
       -
       			want:      "",

     

       36
       36
       -
       			wantError: false,

     

       37
       37
       -
       		},

     

       38
       38
       -
       		{

     

       39
       39
       -
       			name:      "invalid base64",

     

       40
       40
       -
       			envKey:    "TEST_INVALID_BASE64",

     

       41
       41
       -
       			envValue:  "base64:not-valid-base64!!!",

     

       42
       42
       -
       			want:      "",

     

       43
       43
       -
       			wantError: true,

     

       44
       44
       -
       		},

     

       45
       45
       -
       		{

     

       46
       46
       -
       			name:      "plain string with special chars",

     

       47
       47
       -
       			envKey:    "TEST_SPECIAL_CHARS",

     

       48
       48
       -
       			envValue:  "secret-with-dashes_and_underscores",

     

       49
       49
       -
       			want:      "secret-with-dashes_and_underscores",

     

       50
       50
       -
       			wantError: false,

     

       51
       51
       -
       		},

     

       52
       52
       -
       		{

     

       53
       53
       -
       			name:      "base64 encoded hex string",

     

       54
       54
       -
       			envKey:    "TEST_BASE64_HEX",

     

       55
       55
       -
       			envValue:  "base64:" + base64.StdEncoding.EncodeToString([]byte("f1132c01b1a625a865c6c455a75ee793")),

     

       56
       56
       -
       			want:      "f1132c01b1a625a865c6c455a75ee793",

     

       57
       57
       -
       			wantError: false,

     

       58
       58
       -
       		},

     

       59
       59
       -
       	}

     

       60
       60
       -
       

     

       61
       61
       -
       	for _, tt := range tests {

     

       62
       62
       -
       		t.Run(tt.name, func(t *testing.T) {

     

       63
       63
       -
       			// Set environment variable

     

       64
       64
       -
       			if tt.envValue != "" {

     

       65
       65
       -
       				if err := os.Setenv(tt.envKey, tt.envValue); err != nil {

     

       66
       66
       -
       					t.Fatalf("Failed to set env var: %v", err)

     

       67
       67
       -
       				}

     

       68
       68
       -
       				defer func() {

     

       69
       69
       -
       					if err := os.Unsetenv(tt.envKey); err != nil {

     

       70
       70
       -
       						t.Errorf("Failed to unset env var: %v", err)

     

       71
       71
       -
       					}

     

       72
       72
       -
       				}()

     

       73
       73
       -
       			}

     

       74
       74
       -
       

     

       75
       75
       -
       			got, err := GetEnvBase64OrPlain(tt.envKey)

     

       76
       76
       -
       

     

       77
       77
       -
       			if (err != nil) != tt.wantError {

     

       78
       78
       -
       				t.Errorf("GetEnvBase64OrPlain() error = %v, wantError %v", err, tt.wantError)

     

       79
       79
       -
       				return

     

       80
       80
       -
       			}

     

       81
       81
       -
       

     

       82
       82
       -
       			if got != tt.want {

     

       83
       83
       -
       				t.Errorf("GetEnvBase64OrPlain() = %v, want %v", got, tt.want)

     

       84
       84
       -
       			}

     

       85
       85
       -
       		})

     

       86
       86
       -
       	}

     

       87
       87
       -
       }

     

       88
       88
       -
       

     

       89
       89
       -
       func TestGetEnvBase64OrPlain_RealWorldJWK(t *testing.T) {

     

       90
       90
       -
       	// Test with a real JWK (the one from .env.dev)

     

       91
       91
       -
       	realJWK := `{"alg":"ES256","crv":"P-256","d":"9tCMceYSgyZfO5KYOCm3rWEhXLqq2l4LjP7-PJtJKyk","kid":"oauth-client-key","kty":"EC","use":"sig","x":"EOYWEgZ2d-smTO6jh0f-9B7YSFYdlrvlryjuXTCrOjE","y":"_FR2jBcWNxoJl5cd1eq9sYtAs33No9AVtd42UyyWYi4"}`

     

       92
       92
       -
       

     

       93
       93
       -
       	tests := []struct {

     

       94
       94
       -
       		name     string

     

       95
       95
       -
       		envValue string

     

       96
       96
       -
       		want     string

     

       97
       97
       -
       	}{

     

       98
       98
       -
       		{

     

       99
       99
       -
       			name:     "plain JWK",

     

       100
       100
       -
       			envValue: realJWK,

     

       101
       101
       -
       			want:     realJWK,

     

       102
       102
       -
       		},

     

       103
       103
       -
       		{

     

       104
       104
       -
       			name:     "base64 encoded JWK",

     

       105
       105
       -
       			envValue: "base64:" + base64.StdEncoding.EncodeToString([]byte(realJWK)),

     

       106
       106
       -
       			want:     realJWK,

     

       107
       107
       -
       		},

     

       108
       108
       -
       	}

     

       109
       109
       -
       

     

       110
       110
       -
       	for _, tt := range tests {

     

       111
       111
       -
       		t.Run(tt.name, func(t *testing.T) {

     

       112
       112
       -
       			if err := os.Setenv("TEST_REAL_JWK", tt.envValue); err != nil {

     

       113
       113
       -
       				t.Fatalf("Failed to set env var: %v", err)

     

       114
       114
       -
       			}

     

       115
       115
       -
       			defer func() {

     

       116
       116
       -
       				if err := os.Unsetenv("TEST_REAL_JWK"); err != nil {

     

       117
       117
       -
       					t.Errorf("Failed to unset env var: %v", err)

     

       118
       118
       -
       				}

     

       119
       119
       -
       			}()

     

       120
       120
       -
       

     

       121
       121
       -
       			got, err := GetEnvBase64OrPlain("TEST_REAL_JWK")

     

       122
       122
       -
       			if err != nil {

     

       123
       123
       -
       				t.Fatalf("unexpected error: %v", err)

     

       124
       124
       -
       			}

     

       125
       125
       -
       

     

       126
       126
       -
       			if got != tt.want {

     

       127
       127
       -
       				t.Errorf("GetEnvBase64OrPlain() = %v, want %v", got, tt.want)

     

       128
       128
       -
       			}

     

       129
       129
       -
       		})

     

       130
       130
       -
       	}

     

       131
       131
       -
       }

-53

internal/api/handlers/oauth/jwks.go

···

       1
       1
       -
       package oauth

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"Coves/internal/atproto/oauth"

     

       5
       5
       -
       	"encoding/json"

     

       6
       6
       -
       	"log"

     

       7
       7
       -
       	"net/http"

     

       8
       8
       -
       

     

       9
       9
       -
       	"github.com/lestrrat-go/jwx/v2/jwk"

     

       10
       10
       -
       )

     

       11
       11
       -
       

     

       12
       12
       -
       // HandleJWKS serves the JSON Web Key Set (JWKS) containing the public key

     

       13
       13
       -
       // GET /oauth/jwks.json

     

       14
       14
       -
       func HandleJWKS(w http.ResponseWriter, r *http.Request) {

     

       15
       15
       -
       	// Get private key from environment (supports base64 encoding)

     

       16
       16
       -
       	privateJWK, err := GetEnvBase64OrPlain("OAUTH_PRIVATE_JWK")

     

       17
       17
       -
       	if err != nil {

     

       18
       18
       -
       		http.Error(w, "OAuth configuration error", http.StatusInternalServerError)

     

       19
       19
       -
       		return

     

       20
       20
       -
       	}

     

       21
       21
       -
       	if privateJWK == "" {

     

       22
       22
       -
       		http.Error(w, "OAuth not configured", http.StatusInternalServerError)

     

       23
       23
       -
       		return

     

       24
       24
       -
       	}

     

       25
       25
       -
       

     

       26
       26
       -
       	// Parse private key

     

       27
       27
       -
       	privateKey, err := oauth.ParseJWKFromJSON([]byte(privateJWK))

     

       28
       28
       -
       	if err != nil {

     

       29
       29
       -
       		http.Error(w, "Failed to parse private key", http.StatusInternalServerError)

     

       30
       30
       -
       		return

     

       31
       31
       -
       	}

     

       32
       32
       -
       

     

       33
       33
       -
       	// Get public key

     

       34
       34
       -
       	publicKey, err := privateKey.PublicKey()

     

       35
       35
       -
       	if err != nil {

     

       36
       36
       -
       		http.Error(w, "Failed to get public key", http.StatusInternalServerError)

     

       37
       37
       -
       		return

     

       38
       38
       -
       	}

     

       39
       39
       -
       

     

       40
       40
       -
       	// Create JWKS

     

       41
       41
       -
       	jwks := jwk.NewSet()

     

       42
       42
       -
       	if err := jwks.AddKey(publicKey); err != nil {

     

       43
       43
       -
       		http.Error(w, "Failed to create JWKS", http.StatusInternalServerError)

     

       44
       44
       -
       		return

     

       45
       45
       -
       	}

     

       46
       46
       -
       

     

       47
       47
       -
       	// Serve JWKS

     

       48
       48
       -
       	w.Header().Set("Content-Type", "application/json")

     

       49
       49
       -
       	w.WriteHeader(http.StatusOK)

     

       50
       50
       -
       	if err := json.NewEncoder(w).Encode(jwks); err != nil {

     

       51
       51
       -
       		log.Printf("Failed to encode JWKS response: %v", err)

     

       52
       52
       -
       	}

     

       53
       53
       -
       }

-177

internal/api/handlers/oauth/login.go

···

       1
       1
       -
       package oauth

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"Coves/internal/atproto/identity"

     

       5
       5
       -
       	"Coves/internal/atproto/oauth"

     

       6
       6
       -
       	"encoding/json"

     

       7
       7
       -
       	"log"

     

       8
       8
       -
       	"net/http"

     

       9
       9
       -
       	"net/url"

     

       10
       10
       -
       	"strings"

     

       11
       11
       -
       

     

       12
       12
       -
       	oauthCore "Coves/internal/core/oauth"

     

       13
       13
       -
       )

     

       14
       14
       -
       

     

       15
       15
       -
       // LoginHandler handles OAuth login flow initiation

     

       16
       16
       -
       type LoginHandler struct {

     

       17
       17
       -
       	identityResolver identity.Resolver

     

       18
       18
       -
       	sessionStore     oauthCore.SessionStore

     

       19
       19
       -
       }

     

       20
       20
       -
       

     

       21
       21
       -
       // NewLoginHandler creates a new login handler

     

       22
       22
       -
       func NewLoginHandler(identityResolver identity.Resolver, sessionStore oauthCore.SessionStore) *LoginHandler {

     

       23
       23
       -
       	return &LoginHandler{

     

       24
       24
       -
       		identityResolver: identityResolver,

     

       25
       25
       -
       		sessionStore:     sessionStore,

     

       26
       26
       -
       	}

     

       27
       27
       -
       }

     

       28
       28
       -
       

     

       29
       29
       -
       // HandleLogin initiates the OAuth login flow

     

       30
       30
       -
       // POST /oauth/login

     

       31
       31
       -
       // Body: { "handle": "alice.bsky.social" }

     

       32
       32
       -
       func (h *LoginHandler) HandleLogin(w http.ResponseWriter, r *http.Request) {

     

       33
       33
       -
       	if r.Method != http.MethodPost {

     

       34
       34
       -
       		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)

     

       35
       35
       -
       		return

     

       36
       36
       -
       	}

     

       37
       37
       -
       

     

       38
       38
       -
       	// Parse request body

     

       39
       39
       -
       	var req struct {

     

       40
       40
       -
       		Handle    string `json:"handle"`

     

       41
       41
       -
       		ReturnURL string `json:"returnUrl,omitempty"`

     

       42
       42
       -
       	}

     

       43
       43
       -
       

     

       44
       44
       -
       	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {

     

       45
       45
       -
       		http.Error(w, "Invalid request body", http.StatusBadRequest)

     

       46
       46
       -
       		return

     

       47
       47
       -
       	}

     

       48
       48
       -
       

     

       49
       49
       -
       	// Normalize handle

     

       50
       50
       -
       	handle := strings.TrimSpace(strings.ToLower(req.Handle))

     

       51
       51
       -
       	handle = strings.TrimPrefix(handle, "@")

     

       52
       52
       -
       

     

       53
       53
       -
       	// Validate handle format

     

       54
       54
       -
       	if handle == "" || !strings.Contains(handle, ".") {

     

       55
       55
       -
       		http.Error(w, "Invalid handle format", http.StatusBadRequest)

     

       56
       56
       -
       		return

     

       57
       57
       -
       	}

     

       58
       58
       -
       

     

       59
       59
       -
       	// Resolve handle to DID and PDS

     

       60
       60
       -
       	resolved, err := h.identityResolver.Resolve(r.Context(), handle)

     

       61
       61
       -
       	if err != nil {

     

       62
       62
       -
       		log.Printf("Failed to resolve handle %s: %v", handle, err)

     

       63
       63
       -
       		http.Error(w, "Unable to find that account", http.StatusBadRequest)

     

       64
       64
       -
       		return

     

       65
       65
       -
       	}

     

       66
       66
       -
       

     

       67
       67
       -
       	// Get OAuth client configuration (supports base64 encoding)

     

       68
       68
       -
       	privateJWK, err := GetEnvBase64OrPlain("OAUTH_PRIVATE_JWK")

     

       69
       69
       -
       	if err != nil {

     

       70
       70
       -
       		log.Printf("Failed to load OAuth private key: %v", err)

     

       71
       71
       -
       		http.Error(w, "OAuth configuration error", http.StatusInternalServerError)

     

       72
       72
       -
       		return

     

       73
       73
       -
       	}

     

       74
       74
       -
       	if privateJWK == "" {

     

       75
       75
       -
       		http.Error(w, "OAuth not configured", http.StatusInternalServerError)

     

       76
       76
       -
       		return

     

       77
       77
       -
       	}

     

       78
       78
       -
       

     

       79
       79
       -
       	privateKey, err := oauth.ParseJWKFromJSON([]byte(privateJWK))

     

       80
       80
       -
       	if err != nil {

     

       81
       81
       -
       		log.Printf("Failed to parse OAuth private key: %v", err)

     

       82
       82
       -
       		http.Error(w, "OAuth configuration error", http.StatusInternalServerError)

     

       83
       83
       -
       		return

     

       84
       84
       -
       	}

     

       85
       85
       -
       

     

       86
       86
       -
       	appviewURL := getAppViewURL()

     

       87
       87
       -
       	clientID := getClientID(appviewURL)

     

       88
       88
       -
       	redirectURI := appviewURL + "/oauth/callback"

     

       89
       89
       -
       

     

       90
       90
       -
       	// Create OAuth client

     

       91
       91
       -
       	client := oauth.NewClient(clientID, privateKey, redirectURI)

     

       92
       92
       -
       

     

       93
       93
       -
       	// Discover auth server from PDS

     

       94
       94
       -
       	pdsURL := resolved.PDSURL

     

       95
       95
       -
       	authServerIss, err := client.ResolvePDSAuthServer(r.Context(), pdsURL)

     

       96
       96
       -
       	if err != nil {

     

       97
       97
       -
       		log.Printf("Failed to resolve auth server for PDS %s: %v", pdsURL, err)

     

       98
       98
       -
       		http.Error(w, "Failed to discover authorization server", http.StatusInternalServerError)

     

       99
       99
       -
       		return

     

       100
       100
       -
       	}

     

       101
       101
       -
       

     

       102
       102
       -
       	// Fetch auth server metadata

     

       103
       103
       -
       	authMeta, err := client.FetchAuthServerMetadata(r.Context(), authServerIss)

     

       104
       104
       -
       	if err != nil {

     

       105
       105
       -
       		log.Printf("Failed to fetch auth server metadata: %v", err)

     

       106
       106
       -
       		http.Error(w, "Failed to fetch authorization server metadata", http.StatusInternalServerError)

     

       107
       107
       -
       		return

     

       108
       108
       -
       	}

     

       109
       109
       -
       

     

       110
       110
       -
       	// Generate DPoP key for this session

     

       111
       111
       -
       	dpopKey, err := oauth.GenerateDPoPKey()

     

       112
       112
       -
       	if err != nil {

     

       113
       113
       -
       		log.Printf("Failed to generate DPoP key: %v", err)

     

       114
       114
       -
       		http.Error(w, "Failed to generate session key", http.StatusInternalServerError)

     

       115
       115
       -
       		return

     

       116
       116
       -
       	}

     

       117
       117
       -
       

     

       118
       118
       -
       	// Send PAR request

     

       119
       119
       -
       	parResp, err := client.SendPARRequest(r.Context(), authMeta, handle, "atproto transition:generic", dpopKey)

     

       120
       120
       -
       	if err != nil {

     

       121
       121
       -
       		log.Printf("Failed to send PAR request: %v", err)

     

       122
       122
       -
       		http.Error(w, "Failed to initiate authorization", http.StatusInternalServerError)

     

       123
       123
       -
       		return

     

       124
       124
       -
       	}

     

       125
       125
       -
       

     

       126
       126
       -
       	// Serialize DPoP key to JSON

     

       127
       127
       -
       	dpopKeyJSON, err := oauth.JWKToJSON(dpopKey)

     

       128
       128
       -
       	if err != nil {

     

       129
       129
       -
       		log.Printf("Failed to serialize DPoP key: %v", err)

     

       130
       130
       -
       		http.Error(w, "Failed to store session key", http.StatusInternalServerError)

     

       131
       131
       -
       		return

     

       132
       132
       -
       	}

     

       133
       133
       -
       

     

       134
       134
       -
       	// Save OAuth request state to database

     

       135
       135
       -
       	oauthReq := &oauthCore.OAuthRequest{

     

       136
       136
       -
       		State:               parResp.State,

     

       137
       137
       -
       		DID:                 resolved.DID,

     

       138
       138
       -
       		Handle:              handle,

     

       139
       139
       -
       		PDSURL:              pdsURL,

     

       140
       140
       -
       		PKCEVerifier:        parResp.PKCEVerifier,

     

       141
       141
       -
       		DPoPPrivateJWK:      string(dpopKeyJSON),

     

       142
       142
       -
       		DPoPAuthServerNonce: parResp.DpopAuthserverNonce,

     

       143
       143
       -
       		AuthServerIss:       authServerIss,

     

       144
       144
       -
       		ReturnURL:           req.ReturnURL,

     

       145
       145
       -
       	}

     

       146
       146
       -
       

     

       147
       147
       -
       	if saveErr := h.sessionStore.SaveRequest(oauthReq); saveErr != nil {

     

       148
       148
       -
       		log.Printf("Failed to save OAuth request: %v", saveErr)

     

       149
       149
       -
       		http.Error(w, "Failed to save authorization state", http.StatusInternalServerError)

     

       150
       150
       -
       		return

     

       151
       151
       -
       	}

     

       152
       152
       -
       

     

       153
       153
       -
       	// Build authorization URL

     

       154
       154
       -
       	authURL, err := url.Parse(authMeta.AuthorizationEndpoint)

     

       155
       155
       -
       	if err != nil {

     

       156
       156
       -
       		log.Printf("Invalid authorization endpoint: %v", err)

     

       157
       157
       -
       		http.Error(w, "Invalid authorization endpoint", http.StatusInternalServerError)

     

       158
       158
       -
       		return

     

       159
       159
       -
       	}

     

       160
       160
       -
       

     

       161
       161
       -
       	query := authURL.Query()

     

       162
       162
       -
       	query.Set("client_id", clientID)

     

       163
       163
       -
       	query.Set("request_uri", parResp.RequestURI)

     

       164
       164
       -
       	authURL.RawQuery = query.Encode()

     

       165
       165
       -
       

     

       166
       166
       -
       	// Return authorization URL to client

     

       167
       167
       -
       	resp := map[string]string{

     

       168
       168
       -
       		"authorizationUrl": authURL.String(),

     

       169
       169
       -
       		"state":            parResp.State,

     

       170
       170
       -
       	}

     

       171
       171
       -
       

     

       172
       172
       -
       	w.Header().Set("Content-Type", "application/json")

     

       173
       173
       -
       	w.WriteHeader(http.StatusOK)

     

       174
       174
       -
       	if err := json.NewEncoder(w).Encode(resp); err != nil {

     

       175
       175
       -
       		log.Printf("Failed to encode response: %v", err)

     

       176
       176
       -
       	}

     

       177
       177
       -
       }

-90

internal/api/handlers/oauth/logout.go

···

       1
       1
       -
       package oauth

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"log"

     

       5
       5
       -
       	"net/http"

     

       6
       6
       -
       

     

       7
       7
       -
       	oauthCore "Coves/internal/core/oauth"

     

       8
       8
       -
       )

     

       9
       9
       -
       

     

       10
       10
       -
       // LogoutHandler handles user logout

     

       11
       11
       -
       type LogoutHandler struct {

     

       12
       12
       -
       	sessionStore oauthCore.SessionStore

     

       13
       13
       -
       }

     

       14
       14
       -
       

     

       15
       15
       -
       // NewLogoutHandler creates a new logout handler

     

       16
       16
       -
       func NewLogoutHandler(sessionStore oauthCore.SessionStore) *LogoutHandler {

     

       17
       17
       -
       	return &LogoutHandler{

     

       18
       18
       -
       		sessionStore: sessionStore,

     

       19
       19
       -
       	}

     

       20
       20
       -
       }

     

       21
       21
       -
       

     

       22
       22
       -
       // HandleLogout logs out the current user

     

       23
       23
       -
       // POST /oauth/logout

     

       24
       24
       -
       func (h *LogoutHandler) HandleLogout(w http.ResponseWriter, r *http.Request) {

     

       25
       25
       -
       	if r.Method != http.MethodPost {

     

       26
       26
       -
       		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)

     

       27
       27
       -
       		return

     

       28
       28
       -
       	}

     

       29
       29
       -
       

     

       30
       30
       -
       	// Get HTTP session

     

       31
       31
       -
       	cookieStore := GetCookieStore()

     

       32
       32
       -
       	httpSession, err := cookieStore.Get(r, sessionName)

     

       33
       33
       -
       	if err != nil || httpSession.IsNew {

     

       34
       34
       -
       		// No session to logout

     

       35
       35
       -
       		http.Redirect(w, r, "/", http.StatusFound)

     

       36
       36
       -
       		return

     

       37
       37
       -
       	}

     

       38
       38
       -
       

     

       39
       39
       -
       	// Get DID from session

     

       40
       40
       -
       	did, ok := httpSession.Values[sessionDID].(string)

     

       41
       41
       -
       	if !ok || did == "" {

     

       42
       42
       -
       		// No DID in session

     

       43
       43
       -
       		http.Redirect(w, r, "/", http.StatusFound)

     

       44
       44
       -
       		return

     

       45
       45
       -
       	}

     

       46
       46
       -
       

     

       47
       47
       -
       	// Delete OAuth session from database

     

       48
       48
       -
       	if err := h.sessionStore.DeleteSession(did); err != nil {

     

       49
       49
       -
       		log.Printf("Failed to delete OAuth session for DID %s: %v", did, err)

     

       50
       50
       -
       		// Continue with logout anyway

     

       51
       51
       -
       	}

     

       52
       52
       -
       

     

       53
       53
       -
       	// Clear HTTP session cookie

     

       54
       54
       -
       	httpSession.Options.MaxAge = -1 // Delete cookie

     

       55
       55
       -
       	if err := httpSession.Save(r, w); err != nil {

     

       56
       56
       -
       		log.Printf("Failed to clear HTTP session: %v", err)

     

       57
       57
       -
       	}

     

       58
       58
       -
       

     

       59
       59
       -
       	// Redirect to home

     

       60
       60
       -
       	http.Redirect(w, r, "/", http.StatusFound)

     

       61
       61
       -
       }

     

       62
       62
       -
       

     

       63
       63
       -
       // GetCurrentUser returns the currently authenticated user's DID

     

       64
       64
       -
       // Helper function for other handlers

     

       65
       65
       -
       func GetCurrentUser(r *http.Request) (string, error) {

     

       66
       66
       -
       	cookieStore := GetCookieStore()

     

       67
       67
       -
       	httpSession, err := cookieStore.Get(r, sessionName)

     

       68
       68
       -
       	if err != nil || httpSession.IsNew {

     

       69
       69
       -
       		return "", err

     

       70
       70
       -
       	}

     

       71
       71
       -
       

     

       72
       72
       -
       	did, ok := httpSession.Values[sessionDID].(string)

     

       73
       73
       -
       	if !ok || did == "" {

     

       74
       74
       -
       		return "", nil

     

       75
       75
       -
       	}

     

       76
       76
       -
       

     

       77
       77
       -
       	return did, nil

     

       78
       78
       -
       }

     

       79
       79
       -
       

     

       80
       80
       -
       // GetCurrentUserOrError returns the current user's DID or sends an error response

     

       81
       81
       -
       // Helper function for protected handlers

     

       82
       82
       -
       func GetCurrentUserOrError(w http.ResponseWriter, r *http.Request) (string, bool) {

     

       83
       83
       -
       	did, err := GetCurrentUser(r)

     

       84
       84
       -
       	if err != nil || did == "" {

     

       85
       85
       -
       		http.Error(w, "Unauthorized", http.StatusUnauthorized)

     

       86
       86
       -
       		return "", false

     

       87
       87
       -
       	}

     

       88
       88
       -
       

     

       89
       89
       -
       	return did, true

     

       90
       90
       -
       }

-86

internal/api/handlers/oauth/metadata.go

···

       1
       1
       -
       package oauth

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"encoding/json"

     

       5
       5
       -
       	"net/http"

     

       6
       6
       -
       	"os"

     

       7
       7
       -
       	"strings"

     

       8
       8
       -
       )

     

       9
       9
       -
       

     

       10
       10
       -
       // ClientMetadata represents OAuth 2.0 client metadata (RFC 7591)

     

       11
       11
       -
       // Served at /oauth/client-metadata.json

     

       12
       12
       -
       type ClientMetadata struct {

     

       13
       13
       -
       	ClientID                    string   `json:"client_id"`

     

       14
       14
       -
       	ClientName                  string   `json:"client_name"`

     

       15
       15
       -
       	ClientURI                   string   `json:"client_uri"`

     

       16
       16
       -
       	Scope                       string   `json:"scope"`

     

       17
       17
       -
       	TokenEndpointAuthMethod     string   `json:"token_endpoint_auth_method"`

     

       18
       18
       -
       	TokenEndpointAuthSigningAlg string   `json:"token_endpoint_auth_signing_alg"`

     

       19
       19
       -
       	ApplicationType             string   `json:"application_type"`

     

       20
       20
       -
       	JwksURI                     string   `json:"jwks_uri,omitempty"`

     

       21
       21
       -
       	RedirectURIs                []string `json:"redirect_uris"`

     

       22
       22
       -
       	GrantTypes                  []string `json:"grant_types"`

     

       23
       23
       -
       	ResponseTypes               []string `json:"response_types"`

     

       24
       24
       -
       	DpopBoundAccessTokens       bool     `json:"dpop_bound_access_tokens"`

     

       25
       25
       -
       }

     

       26
       26
       -
       

     

       27
       27
       -
       // HandleClientMetadata serves the OAuth client metadata

     

       28
       28
       -
       // GET /oauth/client-metadata.json

     

       29
       29
       -
       func HandleClientMetadata(w http.ResponseWriter, r *http.Request) {

     

       30
       30
       -
       	appviewURL := getAppViewURL()

     

       31
       31
       -
       

     

       32
       32
       -
       	// Determine client ID based on environment

     

       33
       33
       -
       	clientID := getClientID(appviewURL)

     

       34
       34
       -
       	jwksURI := ""

     

       35
       35
       -
       

     

       36
       36
       -
       	// Only include JWKS URI in production (not for loopback clients)

     

       37
       37
       -
       	if !strings.HasPrefix(appviewURL, "http://localhost") && !strings.HasPrefix(appviewURL, "http://127.0.0.1") {

     

       38
       38
       -
       		jwksURI = appviewURL + "/oauth/jwks.json"

     

       39
       39
       -
       	}

     

       40
       40
       -
       

     

       41
       41
       -
       	metadata := ClientMetadata{

     

       42
       42
       -
       		ClientID:                    clientID,

     

       43
       43
       -
       		ClientName:                  "Coves",

     

       44
       44
       -
       		ClientURI:                   appviewURL,

     

       45
       45
       -
       		RedirectURIs:                []string{appviewURL + "/oauth/callback"},

     

       46
       46
       -
       		GrantTypes:                  []string{"authorization_code", "refresh_token"},

     

       47
       47
       -
       		ResponseTypes:               []string{"code"},

     

       48
       48
       -
       		Scope:                       "atproto transition:generic",

     

       49
       49
       -
       		TokenEndpointAuthMethod:     "private_key_jwt",

     

       50
       50
       -
       		TokenEndpointAuthSigningAlg: "ES256",

     

       51
       51
       -
       		DpopBoundAccessTokens:       true,

     

       52
       52
       -
       		ApplicationType:             "web",

     

       53
       53
       -
       		JwksURI:                     jwksURI,

     

       54
       54
       -
       	}

     

       55
       55
       -
       

     

       56
       56
       -
       	w.Header().Set("Content-Type", "application/json")

     

       57
       57
       -
       	w.WriteHeader(http.StatusOK)

     

       58
       58
       -
       	if err := json.NewEncoder(w).Encode(metadata); err != nil {

     

       59
       59
       -
       		// Log encoding errors but don't return error response (headers already sent)

     

       60
       60
       -
       		// This follows Go's standard practice for HTTP handlers

     

       61
       61
       -
       		_ = err

     

       62
       62
       -
       	}

     

       63
       63
       -
       }

     

       64
       64
       -
       

     

       65
       65
       -
       // getAppViewURL returns the public URL of the AppView

     

       66
       66
       -
       func getAppViewURL() string {

     

       67
       67
       -
       	url := os.Getenv("APPVIEW_PUBLIC_URL")

     

       68
       68
       -
       	if url == "" {

     

       69
       69
       -
       		// Default to localhost for development

     

       70
       70
       -
       		url = "http://localhost:8081"

     

       71
       71
       -
       	}

     

       72
       72
       -
       	return strings.TrimSuffix(url, "/")

     

       73
       73
       -
       }

     

       74
       74
       -
       

     

       75
       75
       -
       // getClientID returns the OAuth client ID based on environment

     

       76
       76
       -
       // For localhost development, use loopback client identifier

     

       77
       77
       -
       // For production, use HTTPS URL to client metadata

     

       78
       78
       -
       func getClientID(appviewURL string) string {

     

       79
       79
       -
       	// Development: use loopback client (http://localhost?...)

     

       80
       80
       -
       	if strings.HasPrefix(appviewURL, "http://localhost") || strings.HasPrefix(appviewURL, "http://127.0.0.1") {

     

       81
       81
       -
       		return "http://localhost?redirect_uri=" + appviewURL + "/oauth/callback&scope=atproto%20transition:generic"

     

       82
       82
       -
       	}

     

       83
       83
       -
       

     

       84
       84
       -
       	// Production: use HTTPS URL to client metadata

     

       85
       85
       -
       	return appviewURL + "/oauth/client-metadata.json"

     

       86
       86
       -
       }

-350

internal/atproto/oauth/client.go

···

       1
       1
       -
       package oauth

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"context"

     

       5
       5
       -
       	"encoding/json"

     

       6
       6
       -
       	"fmt"

     

       7
       7
       -
       	"io"

     

       8
       8
       -
       	"net/http"

     

       9
       9
       -
       	"net/url"

     

       10
       10
       -
       	"strings"

     

       11
       11
       -
       	"time"

     

       12
       12
       -
       

     

       13
       13
       -
       	"github.com/lestrrat-go/jwx/v2/jwk"

     

       14
       14
       -
       )

     

       15
       15
       -
       

     

       16
       16
       -
       // Client handles atProto OAuth flows (PAR, PKCE, DPoP)

     

       17
       17
       -
       type Client struct {

     

       18
       18
       -
       	clientJWK   jwk.Key

     

       19
       19
       -
       	httpClient  *http.Client

     

       20
       20
       -
       	clientID    string

     

       21
       21
       -
       	redirectURI string

     

       22
       22
       -
       }

     

       23
       23
       -
       

     

       24
       24
       -
       // NewClient creates a new OAuth client

     

       25
       25
       -
       func NewClient(clientID string, clientJWK jwk.Key, redirectURI string) *Client {

     

       26
       26
       -
       	return &Client{

     

       27
       27
       -
       		clientID:    clientID,

     

       28
       28
       -
       		clientJWK:   clientJWK,

     

       29
       29
       -
       		redirectURI: redirectURI,

     

       30
       30
       -
       		httpClient: &http.Client{

     

       31
       31
       -
       			Timeout: 30 * time.Second,

     

       32
       32
       -
       		},

     

       33
       33
       -
       	}

     

       34
       34
       -
       }

     

       35
       35
       -
       

     

       36
       36
       -
       // AuthServerMetadata represents OAuth 2.0 authorization server metadata (RFC 8414)

     

       37
       37
       -
       type AuthServerMetadata struct {

     

       38
       38
       -
       	Issuer                        string   `json:"issuer"`

     

       39
       39
       -
       	AuthorizationEndpoint         string   `json:"authorization_endpoint"`

     

       40
       40
       -
       	TokenEndpoint                 string   `json:"token_endpoint"`

     

       41
       41
       -
       	PushedAuthReqEndpoint         string   `json:"pushed_authorization_request_endpoint"`

     

       42
       42
       -
       	JWKSURI                       string   `json:"jwks_uri"`

     

       43
       43
       -
       	GrantTypesSupported           []string `json:"grant_types_supported"`

     

       44
       44
       -
       	ResponseTypesSupported        []string `json:"response_types_supported"`

     

       45
       45
       -
       	CodeChallengeMethodsSupported []string `json:"code_challenge_methods_supported"`

     

       46
       46
       -
       	DPoPSigningAlgValuesSupported []string `json:"dpop_signing_alg_values_supported"`

     

       47
       47
       -
       }

     

       48
       48
       -
       

     

       49
       49
       -
       // ResolvePDSAuthServer resolves the authorization server for a PDS

     

       50
       50
       -
       // Follows the PDS → Authorization Server discovery flow

     

       51
       51
       -
       func (c *Client) ResolvePDSAuthServer(ctx context.Context, pdsURL string) (string, error) {

     

       52
       52
       -
       	// Fetch PDS metadata from /.well-known/oauth-protected-resource

     

       53
       53
       -
       	metadataURL := strings.TrimSuffix(pdsURL, "/") + "/.well-known/oauth-protected-resource"

     

       54
       54
       -
       

     

       55
       55
       -
       	req, err := http.NewRequestWithContext(ctx, "GET", metadataURL, nil)

     

       56
       56
       -
       	if err != nil {

     

       57
       57
       -
       		return "", fmt.Errorf("failed to create request: %w", err)

     

       58
       58
       -
       	}

     

       59
       59
       -
       

     

       60
       60
       -
       	resp, err := c.httpClient.Do(req)

     

       61
       61
       -
       	if err != nil {

     

       62
       62
       -
       		return "", fmt.Errorf("failed to fetch PDS metadata: %w", err)

     

       63
       63
       -
       	}

     

       64
       64
       -
       	defer func() { _ = resp.Body.Close() }() //nolint:errcheck

     

       65
       65
       -
       

     

       66
       66
       -
       	if resp.StatusCode != http.StatusOK {

     

       67
       67
       -
       		return "", fmt.Errorf("PDS returned status %d", resp.StatusCode)

     

       68
       68
       -
       	}

     

       69
       69
       -
       

     

       70
       70
       -
       	var metadata struct {

     

       71
       71
       -
       		AuthorizationServers []string `json:"authorization_servers"`

     

       72
       72
       -
       	}

     

       73
       73
       -
       

     

       74
       74
       -
       	if err := json.NewDecoder(resp.Body).Decode(&metadata); err != nil {

     

       75
       75
       -
       		return "", fmt.Errorf("failed to decode PDS metadata: %w", err)

     

       76
       76
       -
       	}

     

       77
       77
       -
       

     

       78
       78
       -
       	if len(metadata.AuthorizationServers) == 0 {

     

       79
       79
       -
       		return "", fmt.Errorf("no authorization servers found for PDS")

     

       80
       80
       -
       	}

     

       81
       81
       -
       

     

       82
       82
       -
       	// Return the first (primary) authorization server

     

       83
       83
       -
       	return metadata.AuthorizationServers[0], nil

     

       84
       84
       -
       }

     

       85
       85
       -
       

     

       86
       86
       -
       // FetchAuthServerMetadata fetches OAuth 2.0 authorization server metadata

     

       87
       87
       -
       func (c *Client) FetchAuthServerMetadata(ctx context.Context, issuer string) (*AuthServerMetadata, error) {

     

       88
       88
       -
       	// OAuth 2.0 discovery endpoint

     

       89
       89
       -
       	metadataURL := strings.TrimSuffix(issuer, "/") + "/.well-known/oauth-authorization-server"

     

       90
       90
       -
       

     

       91
       91
       -
       	req, err := http.NewRequestWithContext(ctx, "GET", metadataURL, nil)

     

       92
       92
       -
       	if err != nil {

     

       93
       93
       -
       		return nil, fmt.Errorf("failed to create request: %w", err)

     

       94
       94
       -
       	}

     

       95
       95
       -
       

     

       96
       96
       -
       	resp, err := c.httpClient.Do(req)

     

       97
       97
       -
       	if err != nil {

     

       98
       98
       -
       		return nil, fmt.Errorf("failed to fetch auth server metadata: %w", err)

     

       99
       99
       -
       	}

     

       100
       100
       -
       	defer func() { _ = resp.Body.Close() }() //nolint:errcheck

     

       101
       101
       -
       

     

       102
       102
       -
       	if resp.StatusCode != http.StatusOK {

     

       103
       103
       -
       		return nil, fmt.Errorf("auth server returned status %d", resp.StatusCode)

     

       104
       104
       -
       	}

     

       105
       105
       -
       

     

       106
       106
       -
       	var metadata AuthServerMetadata

     

       107
       107
       -
       	if err := json.NewDecoder(resp.Body).Decode(&metadata); err != nil {

     

       108
       108
       -
       		return nil, fmt.Errorf("failed to decode auth server metadata: %w", err)

     

       109
       109
       -
       	}

     

       110
       110
       -
       

     

       111
       111
       -
       	return &metadata, nil

     

       112
       112
       -
       }

     

       113
       113
       -
       

     

       114
       114
       -
       // PARResponse represents the response from a Pushed Authorization Request

     

       115
       115
       -
       type PARResponse struct {

     

       116
       116
       -
       	RequestURI          string `json:"request_uri"`

     

       117
       117
       -
       	State               string

     

       118
       118
       -
       	PKCEVerifier        string

     

       119
       119
       -
       	DpopAuthserverNonce string

     

       120
       120
       -
       	ExpiresIn           int `json:"expires_in"`

     

       121
       121
       -
       }

     

       122
       122
       -
       

     

       123
       123
       -
       // SendPARRequest sends a Pushed Authorization Request (PAR) - RFC 9126

     

       124
       124
       -
       // This pre-registers the authorization request with the server

     

       125
       125
       -
       func (c *Client) SendPARRequest(ctx context.Context, authMeta *AuthServerMetadata, handle, scope string, dpopKey jwk.Key) (*PARResponse, error) {

     

       126
       126
       -
       	// Generate PKCE challenge

     

       127
       127
       -
       	pkce, err := GeneratePKCEChallenge()

     

       128
       128
       -
       	if err != nil {

     

       129
       129
       -
       		return nil, fmt.Errorf("failed to generate PKCE: %w", err)

     

       130
       130
       -
       	}

     

       131
       131
       -
       

     

       132
       132
       -
       	// Generate state

     

       133
       133
       -
       	state, err := GenerateState()

     

       134
       134
       -
       	if err != nil {

     

       135
       135
       -
       		return nil, fmt.Errorf("failed to generate state: %w", err)

     

       136
       136
       -
       	}

     

       137
       137
       -
       

     

       138
       138
       -
       	// Create form data

     

       139
       139
       -
       	data := url.Values{}

     

       140
       140
       -
       	data.Set("client_id", c.clientID)

     

       141
       141
       -
       	data.Set("redirect_uri", c.redirectURI)

     

       142
       142
       -
       	data.Set("response_type", "code")

     

       143
       143
       -
       	data.Set("scope", scope)

     

       144
       144
       -
       	data.Set("state", state)

     

       145
       145
       -
       	data.Set("code_challenge", pkce.Challenge)

     

       146
       146
       -
       	data.Set("code_challenge_method", pkce.Method)

     

       147
       147
       -
       	data.Set("login_hint", handle) // atProto-specific: suggests which account to use

     

       148
       148
       -
       

     

       149
       149
       -
       	// Create DPoP proof for PAR endpoint

     

       150
       150
       -
       	dpopProof, err := CreateDPoPProof(dpopKey, "POST", authMeta.PushedAuthReqEndpoint, "", "")

     

       151
       151
       -
       	if err != nil {

     

       152
       152
       -
       		return nil, fmt.Errorf("failed to create DPoP proof: %w", err)

     

       153
       153
       -
       	}

     

       154
       154
       -
       

     

       155
       155
       -
       	// Send PAR request

     

       156
       156
       -
       	req, err := http.NewRequestWithContext(ctx, "POST", authMeta.PushedAuthReqEndpoint, strings.NewReader(data.Encode()))

     

       157
       157
       -
       	if err != nil {

     

       158
       158
       -
       		return nil, fmt.Errorf("failed to create request: %w", err)

     

       159
       159
       -
       	}

     

       160
       160
       -
       

     

       161
       161
       -
       	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

     

       162
       162
       -
       	req.Header.Set("DPoP", dpopProof)

     

       163
       163
       -
       

     

       164
       164
       -
       	resp, err := c.httpClient.Do(req)

     

       165
       165
       -
       	if err != nil {

     

       166
       166
       -
       		return nil, fmt.Errorf("failed to send PAR request: %w", err)

     

       167
       167
       -
       	}

     

       168
       168
       -
       	defer func() { _ = resp.Body.Close() }() //nolint:errcheck

     

       169
       169
       -
       

     

       170
       170
       -
       	body, err := io.ReadAll(resp.Body)

     

       171
       171
       -
       	if err != nil {

     

       172
       172
       -
       		return nil, fmt.Errorf("failed to read PAR response: %w", err)

     

       173
       173
       -
       	}

     

       174
       174
       -
       

     

       175
       175
       -
       	// Handle DPoP nonce requirement (RFC 9449 Section 8)

     

       176
       176
       -
       	// If server returns use_dpop_nonce error, retry with the nonce

     

       177
       177
       -
       	if resp.StatusCode == http.StatusBadRequest {

     

       178
       178
       -
       		var errorResp struct {

     

       179
       179
       -
       			Error            string `json:"error"`

     

       180
       180
       -
       			ErrorDescription string `json:"error_description"`

     

       181
       181
       -
       		}

     

       182
       182
       -
       		if err := json.Unmarshal(body, &errorResp); err == nil && errorResp.Error == "use_dpop_nonce" {

     

       183
       183
       -
       			// Get nonce from response header

     

       184
       184
       -
       			nonce := resp.Header.Get("DPoP-Nonce")

     

       185
       185
       -
       			if nonce != "" {

     

       186
       186
       -
       				// Retry with nonce

     

       187
       187
       -
       				dpopProof, err = CreateDPoPProof(dpopKey, "POST", authMeta.PushedAuthReqEndpoint, nonce, "")

     

       188
       188
       -
       				if err != nil {

     

       189
       189
       -
       					return nil, fmt.Errorf("failed to create DPoP proof with nonce: %w", err)

     

       190
       190
       -
       				}

     

       191
       191
       -
       

     

       192
       192
       -
       				// Re-create request with new DPoP proof

     

       193
       193
       -
       				req, err = http.NewRequestWithContext(ctx, "POST", authMeta.PushedAuthReqEndpoint, strings.NewReader(data.Encode()))

     

       194
       194
       -
       				if err != nil {

     

       195
       195
       -
       					return nil, fmt.Errorf("failed to create retry request: %w", err)

     

       196
       196
       -
       				}

     

       197
       197
       -
       				req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

     

       198
       198
       -
       				req.Header.Set("DPoP", dpopProof)

     

       199
       199
       -
       

     

       200
       200
       -
       				// Send retry request

     

       201
       201
       -
       				resp, err = c.httpClient.Do(req)

     

       202
       202
       -
       				if err != nil {

     

       203
       203
       -
       					return nil, fmt.Errorf("failed to send retry PAR request: %w", err)

     

       204
       204
       -
       				}

     

       205
       205
       -
       				defer func() { _ = resp.Body.Close() }() //nolint:errcheck

     

       206
       206
       -
       				body, err = io.ReadAll(resp.Body)

     

       207
       207
       -
       				if err != nil {

     

       208
       208
       -
       					return nil, fmt.Errorf("failed to read retry PAR response: %w", err)

     

       209
       209
       -
       				}

     

       210
       210
       -
       			}

     

       211
       211
       -
       		}

     

       212
       212
       -
       	}

     

       213
       213
       -
       

     

       214
       214
       -
       	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {

     

       215
       215
       -
       		return nil, fmt.Errorf("PAR request failed with status %d", resp.StatusCode)

     

       216
       216
       -
       	}

     

       217
       217
       -
       

     

       218
       218
       -
       	var parResp struct {

     

       219
       219
       -
       		RequestURI string `json:"request_uri"`

     

       220
       220
       -
       		ExpiresIn  int    `json:"expires_in"`

     

       221
       221
       -
       	}

     

       222
       222
       -
       

     

       223
       223
       -
       	if err := json.Unmarshal(body, &parResp); err != nil {

     

       224
       224
       -
       		return nil, fmt.Errorf("failed to decode PAR response: %w", err)

     

       225
       225
       -
       	}

     

       226
       226
       -
       

     

       227
       227
       -
       	// Extract DPoP nonce from response header (if provided)

     

       228
       228
       -
       	dpopNonce := resp.Header.Get("DPoP-Nonce")

     

       229
       229
       -
       

     

       230
       230
       -
       	return &PARResponse{

     

       231
       231
       -
       		RequestURI:          parResp.RequestURI,

     

       232
       232
       -
       		ExpiresIn:           parResp.ExpiresIn,

     

       233
       233
       -
       		State:               state,

     

       234
       234
       -
       		PKCEVerifier:        pkce.Verifier,

     

       235
       235
       -
       		DpopAuthserverNonce: dpopNonce,

     

       236
       236
       -
       	}, nil

     

       237
       237
       -
       }

     

       238
       238
       -
       

     

       239
       239
       -
       // TokenResponse represents an OAuth token response

     

       240
       240
       -
       type TokenResponse struct {

     

       241
       241
       -
       	AccessToken         string `json:"access_token"`

     

       242
       242
       -
       	TokenType           string `json:"token_type"`

     

       243
       243
       -
       	RefreshToken        string `json:"refresh_token"`

     

       244
       244
       -
       	Scope               string `json:"scope"`

     

       245
       245
       -
       	Sub                 string `json:"sub"`

     

       246
       246
       -
       	DpopAuthserverNonce string

     

       247
       247
       -
       	ExpiresIn           int `json:"expires_in"`

     

       248
       248
       -
       }

     

       249
       249
       -
       

     

       250
       250
       -
       // InitialTokenRequest exchanges authorization code for tokens (DPoP-bound)

     

       251
       251
       -
       func (c *Client) InitialTokenRequest(ctx context.Context, code, issuer, pkceVerifier, dpopNonce string, dpopKey jwk.Key) (*TokenResponse, error) {

     

       252
       252
       -
       	// Get auth server metadata for token endpoint

     

       253
       253
       -
       	authMeta, err := c.FetchAuthServerMetadata(ctx, issuer)

     

       254
       254
       -
       	if err != nil {

     

       255
       255
       -
       		return nil, fmt.Errorf("failed to fetch auth server metadata: %w", err)

     

       256
       256
       -
       	}

     

       257
       257
       -
       

     

       258
       258
       -
       	// Create form data

     

       259
       259
       -
       	data := url.Values{}

     

       260
       260
       -
       	data.Set("grant_type", "authorization_code")

     

       261
       261
       -
       	data.Set("code", code)

     

       262
       262
       -
       	data.Set("redirect_uri", c.redirectURI)

     

       263
       263
       -
       	data.Set("code_verifier", pkceVerifier)

     

       264
       264
       -
       	data.Set("client_id", c.clientID)

     

       265
       265
       -
       

     

       266
       266
       -
       	// Create DPoP proof for token endpoint

     

       267
       267
       -
       	dpopProof, err := CreateDPoPProof(dpopKey, "POST", authMeta.TokenEndpoint, dpopNonce, "")

     

       268
       268
       -
       	if err != nil {

     

       269
       269
       -
       		return nil, fmt.Errorf("failed to create DPoP proof: %w", err)

     

       270
       270
       -
       	}

     

       271
       271
       -
       

     

       272
       272
       -
       	// Send token request

     

       273
       273
       -
       	req, err := http.NewRequestWithContext(ctx, "POST", authMeta.TokenEndpoint, strings.NewReader(data.Encode()))

     

       274
       274
       -
       	if err != nil {

     

       275
       275
       -
       		return nil, fmt.Errorf("failed to create request: %w", err)

     

       276
       276
       -
       	}

     

       277
       277
       -
       

     

       278
       278
       -
       	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

     

       279
       279
       -
       	req.Header.Set("DPoP", dpopProof)

     

       280
       280
       -
       

     

       281
       281
       -
       	resp, err := c.httpClient.Do(req)

     

       282
       282
       -
       	if err != nil {

     

       283
       283
       -
       		return nil, fmt.Errorf("failed to send token request: %w", err)

     

       284
       284
       -
       	}

     

       285
       285
       -
       	defer func() { _ = resp.Body.Close() }() //nolint:errcheck

     

       286
       286
       -
       

     

       287
       287
       -
       	var tokenResp TokenResponse

     

       288
       288
       -
       	if resp.StatusCode != http.StatusOK {

     

       289
       289
       -
       		return nil, fmt.Errorf("token request failed with status %d", resp.StatusCode)

     

       290
       290
       -
       	}

     

       291
       291
       -
       

     

       292
       292
       -
       	if err := json.NewDecoder(resp.Body).Decode(&tokenResp); err != nil {

     

       293
       293
       -
       		return nil, fmt.Errorf("failed to decode token response: %w", err)

     

       294
       294
       -
       	}

     

       295
       295
       -
       

     

       296
       296
       -
       	// Extract updated DPoP nonce

     

       297
       297
       -
       	tokenResp.DpopAuthserverNonce = resp.Header.Get("DPoP-Nonce")

     

       298
       298
       -
       

     

       299
       299
       -
       	return &tokenResp, nil

     

       300
       300
       -
       }

     

       301
       301
       -
       

     

       302
       302
       -
       // RefreshTokenRequest refreshes an access token using a refresh token

     

       303
       303
       -
       func (c *Client) RefreshTokenRequest(ctx context.Context, refreshToken, issuer, dpopNonce string, dpopKey jwk.Key) (*TokenResponse, error) {

     

       304
       304
       -
       	// Get auth server metadata for token endpoint

     

       305
       305
       -
       	authMeta, err := c.FetchAuthServerMetadata(ctx, issuer)

     

       306
       306
       -
       	if err != nil {

     

       307
       307
       -
       		return nil, fmt.Errorf("failed to fetch auth server metadata: %w", err)

     

       308
       308
       -
       	}

     

       309
       309
       -
       

     

       310
       310
       -
       	// Create form data

     

       311
       311
       -
       	data := url.Values{}

     

       312
       312
       -
       	data.Set("grant_type", "refresh_token")

     

       313
       313
       -
       	data.Set("refresh_token", refreshToken)

     

       314
       314
       -
       	data.Set("client_id", c.clientID)

     

       315
       315
       -
       

     

       316
       316
       -
       	// Create DPoP proof for token endpoint

     

       317
       317
       -
       	dpopProof, err := CreateDPoPProof(dpopKey, "POST", authMeta.TokenEndpoint, dpopNonce, "")

     

       318
       318
       -
       	if err != nil {

     

       319
       319
       -
       		return nil, fmt.Errorf("failed to create DPoP proof: %w", err)

     

       320
       320
       -
       	}

     

       321
       321
       -
       

     

       322
       322
       -
       	// Send refresh request

     

       323
       323
       -
       	req, err := http.NewRequestWithContext(ctx, "POST", authMeta.TokenEndpoint, strings.NewReader(data.Encode()))

     

       324
       324
       -
       	if err != nil {

     

       325
       325
       -
       		return nil, fmt.Errorf("failed to create request: %w", err)

     

       326
       326
       -
       	}

     

       327
       327
       -
       

     

       328
       328
       -
       	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

     

       329
       329
       -
       	req.Header.Set("DPoP", dpopProof)

     

       330
       330
       -
       

     

       331
       331
       -
       	resp, err := c.httpClient.Do(req)

     

       332
       332
       -
       	if err != nil {

     

       333
       333
       -
       		return nil, fmt.Errorf("failed to send refresh request: %w", err)

     

       334
       334
       -
       	}

     

       335
       335
       -
       	defer func() { _ = resp.Body.Close() }() //nolint:errcheck

     

       336
       336
       -
       

     

       337
       337
       -
       	var tokenResp TokenResponse

     

       338
       338
       -
       	if resp.StatusCode != http.StatusOK {

     

       339
       339
       -
       		return nil, fmt.Errorf("refresh request failed with status %d", resp.StatusCode)

     

       340
       340
       -
       	}

     

       341
       341
       -
       

     

       342
       342
       -
       	if err := json.NewDecoder(resp.Body).Decode(&tokenResp); err != nil {

     

       343
       343
       -
       		return nil, fmt.Errorf("failed to decode token response: %w", err)

     

       344
       344
       -
       	}

     

       345
       345
       -
       

     

       346
       346
       -
       	// Extract updated DPoP nonce

     

       347
       347
       -
       	tokenResp.DpopAuthserverNonce = resp.Header.Get("DPoP-Nonce")

     

       348
       348
       -
       

     

       349
       349
       -
       	return &tokenResp, nil

     

       350
       350
       -
       }

-167

internal/atproto/oauth/dpop.go

···

       1
       1
       -
       package oauth

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"crypto/ecdsa"

     

       5
       5
       -
       	"crypto/elliptic"

     

       6
       6
       -
       	"crypto/rand"

     

       7
       7
       -
       	"crypto/sha256"

     

       8
       8
       -
       	"encoding/base64"

     

       9
       9
       -
       	"encoding/json"

     

       10
       10
       -
       	"fmt"

     

       11
       11
       -
       	"time"

     

       12
       12
       -
       

     

       13
       13
       -
       	"github.com/lestrrat-go/jwx/v2/jwa"

     

       14
       14
       -
       	"github.com/lestrrat-go/jwx/v2/jwk"

     

       15
       15
       -
       	"github.com/lestrrat-go/jwx/v2/jws"

     

       16
       16
       -
       	"github.com/lestrrat-go/jwx/v2/jwt"

     

       17
       17
       -
       )

     

       18
       18
       -
       

     

       19
       19
       -
       // DPoP (Demonstrating Proof of Possession) - RFC 9449

     

       20
       20
       -
       // Binds access tokens to specific clients using cryptographic proofs

     

       21
       21
       -
       

     

       22
       22
       -
       // GenerateDPoPKey generates a new ES256 (NIST P-256) keypair for DPoP

     

       23
       23
       -
       // Each OAuth session should have its own unique DPoP key

     

       24
       24
       -
       func GenerateDPoPKey() (jwk.Key, error) {

     

       25
       25
       -
       	// Generate ES256 private key

     

       26
       26
       -
       	privateKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)

     

       27
       27
       -
       	if err != nil {

     

       28
       28
       -
       		return nil, fmt.Errorf("failed to generate ECDSA key: %w", err)

     

       29
       29
       -
       	}

     

       30
       30
       -
       

     

       31
       31
       -
       	// Convert to JWK

     

       32
       32
       -
       	jwkKey, err := jwk.FromRaw(privateKey)

     

       33
       33
       -
       	if err != nil {

     

       34
       34
       -
       		return nil, fmt.Errorf("failed to create JWK from private key: %w", err)

     

       35
       35
       -
       	}

     

       36
       36
       -
       

     

       37
       37
       -
       	// Set JWK parameters

     

       38
       38
       -
       	if err := jwkKey.Set(jwk.AlgorithmKey, jwa.ES256); err != nil {

     

       39
       39
       -
       		return nil, fmt.Errorf("failed to set algorithm: %w", err)

     

       40
       40
       -
       	}

     

       41
       41
       -
       	if err := jwkKey.Set(jwk.KeyUsageKey, "sig"); err != nil {

     

       42
       42
       -
       		return nil, fmt.Errorf("failed to set key usage: %w", err)

     

       43
       43
       -
       	}

     

       44
       44
       -
       

     

       45
       45
       -
       	return jwkKey, nil

     

       46
       46
       -
       }

     

       47
       47
       -
       

     

       48
       48
       -
       // CreateDPoPProof creates a DPoP proof JWT for HTTP requests

     

       49
       49
       -
       // Parameters:

     

       50
       50
       -
       //   - privateKey: The DPoP private key (ES256) as JWK

     

       51
       51
       -
       //   - method: HTTP method (e.g., "POST", "GET")

     

       52
       52
       -
       //   - uri: Full HTTP URI (e.g., "https://pds.example.com/xrpc/com.atproto.server.getSession")

     

       53
       53
       -
       //   - nonce: Optional server-provided nonce (empty on first request, use nonce from 401 response on retry)

     

       54
       54
       -
       //   - accessToken: Optional access token hash (required when using access token)

     

       55
       55
       -
       func CreateDPoPProof(privateKey jwk.Key, method, uri, nonce, accessToken string) (string, error) {

     

       56
       56
       -
       	// Get public key for JWK thumbprint

     

       57
       57
       -
       	pubKey, err := privateKey.PublicKey()

     

       58
       58
       -
       	if err != nil {

     

       59
       59
       -
       		return "", fmt.Errorf("failed to get public key: %w", err)

     

       60
       60
       -
       	}

     

       61
       61
       -
       

     

       62
       62
       -
       	// Create JWT builder

     

       63
       63
       -
       	builder := jwt.NewBuilder().

     

       64
       64
       -
       		Claim("htm", method).            // HTTP method

     

       65
       65
       -
       		Claim("htu", uri).               // HTTP URI

     

       66
       66
       -
       		Claim("iat", time.Now().Unix()). // Issued at

     

       67
       67
       -
       		Claim("jti", generateJTI())      // Unique JWT ID

     

       68
       68
       -
       

     

       69
       69
       -
       	// Add nonce if provided (required after first DPoP request)

     

       70
       70
       -
       	if nonce != "" {

     

       71
       71
       -
       		builder = builder.Claim("nonce", nonce)

     

       72
       72
       -
       	}

     

       73
       73
       -
       

     

       74
       74
       -
       	// Add access token hash if provided (required when using access token)

     

       75
       75
       -
       	if accessToken != "" {

     

       76
       76
       -
       		ath := hashAccessToken(accessToken)

     

       77
       77
       -
       		builder = builder.Claim("ath", ath)

     

       78
       78
       -
       	}

     

       79
       79
       -
       

     

       80
       80
       -
       	// Build the token

     

       81
       81
       -
       	token, err := builder.Build()

     

       82
       82
       -
       	if err != nil {

     

       83
       83
       -
       		return "", fmt.Errorf("failed to build JWT: %w", err)

     

       84
       84
       -
       	}

     

       85
       85
       -
       

     

       86
       86
       -
       	// Serialize the token payload to JSON

     

       87
       87
       -
       	payloadBytes, err := json.Marshal(token)

     

       88
       88
       -
       	if err != nil {

     

       89
       89
       -
       		return "", fmt.Errorf("failed to marshal token: %w", err)

     

       90
       90
       -
       	}

     

       91
       91
       -
       

     

       92
       92
       -
       	// Create headers with DPoP-specific fields

     

       93
       93
       -
       	// RFC 9449 requires the "jwk" header to contain the public key as a JSON object

     

       94
       94
       -
       	headers := jws.NewHeaders()

     

       95
       95
       -
       	if setErr := headers.Set(jws.AlgorithmKey, jwa.ES256); setErr != nil {

     

       96
       96
       -
       		return "", fmt.Errorf("failed to set algorithm: %w", setErr)

     

       97
       97
       -
       	}

     

       98
       98
       -
       	if setErr := headers.Set(jws.TypeKey, "dpop+jwt"); setErr != nil {

     

       99
       99
       -
       		return "", fmt.Errorf("failed to set type: %w", setErr)

     

       100
       100
       -
       	}

     

       101
       101
       -
       	// Set the public JWK directly - jwx library will handle serialization

     

       102
       102
       -
       	if setErr := headers.Set(jws.JWKKey, pubKey); setErr != nil {

     

       103
       103
       -
       		return "", fmt.Errorf("failed to set JWK: %w", setErr)

     

       104
       104
       -
       	}

     

       105
       105
       -
       

     

       106
       106
       -
       	// Sign using jws.Sign to preserve custom headers

     

       107
       107
       -
       	// (jwt.Sign() overrides headers, so we use jws.Sign() directly)

     

       108
       108
       -
       	signed, err := jws.Sign(payloadBytes, jws.WithKey(jwa.ES256, privateKey, jws.WithProtectedHeaders(headers)))

     

       109
       109
       -
       	if err != nil {

     

       110
       110
       -
       		return "", fmt.Errorf("failed to sign JWT: %w", err)

     

       111
       111
       -
       	}

     

       112
       112
       -
       

     

       113
       113
       -
       	return string(signed), nil

     

       114
       114
       -
       }

     

       115
       115
       -
       

     

       116
       116
       -
       // generateJTI generates a unique JWT ID for DPoP proofs

     

       117
       117
       -
       func generateJTI() string {

     

       118
       118
       -
       	// Generate 16 random bytes

     

       119
       119
       -
       	b := make([]byte, 16)

     

       120
       120
       -
       	if _, err := rand.Read(b); err != nil {

     

       121
       121
       -
       		// Fallback to timestamp-based ID

     

       122
       122
       -
       		return fmt.Sprintf("%d", time.Now().UnixNano())

     

       123
       123
       -
       	}

     

       124
       124
       -
       	return base64.RawURLEncoding.EncodeToString(b)

     

       125
       125
       -
       }

     

       126
       126
       -
       

     

       127
       127
       -
       // hashAccessToken creates the 'ath' (access token hash) claim

     

       128
       128
       -
       // ath = base64url(SHA-256(access_token))

     

       129
       129
       -
       func hashAccessToken(accessToken string) string {

     

       130
       130
       -
       	hash := sha256.Sum256([]byte(accessToken))

     

       131
       131
       -
       	return base64.RawURLEncoding.EncodeToString(hash[:])

     

       132
       132
       -
       }

     

       133
       133
       -
       

     

       134
       134
       -
       // ParseJWKFromJSON parses a JWK from JSON bytes

     

       135
       135
       -
       func ParseJWKFromJSON(data []byte) (jwk.Key, error) {

     

       136
       136
       -
       	key, err := jwk.ParseKey(data)

     

       137
       137
       -
       	if err != nil {

     

       138
       138
       -
       		return nil, fmt.Errorf("failed to parse JWK: %w", err)

     

       139
       139
       -
       	}

     

       140
       140
       -
       	return key, nil

     

       141
       141
       -
       }

     

       142
       142
       -
       

     

       143
       143
       -
       // JWKToJSON converts a JWK to JSON bytes

     

       144
       144
       -
       func JWKToJSON(key jwk.Key) ([]byte, error) {

     

       145
       145
       -
       	data, err := json.Marshal(key)

     

       146
       146
       -
       	if err != nil {

     

       147
       147
       -
       		return nil, fmt.Errorf("failed to marshal JWK: %w", err)

     

       148
       148
       -
       	}

     

       149
       149
       -
       	return data, nil

     

       150
       150
       -
       }

     

       151
       151
       -
       

     

       152
       152
       -
       // GetPublicJWKS creates a JWKS (JSON Web Key Set) response for the public key

     

       153
       153
       -
       // This is served at /oauth/jwks.json

     

       154
       154
       -
       func GetPublicJWKS(privateKey jwk.Key) (jwk.Set, error) {

     

       155
       155
       -
       	pubKey, err := privateKey.PublicKey()

     

       156
       156
       -
       	if err != nil {

     

       157
       157
       -
       		return nil, fmt.Errorf("failed to get public key: %w", err)

     

       158
       158
       -
       	}

     

       159
       159
       -
       

     

       160
       160
       -
       	// Create JWK Set

     

       161
       161
       -
       	set := jwk.NewSet()

     

       162
       162
       -
       	if err := set.AddKey(pubKey); err != nil {

     

       163
       163
       -
       		return nil, fmt.Errorf("failed to add key to set: %w", err)

     

       164
       164
       -
       	}

     

       165
       165
       -
       

     

       166
       166
       -
       	return set, nil

     

       167
       167
       -
       }

-172

internal/atproto/oauth/dpop_test.go

···

       1
       1
       -
       package oauth

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"encoding/base64"

     

       5
       5
       -
       	"encoding/json"

     

       6
       6
       -
       	"strings"

     

       7
       7
       -
       	"testing"

     

       8
       8
       -
       )

     

       9
       9
       -
       

     

       10
       10
       -
       // TestCreateDPoPProof tests DPoP proof generation and structure

     

       11
       11
       -
       func TestCreateDPoPProof(t *testing.T) {

     

       12
       12
       -
       	// Generate a test DPoP key

     

       13
       13
       -
       	dpopKey, err := GenerateDPoPKey()

     

       14
       14
       -
       	if err != nil {

     

       15
       15
       -
       		t.Fatalf("Failed to generate DPoP key: %v", err)

     

       16
       16
       -
       	}

     

       17
       17
       -
       

     

       18
       18
       -
       	// Create a DPoP proof

     

       19
       19
       -
       	proof, err := CreateDPoPProof(dpopKey, "POST", "https://example.com/token", "", "")

     

       20
       20
       -
       	if err != nil {

     

       21
       21
       -
       		t.Fatalf("Failed to create DPoP proof: %v", err)

     

       22
       22
       -
       	}

     

       23
       23
       -
       

     

       24
       24
       -
       	// DPoP proof should be a JWT in form: header.payload.signature

     

       25
       25
       -
       	parts := strings.Split(proof, ".")

     

       26
       26
       -
       	if len(parts) != 3 {

     

       27
       27
       -
       		t.Fatalf("Expected 3 parts in JWT, got %d", len(parts))

     

       28
       28
       -
       	}

     

       29
       29
       -
       

     

       30
       30
       -
       	// Decode and inspect the header

     

       31
       31
       -
       	headerJSON, decodeErr := base64.RawURLEncoding.DecodeString(parts[0])

     

       32
       32
       -
       	if decodeErr != nil {

     

       33
       33
       -
       		t.Fatalf("Failed to decode header: %v", decodeErr)

     

       34
       34
       -
       	}

     

       35
       35
       -
       

     

       36
       36
       -
       	var header map[string]interface{}

     

       37
       37
       -
       	if unmarshalErr := json.Unmarshal(headerJSON, &header); unmarshalErr != nil {

     

       38
       38
       -
       		t.Fatalf("Failed to unmarshal header: %v", unmarshalErr)

     

       39
       39
       -
       	}

     

       40
       40
       -
       

     

       41
       41
       -
       	t.Logf("DPoP Header: %s", string(headerJSON))

     

       42
       42
       -
       

     

       43
       43
       -
       	// Verify required header fields

     

       44
       44
       -
       	if header["alg"] != "ES256" {

     

       45
       45
       -
       		t.Errorf("Expected alg=ES256, got %v", header["alg"])

     

       46
       46
       -
       	}

     

       47
       47
       -
       	if header["typ"] != "dpop+jwt" {

     

       48
       48
       -
       		t.Errorf("Expected typ=dpop+jwt, got %v", header["typ"])

     

       49
       49
       -
       	}

     

       50
       50
       -
       

     

       51
       51
       -
       	// Verify JWK is present and is a JSON object

     

       52
       52
       -
       	jwkValue, hasJWK := header["jwk"]

     

       53
       53
       -
       	if !hasJWK {

     

       54
       54
       -
       		t.Fatal("Header missing 'jwk' field")

     

       55
       55
       -
       	}

     

       56
       56
       -
       

     

       57
       57
       -
       	// JWK should be a map/object, not a string

     

       58
       58
       -
       	jwkMap, ok := jwkValue.(map[string]interface{})

     

       59
       59
       -
       	if !ok {

     

       60
       60
       -
       		t.Fatalf("JWK is not a JSON object, got type: %T, value: %v", jwkValue, jwkValue)

     

       61
       61
       -
       	}

     

       62
       62
       -
       

     

       63
       63
       -
       	// Verify JWK has required fields for EC key

     

       64
       64
       -
       	if jwkMap["kty"] != "EC" {

     

       65
       65
       -
       		t.Errorf("Expected kty=EC, got %v", jwkMap["kty"])

     

       66
       66
       -
       	}

     

       67
       67
       -
       	if jwkMap["crv"] != "P-256" {

     

       68
       68
       -
       		t.Errorf("Expected crv=P-256, got %v", jwkMap["crv"])

     

       69
       69
       -
       	}

     

       70
       70
       -
       	if _, hasX := jwkMap["x"]; !hasX {

     

       71
       71
       -
       		t.Error("JWK missing 'x' coordinate")

     

       72
       72
       -
       	}

     

       73
       73
       -
       	if _, hasY := jwkMap["y"]; !hasY {

     

       74
       74
       -
       		t.Error("JWK missing 'y' coordinate")

     

       75
       75
       -
       	}

     

       76
       76
       -
       

     

       77
       77
       -
       	// Verify private key is NOT in the public JWK

     

       78
       78
       -
       	if _, hasD := jwkMap["d"]; hasD {

     

       79
       79
       -
       		t.Error("SECURITY: JWK contains private key component 'd'!")

     

       80
       80
       -
       	}

     

       81
       81
       -
       

     

       82
       82
       -
       	// Decode and inspect the payload

     

       83
       83
       -
       	payloadJSON, err := base64.RawURLEncoding.DecodeString(parts[1])

     

       84
       84
       -
       	if err != nil {

     

       85
       85
       -
       		t.Fatalf("Failed to decode payload: %v", err)

     

       86
       86
       -
       	}

     

       87
       87
       -
       

     

       88
       88
       -
       	var payload map[string]interface{}

     

       89
       89
       -
       	if err := json.Unmarshal(payloadJSON, &payload); err != nil {

     

       90
       90
       -
       		t.Fatalf("Failed to unmarshal payload: %v", err)

     

       91
       91
       -
       	}

     

       92
       92
       -
       

     

       93
       93
       -
       	t.Logf("DPoP Payload: %s", string(payloadJSON))

     

       94
       94
       -
       

     

       95
       95
       -
       	// Verify required payload claims

     

       96
       96
       -
       	if payload["htm"] != "POST" {

     

       97
       97
       -
       		t.Errorf("Expected htm=POST, got %v", payload["htm"])

     

       98
       98
       -
       	}

     

       99
       99
       -
       	if payload["htu"] != "https://example.com/token" {

     

       100
       100
       -
       		t.Errorf("Expected htu=https://example.com/token, got %v", payload["htu"])

     

       101
       101
       -
       	}

     

       102
       102
       -
       	if _, hasIAT := payload["iat"]; !hasIAT {

     

       103
       103
       -
       		t.Error("Payload missing 'iat' (issued at)")

     

       104
       104
       -
       	}

     

       105
       105
       -
       	if _, hasJTI := payload["jti"]; !hasJTI {

     

       106
       106
       -
       		t.Error("Payload missing 'jti' (JWT ID)")

     

       107
       107
       -
       	}

     

       108
       108
       -
       }

     

       109
       109
       -
       

     

       110
       110
       -
       // TestDPoPProofWithNonce tests DPoP proof with nonce

     

       111
       111
       -
       func TestDPoPProofWithNonce(t *testing.T) {

     

       112
       112
       -
       	dpopKey, err := GenerateDPoPKey()

     

       113
       113
       -
       	if err != nil {

     

       114
       114
       -
       		t.Fatalf("Failed to generate DPoP key: %v", err)

     

       115
       115
       -
       	}

     

       116
       116
       -
       

     

       117
       117
       -
       	testNonce := "test-nonce-12345"

     

       118
       118
       -
       	proof, err := CreateDPoPProof(dpopKey, "POST", "https://example.com/token", testNonce, "")

     

       119
       119
       -
       	if err != nil {

     

       120
       120
       -
       		t.Fatalf("Failed to create DPoP proof: %v", err)

     

       121
       121
       -
       	}

     

       122
       122
       -
       

     

       123
       123
       -
       	// Decode payload

     

       124
       124
       -
       	parts := strings.Split(proof, ".")

     

       125
       125
       -
       	payloadJSON, err := base64.RawURLEncoding.DecodeString(parts[1])

     

       126
       126
       -
       	if err != nil {

     

       127
       127
       -
       		t.Fatalf("Failed to decode payload: %v", err)

     

       128
       128
       -
       	}

     

       129
       129
       -
       	var payload map[string]interface{}

     

       130
       130
       -
       	if err := json.Unmarshal(payloadJSON, &payload); err != nil {

     

       131
       131
       -
       		t.Fatalf("Failed to unmarshal payload: %v", err)

     

       132
       132
       -
       	}

     

       133
       133
       -
       

     

       134
       134
       -
       	if payload["nonce"] != testNonce {

     

       135
       135
       -
       		t.Errorf("Expected nonce=%s, got %v", testNonce, payload["nonce"])

     

       136
       136
       -
       	}

     

       137
       137
       -
       }

     

       138
       138
       -
       

     

       139
       139
       -
       // TestDPoPProofWithAccessToken tests DPoP proof with access token hash

     

       140
       140
       -
       func TestDPoPProofWithAccessToken(t *testing.T) {

     

       141
       141
       -
       	dpopKey, err := GenerateDPoPKey()

     

       142
       142
       -
       	if err != nil {

     

       143
       143
       -
       		t.Fatalf("Failed to generate DPoP key: %v", err)

     

       144
       144
       -
       	}

     

       145
       145
       -
       

     

       146
       146
       -
       	testToken := "test-access-token"

     

       147
       147
       -
       	proof, err := CreateDPoPProof(dpopKey, "GET", "https://example.com/resource", "", testToken)

     

       148
       148
       -
       	if err != nil {

     

       149
       149
       -
       		t.Fatalf("Failed to create DPoP proof: %v", err)

     

       150
       150
       -
       	}

     

       151
       151
       -
       

     

       152
       152
       -
       	// Decode payload

     

       153
       153
       -
       	parts := strings.Split(proof, ".")

     

       154
       154
       -
       	payloadJSON, err := base64.RawURLEncoding.DecodeString(parts[1])

     

       155
       155
       -
       	if err != nil {

     

       156
       156
       -
       		t.Fatalf("Failed to decode payload: %v", err)

     

       157
       157
       -
       	}

     

       158
       158
       -
       	var payload map[string]interface{}

     

       159
       159
       -
       	if err := json.Unmarshal(payloadJSON, &payload); err != nil {

     

       160
       160
       -
       		t.Fatalf("Failed to unmarshal payload: %v", err)

     

       161
       161
       -
       	}

     

       162
       162
       -
       

     

       163
       163
       -
       	ath, hasATH := payload["ath"]

     

       164
       164
       -
       	if !hasATH {

     

       165
       165
       -
       		t.Fatal("Payload missing 'ath' (access token hash)")

     

       166
       166
       -
       	}

     

       167
       167
       -
       	if ath == "" {

     

       168
       168
       -
       		t.Error("Access token hash is empty")

     

       169
       169
       -
       	}

     

       170
       170
       -
       

     

       171
       171
       -
       	t.Logf("Access token hash: %v", ath)

     

       172
       172
       -
       }

-53

internal/atproto/oauth/pkce.go

···

       1
       1
       -
       package oauth

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"crypto/rand"

     

       5
       5
       -
       	"crypto/sha256"

     

       6
       6
       -
       	"encoding/base64"

     

       7
       7
       -
       	"fmt"

     

       8
       8
       -
       )

     

       9
       9
       -
       

     

       10
       10
       -
       // PKCE (Proof Key for Code Exchange) - RFC 7636

     

       11
       11
       -
       // Prevents authorization code interception attacks

     

       12
       12
       -
       

     

       13
       13
       -
       // PKCEChallenge contains the code verifier and challenge for PKCE

     

       14
       14
       -
       type PKCEChallenge struct {

     

       15
       15
       -
       	Verifier  string // Random string (43-128 characters)

     

       16
       16
       -
       	Challenge string // Base64URL(SHA256(verifier))

     

       17
       17
       -
       	Method    string // Always "S256" for atProto

     

       18
       18
       -
       }

     

       19
       19
       -
       

     

       20
       20
       -
       // GeneratePKCEChallenge generates a new PKCE code verifier and challenge

     

       21
       21
       -
       // Uses S256 method (SHA-256 hash) as required by atProto OAuth

     

       22
       22
       -
       func GeneratePKCEChallenge() (*PKCEChallenge, error) {

     

       23
       23
       -
       	// Generate 32 random bytes (will be 43 chars when base64url encoded)

     

       24
       24
       -
       	verifierBytes := make([]byte, 32)

     

       25
       25
       -
       	if _, err := rand.Read(verifierBytes); err != nil {

     

       26
       26
       -
       		return nil, fmt.Errorf("failed to generate random bytes: %w", err)

     

       27
       27
       -
       	}

     

       28
       28
       -
       

     

       29
       29
       -
       	// Base64URL encode (no padding)

     

       30
       30
       -
       	verifier := base64.RawURLEncoding.EncodeToString(verifierBytes)

     

       31
       31
       -
       

     

       32
       32
       -
       	// Create SHA-256 hash of verifier

     

       33
       33
       -
       	hash := sha256.Sum256([]byte(verifier))

     

       34
       34
       -
       	challenge := base64.RawURLEncoding.EncodeToString(hash[:])

     

       35
       35
       -
       

     

       36
       36
       -
       	return &PKCEChallenge{

     

       37
       37
       -
       		Verifier:  verifier,

     

       38
       38
       -
       		Challenge: challenge,

     

       39
       39
       -
       		Method:    "S256",

     

       40
       40
       -
       	}, nil

     

       41
       41
       -
       }

     

       42
       42
       -
       

     

       43
       43
       -
       // GenerateState generates a random state parameter for CSRF protection

     

       44
       44
       -
       // State is used to prevent CSRF attacks in the OAuth flow

     

       45
       45
       -
       func GenerateState() (string, error) {

     

       46
       46
       -
       	// Generate 32 random bytes

     

       47
       47
       -
       	stateBytes := make([]byte, 32)

     

       48
       48
       -
       	if _, err := rand.Read(stateBytes); err != nil {

     

       49
       49
       -
       		return "", fmt.Errorf("failed to generate random state: %w", err)

     

       50
       50
       -
       	}

     

       51
       51
       -
       

     

       52
       52
       -
       	return base64.RawURLEncoding.EncodeToString(stateBytes), nil

     

       53
       53
       -
       }

-201

internal/atproto/xrpc/dpop_transport.go

···

       1
       1
       -
       package xrpc

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"Coves/internal/atproto/oauth"

     

       5
       5
       -
       	"fmt"

     

       6
       6
       -
       	"log"

     

       7
       7
       -
       	"net/http"

     

       8
       8
       -
       	"sync"

     

       9
       9
       -
       

     

       10
       10
       -
       	oauthCore "Coves/internal/core/oauth"

     

       11
       11
       -
       

     

       12
       12
       -
       	"github.com/lestrrat-go/jwx/v2/jwk"

     

       13
       13
       -
       )

     

       14
       14
       -
       

     

       15
       15
       -
       // DPoPTransport is an http.RoundTripper that automatically adds DPoP proofs to requests

     

       16
       16
       -
       // It intercepts HTTP requests and:

     

       17
       17
       -
       // 1. Adds Authorization: DPoP <access_token>

     

       18
       18
       -
       // 2. Creates and adds DPoP proof JWT

     

       19
       19
       -
       // 3. Handles nonce rotation (retries on 401 with new nonce)

     

       20
       20
       -
       // 4. Updates nonces in session store

     

       21
       21
       -
       type DPoPTransport struct {

     

       22
       22
       -
       	base         http.RoundTripper       // Underlying transport (usually http.DefaultTransport)

     

       23
       23
       -
       	session      *oauthCore.OAuthSession // User's OAuth session

     

       24
       24
       -
       	sessionStore oauthCore.SessionStore  // For updating nonces

     

       25
       25
       -
       	dpopKey      jwk.Key                 // Parsed DPoP private key

     

       26
       26
       -
       	mu           sync.Mutex              // Protects nonce updates

     

       27
       27
       -
       }

     

       28
       28
       -
       

     

       29
       29
       -
       // NewDPoPTransport creates a new DPoP-enabled HTTP transport

     

       30
       30
       -
       func NewDPoPTransport(base http.RoundTripper, session *oauthCore.OAuthSession, sessionStore oauthCore.SessionStore) (*DPoPTransport, error) {

     

       31
       31
       -
       	if base == nil {

     

       32
       32
       -
       		base = http.DefaultTransport

     

       33
       33
       -
       	}

     

       34
       34
       -
       

     

       35
       35
       -
       	// Parse DPoP private key from session

     

       36
       36
       -
       	dpopKey, err := oauth.ParseJWKFromJSON([]byte(session.DPoPPrivateJWK))

     

       37
       37
       -
       	if err != nil {

     

       38
       38
       -
       		return nil, fmt.Errorf("failed to parse DPoP key: %w", err)

     

       39
       39
       -
       	}

     

       40
       40
       -
       

     

       41
       41
       -
       	return &DPoPTransport{

     

       42
       42
       -
       		base:         base,

     

       43
       43
       -
       		session:      session,

     

       44
       44
       -
       		sessionStore: sessionStore,

     

       45
       45
       -
       		dpopKey:      dpopKey,

     

       46
       46
       -
       	}, nil

     

       47
       47
       -
       }

     

       48
       48
       -
       

     

       49
       49
       -
       // RoundTrip implements http.RoundTripper

     

       50
       50
       -
       // This is called for every HTTP request made by the client

     

       51
       51
       -
       func (t *DPoPTransport) RoundTrip(req *http.Request) (*http.Response, error) {

     

       52
       52
       -
       	// Clone the request (don't modify original)

     

       53
       53
       -
       	req = req.Clone(req.Context())

     

       54
       54
       -
       

     

       55
       55
       -
       	// Add Authorization header with DPoP-bound access token

     

       56
       56
       -
       	req.Header.Set("Authorization", "DPoP "+t.session.AccessToken)

     

       57
       57
       -
       

     

       58
       58
       -
       	// Determine which nonce to use based on the target URL

     

       59
       59
       -
       	nonce := t.getDPoPNonce(req.URL.String())

     

       60
       60
       -
       

     

       61
       61
       -
       	// Create DPoP proof for this specific request

     

       62
       62
       -
       	dpopProof, err := oauth.CreateDPoPProof(

     

       63
       63
       -
       		t.dpopKey,

     

       64
       64
       -
       		req.Method,

     

       65
       65
       -
       		req.URL.String(),

     

       66
       66
       -
       		nonce,

     

       67
       67
       -
       		t.session.AccessToken,

     

       68
       68
       -
       	)

     

       69
       69
       -
       	if err != nil {

     

       70
       70
       -
       		return nil, fmt.Errorf("failed to create DPoP proof: %w", err)

     

       71
       71
       -
       	}

     

       72
       72
       -
       

     

       73
       73
       -
       	// Add DPoP proof header

     

       74
       74
       -
       	req.Header.Set("DPoP", dpopProof)

     

       75
       75
       -
       

     

       76
       76
       -
       	// Execute the request

     

       77
       77
       -
       	resp, err := t.base.RoundTrip(req)

     

       78
       78
       -
       	if err != nil {

     

       79
       79
       -
       		return nil, err

     

       80
       80
       -
       	}

     

       81
       81
       -
       

     

       82
       82
       -
       	// Handle DPoP nonce rotation

     

       83
       83
       -
       	if resp.StatusCode == http.StatusUnauthorized {

     

       84
       84
       -
       		// Check if server provided a new nonce

     

       85
       85
       -
       		newNonce := resp.Header.Get("DPoP-Nonce")

     

       86
       86
       -
       		if newNonce != "" {

     

       87
       87
       -
       			// Update nonce and retry request once

     

       88
       88
       -
       			t.updateDPoPNonce(req.URL.String(), newNonce)

     

       89
       89
       -
       

     

       90
       90
       -
       			// Close the 401 response body

     

       91
       91
       -
       			if err := resp.Body.Close(); err != nil {

     

       92
       92
       -
       				log.Printf("Failed to close response body: %v", err)

     

       93
       93
       -
       			}

     

       94
       94
       -
       

     

       95
       95
       -
       			// Retry with new nonce

     

       96
       96
       -
       			return t.retryWithNewNonce(req, newNonce)

     

       97
       97
       -
       		}

     

       98
       98
       -
       	}

     

       99
       99
       -
       

     

       100
       100
       -
       	// Check for nonce update even on successful responses

     

       101
       101
       -
       	if newNonce := resp.Header.Get("DPoP-Nonce"); newNonce != "" {

     

       102
       102
       -
       		t.updateDPoPNonce(req.URL.String(), newNonce)

     

       103
       103
       -
       	}

     

       104
       104
       -
       

     

       105
       105
       -
       	return resp, nil

     

       106
       106
       -
       }

     

       107
       107
       -
       

     

       108
       108
       -
       // getDPoPNonce determines which DPoP nonce to use for a given URL

     

       109
       109
       -
       func (t *DPoPTransport) getDPoPNonce(url string) string {

     

       110
       110
       -
       	t.mu.Lock()

     

       111
       111
       -
       	defer t.mu.Unlock()

     

       112
       112
       -
       

     

       113
       113
       -
       	// If URL is to the PDS, use PDS nonce

     

       114
       114
       -
       	if contains(url, t.session.PDSURL) {

     

       115
       115
       -
       		return t.session.DPoPPDSNonce

     

       116
       116
       -
       	}

     

       117
       117
       -
       

     

       118
       118
       -
       	// If URL is to auth server, use auth server nonce

     

       119
       119
       -
       	if contains(url, t.session.AuthServerIss) {

     

       120
       120
       -
       		return t.session.DPoPAuthServerNonce

     

       121
       121
       -
       	}

     

       122
       122
       -
       

     

       123
       123
       -
       	// Default: no nonce (first request to this server)

     

       124
       124
       -
       	return ""

     

       125
       125
       -
       }

     

       126
       126
       -
       

     

       127
       127
       -
       // updateDPoPNonce updates the appropriate nonce based on URL

     

       128
       128
       -
       func (t *DPoPTransport) updateDPoPNonce(url, newNonce string) {

     

       129
       129
       -
       	t.mu.Lock()

     

       130
       130
       -
       

     

       131
       131
       -
       	// Read DID inside lock to avoid race condition

     

       132
       132
       -
       	did := t.session.DID

     

       133
       133
       -
       

     

       134
       134
       -
       	// Update PDS nonce

     

       135
       135
       -
       	if contains(url, t.session.PDSURL) {

     

       136
       136
       -
       		t.session.DPoPPDSNonce = newNonce

     

       137
       137
       -
       		t.mu.Unlock()

     

       138
       138
       -
       		// Persist to database (async, best-effort)

     

       139
       139
       -
       		go func() {

     

       140
       140
       -
       			if err := t.sessionStore.UpdatePDSNonce(did, newNonce); err != nil {

     

       141
       141
       -
       				log.Printf("Failed to update PDS nonce: %v", err)

     

       142
       142
       -
       			}

     

       143
       143
       -
       		}()

     

       144
       144
       -
       		return

     

       145
       145
       -
       	}

     

       146
       146
       -
       

     

       147
       147
       -
       	// Update auth server nonce

     

       148
       148
       -
       	if contains(url, t.session.AuthServerIss) {

     

       149
       149
       -
       		t.session.DPoPAuthServerNonce = newNonce

     

       150
       150
       -
       		t.mu.Unlock()

     

       151
       151
       -
       		// Persist to database (async, best-effort)

     

       152
       152
       -
       		go func() {

     

       153
       153
       -
       			if err := t.sessionStore.UpdateAuthServerNonce(did, newNonce); err != nil {

     

       154
       154
       -
       				log.Printf("Failed to update auth server nonce: %v", err)

     

       155
       155
       -
       			}

     

       156
       156
       -
       		}()

     

       157
       157
       -
       		return

     

       158
       158
       -
       	}

     

       159
       159
       -
       

     

       160
       160
       -
       	t.mu.Unlock()

     

       161
       161
       -
       }

     

       162
       162
       -
       

     

       163
       163
       -
       // retryWithNewNonce retries a request with an updated DPoP nonce

     

       164
       164
       -
       func (t *DPoPTransport) retryWithNewNonce(req *http.Request, newNonce string) (*http.Response, error) {

     

       165
       165
       -
       	// Create new DPoP proof with updated nonce

     

       166
       166
       -
       	dpopProof, err := oauth.CreateDPoPProof(

     

       167
       167
       -
       		t.dpopKey,

     

       168
       168
       -
       		req.Method,

     

       169
       169
       -
       		req.URL.String(),

     

       170
       170
       -
       		newNonce,

     

       171
       171
       -
       		t.session.AccessToken,

     

       172
       172
       -
       	)

     

       173
       173
       -
       	if err != nil {

     

       174
       174
       -
       		return nil, fmt.Errorf("failed to create DPoP proof on retry: %w", err)

     

       175
       175
       -
       	}

     

       176
       176
       -
       

     

       177
       177
       -
       	// Update DPoP header

     

       178
       178
       -
       	req.Header.Set("DPoP", dpopProof)

     

       179
       179
       -
       

     

       180
       180
       -
       	// Retry the request (only once - no infinite loops)

     

       181
       181
       -
       	return t.base.RoundTrip(req)

     

       182
       182
       -
       }

     

       183
       183
       -
       

     

       184
       184
       -
       // contains checks if haystack contains needle (case-sensitive)

     

       185
       185
       -
       func contains(haystack, needle string) bool {

     

       186
       186
       -
       	return len(haystack) >= len(needle) && haystack[:len(needle)] == needle ||

     

       187
       187
       -
       		len(haystack) > len(needle) && haystack[len(haystack)-len(needle):] == needle

     

       188
       188
       -
       }

     

       189
       189
       -
       

     

       190
       190
       -
       // AuthenticatedClient creates an HTTP client with DPoP transport

     

       191
       191
       -
       // This is what handlers use to make authenticated requests to the user's PDS

     

       192
       192
       -
       func NewAuthenticatedClient(session *oauthCore.OAuthSession, sessionStore oauthCore.SessionStore) (*http.Client, error) {

     

       193
       193
       -
       	transport, err := NewDPoPTransport(nil, session, sessionStore)

     

       194
       194
       -
       	if err != nil {

     

       195
       195
       -
       		return nil, fmt.Errorf("failed to create DPoP transport: %w", err)

     

       196
       196
       -
       	}

     

       197
       197
       -
       

     

       198
       198
       -
       	return &http.Client{

     

       199
       199
       -
       		Transport: transport,

     

       200
       200
       -
       	}, nil

     

       201
       201
       -
       }

-91

internal/core/oauth/auth_service.go

···

       1
       1
       -
       package oauth

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"Coves/internal/atproto/oauth"

     

       5
       5
       -
       	"context"

     

       6
       6
       -
       	"fmt"

     

       7
       7
       -
       	"time"

     

       8
       8
       -
       

     

       9
       9
       -
       	"github.com/lestrrat-go/jwx/v2/jwk"

     

       10
       10
       -
       )

     

       11
       11
       -
       

     

       12
       12
       -
       // AuthService handles authentication-related business logic

     

       13
       13
       -
       // Extracted from middleware to maintain clean architecture

     

       14
       14
       -
       type AuthService struct {

     

       15
       15
       -
       	sessionStore SessionStore

     

       16
       16
       -
       	oauthClient  *oauth.Client

     

       17
       17
       -
       }

     

       18
       18
       -
       

     

       19
       19
       -
       // NewAuthService creates a new authentication service

     

       20
       20
       -
       func NewAuthService(sessionStore SessionStore, oauthClient *oauth.Client) *AuthService {

     

       21
       21
       -
       	return &AuthService{

     

       22
       22
       -
       		sessionStore: sessionStore,

     

       23
       23
       -
       		oauthClient:  oauthClient,

     

       24
       24
       -
       	}

     

       25
       25
       -
       }

     

       26
       26
       -
       

     

       27
       27
       -
       // ValidateSession retrieves and validates a user's OAuth session

     

       28
       28
       -
       // Returns the session if valid, error if not found or expired

     

       29
       29
       -
       func (s *AuthService) ValidateSession(ctx context.Context, did string) (*OAuthSession, error) {

     

       30
       30
       -
       	session, err := s.sessionStore.GetSession(did)

     

       31
       31
       -
       	if err != nil {

     

       32
       32
       -
       		return nil, fmt.Errorf("session not found: %w", err)

     

       33
       33
       -
       	}

     

       34
       34
       -
       	return session, nil

     

       35
       35
       -
       }

     

       36
       36
       -
       

     

       37
       37
       -
       // RefreshTokenIfNeeded checks if token needs refresh and refreshes if necessary

     

       38
       38
       -
       // Returns updated session if refreshed, original session otherwise

     

       39
       39
       -
       func (s *AuthService) RefreshTokenIfNeeded(ctx context.Context, session *OAuthSession, threshold time.Duration) (*OAuthSession, error) {

     

       40
       40
       -
       	// Check if token needs refresh

     

       41
       41
       -
       	if time.Until(session.ExpiresAt) >= threshold {

     

       42
       42
       -
       		// Token is still valid, no refresh needed

     

       43
       43
       -
       		return session, nil

     

       44
       44
       -
       	}

     

       45
       45
       -
       

     

       46
       46
       -
       	// Parse DPoP key

     

       47
       47
       -
       	dpopKey, err := oauth.ParseJWKFromJSON([]byte(session.DPoPPrivateJWK))

     

       48
       48
       -
       	if err != nil {

     

       49
       49
       -
       		return nil, fmt.Errorf("failed to parse DPoP key: %w", err)

     

       50
       50
       -
       	}

     

       51
       51
       -
       

     

       52
       52
       -
       	// Refresh token

     

       53
       53
       -
       	tokenResp, err := s.oauthClient.RefreshTokenRequest(

     

       54
       54
       -
       		ctx,

     

       55
       55
       -
       		session.RefreshToken,

     

       56
       56
       -
       		session.AuthServerIss,

     

       57
       57
       -
       		session.DPoPAuthServerNonce,

     

       58
       58
       -
       		dpopKey,

     

       59
       59
       -
       	)

     

       60
       60
       -
       	if err != nil {

     

       61
       61
       -
       		return nil, fmt.Errorf("failed to refresh token: %w", err)

     

       62
       62
       -
       	}

     

       63
       63
       -
       

     

       64
       64
       -
       	// Update session with new tokens

     

       65
       65
       -
       	expiresAt := time.Now().Add(time.Duration(tokenResp.ExpiresIn) * time.Second)

     

       66
       66
       -
       	if err := s.sessionStore.RefreshSession(session.DID, tokenResp.AccessToken, tokenResp.RefreshToken, expiresAt); err != nil {

     

       67
       67
       -
       		return nil, fmt.Errorf("failed to update session: %w", err)

     

       68
       68
       -
       	}

     

       69
       69
       -
       

     

       70
       70
       -
       	// Update nonce if provided (best effort - non-critical)

     

       71
       71
       -
       	if tokenResp.DpopAuthserverNonce != "" {

     

       72
       72
       -
       		session.DPoPAuthServerNonce = tokenResp.DpopAuthserverNonce

     

       73
       73
       -
       		if updateErr := s.sessionStore.UpdateAuthServerNonce(session.DID, tokenResp.DpopAuthserverNonce); updateErr != nil {

     

       74
       74
       -
       			// Log but don't fail - nonce will be updated on next request

     

       75
       75
       -
       			// (We ignore the error here intentionally as nonce updates are non-critical)

     

       76
       76
       -
       			_ = updateErr

     

       77
       77
       -
       		}

     

       78
       78
       -
       	}

     

       79
       79
       -
       

     

       80
       80
       -
       	// Return updated session

     

       81
       81
       -
       	session.AccessToken = tokenResp.AccessToken

     

       82
       82
       -
       	session.RefreshToken = tokenResp.RefreshToken

     

       83
       83
       -
       	session.ExpiresAt = expiresAt

     

       84
       84
       -
       

     

       85
       85
       -
       	return session, nil

     

       86
       86
       -
       }

     

       87
       87
       -
       

     

       88
       88
       -
       // CreateDPoPKey generates a new DPoP key for a session

     

       89
       89
       -
       func (s *AuthService) CreateDPoPKey() (jwk.Key, error) {

     

       90
       90
       -
       	return oauth.GenerateDPoPKey()

     

       91
       91
       -
       }

-353

internal/core/oauth/repository.go

···

       1
       1
       -
       package oauth

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"context"

     

       5
       5
       -
       	"database/sql"

     

       6
       6
       -
       	"fmt"

     

       7
       7
       -
       	"time"

     

       8
       8
       -
       )

     

       9
       9
       -
       

     

       10
       10
       -
       // PostgresSessionStore implements SessionStore using PostgreSQL

     

       11
       11
       -
       type PostgresSessionStore struct {

     

       12
       12
       -
       	db *sql.DB

     

       13
       13
       -
       }

     

       14
       14
       -
       

     

       15
       15
       -
       // NewPostgresSessionStore creates a new PostgreSQL-backed session store

     

       16
       16
       -
       func NewPostgresSessionStore(db *sql.DB) SessionStore {

     

       17
       17
       -
       	return &PostgresSessionStore{db: db}

     

       18
       18
       -
       }

     

       19
       19
       -
       

     

       20
       20
       -
       // SaveRequest stores a temporary OAuth request state

     

       21
       21
       -
       func (s *PostgresSessionStore) SaveRequest(req *OAuthRequest) error {

     

       22
       22
       -
       	query := `

     

       23
       23
       -
       		INSERT INTO oauth_requests (

     

       24
       24
       -
       			state, did, handle, pds_url, pkce_verifier,

     

       25
       25
       -
       			dpop_private_jwk, dpop_authserver_nonce, auth_server_iss, return_url

     

       26
       26
       -
       		) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)

     

       27
       27
       -
       	`

     

       28
       28
       -
       

     

       29
       29
       -
       	_, err := s.db.Exec(

     

       30
       30
       -
       		query,

     

       31
       31
       -
       		req.State,

     

       32
       32
       -
       		req.DID,

     

       33
       33
       -
       		req.Handle,

     

       34
       34
       -
       		req.PDSURL,

     

       35
       35
       -
       		req.PKCEVerifier,

     

       36
       36
       -
       		req.DPoPPrivateJWK,

     

       37
       37
       -
       		req.DPoPAuthServerNonce,

     

       38
       38
       -
       		req.AuthServerIss,

     

       39
       39
       -
       		req.ReturnURL,

     

       40
       40
       -
       	)

     

       41
       41
       -
       	if err != nil {

     

       42
       42
       -
       		return fmt.Errorf("failed to save OAuth request: %w", err)

     

       43
       43
       -
       	}

     

       44
       44
       -
       

     

       45
       45
       -
       	return nil

     

       46
       46
       -
       }

     

       47
       47
       -
       

     

       48
       48
       -
       // GetRequestByState retrieves an OAuth request by state parameter

     

       49
       49
       -
       func (s *PostgresSessionStore) GetRequestByState(state string) (*OAuthRequest, error) {

     

       50
       50
       -
       	query := `

     

       51
       51
       -
       		SELECT

     

       52
       52
       -
       			state, did, handle, pds_url, pkce_verifier,

     

       53
       53
       -
       			dpop_private_jwk, dpop_authserver_nonce, auth_server_iss,

     

       54
       54
       -
       			COALESCE(return_url, ''), created_at

     

       55
       55
       -
       		FROM oauth_requests

     

       56
       56
       -
       		WHERE state = $1

     

       57
       57
       -
       	`

     

       58
       58
       -
       

     

       59
       59
       -
       	var req OAuthRequest

     

       60
       60
       -
       	err := s.db.QueryRow(query, state).Scan(

     

       61
       61
       -
       		&req.State,

     

       62
       62
       -
       		&req.DID,

     

       63
       63
       -
       		&req.Handle,

     

       64
       64
       -
       		&req.PDSURL,

     

       65
       65
       -
       		&req.PKCEVerifier,

     

       66
       66
       -
       		&req.DPoPPrivateJWK,

     

       67
       67
       -
       		&req.DPoPAuthServerNonce,

     

       68
       68
       -
       		&req.AuthServerIss,

     

       69
       69
       -
       		&req.ReturnURL,

     

       70
       70
       -
       		&req.CreatedAt,

     

       71
       71
       -
       	)

     

       72
       72
       -
       

     

       73
       73
       -
       	if err == sql.ErrNoRows {

     

       74
       74
       -
       		return nil, fmt.Errorf("OAuth request not found for state: %s", state)

     

       75
       75
       -
       	}

     

       76
       76
       -
       	if err != nil {

     

       77
       77
       -
       		return nil, fmt.Errorf("failed to get OAuth request: %w", err)

     

       78
       78
       -
       	}

     

       79
       79
       -
       

     

       80
       80
       -
       	return &req, nil

     

       81
       81
       -
       }

     

       82
       82
       -
       

     

       83
       83
       -
       // GetAndDeleteRequest atomically retrieves and deletes an OAuth request to prevent replay attacks

     

       84
       84
       -
       // This ensures the state parameter can only be used once

     

       85
       85
       -
       func (s *PostgresSessionStore) GetAndDeleteRequest(state string) (*OAuthRequest, error) {

     

       86
       86
       -
       	query := `

     

       87
       87
       -
       		DELETE FROM oauth_requests

     

       88
       88
       -
       		WHERE state = $1

     

       89
       89
       -
       		RETURNING

     

       90
       90
       -
       			state, did, handle, pds_url, pkce_verifier,

     

       91
       91
       -
       			dpop_private_jwk, dpop_authserver_nonce, auth_server_iss,

     

       92
       92
       -
       			COALESCE(return_url, ''), created_at

     

       93
       93
       -
       	`

     

       94
       94
       -
       

     

       95
       95
       -
       	var req OAuthRequest

     

       96
       96
       -
       	err := s.db.QueryRow(query, state).Scan(

     

       97
       97
       -
       		&req.State,

     

       98
       98
       -
       		&req.DID,

     

       99
       99
       -
       		&req.Handle,

     

       100
       100
       -
       		&req.PDSURL,

     

       101
       101
       -
       		&req.PKCEVerifier,

     

       102
       102
       -
       		&req.DPoPPrivateJWK,

     

       103
       103
       -
       		&req.DPoPAuthServerNonce,

     

       104
       104
       -
       		&req.AuthServerIss,

     

       105
       105
       -
       		&req.ReturnURL,

     

       106
       106
       -
       		&req.CreatedAt,

     

       107
       107
       -
       	)

     

       108
       108
       -
       

     

       109
       109
       -
       	if err == sql.ErrNoRows {

     

       110
       110
       -
       		return nil, fmt.Errorf("OAuth request not found or already used: %s", state)

     

       111
       111
       -
       	}

     

       112
       112
       -
       	if err != nil {

     

       113
       113
       -
       		return nil, fmt.Errorf("failed to get and delete OAuth request: %w", err)

     

       114
       114
       -
       	}

     

       115
       115
       -
       

     

       116
       116
       -
       	return &req, nil

     

       117
       117
       -
       }

     

       118
       118
       -
       

     

       119
       119
       -
       // DeleteRequest removes an OAuth request (cleanup after callback)

     

       120
       120
       -
       func (s *PostgresSessionStore) DeleteRequest(state string) error {

     

       121
       121
       -
       	query := `DELETE FROM oauth_requests WHERE state = $1`

     

       122
       122
       -
       

     

       123
       123
       -
       	_, err := s.db.Exec(query, state)

     

       124
       124
       -
       	if err != nil {

     

       125
       125
       -
       		return fmt.Errorf("failed to delete OAuth request: %w", err)

     

       126
       126
       -
       	}

     

       127
       127
       -
       

     

       128
       128
       -
       	return nil

     

       129
       129
       -
       }

     

       130
       130
       -
       

     

       131
       131
       -
       // SaveSession stores a new OAuth session (upsert on DID)

     

       132
       132
       -
       func (s *PostgresSessionStore) SaveSession(session *OAuthSession) error {

     

       133
       133
       -
       	query := `

     

       134
       134
       -
       		INSERT INTO oauth_sessions (

     

       135
       135
       -
       			did, handle, pds_url, access_token, refresh_token,

     

       136
       136
       -
       			dpop_private_jwk, dpop_authserver_nonce, dpop_pds_nonce,

     

       137
       137
       -
       			auth_server_iss, expires_at

     

       138
       138
       -
       		) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)

     

       139
       139
       -
       		ON CONFLICT (did) DO UPDATE SET

     

       140
       140
       -
       			handle = EXCLUDED.handle,

     

       141
       141
       -
       			pds_url = EXCLUDED.pds_url,

     

       142
       142
       -
       			access_token = EXCLUDED.access_token,

     

       143
       143
       -
       			refresh_token = EXCLUDED.refresh_token,

     

       144
       144
       -
       			dpop_private_jwk = EXCLUDED.dpop_private_jwk,

     

       145
       145
       -
       			dpop_authserver_nonce = EXCLUDED.dpop_authserver_nonce,

     

       146
       146
       -
       			dpop_pds_nonce = EXCLUDED.dpop_pds_nonce,

     

       147
       147
       -
       			auth_server_iss = EXCLUDED.auth_server_iss,

     

       148
       148
       -
       			expires_at = EXCLUDED.expires_at,

     

       149
       149
       -
       			updated_at = CURRENT_TIMESTAMP

     

       150
       150
       -
       	`

     

       151
       151
       -
       

     

       152
       152
       -
       	_, err := s.db.Exec(

     

       153
       153
       -
       		query,

     

       154
       154
       -
       		session.DID,

     

       155
       155
       -
       		session.Handle,

     

       156
       156
       -
       		session.PDSURL,

     

       157
       157
       -
       		session.AccessToken,

     

       158
       158
       -
       		session.RefreshToken,

     

       159
       159
       -
       		session.DPoPPrivateJWK,

     

       160
       160
       -
       		session.DPoPAuthServerNonce,

     

       161
       161
       -
       		session.DPoPPDSNonce,

     

       162
       162
       -
       		session.AuthServerIss,

     

       163
       163
       -
       		session.ExpiresAt,

     

       164
       164
       -
       	)

     

       165
       165
       -
       	if err != nil {

     

       166
       166
       -
       		return fmt.Errorf("failed to save OAuth session: %w", err)

     

       167
       167
       -
       	}

     

       168
       168
       -
       

     

       169
       169
       -
       	return nil

     

       170
       170
       -
       }

     

       171
       171
       -
       

     

       172
       172
       -
       // GetSession retrieves an OAuth session by DID

     

       173
       173
       -
       func (s *PostgresSessionStore) GetSession(did string) (*OAuthSession, error) {

     

       174
       174
       -
       	query := `

     

       175
       175
       -
       		SELECT

     

       176
       176
       -
       			did, handle, pds_url, access_token, refresh_token,

     

       177
       177
       -
       			dpop_private_jwk,

     

       178
       178
       -
       			COALESCE(dpop_authserver_nonce, ''),

     

       179
       179
       -
       			COALESCE(dpop_pds_nonce, ''),

     

       180
       180
       -
       			auth_server_iss, expires_at, created_at, updated_at

     

       181
       181
       -
       		FROM oauth_sessions

     

       182
       182
       -
       		WHERE did = $1

     

       183
       183
       -
       	`

     

       184
       184
       -
       

     

       185
       185
       -
       	var session OAuthSession

     

       186
       186
       -
       	err := s.db.QueryRow(query, did).Scan(

     

       187
       187
       -
       		&session.DID,

     

       188
       188
       -
       		&session.Handle,

     

       189
       189
       -
       		&session.PDSURL,

     

       190
       190
       -
       		&session.AccessToken,

     

       191
       191
       -
       		&session.RefreshToken,

     

       192
       192
       -
       		&session.DPoPPrivateJWK,

     

       193
       193
       -
       		&session.DPoPAuthServerNonce,

     

       194
       194
       -
       		&session.DPoPPDSNonce,

     

       195
       195
       -
       		&session.AuthServerIss,

     

       196
       196
       -
       		&session.ExpiresAt,

     

       197
       197
       -
       		&session.CreatedAt,

     

       198
       198
       -
       		&session.UpdatedAt,

     

       199
       199
       -
       	)

     

       200
       200
       -
       

     

       201
       201
       -
       	if err == sql.ErrNoRows {

     

       202
       202
       -
       		return nil, fmt.Errorf("session not found for DID: %s", did)

     

       203
       203
       -
       	}

     

       204
       204
       -
       	if err != nil {

     

       205
       205
       -
       		return nil, fmt.Errorf("failed to get OAuth session: %w", err)

     

       206
       206
       -
       	}

     

       207
       207
       -
       

     

       208
       208
       -
       	return &session, nil

     

       209
       209
       -
       }

     

       210
       210
       -
       

     

       211
       211
       -
       // UpdateSession updates an existing OAuth session

     

       212
       212
       -
       func (s *PostgresSessionStore) UpdateSession(session *OAuthSession) error {

     

       213
       213
       -
       	query := `

     

       214
       214
       -
       		UPDATE oauth_sessions SET

     

       215
       215
       -
       			handle = $2,

     

       216
       216
       -
       			pds_url = $3,

     

       217
       217
       -
       			access_token = $4,

     

       218
       218
       -
       			refresh_token = $5,

     

       219
       219
       -
       			dpop_private_jwk = $6,

     

       220
       220
       -
       			dpop_authserver_nonce = $7,

     

       221
       221
       -
       			dpop_pds_nonce = $8,

     

       222
       222
       -
       			auth_server_iss = $9,

     

       223
       223
       -
       			expires_at = $10,

     

       224
       224
       -
       			updated_at = CURRENT_TIMESTAMP

     

       225
       225
       -
       		WHERE did = $1

     

       226
       226
       -
       	`

     

       227
       227
       -
       

     

       228
       228
       -
       	result, err := s.db.Exec(

     

       229
       229
       -
       		query,

     

       230
       230
       -
       		session.DID,

     

       231
       231
       -
       		session.Handle,

     

       232
       232
       -
       		session.PDSURL,

     

       233
       233
       -
       		session.AccessToken,

     

       234
       234
       -
       		session.RefreshToken,

     

       235
       235
       -
       		session.DPoPPrivateJWK,

     

       236
       236
       -
       		session.DPoPAuthServerNonce,

     

       237
       237
       -
       		session.DPoPPDSNonce,

     

       238
       238
       -
       		session.AuthServerIss,

     

       239
       239
       -
       		session.ExpiresAt,

     

       240
       240
       -
       	)

     

       241
       241
       -
       	if err != nil {

     

       242
       242
       -
       		return fmt.Errorf("failed to update OAuth session: %w", err)

     

       243
       243
       -
       	}

     

       244
       244
       -
       

     

       245
       245
       -
       	rows, err := result.RowsAffected()

     

       246
       246
       -
       	if err != nil {

     

       247
       247
       -
       		return fmt.Errorf("failed to check rows affected: %w", err)

     

       248
       248
       -
       	}

     

       249
       249
       -
       	if rows == 0 {

     

       250
       250
       -
       		return fmt.Errorf("session not found for DID: %s", session.DID)

     

       251
       251
       -
       	}

     

       252
       252
       -
       

     

       253
       253
       -
       	return nil

     

       254
       254
       -
       }

     

       255
       255
       -
       

     

       256
       256
       -
       // DeleteSession removes an OAuth session (logout)

     

       257
       257
       -
       func (s *PostgresSessionStore) DeleteSession(did string) error {

     

       258
       258
       -
       	query := `DELETE FROM oauth_sessions WHERE did = $1`

     

       259
       259
       -
       

     

       260
       260
       -
       	_, err := s.db.Exec(query, did)

     

       261
       261
       -
       	if err != nil {

     

       262
       262
       -
       		return fmt.Errorf("failed to delete OAuth session: %w", err)

     

       263
       263
       -
       	}

     

       264
       264
       -
       

     

       265
       265
       -
       	return nil

     

       266
       266
       -
       }

     

       267
       267
       -
       

     

       268
       268
       -
       // RefreshSession updates access and refresh tokens after a token refresh

     

       269
       269
       -
       func (s *PostgresSessionStore) RefreshSession(did, newAccessToken, newRefreshToken string, expiresAt time.Time) error {

     

       270
       270
       -
       	query := `

     

       271
       271
       -
       		UPDATE oauth_sessions SET

     

       272
       272
       -
       			access_token = $2,

     

       273
       273
       -
       			refresh_token = $3,

     

       274
       274
       -
       			expires_at = $4,

     

       275
       275
       -
       			updated_at = CURRENT_TIMESTAMP

     

       276
       276
       -
       		WHERE did = $1

     

       277
       277
       -
       	`

     

       278
       278
       -
       

     

       279
       279
       -
       	result, err := s.db.Exec(query, did, newAccessToken, newRefreshToken, expiresAt)

     

       280
       280
       -
       	if err != nil {

     

       281
       281
       -
       		return fmt.Errorf("failed to refresh OAuth session: %w", err)

     

       282
       282
       -
       	}

     

       283
       283
       -
       

     

       284
       284
       -
       	rows, err := result.RowsAffected()

     

       285
       285
       -
       	if err != nil {

     

       286
       286
       -
       		return fmt.Errorf("failed to check rows affected: %w", err)

     

       287
       287
       -
       	}

     

       288
       288
       -
       	if rows == 0 {

     

       289
       289
       -
       		return fmt.Errorf("session not found for DID: %s", did)

     

       290
       290
       -
       	}

     

       291
       291
       -
       

     

       292
       292
       -
       	return nil

     

       293
       293
       -
       }

     

       294
       294
       -
       

     

       295
       295
       -
       // UpdateAuthServerNonce updates the DPoP nonce for the auth server token endpoint

     

       296
       296
       -
       func (s *PostgresSessionStore) UpdateAuthServerNonce(did, nonce string) error {

     

       297
       297
       -
       	query := `

     

       298
       298
       -
       		UPDATE oauth_sessions SET

     

       299
       299
       -
       			dpop_authserver_nonce = $2,

     

       300
       300
       -
       			updated_at = CURRENT_TIMESTAMP

     

       301
       301
       -
       		WHERE did = $1

     

       302
       302
       -
       	`

     

       303
       303
       -
       

     

       304
       304
       -
       	_, err := s.db.Exec(query, did, nonce)

     

       305
       305
       -
       	if err != nil {

     

       306
       306
       -
       		return fmt.Errorf("failed to update auth server nonce: %w", err)

     

       307
       307
       -
       	}

     

       308
       308
       -
       

     

       309
       309
       -
       	return nil

     

       310
       310
       -
       }

     

       311
       311
       -
       

     

       312
       312
       -
       // UpdatePDSNonce updates the DPoP nonce for PDS requests

     

       313
       313
       -
       func (s *PostgresSessionStore) UpdatePDSNonce(did, nonce string) error {

     

       314
       314
       -
       	query := `

     

       315
       315
       -
       		UPDATE oauth_sessions SET

     

       316
       316
       -
       			dpop_pds_nonce = $2,

     

       317
       317
       -
       			updated_at = CURRENT_TIMESTAMP

     

       318
       318
       -
       		WHERE did = $1

     

       319
       319
       -
       	`

     

       320
       320
       -
       

     

       321
       321
       -
       	_, err := s.db.Exec(query, did, nonce)

     

       322
       322
       -
       	if err != nil {

     

       323
       323
       -
       		return fmt.Errorf("failed to update PDS nonce: %w", err)

     

       324
       324
       -
       	}

     

       325
       325
       -
       

     

       326
       326
       -
       	return nil

     

       327
       327
       -
       }

     

       328
       328
       -
       

     

       329
       329
       -
       // CleanupExpiredRequests removes OAuth requests older than 30 minutes

     

       330
       330
       -
       // Should be called periodically (e.g., via cron job or background goroutine)

     

       331
       331
       -
       func (s *PostgresSessionStore) CleanupExpiredRequests(ctx context.Context) error {

     

       332
       332
       -
       	query := `DELETE FROM oauth_requests WHERE created_at < NOW() - INTERVAL '30 minutes'`

     

       333
       333
       -
       

     

       334
       334
       -
       	_, err := s.db.ExecContext(ctx, query)

     

       335
       335
       -
       	if err != nil {

     

       336
       336
       -
       		return fmt.Errorf("failed to cleanup expired requests: %w", err)

     

       337
       337
       -
       	}

     

       338
       338
       -
       

     

       339
       339
       -
       	return nil

     

       340
       340
       -
       }

     

       341
       341
       -
       

     

       342
       342
       -
       // CleanupExpiredSessions removes OAuth sessions that have been expired for > 7 days

     

       343
       343
       -
       // Gives users time to refresh their tokens before permanent deletion

     

       344
       344
       -
       func (s *PostgresSessionStore) CleanupExpiredSessions(ctx context.Context) error {

     

       345
       345
       -
       	query := `DELETE FROM oauth_sessions WHERE expires_at < NOW() - INTERVAL '7 days'`

     

       346
       346
       -
       

     

       347
       347
       -
       	_, err := s.db.ExecContext(ctx, query)

     

       348
       348
       -
       	if err != nil {

     

       349
       349
       -
       		return fmt.Errorf("failed to cleanup expired sessions: %w", err)

     

       350
       350
       -
       	}

     

       351
       351
       -
       

     

       352
       352
       -
       	return nil

     

       353
       353
       -
       }

-59

internal/core/oauth/session.go

···

       1
       1
       -
       package oauth

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"time"

     

       5
       5
       -
       )

     

       6
       6
       -
       

     

       7
       7
       -
       // OAuthRequest represents a temporary OAuth authorization flow state

     

       8
       8
       -
       // Stored during the redirect to auth server, deleted after callback

     

       9
       9
       -
       type OAuthRequest struct {

     

       10
       10
       -
       	CreatedAt           time.Time `db:"created_at"`

     

       11
       11
       -
       	State               string    `db:"state"`

     

       12
       12
       -
       	DID                 string    `db:"did"`

     

       13
       13
       -
       	Handle              string    `db:"handle"`

     

       14
       14
       -
       	PDSURL              string    `db:"pds_url"`

     

       15
       15
       -
       	PKCEVerifier        string    `db:"pkce_verifier"`

     

       16
       16
       -
       	DPoPPrivateJWK      string    `db:"dpop_private_jwk"`

     

       17
       17
       -
       	DPoPAuthServerNonce string    `db:"dpop_authserver_nonce"`

     

       18
       18
       -
       	AuthServerIss       string    `db:"auth_server_iss"`

     

       19
       19
       -
       	ReturnURL           string    `db:"return_url"`

     

       20
       20
       -
       }

     

       21
       21
       -
       

     

       22
       22
       -
       // OAuthSession represents a long-lived authenticated user session

     

       23
       23
       -
       // Stored after successful OAuth login, used for all authenticated requests

     

       24
       24
       -
       type OAuthSession struct {

     

       25
       25
       -
       	ExpiresAt           time.Time `db:"expires_at"`

     

       26
       26
       -
       	CreatedAt           time.Time `db:"created_at"`

     

       27
       27
       -
       	UpdatedAt           time.Time `db:"updated_at"`

     

       28
       28
       -
       	DID                 string    `db:"did"`

     

       29
       29
       -
       	Handle              string    `db:"handle"`

     

       30
       30
       -
       	PDSURL              string    `db:"pds_url"`

     

       31
       31
       -
       	AccessToken         string    `db:"access_token"`

     

       32
       32
       -
       	RefreshToken        string    `db:"refresh_token"`

     

       33
       33
       -
       	DPoPPrivateJWK      string    `db:"dpop_private_jwk"`

     

       34
       34
       -
       	DPoPAuthServerNonce string    `db:"dpop_authserver_nonce"`

     

       35
       35
       -
       	DPoPPDSNonce        string    `db:"dpop_pds_nonce"`

     

       36
       36
       -
       	AuthServerIss       string    `db:"auth_server_iss"`

     

       37
       37
       -
       }

     

       38
       38
       -
       

     

       39
       39
       -
       // SessionStore defines the interface for OAuth session storage

     

       40
       40
       -
       type SessionStore interface {

     

       41
       41
       -
       	// OAuth flow state management

     

       42
       42
       -
       	SaveRequest(req *OAuthRequest) error

     

       43
       43
       -
       	GetRequestByState(state string) (*OAuthRequest, error)

     

       44
       44
       -
       	GetAndDeleteRequest(state string) (*OAuthRequest, error) // Atomic get-and-delete for CSRF protection

     

       45
       45
       -
       	DeleteRequest(state string) error

     

       46
       46
       -
       

     

       47
       47
       -
       	// User session management

     

       48
       48
       -
       	SaveSession(session *OAuthSession) error

     

       49
       49
       -
       	GetSession(did string) (*OAuthSession, error)

     

       50
       50
       -
       	UpdateSession(session *OAuthSession) error

     

       51
       51
       -
       	DeleteSession(did string) error

     

       52
       52
       -
       

     

       53
       53
       -
       	// Token refresh

     

       54
       54
       -
       	RefreshSession(did, newAccessToken, newRefreshToken string, expiresAt time.Time) error

     

       55
       55
       -
       

     

       56
       56
       -
       	// Nonce updates (for DPoP)

     

       57
       57
       -
       	UpdateAuthServerNonce(did, nonce string) error

     

       58
       58
       -
       	UpdatePDSNonce(did, nonce string) error

     

       59
       59
       -
       }

-452

tests/integration/oauth_test.go

···

       1
       1
       -
       package integration

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"Coves/internal/api/handlers/oauth"

     

       5
       5
       -
       	"Coves/internal/atproto/identity"

     

       6
       6
       -
       	"bytes"

     

       7
       7
       -
       	"context"

     

       8
       8
       -
       	"encoding/json"

     

       9
       9
       -
       	"net/http"

     

       10
       10
       -
       	"net/http/httptest"

     

       11
       11
       -
       	"os"

     

       12
       12
       -
       	"testing"

     

       13
       13
       -
       

     

       14
       14
       -
       	oauthCore "Coves/internal/core/oauth"

     

       15
       15
       -
       

     

       16
       16
       -
       	"github.com/lestrrat-go/jwx/v2/jwk"

     

       17
       17
       -
       )

     

       18
       18
       -
       

     

       19
       19
       -
       // TestOAuthClientMetadata tests the /oauth/client-metadata.json endpoint

     

       20
       20
       -
       func TestOAuthClientMetadata(t *testing.T) {

     

       21
       21
       -
       	tests := []struct {

     

       22
       22
       -
       		name             string

     

       23
       23
       -
       		appviewURL       string

     

       24
       24
       -
       		expectedClientID string

     

       25
       25
       -
       		expectedJWKSURI  string

     

       26
       26
       -
       		expectedRedirect string

     

       27
       27
       -
       	}{

     

       28
       28
       -
       		{

     

       29
       29
       -
       			name:             "localhost development",

     

       30
       30
       -
       			appviewURL:       "http://localhost:8081",

     

       31
       31
       -
       			expectedClientID: "http://localhost?redirect_uri=http://localhost:8081/oauth/callback&scope=atproto%20transition:generic",

     

       32
       32
       -
       			expectedJWKSURI:  "", // No JWKS URI for localhost

     

       33
       33
       -
       			expectedRedirect: "http://localhost:8081/oauth/callback",

     

       34
       34
       -
       		},

     

       35
       35
       -
       		{

     

       36
       36
       -
       			name:             "production HTTPS",

     

       37
       37
       -
       			appviewURL:       "https://coves.social",

     

       38
       38
       -
       			expectedClientID: "https://coves.social/oauth/client-metadata.json",

     

       39
       39
       -
       			expectedJWKSURI:  "https://coves.social/oauth/jwks.json",

     

       40
       40
       -
       			expectedRedirect: "https://coves.social/oauth/callback",

     

       41
       41
       -
       		},

     

       42
       42
       -
       	}

     

       43
       43
       -
       

     

       44
       44
       -
       	for _, tt := range tests {

     

       45
       45
       -
       		t.Run(tt.name, func(t *testing.T) {

     

       46
       46
       -
       			// Set environment

     

       47
       47
       -
       			if err := os.Setenv("APPVIEW_PUBLIC_URL", tt.appviewURL); err != nil {

     

       48
       48
       -
       				t.Fatalf("Failed to set APPVIEW_PUBLIC_URL: %v", err)

     

       49
       49
       -
       			}

     

       50
       50
       -
       			defer func() {

     

       51
       51
       -
       				if err := os.Unsetenv("APPVIEW_PUBLIC_URL"); err != nil {

     

       52
       52
       -
       					t.Logf("Failed to unset APPVIEW_PUBLIC_URL: %v", err)

     

       53
       53
       -
       				}

     

       54
       54
       -
       			}()

     

       55
       55
       -
       

     

       56
       56
       -
       			// Create request

     

       57
       57
       -
       			req := httptest.NewRequest("GET", "/oauth/client-metadata.json", nil)

     

       58
       58
       -
       			w := httptest.NewRecorder()

     

       59
       59
       -
       

     

       60
       60
       -
       			// Call handler

     

       61
       61
       -
       			oauth.HandleClientMetadata(w, req)

     

       62
       62
       -
       

     

       63
       63
       -
       			// Check status code

     

       64
       64
       -
       			if w.Code != http.StatusOK {

     

       65
       65
       -
       				t.Fatalf("expected status 200, got %d", w.Code)

     

       66
       66
       -
       			}

     

       67
       67
       -
       

     

       68
       68
       -
       			// Parse response

     

       69
       69
       -
       			var metadata oauth.ClientMetadata

     

       70
       70
       -
       			if err := json.NewDecoder(w.Body).Decode(&metadata); err != nil {

     

       71
       71
       -
       				t.Fatalf("failed to decode response: %v", err)

     

       72
       72
       -
       			}

     

       73
       73
       -
       

     

       74
       74
       -
       			// Verify client ID

     

       75
       75
       -
       			if metadata.ClientID != tt.expectedClientID {

     

       76
       76
       -
       				t.Errorf("expected client_id %q, got %q", tt.expectedClientID, metadata.ClientID)

     

       77
       77
       -
       			}

     

       78
       78
       -
       

     

       79
       79
       -
       			// Verify JWKS URI

     

       80
       80
       -
       			if metadata.JwksURI != tt.expectedJWKSURI {

     

       81
       81
       -
       				t.Errorf("expected jwks_uri %q, got %q", tt.expectedJWKSURI, metadata.JwksURI)

     

       82
       82
       -
       			}

     

       83
       83
       -
       

     

       84
       84
       -
       			// Verify redirect URI

     

       85
       85
       -
       			if len(metadata.RedirectURIs) != 1 || metadata.RedirectURIs[0] != tt.expectedRedirect {

     

       86
       86
       -
       				t.Errorf("expected redirect_uris [%q], got %v", tt.expectedRedirect, metadata.RedirectURIs)

     

       87
       87
       -
       			}

     

       88
       88
       -
       

     

       89
       89
       -
       			// Verify OAuth spec compliance

     

       90
       90
       -
       			if metadata.ClientName != "Coves" {

     

       91
       91
       -
       				t.Errorf("expected client_name 'Coves', got %q", metadata.ClientName)

     

       92
       92
       -
       			}

     

       93
       93
       -
       			if metadata.TokenEndpointAuthMethod != "private_key_jwt" {

     

       94
       94
       -
       				t.Errorf("expected token_endpoint_auth_method 'private_key_jwt', got %q", metadata.TokenEndpointAuthMethod)

     

       95
       95
       -
       			}

     

       96
       96
       -
       			if metadata.TokenEndpointAuthSigningAlg != "ES256" {

     

       97
       97
       -
       				t.Errorf("expected token_endpoint_auth_signing_alg 'ES256', got %q", metadata.TokenEndpointAuthSigningAlg)

     

       98
       98
       -
       			}

     

       99
       99
       -
       			if !metadata.DpopBoundAccessTokens {

     

       100
       100
       -
       				t.Error("expected dpop_bound_access_tokens to be true")

     

       101
       101
       -
       			}

     

       102
       102
       -
       		})

     

       103
       103
       -
       	}

     

       104
       104
       -
       }

     

       105
       105
       -
       

     

       106
       106
       -
       // TestOAuthJWKS tests the /oauth/jwks.json endpoint

     

       107
       107
       -
       func TestOAuthJWKS(t *testing.T) {

     

       108
       108
       -
       	// Use the test JWK from .env.dev

     

       109
       109
       -
       	testJWK := `{"alg":"ES256","crv":"P-256","d":"9tCMceYSgyZfO5KYOCm3rWEhXLqq2l4LjP7-PJtJKyk","kid":"oauth-client-key","kty":"EC","use":"sig","x":"EOYWEgZ2d-smTO6jh0f-9B7YSFYdlrvlryjuXTCrOjE","y":"_FR2jBcWNxoJl5cd1eq9sYtAs33No9AVtd42UyyWYi4"}`

     

       110
       110
       -
       

     

       111
       111
       -
       	tests := []struct {

     

       112
       112
       -
       		name          string

     

       113
       113
       -
       		envValue      string

     

       114
       114
       -
       		expectSuccess bool

     

       115
       115
       -
       	}{

     

       116
       116
       -
       		{

     

       117
       117
       -
       			name:          "valid plain JWK",

     

       118
       118
       -
       			envValue:      testJWK,

     

       119
       119
       -
       			expectSuccess: true,

     

       120
       120
       -
       		},

     

       121
       121
       -
       		{

     

       122
       122
       -
       			name:          "missing JWK",

     

       123
       123
       -
       			envValue:      "",

     

       124
       124
       -
       			expectSuccess: false,

     

       125
       125
       -
       		},

     

       126
       126
       -
       	}

     

       127
       127
       -
       

     

       128
       128
       -
       	for _, tt := range tests {

     

       129
       129
       -
       		t.Run(tt.name, func(t *testing.T) {

     

       130
       130
       -
       			// Set environment

     

       131
       131
       -
       			if tt.envValue != "" {

     

       132
       132
       -
       				if err := os.Setenv("OAUTH_PRIVATE_JWK", tt.envValue); err != nil {

     

       133
       133
       -
       					t.Fatalf("Failed to set OAUTH_PRIVATE_JWK: %v", err)

     

       134
       134
       -
       				}

     

       135
       135
       -
       				defer func() {

     

       136
       136
       -
       					if err := os.Unsetenv("OAUTH_PRIVATE_JWK"); err != nil {

     

       137
       137
       -
       						t.Logf("Failed to unset OAUTH_PRIVATE_JWK: %v", err)

     

       138
       138
       -
       					}

     

       139
       139
       -
       				}()

     

       140
       140
       -
       			}

     

       141
       141
       -
       

     

       142
       142
       -
       			// Create request

     

       143
       143
       -
       			req := httptest.NewRequest("GET", "/oauth/jwks.json", nil)

     

       144
       144
       -
       			w := httptest.NewRecorder()

     

       145
       145
       -
       

     

       146
       146
       -
       			// Call handler

     

       147
       147
       -
       			oauth.HandleJWKS(w, req)

     

       148
       148
       -
       

     

       149
       149
       -
       			// Check status code

     

       150
       150
       -
       			if tt.expectSuccess {

     

       151
       151
       -
       				if w.Code != http.StatusOK {

     

       152
       152
       -
       					t.Fatalf("expected status 200, got %d: %s", w.Code, w.Body.String())

     

       153
       153
       -
       				}

     

       154
       154
       -
       

     

       155
       155
       -
       				// Parse response

     

       156
       156
       -
       				var jwksResp struct {

     

       157
       157
       -
       					Keys []map[string]interface{} `json:"keys"`

     

       158
       158
       -
       				}

     

       159
       159
       -
       				if err := json.NewDecoder(w.Body).Decode(&jwksResp); err != nil {

     

       160
       160
       -
       					t.Fatalf("failed to decode JWKS: %v", err)

     

       161
       161
       -
       				}

     

       162
       162
       -
       

     

       163
       163
       -
       				// Verify we got a public key

     

       164
       164
       -
       				if len(jwksResp.Keys) != 1 {

     

       165
       165
       -
       					t.Fatalf("expected 1 key, got %d", len(jwksResp.Keys))

     

       166
       166
       -
       				}

     

       167
       167
       -
       

     

       168
       168
       -
       				key := jwksResp.Keys[0]

     

       169
       169
       -
       				if key["kty"] != "EC" {

     

       170
       170
       -
       					t.Errorf("expected kty 'EC', got %v", key["kty"])

     

       171
       171
       -
       				}

     

       172
       172
       -
       				if key["alg"] != "ES256" {

     

       173
       173
       -
       					t.Errorf("expected alg 'ES256', got %v", key["alg"])

     

       174
       174
       -
       				}

     

       175
       175
       -
       				if key["kid"] != "oauth-client-key" {

     

       176
       176
       -
       					t.Errorf("expected kid 'oauth-client-key', got %v", key["kid"])

     

       177
       177
       -
       				}

     

       178
       178
       -
       

     

       179
       179
       -
       				// Verify private key is NOT exposed

     

       180
       180
       -
       				if _, hasPrivate := key["d"]; hasPrivate {

     

       181
       181
       -
       					t.Error("SECURITY: private key 'd' should not be in JWKS!")

     

       182
       182
       -
       				}

     

       183
       183
       -
       

     

       184
       184
       -
       			} else {

     

       185
       185
       -
       				if w.Code == http.StatusOK {

     

       186
       186
       -
       					t.Fatalf("expected error status, got 200")

     

       187
       187
       -
       				}

     

       188
       188
       -
       			}

     

       189
       189
       -
       		})

     

       190
       190
       -
       	}

     

       191
       191
       -
       }

     

       192
       192
       -
       

     

       193
       193
       -
       // TestOAuthLoginHandler tests the OAuth login initiation

     

       194
       194
       -
       func TestOAuthLoginHandler(t *testing.T) {

     

       195
       195
       -
       	// Skip if running in CI without database

     

       196
       196
       -
       	if os.Getenv("SKIP_INTEGRATION") == "true" {

     

       197
       197
       -
       		t.Skip("Skipping integration test")

     

       198
       198
       -
       	}

     

       199
       199
       -
       

     

       200
       200
       -
       	// Setup test database

     

       201
       201
       -
       	db := setupTestDB(t)

     

       202
       202
       -
       	defer func() {

     

       203
       203
       -
       		if err := db.Close(); err != nil {

     

       204
       204
       -
       			t.Logf("Failed to close database: %v", err)

     

       205
       205
       -
       		}

     

       206
       206
       -
       	}()

     

       207
       207
       -
       

     

       208
       208
       -
       	// Create session store

     

       209
       209
       -
       	sessionStore := oauthCore.NewPostgresSessionStore(db)

     

       210
       210
       -
       

     

       211
       211
       -
       	// Create identity resolver (mock for now - we'll test with real PDS separately)

     

       212
       212
       -
       	// For now, just test the handler structure and validation

     

       213
       213
       -
       

     

       214
       214
       -
       	tests := []struct {

     

       215
       215
       -
       		name           string

     

       216
       216
       -
       		requestBody    map[string]interface{}

     

       217
       217
       -
       		envJWK         string

     

       218
       218
       -
       		expectedStatus int

     

       219
       219
       -
       	}{

     

       220
       220
       -
       		{

     

       221
       221
       -
       			name: "missing handle",

     

       222
       222
       -
       			requestBody: map[string]interface{}{

     

       223
       223
       -
       				"handle": "",

     

       224
       224
       -
       			},

     

       225
       225
       -
       			envJWK:         `{"alg":"ES256","crv":"P-256","d":"9tCMceYSgyZfO5KYOCm3rWEhXLqq2l4LjP7-PJtJKyk","kid":"oauth-client-key","kty":"EC","use":"sig","x":"EOYWEgZ2d-smTO6jh0f-9B7YSFYdlrvlryjuXTCrOjE","y":"_FR2jBcWNxoJl5cd1eq9sYtAs33No9AVtd42UyyWYi4"}`,

     

       226
       226
       -
       			expectedStatus: http.StatusBadRequest,

     

       227
       227
       -
       		},

     

       228
       228
       -
       		{

     

       229
       229
       -
       			name: "invalid handle format",

     

       230
       230
       -
       			requestBody: map[string]interface{}{

     

       231
       231
       -
       				"handle": "no-dots-invalid",

     

       232
       232
       -
       			},

     

       233
       233
       -
       			envJWK:         `{"alg":"ES256","crv":"P-256","d":"9tCMceYSgyZfO5KYOCm3rWEhXLqq2l4LjP7-PJtJKyk","kid":"oauth-client-key","kty":"EC","use":"sig","x":"EOYWEgZ2d-smTO6jh0f-9B7YSFYdlrvlryjuXTCrOjE","y":"_FR2jBcWNxoJl5cd1eq9sYtAs33No9AVtd42UyyWYi4"}`,

     

       234
       234
       -
       			expectedStatus: http.StatusBadRequest,

     

       235
       235
       -
       		},

     

       236
       236
       -
       		{

     

       237
       237
       -
       			name: "missing OAuth JWK",

     

       238
       238
       -
       			requestBody: map[string]interface{}{

     

       239
       239
       -
       				"handle": "alice.bsky.social",

     

       240
       240
       -
       			},

     

       241
       241
       -
       			envJWK:         "",

     

       242
       242
       -
       			expectedStatus: http.StatusInternalServerError,

     

       243
       243
       -
       		},

     

       244
       244
       -
       	}

     

       245
       245
       -
       

     

       246
       246
       -
       	for _, tt := range tests {

     

       247
       247
       -
       		t.Run(tt.name, func(t *testing.T) {

     

       248
       248
       -
       			// Set environment

     

       249
       249
       -
       			if tt.envJWK != "" {

     

       250
       250
       -
       				if err := os.Setenv("OAUTH_PRIVATE_JWK", tt.envJWK); err != nil {

     

       251
       251
       -
       					t.Fatalf("Failed to set OAUTH_PRIVATE_JWK: %v", err)

     

       252
       252
       -
       				}

     

       253
       253
       -
       				defer func() {

     

       254
       254
       -
       					if err := os.Unsetenv("OAUTH_PRIVATE_JWK"); err != nil {

     

       255
       255
       -
       						t.Logf("Failed to unset OAUTH_PRIVATE_JWK: %v", err)

     

       256
       256
       -
       					}

     

       257
       257
       -
       				}()

     

       258
       258
       -
       			} else {

     

       259
       259
       -
       				if err := os.Unsetenv("OAUTH_PRIVATE_JWK"); err != nil {

     

       260
       260
       -
       					t.Logf("Failed to unset OAUTH_PRIVATE_JWK: %v", err)

     

       261
       261
       -
       				}

     

       262
       262
       -
       			}

     

       263
       263
       -
       

     

       264
       264
       -
       			// Create mock identity resolver for validation tests

     

       265
       265
       -
       			mockResolver := &mockIdentityResolver{}

     

       266
       266
       -
       

     

       267
       267
       -
       			// Create handler

     

       268
       268
       -
       			handler := oauth.NewLoginHandler(mockResolver, sessionStore)

     

       269
       269
       -
       

     

       270
       270
       -
       			// Create request

     

       271
       271
       -
       			bodyBytes, marshalErr := json.Marshal(tt.requestBody)

     

       272
       272
       -
       			if marshalErr != nil {

     

       273
       273
       -
       				t.Fatalf("Failed to marshal request body: %v", marshalErr)

     

       274
       274
       -
       			}

     

       275
       275
       -
       			req := httptest.NewRequest("POST", "/oauth/login", bytes.NewReader(bodyBytes))

     

       276
       276
       -
       			req.Header.Set("Content-Type", "application/json")

     

       277
       277
       -
       			w := httptest.NewRecorder()

     

       278
       278
       -
       

     

       279
       279
       -
       			// Call handler

     

       280
       280
       -
       			handler.HandleLogin(w, req)

     

       281
       281
       -
       

     

       282
       282
       -
       			// Check status code

     

       283
       283
       -
       			if w.Code != tt.expectedStatus {

     

       284
       284
       -
       				t.Errorf("expected status %d, got %d: %s", tt.expectedStatus, w.Code, w.Body.String())

     

       285
       285
       -
       			}

     

       286
       286
       -
       		})

     

       287
       287
       -
       	}

     

       288
       288
       -
       }

     

       289
       289
       -
       

     

       290
       290
       -
       // TestOAuthCallbackHandler tests the OAuth callback handling

     

       291
       291
       -
       func TestOAuthCallbackHandler(t *testing.T) {

     

       292
       292
       -
       	// Skip if running in CI without database

     

       293
       293
       -
       	if os.Getenv("SKIP_INTEGRATION") == "true" {

     

       294
       294
       -
       		t.Skip("Skipping integration test")

     

       295
       295
       -
       	}

     

       296
       296
       -
       

     

       297
       297
       -
       	// Setup test database

     

       298
       298
       -
       	db := setupTestDB(t)

     

       299
       299
       -
       	defer func() {

     

       300
       300
       -
       		if err := db.Close(); err != nil {

     

       301
       301
       -
       			t.Logf("Failed to close database: %v", err)

     

       302
       302
       -
       		}

     

       303
       303
       -
       	}()

     

       304
       304
       -
       

     

       305
       305
       -
       	// Create session store

     

       306
       306
       -
       	sessionStore := oauthCore.NewPostgresSessionStore(db)

     

       307
       307
       -
       

     

       308
       308
       -
       	testJWK := `{"alg":"ES256","crv":"P-256","d":"9tCMceYSgyZfO5KYOCm3rWEhXLqq2l4LjP7-PJtJKyk","kid":"oauth-client-key","kty":"EC","use":"sig","x":"EOYWEgZ2d-smTO6jh0f-9B7YSFYdlrvlryjuXTCrOjE","y":"_FR2jBcWNxoJl5cd1eq9sYtAs33No9AVtd42UyyWYi4"}`

     

       309
       309
       -
       

     

       310
       310
       -
       	tests := []struct {

     

       311
       311
       -
       		queryParams    map[string]string

     

       312
       312
       -
       		name           string

     

       313
       313
       -
       		expectedStatus int

     

       314
       314
       -
       	}{

     

       315
       315
       -
       		{

     

       316
       316
       -
       			name: "missing code",

     

       317
       317
       -
       			queryParams: map[string]string{

     

       318
       318
       -
       				"state": "test-state",

     

       319
       319
       -
       				"iss":   "https://bsky.social",

     

       320
       320
       -
       			},

     

       321
       321
       -
       			expectedStatus: http.StatusBadRequest,

     

       322
       322
       -
       		},

     

       323
       323
       -
       		{

     

       324
       324
       -
       			name: "missing state",

     

       325
       325
       -
       			queryParams: map[string]string{

     

       326
       326
       -
       				"code": "test-code",

     

       327
       327
       -
       				"iss":  "https://bsky.social",

     

       328
       328
       -
       			},

     

       329
       329
       -
       			expectedStatus: http.StatusBadRequest,

     

       330
       330
       -
       		},

     

       331
       331
       -
       		{

     

       332
       332
       -
       			name: "missing issuer",

     

       333
       333
       -
       			queryParams: map[string]string{

     

       334
       334
       -
       				"code":  "test-code",

     

       335
       335
       -
       				"state": "test-state",

     

       336
       336
       -
       			},

     

       337
       337
       -
       			expectedStatus: http.StatusBadRequest,

     

       338
       338
       -
       		},

     

       339
       339
       -
       		{

     

       340
       340
       -
       			name: "OAuth error parameter",

     

       341
       341
       -
       			queryParams: map[string]string{

     

       342
       342
       -
       				"error":             "access_denied",

     

       343
       343
       -
       				"error_description": "User denied access",

     

       344
       344
       -
       			},

     

       345
       345
       -
       			expectedStatus: http.StatusBadRequest,

     

       346
       346
       -
       		},

     

       347
       347
       -
       	}

     

       348
       348
       -
       

     

       349
       349
       -
       	for _, tt := range tests {

     

       350
       350
       -
       		t.Run(tt.name, func(t *testing.T) {

     

       351
       351
       -
       			// Set environment

     

       352
       352
       -
       			if err := os.Setenv("OAUTH_PRIVATE_JWK", testJWK); err != nil {

     

       353
       353
       -
       				t.Fatalf("Failed to set OAUTH_PRIVATE_JWK: %v", err)

     

       354
       354
       -
       			}

     

       355
       355
       -
       			defer func() {

     

       356
       356
       -
       				if err := os.Unsetenv("OAUTH_PRIVATE_JWK"); err != nil {

     

       357
       357
       -
       					t.Logf("Failed to unset OAUTH_PRIVATE_JWK: %v", err)

     

       358
       358
       -
       				}

     

       359
       359
       -
       			}()

     

       360
       360
       -
       

     

       361
       361
       -
       			// Create handler

     

       362
       362
       -
       			handler := oauth.NewCallbackHandler(sessionStore)

     

       363
       363
       -
       

     

       364
       364
       -
       			// Build query string

     

       365
       365
       -
       			req := httptest.NewRequest("GET", "/oauth/callback", nil)

     

       366
       366
       -
       			q := req.URL.Query()

     

       367
       367
       -
       			for k, v := range tt.queryParams {

     

       368
       368
       -
       				q.Add(k, v)

     

       369
       369
       -
       			}

     

       370
       370
       -
       			req.URL.RawQuery = q.Encode()

     

       371
       371
       -
       

     

       372
       372
       -
       			w := httptest.NewRecorder()

     

       373
       373
       -
       

     

       374
       374
       -
       			// Call handler

     

       375
       375
       -
       			handler.HandleCallback(w, req)

     

       376
       376
       -
       

     

       377
       377
       -
       			// Check status code

     

       378
       378
       -
       			if w.Code != tt.expectedStatus {

     

       379
       379
       -
       				t.Errorf("expected status %d, got %d: %s", tt.expectedStatus, w.Code, w.Body.String())

     

       380
       380
       -
       			}

     

       381
       381
       -
       		})

     

       382
       382
       -
       	}

     

       383
       383
       -
       }

     

       384
       384
       -
       

     

       385
       385
       -
       // mockIdentityResolver is a mock for testing

     

       386
       386
       -
       type mockIdentityResolver struct{}

     

       387
       387
       -
       

     

       388
       388
       -
       func (m *mockIdentityResolver) Resolve(ctx context.Context, identifier string) (*identity.Identity, error) {

     

       389
       389
       -
       	// Return a mock resolved identity

     

       390
       390
       -
       	return &identity.Identity{

     

       391
       391
       -
       		DID:    "did:plc:test123",

     

       392
       392
       -
       		Handle: identifier,

     

       393
       393
       -
       		PDSURL: "https://test.pds.example",

     

       394
       394
       -
       	}, nil

     

       395
       395
       -
       }

     

       396
       396
       -
       

     

       397
       397
       -
       func (m *mockIdentityResolver) ResolveHandle(ctx context.Context, handle string) (string, string, error) {

     

       398
       398
       -
       	return "did:plc:test123", "https://test.pds.example", nil

     

       399
       399
       -
       }

     

       400
       400
       -
       

     

       401
       401
       -
       func (m *mockIdentityResolver) ResolveDID(ctx context.Context, did string) (*identity.DIDDocument, error) {

     

       402
       402
       -
       	return &identity.DIDDocument{

     

       403
       403
       -
       		DID: did,

     

       404
       404
       -
       		Service: []identity.Service{

     

       405
       405
       -
       			{

     

       406
       406
       -
       				ID:              "#atproto_pds",

     

       407
       407
       -
       				Type:            "AtprotoPersonalDataServer",

     

       408
       408
       -
       				ServiceEndpoint: "https://test.pds.example",

     

       409
       409
       -
       			},

     

       410
       410
       -
       		},

     

       411
       411
       -
       	}, nil

     

       412
       412
       -
       }

     

       413
       413
       -
       

     

       414
       414
       -
       func (m *mockIdentityResolver) Purge(ctx context.Context, identifier string) error {

     

       415
       415
       -
       	return nil

     

       416
       416
       -
       }

     

       417
       417
       -
       

     

       418
       418
       -
       // TestJWKParsing tests that we can parse JWKs correctly

     

       419
       419
       -
       func TestJWKParsing(t *testing.T) {

     

       420
       420
       -
       	testJWK := `{"alg":"ES256","crv":"P-256","d":"9tCMceYSgyZfO5KYOCm3rWEhXLqq2l4LjP7-PJtJKyk","kid":"oauth-client-key","kty":"EC","use":"sig","x":"EOYWEgZ2d-smTO6jh0f-9B7YSFYdlrvlryjuXTCrOjE","y":"_FR2jBcWNxoJl5cd1eq9sYtAs33No9AVtd42UyyWYi4"}`

     

       421
       421
       -
       

     

       422
       422
       -
       	// Parse the JWK

     

       423
       423
       -
       	key, err := jwk.ParseKey([]byte(testJWK))

     

       424
       424
       -
       	if err != nil {

     

       425
       425
       -
       		t.Fatalf("failed to parse JWK: %v", err)

     

       426
       426
       -
       	}

     

       427
       427
       -
       

     

       428
       428
       -
       	// Verify it's an EC key

     

       429
       429
       -
       	if key.KeyType() != "EC" {

     

       430
       430
       -
       		t.Errorf("expected key type 'EC', got %v", key.KeyType())

     

       431
       431
       -
       	}

     

       432
       432
       -
       

     

       433
       433
       -
       	// Verify we can get the public key

     

       434
       434
       -
       	pubKey, err := key.PublicKey()

     

       435
       435
       -
       	if err != nil {

     

       436
       436
       -
       		t.Fatalf("failed to get public key: %v", err)

     

       437
       437
       -
       	}

     

       438
       438
       -
       

     

       439
       439
       -
       	// Verify public key doesn't have private component

     

       440
       440
       -
       	pubKeyJSON, marshalErr := json.Marshal(pubKey)

     

       441
       441
       -
       	if marshalErr != nil {

     

       442
       442
       -
       		t.Fatalf("failed to marshal public key: %v", marshalErr)

     

       443
       443
       -
       	}

     

       444
       444
       -
       	var pubKeyMap map[string]interface{}

     

       445
       445
       -
       	if unmarshalErr := json.Unmarshal(pubKeyJSON, &pubKeyMap); unmarshalErr != nil {

     

       446
       446
       -
       		t.Fatalf("failed to unmarshal public key: %v", unmarshalErr)

     

       447
       447
       -
       	}

     

       448
       448
       -
       

     

       449
       449
       -
       	if _, hasPrivate := pubKeyMap["d"]; hasPrivate {

     

       450
       450
       -
       		t.Error("SECURITY: public key should not contain private 'd' component!")

     

       451
       451
       -
       	}

     

       452
       452
       -
       }