commit 64923a4e46499945c59c5653c8c7c267af2566fc · bretton.dev/coves

+4 -1

internal/atproto/auth/jwt.go

···

       87
       87
        
       // Claims represents the standard JWT claims we care about

     

       88
       88
        
       type Claims struct {

     

       89
       89
        
       	jwt.RegisteredClaims

     

       90
       90
       -
       	Scope string `json:"scope,omitempty"`

     

       90
       90
       +
       	// Confirmation claim for DPoP token binding (RFC 9449)

     

       91
       91
       +
       	// Contains "jkt" (JWK thumbprint) when token is bound to a DPoP key

     

       92
       92
       +
       	Confirmation map[string]interface{} `json:"cnf,omitempty"`

     

       93
       93
       +
       	Scope        string                 `json:"scope,omitempty"`

     

       91
       94
        
       }

     

       92
       95
        
       

     

       93
       96
        
       // stripBearerPrefix removes the "Bearer " prefix from a token string

+32 -73

internal/atproto/auth/jwt_test.go

···

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
        
       	"context"

     

       5
       5
       -
       	"os"

     

       6
       5
        
       	"testing"

     

       7
       6
        
       	"time"

     

       8
       7
        
       

     
···

       208
       207
        
       	issuer := "https://pds.coves.social"

     

       209
       208
        
       

     

       210
       209
        
       	ResetJWTConfigForTesting()

     

       211
       211
       -
       	os.Setenv("PDS_JWT_SECRET", secret)

     

       212
       212
       -
       	os.Setenv("HS256_ISSUERS", issuer)

     

       213
       213
       -
       	defer func() {

     

       214
       214
       -
       		os.Unsetenv("PDS_JWT_SECRET")

     

       215
       215
       -
       		os.Unsetenv("HS256_ISSUERS")

     

       216
       216
       -
       		ResetJWTConfigForTesting()

     

       217
       217
       -
       	}()

     

       210
       210
       +
       	t.Setenv("PDS_JWT_SECRET", secret)

     

       211
       211
       +
       	t.Setenv("HS256_ISSUERS", issuer)

     

       212
       212
       +
       	t.Cleanup(ResetJWTConfigForTesting)

     

       218
       213
        
       

     

       219
       214
        
       	tokenString := createHS256Token(t, "did:plc:test123", issuer, secret, 1*time.Hour)

     

       220
       215
        
       

     
···

       237
       232
        
       	issuer := "https://pds.coves.social"

     

       238
       233
        
       

     

       239
       234
        
       	ResetJWTConfigForTesting()

     

       240
       240
       -
       	os.Setenv("PDS_JWT_SECRET", "correct-secret")

     

       241
       241
       -
       	os.Setenv("HS256_ISSUERS", issuer)

     

       242
       242
       -
       	defer func() {

     

       243
       243
       -
       		os.Unsetenv("PDS_JWT_SECRET")

     

       244
       244
       -
       		os.Unsetenv("HS256_ISSUERS")

     

       245
       245
       -
       		ResetJWTConfigForTesting()

     

       246
       246
       -
       	}()

     

       235
       235
       +
       	t.Setenv("PDS_JWT_SECRET", "correct-secret")

     

       236
       236
       +
       	t.Setenv("HS256_ISSUERS", issuer)

     

       237
       237
       +
       	t.Cleanup(ResetJWTConfigForTesting)

     

       247
       238
        
       

     

       248
       239
        
       	// Create token with wrong secret

     

       249
       240
        
       	tokenString := createHS256Token(t, "did:plc:test123", issuer, "wrong-secret", 1*time.Hour)

     
···

       260
       251
        
       	issuer := "https://pds.coves.social"

     

       261
       252
        
       

     

       262
       253
        
       	ResetJWTConfigForTesting()

     

       263
       263
       -
       	os.Unsetenv("PDS_JWT_SECRET") // Ensure secret is not set

     

       264
       264
       -
       	os.Setenv("HS256_ISSUERS", issuer)

     

       265
       265
       -
       	defer func() {

     

       266
       266
       -
       		os.Unsetenv("HS256_ISSUERS")

     

       267
       267
       -
       		ResetJWTConfigForTesting()

     

       268
       268
       -
       	}()

     

       254
       254
       +
       	t.Setenv("PDS_JWT_SECRET", "") // Ensure secret is not set (empty = not configured)

     

       255
       255
       +
       	t.Setenv("HS256_ISSUERS", issuer)

     

       256
       256
       +
       	t.Cleanup(ResetJWTConfigForTesting)

     

       269
       257
        
       

     

       270
       258
        
       	tokenString := createHS256Token(t, "did:plc:test123", issuer, "any-secret", 1*time.Hour)

     

       271
       259
        
       

     
