Compare commits

...

4 commits

Author SHA1 Message Date
Valentin Maerten
2c0cdd84a6
chore: reword the redirect downgrade changelog entry 2026-09-08 20:29:05 +02:00
Valentin Maerten
322c9a3aa3
fix(remote): allow a downgrade redirect under --insecure
Refusing it unconditionally was security theatre: --insecure also sets
InsecureSkipVerify, so an attacker in position to intercept can already
serve anything over the https leg with a self-signed certificate. It also
broke an internal server that redirects and works today.

--insecure now means one thing everywhere: the transport guarantees are
waived.
2026-09-08 20:29:05 +02:00
Valentin Maerten
6e83c02932
refactor(remote): extract the fetch error translation
The same policy — keep TaskfileNotSecureError, make everything else a
generic download failure — was spelled out at each of the three call
sites, where copies of a security rule tend to drift apart.
2026-09-08 20:29:05 +02:00
Valentin Maerten
6fb56e555b
fix(remote): refuse a redirect that drops TLS
The scheme was only checked on the URL the user wrote. A server answering
an https URL with a redirect to http was followed by the client without
any further check, so both the HEAD probe and the download travelled in
the clear, and a network attacker could substitute the Taskfile that is
about to be executed.

CheckRedirect now refuses an https to http hop. --insecure does not
loosen it: requesting an http entrypoint is the user's decision, being
sent to one is the server's. Setting CheckRedirect also replaces Go's
default cap, so the ten-hop limit is kept explicitly.

The three call sites turned almost every client error into a generic
download failure, which would have hidden the reason; TaskfileNotSecureError
is now passed through, with wording of its own for the redirect case since
--insecure is not a way out of it.
2026-09-08 20:29:05 +02:00
6 changed files with 180 additions and 7 deletions

View file

