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:
parent
28220b0be6
commit
df018fc43b
1 changed files with 873 additions and 283 deletions
|
|
@ -2,15 +2,9 @@ package auth
|
|||
|
||||
import (
|
||||
"context"
|
||||
"crypto/ed25519"
|
||||
"encoding/base64"
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
"net"
|
||||
"net/http"
|
||||
"regexp"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/danielgtaylor/huma/v2"
|
||||
v0 "github.com/modelcontextprotocol/registry/internal/api/handlers/v0"
|
||||
|
|
@ -20,11 +14,7 @@ import (
|
|||
|
||||
// DNSTokenExchangeInput represents the input for DNS-based authentication
|
||||
type DNSTokenExchangeInput struct {
|
||||
Body struct {
|
||||
Domain string `json:"domain" doc:"Domain name" example:"example.com" required:"true"`
|
||||
Timestamp string `json:"timestamp" doc:"RFC3339 timestamp" example:"2023-01-01T00:00:00Z" required:"true"`
|
||||
SignedTimestamp string `json:"signed_timestamp" doc:"Hex-encoded Ed25519 signature of timestamp" example:"abcdef1234567890" required:"true"`
|
||||
}
|
||||
Body SignatureTokenExchangeInput
|
||||
}
|
||||
|
||||
// DNSResolver defines the interface for DNS resolution
|
||||
|
|
@ -42,17 +32,15 @@ func (r *DefaultDNSResolver) LookupTXT(ctx context.Context, name string) ([]stri
|
|||
|
||||
// DNSAuthHandler handles DNS-based authentication
|
||||
type DNSAuthHandler struct {
|
||||
config *config.Config
|
||||
jwtManager *auth.JWTManager
|
||||
resolver DNSResolver
|
||||
CoreAuthHandler
|
||||
resolver DNSResolver
|
||||
}
|
||||
|
||||
// NewDNSAuthHandler creates a new DNS authentication handler
|
||||
func NewDNSAuthHandler(cfg *config.Config) *DNSAuthHandler {
|
||||
return &DNSAuthHandler{
|
||||
config: cfg,
|
||||
jwtManager: auth.NewJWTManager(cfg),
|
||||
resolver: &DefaultDNSResolver{},
|
||||
CoreAuthHandler: *NewCoreAuthHandler(cfg),
|
||||
resolver: &DefaultDNSResolver{},
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -87,141 +75,18 @@ func RegisterDNSEndpoint(api huma.API, cfg *config.Config) {
|
|||
|
||||
// ExchangeToken exchanges DNS signature for a Registry JWT token
|
||||
func (h *DNSAuthHandler) ExchangeToken(ctx context.Context, domain, timestamp, signedTimestamp string) (*auth.TokenResponse, error) {
|
||||
// Validate domain format
|
||||
if !isValidDomain(domain) {
|
||||
return nil, fmt.Errorf("invalid domain format")
|
||||
}
|
||||
|
||||
// Parse and validate timestamp
|
||||
ts, err := time.Parse(time.RFC3339, timestamp)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("invalid timestamp format: %w", err)
|
||||
}
|
||||
|
||||
// Check timestamp is within 15 seconds
|
||||
now := time.Now()
|
||||
if ts.Before(now.Add(-15*time.Second)) || ts.After(now.Add(15*time.Second)) {
|
||||
return nil, fmt.Errorf("timestamp outside valid window (±15 seconds)")
|
||||
}
|
||||
|
||||
// Decode signature
|
||||
signature, err := hex.DecodeString(signedTimestamp)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("invalid signature format, must be hex: %w", err)
|
||||
}
|
||||
|
||||
if len(signature) != ed25519.SignatureSize {
|
||||
return nil, fmt.Errorf("invalid signature length: expected %d, got %d", ed25519.SignatureSize, len(signature))
|
||||
}
|
||||
|
||||
// Lookup DNS TXT records
|
||||
txtRecords, err := h.resolver.LookupTXT(ctx, domain)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to lookup DNS TXT records: %w", err)
|
||||
}
|
||||
|
||||
// Parse public keys from TXT records
|
||||
publicKeys := h.parsePublicKeysFromTXT(txtRecords)
|
||||
|
||||
if len(publicKeys) == 0 {
|
||||
return nil, fmt.Errorf("no valid MCP public keys found in DNS TXT records")
|
||||
}
|
||||
|
||||
// Verify signature with any of the public keys
|
||||
messageBytes := []byte(timestamp)
|
||||
signatureValid := false
|
||||
for _, publicKey := range publicKeys {
|
||||
if ed25519.Verify(publicKey, messageBytes, signature) {
|
||||
signatureValid = true
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
if !signatureValid {
|
||||
return nil, fmt.Errorf("signature verification failed")
|
||||
}
|
||||
|
||||
// Build permissions for domain and subdomains
|
||||
permissions := h.buildPermissions(domain)
|
||||
|
||||
// Create JWT claims
|
||||
jwtClaims := auth.JWTClaims{
|
||||
AuthMethod: auth.MethodDNS,
|
||||
AuthMethodSubject: domain,
|
||||
Permissions: permissions,
|
||||
}
|
||||
|
||||
// Generate Registry JWT token
|
||||
tokenResponse, err := h.jwtManager.GenerateTokenResponse(ctx, jwtClaims)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to generate JWT token: %w", err)
|
||||
}
|
||||
|
||||
return tokenResponse, nil
|
||||
}
|
||||
|
||||
// parsePublicKeysFromTXT parses Ed25519 public keys from DNS TXT records
|
||||
func (h *DNSAuthHandler) parsePublicKeysFromTXT(txtRecords []string) []ed25519.PublicKey {
|
||||
var publicKeys []ed25519.PublicKey
|
||||
mcpPattern := regexp.MustCompile(`v=MCPv1;\s*k=ed25519;\s*p=([A-Za-z0-9+/=]+)`)
|
||||
|
||||
for _, record := range txtRecords {
|
||||
matches := mcpPattern.FindStringSubmatch(record)
|
||||
if len(matches) == 2 {
|
||||
// Decode base64 public key
|
||||
publicKeyBytes, err := base64.StdEncoding.DecodeString(matches[1])
|
||||
if err != nil {
|
||||
continue // Skip invalid keys
|
||||
}
|
||||
|
||||
if len(publicKeyBytes) != ed25519.PublicKeySize {
|
||||
continue // Skip invalid key sizes
|
||||
}
|
||||
|
||||
publicKeys = append(publicKeys, ed25519.PublicKey(publicKeyBytes))
|
||||
}
|
||||
}
|
||||
|
||||
return publicKeys
|
||||
}
|
||||
|
||||
// buildPermissions builds permissions for a domain and its subdomains using reverse DNS notation
|
||||
func (h *DNSAuthHandler) buildPermissions(domain string) []auth.Permission {
|
||||
reverseDomain := reverseString(domain)
|
||||
|
||||
permissions := []auth.Permission{
|
||||
// Grant permissions for the exact domain (e.g., com.example/*)
|
||||
{
|
||||
Action: auth.PermissionActionPublish,
|
||||
ResourcePattern: fmt.Sprintf("%s/*", reverseDomain),
|
||||
},
|
||||
keyFetcher := func(ctx context.Context, domain string) ([]string, error) {
|
||||
// Lookup DNS TXT records
|
||||
// DNS implies a hierarchy where subdomains are treated as part of the parent domain,
|
||||
// therefore we grant permissions for all subdomains (e.g., com.example.*)
|
||||
// This is in line with other DNS-based authentication methods e.g. ACME DNS-01 challenges
|
||||
{
|
||||
Action: auth.PermissionActionPublish,
|
||||
ResourcePattern: fmt.Sprintf("%s.*", reverseDomain),
|
||||
},
|
||||
txtRecords, err := h.resolver.LookupTXT(ctx, domain)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to lookup DNS TXT records: %w", err)
|
||||
}
|
||||
return txtRecords, nil
|
||||
}
|
||||
|
||||
return permissions
|
||||
}
|
||||
|
||||
// reverseString reverses a domain string (example.com -> com.example)
|
||||
func reverseString(domain string) string {
|
||||
parts := strings.Split(domain, ".")
|
||||
for i, j := 0, len(parts)-1; i < j; i, j = i+1, j-1 {
|
||||
parts[i], parts[j] = parts[j], parts[i]
|
||||
}
|
||||
return strings.Join(parts, ".")
|
||||
}
|
||||
|
||||
func isValidDomain(domain string) bool {
|
||||
if len(domain) == 0 || len(domain) > 253 {
|
||||
return false
|
||||
}
|
||||
|
||||
// Check for valid characters and structure
|
||||
domainPattern := regexp.MustCompile(`^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?)*$`)
|
||||
return domainPattern.MatchString(domain)
|
||||
allowSubdomains := true
|
||||
return h.CoreAuthHandler.ExchangeToken(ctx, domain, timestamp, signedTimestamp, keyFetcher, allowSubdomains, auth.MethodDNS)
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue