lib/controller/localdb/login_oidc_test.go

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 package localdb
   6
   7 import (
   8         "bytes"
   9         "context"
  10         "crypto/hmac"
  11         "crypto/sha256"
  12         "encoding/json"
  13         "fmt"
  14         "io"
  15         "net/http"
  16         "net/http/httptest"
  17         "net/url"
  18         "sort"
  19         "strings"
  20         "sync"
  21         "testing"
  22         "time"
  23
  24         "git.arvados.org/arvados.git/lib/config"
  25         "git.arvados.org/arvados.git/lib/controller/rpc"
  26         "git.arvados.org/arvados.git/sdk/go/arvados"
  27         "git.arvados.org/arvados.git/sdk/go/arvadostest"
  28         "git.arvados.org/arvados.git/sdk/go/auth"
  29         "git.arvados.org/arvados.git/sdk/go/ctxlog"
  30         "github.com/jmoiron/sqlx"
  31         check "gopkg.in/check.v1"
  32 )
  33
  34 // Gocheck boilerplate
  35 func Test(t *testing.T) {
  36         check.TestingT(t)
  37 }
  38
  39 var _ = check.Suite(&OIDCLoginSuite{})
  40
  41 type OIDCLoginSuite struct {
  42         cluster      *arvados.Cluster
  43         localdb      *Conn
  44         railsSpy     *arvadostest.Proxy
  45         trustedURL   *arvados.URL
  46         fakeProvider *arvadostest.OIDCProvider
  47 }
  48
  49 func (s *OIDCLoginSuite) TearDownSuite(c *check.C) {
  50         // Undo any changes/additions to the user database so they
  51         // don't affect subsequent tests.
  52         arvadostest.ResetEnv()
  53         c.Check(arvados.NewClientFromEnv().RequestAndDecode(nil, "POST", "database/reset", nil, nil), check.IsNil)
  54 }
  55
  56 func (s *OIDCLoginSuite) SetUpTest(c *check.C) {
  57         s.trustedURL = &arvados.URL{Scheme: "https", Host: "app.example.com", Path: "/"}
  58
  59         s.fakeProvider = arvadostest.NewOIDCProvider(c)
  60         s.fakeProvider.AuthEmail = "active-user@arvados.local"
  61         s.fakeProvider.AuthEmailVerified = true
  62         s.fakeProvider.AuthName = "Fake User Name"
  63         s.fakeProvider.AuthGivenName = "Fake"
  64         s.fakeProvider.AuthFamilyName = "User Name"
  65         s.fakeProvider.ValidCode = fmt.Sprintf("abcdefgh-%d", time.Now().Unix())
  66         s.fakeProvider.PeopleAPIResponse = map[string]interface{}{}
  67
  68         cfg, err := config.NewLoader(nil, ctxlog.TestLogger(c)).Load()
  69         c.Assert(err, check.IsNil)
  70         s.cluster, err = cfg.GetCluster("")
  71         c.Assert(err, check.IsNil)
  72         s.cluster.Login.Test.Enable = false
  73         s.cluster.Login.Google.Enable = true
  74         s.cluster.Login.Google.ClientID = "test%client$id"
  75         s.cluster.Login.Google.ClientSecret = "test#client/secret"
  76         s.cluster.Login.TrustedClients = map[arvados.URL]struct{}{*s.trustedURL: {}}
  77         s.cluster.Users.PreferDomainForUsername = "PreferDomainForUsername.example.com"
  78         s.fakeProvider.ValidClientID = "test%client$id"
  79         s.fakeProvider.ValidClientSecret = "test#client/secret"
  80
  81         s.localdb = NewConn(s.cluster)
  82         c.Assert(s.localdb.loginController, check.FitsTypeOf, (*oidcLoginController)(nil))
  83         s.localdb.loginController.(*oidcLoginController).Issuer = s.fakeProvider.Issuer.URL
  84         s.localdb.loginController.(*oidcLoginController).peopleAPIBasePath = s.fakeProvider.PeopleAPI.URL
  85
  86         s.railsSpy = arvadostest.NewProxy(c, s.cluster.Services.RailsAPI)
  87         *s.localdb.railsProxy = *rpc.NewConn(s.cluster.ClusterID, s.railsSpy.URL, true, rpc.PassthroughTokenProvider)
  88 }
  89
  90 func (s *OIDCLoginSuite) TearDownTest(c *check.C) {
  91         s.railsSpy.Close()
  92 }
  93
  94 func (s *OIDCLoginSuite) TestGoogleLogout(c *check.C) {
  95         s.cluster.Login.TrustedClients[arvados.URL{Scheme: "https", Host: "foo.example", Path: "/"}] = struct{}{}
  96         s.cluster.Login.TrustPrivateNetworks = false
  97
  98         resp, err := s.localdb.Logout(context.Background(), arvados.LogoutOptions{ReturnTo: "https://foo.example.com/bar"})
  99         c.Check(err, check.NotNil)
 100         c.Check(resp.RedirectLocation, check.Equals, "")
 101
 102         resp, err = s.localdb.Logout(context.Background(), arvados.LogoutOptions{ReturnTo: "https://127.0.0.1/bar"})
 103         c.Check(err, check.NotNil)
 104         c.Check(resp.RedirectLocation, check.Equals, "")
 105
 106         resp, err = s.localdb.Logout(context.Background(), arvados.LogoutOptions{ReturnTo: "https://foo.example/bar"})
 107         c.Check(err, check.IsNil)
 108         c.Check(resp.RedirectLocation, check.Equals, "https://foo.example/bar")
 109
 110         s.cluster.Login.TrustPrivateNetworks = true
 111
 112         resp, err = s.localdb.Logout(context.Background(), arvados.LogoutOptions{ReturnTo: "https://192.168.1.1/bar"})
 113         c.Check(err, check.IsNil)
 114         c.Check(resp.RedirectLocation, check.Equals, "https://192.168.1.1/bar")
 115 }
 116
 117 func (s *OIDCLoginSuite) TestGoogleLogin_Start_Bogus(c *check.C) {
 118         resp, err := s.localdb.Login(context.Background(), arvados.LoginOptions{})
 119         c.Check(err, check.IsNil)
 120         c.Check(resp.RedirectLocation, check.Equals, "")
 121         c.Check(resp.HTML.String(), check.Matches, `.*missing return_to parameter.*`)
 122 }
 123
 124 func (s *OIDCLoginSuite) TestGoogleLogin_Start(c *check.C) {
 125         for _, remote := range []string{"", "zzzzz"} {
 126                 resp, err := s.localdb.Login(context.Background(), arvados.LoginOptions{Remote: remote, ReturnTo: "https://app.example.com/foo?bar"})
 127                 c.Check(err, check.IsNil)
 128                 target, err := url.Parse(resp.RedirectLocation)
 129                 c.Check(err, check.IsNil)
 130                 issuerURL, _ := url.Parse(s.fakeProvider.Issuer.URL)
 131                 c.Check(target.Host, check.Equals, issuerURL.Host)
 132                 q := target.Query()
 133                 c.Check(q.Get("client_id"), check.Equals, "test%client$id")
 134                 state := s.localdb.loginController.(*oidcLoginController).parseOAuth2State(q.Get("state"))
 135                 c.Check(state.verify([]byte(s.cluster.SystemRootToken)), check.Equals, true)
 136                 c.Check(state.Time, check.Not(check.Equals), 0)
 137                 c.Check(state.Remote, check.Equals, remote)
 138                 c.Check(state.ReturnTo, check.Equals, "https://app.example.com/foo?bar")
 139         }
 140 }
 141
 142 func (s *OIDCLoginSuite) TestGoogleLogin_UnknownClient(c *check.C) {
 143         resp, err := s.localdb.Login(context.Background(), arvados.LoginOptions{ReturnTo: "https://bad-app.example.com/foo?bar"})
 144         c.Check(err, check.IsNil)
 145         c.Check(resp.RedirectLocation, check.Equals, "")
 146         c.Check(resp.HTML.String(), check.Matches, `(?ms).*requesting site is not listed in TrustedClients.*`)
 147 }
 148
 149 func (s *OIDCLoginSuite) TestGoogleLogin_InvalidCode(c *check.C) {
 150         state := s.startLogin(c)
 151         resp, err := s.localdb.Login(context.Background(), arvados.LoginOptions{
 152                 Code:  "first-try-a-bogus-code",
 153                 State: state,
 154         })
 155         c.Check(err, check.IsNil)
 156         c.Check(resp.RedirectLocation, check.Equals, "")
 157         c.Check(resp.HTML.String(), check.Matches, `(?ms).*error in OAuth2 exchange.*cannot fetch token.*`)
 158 }
 159
 160 func (s *OIDCLoginSuite) TestGoogleLogin_InvalidState(c *check.C) {
 161         s.startLogin(c)
 162         resp, err := s.localdb.Login(context.Background(), arvados.LoginOptions{
 163                 Code:  s.fakeProvider.ValidCode,
 164                 State: "bogus-state",
 165         })
 166         c.Check(err, check.IsNil)
 167         c.Check(resp.RedirectLocation, check.Equals, "")
 168         c.Check(resp.HTML.String(), check.Matches, `(?ms).*invalid OAuth2 state.*`)
 169 }
 170
 171 func (s *OIDCLoginSuite) setupPeopleAPIError(c *check.C) {
 172         s.fakeProvider.PeopleAPI = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
 173                 w.WriteHeader(http.StatusForbidden)
 174                 fmt.Fprintln(w, `Error 403: accessNotConfigured`)
 175         }))
 176         s.localdb.loginController.(*oidcLoginController).peopleAPIBasePath = s.fakeProvider.PeopleAPI.URL
 177 }
 178
 179 func (s *OIDCLoginSuite) TestGoogleLogin_PeopleAPIDisabled(c *check.C) {
 180         s.localdb.loginController.(*oidcLoginController).UseGooglePeopleAPI = false
 181         s.fakeProvider.AuthEmail = "joe.smith@primary.example.com"
 182         s.setupPeopleAPIError(c)
 183         state := s.startLogin(c)
 184         _, err := s.localdb.Login(context.Background(), arvados.LoginOptions{
 185                 Code:  s.fakeProvider.ValidCode,
 186                 State: state,
 187         })
 188         c.Check(err, check.IsNil)
 189         authinfo := getCallbackAuthInfo(c, s.railsSpy)
 190         c.Check(authinfo.Email, check.Equals, "joe.smith@primary.example.com")
 191 }
 192
 193 func (s *OIDCLoginSuite) TestConfig(c *check.C) {
 194         s.cluster.Login.Google.Enable = false
 195         s.cluster.Login.OpenIDConnect.Enable = true
 196         s.cluster.Login.OpenIDConnect.Issuer = "https://accounts.example.com/"
 197         s.cluster.Login.OpenIDConnect.ClientID = "oidc-client-id"
 198         s.cluster.Login.OpenIDConnect.ClientSecret = "oidc-client-secret"
 199         s.cluster.Login.OpenIDConnect.AuthenticationRequestParameters = map[string]string{"testkey": "testvalue"}
 200         localdb := NewConn(s.cluster)
 201         ctrl := localdb.loginController.(*oidcLoginController)
 202         c.Check(ctrl.Issuer, check.Equals, "https://accounts.example.com/")
 203         c.Check(ctrl.ClientID, check.Equals, "oidc-client-id")
 204         c.Check(ctrl.ClientSecret, check.Equals, "oidc-client-secret")
 205         c.Check(ctrl.UseGooglePeopleAPI, check.Equals, false)
 206         c.Check(ctrl.AuthParams["testkey"], check.Equals, "testvalue")
 207
 208         for _, enableAltEmails := range []bool{false, true} {
 209                 s.cluster.Login.OpenIDConnect.Enable = false
 210                 s.cluster.Login.Google.Enable = true
 211                 s.cluster.Login.Google.ClientID = "google-client-id"
 212                 s.cluster.Login.Google.ClientSecret = "google-client-secret"
 213                 s.cluster.Login.Google.AlternateEmailAddresses = enableAltEmails
 214                 s.cluster.Login.Google.AuthenticationRequestParameters = map[string]string{"testkey": "testvalue"}
 215                 localdb = NewConn(s.cluster)
 216                 ctrl = localdb.loginController.(*oidcLoginController)
 217                 c.Check(ctrl.Issuer, check.Equals, "https://accounts.google.com")
 218                 c.Check(ctrl.ClientID, check.Equals, "google-client-id")
 219                 c.Check(ctrl.ClientSecret, check.Equals, "google-client-secret")
 220                 c.Check(ctrl.UseGooglePeopleAPI, check.Equals, enableAltEmails)
 221                 c.Check(ctrl.AuthParams["testkey"], check.Equals, "testvalue")
 222         }
 223 }
 224
 225 func (s *OIDCLoginSuite) TestGoogleLogin_PeopleAPIError(c *check.C) {
 226         s.setupPeopleAPIError(c)
 227         state := s.startLogin(c)
 228         resp, err := s.localdb.Login(context.Background(), arvados.LoginOptions{
 229                 Code:  s.fakeProvider.ValidCode,
 230                 State: state,
 231         })
 232         c.Check(err, check.IsNil)
 233         c.Check(resp.RedirectLocation, check.Equals, "")
 234 }
 235
 236 func (s *OIDCLoginSuite) TestOIDCAuthorizer(c *check.C) {
 237         s.cluster.Login.Google.Enable = false
 238         s.cluster.Login.OpenIDConnect.Enable = true
 239         json.Unmarshal([]byte(fmt.Sprintf("%q", s.fakeProvider.Issuer.URL)), &s.cluster.Login.OpenIDConnect.Issuer)
 240         s.cluster.Login.OpenIDConnect.ClientID = "oidc#client#id"
 241         s.cluster.Login.OpenIDConnect.ClientSecret = "oidc#client#secret"
 242         s.cluster.Login.OpenIDConnect.AcceptAccessToken = true
 243         s.cluster.Login.OpenIDConnect.AcceptAccessTokenScope = ""
 244         s.fakeProvider.ValidClientID = "oidc#client#id"
 245         s.fakeProvider.ValidClientSecret = "oidc#client#secret"
 246         db := arvadostest.DB(c, s.cluster)
 247
 248         tokenCacheTTL = time.Millisecond
 249         tokenCacheRaceWindow = time.Millisecond
 250         tokenCacheNegativeTTL = time.Millisecond
 251
 252         oidcAuthorizer := OIDCAccessTokenAuthorizer(s.cluster, func(context.Context) (*sqlx.DB, error) { return db, nil })
 253         accessToken := s.fakeProvider.ValidAccessToken()
 254
 255         mac := hmac.New(sha256.New, []byte(s.cluster.SystemRootToken))
 256         io.WriteString(mac, accessToken)
 257         apiToken := fmt.Sprintf("%x", mac.Sum(nil))
 258
 259         checkTokenInDB := func() time.Time {
 260                 var exp time.Time
 261                 err := db.QueryRow(`select expires_at at time zone 'UTC' from api_client_authorizations where api_token=$1`, apiToken).Scan(&exp)
 262                 c.Check(err, check.IsNil)
 263                 c.Check(exp.Sub(time.Now()) > -time.Second, check.Equals, true)
 264                 c.Check(exp.Sub(time.Now()) < time.Second, check.Equals, true)
 265                 return exp
 266         }
 267         cleanup := func() {
 268                 oidcAuthorizer.cache.Purge()
 269                 _, err := db.Exec(`delete from api_client_authorizations where api_token=$1`, apiToken)
 270                 c.Check(err, check.IsNil)
 271         }
 272         cleanup()
 273         defer cleanup()
 274
 275         ctx := auth.NewContext(context.Background(), &auth.Credentials{Tokens: []string{accessToken}})
 276
 277         // Check behavior on 5xx/network errors (don't cache) vs 4xx
 278         // (do cache)
 279         {
 280                 call := oidcAuthorizer.WrapCalls(func(ctx context.Context, opts interface{}) (interface{}, error) {
 281                         return nil, nil
 282                 })
 283
 284                 // If fakeProvider UserInfo endpoint returns 502, we
 285                 // should fail, return an error, and *not* cache the
 286                 // negative result.
 287                 tokenCacheNegativeTTL = time.Minute
 288                 s.fakeProvider.UserInfoErrorStatus = 502
 289                 _, err := call(ctx, nil)
 290                 c.Check(err, check.NotNil)
 291
 292                 // The negative result was not cached, so retrying
 293                 // immediately (with UserInfo working now) should
 294                 // succeed.
 295                 s.fakeProvider.UserInfoErrorStatus = 0
 296                 _, err = call(ctx, nil)
 297                 c.Check(err, check.IsNil)
 298                 checkTokenInDB()
 299
 300                 cleanup()
 301
 302                 // UserInfo 401 => cache the negative result, but
 303                 // don't return an error (just pass the token through
 304                 // as a v1 token)
 305                 s.fakeProvider.UserInfoErrorStatus = 401
 306                 _, err = call(ctx, nil)
 307                 c.Check(err, check.IsNil)
 308                 ent, ok := oidcAuthorizer.cache.Get(accessToken)
 309                 c.Check(ok, check.Equals, true)
 310                 c.Check(ent, check.FitsTypeOf, time.Time{})
 311
 312                 // UserInfo succeeds now, but we still have a cached
 313                 // negative result.
 314                 s.fakeProvider.UserInfoErrorStatus = 0
 315                 _, err = call(ctx, nil)
 316                 c.Check(err, check.IsNil)
 317                 ent, ok = oidcAuthorizer.cache.Get(accessToken)
 318                 c.Check(ok, check.Equals, true)
 319                 c.Check(ent, check.FitsTypeOf, time.Time{})
 320
 321                 tokenCacheNegativeTTL = time.Millisecond
 322                 cleanup()
 323         }
 324
 325         var exp1 time.Time
 326         concurrent := 4
 327         s.fakeProvider.HoldUserInfo = make(chan *http.Request)
 328         s.fakeProvider.ReleaseUserInfo = make(chan struct{})
 329         go func() {
 330                 for i := 0; ; i++ {
 331                         if i == concurrent {
 332                                 close(s.fakeProvider.ReleaseUserInfo)
 333                         }
 334                         <-s.fakeProvider.HoldUserInfo
 335                 }
 336         }()
 337         var wg sync.WaitGroup
 338         for i := 0; i < concurrent; i++ {
 339                 i := i
 340                 wg.Add(1)
 341                 go func() {
 342                         defer wg.Done()
 343                         _, err := oidcAuthorizer.WrapCalls(func(ctx context.Context, opts interface{}) (interface{}, error) {
 344                                 c.Logf("concurrent req %d/%d", i, concurrent)
 345
 346                                 creds, ok := auth.FromContext(ctx)
 347                                 c.Assert(ok, check.Equals, true)
 348                                 c.Assert(creds.Tokens, check.HasLen, 1)
 349                                 c.Check(creds.Tokens[0], check.Equals, accessToken)
 350                                 exp := checkTokenInDB()
 351                                 if i == 0 {
 352                                         exp1 = exp
 353                                 }
 354                                 return nil, nil
 355                         })(ctx, nil)
 356                         c.Check(err, check.IsNil)
 357                 }()
 358         }
 359         wg.Wait()
 360         if c.Failed() {
 361                 c.Fatal("giving up")
 362         }
 363
 364         // If the token is used again after the in-memory cache
 365         // expires, oidcAuthorizer must re-check the token and update
 366         // the expires_at value in the database.
 367         time.Sleep(3 * time.Millisecond)
 368         oidcAuthorizer.WrapCalls(func(ctx context.Context, opts interface{}) (interface{}, error) {
 369                 exp := checkTokenInDB()
 370                 c.Check(exp.Sub(exp1) > 0, check.Equals, true, check.Commentf("expect %v > 0", exp.Sub(exp1)))
 371                 c.Check(exp.Sub(exp1) < time.Second, check.Equals, true, check.Commentf("expect %v < 1s", exp.Sub(exp1)))
 372                 return nil, nil
 373         })(ctx, nil)
 374
 375         s.fakeProvider.AccessTokenPayload = map[string]interface{}{"scope": "openid profile foobar"}
 376         accessToken = s.fakeProvider.ValidAccessToken()
 377         ctx = auth.NewContext(context.Background(), &auth.Credentials{Tokens: []string{accessToken}})
 378
 379         mac = hmac.New(sha256.New, []byte(s.cluster.SystemRootToken))
 380         io.WriteString(mac, accessToken)
 381         apiToken = fmt.Sprintf("%x", mac.Sum(nil))
 382
 383         for _, trial := range []struct {
 384                 configEnable bool
 385                 configScope  string
 386                 acceptable   bool
 387                 shouldRun    bool
 388         }{
 389                 {true, "foobar", true, true},
 390                 {true, "foo", false, false},
 391                 {true, "", true, true},
 392                 {false, "", false, true},
 393                 {false, "foobar", false, true},
 394         } {
 395                 c.Logf("trial = %+v", trial)
 396                 cleanup()
 397                 s.cluster.Login.OpenIDConnect.AcceptAccessToken = trial.configEnable
 398                 s.cluster.Login.OpenIDConnect.AcceptAccessTokenScope = trial.configScope
 399                 oidcAuthorizer = OIDCAccessTokenAuthorizer(s.cluster, func(context.Context) (*sqlx.DB, error) { return db, nil })
 400                 checked := false
 401                 oidcAuthorizer.WrapCalls(func(ctx context.Context, opts interface{}) (interface{}, error) {
 402                         var n int
 403                         err := db.QueryRowContext(ctx, `select count(*) from api_client_authorizations where api_token=$1`, apiToken).Scan(&n)
 404                         c.Check(err, check.IsNil)
 405                         if trial.acceptable {
 406                                 c.Check(n, check.Equals, 1)
 407                         } else {
 408                                 c.Check(n, check.Equals, 0)
 409                         }
 410                         checked = true
 411                         return nil, nil
 412                 })(ctx, nil)
 413                 c.Check(checked, check.Equals, trial.shouldRun)
 414         }
 415 }
 416
 417 func (s *OIDCLoginSuite) TestGenericOIDCLogin(c *check.C) {
 418         s.cluster.Login.Google.Enable = false
 419         s.cluster.Login.OpenIDConnect.Enable = true
 420         json.Unmarshal([]byte(fmt.Sprintf("%q", s.fakeProvider.Issuer.URL)), &s.cluster.Login.OpenIDConnect.Issuer)
 421         s.cluster.Login.OpenIDConnect.ClientID = "oidc#client#id"
 422         s.cluster.Login.OpenIDConnect.ClientSecret = "oidc#client#secret"
 423         s.cluster.Login.OpenIDConnect.AuthenticationRequestParameters = map[string]string{"testkey": "testvalue"}
 424         s.fakeProvider.ValidClientID = "oidc#client#id"
 425         s.fakeProvider.ValidClientSecret = "oidc#client#secret"
 426         for _, trial := range []struct {
 427                 expectEmail string // "" if failure expected
 428                 setup       func()
 429         }{
 430                 {
 431                         expectEmail: "user@oidc.example.com",
 432                         setup: func() {
 433                                 c.Log("=== succeed because email_verified is false but not required")
 434                                 s.fakeProvider.AuthEmail = "user@oidc.example.com"
 435                                 s.fakeProvider.AuthEmailVerified = false
 436                                 s.cluster.Login.OpenIDConnect.EmailClaim = "email"
 437                                 s.cluster.Login.OpenIDConnect.EmailVerifiedClaim = ""
 438                                 s.cluster.Login.OpenIDConnect.UsernameClaim = ""
 439                         },
 440                 },
 441                 {
 442                         expectEmail: "",
 443                         setup: func() {
 444                                 c.Log("=== fail because email_verified is false and required")
 445                                 s.fakeProvider.AuthEmail = "user@oidc.example.com"
 446                                 s.fakeProvider.AuthEmailVerified = false
 447                                 s.cluster.Login.OpenIDConnect.EmailClaim = "email"
 448                                 s.cluster.Login.OpenIDConnect.EmailVerifiedClaim = "email_verified"
 449                                 s.cluster.Login.OpenIDConnect.UsernameClaim = ""
 450                         },
 451                 },
 452                 {
 453                         expectEmail: "user@oidc.example.com",
 454                         setup: func() {
 455                                 c.Log("=== succeed because email_verified is false but config uses custom 'verified' claim")
 456                                 s.fakeProvider.AuthEmail = "user@oidc.example.com"
 457                                 s.fakeProvider.AuthEmailVerified = false
 458                                 s.cluster.Login.OpenIDConnect.EmailClaim = "email"
 459                                 s.cluster.Login.OpenIDConnect.EmailVerifiedClaim = "alt_verified"
 460                                 s.cluster.Login.OpenIDConnect.UsernameClaim = ""
 461                         },
 462                 },
 463                 {
 464                         expectEmail: "alt_email@example.com",
 465                         setup: func() {
 466                                 c.Log("=== succeed with custom 'email' and 'email_verified' claims")
 467                                 s.fakeProvider.AuthEmail = "bad@wrong.example.com"
 468                                 s.fakeProvider.AuthEmailVerified = false
 469                                 s.cluster.Login.OpenIDConnect.EmailClaim = "alt_email"
 470                                 s.cluster.Login.OpenIDConnect.EmailVerifiedClaim = "alt_verified"
 471                                 s.cluster.Login.OpenIDConnect.UsernameClaim = "alt_username"
 472                         },
 473                 },
 474         } {
 475                 trial.setup()
 476                 if s.railsSpy != nil {
 477                         s.railsSpy.Close()
 478                 }
 479                 s.railsSpy = arvadostest.NewProxy(c, s.cluster.Services.RailsAPI)
 480                 s.localdb = NewConn(s.cluster)
 481                 *s.localdb.railsProxy = *rpc.NewConn(s.cluster.ClusterID, s.railsSpy.URL, true, rpc.PassthroughTokenProvider)
 482
 483                 state := s.startLogin(c, func(form url.Values) {
 484                         c.Check(form.Get("testkey"), check.Equals, "testvalue")
 485                 })
 486                 resp, err := s.localdb.Login(context.Background(), arvados.LoginOptions{
 487                         Code:  s.fakeProvider.ValidCode,
 488                         State: state,
 489                 })
 490                 c.Assert(err, check.IsNil)
 491                 if trial.expectEmail == "" {
 492                         c.Check(resp.HTML.String(), check.Matches, `(?ms).*Login error.*`)
 493                         c.Check(resp.RedirectLocation, check.Equals, "")
 494                         continue
 495                 }
 496                 c.Check(resp.HTML.String(), check.Equals, "")
 497                 target, err := url.Parse(resp.RedirectLocation)
 498                 c.Assert(err, check.IsNil)
 499                 token := target.Query().Get("api_token")
 500                 c.Check(token, check.Matches, `v2/zzzzz-gj3su-.{15}/.{32,50}`)
 501                 authinfo := getCallbackAuthInfo(c, s.railsSpy)
 502                 c.Check(authinfo.Email, check.Equals, trial.expectEmail)
 503
 504                 switch s.cluster.Login.OpenIDConnect.UsernameClaim {
 505                 case "alt_username":
 506                         c.Check(authinfo.Username, check.Equals, "desired-username")
 507                 case "":
 508                         c.Check(authinfo.Username, check.Equals, "")
 509                 default:
 510                         c.Fail() // bad test case
 511                 }
 512         }
 513 }
 514
 515 func (s *OIDCLoginSuite) TestGoogleLogin_Success(c *check.C) {
 516         s.cluster.Login.Google.AuthenticationRequestParameters["prompt"] = "consent"
 517         s.cluster.Login.Google.AuthenticationRequestParameters["foo"] = "bar"
 518         state := s.startLogin(c, func(form url.Values) {
 519                 c.Check(form.Get("foo"), check.Equals, "bar")
 520                 c.Check(form.Get("prompt"), check.Equals, "consent")
 521         })
 522         resp, err := s.localdb.Login(context.Background(), arvados.LoginOptions{
 523                 Code:  s.fakeProvider.ValidCode,
 524                 State: state,
 525         })
 526         c.Check(err, check.IsNil)
 527         c.Check(resp.HTML.String(), check.Equals, "")
 528         target, err := url.Parse(resp.RedirectLocation)
 529         c.Check(err, check.IsNil)
 530         c.Check(target.Host, check.Equals, "app.example.com")
 531         c.Check(target.Path, check.Equals, "/foo")
 532         token := target.Query().Get("api_token")
 533         c.Check(token, check.Matches, `v2/zzzzz-gj3su-.{15}/.{32,50}`)
 534
 535         authinfo := getCallbackAuthInfo(c, s.railsSpy)
 536         c.Check(authinfo.FirstName, check.Equals, "Fake")
 537         c.Check(authinfo.LastName, check.Equals, "User Name")
 538         c.Check(authinfo.Email, check.Equals, "active-user@arvados.local")
 539         c.Check(authinfo.AlternateEmails, check.HasLen, 0)
 540
 541         // Try using the returned Arvados token.
 542         c.Logf("trying an API call with new token %q", token)
 543         ctx := auth.NewContext(context.Background(), &auth.Credentials{Tokens: []string{token}})
 544         cl, err := s.localdb.CollectionList(ctx, arvados.ListOptions{Limit: -1})
 545         c.Check(cl.ItemsAvailable, check.Not(check.Equals), 0)
 546         c.Check(cl.Items, check.Not(check.HasLen), 0)
 547         c.Check(err, check.IsNil)
 548
 549         // Might as well check that bogus tokens aren't accepted.
 550         badtoken := token + "plussomeboguschars"
 551         c.Logf("trying an API call with mangled token %q", badtoken)
 552         ctx = auth.NewContext(context.Background(), &auth.Credentials{Tokens: []string{badtoken}})
 553         cl, err = s.localdb.CollectionList(ctx, arvados.ListOptions{Limit: -1})
 554         c.Check(cl.Items, check.HasLen, 0)
 555         c.Check(err, check.NotNil)
 556         c.Check(err, check.ErrorMatches, `.*401 Unauthorized: Not logged in.*`)
 557 }
 558
 559 func (s *OIDCLoginSuite) TestGoogleLogin_RealName(c *check.C) {
 560         s.fakeProvider.AuthEmail = "joe.smith@primary.example.com"
 561         s.fakeProvider.AuthEmailVerified = true
 562         s.fakeProvider.PeopleAPIResponse = map[string]interface{}{
 563                 "names": []map[string]interface{}{
 564                         {
 565                                 "metadata":   map[string]interface{}{"primary": false},
 566                                 "givenName":  "Joe",
 567                                 "familyName": "Smith",
 568                         },
 569                         {
 570                                 "metadata":   map[string]interface{}{"primary": true},
 571                                 "givenName":  "Joseph",
 572                                 "familyName": "Psmith",
 573                         },
 574                 },
 575         }
 576         state := s.startLogin(c)
 577         s.localdb.Login(context.Background(), arvados.LoginOptions{
 578                 Code:  s.fakeProvider.ValidCode,
 579                 State: state,
 580         })
 581
 582         authinfo := getCallbackAuthInfo(c, s.railsSpy)
 583         c.Check(authinfo.FirstName, check.Equals, "Joseph")
 584         c.Check(authinfo.LastName, check.Equals, "Psmith")
 585 }
 586
 587 func (s *OIDCLoginSuite) TestGoogleLogin_OIDCNameWithoutGivenAndFamilyNames(c *check.C) {
 588         s.fakeProvider.AuthName = "Joe P. Smith"
 589         s.fakeProvider.AuthGivenName = ""
 590         s.fakeProvider.AuthFamilyName = ""
 591         s.fakeProvider.AuthEmail = "joe.smith@primary.example.com"
 592         state := s.startLogin(c)
 593         s.localdb.Login(context.Background(), arvados.LoginOptions{
 594                 Code:  s.fakeProvider.ValidCode,
 595                 State: state,
 596         })
 597
 598         authinfo := getCallbackAuthInfo(c, s.railsSpy)
 599         c.Check(authinfo.FirstName, check.Equals, "Joe P.")
 600         c.Check(authinfo.LastName, check.Equals, "Smith")
 601 }
 602
 603 // People API returns some additional email addresses.
 604 func (s *OIDCLoginSuite) TestGoogleLogin_AlternateEmailAddresses(c *check.C) {
 605         s.fakeProvider.AuthEmail = "joe.smith@primary.example.com"
 606         s.fakeProvider.PeopleAPIResponse = map[string]interface{}{
 607                 "emailAddresses": []map[string]interface{}{
 608                         {
 609                                 "metadata": map[string]interface{}{"verified": true},
 610                                 "value":    "joe.smith@work.example.com",
 611                         },
 612                         {
 613                                 "value": "joe.smith@unverified.example.com", // unverified, so this one will be ignored
 614                         },
 615                         {
 616                                 "metadata": map[string]interface{}{"verified": true},
 617                                 "value":    "joe.smith@home.example.com",
 618                         },
 619                 },
 620         }
 621         state := s.startLogin(c)
 622         s.localdb.Login(context.Background(), arvados.LoginOptions{
 623                 Code:  s.fakeProvider.ValidCode,
 624                 State: state,
 625         })
 626
 627         authinfo := getCallbackAuthInfo(c, s.railsSpy)
 628         c.Check(authinfo.Email, check.Equals, "joe.smith@primary.example.com")
 629         c.Check(authinfo.AlternateEmails, check.DeepEquals, []string{"joe.smith@home.example.com", "joe.smith@work.example.com"})
 630 }
 631
 632 // Primary address is not the one initially returned by oidc.
 633 func (s *OIDCLoginSuite) TestGoogleLogin_AlternateEmailAddresses_Primary(c *check.C) {
 634         s.fakeProvider.AuthEmail = "joe.smith@alternate.example.com"
 635         s.fakeProvider.PeopleAPIResponse = map[string]interface{}{
 636                 "emailAddresses": []map[string]interface{}{
 637                         {
 638                                 "metadata": map[string]interface{}{"verified": true, "primary": true},
 639                                 "value":    "joe.smith@primary.example.com",
 640                         },
 641                         {
 642                                 "metadata": map[string]interface{}{"verified": true},
 643                                 "value":    "joe.smith@alternate.example.com",
 644                         },
 645                         {
 646                                 "metadata": map[string]interface{}{"verified": true},
 647                                 "value":    "jsmith+123@preferdomainforusername.example.com",
 648                         },
 649                 },
 650         }
 651         state := s.startLogin(c)
 652         s.localdb.Login(context.Background(), arvados.LoginOptions{
 653                 Code:  s.fakeProvider.ValidCode,
 654                 State: state,
 655         })
 656         authinfo := getCallbackAuthInfo(c, s.railsSpy)
 657         c.Check(authinfo.Email, check.Equals, "joe.smith@primary.example.com")
 658         c.Check(authinfo.AlternateEmails, check.DeepEquals, []string{"joe.smith@alternate.example.com", "jsmith+123@preferdomainforusername.example.com"})
 659         c.Check(authinfo.Username, check.Equals, "jsmith")
 660 }
 661
 662 func (s *OIDCLoginSuite) TestGoogleLogin_NoPrimaryEmailAddress(c *check.C) {
 663         s.fakeProvider.AuthEmail = "joe.smith@unverified.example.com"
 664         s.fakeProvider.AuthEmailVerified = false
 665         s.fakeProvider.PeopleAPIResponse = map[string]interface{}{
 666                 "emailAddresses": []map[string]interface{}{
 667                         {
 668                                 "metadata": map[string]interface{}{"verified": true},
 669                                 "value":    "joe.smith@work.example.com",
 670                         },
 671                         {
 672                                 "metadata": map[string]interface{}{"verified": true},
 673                                 "value":    "joe.smith@home.example.com",
 674                         },
 675                 },
 676         }
 677         state := s.startLogin(c)
 678         s.localdb.Login(context.Background(), arvados.LoginOptions{
 679                 Code:  s.fakeProvider.ValidCode,
 680                 State: state,
 681         })
 682
 683         authinfo := getCallbackAuthInfo(c, s.railsSpy)
 684         c.Check(authinfo.Email, check.Equals, "joe.smith@work.example.com") // first verified email in People response
 685         c.Check(authinfo.AlternateEmails, check.DeepEquals, []string{"joe.smith@home.example.com"})
 686         c.Check(authinfo.Username, check.Equals, "")
 687 }
 688
 689 func (s *OIDCLoginSuite) startLogin(c *check.C, checks ...func(url.Values)) (state string) {
 690         // Initiate login, but instead of following the redirect to
 691         // the provider, just grab state from the redirect URL.
 692         resp, err := s.localdb.Login(context.Background(), arvados.LoginOptions{ReturnTo: "https://app.example.com/foo?bar"})
 693         c.Check(err, check.IsNil)
 694         c.Check(resp.HTML.String(), check.Not(check.Matches), `(?ms).*error:.*`)
 695         target, err := url.Parse(resp.RedirectLocation)
 696         c.Check(err, check.IsNil)
 697         state = target.Query().Get("state")
 698         if !c.Check(state, check.Not(check.Equals), "") {
 699                 c.Logf("Redirect target: %q", target)
 700                 c.Logf("HTML: %q", resp.HTML)
 701         }
 702         for _, fn := range checks {
 703                 fn(target.Query())
 704         }
 705         s.cluster.Login.OpenIDConnect.AuthenticationRequestParameters = map[string]string{"testkey": "testvalue"}
 706         return
 707 }
 708
 709 func (s *OIDCLoginSuite) TestValidateLoginRedirectTarget(c *check.C) {
 710         for _, trial := range []struct {
 711                 permit       bool
 712                 trustPrivate bool
 713                 url          string
 714         }{
 715                 // wb1, wb2 => accept
 716                 {true, false, s.cluster.Services.Workbench1.ExternalURL.String()},
 717                 {true, false, s.cluster.Services.Workbench2.ExternalURL.String()},
 718                 // explicitly listed host => accept
 719                 {true, false, "https://app.example.com/"},
 720                 {true, false, "https://app.example.com:443/foo?bar=baz"},
 721                 // non-listed hostname => deny (regardless of TrustPrivateNetworks)
 722                 {false, false, "https://bad.example/"},
 723                 {false, true, "https://bad.example/"},
 724                 // non-listed non-private IP addr => deny (regardless of TrustPrivateNetworks)
 725                 {false, true, "https://1.2.3.4/"},
 726                 {false, true, "https://1.2.3.4/"},
 727                 {false, true, "https://[ab::cd]:1234/"},
 728                 // localhost or non-listed private IP addr => accept only if TrustPrivateNetworks is set
 729                 {false, false, "https://localhost/"},
 730                 {true, true, "https://localhost/"},
 731                 {false, false, "https://[10.9.8.7]:80/foo"},
 732                 {true, true, "https://[10.9.8.7]:80/foo"},
 733                 {false, false, "https://[::1]:80/foo"},
 734                 {true, true, "https://[::1]:80/foo"},
 735                 {true, true, "http://192.168.1.1/"},
 736                 {true, true, "http://172.17.2.0/"},
 737                 // bad url => deny
 738                 {false, true, "https://10.1.1.1:blorp/foo"},        // non-numeric port
 739                 {false, true, "https://app.example.com:blorp/foo"}, // non-numeric port
 740                 {false, true, "https://]:443"},
 741                 {false, true, "https://"},
 742                 {false, true, "https:"},
 743                 {false, true, ""},
 744                 // explicitly listed host but different port, protocol, or user/pass => deny
 745                 {false, true, "http://app.example.com/"},
 746                 {false, true, "http://app.example.com:443/"},
 747                 {false, true, "https://app.example.com:80/"},
 748                 {false, true, "https://app.example.com:4433/"},
 749                 {false, true, "https://u:p@app.example.com:443/foo?bar=baz"},
 750         } {
 751                 c.Logf("trial %+v", trial)
 752                 s.cluster.Login.TrustPrivateNetworks = trial.trustPrivate
 753                 err := validateLoginRedirectTarget(s.cluster, trial.url)
 754                 c.Check(err == nil, check.Equals, trial.permit)
 755         }
 756
 757 }
 758
 759 func getCallbackAuthInfo(c *check.C, railsSpy *arvadostest.Proxy) (authinfo rpc.UserSessionAuthInfo) {
 760         for _, dump := range railsSpy.RequestDumps {
 761                 c.Logf("spied request: %q", dump)
 762                 split := bytes.Split(dump, []byte("\r\n\r\n"))
 763                 c.Assert(split, check.HasLen, 2)
 764                 hdr, body := string(split[0]), string(split[1])
 765                 if strings.Contains(hdr, "POST /auth/controller/callback") {
 766                         vs, err := url.ParseQuery(body)
 767                         c.Check(json.Unmarshal([]byte(vs.Get("auth_info")), &authinfo), check.IsNil)
 768                         c.Check(err, check.IsNil)
 769                         sort.Strings(authinfo.AlternateEmails)
 770                         return
 771                 }
 772         }
 773         c.Error("callback not found")
 774         return
 775 }