From a4b61c044e69eb101af04b6fc9ed0f4bf78f6596 Mon Sep 17 00:00:00 2001 From: Peter Grlica Date: Tue, 18 May 2021 07:56:42 +0200 Subject: [PATCH] Added integration and unit tests --- auth/saml/saml_test.go | 46 +++++ auth/saml/sp_test.go | 71 +++++++ system/service/auth_test.go | 13 +- .../system/auth_external_saml_success_test.go | 175 ++++++++++++++++++ tests/system/main_test.go | 48 ++++- tests/system/static/idp_metadata.xml | 1 + tests/system/static/idp_to_sp.cookie | 1 + tests/system/static/idp_to_sp.post | 1 + tests/system/static/idp_to_sp_token.cookie | 1 + tests/system/static/spCert.cert | 19 ++ tests/system/static/spCert.key | 28 +++ 11 files changed, 392 insertions(+), 12 deletions(-) create mode 100644 auth/saml/saml_test.go create mode 100644 auth/saml/sp_test.go create mode 100644 tests/system/auth_external_saml_success_test.go create mode 100644 tests/system/static/idp_metadata.xml create mode 100644 tests/system/static/idp_to_sp.cookie create mode 100644 tests/system/static/idp_to_sp.post create mode 100644 tests/system/static/idp_to_sp_token.cookie create mode 100644 tests/system/static/spCert.cert create mode 100644 tests/system/static/spCert.key diff --git a/auth/saml/saml_test.go b/auth/saml/saml_test.go new file mode 100644 index 000000000..53a1924b6 --- /dev/null +++ b/auth/saml/saml_test.go @@ -0,0 +1,46 @@ +package saml + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +func Test_TemplateProvider(t *testing.T) { + var ( + tcc = []struct { + name string + url string + expect templateProvider + }{ + { + name: "Default SAML provider", + url: "http://example.tld", + expect: templateProvider{ + Label: "Default SAML provider", + Handle: "saml/init", + Icon: "key", + }, + }, + { + name: "", + url: "http://example.tld", + expect: templateProvider{ + Label: "http://example.tld", + Handle: "saml/init", + Icon: "key", + }, + }, + } + ) + + for _, tc := range tcc { + t.Run(tc.name, func(t *testing.T) { + var ( + req = require.New(t) + ) + + req.Equal(tc.expect, TemplateProvider(tc.url, tc.name)) + }) + } +} diff --git a/auth/saml/sp_test.go b/auth/saml/sp_test.go new file mode 100644 index 000000000..5e687a19c --- /dev/null +++ b/auth/saml/sp_test.go @@ -0,0 +1,71 @@ +package saml + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +const ( + defaultSAMLEmailPayload = "urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress" + defaultSamlTestEmailPayload = "urn:oasis:names:tc:SAML:attribute:subject-id" +) + +func Test_guessIdentifier(t *testing.T) { + var ( + sp = SamlSPService{ + IDPUserMeta: &IdpIdentityPayload{ + Name: "name_field", + Handle: "handle_field", + Identifier: "identifier_field", + }, + } + + tcc = []struct { + name string + payload map[string][]string + expect string + }{ + { + name: "default email", + payload: map[string][]string{"email": {"test@example.com"}}, + expect: "test@example.com", + }, + { + name: "samltest.id email payload", + payload: map[string][]string{defaultSamlTestEmailPayload: {"test@example.com"}}, + expect: "test@example.com", + }, + { + name: "default SAML emailAddress payload", + payload: map[string][]string{defaultSAMLEmailPayload: {"test@example.com"}}, + expect: "test@example.com", + }, + { + name: "emailAddress payload", + payload: map[string][]string{"emailAddress": {"test@example.com"}}, + expect: "test@example.com", + }, + { + name: "missing email payload", + payload: map[string][]string{"non-existing-identifier": {"test@example.com"}}, + expect: "", + }, + { + name: "default payload as set in settings", + payload: map[string][]string{"identifier_field": {"test@example.com"}}, + expect: "test@example.com", + }, + } + ) + + for _, tc := range tcc { + t.Run(tc.name, func(t *testing.T) { + var ( + req = require.New(t) + ) + + req.Equal(tc.expect, sp.GuessIdentifier(tc.payload)) + }) + } +} diff --git a/system/service/auth_test.go b/system/service/auth_test.go index af16f36d6..a8dfd1fa6 100644 --- a/system/service/auth_test.go +++ b/system/service/auth_test.go @@ -3,6 +3,9 @@ package service import ( "context" "fmt" + "testing" + "time" + "github.com/cortezaproject/corteza-server/pkg/eventbus" "github.com/cortezaproject/corteza-server/pkg/id" "github.com/cortezaproject/corteza-server/store" @@ -12,8 +15,6 @@ import ( "github.com/stretchr/testify/require" "go.uber.org/zap" "golang.org/x/crypto/bcrypt" - "testing" - "time" ) // Mock auth service with nil for current time, dummy provider validator and mock db @@ -80,23 +81,23 @@ func TestAuth_External(t *testing.T) { cases = []struct { name string - profile goth.User + profile types.ExternalAuthUser user *types.User err error }{ { "matching by user email", - goth.User{UserID: freshProfileID(), Provider: "-", Email: validUser.Email}, + types.ExternalAuthUser{goth.User{UserID: freshProfileID(), Provider: "-", Email: validUser.Email}}, validUser, nil}, { "unknown profile", - goth.User{UserID: freshProfileID(), Provider: "-", Email: "fresh-from-foo@test.cortezaproject.org"}, + types.ExternalAuthUser{goth.User{UserID: freshProfileID(), Provider: "-", Email: "fresh-from-foo@test.cortezaproject.org"}}, &types.User{Email: "fresh-from-foo@test.cortezaproject.org"}, nil}, { "profile match by provider ID", - goth.User{UserID: fooCredentials.Credentials, Provider: fooCredentials.Kind, Email: "valid+2nd+email@test.cortezaproject.org"}, + types.ExternalAuthUser{goth.User{UserID: fooCredentials.Credentials, Provider: fooCredentials.Kind, Email: "valid+2nd+email@test.cortezaproject.org"}}, validUser, nil}, } diff --git a/tests/system/auth_external_saml_success_test.go b/tests/system/auth_external_saml_success_test.go new file mode 100644 index 000000000..d05a49a9d --- /dev/null +++ b/tests/system/auth_external_saml_success_test.go @@ -0,0 +1,175 @@ +package system + +import ( + "context" + "net/http" + "net/url" + "testing" + "time" + + "github.com/cortezaproject/corteza-server/auth/handlers" + "github.com/cortezaproject/corteza-server/auth/saml" + "github.com/cortezaproject/corteza-server/system/service" + "github.com/cortezaproject/corteza-server/system/types" + s "github.com/crewjam/saml" + "github.com/crewjam/saml/samlsp" + jwt "github.com/dgrijalva/jwt-go" + "github.com/steinfletcher/apitest" +) + +func loadSAMLService(ctx context.Context) (srvc *saml.SamlSPService, err error) { + links := handlers.GetLinks() + + certManager := saml.NewCertManager(&saml.CertStoreLoader{}) + + cert, err := certManager.Parse( + readStaticFile("static/spCert.cert"), + readStaticFile("static/spCert.key")) + + if err != nil { + return + } + + idpUrl, err := url.Parse("") + if err != nil { + return + } + + // idp metadata needs to be loaded before + // the internal samlsp package + md, err := samlsp.ParseMetadata(readStaticFile("static/idp_metadata.xml")) + ru, err := url.Parse("http://localhost:8084") + + rootURL := &url.URL{ + Scheme: ru.Scheme, + User: ru.User, + Host: ru.Host, + } + + if err != nil { + return + } + + srvc, err = saml.NewSamlSPService(saml.SamlSPArgs{ + AcsURL: links.SamlCallback, + MetaURL: links.SamlMetadata, + SloURL: links.SamlLogout, + + IdpURL: *idpUrl, + Host: *rootURL, + + Cert: cert, + IdpMeta: md, + }) + + srvc.Handler().ServiceProvider.AllowIDPInitiated = true + + return +} + +func TestAuthExternalSAMLSuccess(t *testing.T) { + var ( + h = newHelper(t) + + cookieSessionIDPtoSP = apitest. + NewCookie("saml_tCu5PV6EgxcvUAa9e57uJ2g-bTkqnNkyyHHaOu15yEfZjgWKt02AtXGe"). + Value(string(readStaticFile("static/idp_to_sp.cookie"))) + + cookieTokenIDPtoSPAfterLogin = apitest. + NewCookie("token"). + Value(string(readStaticFile("static/idp_to_sp_token.cookie"))) + ) + + s.MaxClockSkew = time.Hour + s.MaxIssueDelay = time.Hour + + jwt.TimeFunc = func() time.Time { + tm, _ := time.Parse("2006-01-2 15:04:05", "2021-05-17 09:17:10") + return tm + } + + s.TimeNow = func() time.Time { + tm, _ := time.Parse("2006-01-2 15:04:05", "2021-05-17 09:17:10") + return tm + } + + // first step, there is no session cookie, redirect to idp + // in this case, host from parsed metadata + t.Log("start login process") + + h.apiInit(). + Get(handlers.GetLinks().SamlInit). + Expect(t). + Assert(func(res *http.Response, req *http.Request) error { + loc, _ := res.Location() + + h.assertBody("SSO Error: saml: session not present", res.Body) + h.a.NotEmpty(loc.Query().Get("RelayState")) + h.a.NotEmpty(loc.Query().Get("SAMLRequest")) + h.a.Equal(http.StatusFound, res.StatusCode) + return nil + }). + End() + + cookies := []*apitest.Cookie{} + + // coming back from idp, posting to sp-related endpoint + // mocking session cookie and saml response + // if everything is ok, redirect back to SAML init + t.Log("post from idp to sp") + + h.apiInit(). + Post(handlers.GetLinks().SamlCallback). + Header("Content-Type", "application/x-www-form-urlencoded"). + FormData("RelayState", "tCu5PV6EgxcvUAa9e57uJ2g-bTkqnNkyyHHaOu15yEfZjgWKt02AtXGe"). + Cookies(cookieSessionIDPtoSP). + FormData("SAMLResponse", string(readStaticFile("static/idp_to_sp.post"))). + Expect(t). + Assert(func(res *http.Response, req *http.Request) error { + loc, _ := res.Location() + + h.a.NotNil(getSessionCookie("token", res.Cookies()...)) + h.a.Equal(http.StatusFound, res.StatusCode) + h.a.Equal(handlers.GetLinks().SamlInit, loc.String()) + + cookies = append(cookies, cookieSessionIDPtoSP) + return nil + }). + End() + + // idp sends a token session cookie also + cookies = append(cookies, cookieTokenIDPtoSPAfterLogin) + + // once everything is set and the external authentication via + // internal Corteza services is done, redirect to default path (profile) + t.Log("redirect to profile after session is created") + + h.apiInit(). + Get(handlers.GetLinks().SamlInit). + Cookies(cookies...). + Expect(t). + Assert(func(res *http.Response, req *http.Request) error { + loc, _ := res.Location() + + ss, _, err := service.DefaultStore.SearchAuthSessions(context.Background(), types.AuthSessionFilter{}) + h.a.NoError(err) + h.a.Len(ss, 1) + + h.a.NotNil(getSessionCookie("session", res.Cookies()...)) + h.a.Equal(http.StatusSeeOther, res.StatusCode) + h.a.Equal(handlers.GetLinks().Profile, loc.String()) + return nil + }). + End() +} + +func getSessionCookie(name string, cc ...*http.Cookie) (found *http.Cookie) { + for _, c := range cc { + if c.Name == name { + found = c + return + } + } + + return +} diff --git a/tests/system/main_test.go b/tests/system/main_test.go index 2e4cb52f4..78948f379 100644 --- a/tests/system/main_test.go +++ b/tests/system/main_test.go @@ -2,15 +2,19 @@ package system import ( "context" + "embed" "errors" + "io" "os" "testing" "github.com/cortezaproject/corteza-server/app" + handlers "github.com/cortezaproject/corteza-server/auth/handlers" + "github.com/cortezaproject/corteza-server/auth/request" + "github.com/cortezaproject/corteza-server/auth/saml" "github.com/cortezaproject/corteza-server/pkg/api/server" "github.com/cortezaproject/corteza-server/pkg/auth" "github.com/cortezaproject/corteza-server/pkg/cli" - "github.com/cortezaproject/corteza-server/pkg/eventbus" "github.com/cortezaproject/corteza-server/pkg/id" label "github.com/cortezaproject/corteza-server/pkg/label" ltype "github.com/cortezaproject/corteza-server/pkg/label/types" @@ -32,21 +36,25 @@ import ( "go.uber.org/zap" ) +//go:embed static +var mockData embed.FS + type ( helper struct { - t *testing.T - a *require.Assertions + t *testing.T + a *require.Assertions + sp *saml.SamlSPService cUser *types.User roleID uint64 + data embed.FS } ) var ( testApp *app.CortezaApp r chi.Router - - eventBus = eventbus.New() + hh *handlers.AuthHandlers ) func init() { @@ -64,10 +72,14 @@ func rs(a ...int) string { } func InitTestApp() { + var sm *request.SessionManager + if testApp == nil { ctx := cli.Context() testApp = helpers.NewIntegrationTestApp(ctx, func(app *app.CortezaApp) (err error) { + service.CurrentSettings.Auth.External.Enabled = true + rbac.SetGlobal(rbac.NewTestService(zap.NewNop(), app.Store)) service.DefaultObjectStore, err = plain.NewWithAfero(afero.NewMemMapFs(), "test") if err != nil { @@ -79,16 +91,28 @@ func InitTestApp() { return err } - eventbus.Set(eventBus) + sm = request.NewSessionManager(service.DefaultStore, app.Opt.Auth, service.DefaultLogger) + return nil }) } + sp, _ := loadSAMLService(context.Background()) + + hh = &handlers.AuthHandlers{ + SamlSPService: *sp, + Log: zap.NewNop(), + AuthService: service.DefaultAuth, + SessionManager: sm, + } + if r == nil { r = chi.NewRouter() r.Use(server.BaseMiddleware(false, logger.Default())...) + helpers.BindAuthMiddleware(r) rest.MountRoutes(r) + hh.MountHttpRoutes(r) } } @@ -105,6 +129,7 @@ func newHelper(t *testing.T) helper { cUser: &types.User{ ID: id.Next(), }, + data: mockData, } h.cUser.SetRoles([]uint64{h.roleID}) @@ -174,6 +199,17 @@ func (h helper) setLabel(res label.LabeledResource, name, value string) { })) } +func (h helper) assertBody(e string, s io.ReadCloser) { + b, err := io.ReadAll(s) + h.a.NoError(err) + h.a.Equal(e, string(b)) +} + func (h helper) clearTemplates() { h.noError(store.TruncateTemplates(context.Background(), service.DefaultStore)) } + +func readStaticFile(f string) []byte { + c, _ := mockData.ReadFile(f) + return c +} diff --git a/tests/system/static/idp_metadata.xml b/tests/system/static/idp_metadata.xml new file mode 100644 index 000000000..0e6487516 --- /dev/null +++ b/tests/system/static/idp_metadata.xml @@ -0,0 +1 @@ +samltest.idSAMLtest IdPA free and basic IdP for testing SAML deploymentshttps://samltest.id/saml/logo.png MIIDETCCAfmgAwIBAgIUZRpDhkNKl5eWtJqk0Bu1BgTTargwDQYJKoZIhvcNAQEL BQAwFjEUMBIGA1UEAwwLc2FtbHRlc3QuaWQwHhcNMTgwODI0MjExNDEwWhcNMzgw ODI0MjExNDEwWjAWMRQwEgYDVQQDDAtzYW1sdGVzdC5pZDCCASIwDQYJKoZIhvcN AQEBBQADggEPADCCAQoCggEBAJrh9/PcDsiv3UeL8Iv9rf4WfLPxuOm9W6aCntEA 8l6c1LQ1Zyrz+Xa/40ZgP29ENf3oKKbPCzDcc6zooHMji2fBmgXp6Li3fQUzu7yd +nIC2teejijVtrNLjn1WUTwmqjLtuzrKC/ePoZyIRjpoUxyEMJopAd4dJmAcCq/K k2eYX9GYRlqvIjLFoGNgy2R4dWwAKwljyh6pdnPUgyO/WjRDrqUBRFrLQJorR2kD c4seZUbmpZZfp4MjmWMDgyGM1ZnR0XvNLtYeWAyt0KkSvFoOMjZUeVK/4xR74F8e 8ToPqLmZEg9ZUx+4z2KjVK00LpdRkH9Uxhh03RQ0FabHW6UCAwEAAaNXMFUwHQYD VR0OBBYEFJDbe6uSmYQScxpVJhmt7PsCG4IeMDQGA1UdEQQtMCuCC3NhbWx0ZXN0 LmlkhhxodHRwczovL3NhbWx0ZXN0LmlkL3NhbWwvaWRwMA0GCSqGSIb3DQEBCwUA A4IBAQBNcF3zkw/g51q26uxgyuy4gQwnSr01Mhvix3Dj/Gak4tc4XwvxUdLQq+jC cxr2Pie96klWhY/v/JiHDU2FJo9/VWxmc/YOk83whvNd7mWaNMUsX3xGv6AlZtCO L3JhCpHjiN+kBcMgS5jrtGgV1Lz3/1zpGxykdvS0B4sPnFOcaCwHe2B9SOCWbDAN JXpTjz1DmJO4ImyWPJpN1xsYKtm67Pefxmn0ax0uE2uuzq25h0xbTkqIQgJzyoE/ DPkBFK1vDkMfAW11dQ0BXatEnW7Gtkc0lh2/PIbHWj4AzxYMyBf5Gy6HSVOftwjC voQR2qr2xJBixsg+MIORKtmKHLfU MIIDEjCCAfqgAwIBAgIVAMECQ1tjghafm5OxWDh9hwZfxthWMA0GCSqGSIb3DQEB CwUAMBYxFDASBgNVBAMMC3NhbWx0ZXN0LmlkMB4XDTE4MDgyNDIxMTQwOVoXDTM4 MDgyNDIxMTQwOVowFjEUMBIGA1UEAwwLc2FtbHRlc3QuaWQwggEiMA0GCSqGSIb3 DQEBAQUAA4IBDwAwggEKAoIBAQC0Z4QX1NFKs71ufbQwoQoW7qkNAJRIANGA4iM0 ThYghul3pC+FwrGv37aTxWXfA1UG9njKbbDreiDAZKngCgyjxj0uJ4lArgkr4AOE jj5zXA81uGHARfUBctvQcsZpBIxDOvUUImAl+3NqLgMGF2fktxMG7kX3GEVNc1kl bN3dfYsaw5dUrw25DheL9np7G/+28GwHPvLb4aptOiONbCaVvh9UMHEA9F7c0zfF /cL5fOpdVa54wTI0u12CsFKt78h6lEGG5jUs/qX9clZncJM7EFkN3imPPy+0HC8n spXiH/MZW8o2cqWRkrw3MzBZW3Ojk5nQj40V6NUbjb7kfejzAgMBAAGjVzBVMB0G A1UdDgQWBBQT6Y9J3Tw/hOGc8PNV7JEE4k2ZNTA0BgNVHREELTArggtzYW1sdGVz dC5pZIYcaHR0cHM6Ly9zYW1sdGVzdC5pZC9zYW1sL2lkcDANBgkqhkiG9w0BAQsF AAOCAQEASk3guKfTkVhEaIVvxEPNR2w3vWt3fwmwJCccW98XXLWgNbu3YaMb2RSn 7Th4p3h+mfyk2don6au7Uyzc1Jd39RNv80TG5iQoxfCgphy1FYmmdaSfO8wvDtHT TNiLArAxOYtzfYbzb5QrNNH/gQEN8RJaEf/g/1GTw9x/103dSMK0RXtl+fRs2nbl D1JJKSQ3AdhxK/weP3aUPtLxVVJ9wMOQOfcy02l+hHMb6uAjsPOpOVKqi3M8XmcU ZOpx4swtgGdeoSpeRyrtMvRwdcciNBp9UZome44qZAYH1iqrpmmjsfI9pJItsgWu 3kXPjhSfj1AJGR1l9JGvJrHki1iHTA== MIIDEjCCAfqgAwIBAgIVAPVbodo8Su7/BaHXUHykx0Pi5CFaMA0GCSqGSIb3DQEB CwUAMBYxFDASBgNVBAMMC3NhbWx0ZXN0LmlkMB4XDTE4MDgyNDIxMTQwOVoXDTM4 MDgyNDIxMTQwOVowFjEUMBIGA1UEAwwLc2FtbHRlc3QuaWQwggEiMA0GCSqGSIb3 DQEBAQUAA4IBDwAwggEKAoIBAQCQb+1a7uDdTTBBFfwOUun3IQ9nEuKM98SmJDWa MwM877elswKUTIBVh5gB2RIXAPZt7J/KGqypmgw9UNXFnoslpeZbA9fcAqqu28Z4 sSb2YSajV1ZgEYPUKvXwQEmLWN6aDhkn8HnEZNrmeXihTFdyr7wjsLj0JpQ+VUlc 4/J+hNuU7rGYZ1rKY8AA34qDVd4DiJ+DXW2PESfOu8lJSOteEaNtbmnvH8KlwkDs 1NvPTsI0W/m4SK0UdXo6LLaV8saIpJfnkVC/FwpBolBrRC/Em64UlBsRZm2T89ca uzDee2yPUvbBd5kLErw+sC7i4xXa2rGmsQLYcBPhsRwnmBmlAgMBAAGjVzBVMB0G A1UdDgQWBBRZ3exEu6rCwRe5C7f5QrPcAKRPUjA0BgNVHREELTArggtzYW1sdGVz dC5pZIYcaHR0cHM6Ly9zYW1sdGVzdC5pZC9zYW1sL2lkcDANBgkqhkiG9w0BAQsF AAOCAQEABZDFRNtcbvIRmblnZItoWCFhVUlq81ceSQddLYs8DqK340//hWNAbYdj WcP85HhIZnrw6NGCO4bUipxZXhiqTA/A9d1BUll0vYB8qckYDEdPDduYCOYemKkD dmnHMQWs9Y6zWiYuNKEJ9mf3+1N8knN/PK0TYVjVjXAf2CnOETDbLtlj6Nqb8La3 sQkYmU+aUdopbjd5JFFwbZRaj6KiHXHtnIRgu8sUXNPrgipUgZUOVhP0C0N5OfE4 JW8ZBrKgQC/6vJ2rSa9TlzI6JAa5Ww7gMXMP9M+cJUNQklcq+SBnTK8G+uBHgPKR zBDsMIEzRtQZm4GIoHJae4zmnCekkQ== \ No newline at end of file diff --git a/tests/system/static/idp_to_sp.cookie b/tests/system/static/idp_to_sp.cookie new file mode 100644 index 000000000..2a70246e1 --- /dev/null +++ b/tests/system/static/idp_to_sp.cookie @@ -0,0 +1 @@ +eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJhdWQiOiJodHRwOi8vbG9jYWxob3N0OjgwODQiLCJleHAiOjE2MjEyNDMwODIsImlhdCI6MTYyMTI0Mjk5MiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo4MDg0IiwibmJmIjoxNjIxMjQyOTkyLCJzdWIiOiJ0Q3U1UFY2RWd4Y3ZVQWE5ZTU3dUoyZy1iVGtxbk5reXlISGFPdTE1eUVmWmpnV0t0MDJBdFhHZSIsImlkIjoiaWQtN2JmZmIyNmQ2YmVlNGI1YmRmODZmOGRjNGRhMmNmYzExN2Q4OWQwZiIsInVyaSI6Ii9hdXRoL2V4dGVybmFsL3NhbWwvaW5pdCIsInNhbWwtYXV0aG4tcmVxdWVzdCI6dHJ1ZX0.CU_jrc5gx6JhafzbekO-7VXLJU6jzDd-R4QyrtQIZN3jyqIZtYB466KiTFZnyYeEWEjK7GW18eHuzZFHmDpcQ9weOtvu9u0Z7UUDm3YQoG-6XgUeQKTV2i1uPzq1ZlT8iiMBUsn0kdKL2F18U4jl4Fss0_Ysdc3OqoEJ73xcu0P721ZSsg-vEwyooe1WMSosunN_HEmWOU2aC61uQwNFSRk5_JotdUEytko1Jzn9JeOnLllf8izr7z7JWEnBqN8845IV_zqiScrAptpAZRocAeMAbFPFPmj5_lL2SzKC4GF4lkoOIZ5vWRBVdfzIxvD21rVZK5rRlSdYUmT0txFoQw \ No newline at end of file diff --git a/tests/system/static/idp_to_sp.post b/tests/system/static/idp_to_sp.post new file mode 100644 index 000000000..421ff50ab --- /dev/null +++ b/tests/system/static/idp_to_sp.post @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/tests/system/static/idp_to_sp_token.cookie b/tests/system/static/idp_to_sp_token.cookie new file mode 100644 index 000000000..0686e5e9d --- /dev/null +++ b/tests/system/static/idp_to_sp_token.cookie @@ -0,0 +1 @@ +eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJhdWQiOiJodHRwOi8vbG9jYWxob3N0OjgwODQiLCJleHAiOjE2MjEyNDY2MzAsImlhdCI6MTYyMTI0MzAzMCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo4MDg0IiwibmJmIjoxNjIxMjQzMDMwLCJzdWIiOiJBQWR6WldOeVpYUXhFMmR5SFBqRStoTVhQQW5uSUNpbUt2c21XeC9YMW9MaEFOV1dGbU0wWElMS01xa1dBWjFrVldiR0J0ZjhFS0xsb2wvakM2ZlJMa25Cc3dZRDlWNUxHQUErcDFxZHBON2w2MGI3ZHYvMFcwa25VRm1SSm8vWFlTYmRkTVFweUtBMWlCNVFrejZERDVsS0Ixa2VTMzBiYWpuT29OTT0iLCJhdHRyIjp7IlNlc3Npb25JbmRleCI6WyJfYzA5YWFiNDRhNTUyOGVhNzM2NTdkNTNjYTRmODA4NDMiXSwiZGlzcGxheU5hbWUiOlsiUmljayBTYW5jaGV6Il0sImVkdVBlcnNvbkVudGl0bGVtZW50IjpbInVybjptYWNlOmRpcjplbnRpdGxlbWVudDpjb21tb24tbGliLXRlcm1zIl0sImdpdmVuTmFtZSI6WyJSaWNrIl0sIm1haWwiOlsicnNhbmNoZXpAc2FtbHRlc3QuaWQiXSwicm9sZSI6WyJtYW5hZ2VyQHNhbWx0ZXN0LmlkIl0sInNuIjpbIlNhbmNoZXoiXSwidGVsZXBob25lTnVtYmVyIjpbIisxLTU1NS01NTUtNTUxNSJdLCJ1aWQiOlsicmljayJdLCJ1cm46b2FzaXM6bmFtZXM6dGM6U0FNTDphdHRyaWJ1dGU6c3ViamVjdC1pZCI6WyJyc2FuY2hlekBzYW1sdGVzdC5pZCJdfSwic2FtbC1zZXNzaW9uIjp0cnVlfQ.bNYxkq2dnISDr4x0Wg9pBXcOsSpKEvf5Bb_1vfZDLax6yH2Jjn0Dwjn7LMI6rRcz31YdMkhxrc9sISDD4Peotc1q_QNmJ92xCCzDq9jZM7ptRpKHZJIWkgwUDmmsLjCWj_YiuOwsPP6Zt70AJXNUtOcBg04Dw5ncpcR1cRqf6rTP7rAdNjQ_Euitln1gHK4Zz-fH0GgtS_pYHIzKTRarxiEktMvQGiaNce5e-1DmMOS3L9_6-lSlTa4sYG9BVG4icFf3QnUXqc3DCgGQr7waMuZNA35jqSJ1MSwhLVSHV5gb_l3HxoHKwZhue5d874apTk8cX00wlDO0Q9Z1z2R9Pg \ No newline at end of file diff --git a/tests/system/static/spCert.cert b/tests/system/static/spCert.cert new file mode 100644 index 000000000..173fddb74 --- /dev/null +++ b/tests/system/static/spCert.cert @@ -0,0 +1,19 @@ +-----BEGIN CERTIFICATE----- +MIIDITCCAgmgAwIBAgIUB34XNoIgt3k4tLbC40GDnLuvYAkwDQYJKoZIhvcNAQEL +BQAwIDEeMBwGA1UEAwwVbXlzZXJ2aWNlLmV4YW1wbGUuY29tMB4XDTIxMDQyMjE3 +MzIzOVoXDTIyMDQyMjE3MzIzOVowIDEeMBwGA1UEAwwVbXlzZXJ2aWNlLmV4YW1w +bGUuY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAp9jElUsjM3We +UHA9CjGQLoQJlhNOqkv2oKZBvTpr8bAQF40vP9qGiwrZqRe0se1xCTmlVM/HGrct +C0I6aL7+WTamNEvwPimoWsk1V7zYY7cFW+JEmL/E379R+9giQLBxIvvg7hSd7icl +ucwG5V6WPenQiyneEegTsEEgKqagIAgSV9zYjNQrQes73WHBj8VCZhTsVEnVO+/V +mCJaEwwovZWP0loLebR29/I4gr/LmfQfrIA+j116o5zp44vl1yW98xq5snkgb4YB +fm6pTHDl2rn4pM3avL+sK1usz7HQwmKrW6cpLtKVc+Sbjf3MyLUuHxRmkPoY2J56 +uJ1OWChoYwIDAQABo1MwUTAdBgNVHQ4EFgQUTjg/FEKaUjpqzm3KzCg+WMUsm2ow +HwYDVR0jBBgwFoAUTjg/FEKaUjpqzm3KzCg+WMUsm2owDwYDVR0TAQH/BAUwAwEB +/zANBgkqhkiG9w0BAQsFAAOCAQEALXtIWymIgZDMKHlVzMWq/Id/jP2aI0hpvZgS +2Lv7UDdyF1bj1MDTOtDkERoTVh/Xbhao5ls+GVhxvudjnZ8irdtlQRJNWTgj58Zi +zagO3StQ2duwZPyvt9jHgVJ8Jm9w8JVgsNP4Notl5Gj7dMGhxnm4aA2oHScJoC5g +u2ukGAAxgUpjNA7j9C/7iVLzijFzhztq7XTmbnJmuFPR50rqHJcTTYMVDc8Pb73c +mjDZDz9U91v+7j5oDLV/8khvLsHxi85/GA1+j7z77wWzrIwwNjY4YfbhF0HJZXQz +Xf3EHGxtSC01hJyfBjyXh5H8+NbyAYF8+d8y+uFu+GHhLS+Yag== +-----END CERTIFICATE----- diff --git a/tests/system/static/spCert.key b/tests/system/static/spCert.key new file mode 100644 index 000000000..e70b55180 --- /dev/null +++ b/tests/system/static/spCert.key @@ -0,0 +1,28 @@ +-----BEGIN PRIVATE KEY----- +MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCn2MSVSyMzdZ5Q +cD0KMZAuhAmWE06qS/agpkG9OmvxsBAXjS8/2oaLCtmpF7Sx7XEJOaVUz8caty0L +Qjpovv5ZNqY0S/A+KahayTVXvNhjtwVb4kSYv8Tfv1H72CJAsHEi++DuFJ3uJyW5 +zAblXpY96dCLKd4R6BOwQSAqpqAgCBJX3NiM1CtB6zvdYcGPxUJmFOxUSdU779WY +IloTDCi9lY/SWgt5tHb38jiCv8uZ9B+sgD6PXXqjnOnji+XXJb3zGrmyeSBvhgF+ +bqlMcOXaufikzdq8v6wrW6zPsdDCYqtbpyku0pVz5JuN/czItS4fFGaQ+hjYnnq4 +nU5YKGhjAgMBAAECggEAPlzd/ZJjS9VhswVgyI7NwVqxrR8TVVbQFbRwLHyuaqg9 +8mI0sgbhgnvPj3INYyaTnxfaA/8HPTfd9pbu2MhN/Ju/eSLV6mLT+JdVyHmT9Mil +pxQU5KQr4+5T6bzOTTbBcnwfgJYMb9X/wF68GTDhpbNgFrTBm+mclxo7d11dlUiQ +bdA2KBhIM54kKcWEO90AP2FiC/cRSbv8afHVb0Fxy1SBAGVDSscUaEwgyHkRf6H7 +Mmt4xhfBwLZZk5pVa97pZsas7L0sm4BtyYSs4elJesuo3DTpezZSzWHNreJcCL00 +v7pm9ZWv9PYeUcQqSw6Ws2fhsydiN93o8s/fPpF0IQKBgQDQqvKPjGo3HLRnBmpc +nhUVQgjdh/QobJCGBjdxR/C3NkcatNLONddhefqovfb2jITdHmRKW+7XgRq/q457 +mZ2JPvvryiWcVqf6D91tSoFYrVg5nU1zr6nTga1BpTH00/eNEXxjMAAguPj3m7Sw +3BP7L8yZZI1pOOjzVzuISEDlGwKBgQDN62ZXzRqorn5t+mDywTAJ2qAyZzoDAtUP +CjANOKBCECqE9cOW1qBDJcaEF7G+xyB22CMciOELjGXWw6ZwFWjc23tDCEkoHoia +5IWvwNs5ncdPCuOm3aay9w2dx9Idy+Eq5Vpe4XDlnZvEfzjwXX3gbQ5YS9kbNE2r +XtmgD/BmWQKBgBNKqrBA0BUWT0tzGWRErThQ6ZbpmdYe62Gos3mCqCuYFgzPCOpN +qgL2DwmIvotexG3ZAHardzJvWjS8PKkKs7jbnNjY0I9ap58D1nnjOIAlTpHNDDsU +04OdapI2Hp8+9ZUSN8jHyEs+Lq5ds9/iCOrhKW5JEJXY0BinSPa5j15fAoGBAM2I +dqCQollXwe34CaiD13UeeOOWUTsMKqlWW9v2d085X5dSzyTRmSksnVbfZ5SqoOa+ +mV0z6pxiSIvywUACvqYjlIa10H9w6pzgF+fzMV3y9CsbDVtSxb7ABSFFf54qD9eH +EYq+rrchd4bMDYMtbiUB9V2AZ3VV4Wh5xfKTtjoRAoGAec/nBmX/oHiG/3T2LEmo +bTT+/eXc4LUzgHvFG6HW40PI8T2TfMTUGQH+90zkraryUF5PNoUF58tooDAcMWXm +DPEHFHeWn8T4obfuUjTw1mwj7Xjzr40HDitjIQa0bvBVwdYyEgiEw1CaeaUpq9Z8 +ElGWoRHT87pfoZjbdPz7a4Y= +-----END PRIVATE KEY-----