Skip to content

Agent Mesh

implement RFC 8252 dynamic loopback

Antonio Ojeaf20fb93e124e
diff --git a/.github/k8s/dex-config.yaml b/.github/k8s/dex-config.yaml
index cbf6bb6c..cc6cba22 100644
--- a/.github/k8s/dex-config.yaml
+++ b/.github/k8s/dex-config.yaml
@@ -18,11 +18,9 @@ data:
http: 0.0.0.0:5556
oauth2:
- # Explicitly enable the Device Flow for headless CLI usage
grantTypes:
- "authorization_code"
- "refresh_token"
- - "urn:ietf:params:oauth:grant-type:device_code"
skipApprovalScreen: true
connectors:
@@ -48,7 +46,5 @@ data:
name: 'SAM Mesh CLI'
public: true # Allows PKCE flow for CLIs without exposing the secret
redirectURIs:
- - 'http://127.0.0.1:8080/callback'
- - 'http://localhost:8080/callback'
- - 'https://auth.sam-mesh.dev/device/callback'
- - '/device/callback'
+ - 'http://127.0.0.1/callback'
+ - 'http://localhost/callback'
diff --git a/Makefile b/Makefile
index dd104189..6f5639af 100644
--- a/Makefile
+++ b/Makefile
@@ -64,16 +64,16 @@ update:
go mod tidy
docker-build-hub:
- docker build -t sam-hub:local -f Dockerfile.sam-hub .
+ docker build --load -t sam-hub:local -f Dockerfile.sam-hub .
docker-build-node:
- docker build --no-cache -t sam-node:local -f Dockerfile.sam-node .
+ docker build --load --no-cache -t sam-node:local -f Dockerfile.sam-node .
docker-build-mock-oidc:
- docker build -t sam-mock-oidc:local -f tests/e2e/docker/Dockerfile.mock-oidc .
+ docker build --load -t sam-mock-oidc:local -f tests/e2e/docker/Dockerfile.mock-oidc .
docker-build-e2e-runtime:
- docker build -t sam-e2e-runtime:local -f tests/e2e/docker/Dockerfile.sam-runtime .
+ docker build --load -t sam-e2e-runtime:local -f tests/e2e/docker/Dockerfile.sam-runtime .
docker-build: docker-build-hub docker-build-node docker-build-mock-oidc docker-build-e2e-runtime
diff --git a/cmd/sam-node/main.go b/cmd/sam-node/main.go
index acc68983..8e98fe17 100644
--- a/cmd/sam-node/main.go
+++ b/cmd/sam-node/main.go
@@ -338,12 +338,12 @@ func main() {
fmt.Printf("Client ID discovered: %s\n", hubInfo.ClientId)
logger.Info("Discovering OIDC endpoints...")
- tokenURL, deviceAuthURL, err := dummyNode.DiscoverEndpoints(ctx, hubInfo.OidcIssuer)
+ tokenURL, authURL, err := dummyNode.DiscoverEndpoints(ctx, hubInfo.OidcIssuer)
if err != nil {
logger.Fatalf("Failed to discover OIDC endpoints: %v", err)
}
- jwtStr, err := dummyNode.InteractiveLogin(ctx, deviceAuthURL, tokenURL, hubInfo.ClientId, hubInfo.Audience)
+ jwtStr, err := dummyNode.InteractiveLogin(ctx, authURL, tokenURL, hubInfo.ClientId, hubInfo.Audience)
if err != nil {
logger.Fatalf("Failed to get token: %v", err)
}
diff --git a/cmd/sam-node/mcp.go b/cmd/sam-node/mcp.go
index dece95a7..45bdd891 100644
--- a/cmd/sam-node/mcp.go
+++ b/cmd/sam-node/mcp.go
@@ -154,10 +154,12 @@ func (n *SamNode) CallMCPTool(ctx context.Context, targetPeer peer.ID, toolName
func (n *SamNode) callMCPToolOnce(ctx context.Context, targetPeer peer.ID, toolName string, params any) (*mcp.CallToolResult, error) {
// Open stream
+ logger.Debugf("Dialing %s for MCP...\n", targetPeer)
s, err := n.Host.NewStream(ctx, targetPeer, api.MCPProtocolID)
if err != nil {
return nil, fmt.Errorf("failed to open stream to %s: %w", targetPeer, err)
}
+ logger.Debugf("Opened stream to %s for MCP\n", targetPeer)
defer func() {
if err := s.Close(); err != nil {
logger.Debugf("[MCP] Failed to close stream: %v", err)
@@ -177,12 +179,14 @@ func (n *SamNode) callMCPToolOnce(ctx context.Context, targetPeer peer.ID, toolN
authBytes, _ := proto.Marshal(&authFrame)
// Write AuthFrame
+ logger.Debugf("Writing auth frame to %s...\n", targetPeer)
writer := msgio.NewVarintWriter(s)
if err := writer.WriteMsg(authBytes); err != nil {
return nil, fmt.Errorf("failed to write auth frame to %s: %w", targetPeer, err)
}
// Read ACK
+ logger.Debugf("Reading auth response from %s...\n", targetPeer)
reader := msgio.NewVarintReaderSize(s, 1024*64)
msg, err := reader.ReadMsg()
if err != nil {
@@ -226,7 +230,7 @@ func (n *SamNode) callMCPToolOnce(ctx context.Context, targetPeer peer.ID, toolN
// fetchRemoteServiceCatalog calls the remote peer's list_local_services
// MCP tool with the type filter and returns the parsed catalog.
func (n *SamNode) fetchRemoteServiceCatalog(ctx context.Context, peerID peer.ID, typeStr string) ([]*api.ServiceInfo, error) {
- res, err := n.callMCPToolOnce(ctx, peerID, "list_local_services", map[string]string{"type": typeStr})
+ res, err := n.CallMCPTool(ctx, peerID, "list_local_services", map[string]string{"type": typeStr})
if err != nil {
return nil, err
}
diff --git a/cmd/sam-node/mcp_handlers.go b/cmd/sam-node/mcp_handlers.go
index 98377e7d..4bd418dd 100644
--- a/cmd/sam-node/mcp_handlers.go
+++ b/cmd/sam-node/mcp_handlers.go
@@ -49,6 +49,7 @@ func (n *SamNode) handleListLocalServices(ctx context.Context, req *mcp.CallTool
typeFilter = parsed
}
services := n.ListLocalServices(typeFilter)
+ logger.Infof("[ListLocalServices] Filter: %v, Returning %d services", typeFilter, len(services))
respData, err := json.Marshal(services)
if err != nil {
return nil, nil, err
diff --git a/cmd/sam-node/node.go b/cmd/sam-node/node.go
index 41f00b47..4268b8b3 100644
--- a/cmd/sam-node/node.go
+++ b/cmd/sam-node/node.go
@@ -416,6 +416,7 @@ dhtLoop:
if len(errs) > 0 {
return fmt.Errorf("failed to register static services: %w", errors.Join(errs...))
}
+ logger.Infof("[ServiceRegistry] Successfully registered %d static services", len(services))
return nil
}
diff --git a/cmd/sam-node/oidc.go b/cmd/sam-node/oidc.go
index 800e2f1e..e6e5bbb1 100644
--- a/cmd/sam-node/oidc.go
+++ b/cmd/sam-node/oidc.go
@@ -16,9 +16,13 @@ package main
import (
"context"
+ "crypto/rand"
+ "crypto/sha256"
+ "encoding/base64"
"encoding/json"
"fmt"
"io"
+ "net"
"net/http"
"net/url"
"os/exec"
@@ -32,6 +36,18 @@ import (
"google.golang.org/protobuf/proto"
)
+// generatePKCE generates a PKCE code verifier and challenge.
+func generatePKCE() (string, string, error) {
+ b := make([]byte, 32)
+ if _, err := rand.Read(b); err != nil {
+ return "", "", err
+ }
+ verifier := base64.RawURLEncoding.EncodeToString(b)
+ hash := sha256.Sum256([]byte(verifier))
+ challenge := base64.RawURLEncoding.EncodeToString(hash[:])
+ return verifier, challenge, nil
+}
+
// FetchJWT fetches a JWT token using the Client Credentials flow.
func (n *SamNode) FetchJWT(ctx context.Context, tokenURL, clientID, clientSecret string) (string, error) {
config := &clientcredentials.Config{
@@ -47,153 +63,172 @@ func (n *SamNode) FetchJWT(ctx context.Context, tokenURL, clientID, clientSecret
}
// InteractiveLogin prompts the user to go to a URL and enter a code.
-func (n *SamNode) InteractiveLogin(ctx context.Context, deviceAuthURL, tokenURL, clientID, audience string) (string, error) {
- if deviceAuthURL == "" {
- return "", fmt.Errorf("device authorization URL is required")
+func (n *SamNode) InteractiveLogin(ctx context.Context, authURL, tokenURL, clientID, audience string) (string, error) {
+ if authURL == "" {
+ return "", fmt.Errorf("authorization URL is required")
}
if tokenURL == "" {
return "", fmt.Errorf("token URL is required")
}
if clientID == "" {
- return "", fmt.Errorf("client ID is required for device flow")
+ return "", fmt.Errorf("client ID is required")
}
- data := url.Values{}
- data.Set("client_id", clientID)
- data.Set("scope", "openid email profile")
- if audience != "" {
- data.Set("audience", audience)
+ stateBytes := make([]byte, 16)
+ if _, err := rand.Read(stateBytes); err != nil {
+ return "", fmt.Errorf("failed to generate state: %w", err)
}
+ state := base64.RawURLEncoding.EncodeToString(stateBytes)
- req, err := http.NewRequestWithContext(ctx, "POST", deviceAuthURL, strings.NewReader(data.Encode()))
+ verifier, challenge, err := generatePKCE()
if err != nil {
- return "", err
+ return "", fmt.Errorf("failed to generate PKCE: %w", err)
}
- req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
- client := &http.Client{}
- resp, err := client.Do(req)
+ listener, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
- return "", err
- }
- defer func() {
- if err := resp.Body.Close(); err != nil {
- logger.Errorf("Failed to close response body: %v", err)
- }
- }()
-
- if resp.StatusCode != http.StatusOK {
- body, _ := io.ReadAll(io.LimitReader(resp.Body, 1024*1024))
- return "", fmt.Errorf("device auth request failed: %s - %s", resp.Status, string(body))
+ return "", fmt.Errorf("failed to start local server: %w", err)
}
+ defer func() { _ = listener.Close() }()
- var authResp struct {
- DeviceCode string `json:"device_code"`
- UserCode string `json:"user_code"`
- VerificationURI string `json:"verification_uri"`
- VerificationURIComplete string `json:"verification_uri_complete"`
- ExpiresIn int `json:"expires_in"`
- Interval int `json:"interval"`
- }
+ port := listener.Addr().(*net.TCPAddr).Port
+ redirectURI := fmt.Sprintf("http://127.0.0.1:%d/callback", port)
- if err := json.NewDecoder(resp.Body).Decode(&authResp); err != nil {
- return "", err
+ authReq, err := http.NewRequest("GET", authURL, nil)
+ if err != nil {
+ return "", fmt.Errorf("failed to create auth request: %w", err)
+ }
+ q := authReq.URL.Query()
+ q.Add("response_type", "code")
+ q.Add("client_id", clientID)
+ q.Add("redirect_uri", redirectURI)
+ q.Add("scope", "openid email profile")
+ q.Add("state", state)
+ q.Add("code_challenge", challenge)
+ q.Add("code_challenge_method", "S256")
+ if audience != "" {
+ q.Add("audience", audience)
}
+ authReq.URL.RawQuery = q.Encode()
+ targetURL := authReq.URL.String()
fmt.Println("------------------------------------------------------------")
- fmt.Println("Device Authorization Flow")
+ fmt.Println("OAuth Authorization Flow")
fmt.Println("------------------------------------------------------------")
fmt.Printf("To authenticate, please go to the following URL in your browser:\n\n")
- targetURL := authResp.VerificationURIComplete
- if targetURL == "" {
- targetURL = authResp.VerificationURI
- }
fmt.Printf(" %s\n\n", targetURL)
- if authResp.VerificationURIComplete == "" {
- fmt.Printf("And enter the following code:\n\n")
- fmt.Printf(" %s\n\n", authResp.UserCode)
- } else {
- fmt.Println("The login code has been pre-filled for your convenience.")
- }
fmt.Println("Waiting for authorization...")
fmt.Println("------------------------------------------------------------")
// Try to open browser automatically
- openBrowser(targetURL)
+ openBrowserFunc(targetURL)
- interval := authResp.Interval
- if interval <= 0 {
- interval = 5
- }
+ codeChan := make(chan string)
+ errChan := make(chan error)
+
+ mux := http.NewServeMux()
+ mux.HandleFunc("/callback", func(w http.ResponseWriter, r *http.Request) {
+ query := r.URL.Query()
+ if query.Get("state") != state {
+ http.Error(w, "Invalid state parameter", http.StatusBadRequest)
+ select {
+ case errChan <- fmt.Errorf("invalid state parameter received"):
+ case <-ctx.Done():
+ }
+ return
+ }
+ if errStr := query.Get("error"); errStr != "" {
+ desc := query.Get("error_description")
+ http.Error(w, "Authorization failed: "+errStr, http.StatusBadRequest)
+ select {
+ case errChan <- fmt.Errorf("authorization failed: %s - %s", errStr, desc):
+ case <-ctx.Done():
+ }
+ return
+ }
+ code := query.Get("code")
+ if code == "" {
+ http.Error(w, "No code in request", http.StatusBadRequest)
+ select {
+ case errChan <- fmt.Errorf("no code received"):
+ case <-ctx.Done():
+ }
+ return
+ }
- ticker := time.NewTicker(time.Duration(interval) * time.Second)
- defer ticker.Stop()
+ w.Header().Set("Content-Type", "text/html")
+ _, _ = w.Write([]byte("<html><body><h1>Authorization successful!</h1><p>You can close this window and return to the CLI.</p></body></html>"))
- for {
select {
+ case codeChan <- code:
case <-ctx.Done():
- return "", ctx.Err()
- case <-ticker.C:
- pollData := url.Values{}
- pollData.Set("grant_type", "urn:ietf:params:oauth:grant-type:device_code")
- pollData.Set("device_code", authResp.DeviceCode)
- pollData.Set("client_id", clientID)
-
- req, err := http.NewRequestWithContext(ctx, "POST", tokenURL, strings.NewReader(pollData.Encode()))
- if err != nil {
- return "", err
- }
- req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+ }
+ })
- resp, err := client.Do(req)
- if err != nil {
- return "", err
- }
+ srv := &http.Server{Handler: mux}
+ go func() {
+ if err := srv.Serve(listener); err != nil && err != http.ErrServerClosed {
+ errChan <- fmt.Errorf("local server error: %w", err)
+ }
+ }()
- if resp.StatusCode == http.StatusOK {
- var tokenResp struct {
- AccessToken string `json:"access_token"`
- IdToken string `json:"id_token"`
- }
- err := json.NewDecoder(resp.Body).Decode(&tokenResp)
- if closeErr := resp.Body.Close(); closeErr != nil {
- logger.Errorf("Failed to close response body: %v", closeErr)
- }
- if err != nil {
- return "", err
- }
- if tokenResp.IdToken != "" {
- return tokenResp.IdToken, nil
- }
- return tokenResp.AccessToken, nil
- }
+ var code string
+ select {
+ case <-ctx.Done():
+ _ = srv.Close()
+ return "", ctx.Err()
+ case err := <-errChan:
+ _ = srv.Close()
+ return "", err
+ case code = <-codeChan:
+ _ = srv.Close()
+ }
- var errResp struct {
- Error string `json:"error"`
- }
- err = json.NewDecoder(resp.Body).Decode(&errResp)
- if closeErr := resp.Body.Close(); closeErr != nil {
- logger.Errorf("Failed to close response body: %v", closeErr)
- }
- if err != nil {
- return "", fmt.Errorf("token request failed with status %s", resp.Status)
- }
+ tokenData := url.Values{}
+ tokenData.Set("grant_type", "authorization_code")
+ tokenData.Set("client_id", clientID)
+ tokenData.Set("code", code)
+ tokenData.Set("redirect_uri", redirectURI)
+ tokenData.Set("code_verifier", verifier)
- switch errResp.Error {
- case "authorization_pending":
- continue
- case "slow_down":
- ticker.Reset(time.Duration(interval+5) * time.Second)
- continue
- case "expired_token":
- return "", fmt.Errorf("device code expired")
- case "access_denied":
- return "", fmt.Errorf("access denied by user")
- default:
- return "", fmt.Errorf("token request failed: %s", errResp.Error)
- }
+ req, err := http.NewRequestWithContext(ctx, "POST", tokenURL, strings.NewReader(tokenData.Encode()))
+ if err != nil {
+ return "", err
+ }
+ req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+ client := &http.Client{Timeout: 10 * time.Second}
+ resp, err := client.Do(req)
+ if err != nil {
+ return "", err
+ }
+ defer func() {
+ if err := resp.Body.Close(); err != nil {
+ logger.Errorf("Failed to close response body: %v", err)
+ }
+ }()
+
+ if resp.StatusCode != http.StatusOK {
+ var errResp struct {
+ Error string `json:"error"`
+ ErrorDescription string `json:"error_description"`
}
+ _ = json.NewDecoder(resp.Body).Decode(&errResp)
+ return "", fmt.Errorf("token request failed: %s - %s", errResp.Error, errResp.ErrorDescription)
}
+
+ var tokenResp struct {
+ AccessToken string `json:"access_token"`
+ IdToken string `json:"id_token"`
+ }
+ if err := json.NewDecoder(resp.Body).Decode(&tokenResp); err != nil {
+ return "", err
+ }
+
+ if tokenResp.IdToken != "" {
+ return tokenResp.IdToken, nil
+ }
+ return tokenResp.AccessToken, nil
}
// DiscoverTokenURL discovers the token URL from the OIDC issuer.
@@ -214,20 +249,20 @@ func (n *SamNode) DiscoverTokenURL(ctx context.Context, issuerURL string) (strin
return claims.TokenURL, nil
}
-// DiscoverEndpoints discovers both token and device auth endpoints.
-func (n *SamNode) DiscoverEndpoints(ctx context.Context, issuerURL string) (tokenURL, deviceURL string, err error) {
+// DiscoverEndpoints discovers both token and authorization endpoints.
+func (n *SamNode) DiscoverEndpoints(ctx context.Context, issuerURL string) (tokenURL, authURL string, err error) {
provider, err := oidc.NewProvider(ctx, issuerURL)
if err != nil {
return "", "", fmt.Errorf("failed to create OIDC provider: %w", err)
}
var claims struct {
- TokenURL string `json:"token_endpoint"`
- DeviceURL string `json:"device_authorization_endpoint"`
+ TokenURL string `json:"token_endpoint"`
+ AuthURL string `json:"authorization_endpoint"`
}
if err := provider.Claims(&claims); err != nil {
return "", "", fmt.Errorf("failed to extract claims: %w", err)
}
- return claims.TokenURL, claims.DeviceURL, nil
+ return claims.TokenURL, claims.AuthURL, nil
}
// DiscoverHubInfo queries the hub's /info endpoint to fetch OIDC configurations.
@@ -274,6 +309,8 @@ func (n *SamNode) DiscoverHubInfo(ctx context.Context, hubURL string) (*api.HubI
return &hubInfo, nil
}
+var openBrowserFunc = openBrowser
+
func openBrowser(targetURL string) {
parsedURL, err := url.Parse(targetURL)
if err != nil || (parsedURL.Scheme != "http" && parsedURL.Scheme != "https") {
diff --git a/cmd/sam-node/oidc_test.go b/cmd/sam-node/oidc_test.go
index 89f79b59..a063aaae 100644
--- a/cmd/sam-node/oidc_test.go
+++ b/cmd/sam-node/oidc_test.go
@@ -5,52 +5,34 @@ import (
"encoding/json"
"net/http"
"net/http/httptest"
- "sync/atomic"
+ "net/url"
"testing"
"time"
)
func TestInteractiveLogin(t *testing.T) {
- // Mock OIDC server
mux := http.NewServeMux()
-
- // State for polling
- var authorized atomic.Bool
-
- mux.HandleFunc("/device/code", func(w http.ResponseWriter, r *http.Request) {
+
+ mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
return
}
- w.Header().Set("Content-Type", "application/json")
- if err := json.NewEncoder(w).Encode(map[string]interface{}{
- "device_code": "dev_code_123",
- "user_code": "ABCD-1234",
- "verification_uri": "http://example.com/verify",
- "expires_in": 60,
- "interval": 1, // Fast polling for test
- }); err != nil {
- t.Errorf("Failed to encode response: %v", err)
+ _ = r.ParseForm()
+ if r.FormValue("grant_type") != "authorization_code" {
+ http.Error(w, "Invalid grant_type", http.StatusBadRequest)
+ return
}
- })
-
- mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {
- if r.Method != "POST" {
- http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+ if r.FormValue("code") != "dev_code_123" {
+ http.Error(w, "Invalid code", http.StatusBadRequest)
return
}
- w.Header().Set("Content-Type", "application/json")
-
- if !authorized.Load() {
- w.WriteHeader(http.StatusBadRequest)
- if err := json.NewEncoder(w).Encode(map[string]string{
- "error": "authorization_pending",
- }); err != nil {
- t.Errorf("Failed to encode response: %v", err)
- }
+ if r.FormValue("code_verifier") == "" {
+ http.Error(w, "Missing code_verifier", http.StatusBadRequest)
return
}
-
+
+ w.Header().Set("Content-Type", "application/json")
if err := json.NewEncoder(w).Encode(map[string]string{
"access_token": "access_token_xyz",
"id_token": "id_token_abc",
@@ -63,33 +45,31 @@ func TestInteractiveLogin(t *testing.T) {
defer server.Close()
node := &SamNode{}
-
+
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
- // Run InteractiveLogin in a goroutine because it blocks
- type result struct {
- token string
- err error
- }
- resChan := make(chan result, 1)
-
- go func() {
- token, err := node.InteractiveLogin(ctx, server.URL+"/device/code", server.URL+"/token", "client_id_test", "sam-e2e")
- resChan <- result{token, err}
- }()
+ // Mock openBrowser to simulate the user authorizing in the browser
+ originalOpenBrowser := openBrowserFunc
+ openBrowserFunc = func(urlStr string) {
+ u, _ := url.Parse(urlStr)
+ redirectURI := u.Query().Get("redirect_uri")
+ state := u.Query().Get("state")
- // Wait a bit and then authorize the user
- time.Sleep(1500 * time.Millisecond)
- authorized.Store(true)
+ go func() {
+ time.Sleep(100 * time.Millisecond)
+ _, _ = http.Get(redirectURI + "?code=dev_code_123&state=" + state)
+ }()
+ }
+ defer func() { openBrowserFunc = originalOpenBrowser }()
- res := <-resChan
- if res.err != nil {
- t.Fatalf("InteractiveLogin failed: %v", res.err)
+ token, err := node.InteractiveLogin(ctx, "http://auth.example.com/auth", server.URL+"/token", "client_id_test", "sam-e2e")
+ if err != nil {
+ t.Fatalf("InteractiveLogin failed: %v", err)
}
- if res.token != "id_token_abc" {
- t.Errorf("Expected token 'id_token_abc', got '%s'", res.token)
+ if token != "id_token_abc" {
+ t.Errorf("Expected token 'id_token_abc', got '%s'", token)
}
}
@@ -98,9 +78,9 @@ func TestDiscoverEndpoints(t *testing.T) {
mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
if err := json.NewEncoder(w).Encode(map[string]interface{}{
- "issuer": "http://" + r.Host,
- "token_endpoint": "http://" + r.Host + "/token",
- "device_authorization_endpoint": "http://" + r.Host + "/device/code",
+ "issuer": "http://" + r.Host,
+ "token_endpoint": "http://" + r.Host + "/token",
+ "authorization_endpoint": "http://" + r.Host + "/auth",
}); err != nil {
t.Errorf("Failed to encode response: %v", err)
}
@@ -112,7 +92,7 @@ func TestDiscoverEndpoints(t *testing.T) {
node := &SamNode{}
ctx := context.Background()
- tokenURL, deviceURL, err := node.DiscoverEndpoints(ctx, server.URL)
+ tokenURL, authURL, err := node.DiscoverEndpoints(ctx, server.URL)
if err != nil {
t.Fatalf("DiscoverEndpoints failed: %v", err)
}
@@ -120,7 +100,7 @@ func TestDiscoverEndpoints(t *testing.T) {
if tokenURL != server.URL+"/token" {
t.Errorf("Expected tokenURL %s, got %s", server.URL+"/token", tokenURL)
}
- if deviceURL != server.URL+"/device/code" {
- t.Errorf("Expected deviceURL %s, got %s", server.URL+"/device/code", deviceURL)
+ if authURL != server.URL+"/auth" {
+ t.Errorf("Expected authURL %s, got %s", server.URL+"/auth", authURL)
}
}
diff --git a/docs/kubernetes-deployment.md b/docs/kubernetes-deployment.md
index 3f776878..d8c42ed9 100644
--- a/docs/kubernetes-deployment.md
+++ b/docs/kubernetes-deployment.md
@@ -26,8 +26,7 @@ The manifests for the SAM Hub are available in [sam-hub.yaml](manifests/sam-hub.
To use Google as the OIDC provider instead of the mock provider:
-1. **Create OAuth Client ID:** Create a OAuth 2.0 Client ID in the Google Cloud Console.
-2. **Set Redirect URI:** Set the authorized redirect URI to `http://<your-hub-public-ip>:8080/callback` (replace `<your-hub-public-ip>` with your actual public IP or domain).
+2. **No Redirect URI required:** Because `sam-node` implements RFC 8252 (dynamic loopback port selection for native apps), you don't need to configure a specific Redirect URI when setting up a Desktop app. The authorization server will automatically allow loopback redirects.
3. **Update Secret:** Update the `sam-hub-secret` in `sam-hub.yaml` with your Google credentials:
```yaml
SAM_OIDC_ISSUER: "https://accounts.google.com"
@@ -175,10 +174,10 @@ sam-node run \
--client-secret "$SAM_OIDC_SECRET"
```
-#### 2. Device Authorization Flow (Human Intervention)
-* **Description:** For input-constrained devices or CLI tools used by humans. The device asks the user to go to a link on their computer or smartphone to authorize the device, avoiding the need to enter complex passwords in the CLI.
-* **Use Case:** When a human operator is enrolling a node manually.
-* **How to use:** The user obtains a token via the OIDC provider's device flow (or browser flow) and passes it directly via the `--jwt` flag.
+#### 2. Native App Authorization Code Flow (Human Intervention)
+* **Description:** For devices operated by humans, this uses the standard Authorization Code Flow with PKCE for native apps (RFC 8252). `sam-node` spins up a temporary local HTTP server, opens your browser, and receives the authentication token locally via an ephemeral loopback address.
+* **Use Case:** When a human operator is enrolling a node manually via their local terminal.
+* **How to use:** When you omit the `--jwt` or `--token-url` flags (or pass the OIDC issuer flag interactively), the node opens the browser and completes the flow without needing to enter complex passwords in the CLI. Alternatively, you can obtain a token yourself and pass it via the `--jwt` flag.
* **Example:**
```bash
sam-node run \
diff --git a/tests/e2e/auth_flows.bats b/tests/e2e/auth_flows.bats
index b41bcdf4..50a4e8bd 100644
--- a/tests/e2e/auth_flows.bats
+++ b/tests/e2e/auth_flows.bats
@@ -54,11 +54,45 @@ teardown() {
local data_vol="${MESH_PREFIX}-data"
docker volume create "${data_vol}"
- docker run --rm \
+ docker run --name "${node_name}-join" \
--network "${MESH_NETWORK}" \
-v "${data_vol}:/root/.config/sam-mesh" \
"sam-node:local" \
- join "http://sam-hub:9090"
+ join "http://sam-hub:9090" > "/tmp/${node_name}-join.out" 2>&1 &
+ local join_pid=$!
+
+ # Wait for redirect_uri and state in the output
+ local redirect_uri=""
+ local state=""
+ local port=""
+ for i in {1..20}; do
+ if grep -q "redirect_uri=" "/tmp/${node_name}-join.out"; then
+ # Output format: http://mock-oidc...redirect_uri=http%3A%2F%2F127.0.0.1%3A<PORT>%2Fcallback&...&state=<STATE>
+ local line
+ line=$(grep "redirect_uri=" "/tmp/${node_name}-join.out" | head -n 1)
+ redirect_uri=$(echo "$line" | grep -o 'redirect_uri=[^&]*' | cut -d= -f2 | tr -d '\r\n')
+ state=$(echo "$line" | grep -o 'state=[^&]*' | cut -d= -f2 | tr -d '\r\n')
+
+ # URL decode redirect_uri
+ # e.g. http%3A%2F%2F127.0.0.1%3A41353%2Fcallback -> http://127.0.0.1:41353/callback
+ redirect_uri=$(echo "$redirect_uri" | sed -e 's/%3A/:/g' -e 's/%2F/\//g')
+
+ port=$(echo "$redirect_uri" | grep -o ':[0-9]*' | tr -d ':\r\n')
+ if [[ -n "$port" && -n "$state" ]]; then
+ break
+ fi
+ fi
+ sleep 1
+ done
+
+ [[ -n "$port" ]] && [[ -n "$state" ]]
+
+ # Trigger the callback in the sam-node container's network namespace
+ docker run --rm --network "container:${node_name}-join" python:3.12 python3 -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:${port}/callback?code=dev_code_123&state=${state}')"
+
+ # Wait for the join process to finish
+ wait $join_pid
+ docker rm -f "${node_name}-join" >/dev/null 2>&1 || true
# Now run the node with the stored identity
docker run -d \
diff --git a/tests/e2e/policy.bats b/tests/e2e/policy.bats
index e79ad309..e95bd339 100644
--- a/tests/e2e/policy.bats
+++ b/tests/e2e/policy.bats
@@ -232,7 +232,7 @@ EOF"
mesh_wait_for_log "${MESH_PREFIX}-node-2" "SAM Node Online" 20
local node2_id
- node2_id=$(docker logs "${MESH_PREFIX}-node-2" 2>&1 | grep -A 1 "SAM Node Online" | grep -oE '12D3Koo[a-zA-Z0-9]+' | head -n 1)
+ node2_id=$(docker logs "${MESH_PREFIX}-node-2" 2>&1 | grep "PeerID:" | grep -oE '12D3Koo[a-zA-Z0-9]+' | head -n 1)
# Wait for discovery (Node 2 should see Node 1)
local i
diff --git a/tests/integration/fallback_test.go b/tests/integration/fallback_test.go
index ffd5f02b..39b8bf85 100644
--- a/tests/integration/fallback_test.go
+++ b/tests/integration/fallback_test.go
@@ -392,7 +392,7 @@ func TestSelfHealingHTTPFallback(t *testing.T) {
_ = json.NewEncoder(w).Encode(map[string]interface{}{
"issuer": "http://" + r.Host,
"token_endpoint": "http://" + r.Host + "/token",
- "device_authorization_endpoint": "http://" + r.Host + "/device/code",
+ "authorization_endpoint": "http://" + r.Host + "/auth",
})
})
mux.HandleFunc("/device/code", func(w http.ResponseWriter, r *http.Request) {
@@ -453,7 +453,7 @@ func TestSelfHealingHTTPFallback(t *testing.T) {
)
// Step 1: Enroll via Join (using mock OIDC)
- joinStdout, joinStderr, err := runCommand(
+ joinStdout, joinStderr, err := runCommandWithCallback(
t,
repoRoot(t),
5*time.Second,
diff --git a/tests/integration/login_test.go b/tests/integration/login_test.go
index 1c943d1c..1a6ba395 100644
--- a/tests/integration/login_test.go
+++ b/tests/integration/login_test.go
@@ -41,7 +41,7 @@ func TestSamNodeJoin(t *testing.T) {
if err := json.NewEncoder(w).Encode(map[string]interface{}{
"issuer": "http://" + r.Host,
"token_endpoint": "http://" + r.Host + "/token",
- "device_authorization_endpoint": "http://" + r.Host + "/device/code",
+ "authorization_endpoint": "http://" + r.Host + "/auth",
}); err != nil {
t.Errorf("Failed to encode response: %v", err)
}
@@ -74,7 +74,7 @@ func TestSamNodeJoin(t *testing.T) {
// Start mock libp2p hub that knows about our mock OIDC server
_, hubAddr := startMockLibp2pHubWithOIDC(t, oidcServer.URL)
- stdout, stderr, err := runCommand(
+ stdout, stderr, err := runCommandWithCallback(
t,
repoRoot(t),
5*time.Second,
diff --git a/tests/integration/minimal_helpers_test.go b/tests/integration/minimal_helpers_test.go
index 94da1773..b879e5d4 100644
--- a/tests/integration/minimal_helpers_test.go
+++ b/tests/integration/minimal_helpers_test.go
@@ -21,17 +21,20 @@ import (
"os/exec"
"path/filepath"
"runtime"
+ "strings"
"testing"
"time"
"io"
"net/http"
"net/http/httptest"
+ "net/url"
+
"github.com/google/sam/api"
"github.com/libp2p/go-libp2p"
dht "github.com/libp2p/go-libp2p-kad-dht"
- "github.com/libp2p/go-libp2p/core/peer"
"github.com/libp2p/go-libp2p/core/network"
+ "github.com/libp2p/go-libp2p/core/peer"
"github.com/libp2p/go-msgio"
"google.golang.org/protobuf/proto"
)
@@ -92,6 +95,82 @@ func runCommand(
return stdout.String(), stderr.String(), err
}
+type interceptorWriter struct {
+ w io.Writer
+ buf *bytes.Buffer
+ handled bool
+}
+
+func (iw *interceptorWriter) Write(p []byte) (n int, err error) {
+ n, err = iw.w.Write(p)
+ iw.buf.Write(p)
+ if !iw.handled {
+ s := iw.buf.String()
+ if strings.Contains(s, "redirect_uri=") && strings.Contains(s, "state=") {
+ iw.handled = true
+ go func() {
+ // Parse URL from the buffer to extract state and redirect_uri
+ // The URL is printed like: " http://...redirect_uri=...&state=..."
+ lines := strings.Split(s, "\n")
+ for _, line := range lines {
+ if strings.Contains(line, "redirect_uri=") {
+ parts := strings.Split(strings.TrimSpace(line), " ")
+ for _, p := range parts {
+ if strings.HasPrefix(p, "http") {
+ u, err := url.Parse(p)
+ if err == nil {
+ redirectURI := u.Query().Get("redirect_uri")
+ state := u.Query().Get("state")
+ if redirectURI != "" && state != "" {
+ time.Sleep(100 * time.Millisecond)
+ _, _ = http.Get(redirectURI + "?code=dev_code_123&state=" + state)
+ }
+ }
+ }
+ }
+ }
+ }
+ }()
+ }
+ }
+ return n, err
+}
+
+func runCommandWithCallback(
+ t *testing.T,
+ cwd string,
+ timeout time.Duration,
+ env []string,
+ stdin string,
+ name string,
+ args ...string,
+) (string, string, error) {
+ t.Helper()
+
+ ctx, cancel := context.WithTimeout(context.Background(), timeout)
+ defer cancel()
+
+ cmd := exec.CommandContext(ctx, name, args...)
+ cmd.Dir = cwd
+ if len(env) > 0 {
+ cmd.Env = append(cmd.Env, env...)
+ }
+ if stdin != "" {
+ cmd.Stdin = bytes.NewBufferString(stdin)
+ }
+
+ var stdout bytes.Buffer
+ var stderr bytes.Buffer
+ cmd.Stdout = &interceptorWriter{w: &stdout, buf: &bytes.Buffer{}}
+ cmd.Stderr = &stderr
+
+ err := cmd.Run()
+ if errors.Is(ctx.Err(), context.DeadlineExceeded) {
+ return stdout.String(), stderr.String(), context.DeadlineExceeded
+ }
+ return stdout.String(), stderr.String(), err
+}
+
func startMockLibp2pHub(t *testing.T) (peer.ID, string) {
t.Helper()