diff --git a/cmd/cloudflared/access/cmd.go b/cmd/cloudflared/access/cmd.go index 636b9288..3a7bbf7b 100644 --- a/cmd/cloudflared/access/cmd.go +++ b/cmd/cloudflared/access/cmd.go @@ -82,7 +82,7 @@ func Commands() []*cli.Command { Usage: "access ", Flags: []cli.Flag{&cli.BoolFlag{ Name: fedrampFlag, - Usage: "use when performing operations in fedramp account", + Usage: "Force the FedRAMP token transfer relay for Access authentication. Not usually needed: cloudflared selects it automatically when the application's verified auth domain is a FedRAMP domain (*.fed.cloudflareaccess.com).", }}, Description: `Cloudflare Access protects internal resources by securing, authenticating and monitoring access per-user and by application. With Cloudflare Access, only authenticated users with the required permissions are @@ -283,9 +283,13 @@ func login(c *cli.Context) error { // Chatty by default for backward compat. The new --app flag // is an implicit opt-out of the backwards-compatible chatty output. if c.Bool("no-verbose") || c.IsSet(appURLFlag) { - fmt.Fprint(os.Stdout, cfdToken) + if _, err := fmt.Fprint(os.Stdout, cfdToken); err != nil { + return fmt.Errorf("failed to write token to stdout: %w", err) + } } else { - fmt.Fprintf(os.Stdout, "Successfully fetched your token:\n\n%s\n\n", cfdToken) + if _, err := fmt.Fprintf(os.Stdout, "Successfully fetched your token:\n\n%s\n\n", cfdToken); err != nil { + return fmt.Errorf("failed to write token to stdout: %w", err) + } } return nil @@ -345,7 +349,7 @@ func curl(c *cli.Context) error { // run kicks off a shell task and pipe the results to the respective std pipes func run(cmd string, args ...string) error { - c := exec.Command(cmd, args...) + c := exec.Command(cmd, args...) // nolint: gosec // access curl intentionally runs curl with user-supplied arguments c.Stdin = os.Stdin stderr, err := c.StderrPipe() if err != nil { @@ -533,7 +537,7 @@ func cloudflaredPath() string { // isFileThere will check for the presence of candidate path func isFileThere(candidate string) bool { - fi, err := os.Stat(candidate) + fi, err := os.Stat(candidate) // nolint: gosec // read-only stat of the cloudflared executable or PATH candidates if err != nil || fi.IsDir() || !fi.Mode().IsRegular() { return false } @@ -595,7 +599,7 @@ func isTokenValid(options *carrier.StartOptions, log *zerolog.Logger) (bool, err if err != nil { return false, err } - defer resp.Body.Close() + defer func() { _ = resp.Body.Close() }() // A redirect to login means the token was invalid. return !carrier.IsAccessResponse(resp), nil diff --git a/token/jwks.go b/token/jwks.go index bd9e719c..db0cdf5b 100644 --- a/token/jwks.go +++ b/token/jwks.go @@ -19,6 +19,7 @@ import ( const ( accessCertPath = "/cdn-cgi/access/certs" accessDomainSuffix = ".cloudflareaccess.com" + fedAccessDomainSuffix = ".fed" + accessDomainSuffix httpsScheme = "https" jwksCacheSuffix = "-jwks" maxJWKSResponseSize = 1 << 20 @@ -90,6 +91,18 @@ func parseAuthDomain(authDomain string) (url.URL, error) { return url.URL{Scheme: httpsScheme, Host: hostname}, nil } +// isFedAuthDomain reports whether authDomain is a FedRAMP Access auth domain. +// authDomain is expected to be the verified AppInfo.AuthDomain; it is +// re-normalized here so only an exact ".fed.cloudflareaccess.com" hostname +// suffix matches. +func isFedAuthDomain(authDomain string) bool { + parsed, err := parseAuthDomain(authDomain) + if err != nil { + return false + } + return strings.HasSuffix(parsed.Hostname(), fedAccessDomainSuffix) +} + // fetchJWKS fetches the JWKS from the auth domain's certs endpoint over HTTPS. func fetchJWKS(authDomain url.URL) (*jose.JSONWebKeySet, error) { jwksURL := authDomain diff --git a/token/token.go b/token/token.go index ab6e9342..0bcd9127 100644 --- a/token/token.go +++ b/token/token.go @@ -321,19 +321,21 @@ func Init(version string) { } // FetchTokenWithRedirect will either load a stored token or generate a new one -// it appends the full url as the redirect URL to the access cli request if opening the browser -func FetchTokenWithRedirect(appURL *url.URL, appInfo *AppInfo, autoClose bool, isFedramp bool, log *zerolog.Logger) (string, error) { - return getToken(appURL, appInfo, false, autoClose, isFedramp, log) +// it appends the full url as the redirect URL to the access cli request if opening the browser. +// The FedRAMP token transfer relay is used when forceFedramp is set or appInfo.AuthDomain is a FedRAMP auth domain. +func FetchTokenWithRedirect(appURL *url.URL, appInfo *AppInfo, autoClose bool, forceFedramp bool, log *zerolog.Logger) (string, error) { + return getToken(appURL, appInfo, false, autoClose, forceFedramp, log) } // FetchToken will either load a stored token or generate a new one -// it appends the host of the appURL as the redirect URL to the access cli request if opening the browser -func FetchToken(appURL *url.URL, appInfo *AppInfo, autoClose bool, isFedramp bool, log *zerolog.Logger) (string, error) { - return getToken(appURL, appInfo, true, autoClose, isFedramp, log) +// it appends the host of the appURL as the redirect URL to the access cli request if opening the browser. +// The FedRAMP token transfer relay is used when forceFedramp is set or appInfo.AuthDomain is a FedRAMP auth domain. +func FetchToken(appURL *url.URL, appInfo *AppInfo, autoClose bool, forceFedramp bool, log *zerolog.Logger) (string, error) { + return getToken(appURL, appInfo, true, autoClose, forceFedramp, log) } // getToken will either load a stored token or generate a new one -func getToken(appURL *url.URL, appInfo *AppInfo, useHostOnly bool, autoClose bool, isFedramp bool, log *zerolog.Logger) (string, error) { +func getToken(appURL *url.URL, appInfo *AppInfo, useHostOnly bool, autoClose bool, forceFedramp bool, log *zerolog.Logger) (string, error) { if token, err := GetAppTokenIfExists(appInfo); token != "" && err == nil { return token, nil } @@ -382,6 +384,11 @@ func getToken(appURL *url.URL, appInfo *AppInfo, useHostOnly bool, autoClose boo return appToken, nil } } + isFedramp := forceFedramp + if !isFedramp && isFedAuthDomain(appInfo.AuthDomain) { + log.Debug().Msg("Detected FedRAMP Access auth domain; using FedRAMP token transfer relay") + isFedramp = true + } return getTokensFromEdge(appURL, appInfo.AppAUD, appTokenPath, orgTokenPath, useHostOnly, autoClose, isFedramp, log) } diff --git a/token/token_fetch_test.go b/token/token_fetch_test.go index 5d8d4187..98b5e21f 100644 --- a/token/token_fetch_test.go +++ b/token/token_fetch_test.go @@ -3,11 +3,17 @@ package token import ( "crypto/rand" "crypto/rsa" + "encoding/base64" "encoding/json" + "fmt" + "io" "net/http" "net/http/httptest" "net/url" "os" + "slices" + "strings" + "sync" "testing" "time" @@ -15,6 +21,7 @@ import ( "github.com/rs/zerolog" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + "golang.org/x/crypto/nacl/box" ) func TestFetchTokenWithRedirectAllowsSameProcessReauthentication(t *testing.T) { @@ -82,6 +89,253 @@ func TestFetchTokenWithRedirectAllowsSameProcessReauthentication(t *testing.T) { } } +// relayRecorder stands in for the token transfer relay. It records every +// polled URL and answers with the app and org tokens encrypted to the +// cloudflared public key embedded in the polling path. +type relayRecorder struct { + appToken string + orgToken string + + mu sync.Mutex + urls []string +} + +func (r *relayRecorder) RoundTrip(req *http.Request) (*http.Response, error) { + r.mu.Lock() + r.urls = append(r.urls, req.URL.String()) + r.mu.Unlock() + + recipientKey, ok := strings.CutPrefix(req.URL.Path, "/transfer/") + if !ok { + return nil, fmt.Errorf("unexpected relay path %q", req.URL.Path) + } + sender, err := NewEncrypter() + if err != nil { + return nil, err + } + recipient, err := sender.decodePublicKey(recipientKey) + if err != nil { + return nil, err + } + payload, err := json.Marshal(transferServiceResponse{AppToken: r.appToken, OrgToken: r.orgToken}) + if err != nil { + return nil, err + } + var nonce [24]byte + if _, err := rand.Read(nonce[:]); err != nil { + return nil, err + } + sealed := box.Seal(nonce[:], payload, &nonce, recipient, sender.privateKey) + + header := make(http.Header) + header.Set("service-public-key", sender.PublicKey()) + return &http.Response{ + StatusCode: http.StatusOK, + Header: header, + Body: io.NopCloser(strings.NewReader(base64.StdEncoding.EncodeToString(sealed))), + Request: req, + }, nil +} + +func (r *relayRecorder) polledURLs() []string { + r.mu.Lock() + defer r.mu.Unlock() + return slices.Clone(r.urls) +} + +// stubTransfer replaces the browser launcher and relay transport for the +// duration of the test so no browser is opened and no production relay is +// contacted. +func stubTransfer(t *testing.T, relay *relayRecorder) { + t.Helper() + origOpenBrowser, origTransport := openBrowser, transferTransport + openBrowser = func(string) error { return nil } + transferTransport = relay + t.Cleanup(func() { + openBrowser, transferTransport = origOpenBrowser, origTransport + }) +} + +// discoverTestApp serves a signed metadata JWT for authDomain from a local +// server and returns the app URL with the AppInfo verified by GetAppInfo. +func discoverTestApp(t *testing.T, authDomain, appHostname string) (*url.URL, *AppInfo) { + t.Helper() + + key := testRSAKey(t) + kid := "test-key-1" + require.NoError(t, writeJWKSCache(testAuthDomain(t, authDomain), testJWKS(t, key, kid))) + + var rawJWT string + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.Header.Get(accessMetadataReqHeader) == accessMetadataReqValue { + w.Header().Set(accessMetadataRespHeader, rawJWT) + } + w.WriteHeader(http.StatusOK) + })) + t.Cleanup(server.Close) + + appURL, err := url.Parse(server.URL) + require.NoError(t, err) + rawJWT = signTestMetadataJWT(t, &metadataClaims{ + Type: metadataMatchType, + Hostname: appURL.Hostname(), + AuthDomain: authDomain, + AUD: "app-aud", + AppHostname: appHostname, + IAT: time.Now().Unix(), + }, key, kid) + + appInfo, err := GetAppInfo(appURL) + require.NoError(t, err) + return appURL, appInfo +} + +func TestFetchTokenSelectsTransferRelay(t *testing.T) { + type fetchFunc func(*url.URL, *AppInfo, bool, bool, *zerolog.Logger) (string, error) + + tests := []struct { + name string + authDomain string + appHostname string + forceFedramp bool + fetch fetchFunc + wantRelay string + }{ + { + name: "fed auth domain without flag", + authDomain: "team.fed.cloudflareaccess.com", + fetch: FetchTokenWithRedirect, + wantRelay: fedStoreURL, + }, + { + name: "fed auth domain without flag via FetchToken", + authDomain: "team.fed.cloudflareaccess.com", + fetch: FetchToken, + wantRelay: fedStoreURL, + }, + { + name: "fed auth domain normalized", + authDomain: "Team.FED.CloudflareAccess.com:443", + fetch: FetchTokenWithRedirect, + wantRelay: fedStoreURL, + }, + { + name: "retail auth domain without flag", + authDomain: "team.cloudflareaccess.com", + fetch: FetchTokenWithRedirect, + wantRelay: baseStoreURL, + }, + { + name: "retail auth domain via FetchToken", + authDomain: "team.cloudflareaccess.com", + fetch: FetchToken, + wantRelay: baseStoreURL, + }, + { + name: "retail auth domain with flag", + authDomain: "team.cloudflareaccess.com", + forceFedramp: true, + fetch: FetchTokenWithRedirect, + wantRelay: fedStoreURL, + }, + { + name: "fed auth domain with flag", + authDomain: "team.fed.cloudflareaccess.com", + forceFedramp: true, + fetch: FetchToken, + wantRelay: fedStoreURL, + }, + { + name: "retail auth domain with fed-looking app hostname", + authDomain: "team.cloudflareaccess.com", + appHostname: "app.fed.cloudflareaccess.com", + fetch: FetchTokenWithRedirect, + wantRelay: baseStoreURL, + }, + { + name: "retail team named fed", + authDomain: "fed.cloudflareaccess.com", + fetch: FetchTokenWithRedirect, + wantRelay: baseStoreURL, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + useTempHome(t) + log := zerolog.Nop() + key := testRSAKey(t) + + relay := &relayRecorder{ + appToken: signedAccessToken(t, key, "app-aud", time.Now().Add(time.Hour)), + orgToken: signedAccessToken(t, key, "org-aud", time.Now().Add(time.Hour)), + } + stubTransfer(t, relay) + + appURL, appInfo := discoverTestApp(t, tc.authDomain, tc.appHostname) + + fetchedToken, err := tc.fetch(appURL, appInfo, false, tc.forceFedramp, &log) + require.NoError(t, err) + assert.Equal(t, relay.appToken, fetchedToken) + + polled := relay.polledURLs() + require.Len(t, polled, 1) + assert.True(t, strings.HasPrefix(polled[0], tc.wantRelay+"transfer/"), + "polled %q, want relay %q", polled[0], tc.wantRelay) + + cachedApp, err := GetAppTokenIfExists(appInfo) + require.NoError(t, err) + assert.Equal(t, relay.appToken, cachedApp) + cachedOrg, err := GetOrgTokenIfExists(appInfo.AuthDomain) + require.NoError(t, err) + assert.Equal(t, relay.orgToken, cachedOrg) + }) + } +} + +func TestFetchTokenFedAuthDomainSkipsRelayWhenTokensCached(t *testing.T) { + useTempHome(t) + log := zerolog.Nop() + key := testRSAKey(t) + + relay := &relayRecorder{} + stubTransfer(t, relay) + + _, appInfo := discoverTestApp(t, "team.fed.cloudflareaccess.com", "") + appToken := signedAccessToken(t, key, "app-aud", time.Now().Add(time.Hour)) + orgToken := signedAccessToken(t, key, "org-aud", time.Now().Add(time.Hour)) + + // Org token exchange: the app server returns an app token for the org token. + orgTokenPath, err := generateOrgTokenFilePathFromURL(appInfo.AuthDomain) + require.NoError(t, err) + require.NoError(t, os.WriteFile(orgTokenPath, []byte(orgToken), 0600)) + exchangeServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + http.SetCookie(w, &http.Cookie{ + Name: tokenCookie, + Value: appToken, + Expires: time.Now().Add(time.Hour), + Secure: true, + HttpOnly: true, + SameSite: http.SameSiteStrictMode, + }) + w.WriteHeader(http.StatusOK) + })) + t.Cleanup(exchangeServer.Close) + exchangeURL, err := url.Parse(exchangeServer.URL) + require.NoError(t, err) + + fetchedToken, err := FetchTokenWithRedirect(exchangeURL, appInfo, false, false, &log) + require.NoError(t, err) + assert.Equal(t, appToken, fetchedToken) + + // Cached app token: returned directly from disk. + fetchedToken, err = FetchToken(exchangeURL, appInfo, false, false, &log) + require.NoError(t, err) + assert.Equal(t, appToken, fetchedToken) + + assert.Empty(t, relay.polledURLs()) +} + func signedAccessToken(t *testing.T, key *rsa.PrivateKey, aud string, expiresAt time.Time) string { t.Helper() diff --git a/token/token_test.go b/token/token_test.go index 5e81c54d..3517d6b6 100644 --- a/token/token_test.go +++ b/token/token_test.go @@ -253,6 +253,39 @@ func TestParseAuthDomain(t *testing.T) { } } +func TestIsFedAuthDomain(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + authDomain string + want bool + }{ + {name: "fed", authDomain: "myteam.fed.cloudflareaccess.com", want: true}, + {name: "fed nested subdomain", authDomain: "a.myteam.fed.cloudflareaccess.com", want: true}, + {name: "fed uppercase normalized", authDomain: "MyTeam.FED.CloudflareAccess.com", want: true}, + {name: "fed port discarded", authDomain: "myteam.fed.cloudflareaccess.com:443", want: true}, + {name: "retail", authDomain: "myteam.cloudflareaccess.com"}, + {name: "retail team named fed", authDomain: "fed.cloudflareaccess.com"}, + {name: "fed label without dot", authDomain: "myteamfed.cloudflareaccess.com"}, + {name: "fed label prefix", authDomain: "myteam.fedx.cloudflareaccess.com"}, + {name: "fed label in middle", authDomain: "fed.myteam.cloudflareaccess.com"}, + {name: "fed suffix on foreign domain", authDomain: "myteam.fed.cloudflareaccess.com.evil.example"}, + {name: "fed in path", authDomain: "evil.example/x.fed.cloudflareaccess.com"}, + {name: "fed in fragment", authDomain: "evil.example#.fed.cloudflareaccess.com"}, + {name: "fed in userinfo", authDomain: "myteam.fed.cloudflareaccess.com@evil.example"}, + {name: "non access domain", authDomain: "myteam.fed.example.com"}, + {name: "empty", authDomain: ""}, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + t.Parallel() + assert.Equal(t, tc.want, isFedAuthDomain(tc.authDomain)) + }) + } +} + func TestFetchMetadataJWT_ReturnsAppInfoErrorOnError(t *testing.T) { t.Parallel() diff --git a/token/transfer.go b/token/transfer.go index 76b7d5df..d6143ec3 100644 --- a/token/transfer.go +++ b/token/transfer.go @@ -20,6 +20,12 @@ const ( clientTimeout = time.Second * 60 ) +// Test seams; production code always uses OpenBrowser and the default HTTP transport. +var ( + openBrowser = OpenBrowser + transferTransport http.RoundTripper +) + // RunTransfer does the transfer "dance" with the end result downloading the supported resource. // The expanded description is run is encapsulation of shared business logic needed // to request a resource (token/cert/etc) from the transfer service (loginhelper). @@ -45,7 +51,7 @@ func RunTransfer(transferURL *url.URL, appAUD, resourceName, key, value string, } // See AUTH-1423 for why we use stderr (the way git wraps ssh) - err = OpenBrowser(requestURL) + err = openBrowser(requestURL) if err != nil { fmt.Fprintf(os.Stderr, "Please open the following URL and log in with your Cloudflare account:\n\n%s\n\nLeave cloudflared running to download the %s automatically.\n", requestURL, resourceName) } else { @@ -116,7 +122,7 @@ func buildRequestURL(baseURL *url.URL, appAUD string, key, value string, cli, us // transferRequest downloads the requested resource from the request URL func transferRequest(requestURL string, log *zerolog.Logger) ([]byte, string, error) { - client := &http.Client{Timeout: clientTimeout} + client := &http.Client{Timeout: clientTimeout, Transport: transferTransport} const pollAttempts = 10 // we do "long polling" on the endpoint to get the resource. for i := 0; i < pollAttempts; i++ {