Share more code between DNS and HTTP auth flows (#552)

<!-- Provide a brief summary of your changes -->

## Motivation and Context

Currently the `dns` and `http` based auth flows share code well in the
publisher tool. However there is a lot of duplication in the auth
endpoint. This on it's own is not a problem but it does make
enhancements to the proof record (the `v=MCPv1; ...` string) harder to
keep in sync.

This PR adds a `common.go` file to share logic between the two.

This supports work I am prototyping for
https://github.com/modelcontextprotocol/registry/issues/482.

## How Has This Been Tested?

Added new test cases for the permissions. Ran them before and after the
refactoring to ensure no behavior change.
Ran existing UTs.
Ran the integration tests.
Manually exercised the flows locally.

## Breaking Changes

None.

## Types of changes
<!-- What types of changes does your code introduce? Put an `x` in all
the boxes that apply: -->
- [ ] Bug fix (non-breaking change which fixes an issue)
- [x] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would cause existing
functionality to change)
- [ ] Documentation update

## Checklist
<!-- Go over all the following points, and put an `x` in all the boxes
that apply. -->
- [x] I have read the [MCP
Documentation](https://modelcontextprotocol.io)
- [x] My code follows the repository's style guidelines
- [x] New and existing tests pass locally
- [x] I have added appropriate error handling
- [ ] I have added or updated documentation as needed

## Additional context
<!-- Add any other context, implementation notes, or design decisions
-->
This commit is contained in:
Joel Verhagen 2025-09-29 18:43:27 -04:00 • committed by GitHub
commit df018fc43b
No known key found for this signature in database
GPG key ID: B5690EEEBB952194

View file

@ -43,6 +43,8 @@ func newClientForTLSServer(t *testing.T, srv *httptest.Server) *http.Client {
return &http.Client{Transport: transport, Timeout: 10 * time.Second}
}
const testDomain = "example.com"
// MockHTTPKeyFetcher for testing
type MockHTTPKeyFetcher struct {
keyResponses map[string]string
@ -70,7 +72,7 @@ func TestHTTPAuthHandler_ExchangeToken(t *testing.T) {
publicKeyB64 := base64.StdEncoding.EncodeToString(publicKey)
mockFetcher := &MockHTTPKeyFetcher{
keyResponses: map[string]string{
"example.com": fmt.Sprintf("v=MCPv1; k=ed25519; p=%s", publicKeyB64),
testDomain: fmt.Sprintf("v=MCPv1; k=ed25519; p=%s", publicKeyB64),
},
}
handler.SetFetcher(mockFetcher)
@ -86,7 +88,7 @@ func TestHTTPAuthHandler_ExchangeToken(t *testing.T) {
}{
{
name: "successful authentication",
domain: "example.com",
domain: testDomain,
timestamp: time.Now().UTC().Format(time.RFC3339),
setupMock: func(_ *MockHTTPKeyFetcher) {
// Mock is already set up with valid key
@ -102,28 +104,28 @@ func TestHTTPAuthHandler_ExchangeToken(t *testing.T) {
},
{
name: "invalid timestamp format",
domain: "example.com",
domain: testDomain,
timestamp: "invalid-timestamp",
expectError: true,
errorContains: "invalid timestamp format",
},
{
name: "timestamp too old",
domain: "example.com",
domain: testDomain,
timestamp: time.Now().Add(-30 * time.Second).UTC().Format(time.RFC3339),
expectError: true,
errorContains: "timestamp outside valid window",
},
{
name: "timestamp too far in the future",
domain: "example.com",
domain: testDomain,
timestamp: time.Now().Add(30 * time.Second).UTC().Format(time.RFC3339),
expectError: true,
errorContains: "timestamp outside valid window",
},
{
name: "invalid signature format",
domain: "example.com",
domain: testDomain,
timestamp: time.Now().UTC().Format(time.RFC3339),
signedTimestamp: "invalid-hex",
expectError: true,
@ -131,7 +133,7 @@ func TestHTTPAuthHandler_ExchangeToken(t *testing.T) {
},
{
name: "signature wrong length",
domain: "example.com",
domain: testDomain,
timestamp: time.Now().UTC().Format(time.RFC3339),
signedTimestamp: "abcdef", // too short
expectError: true,
@ -156,7 +158,7 @@ func TestHTTPAuthHandler_ExchangeToken(t *testing.T) {
m.err = nil
},
expectError: true,
errorContains: "invalid key format",
errorContains: "failed to parse public key",
},
{
name: "invalid base64 key",
@ -167,7 +169,7 @@ func TestHTTPAuthHandler_ExchangeToken(t *testing.T) {
m.err = nil
},
expectError: true,
errorContains: "failed to decode base64 public key",
errorContains: "failed to parse public key",
},
{
name: "wrong key size",
@ -180,18 +182,18 @@ func TestHTTPAuthHandler_ExchangeToken(t *testing.T) {
m.err = nil
},
expectError: true,
errorContains: "invalid public key length",
errorContains: "failed to parse public key",
},
{
name: "signature verification failure",
domain: "example.com",
domain: testDomain,
timestamp: time.Now().UTC().Format(time.RFC3339),
setupMock: func(m *MockHTTPKeyFetcher) {
// Generate different key pair for signature verification failure
wrongPublicKey, _, err := ed25519.GenerateKey(nil)
require.NoError(t, err)
wrongPublicKeyB64 := base64.StdEncoding.EncodeToString(wrongPublicKey)
m.keyResponses["example.com"] = fmt.Sprintf("v=MCPv1; k=ed25519; p=%s", wrongPublicKeyB64)
m.keyResponses[testDomain] = fmt.Sprintf("v=MCPv1; k=ed25519; p=%s", wrongPublicKeyB64)
m.err = nil
},
expectError: true,
@ -384,3 +386,356 @@ func TestDefaultHTTPKeyFetcher(t *testing.T) {
})
}
}
func TestHTTPAuthHandler_Permissions(t *testing.T) {
cfg := &config.Config{
JWTPrivateKey: "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
}
handler := auth.NewHTTPAuthHandler(cfg)
jwtManager := intauth.NewJWTManager(cfg)
// Generate a test key pair
publicKey, privateKey, err := ed25519.GenerateKey(nil)
require.NoError(t, err)
publicKeyB64 := base64.StdEncoding.EncodeToString(publicKey)
tests := []struct {
name string
domain string
expectedPatterns []string
unexpectedPatterns []string
}{
{
name: "simple domain",
domain: testDomain,
expectedPatterns: []string{
"com.example/*", // exact domain pattern only (HTTP does not include subdomains)
},
unexpectedPatterns: []string{
"com.example.*", // HTTP should not grant subdomain permissions
"example.com/*", // should be reversed
"*.com.example", // wrong wildcard position
},
},
{
name: "subdomain",
domain: "api.example.com",
expectedPatterns: []string{
"com.example.api/*", // exact subdomain pattern only
},
unexpectedPatterns: []string{
"com.example.api.*", // HTTP should not grant subdomain permissions
"com.example/*", // parent domain should not be included
"api.example.com/*", // should be reversed
},
},
{
name: "multi-level subdomain",
domain: "v1.api.example.com",
expectedPatterns: []string{
"com.example.api.v1/*", // exact pattern only
},
unexpectedPatterns: []string{
"com.example.api.v1.*", // HTTP should not grant subdomain permissions
"com.example/*", // parent domain should not be included
"com.example.api/*", // intermediate domain should not be included
"v1.api.example.com/*", // should be reversed
},
},
{
name: "single part domain",
domain: "localhost",
expectedPatterns: []string{
"localhost/*", // exact pattern only (no reversal needed)
},
unexpectedPatterns: []string{
"localhost.*", // HTTP should not grant subdomain permissions
"*.localhost", // wrong wildcard position
},
},
{
name: "hyphenated domain",
domain: "my-app.example-site.com",
expectedPatterns: []string{
"com.example-site.my-app/*", // exact pattern only
},
unexpectedPatterns: []string{
"com.example-site.my-app.*", // HTTP should not grant subdomain permissions
"my-app.example-site.com/*", // should be reversed
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Set up mock fetcher
mockFetcher := &MockHTTPKeyFetcher{
keyResponses: map[string]string{
tt.domain: fmt.Sprintf("v=MCPv1; k=ed25519; p=%s", publicKeyB64),
},
}
handler.SetFetcher(mockFetcher)
// Generate signature
timestamp := time.Now().UTC().Format(time.RFC3339)
signature := ed25519.Sign(privateKey, []byte(timestamp))
signedTimestamp := hex.EncodeToString(signature)
// Exchange token
result, err := handler.ExchangeToken(context.Background(), tt.domain, timestamp, signedTimestamp)
require.NoError(t, err)
require.NotNil(t, result)
// Validate JWT token
claims, err := jwtManager.ValidateToken(context.Background(), result.RegistryToken)
require.NoError(t, err)
// Verify claims structure
assert.Equal(t, intauth.MethodHTTP, claims.AuthMethod)
assert.Equal(t, tt.domain, claims.AuthMethodSubject)
assert.Len(t, claims.Permissions, 1) // HTTP only grants exact domain permissions
// Extract permission patterns
patterns := make([]string, len(claims.Permissions))
for i, perm := range claims.Permissions {
patterns[i] = perm.ResourcePattern
// All permissions should be for publish action
assert.Equal(t, intauth.PermissionActionPublish, perm.Action)
}
// Check expected patterns are present
for _, expectedPattern := range tt.expectedPatterns {
assert.Contains(t, patterns, expectedPattern, "Expected pattern %s not found", expectedPattern)
}
// Check unexpected patterns are not present
for _, unexpectedPattern := range tt.unexpectedPatterns {
assert.NotContains(t, patterns, unexpectedPattern, "Unexpected pattern %s found", unexpectedPattern)
}
// Verify the permission patterns work correctly with the JWT manager's HasPermission method
for _, expectedPattern := range tt.expectedPatterns {
// Find the permission with this pattern
var foundPerm *intauth.Permission
for _, perm := range claims.Permissions {
if perm.ResourcePattern == expectedPattern {
foundPerm = &perm
break
}
}
require.NotNil(t, foundPerm, "Permission with pattern %s not found", expectedPattern)
// Test resource scenarios - only exact domain should work for HTTP
if strings.HasSuffix(expectedPattern, "/*") {
// Exact domain permissions (e.g., "com.example/*")
basePattern := strings.TrimSuffix(expectedPattern, "/*")
testResource := basePattern + "/my-package"
assert.True(t, jwtManager.HasPermission(testResource, intauth.PermissionActionPublish, claims.Permissions),
"Should have permission for %s with pattern %s", testResource, expectedPattern)
// Test that subdomain resources are NOT allowed for HTTP
subdomainResource := basePattern + ".subdomain/my-package"
assert.False(t, jwtManager.HasPermission(subdomainResource, intauth.PermissionActionPublish, claims.Permissions),
"Should NOT have permission for subdomain %s with HTTP auth", subdomainResource)
}
}
})
}
}
func TestHTTPAuthHandler_PermissionValidation(t *testing.T) {
cfg := &config.Config{
JWTPrivateKey: "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
}
handler := auth.NewHTTPAuthHandler(cfg)
jwtManager := intauth.NewJWTManager(cfg)
// Generate a test key pair
publicKey, privateKey, err := ed25519.GenerateKey(nil)
require.NoError(t, err)
publicKeyB64 := base64.StdEncoding.EncodeToString(publicKey)
domain := testDomain
// Set up mock fetcher
mockFetcher := &MockHTTPKeyFetcher{
keyResponses: map[string]string{
domain: fmt.Sprintf("v=MCPv1; k=ed25519; p=%s", publicKeyB64),
},
}
handler.SetFetcher(mockFetcher)
// Generate signature and exchange token
timestamp := time.Now().UTC().Format(time.RFC3339)
signature := ed25519.Sign(privateKey, []byte(timestamp))
signedTimestamp := hex.EncodeToString(signature)
result, err := handler.ExchangeToken(context.Background(), domain, timestamp, signedTimestamp)
require.NoError(t, err)
claims, err := jwtManager.ValidateToken(context.Background(), result.RegistryToken)
require.NoError(t, err)
// Test permission validation scenarios
testCases := []struct {
name string
resource string
action intauth.PermissionAction
shouldPass bool
}{
{
name: "exact domain resource with publish action",
resource: "com.example/my-package",
action: intauth.PermissionActionPublish,
shouldPass: true,
},
{
name: "subdomain resource should fail for HTTP",
resource: "com.example.api/my-package",
action: intauth.PermissionActionPublish,
shouldPass: false, // HTTP does not grant subdomain permissions
},
{
name: "deep subdomain resource should fail for HTTP",
resource: "com.example.v1.api/my-package",
action: intauth.PermissionActionPublish,
shouldPass: false, // HTTP does not grant subdomain permissions
},
{
name: "different domain should fail",
resource: "com.otherdomain/my-package",
action: intauth.PermissionActionPublish,
shouldPass: false,
},
{
name: "partial domain match should fail",
resource: "com.example-other/my-package",
action: intauth.PermissionActionPublish,
shouldPass: false,
},
{
name: "parent domain should fail",
resource: "com/my-package",
action: intauth.PermissionActionPublish,
shouldPass: false,
},
{
name: "edit action should fail (not granted)",
resource: "com.example/my-package",
action: intauth.PermissionActionEdit,
shouldPass: false,
},
{
name: "resource without package separator should fail",
resource: "com.example",
action: intauth.PermissionActionPublish,
shouldPass: false,
},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
hasPermission := jwtManager.HasPermission(tc.resource, tc.action, claims.Permissions)
if tc.shouldPass {
assert.True(t, hasPermission, "Expected permission for resource %s with action %s", tc.resource, tc.action)
} else {
assert.False(t, hasPermission, "Expected no permission for resource %s with action %s", tc.resource, tc.action)
}
})
}
}
func TestHTTPvsDNS_PermissionDifferences(t *testing.T) {
cfg := &config.Config{
JWTPrivateKey: "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
}
httpHandler := auth.NewHTTPAuthHandler(cfg)
dnsHandler := auth.NewDNSAuthHandler(cfg)
jwtManager := intauth.NewJWTManager(cfg)
// Generate a test key pair
publicKey, privateKey, err := ed25519.GenerateKey(nil)
require.NoError(t, err)
publicKeyB64 := base64.StdEncoding.EncodeToString(publicKey)
domain := testDomain
// Set up mocks
mockFetcher := &MockHTTPKeyFetcher{
keyResponses: map[string]string{
domain: fmt.Sprintf("v=MCPv1; k=ed25519; p=%s", publicKeyB64),
},
}
httpHandler.SetFetcher(mockFetcher)
mockResolver := &MockDNSResolver{
txtRecords: map[string][]string{
domain: {
fmt.Sprintf("v=MCPv1; k=ed25519; p=%s", publicKeyB64),
},
},
}
dnsHandler.SetResolver(mockResolver)
// Generate tokens from both handlers
timestamp := time.Now().UTC().Format(time.RFC3339)
signature := ed25519.Sign(privateKey, []byte(timestamp))
signedTimestamp := hex.EncodeToString(signature)
httpResult, err := httpHandler.ExchangeToken(context.Background(), domain, timestamp, signedTimestamp)
require.NoError(t, err)
dnsResult, err := dnsHandler.ExchangeToken(context.Background(), domain, timestamp, signedTimestamp)
require.NoError(t, err)
// Validate both tokens
httpClaims, err := jwtManager.ValidateToken(context.Background(), httpResult.RegistryToken)
require.NoError(t, err)
dnsClaims, err := jwtManager.ValidateToken(context.Background(), dnsResult.RegistryToken)
require.NoError(t, err)
// Compare permission counts
assert.Len(t, httpClaims.Permissions, 1, "HTTP should grant 1 permission (exact domain only)")
assert.Len(t, dnsClaims.Permissions, 2, "DNS should grant 2 permissions (exact domain + subdomains)")
// Test resources that should behave differently
testCases := []struct {
name string
resource string
httpAllowed bool
dnsAllowed bool
}{
{
name: "exact domain resource",
resource: "com.example/my-package",
httpAllowed: true,
dnsAllowed: true,
},
{
name: "subdomain resource",
resource: "com.example.api/my-package",
httpAllowed: false, // HTTP does not grant subdomain permissions
dnsAllowed: true, // DNS grants subdomain permissions
},
{
name: "deep subdomain resource",
resource: "com.example.v1.api/my-package",
httpAllowed: false, // HTTP does not grant subdomain permissions
dnsAllowed: true, // DNS grants subdomain permissions
},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
httpPermission := jwtManager.HasPermission(tc.resource, intauth.PermissionActionPublish, httpClaims.Permissions)
dnsPermission := jwtManager.HasPermission(tc.resource, intauth.PermissionActionPublish, dnsClaims.Permissions)
assert.Equal(t, tc.httpAllowed, httpPermission, "HTTP permission mismatch for %s", tc.resource)
assert.Equal(t, tc.dnsAllowed, dnsPermission, "DNS permission mismatch for %s", tc.resource)
})
}
}