mirror of
https://github.com/tailscale/tailscale.git
synced 2026-09-17 08:19:35 -04:00
Brad Fitzpatrick
2ee809d10d
The ts_omit_<name> build tags omit a feature at build time; there has
been no way to do the same at runtime. Some users (either proactively
or in response to a security announcement) might like a way to disable
a feature that's linked-in in their binaries that they're not using.
Then a mitigation announcement can say "set this env var" without
asking users to rebuild or wait for a new release.
This adds env var TS_DISABLE_FEATURE, a comma-separated list of
feature names to disable, and the listed set is reported by the
debug-optional-features LocalAPI endpoint next to the registered set.
The legacy per-feature knobs such as TS_DISABLE_SSH_SERVER and
TS_DISABLE_TAILDROP keep working independently.
A disabled feature behaves as if it had not been linked: it is absent
from feature.IsRegistered, its hooks are unset, and its extensions and
handlers are not registered. Three pieces make that happen:
* feature.Register now returns bool, false when disabled, and
feature packages gate their registration init on it. It was added
to the feature packages that never called it (including taildrop
and ssh), which also completes the picture reported by
debug-optional-features. taildrop, routecheck, favorites, and
serviceclientprefs had registration split across several inits and
now register from one gated init.
* ipnext.RegisterExtension ignores a disabled feature's extension.
* feature.Hook.Set and feature.Hooks.Add walk the call stack and
silently skip when the calling package under feature/<name> is
disabled. This covers sub-packages such as
feature/captiveportal/netcheckhook, which cannot call Register
themselves without colliding with their parent, and future
packages whose authors forget the gate.
ssh/tailssh's registrations moved from its inits into tailssh.Register,
called from feature/ssh's gated init. The aws and kube state stores and
syspolicy's Windows store registration are gated too.
feature/register_disable_test.go runs this test binary as a child
process (it links condregister, as tailscaled does) with
TS_DISABLE_FEATURE set to every registered feature at once, and fails
if any of them register anyway, so a feature that ignores the variable
cannot land.
Updates #12614
Signed-off-by: Brad Fitzpatrick <bradfitz@tailscale.com>
Change-Id: I720af6ccab844ae060a9dfd1539fee577fd483e3
91 lines
2.6 KiB
Go
91 lines
2.6 KiB
Go
// Copyright (c) Tailscale Inc & contributors
|
|
// SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
//go:build !ts_omit_aws
|
|
|
|
// Package awsparamstore registers support for fetching secret values from AWS
|
|
// Parameter Store.
|
|
package awsparamstore
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"strings"
|
|
|
|
"github.com/aws/aws-sdk-go-v2/aws"
|
|
"github.com/aws/aws-sdk-go-v2/aws/arn"
|
|
"github.com/aws/aws-sdk-go-v2/config"
|
|
"github.com/aws/aws-sdk-go-v2/service/ssm"
|
|
"tailscale.com/feature"
|
|
"tailscale.com/internal/client/tailscale"
|
|
)
|
|
|
|
func init() {
|
|
if !feature.Register("awsparamstore") {
|
|
return
|
|
}
|
|
tailscale.HookResolveValueFromParameterStore.Set(ResolveValue)
|
|
}
|
|
|
|
// parseARN parses and verifies that the input string is an
|
|
// ARN for AWS Parameter Store, returning the region and parameter name if so.
|
|
//
|
|
// If the input is not a valid Parameter Store ARN, it returns ok==false.
|
|
func parseARN(s string) (region, parameterName string, ok bool) {
|
|
parsed, err := arn.Parse(s)
|
|
if err != nil {
|
|
return "", "", false
|
|
}
|
|
|
|
if parsed.Service != "ssm" {
|
|
return "", "", false
|
|
}
|
|
parameterName, ok = strings.CutPrefix(parsed.Resource, "parameter/")
|
|
if !ok {
|
|
return "", "", false
|
|
}
|
|
|
|
// NOTE: parameter names must have a leading slash
|
|
return parsed.Region, "/" + parameterName, true
|
|
}
|
|
|
|
// ResolveValue fetches a value from AWS Parameter Store if the input
|
|
// looks like an SSM ARN (e.g., arn:aws:ssm:us-east-1:123456789012:parameter/my-secret).
|
|
//
|
|
// If the input is not a Parameter Store ARN, it returns the value unchanged.
|
|
//
|
|
// If the input is a Parameter Store ARN and fetching the parameter fails, it
|
|
// returns an error.
|
|
func ResolveValue(ctx context.Context, valueOrARN string) (string, error) {
|
|
// If it doesn't look like an ARN, return as-is
|
|
region, parameterName, ok := parseARN(valueOrARN)
|
|
if !ok {
|
|
return valueOrARN, nil
|
|
}
|
|
|
|
// Load AWS config with the region from the ARN
|
|
cfg, err := config.LoadDefaultConfig(ctx, config.WithRegion(region))
|
|
if err != nil {
|
|
return "", fmt.Errorf("loading AWS config in region %q: %w", region, err)
|
|
}
|
|
|
|
// Create SSM client and fetch the parameter
|
|
client := ssm.NewFromConfig(cfg)
|
|
output, err := client.GetParameter(ctx, &ssm.GetParameterInput{
|
|
// The parameter to fetch.
|
|
Name: aws.String(parameterName),
|
|
|
|
// If the parameter is a SecureString, decrypt it.
|
|
WithDecryption: aws.Bool(true),
|
|
})
|
|
if err != nil {
|
|
return "", fmt.Errorf("getting SSM parameter %q: %w", parameterName, err)
|
|
}
|
|
|
|
if output.Parameter == nil || output.Parameter.Value == nil {
|
|
return "", fmt.Errorf("SSM parameter %q has no value", parameterName)
|
|
}
|
|
|
|
return strings.TrimSpace(*output.Parameter.Value), nil
|
|
}
|