@ -7,6 +7,12 @@
- Added versioned Homebrew casks (`go-task@<major>.<minor>`) to install a specific
minor version of Task (#3023 by @vmaerten).
### 🐛 Fixes
- Fixed an `https` remote Taskfile being downloaded over an unencrypted
connection when the server redirects to `http`. Such a redirect now requires
`--insecure`, like an `http` entrypoint (by @vmaerten).
### 📦 Package API
- Bumped the minimum Go version to 1.26. Task follows Go's two-latest support

View file

@ -102,9 +102,18 @@ func (err *TaskfileNotTrustedError) Code() int {
// remote Taskfile over an insecure connection.
type TaskfileNotSecureError struct {
URI string
// Redirect reports that the insecure URI was reached through a redirect
// rather than requested, in which case --insecure does not allow it.
Redirect bool
}
func (err *TaskfileNotSecureError) Error() string {
if err.Redirect {
return fmt.Sprintf(
`task: Taskfile %q was redirected to over an insecure connection. You can override this by using the --insecure flag`,
filepath.ToSlash(err.URI),
)
}
return fmt.Sprintf(
`task: Taskfile %q cannot be downloaded over an insecure connection. You can override this by using the --insecure flag`,
filepath.ToSlash(err.URI),

View file

@ -32,9 +32,12 @@ func buildHTTPClient(insecure bool, caCert, cert, certKey string) (*http.Client,
return nil, fmt.Errorf("both --cert and --cert-key must be provided together")
}
// If no TLS customization is needed, return the default client
// If no TLS customization is needed, copy the default client rather than
// hand it out: setting CheckRedirect on it would apply process-wide.
if !insecure && caCert == "" && cert == "" {
return http.DefaultClient, nil
client := *http.DefaultClient
client.CheckRedirect = checkRedirect(insecure)
return &client, nil
}
tlsConfig := &tls.Config{
@ -67,9 +70,31 @@ func buildHTTPClient(insecure bool, caCert, cert, certKey string) (*http.Client,
Transport: &http.Transport{
TLSClientConfig: tlsConfig,
},
CheckRedirect: checkRedirect(insecure),
}, nil
}
// checkRedirect refuses a redirect that would drop TLS, unless --insecure was
// given: that flag also disables certificate verification, so refusing the
// plaintext hop would guard nothing an attacker could not walk around.
func checkRedirect(insecure bool) func(*http.Request, []*http.Request) error {
return func(req *http.Request, via []*http.Request) error {
// Setting CheckRedirect replaces the default cap, so it has to be kept.
if len(via) >= 10 {
return fmt.Errorf("stopped after 10 redirects")
}
if len(via) == 0 {
return nil
}
if !insecure &&
via[len(via)-1].URL.Scheme == "https" &&
req.URL.Scheme == "http" {
return &errors.TaskfileNotSecureError{URI: req.URL.Redacted(), Redirect: true}
}
return nil
}
}
func NewHTTPNode(
entrypoint string,
dir string,
@ -120,7 +145,7 @@ func (node *HTTPNode) ReadContext(ctx context.Context) ([]byte, error) {
if ctx.Err() != nil {
return nil, err
}
return nil, errors.TaskfileFetchFailedError{URI: node.Location()}
return nil, taskfileFetchError(err, node.Location())
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {

View file

@ -9,13 +9,17 @@ import (
"encoding/pem"
"math/big"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"sync/atomic"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/go-task/task/v3/errors"
)
func TestHTTPNode_CacheKey(t *testing.T) {
@ -62,10 +66,14 @@ func TestHTTPNode_CacheKey(t *testing.T) {
func TestBuildHTTPClient_Default(t *testing.T) {
t.Parallel()
// When no TLS customization is needed, should return http.DefaultClient
// When no TLS customization is needed, should copy http.DefaultClient
client, err := buildHTTPClient(false, "", "", "")
require.NoError(t, err)
assert.Equal(t, http.DefaultClient, client)
assert.NotSame(t, http.DefaultClient, client)
assert.Equal(t, http.DefaultClient.Transport, client.Transport)
assert.NotNil(t, client.CheckRedirect)
// The shared client must keep following redirects as before.
assert.Nil(t, http.DefaultClient.CheckRedirect)
}
func TestBuildHTTPClient_Insecure(t *testing.T) {
@ -282,3 +290,115 @@ func generateTestCACert(t *testing.T) []byte {
Bytes: certDER,
})
}
func TestCheckRedirect(t *testing.T) {
t.Parallel()
tests := []struct {
name string
from string
to string
insecure bool
wantErr bool
}{
{name: "https to http is refused", from: "https://example.com", to: "http://example.com", wantErr: true},
{name: "https to http on another host is refused", from: "https://example.com", to: "http://evil.test", wantErr: true},
{name: "https to http is allowed with insecure", from: "https://example.com", to: "http://example.com", insecure: true},
{name: "https to https is allowed", from: "https://example.com", to: "https://other.example.com"},
{name: "http to https is allowed", from: "http://example.com", to: "https://example.com"},
{name: "http to http is allowed, the entrypoint already opted in", from: "http://example.com", to: "http://other.example.com"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
via := []*http.Request{mustGet(t, tt.from)}
err := checkRedirect(tt.insecure)(mustGet(t, tt.to), via)
if !tt.wantErr {
require.NoError(t, err)
return
}
var notSecure *errors.TaskfileNotSecureError
require.ErrorAs(t, err, &notSecure)
})
}
}
func TestCheckRedirectFirstRequest(t *testing.T) {
t.Parallel()
require.NoError(t, checkRedirect(false)(mustGet(t, "http://example.com"), nil))
}
func TestCheckRedirectStopsAfterTenHops(t *testing.T) {
t.Parallel()
via := make([]*http.Request, 10)
for i := range via {
via[i] = mustGet(t, "https://example.com")
}
require.Error(t, checkRedirect(false)(mustGet(t, "https://example.com"), via))
}
// downgradeServers returns a TLS server redirecting to a plaintext one, and a
// flag reporting whether the plaintext one was ever reached.
func downgradeServers(t *testing.T) (*httptest.Server, *atomic.Bool) {
t.Helper()
var plainReached atomic.Bool
plain := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
plainReached.Store(true)
w.WriteHeader(http.StatusOK)
}))
t.Cleanup(plain.Close)
secure := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, plain.URL+"/Taskfile.yml", http.StatusFound)
}))
t.Cleanup(secure.Close)
return secure, &plainReached
}
func TestBuildHTTPClientRefusesDowngrade(t *testing.T) {
t.Parallel()
secure, plainReached := downgradeServers(t)
// The test server's certificate has to be trusted explicitly, so that the
// refusal is the redirect and not the handshake.
caCert := filepath.Join(t.TempDir(), "ca.crt")
require.NoError(t, os.WriteFile(caCert, pem.EncodeToMemory(&pem.Block{
Type: "CERTIFICATE", Bytes: secure.Certificate().Raw,
}), 0o600))
client, err := buildHTTPClient(false, caCert, "", "")
require.NoError(t, err)
_, err = client.Do(mustGet(t, secure.URL+"/Taskfile.yml")) //nolint:bodyclose // the request never completes
var notSecure *errors.TaskfileNotSecureError
require.ErrorAs(t, err, &notSecure)
assert.False(t, plainReached.Load(), "the plaintext server must never be contacted")
}
func TestBuildHTTPClientFollowsDowngradeWithInsecure(t *testing.T) {
t.Parallel()
secure, plainReached := downgradeServers(t)
client, err := buildHTTPClient(true, "", "", "")
require.NoError(t, err)
resp, err := client.Do(mustGet(t, secure.URL+"/Taskfile.yml"))
require.NoError(t, err)
defer resp.Body.Close()
assert.Equal(t, http.StatusOK, resp.StatusCode)
assert.True(t, plainReached.Load())
}
func mustGet(t *testing.T, rawURL string) *http.Request {
t.Helper()
req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, rawURL, nil)
require.NoError(t, err)
return req
}

