" returned the code as a success.
+ if scanErr := scanner.Err(); scanErr != nil {
+ return "", fmt.Errorf("error while reading pinentry output: %w", scanErr)
+ }
+
+ return output, err
+}
diff --git a/pkg/auth/providers/aws/saml2aws/prompter/pinentry_test.go b/pkg/auth/providers/aws/saml2aws/prompter/pinentry_test.go
new file mode 100644
index 00000000000..29d7040e79d
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/prompter/pinentry_test.go
@@ -0,0 +1,229 @@
+package prompter
+
+import (
+ "errors"
+ "strings"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+// creates a fake runner so we can perform unit tests
+type FakePinentryRunner struct {
+ HasRun bool
+ FakeOutput string
+ FakePinentryOutput string
+ PassedInput string
+}
+
+func (f *FakePinentryRunner) Run(cmd string) (string, error) {
+ f.PassedInput = cmd
+ f.HasRun = true
+ if f.FakeOutput != "" {
+ return f.FakeOutput, nil
+ }
+ if f.FakePinentryOutput != "" {
+ reader := strings.NewReader(f.FakePinentryOutput)
+ return ParseResults(reader)
+ }
+ return f.FakeOutput, nil
+}
+
+// FakeDefaultPrompter is a Mock prompter
+type FakeDefaultPrompter struct {
+ CalledRequestSecurityCode bool
+ CalledChoose bool
+ CalledChooseWithDefault bool
+ CalledString bool
+ CalledStringRequired bool
+ CalledPassword bool
+ CalledDisplay bool
+}
+
+// all the functions to implement the Prompter interface
+func (f *FakeDefaultPrompter) RequestSecurityCode(p string) (string, error) {
+ f.CalledRequestSecurityCode = true
+ return "", nil
+}
+
+func (f *FakeDefaultPrompter) Choose(p string, option []string) (int, error) {
+ f.CalledChoose = true
+ return 0, nil
+}
+
+func (f *FakeDefaultPrompter) ChooseWithDefault(p string, d string, c []string) (string, error) {
+ f.CalledChooseWithDefault = true
+ return "", nil
+}
+
+func (f *FakeDefaultPrompter) String(p string, defaultValue string) (string, error) {
+ f.CalledString = true
+ return "", nil
+}
+
+func (f *FakeDefaultPrompter) StringRequired(p string) (string, error) {
+ f.CalledStringRequired = true
+ return "", nil
+}
+
+func (f *FakeDefaultPrompter) Password(p string) (string, error) {
+ f.CalledPassword = true
+ return "", nil
+}
+
+func (f *FakeDefaultPrompter) Display(p string) {
+ f.CalledDisplay = true
+}
+
+func TestValidateAndSetPrompterShouldFailWithWrongInput(t *testing.T) {
+ // backing up the current prompters for the other tests
+ oldPrompter := ActivePrompter
+ defer func() { ActivePrompter = oldPrompter }()
+
+ errPrompts := []string{"abcde", "invalid", "prompt", " ", "pinentryfake"}
+ for _, errPrompt := range errPrompts {
+ err := ValidateAndSetPrompter(errPrompt)
+ assert.Error(t, err)
+ }
+}
+
+func TestValidateAndSetPrompterShouldWorkWithInputForCli(t *testing.T) {
+ // backing up the current prompters for the other tests
+ oldPrompter := ActivePrompter
+ defer func() { ActivePrompter = oldPrompter }()
+
+ errPrompts := []string{"", "default", "survey"}
+ for _, errPrompt := range errPrompts {
+ err := ValidateAndSetPrompter(errPrompt)
+ assert.NoError(t, err)
+ assert.IsType(t, ActivePrompter, NewCli())
+ }
+}
+
+// Regression: selecting a default alias after pinentry resets the active prompter, and an invalid
+// value leaves the active prompter unchanged.
+func TestValidateAndSetPrompterDefaultAliasesResetPinentry(t *testing.T) {
+ oldPrompter := ActivePrompter
+ defer func() { ActivePrompter = oldPrompter }()
+
+ for _, alias := range []string{"", "default", "survey"} {
+ require.NoError(t, ValidateAndSetPrompter("pinentry"))
+ assert.IsType(t, &PinentryPrompter{}, ActivePrompter)
+
+ require.NoError(t, ValidateAndSetPrompter(alias))
+ assert.IsType(t, &CliPrompter{}, ActivePrompter)
+ }
+
+ require.NoError(t, ValidateAndSetPrompter("pinentry"))
+ require.Error(t, ValidateAndSetPrompter("invalid"))
+ assert.IsType(t, &PinentryPrompter{}, ActivePrompter)
+}
+
+// scannerErrReader returns data and then a read error.
+type scannerErrReader struct{ done bool }
+
+func (r *scannerErrReader) Read(p []byte) (int, error) {
+ if r.done {
+ return 0, errors.New("read failed")
+ }
+ r.done = true
+ return copy(p, "D 123456\n"), nil
+}
+
+// Regression: a reader failure after "D " must not return the code as a successful result.
+func TestParseResultsReturnsScannerError(t *testing.T) {
+ output, err := ParseResults(&scannerErrReader{})
+ require.Error(t, err)
+ assert.Empty(t, output)
+}
+
+func TestValidateAndSetPrompterShouldWorkWithInputForPinentry(t *testing.T) {
+ // backing up the current prompters for the other tests
+ oldPrompter := ActivePrompter
+ defer func() { ActivePrompter = oldPrompter }()
+
+ errPrompts := []string{"pinentry", "pinentry-tty", "pinentry-mac", "pinentry-gnome3"}
+ for _, errPrompt := range errPrompts {
+ err := ValidateAndSetPrompter(errPrompt)
+ assert.NoError(t, err)
+ assert.IsType(t, ActivePrompter, &PinentryPrompter{})
+ }
+}
+
+func TestChecksPinentryPrompterDefault(t *testing.T) {
+ p := &PinentryPrompter{}
+ fakeDefaultPrompter := &FakeDefaultPrompter{}
+ p.DefaultPrompter = fakeDefaultPrompter
+
+ _, _ = p.Choose("random", []string{"1", "2"})
+ assert.True(t, fakeDefaultPrompter.CalledChoose)
+
+ _, _ = p.ChooseWithDefault("random", "random", []string{"1", "2"})
+ assert.True(t, fakeDefaultPrompter.CalledChooseWithDefault)
+
+ _, _ = p.String("random", "random")
+ assert.True(t, fakeDefaultPrompter.CalledString)
+
+ _, _ = p.StringRequired("random")
+ assert.True(t, fakeDefaultPrompter.CalledStringRequired)
+
+ _, _ = p.Password("random")
+ assert.True(t, fakeDefaultPrompter.CalledPassword)
+
+ p.Display("random")
+ assert.True(t, fakeDefaultPrompter.CalledDisplay)
+}
+
+func TestChecksPinentryPrompterCallsPinentryForRequestSecurityCode(t *testing.T) {
+ p := &PinentryPrompter{}
+ runner := &FakePinentryRunner{}
+ p.Runner = runner
+ runner.FakeOutput = "random_code"
+ pinentryOutput, err := p.RequestSecurityCode("000000")
+
+ assert.NoError(t, err)
+ assert.True(t, runner.HasRun)
+ assert.Equal(t, pinentryOutput, "random_code")
+ assert.Equal(t, runner.PassedInput, "SETPROMPT Security token [000000]\nGETPIN\n")
+}
+
+func TestChecksPinentryPrompterReturnsRightCodeGivenFakePinentryOutput(t *testing.T) {
+ p := &PinentryPrompter{}
+ runner := &FakePinentryRunner{}
+ p.Runner = runner
+ runner.FakePinentryOutput = "OK This line should get ignored\nOK This line should too\nD 654321\nOK Final\n"
+ pinentryOutput, err := p.RequestSecurityCode("000000")
+
+ assert.NoError(t, err)
+ assert.True(t, runner.HasRun)
+ assert.Equal(t, pinentryOutput, "654321")
+}
+
+func TestChecksPinentryPrompterReturnsNoCodeGivenErroneousFakePinentryOutput(t *testing.T) {
+ p := &PinentryPrompter{}
+ runner := &FakePinentryRunner{}
+ p.Runner = runner
+ runner.FakePinentryOutput = "OK This line should get ignored\nOK This line should too\nERR This is an error\nD 654321\nOK Final\n"
+ pinentryOutput, err := p.RequestSecurityCode("000000")
+
+ assert.Error(t, err)
+ assert.True(t, runner.HasRun)
+ assert.Equal(t, pinentryOutput, "")
+}
+
+func TestParseOutputShouldThrowError(t *testing.T) {
+ input := strings.NewReader("OK Ignore this line\nERR This is an error\nD This result should be ignored\nOK this is irrelevant\n")
+ output, err := ParseResults(input)
+
+ assert.Error(t, err)
+ assert.Equal(t, output, "")
+}
+
+func TestParseOutputShouldReturnCorrectOutput(t *testing.T) {
+ input := strings.NewReader("OK Ignore this line\nD THISISTHERETURN\nOK this is irrelevant\n")
+ output, err := ParseResults(input)
+
+ assert.NoError(t, err)
+ assert.Equal(t, output, "THISISTHERETURN")
+}
diff --git a/pkg/auth/providers/aws/saml2aws/prompter/prompter.go b/pkg/auth/providers/aws/saml2aws/prompter/prompter.go
new file mode 100644
index 00000000000..6326861b55e
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/prompter/prompter.go
@@ -0,0 +1,88 @@
+package prompter
+
+import (
+ "fmt"
+ "regexp"
+)
+
+// ActivePrompter is by default the survey cli prompter
+var ActivePrompter Prompter = NewCli()
+
+// Prompter handles prompting user for input
+type Prompter interface {
+ // Atmos fork: the prompting methods return an error (for example when the user cancels with Ctrl+C
+ // or no terminal is available) so callers can stop instead of continuing with a zero value.
+ RequestSecurityCode(string) (string, error)
+ ChooseWithDefault(string, string, []string) (string, error)
+ Choose(string, []string) (int, error)
+ StringRequired(string) (string, error)
+ String(string, string) (string, error)
+ Password(string) (string, error)
+ Display(string)
+}
+
+// SetPrompter configure an aternate prompter to the default one
+func SetPrompter(prmpt Prompter) {
+ ActivePrompter = prmpt
+}
+
+// ValidateAndSetPrompter validates the user configuration and will create
+// a concrete prompter based on this configuration
+func ValidateAndSetPrompter(prmptCfg string) error {
+ if prmptCfg == "" || prmptCfg == "survey" || prmptCfg == "default" {
+ // Atmos fork: reset to the survey prompter so an earlier pinentry selection does not stay active.
+ SetPrompter(NewCli())
+ return nil
+ }
+
+ // all pinentry programs will start with `pinentry`
+ re := regexp.MustCompile(`^pinentry(-.*)?$`)
+ if re.MatchString(prmptCfg) {
+ SetPrompter(NewPinentryPrompter(prmptCfg))
+ return nil
+ }
+
+ return fmt.Errorf("prompter %s is not valid", prmptCfg)
+}
+
+// RequestSecurityCode request a security code to be entered by the user
+func RequestSecurityCode(pattern string) (string, error) {
+ return ActivePrompter.RequestSecurityCode(pattern)
+}
+
+// ChooseWithDefault given the choice return the option selected with a default
+func ChooseWithDefault(pr string, defaultValue string, options []string) (string, error) {
+ // ensure the default is not empty and avoid bad input error
+ if defaultValue == "" {
+ if len(options) > 0 {
+ defaultValue = options[0]
+ }
+ }
+
+ return ActivePrompter.ChooseWithDefault(pr, defaultValue, options)
+}
+
+// Choose given the choice return the option selected
+func Choose(pr string, options []string) (int, error) {
+ return ActivePrompter.Choose(pr, options)
+}
+
+// StringRequired prompt for string which is required
+func StringRequired(pr string) (string, error) {
+ return ActivePrompter.StringRequired(pr)
+}
+
+// String prompt for string which is required
+func String(pr string, defaultValue string) (string, error) {
+ return ActivePrompter.String(pr, defaultValue)
+}
+
+// Password prompt for password which is required
+func Password(pr string) (string, error) {
+ return ActivePrompter.Password(pr)
+}
+
+// Display prompt, no user input required
+func Display(pr string) {
+ ActivePrompter.Display(pr)
+}
diff --git a/pkg/auth/providers/aws/saml2aws/prompter/prompter_test.go b/pkg/auth/providers/aws/saml2aws/prompter/prompter_test.go
new file mode 100644
index 00000000000..d78105b03e7
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/prompter/prompter_test.go
@@ -0,0 +1,218 @@
+package prompter
+
+import (
+ "io"
+ "os"
+ "path/filepath"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+// recordingPrompter records the arguments it was called with.
+type recordingPrompter struct {
+ calls []string
+ lastPrompt string
+ lastDefault string
+ lastOptions []string
+ chooseResult string
+}
+
+func (r *recordingPrompter) RequestSecurityCode(pattern string) (string, error) {
+ r.calls = append(r.calls, "RequestSecurityCode")
+ r.lastPrompt = pattern
+ return "123456", nil
+}
+
+func (r *recordingPrompter) ChooseWithDefault(pr, def string, options []string) (string, error) {
+ r.calls = append(r.calls, "ChooseWithDefault")
+ r.lastPrompt, r.lastDefault, r.lastOptions = pr, def, options
+ return r.chooseResult, nil
+}
+
+func (r *recordingPrompter) Choose(pr string, options []string) (int, error) {
+ r.calls = append(r.calls, "Choose")
+ r.lastPrompt, r.lastOptions = pr, options
+ return len(options) - 1, nil
+}
+
+func (r *recordingPrompter) StringRequired(pr string) (string, error) {
+ r.calls = append(r.calls, "StringRequired")
+ r.lastPrompt = pr
+ return "required", nil
+}
+
+func (r *recordingPrompter) String(pr, def string) (string, error) {
+ r.calls = append(r.calls, "String")
+ r.lastPrompt, r.lastDefault = pr, def
+ return "value", nil
+}
+
+func (r *recordingPrompter) Password(pr string) (string, error) {
+ r.calls = append(r.calls, "Password")
+ r.lastPrompt = pr
+ return "secret", nil
+}
+
+func (r *recordingPrompter) Display(pr string) {
+ r.calls = append(r.calls, "Display")
+ r.lastPrompt = pr
+}
+
+// useRecordingPrompter installs a recording prompter for the duration of a test.
+func useRecordingPrompter(t *testing.T) *recordingPrompter {
+ t.Helper()
+ orig := ActivePrompter
+ rec := &recordingPrompter{chooseResult: "picked"}
+ SetPrompter(rec)
+ t.Cleanup(func() { SetPrompter(orig) })
+ return rec
+}
+
+func TestPackageFunctionsDelegateToActivePrompter(t *testing.T) {
+ rec := useRecordingPrompter(t)
+
+ code, err := RequestSecurityCode("000000")
+ require.NoError(t, err)
+ assert.Equal(t, "123456", code)
+ assert.Equal(t, "000000", rec.lastPrompt)
+
+ index, err := Choose("Pick", []string{"a", "b"})
+ require.NoError(t, err)
+ assert.Equal(t, 1, index)
+ assert.Equal(t, []string{"a", "b"}, rec.lastOptions)
+
+ required, err := StringRequired("Username")
+ require.NoError(t, err)
+ assert.Equal(t, "required", required)
+ assert.Equal(t, "Username", rec.lastPrompt)
+
+ value, err := String("Region", "us-east-1")
+ require.NoError(t, err)
+ assert.Equal(t, "value", value)
+ assert.Equal(t, "us-east-1", rec.lastDefault)
+
+ secret, err := Password("Password")
+ require.NoError(t, err)
+ assert.Equal(t, "secret", secret)
+ assert.Equal(t, "Password", rec.lastPrompt)
+
+ Display("hello")
+ assert.Equal(t, "hello", rec.lastPrompt)
+
+ assert.Equal(t, []string{"RequestSecurityCode", "Choose", "StringRequired", "String", "Password", "Display"}, rec.calls)
+}
+
+func TestChooseWithDefault(t *testing.T) {
+ tests := []struct {
+ name string
+ def string
+ options []string
+ wantDefault string
+ }{
+ {name: "explicit default kept", def: "b", options: []string{"a", "b"}, wantDefault: "b"},
+ {name: "empty default uses first option", def: "", options: []string{"a", "b"}, wantDefault: "a"},
+ {name: "empty default without options", def: "", options: nil, wantDefault: ""},
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ rec := useRecordingPrompter(t)
+
+ got, err := ChooseWithDefault("Pick a role", tt.def, tt.options)
+ require.NoError(t, err)
+ assert.Equal(t, "picked", got)
+ assert.Equal(t, "Pick a role", rec.lastPrompt)
+ assert.Equal(t, tt.wantDefault, rec.lastDefault)
+ assert.Equal(t, tt.options, rec.lastOptions)
+ })
+ }
+}
+
+func TestNewPinentryPrompter(t *testing.T) {
+ p := NewPinentryPrompter("pinentry-mac")
+
+ runner, ok := p.Runner.(*RealPinentryRunner)
+ require.True(t, ok)
+ assert.Equal(t, "pinentry-mac", runner.PinentryBin)
+ assert.IsType(t, &CliPrompter{}, p.DefaultPrompter)
+}
+
+func TestCliPrompterDisplay(t *testing.T) {
+ r, w, err := os.Pipe()
+ require.NoError(t, err)
+ origStderr := os.Stderr
+ os.Stderr = w
+ t.Cleanup(func() { os.Stderr = origStderr })
+
+ NewCli().Display("Open your authenticator app")
+ require.NoError(t, w.Close())
+ os.Stderr = origStderr
+
+ out, err := io.ReadAll(r)
+ require.NoError(t, err)
+ assert.Equal(t, "Open your authenticator app\n", string(out))
+}
+
+func TestRealPinentryRunner(t *testing.T) {
+ exe, err := os.Executable()
+ require.NoError(t, err)
+
+ tests := []struct {
+ mode string
+ want string
+ wantErr string
+ }{
+ {mode: "ok", want: "424242"},
+ {mode: "cancel", wantErr: "Operation cancelled"},
+ {mode: "crash", wantErr: "exit status 2"},
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.mode, func(t *testing.T) {
+ t.Setenv(fakePinentryEnv, tt.mode)
+
+ out, err := NewRealPinentryRunner(exe).Run(expectedPinentryInput)
+ if tt.wantErr != "" {
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), tt.wantErr)
+ assert.Empty(t, out)
+ return
+ }
+ require.NoError(t, err)
+ assert.Equal(t, tt.want, out)
+ })
+ }
+}
+
+func TestPinentryPrompterEndToEnd(t *testing.T) {
+ exe, err := os.Executable()
+ require.NoError(t, err)
+
+ tests := []struct {
+ mode string
+ want string
+ wantErr bool
+ }{
+ {mode: "ok", want: "424242"},
+ {mode: "cancel", want: "", wantErr: true},
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.mode, func(t *testing.T) {
+ t.Setenv(fakePinentryEnv, tt.mode)
+ got, err := NewPinentryPrompter(exe).RequestSecurityCode("000000")
+ assert.Equal(t, tt.wantErr, err != nil)
+ assert.Equal(t, tt.want, got)
+ })
+ }
+}
+
+func TestRealPinentryRunnerMissingBinary(t *testing.T) {
+ missing := filepath.Join(t.TempDir(), "pinentry-does-not-exist")
+
+ out, err := NewRealPinentryRunner(missing).Run(expectedPinentryInput)
+ require.Error(t, err)
+ assert.Empty(t, out)
+}
diff --git a/pkg/auth/providers/aws/saml2aws/prompter/survey.go b/pkg/auth/providers/aws/saml2aws/prompter/survey.go
new file mode 100644
index 00000000000..77838502c1d
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/prompter/survey.go
@@ -0,0 +1,127 @@
+package prompter
+
+import (
+ "errors"
+ "fmt"
+ "os"
+
+ survey "github.com/AlecAivazis/survey/v2"
+ survey_terminal "github.com/AlecAivazis/survey/v2/terminal"
+)
+
+// outputWriter is where for all prompts will be printed. Defaults to os.Stder.
+var outputWriter survey_terminal.FileWriter = os.Stderr
+
+// CliPrompter used to prompt for cli input
+type CliPrompter struct{}
+
+// SetOutputWriter sets the output writer to use for all survey operations
+func SetOutputWriter(writer survey_terminal.FileWriter) {
+ outputWriter = writer
+}
+
+// stdioOption returns the IO option to use for survey functions
+func stdioOption() survey.AskOpt {
+ return survey.WithStdio(os.Stdin, outputWriter, os.Stderr)
+}
+
+// NewCli builds a new cli prompter
+func NewCli() *CliPrompter {
+ return &CliPrompter{}
+}
+
+// RequestSecurityCode request a security code to be entered by the user
+func (cli *CliPrompter) RequestSecurityCode(pattern string) (string, error) {
+ token := ""
+ prompt := &survey.Input{
+ Message: fmt.Sprintf("Security Token [%s]", pattern),
+ }
+ if err := survey.AskOne(prompt, &token, survey.WithValidator(survey.Required), stdioOption()); err != nil {
+ return "", err
+ }
+ return token, nil
+}
+
+// ChooseWithDefault given the choice return the option selected with a default
+func (cli *CliPrompter) ChooseWithDefault(pr string, defaultValue string, options []string) (string, error) {
+ selected := ""
+ prompt := &survey.Select{
+ Message: pr,
+ Options: options,
+ Default: defaultValue,
+ }
+ // Atmos fork: propagate prompt failures (for example Ctrl+C) instead of discarding them.
+ if err := survey.AskOne(prompt, &selected, survey.WithValidator(survey.Required), stdioOption()); err != nil {
+ return "", err
+ }
+
+ // return the selected element index
+ for i, option := range options {
+ if selected == option {
+ return options[i], nil
+ }
+ }
+ return "", errors.New("bad input")
+}
+
+// Choose given the choice return the option selected
+func (cli *CliPrompter) Choose(pr string, options []string) (int, error) {
+ selected := ""
+ prompt := &survey.Select{
+ Message: pr,
+ Options: options,
+ }
+ // Atmos fork: propagate prompt failures instead of silently selecting the first option.
+ if err := survey.AskOne(prompt, &selected, survey.WithValidator(survey.Required), stdioOption()); err != nil {
+ return 0, err
+ }
+
+ // return the selected element index
+ for i, option := range options {
+ if selected == option {
+ return i, nil
+ }
+ }
+ return 0, errors.New("bad input")
+}
+
+// String prompt for string with a default
+func (cli *CliPrompter) String(pr string, defaultValue string) (string, error) {
+ val := ""
+ prompt := &survey.Input{
+ Message: pr,
+ Default: defaultValue,
+ }
+ if err := survey.AskOne(prompt, &val, stdioOption()); err != nil {
+ return "", err
+ }
+ return val, nil
+}
+
+// StringRequired prompt for string which is required
+func (cli *CliPrompter) StringRequired(pr string) (string, error) {
+ val := ""
+ prompt := &survey.Input{
+ Message: pr,
+ }
+ if err := survey.AskOne(prompt, &val, survey.WithValidator(survey.Required), stdioOption()); err != nil {
+ return "", err
+ }
+ return val, nil
+}
+
+// Password prompt for password which is required
+func (cli *CliPrompter) Password(pr string) (string, error) {
+ val := ""
+ prompt := &survey.Password{
+ Message: pr,
+ }
+ if err := survey.AskOne(prompt, &val, stdioOption()); err != nil {
+ return "", err
+ }
+ return val, nil
+}
+
+func (cli *CliPrompter) Display(pr string) {
+ _, _ = os.Stderr.WriteString(pr + "\n")
+}
diff --git a/pkg/auth/providers/aws/saml2aws/prompter/survey_test.go b/pkg/auth/providers/aws/saml2aws/prompter/survey_test.go
new file mode 100644
index 00000000000..628ba731024
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/prompter/survey_test.go
@@ -0,0 +1,65 @@
+package prompter
+
+import (
+ "os"
+ "path/filepath"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+// useNonInteractiveStdio points the survey prompts at a closed, non-terminal stdin and a
+// temporary output file for the duration of a test.
+func useNonInteractiveStdio(t *testing.T) {
+ t.Helper()
+
+ r, w, err := os.Pipe()
+ require.NoError(t, err)
+ require.NoError(t, w.Close())
+
+ out, err := os.Create(filepath.Join(t.TempDir(), "prompts.txt"))
+ require.NoError(t, err)
+
+ origStdin, origOutput := os.Stdin, outputWriter
+ os.Stdin = r
+ SetOutputWriter(out)
+ t.Cleanup(func() {
+ os.Stdin = origStdin
+ SetOutputWriter(origOutput)
+ _ = r.Close()
+ _ = out.Close()
+ })
+}
+
+// Without a terminal the survey prompts cannot collect input. They must return
+// promptly with zero values rather than block or panic.
+func TestCliPrompterWithoutTerminal(t *testing.T) {
+ useNonInteractiveStdio(t)
+ cli := NewCli()
+
+ // Atmos fork: prompt failures are propagated, never turned into a default selection or an empty value.
+ code, err := cli.RequestSecurityCode("000000")
+ require.Error(t, err)
+ assert.Empty(t, code)
+
+ value, err := cli.String("Region", "us-east-1")
+ require.Error(t, err)
+ assert.Empty(t, value)
+
+ required, err := cli.StringRequired("Username")
+ require.Error(t, err)
+ assert.Empty(t, required)
+
+ secret, err := cli.Password("Password")
+ require.Error(t, err)
+ assert.Empty(t, secret)
+
+ index, err := cli.Choose("Pick", []string{"a", "b"})
+ require.Error(t, err)
+ assert.Equal(t, 0, index)
+
+ selected, err := cli.ChooseWithDefault("Pick", "b", []string{"a", "b"})
+ require.Error(t, err)
+ assert.Empty(t, selected)
+}
diff --git a/pkg/auth/providers/aws/saml2aws/prompter/testmain_test.go b/pkg/auth/providers/aws/saml2aws/prompter/testmain_test.go
new file mode 100644
index 00000000000..96811848509
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/prompter/testmain_test.go
@@ -0,0 +1,50 @@
+package prompter
+
+import (
+ "io"
+ "os"
+ "testing"
+)
+
+// fakePinentryEnv selects a fake pinentry behavior when the test binary is re-executed
+// as a pinentry program. This keeps the subprocess tests cross-platform.
+const fakePinentryEnv = "_SAML2AWS_TEST_FAKE_PINENTRY"
+
+const expectedPinentryInput = "SETPROMPT Security token [000000]\nGETPIN\n"
+
+func TestMain(m *testing.M) {
+ if mode := os.Getenv(fakePinentryEnv); mode != "" {
+ os.Exit(runFakePinentry(mode))
+ }
+ os.Exit(m.Run())
+}
+
+// runFakePinentry speaks a minimal subset of the Assuan protocol used by pinentry.
+func runFakePinentry(mode string) int {
+ input, err := io.ReadAll(os.Stdin)
+ if err != nil {
+ return 3
+ }
+ if len(os.Args) != 3 || os.Args[1] != "--ttyname" || os.Args[2] != "/dev/tty" {
+ _, _ = os.Stdout.WriteString("ERR 1 unexpected arguments\n")
+ return 0
+ }
+ if string(input) != expectedPinentryInput {
+ _, _ = os.Stdout.WriteString("ERR 2 unexpected input\n")
+ return 0
+ }
+
+ switch mode {
+ case "ok":
+ _, _ = os.Stdout.WriteString("OK Pleased to meet you\nOK\nD 424242\nOK\n")
+ return 0
+ case "cancel":
+ _, _ = os.Stdout.WriteString("OK Pleased to meet you\nOK\nERR 83886179 Operation cancelled\n")
+ return 0
+ case "crash":
+ _, _ = os.Stdout.WriteString("OK Pleased to meet you\nOK\nD 424242\n")
+ return 2
+ default:
+ return 4
+ }
+}
diff --git a/pkg/auth/providers/aws/saml2aws/provider/adfs/adfs.go b/pkg/auth/providers/aws/saml2aws/provider/adfs/adfs.go
new file mode 100644
index 00000000000..1ed8fcbbf43
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/provider/adfs/adfs.go
@@ -0,0 +1,349 @@
+package adfs
+
+import (
+ "crypto/tls"
+ "fmt"
+ "log"
+ "net/http"
+ "net/url"
+ "strings"
+ "time"
+
+ "github.com/PuerkitoBio/goquery"
+ "github.com/pkg/errors"
+
+ "github.com/cloudposse/atmos/pkg/auth/providers/aws/saml2aws/cfg"
+ "github.com/cloudposse/atmos/pkg/auth/providers/aws/saml2aws/creds"
+ "github.com/cloudposse/atmos/pkg/auth/providers/aws/saml2aws/prompter"
+ "github.com/cloudposse/atmos/pkg/auth/providers/aws/saml2aws/provider"
+)
+
+// Client wrapper around ADFS enabling authentication and retrieval of assertions
+type Client struct {
+ provider.ValidateBase
+
+ client *provider.HTTPClient
+ idpAccount *cfg.IDPAccount
+}
+
+type AuthResponseType int
+
+const (
+ UNKNOWN AuthResponseType = iota
+ SAML_RESPONSE
+ MFA_PROMPT
+ AZURE_MFA_WAIT
+ AZURE_MFA_SERVER_WAIT
+)
+
+// Atmos fork: the Azure MFA poll interval is a package variable (upstream hard-coded
+// time.Sleep(1 * time.Second)) so tests can shorten it.
+var azureMFAPollInterval = 1 * time.Second
+
+// Atmos fork: upstream looped without a limit, so a server that kept returning an MFA page
+// prompted for codes, or polled, forever. The limits below end the loop with ErrMFAAttemptsExceeded.
+const (
+ // maxMFAPromptAttempts is the number of one-time codes submitted before giving up.
+ maxMFAPromptAttempts = 5
+ // maxAzureMFAPolls is the number of Azure MFA approval polls before giving up
+ // (about five minutes at the default one-second poll interval).
+ maxAzureMFAPolls = 300
+)
+
+// ErrMFAAttemptsExceeded is returned when the server keeps asking for MFA after the attempt limit.
+var ErrMFAAttemptsExceeded = errors.New("too many MFA attempts")
+
+// New create a new ADFS client
+func New(idpAccount *cfg.IDPAccount) (*Client, error) {
+ tr := &http.Transport{
+ Proxy: http.ProxyFromEnvironment,
+ // Atmos fork: explicit TLS 1.2 floor (upstream left MinVersion unset). Not TLS 1.3:
+ // renegotiation, which ADFS relies on, only exists up to TLS 1.2.
+ TLSClientConfig: &tls.Config{MinVersion: provider.MinTLSVersion, InsecureSkipVerify: idpAccount.SkipVerify, Renegotiation: tls.RenegotiateFreelyAsClient}, //nolint:gosec // Skipping verification is an explicit, user-configured opt-in (skip_verify).
+ }
+
+ client, err := provider.NewHTTPClient(tr, provider.BuildHttpClientOpts(idpAccount))
+ if err != nil {
+ return nil, errors.Wrap(err, "error building http client")
+ }
+
+ return &Client{
+ client: client,
+ idpAccount: idpAccount,
+ }, nil
+}
+
+// Authenticate to ADFS and return the data from the body of the SAML assertion.
+func (ac *Client) Authenticate(loginDetails *creds.LoginDetails) (string, error) {
+ var authSubmitURL string
+ var samlAssertion string
+ var instructions string
+
+ awsURN := url.QueryEscape(ac.idpAccount.AmazonWebservicesURN)
+
+ adfsURL := fmt.Sprintf("%s/adfs/ls/IdpInitiatedSignOn.aspx?loginToRp=%s", loginDetails.URL, awsURN)
+
+ mfaToken := loginDetails.MFAToken
+
+ doc, err := ac.get(adfsURL)
+ if err != nil {
+ return "", errors.Wrap(err, "failed to get adfs page")
+ }
+
+ authForm := url.Values{}
+
+ doc.Find("input").Each(func(i int, s *goquery.Selection) {
+ updateFormData(authForm, s, loginDetails)
+ })
+
+ doc.Find("form").Each(func(i int, s *goquery.Selection) {
+ action, ok := s.Attr("action")
+ if !ok {
+ return
+ }
+ authSubmitURL = action
+ })
+
+ // Trim whitespace and discard empty values from Kmsi field
+ if val, ok := authForm["Kmsi"]; ok {
+ var trimmedKmsi []string
+ var t string
+ for _, s := range val {
+ t = strings.TrimSpace(s)
+ if len(t) > 0 {
+ trimmedKmsi = append(trimmedKmsi, t)
+ }
+ }
+ authForm["Kmsi"] = trimmedKmsi
+ }
+
+ if authSubmitURL == "" {
+ return samlAssertion, fmt.Errorf("unable to locate IDP authentication form submit URL")
+ } else {
+ //
+ // Atmos fork: resolve every action against the login page URL. Upstream resolved only actions that start
+ // with "/", so "?step=password" or "step=password" reached the HTTP client without a scheme.
+ // ResolveReference leaves absolute URLs unchanged.
+ //
+ parsedUrl, err := url.Parse(adfsURL)
+ if err != nil {
+ return "", errors.Wrap(err, "failed to parse ADFS URL")
+ }
+ parsedPath, err := url.Parse(authSubmitURL)
+ if err != nil {
+ return "", errors.Wrap(err, "failed to parse authSubmitURL fragment")
+ }
+ authSubmitURL = parsedUrl.ResolveReference(parsedPath).String()
+ }
+
+ doc, err = ac.submit(authSubmitURL, authForm)
+ if err != nil {
+ return samlAssertion, errors.Wrap(err, "failed to submit adfs auth form")
+ }
+
+ mfaPromptAttempts, azureMFAPolls := 0, 0
+ for {
+ responseType, samlAssertion, err := checkResponse(doc)
+
+ switch responseType {
+ case SAML_RESPONSE:
+ return samlAssertion, err
+ case MFA_PROMPT:
+ if mfaPromptAttempts >= maxMFAPromptAttempts {
+ return "", fmt.Errorf("%w: the server asked for a one-time code %d times", ErrMFAAttemptsExceeded, mfaPromptAttempts)
+ }
+ mfaPromptAttempts++
+ otpForm := url.Values{}
+ if mfaToken == "" {
+ mfaToken, err = prompter.RequestSecurityCode("000000")
+ if err != nil {
+ return samlAssertion, errors.Wrap(err, "error reading the MFA code")
+ }
+ }
+
+ doc.Find("input").Each(func(i int, s *goquery.Selection) {
+ updateOTPFormData(otpForm, s, mfaToken)
+ })
+ doc, err = ac.submit(authSubmitURL, otpForm)
+ if err != nil {
+ return samlAssertion, errors.Wrap(err, "error retrieving mfa form results")
+ }
+ mfaToken = ""
+ case AZURE_MFA_SERVER_WAIT:
+ fallthrough
+ case AZURE_MFA_WAIT:
+ if azureMFAPolls >= maxAzureMFAPolls {
+ return "", fmt.Errorf("%w: no Azure MFA approval after %d polls", ErrMFAAttemptsExceeded, azureMFAPolls)
+ }
+ azureMFAPolls++
+ azureForm := url.Values{}
+ doc.Find("input").Each(func(i int, s *goquery.Selection) {
+ updatePassthroughFormData(azureForm, s)
+ })
+ sel := doc.Find("p#validEntropyNumber")
+ if sel.Index() != -1 {
+ if instructions != sel.Text() {
+ instructions = sel.Text()
+ log.Println("Open your Microsoft Authenticator app and tap the number you see below to sign in.")
+ log.Println(instructions)
+ }
+ }
+ sel = doc.Find("p#instructions")
+ if sel.Index() != -1 {
+ if instructions != sel.Text() {
+ instructions = sel.Text()
+ log.Println(instructions)
+ }
+ }
+ time.Sleep(azureMFAPollInterval)
+ doc, err = ac.submit(authSubmitURL, azureForm)
+ if err != nil {
+ return samlAssertion, errors.Wrap(err, "error retrieving mfa form results")
+ }
+ if responseType == AZURE_MFA_SERVER_WAIT {
+ sel := doc.Find("label#errorText")
+ if sel.Index() != -1 {
+ return samlAssertion, errors.New(sel.Text())
+ }
+ }
+ case UNKNOWN:
+ return samlAssertion, errors.New("unable to classify response from auth server")
+ }
+ }
+}
+
+func (ac *Client) get(url string) (*goquery.Document, error) {
+ res, err := ac.client.Get(url)
+ if err != nil {
+ return nil, errors.Wrap(err, "error retieving form")
+ }
+ defer res.Body.Close()
+
+ doc, err := goquery.NewDocumentFromReader(res.Body)
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to build document from response")
+ }
+ return doc, nil
+}
+
+func (ac *Client) submit(url string, form url.Values) (*goquery.Document, error) {
+ req, err := http.NewRequest("POST", url, strings.NewReader(form.Encode()))
+ if err != nil {
+ return nil, errors.Wrap(err, "error building request")
+ }
+
+ req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+
+ res, err := ac.client.Do(req)
+ if err != nil {
+ return nil, errors.Wrap(err, "error submitting form")
+ }
+ defer res.Body.Close()
+
+ doc, err := goquery.NewDocumentFromReader(res.Body)
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to build document from response")
+ }
+ return doc, nil
+}
+
+func checkResponse(doc *goquery.Document) (AuthResponseType, string, error) {
+ samlAssertion := ""
+ responseType := UNKNOWN
+ var checkErr error
+
+ doc.Find("input").Each(func(i int, s *goquery.Selection) {
+ name, ok := s.Attr("name")
+ if !ok {
+ // Atmos fork: upstream called log.Fatalf here, terminating the whole process
+ // whenever the response page contained an unnamed (for example a
+ // submit button). Unnamed inputs carry no form data, so skip them.
+ return
+ }
+ if name == "SAMLResponse" {
+ val, ok := s.Attr("value")
+ if !ok {
+ // Atmos fork: upstream called log.Fatalf here; return an error instead.
+ checkErr = errors.New("unable to locate saml assertion value")
+ }
+ samlAssertion = val
+ responseType = SAML_RESPONSE
+ }
+ if name == "OathCode" {
+ responseType = MFA_PROMPT
+ }
+ if name == "AuthMethod" {
+ val, _ := s.Attr("value")
+ switch val {
+ case "VIPAuthenticationProviderWindowsAccountName", "VIPAuthenticationProviderUPN", "Defender AD FS Adapter":
+ responseType = MFA_PROMPT
+ case "AzureMfaAuthentication":
+ responseType = AZURE_MFA_WAIT
+ case "AzureMfaServerAuthentication":
+ responseType = AZURE_MFA_SERVER_WAIT
+ }
+ }
+ if name == "VerificationCode" {
+ responseType = MFA_PROMPT
+ }
+ })
+ return responseType, samlAssertion, checkErr
+}
+
+func updateFormData(authForm url.Values, s *goquery.Selection, user *creds.LoginDetails) {
+ name, ok := s.Attr("name")
+ if !ok {
+ return
+ }
+
+ typeValue, typeFound := s.Attr("type")
+ hiddenAttr := typeFound && typeValue == "hidden"
+
+ lname := strings.ToLower(name)
+ if strings.Contains(lname, "user") {
+ if !hiddenAttr {
+ authForm.Add(name, user.Username)
+ }
+ } else if strings.Contains(lname, "email") {
+ if !hiddenAttr {
+ authForm.Add(name, user.Username)
+ }
+ } else if strings.Contains(lname, "pass") {
+ if !hiddenAttr {
+ authForm.Add(name, user.Password)
+ }
+ } else {
+ updatePassthroughFormData(authForm, s)
+ }
+}
+
+func updateOTPFormData(otpForm url.Values, s *goquery.Selection, token string) {
+ name, ok := s.Attr("name")
+ if !ok {
+ return
+ }
+ lname := strings.ToLower(name)
+ if strings.Contains(lname, "security_code") {
+ otpForm.Add(name, token)
+ } else if strings.Contains(lname, "verificationcode") {
+ otpForm.Add(name, token)
+ } else if strings.Contains(lname, "challengequestionanswer") {
+ otpForm.Add(name, token)
+ } else if strings.Contains(lname, "oathcode") {
+ otpForm.Add(name, token)
+ } else {
+ updatePassthroughFormData(otpForm, s)
+ }
+}
+
+func updatePassthroughFormData(otpForm url.Values, s *goquery.Selection) {
+ name, ok := s.Attr("name")
+ if !ok {
+ return
+ }
+ val, ok := s.Attr("value")
+ if !ok {
+ return
+ }
+ otpForm.Add(name, val)
+}
diff --git a/pkg/auth/providers/aws/saml2aws/provider/adfs/adfs_mfa_limit_test.go b/pkg/auth/providers/aws/saml2aws/provider/adfs/adfs_mfa_limit_test.go
new file mode 100644
index 00000000000..14c266bebca
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/provider/adfs/adfs_mfa_limit_test.go
@@ -0,0 +1,76 @@
+package adfs
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+
+ "github.com/cloudposse/atmos/pkg/auth/providers/aws/saml2aws/mocks"
+)
+
+// Regression: a server that keeps returning the one-time-code page made Authenticate prompt and
+// submit forever. It must give up after maxMFAPromptAttempts codes.
+func TestAuthenticateMFAPromptAttemptLimit(t *testing.T) {
+ pr := &mocks.Prompter{}
+ pr.On("RequestSecurityCode", "000000").Return("999999")
+ usePrompter(t, pr)
+
+ fake := &fakeADFS{
+ loginHTML: loginPage("/adfs/ls/"),
+ responses: []string{mfaPage(``)},
+ repeatLast: true,
+ }
+ ts := newTestServer(t, fake)
+
+ assertion, err := newTestClient(t).Authenticate(loginDetails(ts.URL, "111111"))
+ require.ErrorIs(t, err, ErrMFAAttemptsExceeded)
+ assert.Empty(t, assertion)
+
+ // One login POST plus one POST per allowed code; the configured token counts as the first code.
+ posts := fake.postedForms()
+ require.Len(t, posts, 1+maxMFAPromptAttempts)
+ assert.Equal(t, []string{"111111"}, posts[1]["VerificationCode"])
+ assert.Equal(t, []string{"999999"}, posts[maxMFAPromptAttempts]["VerificationCode"])
+ pr.AssertNumberOfCalls(t, "RequestSecurityCode", maxMFAPromptAttempts-1)
+}
+
+// Regression: a server that keeps returning the Azure MFA wait page was polled forever.
+func TestAuthenticateAzureMFAPollLimit(t *testing.T) {
+ for _, method := range []string{"AzureMfaAuthentication", "AzureMfaServerAuthentication"} {
+ t.Run(method, func(t *testing.T) {
+ useFastAzurePolling(t)
+ captureLog(t)
+ fake := &fakeADFS{
+ loginHTML: loginPage("/adfs/ls/"),
+ responses: []string{azurePage(method, `Approve the sign-in request.
`)},
+ repeatLast: true,
+ }
+ ts := newTestServer(t, fake)
+
+ assertion, err := newTestClient(t).Authenticate(loginDetails(ts.URL, ""))
+ require.ErrorIs(t, err, ErrMFAAttemptsExceeded)
+ assert.Empty(t, assertion)
+ // One login POST plus one POST per allowed poll.
+ assert.Len(t, fake.postedForms(), 1+maxAzureMFAPolls)
+ })
+ }
+}
+
+// The limit only stops a server that never finishes: approval within the limit still succeeds.
+func TestAuthenticateMFAPromptWithinLimit(t *testing.T) {
+ pr := &mocks.Prompter{}
+ pr.On("RequestSecurityCode", "000000").Return("999999")
+ usePrompter(t, pr)
+
+ verification := mfaPage(``)
+ fake := &fakeADFS{
+ loginHTML: loginPage("/adfs/ls/"),
+ responses: []string{verification, verification, verification, verification, verification, samlResponsePage},
+ }
+ ts := newTestServer(t, fake)
+
+ assertion, err := newTestClient(t).Authenticate(loginDetails(ts.URL, "111111"))
+ require.NoError(t, err)
+ assert.Equal(t, testSAMLAssertion, assertion)
+}
diff --git a/pkg/auth/providers/aws/saml2aws/provider/adfs/adfs_test.go b/pkg/auth/providers/aws/saml2aws/provider/adfs/adfs_test.go
new file mode 100644
index 00000000000..ec54070d1b8
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/provider/adfs/adfs_test.go
@@ -0,0 +1,582 @@
+package adfs
+
+import (
+ "bytes"
+ "fmt"
+ "log"
+ "net/http"
+ "net/http/httptest"
+ "net/url"
+ "strings"
+ "sync"
+ "testing"
+ "time"
+
+ "github.com/PuerkitoBio/goquery"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+
+ "github.com/cloudposse/atmos/pkg/auth/providers/aws/saml2aws/cfg"
+ "github.com/cloudposse/atmos/pkg/auth/providers/aws/saml2aws/creds"
+ "github.com/cloudposse/atmos/pkg/auth/providers/aws/saml2aws/mocks"
+ "github.com/cloudposse/atmos/pkg/auth/providers/aws/saml2aws/prompter"
+)
+
+const (
+ testSAMLAssertion = "PHNhbWxwOlJlc3BvbnNlPjwvc2FtbHA6UmVzcG9uc2U+"
+ testUsername = "alice@example.com"
+ testPassword = "s3cr3t"
+ // abortResponse instructs the fake server to drop the connection without replying.
+ abortResponse = "<>"
+)
+
+// samlResponsePage mimics the auto-submitting page ADFS returns after a successful login.
+var samlResponsePage = `
+`
+
+// loginPage mimics the ADFS forms-authentication page.
+func loginPage(action string) string {
+ actionAttr := ""
+ if action != "" {
+ actionAttr = fmt.Sprintf(` action=%q`, action)
+ }
+ return `
+`
+}
+
+// fakeADFSMaxPosts stops a fake server that repeats its last response from looping forever.
+const fakeADFSMaxPosts = 1000
+
+// fakeADFS is an httptest handler that serves the login page on GET and replays canned
+// responses, in order, for each POST it receives.
+type fakeADFS struct {
+ t *testing.T
+ loginHTML string
+ responses []string
+
+ // repeatLast serves the last response for every POST after the canned ones run out,
+ // up to fakeADFSMaxPosts, after which the connection is dropped.
+ repeatLast bool
+
+ mu sync.Mutex
+ getQuery url.Values
+ posts []url.Values
+ paths []string
+}
+
+func (f *fakeADFS) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+ f.mu.Lock()
+ defer f.mu.Unlock()
+
+ if r.Method == http.MethodGet {
+ f.getQuery = r.URL.Query()
+ _, _ = w.Write([]byte(f.loginHTML))
+ return
+ }
+
+ if err := r.ParseForm(); err != nil {
+ f.t.Errorf("failed to parse posted form: %v", err)
+ w.WriteHeader(http.StatusBadRequest)
+ return
+ }
+ idx := len(f.posts)
+ f.posts = append(f.posts, r.PostForm)
+ f.paths = append(f.paths, r.URL.RequestURI())
+
+ if f.repeatLast && idx >= len(f.responses) && len(f.responses) > 0 {
+ if idx >= fakeADFSMaxPosts {
+ panic(http.ErrAbortHandler)
+ }
+ idx = len(f.responses) - 1
+ }
+ if idx >= len(f.responses) {
+ f.t.Errorf("unexpected POST #%d to %s", idx+1, r.URL)
+ w.WriteHeader(http.StatusInternalServerError)
+ return
+ }
+ if f.responses[idx] == abortResponse {
+ panic(http.ErrAbortHandler)
+ }
+ _, _ = w.Write([]byte(f.responses[idx]))
+}
+
+func (f *fakeADFS) postedForms() []url.Values {
+ f.mu.Lock()
+ defer f.mu.Unlock()
+ return append([]url.Values(nil), f.posts...)
+}
+
+// newTestServer starts a TLS server backed by the fake ADFS handler.
+func newTestServer(t *testing.T, fake *fakeADFS) *httptest.Server {
+ t.Helper()
+ fake.t = t
+ ts := httptest.NewTLSServer(fake)
+ t.Cleanup(ts.Close)
+ return ts
+}
+
+func newTestClient(t *testing.T) *Client {
+ t.Helper()
+ client, err := New(&cfg.IDPAccount{
+ SkipVerify: true,
+ AmazonWebservicesURN: cfg.DefaultAmazonWebservicesURN,
+ })
+ require.NoError(t, err)
+ return client
+}
+
+func loginDetails(serverURL, mfaToken string) *creds.LoginDetails {
+ return &creds.LoginDetails{
+ URL: serverURL,
+ Username: testUsername,
+ Password: testPassword,
+ MFAToken: mfaToken,
+ }
+}
+
+func mfaPage(fields string) string {
+ return ``
+}
+
+func azurePage(authMethod, extra string) string {
+ return `` + extra + ``
+}
+
+// useFastAzurePolling shortens the Azure MFA poll interval for the duration of a test.
+func useFastAzurePolling(t *testing.T) {
+ t.Helper()
+ orig := azureMFAPollInterval
+ azureMFAPollInterval = time.Millisecond
+ t.Cleanup(func() { azureMFAPollInterval = orig })
+}
+
+// usePrompter swaps the active prompter for the duration of a test.
+func usePrompter(t *testing.T, p prompter.Prompter) {
+ t.Helper()
+ orig := prompter.ActivePrompter
+ prompter.SetPrompter(p)
+ t.Cleanup(func() { prompter.SetPrompter(orig) })
+}
+
+// captureLog redirects the standard logger for the duration of a test.
+func captureLog(t *testing.T) *bytes.Buffer {
+ t.Helper()
+ var buf bytes.Buffer
+ origOut, origFlags := log.Writer(), log.Flags()
+ log.SetOutput(&buf)
+ log.SetFlags(0)
+ t.Cleanup(func() {
+ log.SetOutput(origOut)
+ log.SetFlags(origFlags)
+ })
+ return &buf
+}
+
+func TestAuthenticateSuccessRelativeAction(t *testing.T) {
+ fake := &fakeADFS{
+ loginHTML: loginPage("/adfs/ls/?client-request-id=abc"),
+ responses: []string{samlResponsePage},
+ }
+ ts := newTestServer(t, fake)
+
+ assertion, err := newTestClient(t).Authenticate(loginDetails(ts.URL, ""))
+ require.NoError(t, err)
+ assert.Equal(t, testSAMLAssertion, assertion)
+
+ // The IdP-initiated sign-on request targets the AWS relying party.
+ assert.Equal(t, cfg.DefaultAmazonWebservicesURN, fake.getQuery.Get("loginToRp"))
+
+ // The relative action was resolved against the ADFS URL, preserving its query.
+ require.Len(t, fake.paths, 1)
+ assert.Equal(t, "/adfs/ls/?client-request-id=abc", fake.paths[0])
+
+ posts := fake.postedForms()
+ require.Len(t, posts, 1)
+ form := posts[0]
+ assert.Equal(t, []string{testUsername}, form["UserName"])
+ assert.Equal(t, []string{testPassword}, form["Password"])
+ assert.Equal(t, []string{"FormsAuthentication"}, form["AuthMethod"])
+ // Kmsi values are trimmed and empty values discarded.
+ assert.Equal(t, []string{"true"}, form["Kmsi"])
+ // Hidden inputs that look like credential fields are never sent.
+ _, hasHidden := form["UserNameHidden"]
+ assert.False(t, hasHidden)
+}
+
+// Regression: relative actions that do not start with "/" are resolved against the login page URL.
+func TestAuthenticateSuccessRelativeActionWithoutLeadingSlash(t *testing.T) {
+ for action, wantPath := range map[string]string{
+ "?step=password": "/adfs/ls/IdpInitiatedSignOn.aspx?step=password",
+ "step=password": "/adfs/ls/step=password",
+ } {
+ fake := &fakeADFS{
+ loginHTML: loginPage(action),
+ responses: []string{samlResponsePage},
+ }
+ ts := newTestServer(t, fake)
+
+ assertion, err := newTestClient(t).Authenticate(loginDetails(ts.URL, ""))
+ require.NoError(t, err, action)
+ assert.Equal(t, testSAMLAssertion, assertion)
+ require.Len(t, fake.paths, 1)
+ assert.Equal(t, wantPath, fake.paths[0], action)
+ }
+}
+
+func TestAuthenticateSuccessAbsoluteAction(t *testing.T) {
+ fake := &fakeADFS{responses: []string{samlResponsePage}}
+ ts := newTestServer(t, fake)
+ fake.loginHTML = loginPage(ts.URL + "/adfs/ls/absolute")
+
+ assertion, err := newTestClient(t).Authenticate(loginDetails(ts.URL, ""))
+ require.NoError(t, err)
+ assert.Equal(t, testSAMLAssertion, assertion)
+ require.Len(t, fake.paths, 1)
+ assert.Equal(t, "/adfs/ls/absolute", fake.paths[0])
+}
+
+func TestAuthenticateErrors(t *testing.T) {
+ // A server that is closed immediately yields a URL nothing listens on.
+ closed := httptest.NewServer(http.NotFoundHandler())
+ closedURL := closed.URL
+ closed.Close()
+
+ tests := []struct {
+ name string
+ serverURL func(ts *httptest.Server) string
+ loginHTML func(ts *httptest.Server) string
+ responses []string
+ wantErr string
+ }{
+ {
+ name: "login page unreachable",
+ serverURL: func(*httptest.Server) string { return closedURL },
+ loginHTML: func(*httptest.Server) string { return "" },
+ wantErr: "failed to get adfs page",
+ },
+ {
+ name: "login page has no form action",
+ loginHTML: func(*httptest.Server) string { return loginPage("") },
+ wantErr: "unable to locate IDP authentication form submit URL",
+ },
+ {
+ name: "auth form submission fails",
+ loginHTML: func(*httptest.Server) string { return loginPage(closedURL + "/adfs/ls/") },
+ wantErr: "failed to submit adfs auth form",
+ },
+ {
+ name: "unclassifiable response",
+ loginHTML: func(*httptest.Server) string { return loginPage("/adfs/ls/") },
+ // A failed login re-renders the forms-authentication page.
+ responses: []string{loginPage("/adfs/ls/")},
+ wantErr: "unable to classify response from auth server",
+ },
+ {
+ name: "SAMLResponse without value",
+ loginHTML: func(*httptest.Server) string { return loginPage("/adfs/ls/") },
+ responses: []string{``},
+ wantErr: "unable to locate saml assertion value",
+ },
+ {
+ name: "mfa submission fails",
+ loginHTML: func(*httptest.Server) string { return loginPage("/adfs/ls/") },
+ responses: []string{mfaPage(``), abortResponse},
+ wantErr: "error retrieving mfa form results",
+ },
+ {
+ name: "azure mfa poll fails",
+ loginHTML: func(*httptest.Server) string { return loginPage("/adfs/ls/") },
+ responses: []string{azurePage("AzureMfaAuthentication", ""), abortResponse},
+ wantErr: "error retrieving mfa form results",
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ useFastAzurePolling(t)
+ fake := &fakeADFS{responses: tt.responses}
+ ts := newTestServer(t, fake)
+ fake.loginHTML = tt.loginHTML(ts)
+ serverURL := ts.URL
+ if tt.serverURL != nil {
+ serverURL = tt.serverURL(ts)
+ }
+
+ assertion, err := newTestClient(t).Authenticate(loginDetails(serverURL, "123456"))
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), tt.wantErr)
+ assert.Empty(t, assertion)
+ })
+ }
+}
+
+func TestAuthenticateRejectsUntrustedCertificate(t *testing.T) {
+ fake := &fakeADFS{loginHTML: loginPage("/adfs/ls/"), responses: []string{samlResponsePage}}
+ ts := newTestServer(t, fake)
+
+ client, err := New(&cfg.IDPAccount{SkipVerify: false})
+ require.NoError(t, err)
+
+ _, err = client.Authenticate(loginDetails(ts.URL, ""))
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), "failed to get adfs page")
+ assert.Empty(t, fake.postedForms())
+}
+
+func TestAuthenticateMFAPrompt(t *testing.T) {
+ tests := []struct {
+ name string
+ fields string
+ tokenField string
+ }{
+ {
+ name: "OathCode",
+ fields: ``,
+ tokenField: "OathCode",
+ },
+ {
+ name: "VerificationCode",
+ fields: ``,
+ tokenField: "VerificationCode",
+ },
+ {
+ name: "VIP account name",
+ fields: `
+`,
+ tokenField: "security_code",
+ },
+ {
+ name: "VIP UPN",
+ fields: `
+`,
+ tokenField: "security_code",
+ },
+ {
+ name: "Defender",
+ fields: `
+`,
+ tokenField: "ChallengeQuestionAnswer",
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ fake := &fakeADFS{
+ loginHTML: loginPage("/adfs/ls/"),
+ responses: []string{mfaPage(tt.fields), samlResponsePage},
+ }
+ ts := newTestServer(t, fake)
+
+ assertion, err := newTestClient(t).Authenticate(loginDetails(ts.URL, "654321"))
+ require.NoError(t, err)
+ assert.Equal(t, testSAMLAssertion, assertion)
+
+ posts := fake.postedForms()
+ require.Len(t, posts, 2)
+ mfaForm := posts[1]
+ assert.Equal(t, []string{"654321"}, mfaForm[tt.tokenField])
+ // Other inputs are passed through unchanged.
+ assert.Equal(t, []string{"ctx-123"}, mfaForm["Context"])
+ // Credentials are not re-sent with the OTP form.
+ _, hasPassword := mfaForm["Password"]
+ assert.False(t, hasPassword)
+ })
+ }
+}
+
+func TestAuthenticateMFAPromptsWhenTokenMissingOrConsumed(t *testing.T) {
+ pr := &mocks.Prompter{}
+ pr.On("RequestSecurityCode", "000000").Return("999999").Once()
+ usePrompter(t, pr)
+
+ verification := mfaPage(``)
+ fake := &fakeADFS{
+ loginHTML: loginPage("/adfs/ls/"),
+ responses: []string{verification, verification, samlResponsePage},
+ }
+ ts := newTestServer(t, fake)
+
+ // The configured token is used for the first challenge only; the second must be prompted for.
+ assertion, err := newTestClient(t).Authenticate(loginDetails(ts.URL, "111111"))
+ require.NoError(t, err)
+ assert.Equal(t, testSAMLAssertion, assertion)
+
+ posts := fake.postedForms()
+ require.Len(t, posts, 3)
+ assert.Equal(t, []string{"111111"}, posts[1]["VerificationCode"])
+ assert.Equal(t, []string{"999999"}, posts[2]["VerificationCode"])
+ pr.AssertExpectations(t)
+}
+
+func TestAuthenticateAzureMFAWait(t *testing.T) {
+ useFastAzurePolling(t)
+ logs := captureLog(t)
+
+ waiting := azurePage("AzureMfaAuthentication", `42
`)
+ fake := &fakeADFS{
+ loginHTML: loginPage("/adfs/ls/"),
+ responses: []string{waiting, waiting, samlResponsePage},
+ }
+ ts := newTestServer(t, fake)
+
+ assertion, err := newTestClient(t).Authenticate(loginDetails(ts.URL, ""))
+ require.NoError(t, err)
+ assert.Equal(t, testSAMLAssertion, assertion)
+
+ posts := fake.postedForms()
+ require.Len(t, posts, 3)
+ for _, poll := range posts[1:] {
+ assert.Equal(t, []string{"AzureMfaAuthentication"}, poll["AuthMethod"])
+ assert.Equal(t, []string{"azure-ctx"}, poll["Context"])
+ }
+ // The number to tap is shown once even though the page was polled twice.
+ assert.Equal(t, 1, strings.Count(logs.String(), "Microsoft Authenticator"))
+ assert.Contains(t, logs.String(), "42")
+}
+
+func TestAuthenticateAzureMFAServerWait(t *testing.T) {
+ waiting := azurePage("AzureMfaServerAuthentication", `Approve the sign-in request.
`)
+
+ tests := []struct {
+ name string
+ responses []string
+ wantErr string
+ }{
+ {
+ name: "approved",
+ responses: []string{waiting, samlResponsePage},
+ },
+ {
+ name: "denied",
+ responses: []string{waiting, ``},
+ wantErr: "The request was denied.",
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ useFastAzurePolling(t)
+ logs := captureLog(t)
+ fake := &fakeADFS{loginHTML: loginPage("/adfs/ls/"), responses: tt.responses}
+ ts := newTestServer(t, fake)
+
+ assertion, err := newTestClient(t).Authenticate(loginDetails(ts.URL, ""))
+ assert.Contains(t, logs.String(), "Approve the sign-in request.")
+ if tt.wantErr != "" {
+ require.Error(t, err)
+ assert.Equal(t, tt.wantErr, err.Error())
+ assert.Empty(t, assertion)
+ return
+ }
+ require.NoError(t, err)
+ assert.Equal(t, testSAMLAssertion, assertion)
+ })
+ }
+}
+
+func TestCheckResponse(t *testing.T) {
+ tests := []struct {
+ name string
+ html string
+ wantType AuthResponseType
+ wantAssertion string
+ wantErr bool
+ }{
+ {name: "empty page", html: ``, wantType: UNKNOWN},
+ {name: "saml response", html: samlResponsePage, wantType: SAML_RESPONSE, wantAssertion: testSAMLAssertion},
+ {
+ // Regression: upstream terminated the process via log.Fatalf on unnamed inputs.
+ name: "saml response with unnamed submit input",
+ html: ``,
+ wantType: SAML_RESPONSE,
+ wantAssertion: "abc",
+ },
+ {
+ // Regression: upstream terminated the process via log.Fatalf when the value was missing.
+ name: "saml response without value",
+ html: ``,
+ wantType: SAML_RESPONSE,
+ wantErr: true,
+ },
+ {name: "oath code", html: ``, wantType: MFA_PROMPT},
+ {name: "verification code", html: ``, wantType: MFA_PROMPT},
+ {name: "azure", html: ``, wantType: AZURE_MFA_WAIT},
+ {name: "azure server", html: ``, wantType: AZURE_MFA_SERVER_WAIT},
+ {name: "forms auth", html: ``, wantType: UNKNOWN},
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ doc, err := goquery.NewDocumentFromReader(strings.NewReader(tt.html))
+ require.NoError(t, err)
+
+ gotType, gotAssertion, err := checkResponse(doc)
+ assert.Equal(t, tt.wantType, gotType)
+ assert.Equal(t, tt.wantAssertion, gotAssertion)
+ if tt.wantErr {
+ assert.Error(t, err)
+ } else {
+ assert.NoError(t, err)
+ }
+ })
+ }
+}
+
+func TestUpdateFormData(t *testing.T) {
+ user := &creds.LoginDetails{Username: "bob", Password: "pw"}
+
+ tests := []struct {
+ name string
+ input string
+ want url.Values
+ }{
+ {name: "username", input: ``, want: url.Values{"UserName": {"bob"}}},
+ {name: "email", input: ``, want: url.Values{"EmailAddress": {"bob"}}},
+ {name: "password", input: ``, want: url.Values{"Password": {"pw"}}},
+ {name: "hidden username skipped", input: ``, want: url.Values{}},
+ {name: "hidden email skipped", input: ``, want: url.Values{}},
+ {name: "hidden password skipped", input: ``, want: url.Values{}},
+ {name: "passthrough", input: ``, want: url.Values{"AuthMethod": {"Forms"}}},
+ {name: "passthrough without value", input: ``, want: url.Values{}},
+ {name: "unnamed", input: ``, want: url.Values{}},
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ doc, err := goquery.NewDocumentFromReader(strings.NewReader(tt.input))
+ require.NoError(t, err)
+
+ got := url.Values{}
+ doc.Find("input").Each(func(_ int, s *goquery.Selection) {
+ updateFormData(got, s, user)
+ })
+ assert.Equal(t, tt.want, got)
+ })
+ }
+}
+
+func TestUpdateOTPFormDataIgnoresUnnamedInputs(t *testing.T) {
+ doc, err := goquery.NewDocumentFromReader(strings.NewReader(``))
+ require.NoError(t, err)
+
+ got := url.Values{}
+ doc.Find("input").Each(func(_ int, s *goquery.Selection) {
+ updateOTPFormData(got, s, "123456")
+ })
+ assert.Empty(t, got)
+}
diff --git a/pkg/auth/providers/aws/saml2aws/provider/adfs/adfs_tls_test.go b/pkg/auth/providers/aws/saml2aws/provider/adfs/adfs_tls_test.go
new file mode 100644
index 00000000000..c3ffba467a5
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/provider/adfs/adfs_tls_test.go
@@ -0,0 +1,28 @@
+package adfs
+
+import (
+ "crypto/tls"
+ "net/http"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+
+ "github.com/cloudposse/atmos/pkg/auth/providers/aws/saml2aws/cfg"
+)
+
+// Regression: upstream left MinVersion unset (code-scanning missing-ssl-minversion). ADFS keeps
+// TLS renegotiation, which only exists up to TLS 1.2, so the floor is TLS 1.2, not TLS 1.3.
+func TestNewSetsTLSFloorAndKeepsRenegotiation(t *testing.T) {
+ for _, skipVerify := range []bool{false, true} {
+ client, err := New(&cfg.IDPAccount{URL: "https://adfs.example.com", SkipVerify: skipVerify})
+ require.NoError(t, err)
+
+ transport, ok := client.client.Transport.(*http.Transport)
+ require.True(t, ok, "ADFS client must use an *http.Transport")
+ require.NotNil(t, transport.TLSClientConfig)
+ assert.Equal(t, uint16(tls.VersionTLS12), transport.TLSClientConfig.MinVersion)
+ assert.Equal(t, tls.RenegotiateFreelyAsClient, transport.TLSClientConfig.Renegotiation)
+ assert.Equal(t, skipVerify, transport.TLSClientConfig.InsecureSkipVerify)
+ }
+}
diff --git a/pkg/auth/providers/aws/saml2aws/provider/base_validate.go b/pkg/auth/providers/aws/saml2aws/provider/base_validate.go
new file mode 100644
index 00000000000..4c218a09dc3
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/provider/base_validate.go
@@ -0,0 +1,22 @@
+package provider
+
+import (
+ "errors"
+
+ "github.com/cloudposse/atmos/pkg/auth/providers/aws/saml2aws/creds"
+)
+
+type ValidateBase struct{}
+
+func (ac *ValidateBase) Validate(ld *creds.LoginDetails) error {
+ if ld.URL == "" {
+ return errors.New("empty URL")
+ }
+ if ld.Username == "" {
+ return errors.New("empty username")
+ }
+ if ld.Password == "" {
+ return errors.New("empty password")
+ }
+ return nil
+}
diff --git a/pkg/auth/providers/aws/saml2aws/provider/base_validate_test.go b/pkg/auth/providers/aws/saml2aws/provider/base_validate_test.go
new file mode 100644
index 00000000000..c8f4412d332
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/provider/base_validate_test.go
@@ -0,0 +1,39 @@
+package provider
+
+import (
+ "testing"
+
+ "github.com/cloudposse/atmos/pkg/auth/providers/aws/saml2aws/creds"
+)
+
+func TestLoginDetails_Validate(t *testing.T) {
+ type fields struct {
+ Username string
+ Password string
+ URL string
+ }
+ tests := []struct {
+ name string
+ fields fields
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ {name: "hostname missing error", fields: fields{}, wantErr: true},
+ {name: "username missing error", fields: fields{URL: "id.example.com"}, wantErr: true},
+ {name: "password missing error", fields: fields{URL: "id.example.com", Username: "test"}, wantErr: true},
+ {name: "ok", fields: fields{URL: "id.example.com", Username: "test", Password: "test"}, wantErr: false},
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ ld := &creds.LoginDetails{
+ Username: tt.fields.Username,
+ Password: tt.fields.Password,
+ URL: tt.fields.URL,
+ }
+ providerstub := &ValidateBase{}
+ if err := providerstub.Validate(ld); (err != nil) != tt.wantErr {
+ t.Errorf("LoginDetails.Validate() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
diff --git a/pkg/auth/providers/aws/saml2aws/provider/browser/browser.go b/pkg/auth/providers/aws/saml2aws/provider/browser/browser.go
new file mode 100644
index 00000000000..0e7c3bb351b
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/provider/browser/browser.go
@@ -0,0 +1,470 @@
+package browser
+
+import (
+ "errors"
+ "fmt"
+ "net/url"
+ "os"
+ "path/filepath"
+ "regexp"
+ "strings"
+ "sync"
+
+ "github.com/mxschmitt/playwright-go"
+ "github.com/sirupsen/logrus"
+
+ "github.com/cloudposse/atmos/pkg/auth/providers/aws/saml2aws/cfg"
+ "github.com/cloudposse/atmos/pkg/auth/providers/aws/saml2aws/creds"
+ "github.com/cloudposse/atmos/pkg/config/homedir"
+)
+
+//go:generate go run go.uber.org/mock/mockgen@v0.6.0 -source=$GOFILE -destination=mock_page_test.go -package=$GOPACKAGE
+//go:generate go run go.uber.org/mock/mockgen@v0.6.0 -destination=mock_request_test.go -package=$GOPACKAGE github.com/mxschmitt/playwright-go Request,BrowserType,Browser
+
+var logger = logrus.WithField("provider", "browser")
+
+const DEFAULT_TIMEOUT float64 = 300000
+
+// storageStateDirPerm is the permission for the directory holding the browser storage state,
+// which contains IdP session cookies.
+const storageStateDirPerm = 0o700
+
+// storageStateFilePerm is the permission for the browser storage state file.
+const storageStateFilePerm = 0o600
+
+// ErrNoSAMLResponse is returned when the browser flow ends without capturing the AWS sign-in request.
+var ErrNoSAMLResponse = errors.New("no SAML response captured from the AWS sign-in request")
+
+// errSAMLRequestCaptured ends an ExpectRequest wait when the OnRequest callback already captured the request.
+var errSAMLRequestCaptured = errors.New("AWS sign-in request already captured")
+
+// samlPage is the subset of playwright.Page used to capture the SAML response.
+// Atmos fork: narrowed from playwright.Page so the capture logic can be unit-tested with mocks.
+type samlPage interface {
+ Goto(url string, options ...playwright.PageGotoOptions) (playwright.Response, error)
+ OnRequest(fn func(playwright.Request))
+ ExpectRequest(urlOrPredicate any, cb func() error, options ...playwright.PageExpectRequestOptions) (playwright.Request, error)
+}
+
+// storageStatePath returns the path of the persisted browser storage state.
+// Atmos fork: built with filepath.Join and the Atmos homedir package instead of a
+// forward-slash fmt.Sprintf, which produced mixed separators on Windows.
+var storageStatePath = func() (string, error) {
+ userHomeDir, err := homedir.Dir()
+ if err != nil {
+ return "", err
+ }
+ return filepath.Join(userHomeDir, ".aws", "saml2aws", "storageState.json"), nil
+}
+
+// Client client for browser based Identity Provider
+type Client struct {
+ BrowserType string
+ BrowserExecutablePath string
+ Headless bool
+ // Setup alternative directory to download playwright browsers to
+ BrowserDriverDir string
+ Timeout int
+ BrowserAutoFill bool
+}
+
+// New create new browser based client
+func New(idpAccount *cfg.IDPAccount) (*Client, error) {
+ return &Client{
+ Headless: idpAccount.Headless,
+ BrowserDriverDir: idpAccount.BrowserDriverDir,
+ BrowserType: strings.ToLower(idpAccount.BrowserType),
+ BrowserExecutablePath: idpAccount.BrowserExecutablePath,
+ Timeout: idpAccount.Timeout,
+ BrowserAutoFill: idpAccount.BrowserAutoFill,
+ }, nil
+}
+
+// contains checks if a string is present in a slice
+func contains(s []string, str string) bool {
+ for _, v := range s {
+ if v == str {
+ return true
+ }
+ }
+
+ return false
+}
+
+// validBrowserTypes are the browser channels Playwright can launch.
+var validBrowserTypes = []string{"chromium", "firefox", "webkit", "chrome", "chrome-beta", "chrome-dev", "chrome-canary", "msedge", "msedge-beta", "msedge-dev", "msedge-canary"}
+
+// validateBrowserType rejects an unknown browser type.
+// Atmos fork: runs before Playwright is installed or started, so a typo fails fast.
+func (cl *Client) validateBrowserType() error {
+ if len(cl.BrowserType) > 0 && !contains(validBrowserTypes, cl.BrowserType) {
+ return fmt.Errorf("invalid browser-type: '%s', only %s are allowed", cl.BrowserType, validBrowserTypes)
+ }
+ return nil
+}
+
+// Atmos fork: the Playwright entry points are package variables so tests can verify that
+// every resource is released on each early return without starting a real driver.
+var (
+ installPlaywright = playwright.Install
+ runPlaywright = playwright.Run
+ stopPlaywright = func(pw *playwright.Playwright) error { return pw.Stop() }
+)
+
+// runOptions returns the Playwright driver options used to install and run the driver.
+//
+// Atmos fork: upstream used zero-value RunOptions, so `playwright install` printed its
+// download progress to stdout (corrupting the caller's data output, for example
+// `eval $(atmos auth env)`) and downloaded every Playwright browser (Chromium, the Chromium
+// headless shell, Firefox, WebKit and FFmpeg) although only one browser is launched.
+func (cl *Client) runOptions() *playwright.RunOptions {
+ opts := &playwright.RunOptions{
+ DriverDirectory: cl.BrowserDriverDir,
+ Stdout: os.Stderr,
+ }
+ switch cl.BrowserType {
+ case "", "chromium":
+ opts.Browsers = []string{"chromium"}
+ // Only the default headless Chromium launches the headless shell; a headed browser
+ // and the explicit "chromium" channel use the full Chromium build.
+ opts.NoInstallShell = cl.BrowserType != "" || !cl.Headless
+ case "firefox", "webkit":
+ opts.Browsers = []string{cl.BrowserType}
+ }
+ // Other browser types are channels of a browser installed on the system (Chrome, Edge);
+ // keep upstream's behavior of installing the default browsers for them.
+ return opts
+}
+
+func (cl *Client) Authenticate(loginDetails *creds.LoginDetails) (string, error) {
+ if err := cl.validateBrowserType(); err != nil {
+ return "", err
+ }
+
+ runOptions := cl.runOptions()
+
+ // Optionally download browser drivers if specified
+ if loginDetails.DownloadBrowser {
+ err := installPlaywright(runOptions)
+ if err != nil {
+ return "", err
+ }
+ }
+
+ pw, err := runPlaywright(runOptions)
+ if err != nil {
+ return "", err
+ }
+ // Atmos fork: upstream released Playwright, the browser and the context only in one
+ // defer registered after the page was created, so a failed Launch, storage-state lookup,
+ // NewContext or NewPage leaked the driver process (and the browser). Each resource is
+ // now released by its own defer as soon as it exists. Defers run in reverse order, which
+ // keeps upstream's shutdown order: save state, close context, close browser, stop driver.
+ defer func() {
+ if err := stopPlaywright(pw); err != nil {
+ logger.Info("Error when stopping pm", err)
+ }
+ }()
+
+ // TODO: provide some overrides for this window
+ launchOptions := playwright.BrowserTypeLaunchOptions{
+ Headless: playwright.Bool(cl.Headless),
+ }
+
+ if cl.BrowserType != "" {
+ logger.Info(fmt.Sprintf("Setting browser type: %s", cl.BrowserType))
+ launchOptions.Channel = playwright.String(cl.BrowserType)
+ }
+
+ // Default browser is Chromium as it is widely supported for Identity providers,
+ // It can also be set to the other playwright browsers: Firefox and WebKit
+ browserType := pw.Chromium
+ switch cl.BrowserType {
+ case "firefox":
+ browserType = pw.Firefox
+ case "webkit":
+ browserType = pw.WebKit
+ }
+
+ // You can set the path to a browser executable to run instead of the playwright-go bundled one. If `executablePath`
+ // is a relative path, then it is resolved relative to the current working directory.
+ // Note that Playwright only works with the bundled Chromium, Firefox or WebKit, use at your own risk. see:
+ if len(cl.BrowserExecutablePath) > 0 {
+ logger.Info(fmt.Sprintf("Setting browser executable path: %s", cl.BrowserExecutablePath))
+ launchOptions.ExecutablePath = &cl.BrowserExecutablePath
+ }
+
+ // currently using the main browsers supported by Playwright: Chromium, Firefox or Webkit
+ //
+ // this is a sandboxed browser window so password managers and addons are separate
+ browser, err := browserType.Launch(launchOptions)
+ if err != nil {
+ return "", err
+ }
+ defer func() {
+ logger.Info("clean up browser")
+ if err := browser.Close(); err != nil {
+ logger.Info("Error when closing browser", err)
+ }
+ }()
+
+ // create Context Optionsf
+ contextOptions := playwright.BrowserNewContextOptions{}
+
+ // load saved storageState if present and add to contextOptions
+ statePath, err := storageStatePath()
+ if err != nil {
+ return "", err
+ }
+ if _, err := os.Stat(statePath); err == nil {
+ contextOptions.StorageStatePath = playwright.String(statePath)
+ }
+
+ // Create new broswer context
+ context, err := browser.NewContext(contextOptions)
+ if err != nil {
+ return "", err
+ }
+ defer func() {
+ if err := context.Close(); err != nil {
+ logger.Info("Error when closing context", err)
+ }
+ }()
+
+ page, err := context.NewPage()
+ if err != nil {
+ return "", err
+ }
+
+ defer func() {
+ logger.Info("saving storage state")
+ if err := saveStorageState(context, statePath); err != nil {
+ logger.Info("Error saving storage state", err)
+ }
+ }()
+
+ return getSAMLResponse(page, loginDetails, cl)
+}
+
+// storageStateSaver is the subset of playwright.BrowserContext used to persist the storage state.
+type storageStateSaver interface {
+ StorageState(path ...playwright.BrowserContextStorageStateOptions) (*playwright.StorageState, error)
+}
+
+// saveStorageState writes the browser storage state (IdP session cookies) to statePath.
+// Atmos fork: Playwright creates (os.Create, 0644) and writes the state file directly, so the cookies
+// were world-readable until a later chmod, and a failed save could clobber the previous state. The state
+// is saved to a private (0600) temporary file in a private (0700) directory and only moved over statePath
+// after a successful save, so a failure leaves the previous state untouched.
+func saveStorageState(saver storageStateSaver, statePath string) error {
+ dir := filepath.Dir(statePath)
+ if err := os.MkdirAll(dir, storageStateDirPerm); err != nil {
+ return err
+ }
+ // MkdirAll does not tighten an existing directory.
+ if err := os.Chmod(dir, storageStateDirPerm); err != nil {
+ return err
+ }
+
+ tmp, err := os.CreateTemp(dir, filepath.Base(statePath)+".*.tmp") // Created with 0600.
+ if err != nil {
+ return err
+ }
+ tmpPath := tmp.Name()
+ if err := tmp.Close(); err != nil {
+ _ = os.Remove(tmpPath)
+ return err
+ }
+
+ if _, err := saver.StorageState(playwright.BrowserContextStorageStateOptions{Path: playwright.String(tmpPath)}); err != nil {
+ _ = os.Remove(tmpPath)
+ return err
+ }
+ if err := os.Chmod(tmpPath, storageStateFilePerm); err != nil {
+ _ = os.Remove(tmpPath)
+ return err
+ }
+ if err := os.Rename(tmpPath, statePath); err != nil {
+ _ = os.Remove(tmpPath)
+ return err
+ }
+ return nil
+}
+
+// getSAMLResponse navigates to the IdP and captures the SAMLResponse posted to the AWS sign-in endpoint.
+//
+// Atmos fork fixes over upstream v2.36.19:
+// - A timeout or error from ExpectRequest returned a nil request that was then dereferenced (panic).
+// - A PostData error was swallowed because the wrong error variable was returned.
+// - The request callback and the caller shared data without synchronization (data race).
+// - An empty capture now fails with ErrNoSAMLResponse instead of returning an empty assertion.
+// - A request the callback captured just before ExpectRequest started listening is used instead
+// of waiting for the full timeout and failing.
+var getSAMLResponse = func(page samlPage, loginDetails *creds.LoginDetails, client *Client) (string, error) {
+ var (
+ mu sync.Mutex
+ data string
+ dataErr error
+ )
+
+ logger.WithField("URL", loginDetails.URL).Info("opening browser")
+
+ signinRe, err := signinRegex()
+ if err != nil {
+ return "", err
+ }
+
+ // record stores the request body. Atmos fork: a captured SAMLResponse is never replaced by a later
+ // request that carries none (for example a GET to the same URL, whose body is empty), which upstream
+ // overwrote and then waited for another request until the timeout.
+ record := func(postData string, postErr error) {
+ mu.Lock()
+ defer mu.Unlock()
+ if dataErr == nil && hasSAMLResponse(data) && (postErr != nil || !hasSAMLResponse(postData)) {
+ return
+ }
+ data, dataErr = postData, postErr
+ }
+
+ page.OnRequest(func(request playwright.Request) {
+ if signinRe.MatchString(request.URL()) {
+ postData, postErr := request.PostData()
+ record(postData, postErr)
+ }
+ })
+ if _, err := page.Goto(loginDetails.URL); err != nil {
+ return "", err
+ }
+
+ if client.BrowserAutoFill {
+ if fullPage, ok := page.(playwright.Page); ok {
+ if err := autoFill(fullPage, loginDetails); err != nil {
+ logger.Error("error when auto filling", err)
+ }
+ }
+ }
+
+ logger.Info("waiting ...")
+ capturedByCallback := func() bool {
+ mu.Lock()
+ defer mu.Unlock()
+ return data != ""
+ }
+ if !capturedByCallback() {
+ // Atmos fork: the sign-in request can reach the OnRequest callback after the check
+ // above but before ExpectRequest starts listening. ExpectRequest then never sees it
+ // and upstream waited for the full timeout and failed. The callback passed to
+ // ExpectRequest runs once the waiter listens and ends the wait when the request was
+ // already captured, and a failed wait still uses a request the callback captured.
+ r, err := page.ExpectRequest(signinRe, func() error {
+ if capturedByCallback() {
+ return errSAMLRequestCaptured
+ }
+ return nil
+ }, client.expectRequestTimeout())
+ switch {
+ case (err != nil || r == nil) && capturedByCallback():
+ // Use the request captured by the OnRequest callback.
+ case err != nil:
+ return "", fmt.Errorf("waiting for the AWS sign-in request: %w", err)
+ case r == nil:
+ return "", ErrNoSAMLResponse
+ default:
+ postData, postErr := r.PostData()
+ record(postData, postErr)
+ }
+ }
+
+ mu.Lock()
+ captured, capturedErr := data, dataErr
+ mu.Unlock()
+ if capturedErr != nil {
+ return "", fmt.Errorf("reading the AWS sign-in request body: %w", capturedErr)
+ }
+
+ values, err := url.ParseQuery(captured)
+ if err != nil {
+ return "", err
+ }
+
+ samlResponse := values.Get("SAMLResponse")
+ if samlResponse == "" {
+ return "", ErrNoSAMLResponse
+ }
+
+ return samlResponse, nil
+}
+
+// hasSAMLResponse reports whether the request body carries a non-empty SAMLResponse form field.
+func hasSAMLResponse(body string) bool {
+ values, err := url.ParseQuery(body)
+ return err == nil && values.Get("SAMLResponse") != ""
+}
+
+var autoFill = func(page playwright.Page, loginDetails *creds.LoginDetails) error {
+ passwordField := page.Locator("input[type='password']")
+ err := passwordField.WaitFor(playwright.LocatorWaitForOptions{
+ State: playwright.WaitForSelectorStateVisible,
+ })
+ if err != nil {
+ return err
+ }
+
+ err = passwordField.Fill(loginDetails.Password)
+ if err != nil {
+ return err
+ }
+
+ keyboard := page.Keyboard()
+
+ // move to username field which is above password field
+ err = keyboard.Press("Shift+Tab")
+ if err != nil {
+ return err
+ }
+
+ err = keyboard.InsertText(loginDetails.Username)
+ if err != nil {
+ return err
+ }
+
+ // Find the submit button or input of the form that the password field is in
+ submitLocator := page.Locator("form", playwright.PageLocatorOptions{
+ Has: passwordField,
+ }).Locator("[type='submit']")
+ count, err := submitLocator.Count()
+ if err != nil {
+ return err
+ }
+
+ // when submit locator exists, Click it
+ if count > 0 {
+ return submitLocator.Click()
+ } else { // Use javascript to submit the form when no submit input or button is found
+ _, err := page.Evaluate(`document.querySelector('input[type="password"]').form.submit()`, nil)
+ return err
+ }
+}
+
+func signinRegex() (*regexp.Regexp, error) {
+ // https://docs.aws.amazon.com/general/latest/gr/signin-service.html
+ // https://docs.amazonaws.cn/en_us/aws/latest/userguide/endpoints-Ningxia.html
+ // https://docs.amazonaws.cn/en_us/aws/latest/userguide/endpoints-Beijing.html
+ return regexp.Compile(`https:\/\/((.*\.)?signin\.(aws\.amazon\.com|amazonaws-us-gov\.com|amazonaws\.cn))\/saml`)
+}
+
+func (cl *Client) Validate(loginDetails *creds.LoginDetails) error {
+ if loginDetails.URL == "" {
+ return errors.New("empty URL")
+ }
+
+ return nil
+}
+
+func (cl *Client) expectRequestTimeout() playwright.PageExpectRequestOptions {
+ timeout := float64(cl.Timeout)
+ if timeout < 30000 {
+ timeout = DEFAULT_TIMEOUT
+ }
+ return playwright.PageExpectRequestOptions{Timeout: &timeout}
+}
diff --git a/pkg/auth/providers/aws/saml2aws/provider/browser/browser_integration_test.go b/pkg/auth/providers/aws/saml2aws/provider/browser/browser_integration_test.go
new file mode 100644
index 00000000000..4c9ad4cb9e5
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/provider/browser/browser_integration_test.go
@@ -0,0 +1,104 @@
+package browser
+
+import (
+ "net/http"
+ "net/http/httptest"
+ "os"
+ "testing"
+
+ "github.com/mxschmitt/playwright-go"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+
+ "github.com/cloudposse/atmos/pkg/auth/providers/aws/saml2aws/creds"
+)
+
+// These tests launch a real browser. They download the Playwright driver and Chromium
+// (hundreds of MB), so they only run when RUN_PLAYWRIGHT_INTEGRATION=1 is set.
+
+func requirePlaywrightIntegration(t *testing.T) {
+ t.Helper()
+ if os.Getenv("RUN_PLAYWRIGHT_INTEGRATION") != "1" {
+ t.Skipf("Skipping real-browser test (set RUN_PLAYWRIGHT_INTEGRATION=1 to run)")
+ }
+ if testing.Short() {
+ t.Skipf("Skipping real-browser test in short mode")
+ }
+ if err := playwright.Install(&playwright.RunOptions{Browsers: []string{"chromium"}}); err != nil {
+ t.Skipf("Skipping real-browser test: could not install Playwright and Chromium: %v", err)
+ }
+}
+
+func TestAuthenticateWithRealBrowser_Integration(t *testing.T) {
+ requirePlaywrightIntegration(t)
+
+ original := getSAMLResponse
+ t.Cleanup(func() { getSAMLResponse = original })
+ getSAMLResponse = func(samlPage, *creds.LoginDetails, *Client) (string, error) {
+ return testAssertion, nil
+ }
+
+ ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+ _, _ = w.Write([]byte("idp"))
+ }))
+ t.Cleanup(ts.Close)
+
+ client := &Client{Headless: true}
+ got, err := client.Authenticate(&creds.LoginDetails{URL: ts.URL})
+ require.NoError(t, err)
+ assert.Equal(t, testAssertion, got)
+}
+
+func TestAuthenticateInvalidBrowserExecutablePath_Integration(t *testing.T) {
+ requirePlaywrightIntegration(t)
+
+ client := &Client{Headless: true, BrowserExecutablePath: "FAKEPATH"}
+ _, err := client.Authenticate(&creds.LoginDetails{URL: testIdPURL})
+ require.ErrorContains(t, err, "FAKEPATH")
+}
+
+func TestAutoFill_Integration(t *testing.T) {
+ requirePlaywrightIntegration(t)
+
+ pw, err := playwright.Run()
+ require.NoError(t, err)
+ t.Cleanup(func() { _ = pw.Stop() })
+ browser, err := pw.Chromium.Launch()
+ require.NoError(t, err)
+ t.Cleanup(func() { _ = browser.Close() })
+
+ for _, pageLocation := range []string{
+ "example/loginpage.html",
+ "example/loginpage-button-submit.html",
+ "example/loginpage-without-submit.html",
+ } {
+ t.Run(pageLocation, func(t *testing.T) {
+ data, err := os.ReadFile(pageLocation)
+ require.NoError(t, err)
+
+ ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+ _, _ = w.Write(data)
+ }))
+ t.Cleanup(ts.Close)
+
+ context, err := browser.NewContext()
+ require.NoError(t, err)
+ t.Cleanup(func() { _ = context.Close() })
+ page, err := context.NewPage()
+ require.NoError(t, err)
+ _, err = page.Goto(ts.URL)
+ require.NoError(t, err)
+
+ loginDetails := &creds.LoginDetails{URL: ts.URL, Username: "golang", Password: "gopher"}
+ require.NoError(t, autoFill(page, loginDetails))
+
+ username, _ := page.Locator("input[name='username']").First().InputValue()
+ assert.Equal(t, "golang", username)
+ password, _ := page.Locator("input[type='password']").First().InputValue()
+ assert.Equal(t, "gopher", password)
+
+ result, _ := page.Locator("div#result").Evaluate("el => el.innerText", nil)
+ assert.Equal(t, "golang:gopher", result)
+ })
+ }
+}
diff --git a/pkg/auth/providers/aws/saml2aws/provider/browser/browser_lifecycle_test.go b/pkg/auth/providers/aws/saml2aws/provider/browser/browser_lifecycle_test.go
new file mode 100644
index 00000000000..582351cebc5
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/provider/browser/browser_lifecycle_test.go
@@ -0,0 +1,150 @@
+package browser
+
+import (
+ "os"
+ "testing"
+
+ "github.com/mxschmitt/playwright-go"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+ "go.uber.org/mock/gomock"
+
+ "github.com/cloudposse/atmos/pkg/auth/providers/aws/saml2aws/creds"
+)
+
+// fakePlaywright replaces the Playwright entry points with a driver whose Chromium is browserType.
+// It returns a pointer to the number of times the driver was stopped.
+func fakePlaywright(t *testing.T, browserType playwright.BrowserType) *int {
+ t.Helper()
+ originalInstall, originalRun, originalStop := installPlaywright, runPlaywright, stopPlaywright
+ t.Cleanup(func() {
+ installPlaywright, runPlaywright, stopPlaywright = originalInstall, originalRun, originalStop
+ })
+
+ stops := 0
+ installPlaywright = func(...*playwright.RunOptions) error {
+ t.Fatal("install must not run when DownloadBrowser is false")
+ return nil
+ }
+ runPlaywright = func(...*playwright.RunOptions) (*playwright.Playwright, error) {
+ return &playwright.Playwright{Chromium: browserType}, nil
+ }
+ stopPlaywright = func(*playwright.Playwright) error {
+ stops++
+ return nil
+ }
+ return &stops
+}
+
+// Regression: upstream stopped the Playwright driver only in a defer registered after the
+// page was created, so a failed browser launch left the driver process running.
+func TestAuthenticateStopsPlaywrightWhenLaunchFails(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ browserType := NewMockBrowserType(ctrl)
+ stops := fakePlaywright(t, browserType)
+
+ browserType.EXPECT().Launch(gomock.Any()).Return(nil, errTest)
+
+ _, err := (&Client{}).Authenticate(&creds.LoginDetails{URL: testIdPURL})
+ require.ErrorIs(t, err, errTest)
+ assert.Equal(t, 1, *stops, "the Playwright driver must be stopped")
+}
+
+// Regression: a failed context creation leaked both the browser and the driver.
+func TestAuthenticateClosesBrowserWhenNewContextFails(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ browserType := NewMockBrowserType(ctrl)
+ browser := NewMockBrowser(ctrl)
+ stops := fakePlaywright(t, browserType)
+
+ browserType.EXPECT().Launch(gomock.Any()).Return(browser, nil)
+ browser.EXPECT().NewContext(gomock.Any()).Return(nil, errTest)
+ browser.EXPECT().Close().Return(nil)
+
+ _, err := (&Client{}).Authenticate(&creds.LoginDetails{URL: testIdPURL})
+ require.ErrorIs(t, err, errTest)
+ assert.Equal(t, 1, *stops, "the Playwright driver must be stopped")
+}
+
+// Regression: a storage-state path failure leaked both the browser and the driver.
+func TestAuthenticateClosesBrowserWhenStorageStatePathFails(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ browserType := NewMockBrowserType(ctrl)
+ browser := NewMockBrowser(ctrl)
+ stops := fakePlaywright(t, browserType)
+
+ original := storageStatePath
+ t.Cleanup(func() { storageStatePath = original })
+ storageStatePath = func() (string, error) { return "", errTest }
+
+ browserType.EXPECT().Launch(gomock.Any()).Return(browser, nil)
+ browser.EXPECT().Close().Return(nil)
+
+ _, err := (&Client{}).Authenticate(&creds.LoginDetails{URL: testIdPURL})
+ require.ErrorIs(t, err, errTest)
+ assert.Equal(t, 1, *stops, "the Playwright driver must be stopped")
+}
+
+// A failed install never starts the driver.
+func TestAuthenticateInstallFailureDoesNotStartPlaywright(t *testing.T) {
+ stops := fakePlaywright(t, nil)
+ installPlaywright = func(...*playwright.RunOptions) error { return errTest }
+ runPlaywright = func(...*playwright.RunOptions) (*playwright.Playwright, error) {
+ t.Fatal("Playwright must not start after a failed install")
+ return nil, nil
+ }
+
+ _, err := (&Client{}).Authenticate(&creds.LoginDetails{URL: testIdPURL, DownloadBrowser: true})
+ require.ErrorIs(t, err, errTest)
+ assert.Zero(t, *stops)
+}
+
+// Install and Run receive the same options built by runOptions.
+func TestAuthenticatePassesRunOptionsToInstallAndRun(t *testing.T) {
+ stops := fakePlaywright(t, nil)
+ var installed, ran *playwright.RunOptions
+ installPlaywright = func(opts ...*playwright.RunOptions) error {
+ installed = opts[0]
+ return nil
+ }
+ runPlaywright = func(opts ...*playwright.RunOptions) (*playwright.Playwright, error) {
+ ran = opts[0]
+ return nil, errTest
+ }
+
+ client := &Client{BrowserDriverDir: t.TempDir()}
+ _, err := client.Authenticate(&creds.LoginDetails{URL: testIdPURL, DownloadBrowser: true})
+ require.ErrorIs(t, err, errTest)
+ require.NotNil(t, installed)
+ assert.Same(t, installed, ran)
+ assert.Equal(t, client.BrowserDriverDir, installed.DriverDirectory)
+ assert.Zero(t, *stops, "a driver that failed to start has nothing to stop")
+}
+
+// Regression: upstream installed with zero-value options, so the Playwright CLI wrote its
+// download progress to stdout and downloaded every browser although only one is launched.
+func TestRunOptions(t *testing.T) {
+ tests := []struct {
+ name string
+ client Client
+ wantBrowser []string
+ wantNoShell bool
+ }{
+ {name: "default headed chromium", client: Client{}, wantBrowser: []string{"chromium"}, wantNoShell: true},
+ {name: "default headless chromium needs the headless shell", client: Client{Headless: true}, wantBrowser: []string{"chromium"}},
+ {name: "chromium channel uses the full build", client: Client{BrowserType: "chromium", Headless: true}, wantBrowser: []string{"chromium"}, wantNoShell: true},
+ {name: "firefox", client: Client{BrowserType: "firefox"}, wantBrowser: []string{"firefox"}},
+ {name: "webkit", client: Client{BrowserType: "webkit"}, wantBrowser: []string{"webkit"}},
+ {name: "system browser channel keeps upstream defaults", client: Client{BrowserType: "msedge"}},
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ opts := tt.client.runOptions()
+ assert.Same(t, os.Stderr, opts.Stdout, "install progress must not go to stdout")
+ assert.Equal(t, tt.wantBrowser, opts.Browsers)
+ assert.Equal(t, tt.wantNoShell, opts.NoInstallShell)
+ assert.False(t, opts.OnlyInstallShell)
+ })
+ }
+}
diff --git a/pkg/auth/providers/aws/saml2aws/provider/browser/browser_test.go b/pkg/auth/providers/aws/saml2aws/provider/browser/browser_test.go
new file mode 100644
index 00000000000..bf05a853965
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/provider/browser/browser_test.go
@@ -0,0 +1,386 @@
+package browser
+
+import (
+ "errors"
+ "net/url"
+ "path/filepath"
+ "testing"
+
+ "github.com/mxschmitt/playwright-go"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+ "go.uber.org/mock/gomock"
+
+ "github.com/cloudposse/atmos/pkg/auth/providers/aws/saml2aws/cfg"
+ "github.com/cloudposse/atmos/pkg/auth/providers/aws/saml2aws/creds"
+)
+
+const (
+ testIdPURL = "https://idp.example.com/login"
+ testSigninURL = "https://signin.aws.amazon.com/saml"
+ testAssertion = "PHNhbWxwOlJlc3BvbnNlPjwvc2FtbHA6UmVzcG9uc2U+"
+)
+
+var errTest = errors.New("boom")
+
+func samlPostBody(assertion string) string {
+ params := url.Values{}
+ params.Add("RelayState", "state")
+ params.Add("SAMLResponse", assertion)
+ return params.Encode()
+}
+
+func newTestClient(t *testing.T) *Client {
+ t.Helper()
+ client, err := New(&cfg.IDPAccount{Headless: true, Timeout: 100000})
+ require.NoError(t, err)
+ return client
+}
+
+func TestNew(t *testing.T) {
+ client, err := New(&cfg.IDPAccount{
+ Headless: true,
+ BrowserDriverDir: "/drivers",
+ BrowserType: "Firefox",
+ BrowserExecutablePath: "/usr/bin/firefox",
+ Timeout: 42,
+ BrowserAutoFill: true,
+ })
+ require.NoError(t, err)
+ assert.Equal(t, &Client{
+ Headless: true,
+ BrowserDriverDir: "/drivers",
+ BrowserType: "firefox",
+ BrowserExecutablePath: "/usr/bin/firefox",
+ Timeout: 42,
+ BrowserAutoFill: true,
+ }, client)
+}
+
+func TestValidate(t *testing.T) {
+ client := newTestClient(t)
+
+ require.NoError(t, client.Validate(&creds.LoginDetails{URL: testIdPURL}))
+ require.ErrorContains(t, client.Validate(&creds.LoginDetails{}), "empty URL")
+}
+
+func TestValidateBrowserType(t *testing.T) {
+ for _, browserType := range append([]string{""}, validBrowserTypes...) {
+ t.Run("valid "+browserType, func(t *testing.T) {
+ require.NoError(t, (&Client{BrowserType: browserType}).validateBrowserType())
+ })
+ }
+
+ err := (&Client{BrowserType: "invalid"}).validateBrowserType()
+ require.ErrorContains(t, err, "invalid browser-type: 'invalid', only [chromium firefox webkit chrome chrome-beta chrome-dev chrome-canary msedge msedge-beta msedge-dev msedge-canary] are allowed")
+}
+
+// An invalid browser type must fail before Playwright is installed or started.
+func TestAuthenticateRejectsInvalidBrowserTypeBeforeStartingPlaywright(t *testing.T) {
+ client := &Client{BrowserType: "invalid", BrowserDriverDir: t.TempDir()}
+
+ _, err := client.Authenticate(&creds.LoginDetails{URL: testIdPURL, DownloadBrowser: true})
+ require.ErrorContains(t, err, "invalid browser-type")
+}
+
+// Without an installed driver and without download, Run fails with a clear message (no network needed).
+func TestAuthenticateWithoutDriverFails(t *testing.T) {
+ client := &Client{Headless: true, BrowserDriverDir: t.TempDir()}
+
+ _, err := client.Authenticate(&creds.LoginDetails{URL: testIdPURL})
+ require.ErrorContains(t, err, "please install the driver")
+}
+
+func TestSigninRegex(t *testing.T) {
+ regex, err := signinRegex()
+ require.NoError(t, err)
+
+ for _, u := range []string{
+ "https://signin.aws.amazon.com/saml",
+ "https://us-east-1.signin.aws.amazon.com/saml",
+ "https://signin.amazonaws-us-gov.com/saml",
+ "https://signin.amazonaws.cn/saml",
+ } {
+ assert.True(t, regex.MatchString(u), u)
+ }
+ for _, u := range []string{"https://google.com/", "http://signin.aws.amazon.com/saml", "https://signin.aws.amazon.com/console"} {
+ assert.False(t, regex.MatchString(u), u)
+ }
+}
+
+func TestExpectRequestOptions(t *testing.T) {
+ options := (&Client{Timeout: 100000}).expectRequestTimeout()
+ assert.InDelta(t, float64(100000), *options.Timeout, 0)
+}
+
+func TestExpectRequestOptionsDefaultTimeout(t *testing.T) {
+ options := (&Client{Timeout: 1000}).expectRequestTimeout()
+ assert.InDelta(t, DEFAULT_TIMEOUT, *options.Timeout, 0)
+}
+
+func TestStorageStatePath(t *testing.T) {
+ path, err := storageStatePath()
+ require.NoError(t, err)
+ assert.True(t, filepath.IsAbs(path), path)
+ assert.Equal(t, filepath.Join(".aws", "saml2aws", "storageState.json"), filepath.Join(filepath.Base(filepath.Dir(filepath.Dir(path))), filepath.Base(filepath.Dir(path)), filepath.Base(path)))
+}
+
+// The SAML response is captured by ExpectRequest when the callback has not fired yet.
+func TestGetSAMLResponseViaExpectRequest(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ page := NewMocksamlPage(ctrl)
+ req := NewMockRequest(ctrl)
+ client := newTestClient(t)
+
+ page.EXPECT().OnRequest(gomock.Any())
+ page.EXPECT().Goto(testIdPURL).Return(nil, nil)
+ page.EXPECT().ExpectRequest(gomock.Any(), gomock.Any(), client.expectRequestTimeout()).Return(req, nil)
+ req.EXPECT().PostData().Return(samlPostBody(testAssertion), nil)
+
+ got, err := getSAMLResponse(page, &creds.LoginDetails{URL: testIdPURL}, client)
+ require.NoError(t, err)
+ assert.Equal(t, testAssertion, got)
+}
+
+// The SAML response is captured by the OnRequest callback, and ExpectRequest is not needed.
+func TestGetSAMLResponseViaOnRequestCallback(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ page := NewMocksamlPage(ctrl)
+ req := NewMockRequest(ctrl)
+ client := newTestClient(t)
+
+ var handler func(playwright.Request)
+ page.EXPECT().OnRequest(gomock.Any()).Do(func(fn func(playwright.Request)) { handler = fn })
+ page.EXPECT().Goto(testIdPURL).DoAndReturn(func(string, ...playwright.PageGotoOptions) (playwright.Response, error) {
+ handler(req)
+ return nil, nil
+ })
+ req.EXPECT().URL().Return(testSigninURL)
+ req.EXPECT().PostData().Return(samlPostBody(testAssertion), nil)
+
+ got, err := getSAMLResponse(page, &creds.LoginDetails{URL: testIdPURL}, client)
+ require.NoError(t, err)
+ assert.Equal(t, testAssertion, got)
+}
+
+// Requests to other URLs are ignored by the callback.
+func TestGetSAMLResponseCallbackIgnoresOtherURLs(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ page := NewMocksamlPage(ctrl)
+ other := NewMockRequest(ctrl)
+ signin := NewMockRequest(ctrl)
+ client := newTestClient(t)
+
+ var handler func(playwright.Request)
+ page.EXPECT().OnRequest(gomock.Any()).Do(func(fn func(playwright.Request)) { handler = fn })
+ page.EXPECT().Goto(testIdPURL).DoAndReturn(func(string, ...playwright.PageGotoOptions) (playwright.Response, error) {
+ handler(other)
+ return nil, nil
+ })
+ other.EXPECT().URL().Return("https://idp.example.com/assets/app.js")
+ page.EXPECT().ExpectRequest(gomock.Any(), gomock.Any(), gomock.Any()).Return(signin, nil)
+ signin.EXPECT().PostData().Return(samlPostBody(testAssertion), nil)
+
+ got, err := getSAMLResponse(page, &creds.LoginDetails{URL: testIdPURL}, client)
+ require.NoError(t, err)
+ assert.Equal(t, testAssertion, got)
+}
+
+// Regression: upstream dereferenced the nil request after an ExpectRequest timeout and panicked.
+func TestGetSAMLResponseExpectRequestTimeoutDoesNotPanic(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ page := NewMocksamlPage(ctrl)
+ client := newTestClient(t)
+
+ page.EXPECT().OnRequest(gomock.Any())
+ page.EXPECT().Goto(testIdPURL).Return(nil, nil)
+ page.EXPECT().ExpectRequest(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, errTest)
+
+ var err error
+ require.NotPanics(t, func() {
+ _, err = getSAMLResponse(page, &creds.LoginDetails{URL: testIdPURL}, client)
+ })
+ require.ErrorIs(t, err, errTest)
+ assert.ErrorContains(t, err, "waiting for the AWS sign-in request")
+}
+
+func TestGetSAMLResponseExpectRequestNilRequest(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ page := NewMocksamlPage(ctrl)
+ client := newTestClient(t)
+
+ page.EXPECT().OnRequest(gomock.Any())
+ page.EXPECT().Goto(testIdPURL).Return(nil, nil)
+ page.EXPECT().ExpectRequest(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, nil)
+
+ _, err := getSAMLResponse(page, &creds.LoginDetails{URL: testIdPURL}, client)
+ require.ErrorIs(t, err, ErrNoSAMLResponse)
+}
+
+// Regression: upstream returned the wrong error variable, so a PostData failure was swallowed.
+func TestGetSAMLResponsePostDataError(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ page := NewMocksamlPage(ctrl)
+ req := NewMockRequest(ctrl)
+ client := newTestClient(t)
+
+ page.EXPECT().OnRequest(gomock.Any())
+ page.EXPECT().Goto(testIdPURL).Return(nil, nil)
+ page.EXPECT().ExpectRequest(gomock.Any(), gomock.Any(), gomock.Any()).Return(req, nil)
+ req.EXPECT().PostData().Return("", errTest)
+
+ _, err := getSAMLResponse(page, &creds.LoginDetails{URL: testIdPURL}, client)
+ require.ErrorIs(t, err, errTest)
+}
+
+func TestGetSAMLResponseGotoError(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ page := NewMocksamlPage(ctrl)
+ client := newTestClient(t)
+
+ page.EXPECT().OnRequest(gomock.Any())
+ page.EXPECT().Goto(testIdPURL).Return(nil, errTest)
+
+ _, err := getSAMLResponse(page, &creds.LoginDetails{URL: testIdPURL}, client)
+ require.ErrorIs(t, err, errTest)
+}
+
+func TestGetSAMLResponseMissingSAMLResponseField(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ page := NewMocksamlPage(ctrl)
+ req := NewMockRequest(ctrl)
+ client := newTestClient(t)
+
+ page.EXPECT().OnRequest(gomock.Any())
+ page.EXPECT().Goto(testIdPURL).Return(nil, nil)
+ page.EXPECT().ExpectRequest(gomock.Any(), gomock.Any(), gomock.Any()).Return(req, nil)
+ req.EXPECT().PostData().Return("RelayState=state", nil)
+
+ _, err := getSAMLResponse(page, &creds.LoginDetails{URL: testIdPURL}, client)
+ require.ErrorIs(t, err, ErrNoSAMLResponse)
+}
+
+func TestGetSAMLResponseMalformedBody(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ page := NewMocksamlPage(ctrl)
+ req := NewMockRequest(ctrl)
+ client := newTestClient(t)
+
+ page.EXPECT().OnRequest(gomock.Any())
+ page.EXPECT().Goto(testIdPURL).Return(nil, nil)
+ page.EXPECT().ExpectRequest(gomock.Any(), gomock.Any(), gomock.Any()).Return(req, nil)
+ req.EXPECT().PostData().Return("%zz", nil)
+
+ _, err := getSAMLResponse(page, &creds.LoginDetails{URL: testIdPURL}, client)
+ require.Error(t, err)
+}
+
+// Auto-fill only applies to a full playwright.Page; the narrow mock page is skipped without error.
+func TestGetSAMLResponseAutoFillSkippedForNarrowPage(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ page := NewMocksamlPage(ctrl)
+ req := NewMockRequest(ctrl)
+ client := newTestClient(t)
+ client.BrowserAutoFill = true
+
+ original := autoFill
+ t.Cleanup(func() { autoFill = original })
+ autoFill = func(playwright.Page, *creds.LoginDetails) error {
+ t.Fatal("autoFill must not be called for a page that is not a playwright.Page")
+ return nil
+ }
+
+ page.EXPECT().OnRequest(gomock.Any())
+ page.EXPECT().Goto(testIdPURL).Return(nil, nil)
+ page.EXPECT().ExpectRequest(gomock.Any(), gomock.Any(), gomock.Any()).Return(req, nil)
+ req.EXPECT().PostData().Return(samlPostBody(testAssertion), nil)
+
+ got, err := getSAMLResponse(page, &creds.LoginDetails{URL: testIdPURL}, client)
+ require.NoError(t, err)
+ assert.Equal(t, testAssertion, got)
+}
+
+func TestContains(t *testing.T) {
+ assert.True(t, contains([]string{"a", "b"}, "b"))
+ assert.False(t, contains([]string{"a", "b"}, "c"))
+ assert.False(t, contains(nil, "a"))
+}
+
+// Regression: the sign-in request can reach the OnRequest callback after the "already
+// captured" check but before ExpectRequest starts listening. ExpectRequest then never sees
+// it and times out; upstream failed (or panicked) although the SAML response was captured.
+func TestGetSAMLResponseUsesCallbackCaptureWhenExpectRequestMissesIt(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ page := NewMocksamlPage(ctrl)
+ req := NewMockRequest(ctrl)
+ client := newTestClient(t)
+
+ var handler func(playwright.Request)
+ page.EXPECT().OnRequest(gomock.Any()).Do(func(fn func(playwright.Request)) { handler = fn })
+ page.EXPECT().Goto(testIdPURL).Return(nil, nil)
+ page.EXPECT().ExpectRequest(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(
+ func(any, func() error, ...playwright.PageExpectRequestOptions) (playwright.Request, error) {
+ handler(req) // Delivered to the OnRequest callback only.
+ return nil, errTest // The waiter never saw it and timed out.
+ })
+ req.EXPECT().URL().Return(testSigninURL)
+ req.EXPECT().PostData().Return(samlPostBody(testAssertion), nil)
+
+ got, err := getSAMLResponse(page, &creds.LoginDetails{URL: testIdPURL}, client)
+ require.NoError(t, err)
+ assert.Equal(t, testAssertion, got)
+}
+
+// Regression: a later request to the sign-in URL without a SAMLResponse (for example a GET) must not
+// replace an assertion that was already captured.
+func TestGetSAMLResponseKeepsCapturedAssertionOnLaterEmptyRequest(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ page := NewMocksamlPage(ctrl)
+ post := NewMockRequest(ctrl)
+ get := NewMockRequest(ctrl)
+ client := newTestClient(t)
+
+ var handler func(playwright.Request)
+ page.EXPECT().OnRequest(gomock.Any()).Do(func(fn func(playwright.Request)) { handler = fn })
+ page.EXPECT().Goto(testIdPURL).DoAndReturn(func(string, ...playwright.PageGotoOptions) (playwright.Response, error) {
+ handler(post)
+ handler(get)
+ return nil, nil
+ })
+ post.EXPECT().URL().Return(testSigninURL)
+ post.EXPECT().PostData().Return(samlPostBody(testAssertion), nil)
+ get.EXPECT().URL().Return(testSigninURL)
+ get.EXPECT().PostData().Return("", nil)
+
+ got, err := getSAMLResponse(page, &creds.LoginDetails{URL: testIdPURL}, client)
+ require.NoError(t, err)
+ assert.Equal(t, testAssertion, got)
+}
+
+// The callback passed to ExpectRequest runs once the waiter listens. It lets the wait continue
+// while nothing was captured, and ends it as soon as the OnRequest callback captured the request.
+func TestGetSAMLResponseExpectRequestCallbackEndsWaitWhenCaptured(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ page := NewMocksamlPage(ctrl)
+ req := NewMockRequest(ctrl)
+ client := newTestClient(t)
+
+ var handler func(playwright.Request)
+ page.EXPECT().OnRequest(gomock.Any()).Do(func(fn func(playwright.Request)) { handler = fn })
+ page.EXPECT().Goto(testIdPURL).Return(nil, nil)
+ page.EXPECT().ExpectRequest(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(
+ func(_ any, cb func() error, _ ...playwright.PageExpectRequestOptions) (playwright.Request, error) {
+ require.NotNil(t, cb)
+ require.NoError(t, cb(), "nothing captured yet, keep waiting")
+ handler(req)
+ err := cb()
+ require.ErrorIs(t, err, errSAMLRequestCaptured)
+ return nil, err // playwright-go's RunAndWait returns the callback error.
+ })
+ req.EXPECT().URL().Return(testSigninURL)
+ req.EXPECT().PostData().Return(samlPostBody(testAssertion), nil)
+
+ got, err := getSAMLResponse(page, &creds.LoginDetails{URL: testIdPURL}, client)
+ require.NoError(t, err)
+ assert.Equal(t, testAssertion, got)
+}
diff --git a/pkg/auth/providers/aws/saml2aws/provider/browser/example/loginpage-button-submit.html b/pkg/auth/providers/aws/saml2aws/provider/browser/example/loginpage-button-submit.html
new file mode 100644
index 00000000000..979f798fc7a
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/provider/browser/example/loginpage-button-submit.html
@@ -0,0 +1,41 @@
+
+
+ Fake Login Page
+
+
+
+
+
+
+
+
+
diff --git a/pkg/auth/providers/aws/saml2aws/provider/browser/example/loginpage-without-submit.html b/pkg/auth/providers/aws/saml2aws/provider/browser/example/loginpage-without-submit.html
new file mode 100644
index 00000000000..e267347c6cd
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/provider/browser/example/loginpage-without-submit.html
@@ -0,0 +1,42 @@
+
+
+ Fake Login Page
+
+
+
+
+
+
+
+
+
diff --git a/pkg/auth/providers/aws/saml2aws/provider/browser/example/loginpage.html b/pkg/auth/providers/aws/saml2aws/provider/browser/example/loginpage.html
new file mode 100644
index 00000000000..86c0f74b4a3
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/provider/browser/example/loginpage.html
@@ -0,0 +1,41 @@
+
+
+ Fake Login Page
+
+
+
+
+
+
+
+
+
diff --git a/pkg/auth/providers/aws/saml2aws/provider/browser/mock_page_test.go b/pkg/auth/providers/aws/saml2aws/provider/browser/mock_page_test.go
new file mode 100644
index 00000000000..890ca789f6b
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/provider/browser/mock_page_test.go
@@ -0,0 +1,136 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: browser.go
+//
+// Generated by this command:
+//
+// mockgen -source=browser.go -destination=mock_page_test.go -package=browser
+//
+
+// Package browser is a generated GoMock package.
+package browser
+
+import (
+ reflect "reflect"
+
+ playwright "github.com/mxschmitt/playwright-go"
+ gomock "go.uber.org/mock/gomock"
+)
+
+// MocksamlPage is a mock of samlPage interface.
+type MocksamlPage struct {
+ ctrl *gomock.Controller
+ recorder *MocksamlPageMockRecorder
+ isgomock struct{}
+}
+
+// MocksamlPageMockRecorder is the mock recorder for MocksamlPage.
+type MocksamlPageMockRecorder struct {
+ mock *MocksamlPage
+}
+
+// NewMocksamlPage creates a new mock instance.
+func NewMocksamlPage(ctrl *gomock.Controller) *MocksamlPage {
+ mock := &MocksamlPage{ctrl: ctrl}
+ mock.recorder = &MocksamlPageMockRecorder{mock}
+ return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MocksamlPage) EXPECT() *MocksamlPageMockRecorder {
+ return m.recorder
+}
+
+// ExpectRequest mocks base method.
+func (m *MocksamlPage) ExpectRequest(urlOrPredicate any, cb func() error, options ...playwright.PageExpectRequestOptions) (playwright.Request, error) {
+ m.ctrl.T.Helper()
+ varargs := []any{urlOrPredicate, cb}
+ for _, a := range options {
+ varargs = append(varargs, a)
+ }
+ ret := m.ctrl.Call(m, "ExpectRequest", varargs...)
+ ret0, _ := ret[0].(playwright.Request)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// ExpectRequest indicates an expected call of ExpectRequest.
+func (mr *MocksamlPageMockRecorder) ExpectRequest(urlOrPredicate, cb any, options ...any) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ varargs := append([]any{urlOrPredicate, cb}, options...)
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpectRequest", reflect.TypeOf((*MocksamlPage)(nil).ExpectRequest), varargs...)
+}
+
+// Goto mocks base method.
+func (m *MocksamlPage) Goto(url string, options ...playwright.PageGotoOptions) (playwright.Response, error) {
+ m.ctrl.T.Helper()
+ varargs := []any{url}
+ for _, a := range options {
+ varargs = append(varargs, a)
+ }
+ ret := m.ctrl.Call(m, "Goto", varargs...)
+ ret0, _ := ret[0].(playwright.Response)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// Goto indicates an expected call of Goto.
+func (mr *MocksamlPageMockRecorder) Goto(url any, options ...any) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ varargs := append([]any{url}, options...)
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Goto", reflect.TypeOf((*MocksamlPage)(nil).Goto), varargs...)
+}
+
+// OnRequest mocks base method.
+func (m *MocksamlPage) OnRequest(fn func(playwright.Request)) {
+ m.ctrl.T.Helper()
+ m.ctrl.Call(m, "OnRequest", fn)
+}
+
+// OnRequest indicates an expected call of OnRequest.
+func (mr *MocksamlPageMockRecorder) OnRequest(fn any) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnRequest", reflect.TypeOf((*MocksamlPage)(nil).OnRequest), fn)
+}
+
+// MockstorageStateSaver is a mock of storageStateSaver interface.
+type MockstorageStateSaver struct {
+ ctrl *gomock.Controller
+ recorder *MockstorageStateSaverMockRecorder
+ isgomock struct{}
+}
+
+// MockstorageStateSaverMockRecorder is the mock recorder for MockstorageStateSaver.
+type MockstorageStateSaverMockRecorder struct {
+ mock *MockstorageStateSaver
+}
+
+// NewMockstorageStateSaver creates a new mock instance.
+func NewMockstorageStateSaver(ctrl *gomock.Controller) *MockstorageStateSaver {
+ mock := &MockstorageStateSaver{ctrl: ctrl}
+ mock.recorder = &MockstorageStateSaverMockRecorder{mock}
+ return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockstorageStateSaver) EXPECT() *MockstorageStateSaverMockRecorder {
+ return m.recorder
+}
+
+// StorageState mocks base method.
+func (m *MockstorageStateSaver) StorageState(path ...playwright.BrowserContextStorageStateOptions) (*playwright.StorageState, error) {
+ m.ctrl.T.Helper()
+ varargs := []any{}
+ for _, a := range path {
+ varargs = append(varargs, a)
+ }
+ ret := m.ctrl.Call(m, "StorageState", varargs...)
+ ret0, _ := ret[0].(*playwright.StorageState)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// StorageState indicates an expected call of StorageState.
+func (mr *MockstorageStateSaverMockRecorder) StorageState(path ...any) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageState", reflect.TypeOf((*MockstorageStateSaver)(nil).StorageState), path...)
+}
diff --git a/pkg/auth/providers/aws/saml2aws/provider/browser/mock_request_test.go b/pkg/auth/providers/aws/saml2aws/provider/browser/mock_request_test.go
new file mode 100644
index 00000000000..ef0c70fced9
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/provider/browser/mock_request_test.go
@@ -0,0 +1,769 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/mxschmitt/playwright-go (interfaces: Request,BrowserType,Browser)
+//
+// Generated by this command:
+//
+// mockgen -destination=mock_request_test.go -package=browser github.com/mxschmitt/playwright-go Request,BrowserType,Browser
+//
+
+// Package browser is a generated GoMock package.
+package browser
+
+import (
+ reflect "reflect"
+
+ playwright "github.com/mxschmitt/playwright-go"
+ gomock "go.uber.org/mock/gomock"
+)
+
+// MockRequest is a mock of Request interface.
+type MockRequest struct {
+ ctrl *gomock.Controller
+ recorder *MockRequestMockRecorder
+ isgomock struct{}
+}
+
+// MockRequestMockRecorder is the mock recorder for MockRequest.
+type MockRequestMockRecorder struct {
+ mock *MockRequest
+}
+
+// NewMockRequest creates a new mock instance.
+func NewMockRequest(ctrl *gomock.Controller) *MockRequest {
+ mock := &MockRequest{ctrl: ctrl}
+ mock.recorder = &MockRequestMockRecorder{mock}
+ return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockRequest) EXPECT() *MockRequestMockRecorder {
+ return m.recorder
+}
+
+// AllHeaders mocks base method.
+func (m *MockRequest) AllHeaders() (map[string]string, error) {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "AllHeaders")
+ ret0, _ := ret[0].(map[string]string)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// AllHeaders indicates an expected call of AllHeaders.
+func (mr *MockRequestMockRecorder) AllHeaders() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllHeaders", reflect.TypeOf((*MockRequest)(nil).AllHeaders))
+}
+
+// ExistingResponse mocks base method.
+func (m *MockRequest) ExistingResponse() (playwright.Response, error) {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "ExistingResponse")
+ ret0, _ := ret[0].(playwright.Response)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// ExistingResponse indicates an expected call of ExistingResponse.
+func (mr *MockRequestMockRecorder) ExistingResponse() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistingResponse", reflect.TypeOf((*MockRequest)(nil).ExistingResponse))
+}
+
+// Failure mocks base method.
+func (m *MockRequest) Failure() error {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "Failure")
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// Failure indicates an expected call of Failure.
+func (mr *MockRequestMockRecorder) Failure() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Failure", reflect.TypeOf((*MockRequest)(nil).Failure))
+}
+
+// Frame mocks base method.
+func (m *MockRequest) Frame() playwright.Frame {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "Frame")
+ ret0, _ := ret[0].(playwright.Frame)
+ return ret0
+}
+
+// Frame indicates an expected call of Frame.
+func (mr *MockRequestMockRecorder) Frame() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Frame", reflect.TypeOf((*MockRequest)(nil).Frame))
+}
+
+// HeaderValue mocks base method.
+func (m *MockRequest) HeaderValue(name string) (string, error) {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "HeaderValue", name)
+ ret0, _ := ret[0].(string)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// HeaderValue indicates an expected call of HeaderValue.
+func (mr *MockRequestMockRecorder) HeaderValue(name any) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderValue", reflect.TypeOf((*MockRequest)(nil).HeaderValue), name)
+}
+
+// Headers mocks base method.
+func (m *MockRequest) Headers() map[string]string {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "Headers")
+ ret0, _ := ret[0].(map[string]string)
+ return ret0
+}
+
+// Headers indicates an expected call of Headers.
+func (mr *MockRequestMockRecorder) Headers() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Headers", reflect.TypeOf((*MockRequest)(nil).Headers))
+}
+
+// HeadersArray mocks base method.
+func (m *MockRequest) HeadersArray() ([]playwright.NameValue, error) {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "HeadersArray")
+ ret0, _ := ret[0].([]playwright.NameValue)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// HeadersArray indicates an expected call of HeadersArray.
+func (mr *MockRequestMockRecorder) HeadersArray() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadersArray", reflect.TypeOf((*MockRequest)(nil).HeadersArray))
+}
+
+// IsNavigationRequest mocks base method.
+func (m *MockRequest) IsNavigationRequest() bool {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "IsNavigationRequest")
+ ret0, _ := ret[0].(bool)
+ return ret0
+}
+
+// IsNavigationRequest indicates an expected call of IsNavigationRequest.
+func (mr *MockRequestMockRecorder) IsNavigationRequest() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNavigationRequest", reflect.TypeOf((*MockRequest)(nil).IsNavigationRequest))
+}
+
+// Method mocks base method.
+func (m *MockRequest) Method() string {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "Method")
+ ret0, _ := ret[0].(string)
+ return ret0
+}
+
+// Method indicates an expected call of Method.
+func (mr *MockRequestMockRecorder) Method() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Method", reflect.TypeOf((*MockRequest)(nil).Method))
+}
+
+// PostData mocks base method.
+func (m *MockRequest) PostData() (string, error) {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "PostData")
+ ret0, _ := ret[0].(string)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// PostData indicates an expected call of PostData.
+func (mr *MockRequestMockRecorder) PostData() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostData", reflect.TypeOf((*MockRequest)(nil).PostData))
+}
+
+// PostDataBuffer mocks base method.
+func (m *MockRequest) PostDataBuffer() ([]byte, error) {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "PostDataBuffer")
+ ret0, _ := ret[0].([]byte)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// PostDataBuffer indicates an expected call of PostDataBuffer.
+func (mr *MockRequestMockRecorder) PostDataBuffer() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostDataBuffer", reflect.TypeOf((*MockRequest)(nil).PostDataBuffer))
+}
+
+// PostDataJSON mocks base method.
+func (m *MockRequest) PostDataJSON(v any) error {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "PostDataJSON", v)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// PostDataJSON indicates an expected call of PostDataJSON.
+func (mr *MockRequestMockRecorder) PostDataJSON(v any) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostDataJSON", reflect.TypeOf((*MockRequest)(nil).PostDataJSON), v)
+}
+
+// RedirectedFrom mocks base method.
+func (m *MockRequest) RedirectedFrom() playwright.Request {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "RedirectedFrom")
+ ret0, _ := ret[0].(playwright.Request)
+ return ret0
+}
+
+// RedirectedFrom indicates an expected call of RedirectedFrom.
+func (mr *MockRequestMockRecorder) RedirectedFrom() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RedirectedFrom", reflect.TypeOf((*MockRequest)(nil).RedirectedFrom))
+}
+
+// RedirectedTo mocks base method.
+func (m *MockRequest) RedirectedTo() playwright.Request {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "RedirectedTo")
+ ret0, _ := ret[0].(playwright.Request)
+ return ret0
+}
+
+// RedirectedTo indicates an expected call of RedirectedTo.
+func (mr *MockRequestMockRecorder) RedirectedTo() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RedirectedTo", reflect.TypeOf((*MockRequest)(nil).RedirectedTo))
+}
+
+// ResourceType mocks base method.
+func (m *MockRequest) ResourceType() string {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "ResourceType")
+ ret0, _ := ret[0].(string)
+ return ret0
+}
+
+// ResourceType indicates an expected call of ResourceType.
+func (mr *MockRequestMockRecorder) ResourceType() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResourceType", reflect.TypeOf((*MockRequest)(nil).ResourceType))
+}
+
+// Response mocks base method.
+func (m *MockRequest) Response() (playwright.Response, error) {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "Response")
+ ret0, _ := ret[0].(playwright.Response)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// Response indicates an expected call of Response.
+func (mr *MockRequestMockRecorder) Response() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Response", reflect.TypeOf((*MockRequest)(nil).Response))
+}
+
+// Sizes mocks base method.
+func (m *MockRequest) Sizes() (*playwright.RequestSizesResult, error) {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "Sizes")
+ ret0, _ := ret[0].(*playwright.RequestSizesResult)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// Sizes indicates an expected call of Sizes.
+func (mr *MockRequestMockRecorder) Sizes() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sizes", reflect.TypeOf((*MockRequest)(nil).Sizes))
+}
+
+// Timing mocks base method.
+func (m *MockRequest) Timing() *playwright.RequestTiming {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "Timing")
+ ret0, _ := ret[0].(*playwright.RequestTiming)
+ return ret0
+}
+
+// Timing indicates an expected call of Timing.
+func (mr *MockRequestMockRecorder) Timing() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timing", reflect.TypeOf((*MockRequest)(nil).Timing))
+}
+
+// URL mocks base method.
+func (m *MockRequest) URL() string {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "URL")
+ ret0, _ := ret[0].(string)
+ return ret0
+}
+
+// URL indicates an expected call of URL.
+func (mr *MockRequestMockRecorder) URL() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "URL", reflect.TypeOf((*MockRequest)(nil).URL))
+}
+
+// MockBrowserType is a mock of BrowserType interface.
+type MockBrowserType struct {
+ ctrl *gomock.Controller
+ recorder *MockBrowserTypeMockRecorder
+ isgomock struct{}
+}
+
+// MockBrowserTypeMockRecorder is the mock recorder for MockBrowserType.
+type MockBrowserTypeMockRecorder struct {
+ mock *MockBrowserType
+}
+
+// NewMockBrowserType creates a new mock instance.
+func NewMockBrowserType(ctrl *gomock.Controller) *MockBrowserType {
+ mock := &MockBrowserType{ctrl: ctrl}
+ mock.recorder = &MockBrowserTypeMockRecorder{mock}
+ return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockBrowserType) EXPECT() *MockBrowserTypeMockRecorder {
+ return m.recorder
+}
+
+// Connect mocks base method.
+func (m *MockBrowserType) Connect(endpoint string, options ...playwright.BrowserTypeConnectOptions) (playwright.Browser, error) {
+ m.ctrl.T.Helper()
+ varargs := []any{endpoint}
+ for _, a := range options {
+ varargs = append(varargs, a)
+ }
+ ret := m.ctrl.Call(m, "Connect", varargs...)
+ ret0, _ := ret[0].(playwright.Browser)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// Connect indicates an expected call of Connect.
+func (mr *MockBrowserTypeMockRecorder) Connect(endpoint any, options ...any) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ varargs := append([]any{endpoint}, options...)
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connect", reflect.TypeOf((*MockBrowserType)(nil).Connect), varargs...)
+}
+
+// ConnectOverCDP mocks base method.
+func (m *MockBrowserType) ConnectOverCDP(endpointURL string, options ...playwright.BrowserTypeConnectOverCDPOptions) (playwright.Browser, error) {
+ m.ctrl.T.Helper()
+ varargs := []any{endpointURL}
+ for _, a := range options {
+ varargs = append(varargs, a)
+ }
+ ret := m.ctrl.Call(m, "ConnectOverCDP", varargs...)
+ ret0, _ := ret[0].(playwright.Browser)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// ConnectOverCDP indicates an expected call of ConnectOverCDP.
+func (mr *MockBrowserTypeMockRecorder) ConnectOverCDP(endpointURL any, options ...any) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ varargs := append([]any{endpointURL}, options...)
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectOverCDP", reflect.TypeOf((*MockBrowserType)(nil).ConnectOverCDP), varargs...)
+}
+
+// ExecutablePath mocks base method.
+func (m *MockBrowserType) ExecutablePath() string {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "ExecutablePath")
+ ret0, _ := ret[0].(string)
+ return ret0
+}
+
+// ExecutablePath indicates an expected call of ExecutablePath.
+func (mr *MockBrowserTypeMockRecorder) ExecutablePath() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecutablePath", reflect.TypeOf((*MockBrowserType)(nil).ExecutablePath))
+}
+
+// Launch mocks base method.
+func (m *MockBrowserType) Launch(options ...playwright.BrowserTypeLaunchOptions) (playwright.Browser, error) {
+ m.ctrl.T.Helper()
+ varargs := []any{}
+ for _, a := range options {
+ varargs = append(varargs, a)
+ }
+ ret := m.ctrl.Call(m, "Launch", varargs...)
+ ret0, _ := ret[0].(playwright.Browser)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// Launch indicates an expected call of Launch.
+func (mr *MockBrowserTypeMockRecorder) Launch(options ...any) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Launch", reflect.TypeOf((*MockBrowserType)(nil).Launch), options...)
+}
+
+// LaunchPersistentContext mocks base method.
+func (m *MockBrowserType) LaunchPersistentContext(userDataDir string, options ...playwright.BrowserTypeLaunchPersistentContextOptions) (playwright.BrowserContext, error) {
+ m.ctrl.T.Helper()
+ varargs := []any{userDataDir}
+ for _, a := range options {
+ varargs = append(varargs, a)
+ }
+ ret := m.ctrl.Call(m, "LaunchPersistentContext", varargs...)
+ ret0, _ := ret[0].(playwright.BrowserContext)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// LaunchPersistentContext indicates an expected call of LaunchPersistentContext.
+func (mr *MockBrowserTypeMockRecorder) LaunchPersistentContext(userDataDir any, options ...any) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ varargs := append([]any{userDataDir}, options...)
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LaunchPersistentContext", reflect.TypeOf((*MockBrowserType)(nil).LaunchPersistentContext), varargs...)
+}
+
+// Name mocks base method.
+func (m *MockBrowserType) Name() string {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "Name")
+ ret0, _ := ret[0].(string)
+ return ret0
+}
+
+// Name indicates an expected call of Name.
+func (mr *MockBrowserTypeMockRecorder) Name() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockBrowserType)(nil).Name))
+}
+
+// MockBrowser is a mock of Browser interface.
+type MockBrowser struct {
+ ctrl *gomock.Controller
+ recorder *MockBrowserMockRecorder
+ isgomock struct{}
+}
+
+// MockBrowserMockRecorder is the mock recorder for MockBrowser.
+type MockBrowserMockRecorder struct {
+ mock *MockBrowser
+}
+
+// NewMockBrowser creates a new mock instance.
+func NewMockBrowser(ctrl *gomock.Controller) *MockBrowser {
+ mock := &MockBrowser{ctrl: ctrl}
+ mock.recorder = &MockBrowserMockRecorder{mock}
+ return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockBrowser) EXPECT() *MockBrowserMockRecorder {
+ return m.recorder
+}
+
+// Bind mocks base method.
+func (m *MockBrowser) Bind(title string, options ...playwright.BrowserBindOptions) (*playwright.Bind, error) {
+ m.ctrl.T.Helper()
+ varargs := []any{title}
+ for _, a := range options {
+ varargs = append(varargs, a)
+ }
+ ret := m.ctrl.Call(m, "Bind", varargs...)
+ ret0, _ := ret[0].(*playwright.Bind)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// Bind indicates an expected call of Bind.
+func (mr *MockBrowserMockRecorder) Bind(title any, options ...any) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ varargs := append([]any{title}, options...)
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bind", reflect.TypeOf((*MockBrowser)(nil).Bind), varargs...)
+}
+
+// BrowserType mocks base method.
+func (m *MockBrowser) BrowserType() playwright.BrowserType {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "BrowserType")
+ ret0, _ := ret[0].(playwright.BrowserType)
+ return ret0
+}
+
+// BrowserType indicates an expected call of BrowserType.
+func (mr *MockBrowserMockRecorder) BrowserType() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BrowserType", reflect.TypeOf((*MockBrowser)(nil).BrowserType))
+}
+
+// Close mocks base method.
+func (m *MockBrowser) Close(options ...playwright.BrowserCloseOptions) error {
+ m.ctrl.T.Helper()
+ varargs := []any{}
+ for _, a := range options {
+ varargs = append(varargs, a)
+ }
+ ret := m.ctrl.Call(m, "Close", varargs...)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// Close indicates an expected call of Close.
+func (mr *MockBrowserMockRecorder) Close(options ...any) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockBrowser)(nil).Close), options...)
+}
+
+// Contexts mocks base method.
+func (m *MockBrowser) Contexts() []playwright.BrowserContext {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "Contexts")
+ ret0, _ := ret[0].([]playwright.BrowserContext)
+ return ret0
+}
+
+// Contexts indicates an expected call of Contexts.
+func (mr *MockBrowserMockRecorder) Contexts() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Contexts", reflect.TypeOf((*MockBrowser)(nil).Contexts))
+}
+
+// Emit mocks base method.
+func (m *MockBrowser) Emit(name string, payload ...any) bool {
+ m.ctrl.T.Helper()
+ varargs := []any{name}
+ for _, a := range payload {
+ varargs = append(varargs, a)
+ }
+ ret := m.ctrl.Call(m, "Emit", varargs...)
+ ret0, _ := ret[0].(bool)
+ return ret0
+}
+
+// Emit indicates an expected call of Emit.
+func (mr *MockBrowserMockRecorder) Emit(name any, payload ...any) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ varargs := append([]any{name}, payload...)
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Emit", reflect.TypeOf((*MockBrowser)(nil).Emit), varargs...)
+}
+
+// IsConnected mocks base method.
+func (m *MockBrowser) IsConnected() bool {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "IsConnected")
+ ret0, _ := ret[0].(bool)
+ return ret0
+}
+
+// IsConnected indicates an expected call of IsConnected.
+func (mr *MockBrowserMockRecorder) IsConnected() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsConnected", reflect.TypeOf((*MockBrowser)(nil).IsConnected))
+}
+
+// ListenerCount mocks base method.
+func (m *MockBrowser) ListenerCount(name string) int {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "ListenerCount", name)
+ ret0, _ := ret[0].(int)
+ return ret0
+}
+
+// ListenerCount indicates an expected call of ListenerCount.
+func (mr *MockBrowserMockRecorder) ListenerCount(name any) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListenerCount", reflect.TypeOf((*MockBrowser)(nil).ListenerCount), name)
+}
+
+// NewBrowserCDPSession mocks base method.
+func (m *MockBrowser) NewBrowserCDPSession() (playwright.CDPSession, error) {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "NewBrowserCDPSession")
+ ret0, _ := ret[0].(playwright.CDPSession)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// NewBrowserCDPSession indicates an expected call of NewBrowserCDPSession.
+func (mr *MockBrowserMockRecorder) NewBrowserCDPSession() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewBrowserCDPSession", reflect.TypeOf((*MockBrowser)(nil).NewBrowserCDPSession))
+}
+
+// NewContext mocks base method.
+func (m *MockBrowser) NewContext(options ...playwright.BrowserNewContextOptions) (playwright.BrowserContext, error) {
+ m.ctrl.T.Helper()
+ varargs := []any{}
+ for _, a := range options {
+ varargs = append(varargs, a)
+ }
+ ret := m.ctrl.Call(m, "NewContext", varargs...)
+ ret0, _ := ret[0].(playwright.BrowserContext)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// NewContext indicates an expected call of NewContext.
+func (mr *MockBrowserMockRecorder) NewContext(options ...any) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewContext", reflect.TypeOf((*MockBrowser)(nil).NewContext), options...)
+}
+
+// NewPage mocks base method.
+func (m *MockBrowser) NewPage(options ...playwright.BrowserNewPageOptions) (playwright.Page, error) {
+ m.ctrl.T.Helper()
+ varargs := []any{}
+ for _, a := range options {
+ varargs = append(varargs, a)
+ }
+ ret := m.ctrl.Call(m, "NewPage", varargs...)
+ ret0, _ := ret[0].(playwright.Page)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// NewPage indicates an expected call of NewPage.
+func (mr *MockBrowserMockRecorder) NewPage(options ...any) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewPage", reflect.TypeOf((*MockBrowser)(nil).NewPage), options...)
+}
+
+// On mocks base method.
+func (m *MockBrowser) On(name string, handler any) {
+ m.ctrl.T.Helper()
+ m.ctrl.Call(m, "On", name, handler)
+}
+
+// On indicates an expected call of On.
+func (mr *MockBrowserMockRecorder) On(name, handler any) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "On", reflect.TypeOf((*MockBrowser)(nil).On), name, handler)
+}
+
+// OnContext mocks base method.
+func (m *MockBrowser) OnContext(fn func(playwright.BrowserContext)) {
+ m.ctrl.T.Helper()
+ m.ctrl.Call(m, "OnContext", fn)
+}
+
+// OnContext indicates an expected call of OnContext.
+func (mr *MockBrowserMockRecorder) OnContext(fn any) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnContext", reflect.TypeOf((*MockBrowser)(nil).OnContext), fn)
+}
+
+// OnDisconnected mocks base method.
+func (m *MockBrowser) OnDisconnected(fn func(playwright.Browser)) {
+ m.ctrl.T.Helper()
+ m.ctrl.Call(m, "OnDisconnected", fn)
+}
+
+// OnDisconnected indicates an expected call of OnDisconnected.
+func (mr *MockBrowserMockRecorder) OnDisconnected(fn any) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnDisconnected", reflect.TypeOf((*MockBrowser)(nil).OnDisconnected), fn)
+}
+
+// Once mocks base method.
+func (m *MockBrowser) Once(name string, handler any) {
+ m.ctrl.T.Helper()
+ m.ctrl.Call(m, "Once", name, handler)
+}
+
+// Once indicates an expected call of Once.
+func (mr *MockBrowserMockRecorder) Once(name, handler any) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Once", reflect.TypeOf((*MockBrowser)(nil).Once), name, handler)
+}
+
+// RemoveListener mocks base method.
+func (m *MockBrowser) RemoveListener(name string, handler any) {
+ m.ctrl.T.Helper()
+ m.ctrl.Call(m, "RemoveListener", name, handler)
+}
+
+// RemoveListener indicates an expected call of RemoveListener.
+func (mr *MockBrowserMockRecorder) RemoveListener(name, handler any) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveListener", reflect.TypeOf((*MockBrowser)(nil).RemoveListener), name, handler)
+}
+
+// RemoveListeners mocks base method.
+func (m *MockBrowser) RemoveListeners(name string) {
+ m.ctrl.T.Helper()
+ m.ctrl.Call(m, "RemoveListeners", name)
+}
+
+// RemoveListeners indicates an expected call of RemoveListeners.
+func (mr *MockBrowserMockRecorder) RemoveListeners(name any) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveListeners", reflect.TypeOf((*MockBrowser)(nil).RemoveListeners), name)
+}
+
+// StartTracing mocks base method.
+func (m *MockBrowser) StartTracing(options ...playwright.BrowserStartTracingOptions) error {
+ m.ctrl.T.Helper()
+ varargs := []any{}
+ for _, a := range options {
+ varargs = append(varargs, a)
+ }
+ ret := m.ctrl.Call(m, "StartTracing", varargs...)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// StartTracing indicates an expected call of StartTracing.
+func (mr *MockBrowserMockRecorder) StartTracing(options ...any) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartTracing", reflect.TypeOf((*MockBrowser)(nil).StartTracing), options...)
+}
+
+// StopTracing mocks base method.
+func (m *MockBrowser) StopTracing() ([]byte, error) {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "StopTracing")
+ ret0, _ := ret[0].([]byte)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// StopTracing indicates an expected call of StopTracing.
+func (mr *MockBrowserMockRecorder) StopTracing() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopTracing", reflect.TypeOf((*MockBrowser)(nil).StopTracing))
+}
+
+// Unbind mocks base method.
+func (m *MockBrowser) Unbind() error {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "Unbind")
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// Unbind indicates an expected call of Unbind.
+func (mr *MockBrowserMockRecorder) Unbind() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unbind", reflect.TypeOf((*MockBrowser)(nil).Unbind))
+}
+
+// Version mocks base method.
+func (m *MockBrowser) Version() string {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "Version")
+ ret0, _ := ret[0].(string)
+ return ret0
+}
+
+// Version indicates an expected call of Version.
+func (mr *MockBrowserMockRecorder) Version() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockBrowser)(nil).Version))
+}
diff --git a/pkg/auth/providers/aws/saml2aws/provider/browser/storage_state_test.go b/pkg/auth/providers/aws/saml2aws/provider/browser/storage_state_test.go
new file mode 100644
index 00000000000..95a44d3d1be
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/provider/browser/storage_state_test.go
@@ -0,0 +1,125 @@
+package browser
+
+import (
+ "os"
+ "path/filepath"
+ "runtime"
+ "testing"
+
+ "github.com/mxschmitt/playwright-go"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+ "go.uber.org/mock/gomock"
+)
+
+// writeStateLikePlaywright writes the state file the way Playwright does (world-readable).
+func writeStateLikePlaywright(t *testing.T) func(...playwright.BrowserContextStorageStateOptions) (*playwright.StorageState, error) {
+ t.Helper()
+ return func(opts ...playwright.BrowserContextStorageStateOptions) (*playwright.StorageState, error) {
+ require.Len(t, opts, 1)
+ require.NotNil(t, opts[0].Path)
+ require.NoError(t, os.WriteFile(*opts[0].Path, []byte(`{"cookies":[]}`), 0o644))
+ return &playwright.StorageState{}, nil
+ }
+}
+
+// The storage state holds IdP session cookies, so it must not stay world-readable.
+func TestSaveStorageStateRestrictsPermissions(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ saver := NewMockstorageStateSaver(ctrl)
+ statePath := filepath.Join(t.TempDir(), ".aws", "saml2aws", "storageState.json")
+
+ saver.EXPECT().StorageState(gomock.Any()).DoAndReturn(writeStateLikePlaywright(t))
+
+ require.NoError(t, saveStorageState(saver, statePath))
+
+ data, err := os.ReadFile(statePath)
+ require.NoError(t, err)
+ assert.JSONEq(t, `{"cookies":[]}`, string(data))
+
+ if runtime.GOOS == "windows" {
+ return // Unix permission bits are not meaningful on Windows.
+ }
+ fileInfo, err := os.Stat(statePath)
+ require.NoError(t, err)
+ assert.Equal(t, os.FileMode(storageStateFilePerm), fileInfo.Mode().Perm())
+ dirInfo, err := os.Stat(filepath.Dir(statePath))
+ require.NoError(t, err)
+ assert.Equal(t, os.FileMode(storageStateDirPerm), dirInfo.Mode().Perm())
+}
+
+func TestSaveStorageStateReturnsSaveError(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ saver := NewMockstorageStateSaver(ctrl)
+ statePath := filepath.Join(t.TempDir(), "storageState.json")
+
+ saver.EXPECT().StorageState(gomock.Any()).Return(nil, errTest)
+
+ require.ErrorIs(t, saveStorageState(saver, statePath), errTest)
+ _, err := os.Stat(statePath)
+ assert.ErrorIs(t, err, os.ErrNotExist)
+}
+
+func TestSaveStorageStateReturnsMkdirError(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ saver := NewMockstorageStateSaver(ctrl) // No StorageState call is expected.
+
+ // A regular file where the parent directory should be makes MkdirAll fail on every OS.
+ blocker := filepath.Join(t.TempDir(), "blocker")
+ require.NoError(t, os.WriteFile(blocker, []byte("x"), 0o600))
+
+ require.Error(t, saveStorageState(saver, filepath.Join(blocker, "storageState.json")))
+}
+
+// Regression: the state is written to a private temporary file, so it is never world-readable, even when
+// the destination file or directory already exists with wide permissions.
+func TestSaveStorageStateNeverWorldReadable(t *testing.T) {
+ if runtime.GOOS == "windows" {
+ t.Skipf("Unix permission bits are not meaningful on Windows.")
+ }
+ ctrl := gomock.NewController(t)
+ saver := NewMockstorageStateSaver(ctrl)
+ dir := t.TempDir()
+ require.NoError(t, os.Chmod(dir, 0o755))
+ statePath := filepath.Join(dir, "storageState.json")
+ require.NoError(t, os.WriteFile(statePath, []byte(`{"old":true}`), 0o644))
+
+ saver.EXPECT().StorageState(gomock.Any()).DoAndReturn(func(opts ...playwright.BrowserContextStorageStateOptions) (*playwright.StorageState, error) {
+ // While Playwright writes, the target is a private file in a private directory.
+ info, err := os.Stat(*opts[0].Path)
+ require.NoError(t, err)
+ assert.Equal(t, os.FileMode(0o600), info.Mode().Perm())
+ dirInfo, err := os.Stat(dir)
+ require.NoError(t, err)
+ assert.Equal(t, os.FileMode(storageStateDirPerm), dirInfo.Mode().Perm())
+ return writeStateLikePlaywright(t)(opts...)
+ })
+
+ require.NoError(t, saveStorageState(saver, statePath))
+ info, err := os.Stat(statePath)
+ require.NoError(t, err)
+ assert.Equal(t, os.FileMode(storageStateFilePerm), info.Mode().Perm())
+}
+
+// A failed save keeps the previous state and leaves no temporary file behind.
+func TestSaveStorageStateFailurePreservesPreviousState(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ saver := NewMockstorageStateSaver(ctrl)
+ dir := t.TempDir()
+ statePath := filepath.Join(dir, "storageState.json")
+ require.NoError(t, os.WriteFile(statePath, []byte(`{"old":true}`), 0o600))
+
+ saver.EXPECT().StorageState(gomock.Any()).DoAndReturn(func(opts ...playwright.BrowserContextStorageStateOptions) (*playwright.StorageState, error) {
+ require.NoError(t, os.WriteFile(*opts[0].Path, []byte("partial"), 0o600))
+ return nil, errTest
+ })
+
+ require.ErrorIs(t, saveStorageState(saver, statePath), errTest)
+
+ data, err := os.ReadFile(statePath)
+ require.NoError(t, err)
+ assert.JSONEq(t, `{"old":true}`, string(data))
+ entries, err := os.ReadDir(dir)
+ require.NoError(t, err)
+ assert.Len(t, entries, 1)
+}
diff --git a/pkg/auth/providers/aws/saml2aws/provider/googleapps/example/captcha.html b/pkg/auth/providers/aws/saml2aws/provider/googleapps/example/captcha.html
new file mode 100644
index 00000000000..07e0e05579f
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/provider/googleapps/example/captcha.html
@@ -0,0 +1,102 @@
+
+
+
+ Sign in - Google Accounts
+
+
+
+
+
+
+
+
+
+
+ Sign in
+ Use your Google Account
+
+
+
+
+
+
+
+
+
+
diff --git a/pkg/auth/providers/aws/saml2aws/provider/googleapps/example/challenge-extra-number.html b/pkg/auth/providers/aws/saml2aws/provider/googleapps/example/challenge-extra-number.html
new file mode 100644
index 00000000000..67dcbc6b51c
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/provider/googleapps/example/challenge-extra-number.html
@@ -0,0 +1,96 @@
+
+
+
+
+
+ Google Accounts
+
+
+
+
+
+
+
+
+
+
+
+
+ 2-Step Verification
+ This extra step shows it’s really you trying to sign in
+
+
+
+
+
+
+
+
+ nick@example.comUse a different account
+
+
+
+
+
+
+
+
+
+
+
diff --git a/pkg/auth/providers/aws/saml2aws/provider/googleapps/example/challenge-prompt.html b/pkg/auth/providers/aws/saml2aws/provider/googleapps/example/challenge-prompt.html
new file mode 100644
index 00000000000..ad7bf502ec1
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/provider/googleapps/example/challenge-prompt.html
@@ -0,0 +1,126 @@
+
+
+
+
+
+ Google Accounts
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 2-Step Verification
+
+
+ This extra step shows it’s really you trying to sign in
+
+
+
+
+
+
+
+
diff --git a/pkg/auth/providers/aws/saml2aws/provider/googleapps/example/challenge-sms-send.html b/pkg/auth/providers/aws/saml2aws/provider/googleapps/example/challenge-sms-send.html
new file mode 100644
index 00000000000..2d2d747e3fd
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/provider/googleapps/example/challenge-sms-send.html
@@ -0,0 +1,350 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 2-Step Verification
+
+
+ This extra step shows it’s really you trying to sign in
+
+
+
+
+
+
+
+
+
+
+
+ edw@defang.io
+
+
+ Use a different account
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/pkg/auth/providers/aws/saml2aws/provider/googleapps/example/challenge-sms.html b/pkg/auth/providers/aws/saml2aws/provider/googleapps/example/challenge-sms.html
new file mode 100644
index 00000000000..0a67c70a610
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/provider/googleapps/example/challenge-sms.html
@@ -0,0 +1,371 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 2-Step Verification
+
+
+
+
+ This extra step shows it’s really you trying to sign in
+
+
+
+
+
+
+
+
+
+
+
+
+ edw@defang.io
+
+
+ Use a different account
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/pkg/auth/providers/aws/saml2aws/provider/googleapps/example/challenge-totp.html b/pkg/auth/providers/aws/saml2aws/provider/googleapps/example/challenge-totp.html
new file mode 100644
index 00000000000..b69d2f7393c
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/provider/googleapps/example/challenge-totp.html
@@ -0,0 +1,102 @@
+
+
+
+
+
+ Google Accounts
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 2-Step Verification
+
+
+ This extra step shows it’s really you trying to sign in
+
+
+
+
+
+
+
+
+
+
+ mark@wolfe.id.au
+ Use a different account
+
+
+
+
+
+
+
+
+
+
+
diff --git a/pkg/auth/providers/aws/saml2aws/provider/googleapps/example/form-password-challengeid-1.html b/pkg/auth/providers/aws/saml2aws/provider/googleapps/example/form-password-challengeid-1.html
new file mode 100644
index 00000000000..e8771fd7f63
--- /dev/null
+++ b/pkg/auth/providers/aws/saml2aws/provider/googleapps/example/form-password-challengeid-1.html
@@ -0,0 +1,115 @@
+
+
+
+
+
+
+
+
+
+ Google Accounts
+
+
+
+
+
+
+
+
+
+
+
+
+ One account. All of Google.
+ Sign in with your Google Account
+
+
+
+
+
+
+
+
+
+ Sign in with a different account
+ One Google Account for everything Google
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+