···

       286
       274
        
       	// An attacker tries to use HS256 with an issuer that should use RS256/ES256

     

       287
       275
        
       

     

       288
       276
        
       	ResetJWTConfigForTesting()

     

       289
       289
       -
       	os.Setenv("PDS_JWT_SECRET", "some-secret")

     

       290
       290
       -
       	os.Setenv("HS256_ISSUERS", "https://trusted.example.com") // Different from token issuer

     

       291
       291
       -
       	defer func() {

     

       292
       292
       -
       		os.Unsetenv("PDS_JWT_SECRET")

     

       293
       293
       -
       		os.Unsetenv("HS256_ISSUERS")

     

       294
       294
       -
       		ResetJWTConfigForTesting()

     

       295
       295
       -
       	}()

     

       277
       277
       +
       	t.Setenv("PDS_JWT_SECRET", "some-secret")

     

       278
       278
       +
       	t.Setenv("HS256_ISSUERS", "https://trusted.example.com") // Different from token issuer

     

       279
       279
       +
       	t.Cleanup(ResetJWTConfigForTesting)

     

       296
       280
        
       

     

       297
       281
        
       	// Create HS256 token with non-whitelisted issuer (simulating attack)

     

       298
       282
        
       	tokenString := createHS256Token(t, "did:plc:attacker", "https://victim-pds.example.com", "some-secret", 1*time.Hour)

     
···

       311
       295
        
       	// SECURITY TEST: When no issuers are whitelisted for HS256, all HS256 tokens should be rejected

     

       312
       296
        
       

     

       313
       297
        
       	ResetJWTConfigForTesting()

     

       314
       314
       -
       	os.Setenv("PDS_JWT_SECRET", "some-secret")

     

       315
       315
       -
       	os.Unsetenv("HS256_ISSUERS") // Empty whitelist

     

       316
       316
       -
       	defer func() {

     

       317
       317
       -
       		os.Unsetenv("PDS_JWT_SECRET")

     

       318
       318
       -
       		ResetJWTConfigForTesting()

     

       319
       319
       -
       	}()

     

       298
       298
       +
       	t.Setenv("PDS_JWT_SECRET", "some-secret")

     

       299
       299
       +
       	t.Setenv("HS256_ISSUERS", "") // Empty whitelist

     

       300
       300
       +
       	t.Cleanup(ResetJWTConfigForTesting)

     

       320
       301
        
       

     

       321
       302
        
       	tokenString := createHS256Token(t, "did:plc:test123", "https://any-pds.example.com", "some-secret", 1*time.Hour)

     

       322
       303
        
       

     