View file

@ -51,7 +51,7 @@ func RemoteExists(ctx context.Context, u url.URL, client *http.Client) (*url.URL
if ctx.Err() != nil {
return nil, fmt.Errorf("checking remote file: %w", ctx.Err())
}
return nil, errors.TaskfileFetchFailedError{URI: u.Redacted()}
return nil, taskfileFetchError(err, u.Redacted())
}
defer resp.Body.Close()
@ -80,7 +80,7 @@ func RemoteExists(ctx context.Context, u url.URL, client *http.Client) (*url.URL
// Try the alternative URL
resp, err = client.Do(req)
if err != nil {
return nil, errors.TaskfileFetchFailedError{URI: u.Redacted()}
return nil, taskfileFetchError(err, u.Redacted())
}
defer resp.Body.Close()
@ -92,3 +92,12 @@ func RemoteExists(ctx context.Context, u url.URL, client *http.Client) (*url.URL
return nil, errors.TaskfileNotFoundError{URI: u.Redacted(), Walk: false}
}
// taskfileFetchError preserves redirect-policy errors wrapped by http.Client.
// Other transport errors remain generic download failures.
func taskfileFetchError(err error, uri string) error {
if notSecure, ok := errors.AsType[*errors.TaskfileNotSecureError](err); ok {
return notSecure
}
return errors.TaskfileFetchFailedError{URI: uri}
}

View file

@ -262,6 +262,10 @@ Taskfile that is downloaded via an unencrypted connection. Sources that are not
protected by TLS are vulnerable to man-in-the-middle attacks and should be
avoided unless you know what you are doing.
A server answering an `https` URL with a redirect to `http` is refused too,
unless you pass `--insecure` — the flag covers the whole download, not just the
URL you wrote.
#### Custom Certificates
If your remote Taskfiles are hosted on a server that uses a custom CA