···

       332
       313
        
       	issuer := "https://pds.coves.social"

     

       333
       314
        
       

     

       334
       315
        
       	ResetJWTConfigForTesting()

     

       335
       335
       -
       	os.Setenv("PDS_JWT_SECRET", "test-secret")

     

       336
       336
       -
       	os.Setenv("HS256_ISSUERS", issuer)

     

       337
       337
       -
       	defer func() {

     

       338
       338
       -
       		os.Unsetenv("PDS_JWT_SECRET")

     

       339
       339
       -
       		os.Unsetenv("HS256_ISSUERS")

     

       340
       340
       -
       		ResetJWTConfigForTesting()

     

       341
       341
       -
       	}()

     

       316
       316
       +
       	t.Setenv("PDS_JWT_SECRET", "test-secret")

     

       317
       317
       +
       	t.Setenv("HS256_ISSUERS", issuer)

     

       318
       318
       +
       	t.Cleanup(ResetJWTConfigForTesting)

     

       342
       319
        
       

     

       343
       320
        
       	// Create RS256-signed token (can't actually sign without RSA key, but we can test the header check)

     

       344
       321
        
       	claims := &Claims{

     
···

       414
       391
        
       

     

       415
       392
        
       func TestIsHS256IssuerWhitelisted_Whitelisted(t *testing.T) {

     

       416
       393
        
       	ResetJWTConfigForTesting()

     

       417
       417
       -
       	os.Setenv("HS256_ISSUERS", "https://pds1.example.com,https://pds2.example.com")

     

       418
       418
       -
       	defer func() {

     

       419
       419
       -
       		os.Unsetenv("HS256_ISSUERS")

     

       420
       420
       -
       		ResetJWTConfigForTesting()

     

       421
       421
       -
       	}()

     

       394
       394
       +
       	t.Setenv("HS256_ISSUERS", "https://pds1.example.com,https://pds2.example.com")

     

       395
       395
       +
       	t.Cleanup(ResetJWTConfigForTesting)

     

       422
       396
        
       

     

       423
       397
        
       	if !isHS256IssuerWhitelisted("https://pds1.example.com") {

     

       424
       398
        
       		t.Error("Expected pds1 to be whitelisted")

     
···

       430
       404
        
       

     

       431
       405
        
       func TestIsHS256IssuerWhitelisted_NotWhitelisted(t *testing.T) {

     

       432
       406
        
       	ResetJWTConfigForTesting()

     

       433
       433
       -
       	os.Setenv("HS256_ISSUERS", "https://pds1.example.com")

     

       434
       434
       -
       	defer func() {

     

       435
       435
       -
       		os.Unsetenv("HS256_ISSUERS")

     

       436
       436
       -
       		ResetJWTConfigForTesting()

     

       437
       437
       -
       	}()

     

       407
       407
       +
       	t.Setenv("HS256_ISSUERS", "https://pds1.example.com")

     

       408
       408
       +
       	t.Cleanup(ResetJWTConfigForTesting)

     

       438
       409
        
       

     

       439
       410
        
       	if isHS256IssuerWhitelisted("https://attacker.example.com") {

     

       440
       411
        
       		t.Error("Expected non-whitelisted issuer to return false")

     
···

       443
       414
        
       

     

       444
       415
        
       func TestIsHS256IssuerWhitelisted_EmptyWhitelist(t *testing.T) {

     

       445
       416
        
       	ResetJWTConfigForTesting()

     

       446
       446
       -
       	os.Unsetenv("HS256_ISSUERS")

     

       447
       447
       -
       	defer ResetJWTConfigForTesting()

     

       417
       417
       +
       	t.Setenv("HS256_ISSUERS", "") // Empty whitelist

     

       418
       418
       +
       	t.Cleanup(ResetJWTConfigForTesting)

     

       448
       419
        
       

     

       449
       420
        
       	if isHS256IssuerWhitelisted("https://any.example.com") {

     

       450
       421
        
       		t.Error("Expected false when whitelist is empty (safe default)")

     
···

       453
       424
        
       

     

       454
       425
        
       func TestIsHS256IssuerWhitelisted_WhitespaceHandling(t *testing.T) {

     

       455
       426
        
       	ResetJWTConfigForTesting()

     

       456
       456
       -
       	os.Setenv("HS256_ISSUERS", "  https://pds1.example.com  ,  https://pds2.example.com  ")

     

       457
       457
       -
       	defer func() {

     

       458
       458
       -
       		os.Unsetenv("HS256_ISSUERS")

     

       459
       459
       -
       		ResetJWTConfigForTesting()

     

       460
       460
       -
       	}()

     

       427
       427
       +
       	t.Setenv("HS256_ISSUERS", "  https://pds1.example.com  ,  https://pds2.example.com  ")

     

       428
       428
       +
       	t.Cleanup(ResetJWTConfigForTesting)

     

       461
       429
        
       

     

       462
       430
        
       	if !isHS256IssuerWhitelisted("https://pds1.example.com") {

     

       463
       431
        
       		t.Error("Expected whitespace-trimmed issuer to be whitelisted")

     
···

       469
       437
        
       func TestShouldUseHS256_WithKid_AlwaysFalse(t *testing.T) {

     

       470
       438
        
       	// Tokens with kid should NEVER use HS256, regardless of issuer whitelist

     

       471
       439
        
       	ResetJWTConfigForTesting()

     

       472
       472
       -
       	os.Setenv("HS256_ISSUERS", "https://whitelisted.example.com")

     

       473
       473
       -
       	defer func() {

     

       474
       474
       -
       		os.Unsetenv("HS256_ISSUERS")

     

       475
       475
       -
       		ResetJWTConfigForTesting()

     

       476
       476
       -
       	}()

     

       440
       440
       +
       	t.Setenv("HS256_ISSUERS", "https://whitelisted.example.com")

     

       441
       441
       +
       	t.Cleanup(ResetJWTConfigForTesting)

     

       477
       442
        
       

     

       478
       443
        
       	header := &JWTHeader{

     

       479
       444
        
       		Alg: AlgorithmHS256,

     
···

       488
       453
        
       

     

       489
       454
        
       func TestShouldUseHS256_WithoutKid_WhitelistedIssuer(t *testing.T) {

     

       490
       455
        
       	ResetJWTConfigForTesting()

     

       491
       491
       -
       	os.Setenv("HS256_ISSUERS", "https://my-pds.example.com")

     

       492
       492
       -
       	defer func() {

     

       493
       493
       -
       		os.Unsetenv("HS256_ISSUERS")

     

       494
       494
       -
       		ResetJWTConfigForTesting()

     

       495
       495
       -
       	}()

     

       456
       456
       +
       	t.Setenv("HS256_ISSUERS", "https://my-pds.example.com")

     

       457
       457
       +
       	t.Cleanup(ResetJWTConfigForTesting)

     

       496
       458
        
       

     

       497
       459
        
       	header := &JWTHeader{

     

       498
       460
        
       		Alg: AlgorithmHS256,

     
···

       506
       468
        
       

     

       507
       469
        
       func TestShouldUseHS256_WithoutKid_NotWhitelisted(t *testing.T) {

     

       508
       470
        
       	ResetJWTConfigForTesting()

     

       509
       509
       -
       	os.Setenv("HS256_ISSUERS", "https://my-pds.example.com")

     

       510
       510
       -
       	defer func() {

     

       511
       511
       -
       		os.Unsetenv("HS256_ISSUERS")

     

       512
       512
       -
       		ResetJWTConfigForTesting()

     

       513
       513
       -
       	}()

     

       471
       471
       +
       	t.Setenv("HS256_ISSUERS", "https://my-pds.example.com")

     

       472
       472
       +
       	t.Cleanup(ResetJWTConfigForTesting)

     

       514
       473
        
       

     

       515
       474
        
       	header := &JWTHeader{

     

       516
       475
        
       		Alg: AlgorithmHS256,