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/rand"
  11         "crypto/rsa"
  12         "encoding/base64"
  13         "encoding/json"
  14         "fmt"
  15         "net/http"
  16         "net/http/httptest"
  17         "net/url"
  18         "sort"
  19         "strings"
  20         "testing"
  21         "time"
  22
  23         "git.arvados.org/arvados.git/lib/config"
  24         "git.arvados.org/arvados.git/lib/controller/rpc"
  25         "git.arvados.org/arvados.git/sdk/go/arvados"
  26         "git.arvados.org/arvados.git/sdk/go/arvadostest"
  27         "git.arvados.org/arvados.git/sdk/go/auth"
  28         "git.arvados.org/arvados.git/sdk/go/ctxlog"
  29         check "gopkg.in/check.v1"
  30         jose "gopkg.in/square/go-jose.v2"
  31 )
  32
  33 // Gocheck boilerplate
  34 func Test(t *testing.T) {
  35         check.TestingT(t)
  36 }
  37
  38 var _ = check.Suite(&OIDCLoginSuite{})
  39
  40 type OIDCLoginSuite struct {
  41         cluster               *arvados.Cluster
  42         ctx                   context.Context
  43         localdb               *Conn
  44         railsSpy              *arvadostest.Proxy
  45         fakeIssuer            *httptest.Server
  46         fakePeopleAPI         *httptest.Server
  47         fakePeopleAPIResponse map[string]interface{}
  48         issuerKey             *rsa.PrivateKey
  49
  50         // expected token request
  51         validCode         string
  52         validClientID     string
  53         validClientSecret string
  54         // desired response from token endpoint
  55         authEmail         string
  56         authEmailVerified bool
  57         authName          string
  58 }
  59
  60 func (s *OIDCLoginSuite) TearDownSuite(c *check.C) {
  61         // Undo any changes/additions to the user database so they
  62         // don't affect subsequent tests.
  63         arvadostest.ResetEnv()
  64         c.Check(arvados.NewClientFromEnv().RequestAndDecode(nil, "POST", "database/reset", nil, nil), check.IsNil)
  65 }
  66
  67 func (s *OIDCLoginSuite) SetUpTest(c *check.C) {
  68         var err error
  69         s.issuerKey, err = rsa.GenerateKey(rand.Reader, 2048)
  70         c.Assert(err, check.IsNil)
  71
  72         s.authEmail = "active-user@arvados.local"
  73         s.authEmailVerified = true
  74         s.authName = "Fake User Name"
  75         s.fakeIssuer = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
  76                 req.ParseForm()
  77                 c.Logf("fakeIssuer: got req: %s %s %s", req.Method, req.URL, req.Form)
  78                 w.Header().Set("Content-Type", "application/json")
  79                 switch req.URL.Path {
  80                 case "/.well-known/openid-configuration":
  81                         json.NewEncoder(w).Encode(map[string]interface{}{
  82                                 "issuer":                 s.fakeIssuer.URL,
  83                                 "authorization_endpoint": s.fakeIssuer.URL + "/auth",
  84                                 "token_endpoint":         s.fakeIssuer.URL + "/token",
  85                                 "jwks_uri":               s.fakeIssuer.URL + "/jwks",
  86                                 "userinfo_endpoint":      s.fakeIssuer.URL + "/userinfo",
  87                         })
  88                 case "/token":
  89                         var clientID, clientSecret string
  90                         auth, _ := base64.StdEncoding.DecodeString(strings.TrimPrefix(req.Header.Get("Authorization"), "Basic "))
  91                         authsplit := strings.Split(string(auth), ":")
  92                         if len(authsplit) == 2 {
  93                                 clientID, _ = url.QueryUnescape(authsplit[0])
  94                                 clientSecret, _ = url.QueryUnescape(authsplit[1])
  95                         }
  96                         if clientID != s.validClientID || clientSecret != s.validClientSecret {
  97                                 c.Logf("fakeIssuer: expected (%q, %q) got (%q, %q)", s.validClientID, s.validClientSecret, clientID, clientSecret)
  98                                 w.WriteHeader(http.StatusUnauthorized)
  99                                 return
 100                         }
 101
 102                         if req.Form.Get("code") != s.validCode || s.validCode == "" {
 103                                 w.WriteHeader(http.StatusUnauthorized)
 104                                 return
 105                         }
 106                         idToken, _ := json.Marshal(map[string]interface{}{
 107                                 "iss":            s.fakeIssuer.URL,
 108                                 "aud":            []string{clientID},
 109                                 "sub":            "fake-user-id",
 110                                 "exp":            time.Now().UTC().Add(time.Minute).Unix(),
 111                                 "iat":            time.Now().UTC().Unix(),
 112                                 "nonce":          "fake-nonce",
 113                                 "email":          s.authEmail,
 114                                 "email_verified": s.authEmailVerified,
 115                                 "name":           s.authName,
 116                         })
 117                         json.NewEncoder(w).Encode(struct {
 118                                 AccessToken  string `json:"access_token"`
 119                                 TokenType    string `json:"token_type"`
 120                                 RefreshToken string `json:"refresh_token"`
 121                                 ExpiresIn    int32  `json:"expires_in"`
 122                                 IDToken      string `json:"id_token"`
 123                         }{
 124                                 AccessToken:  s.fakeToken(c, []byte("fake access token")),
 125                                 TokenType:    "Bearer",
 126                                 RefreshToken: "test-refresh-token",
 127                                 ExpiresIn:    30,
 128                                 IDToken:      s.fakeToken(c, idToken),
 129                         })
 130                 case "/jwks":
 131                         json.NewEncoder(w).Encode(jose.JSONWebKeySet{
 132                                 Keys: []jose.JSONWebKey{
 133                                         {Key: s.issuerKey.Public(), Algorithm: string(jose.RS256), KeyID: ""},
 134                                 },
 135                         })
 136                 case "/auth":
 137                         w.WriteHeader(http.StatusInternalServerError)
 138                 case "/userinfo":
 139                         w.WriteHeader(http.StatusInternalServerError)
 140                 default:
 141                         w.WriteHeader(http.StatusNotFound)
 142                 }
 143         }))
 144         s.validCode = fmt.Sprintf("abcdefgh-%d", time.Now().Unix())
 145
 146         s.fakePeopleAPI = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
 147                 req.ParseForm()
 148                 c.Logf("fakePeopleAPI: got req: %s %s %s", req.Method, req.URL, req.Form)
 149                 w.Header().Set("Content-Type", "application/json")
 150                 switch req.URL.Path {
 151                 case "/v1/people/me":
 152                         if f := req.Form.Get("personFields"); f != "emailAddresses,names" {
 153                                 w.WriteHeader(http.StatusBadRequest)
 154                                 break
 155                         }
 156                         json.NewEncoder(w).Encode(s.fakePeopleAPIResponse)
 157                 default:
 158                         w.WriteHeader(http.StatusNotFound)
 159                 }
 160         }))
 161         s.fakePeopleAPIResponse = map[string]interface{}{}
 162
 163         cfg, err := config.NewLoader(nil, ctxlog.TestLogger(c)).Load()
 164         c.Assert(err, check.IsNil)
 165         s.cluster, err = cfg.GetCluster("")
 166         c.Assert(err, check.IsNil)
 167         s.cluster.Login.SSO.Enable = false
 168         s.cluster.Login.Google.Enable = true
 169         s.cluster.Login.Google.ClientID = "test%client$id"
 170         s.cluster.Login.Google.ClientSecret = "test#client/secret"
 171         s.cluster.Users.PreferDomainForUsername = "PreferDomainForUsername.example.com"
 172         s.validClientID = "test%client$id"
 173         s.validClientSecret = "test#client/secret"
 174
 175         s.localdb = NewConn(s.cluster)
 176         c.Assert(s.localdb.loginController, check.FitsTypeOf, (*oidcLoginController)(nil))
 177         s.localdb.loginController.(*oidcLoginController).Issuer = s.fakeIssuer.URL
 178         s.localdb.loginController.(*oidcLoginController).peopleAPIBasePath = s.fakePeopleAPI.URL
 179
 180         s.railsSpy = arvadostest.NewProxy(c, s.cluster.Services.RailsAPI)
 181         *s.localdb.railsProxy = *rpc.NewConn(s.cluster.ClusterID, s.railsSpy.URL, true, rpc.PassthroughTokenProvider)
 182 }
 183
 184 func (s *OIDCLoginSuite) TearDownTest(c *check.C) {
 185         s.railsSpy.Close()
 186 }
 187
 188 func (s *OIDCLoginSuite) TestGoogleLogout(c *check.C) {
 189         resp, err := s.localdb.Logout(context.Background(), arvados.LogoutOptions{ReturnTo: "https://foo.example.com/bar"})
 190         c.Check(err, check.IsNil)
 191         c.Check(resp.RedirectLocation, check.Equals, "https://foo.example.com/bar")
 192 }
 193
 194 func (s *OIDCLoginSuite) TestGoogleLogin_Start_Bogus(c *check.C) {
 195         resp, err := s.localdb.Login(context.Background(), arvados.LoginOptions{})
 196         c.Check(err, check.IsNil)
 197         c.Check(resp.RedirectLocation, check.Equals, "")
 198         c.Check(resp.HTML.String(), check.Matches, `.*missing return_to parameter.*`)
 199 }
 200
 201 func (s *OIDCLoginSuite) TestGoogleLogin_Start(c *check.C) {
 202         for _, remote := range []string{"", "zzzzz"} {
 203                 resp, err := s.localdb.Login(context.Background(), arvados.LoginOptions{Remote: remote, ReturnTo: "https://app.example.com/foo?bar"})
 204                 c.Check(err, check.IsNil)
 205                 target, err := url.Parse(resp.RedirectLocation)
 206                 c.Check(err, check.IsNil)
 207                 issuerURL, _ := url.Parse(s.fakeIssuer.URL)
 208                 c.Check(target.Host, check.Equals, issuerURL.Host)
 209                 q := target.Query()
 210                 c.Check(q.Get("client_id"), check.Equals, "test%client$id")
 211                 state := s.localdb.loginController.(*oidcLoginController).parseOAuth2State(q.Get("state"))
 212                 c.Check(state.verify([]byte(s.cluster.SystemRootToken)), check.Equals, true)
 213                 c.Check(state.Time, check.Not(check.Equals), 0)
 214                 c.Check(state.Remote, check.Equals, remote)
 215                 c.Check(state.ReturnTo, check.Equals, "https://app.example.com/foo?bar")
 216         }
 217 }
 218
 219 func (s *OIDCLoginSuite) TestGoogleLogin_InvalidCode(c *check.C) {
 220         state := s.startLogin(c)
 221         resp, err := s.localdb.Login(context.Background(), arvados.LoginOptions{
 222                 Code:  "first-try-a-bogus-code",
 223                 State: state,
 224         })
 225         c.Check(err, check.IsNil)
 226         c.Check(resp.RedirectLocation, check.Equals, "")
 227         c.Check(resp.HTML.String(), check.Matches, `(?ms).*error in OAuth2 exchange.*cannot fetch token.*`)
 228 }
 229
 230 func (s *OIDCLoginSuite) TestGoogleLogin_InvalidState(c *check.C) {
 231         s.startLogin(c)
 232         resp, err := s.localdb.Login(context.Background(), arvados.LoginOptions{
 233                 Code:  s.validCode,
 234                 State: "bogus-state",
 235         })
 236         c.Check(err, check.IsNil)
 237         c.Check(resp.RedirectLocation, check.Equals, "")
 238         c.Check(resp.HTML.String(), check.Matches, `(?ms).*invalid OAuth2 state.*`)
 239 }
 240
 241 func (s *OIDCLoginSuite) setupPeopleAPIError(c *check.C) {
 242         s.fakePeopleAPI = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
 243                 w.WriteHeader(http.StatusForbidden)
 244                 fmt.Fprintln(w, `Error 403: accessNotConfigured`)
 245         }))
 246         s.localdb.loginController.(*oidcLoginController).peopleAPIBasePath = s.fakePeopleAPI.URL
 247 }
 248
 249 func (s *OIDCLoginSuite) TestGoogleLogin_PeopleAPIDisabled(c *check.C) {
 250         s.localdb.loginController.(*oidcLoginController).UseGooglePeopleAPI = false
 251         s.authEmail = "joe.smith@primary.example.com"
 252         s.setupPeopleAPIError(c)
 253         state := s.startLogin(c)
 254         _, err := s.localdb.Login(context.Background(), arvados.LoginOptions{
 255                 Code:  s.validCode,
 256                 State: state,
 257         })
 258         c.Check(err, check.IsNil)
 259         authinfo := getCallbackAuthInfo(c, s.railsSpy)
 260         c.Check(authinfo.Email, check.Equals, "joe.smith@primary.example.com")
 261 }
 262
 263 func (s *OIDCLoginSuite) TestConfig(c *check.C) {
 264         s.cluster.Login.Google.Enable = false
 265         s.cluster.Login.OpenIDConnect.Enable = true
 266         s.cluster.Login.OpenIDConnect.Issuer = "https://accounts.example.com/"
 267         s.cluster.Login.OpenIDConnect.ClientID = "oidc-client-id"
 268         s.cluster.Login.OpenIDConnect.ClientSecret = "oidc-client-secret"
 269         localdb := NewConn(s.cluster)
 270         ctrl := localdb.loginController.(*oidcLoginController)
 271         c.Check(ctrl.Issuer, check.Equals, "https://accounts.example.com/")
 272         c.Check(ctrl.ClientID, check.Equals, "oidc-client-id")
 273         c.Check(ctrl.ClientSecret, check.Equals, "oidc-client-secret")
 274         c.Check(ctrl.UseGooglePeopleAPI, check.Equals, false)
 275
 276         for _, enableAltEmails := range []bool{false, true} {
 277                 s.cluster.Login.OpenIDConnect.Enable = false
 278                 s.cluster.Login.Google.Enable = true
 279                 s.cluster.Login.Google.ClientID = "google-client-id"
 280                 s.cluster.Login.Google.ClientSecret = "google-client-secret"
 281                 s.cluster.Login.Google.AlternateEmailAddresses = enableAltEmails
 282                 localdb = NewConn(s.cluster)
 283                 ctrl = localdb.loginController.(*oidcLoginController)
 284                 c.Check(ctrl.Issuer, check.Equals, "https://accounts.google.com")
 285                 c.Check(ctrl.ClientID, check.Equals, "google-client-id")
 286                 c.Check(ctrl.ClientSecret, check.Equals, "google-client-secret")
 287                 c.Check(ctrl.UseGooglePeopleAPI, check.Equals, enableAltEmails)
 288         }
 289 }
 290
 291 func (s *OIDCLoginSuite) TestGoogleLogin_PeopleAPIError(c *check.C) {
 292         s.setupPeopleAPIError(c)
 293         state := s.startLogin(c)
 294         resp, err := s.localdb.Login(context.Background(), arvados.LoginOptions{
 295                 Code:  s.validCode,
 296                 State: state,
 297         })
 298         c.Check(err, check.IsNil)
 299         c.Check(resp.RedirectLocation, check.Equals, "")
 300 }
 301
 302 func (s *OIDCLoginSuite) TestOIDCLogin_Success(c *check.C) {
 303         s.cluster.Login.Google.Enable = false
 304         s.cluster.Login.OpenIDConnect.Enable = true
 305         json.Unmarshal([]byte(fmt.Sprintf("%q", s.fakeIssuer.URL)), &s.cluster.Login.OpenIDConnect.Issuer)
 306         s.cluster.Login.OpenIDConnect.ClientID = "oidc#client#id"
 307         s.cluster.Login.OpenIDConnect.ClientSecret = "oidc#client#secret"
 308         s.validClientID = "oidc#client#id"
 309         s.validClientSecret = "oidc#client#secret"
 310         s.localdb = NewConn(s.cluster)
 311         state := s.startLogin(c)
 312         resp, err := s.localdb.Login(context.Background(), arvados.LoginOptions{
 313                 Code:  s.validCode,
 314                 State: state,
 315         })
 316         c.Assert(err, check.IsNil)
 317         c.Check(resp.HTML.String(), check.Equals, "")
 318         target, err := url.Parse(resp.RedirectLocation)
 319         c.Assert(err, check.IsNil)
 320         token := target.Query().Get("api_token")
 321         c.Check(token, check.Matches, `v2/zzzzz-gj3su-.{15}/.{32,50}`)
 322 }
 323
 324 func (s *OIDCLoginSuite) TestGoogleLogin_Success(c *check.C) {
 325         state := s.startLogin(c)
 326         resp, err := s.localdb.Login(context.Background(), arvados.LoginOptions{
 327                 Code:  s.validCode,
 328                 State: state,
 329         })
 330         c.Check(err, check.IsNil)
 331         c.Check(resp.HTML.String(), check.Equals, "")
 332         target, err := url.Parse(resp.RedirectLocation)
 333         c.Check(err, check.IsNil)
 334         c.Check(target.Host, check.Equals, "app.example.com")
 335         c.Check(target.Path, check.Equals, "/foo")
 336         token := target.Query().Get("api_token")
 337         c.Check(token, check.Matches, `v2/zzzzz-gj3su-.{15}/.{32,50}`)
 338
 339         authinfo := getCallbackAuthInfo(c, s.railsSpy)
 340         c.Check(authinfo.FirstName, check.Equals, "Fake User")
 341         c.Check(authinfo.LastName, check.Equals, "Name")
 342         c.Check(authinfo.Email, check.Equals, "active-user@arvados.local")
 343         c.Check(authinfo.AlternateEmails, check.HasLen, 0)
 344
 345         // Try using the returned Arvados token.
 346         c.Logf("trying an API call with new token %q", token)
 347         ctx := auth.NewContext(context.Background(), &auth.Credentials{Tokens: []string{token}})
 348         cl, err := s.localdb.CollectionList(ctx, arvados.ListOptions{Limit: -1})
 349         c.Check(cl.ItemsAvailable, check.Not(check.Equals), 0)
 350         c.Check(cl.Items, check.Not(check.HasLen), 0)
 351         c.Check(err, check.IsNil)
 352
 353         // Might as well check that bogus tokens aren't accepted.
 354         badtoken := token + "plussomeboguschars"
 355         c.Logf("trying an API call with mangled token %q", badtoken)
 356         ctx = auth.NewContext(context.Background(), &auth.Credentials{Tokens: []string{badtoken}})
 357         cl, err = s.localdb.CollectionList(ctx, arvados.ListOptions{Limit: -1})
 358         c.Check(cl.Items, check.HasLen, 0)
 359         c.Check(err, check.NotNil)
 360         c.Check(err, check.ErrorMatches, `.*401 Unauthorized: Not logged in.*`)
 361 }
 362
 363 func (s *OIDCLoginSuite) TestGoogleLogin_RealName(c *check.C) {
 364         s.authEmail = "joe.smith@primary.example.com"
 365         s.fakePeopleAPIResponse = map[string]interface{}{
 366                 "names": []map[string]interface{}{
 367                         {
 368                                 "metadata":   map[string]interface{}{"primary": false},
 369                                 "givenName":  "Joe",
 370                                 "familyName": "Smith",
 371                         },
 372                         {
 373                                 "metadata":   map[string]interface{}{"primary": true},
 374                                 "givenName":  "Joseph",
 375                                 "familyName": "Psmith",
 376                         },
 377                 },
 378         }
 379         state := s.startLogin(c)
 380         s.localdb.Login(context.Background(), arvados.LoginOptions{
 381                 Code:  s.validCode,
 382                 State: state,
 383         })
 384
 385         authinfo := getCallbackAuthInfo(c, s.railsSpy)
 386         c.Check(authinfo.FirstName, check.Equals, "Joseph")
 387         c.Check(authinfo.LastName, check.Equals, "Psmith")
 388 }
 389
 390 func (s *OIDCLoginSuite) TestGoogleLogin_OIDCRealName(c *check.C) {
 391         s.authName = "Joe P. Smith"
 392         s.authEmail = "joe.smith@primary.example.com"
 393         state := s.startLogin(c)
 394         s.localdb.Login(context.Background(), arvados.LoginOptions{
 395                 Code:  s.validCode,
 396                 State: state,
 397         })
 398
 399         authinfo := getCallbackAuthInfo(c, s.railsSpy)
 400         c.Check(authinfo.FirstName, check.Equals, "Joe P.")
 401         c.Check(authinfo.LastName, check.Equals, "Smith")
 402 }
 403
 404 // People API returns some additional email addresses.
 405 func (s *OIDCLoginSuite) TestGoogleLogin_AlternateEmailAddresses(c *check.C) {
 406         s.authEmail = "joe.smith@primary.example.com"
 407         s.fakePeopleAPIResponse = map[string]interface{}{
 408                 "emailAddresses": []map[string]interface{}{
 409                         {
 410                                 "metadata": map[string]interface{}{"verified": true},
 411                                 "value":    "joe.smith@work.example.com",
 412                         },
 413                         {
 414                                 "value": "joe.smith@unverified.example.com", // unverified, so this one will be ignored
 415                         },
 416                         {
 417                                 "metadata": map[string]interface{}{"verified": true},
 418                                 "value":    "joe.smith@home.example.com",
 419                         },
 420                 },
 421         }
 422         state := s.startLogin(c)
 423         s.localdb.Login(context.Background(), arvados.LoginOptions{
 424                 Code:  s.validCode,
 425                 State: state,
 426         })
 427
 428         authinfo := getCallbackAuthInfo(c, s.railsSpy)
 429         c.Check(authinfo.Email, check.Equals, "joe.smith@primary.example.com")
 430         c.Check(authinfo.AlternateEmails, check.DeepEquals, []string{"joe.smith@home.example.com", "joe.smith@work.example.com"})
 431 }
 432
 433 // Primary address is not the one initially returned by oidc.
 434 func (s *OIDCLoginSuite) TestGoogleLogin_AlternateEmailAddresses_Primary(c *check.C) {
 435         s.authEmail = "joe.smith@alternate.example.com"
 436         s.fakePeopleAPIResponse = map[string]interface{}{
 437                 "emailAddresses": []map[string]interface{}{
 438                         {
 439                                 "metadata": map[string]interface{}{"verified": true, "primary": true},
 440                                 "value":    "joe.smith@primary.example.com",
 441                         },
 442                         {
 443                                 "metadata": map[string]interface{}{"verified": true},
 444                                 "value":    "joe.smith@alternate.example.com",
 445                         },
 446                         {
 447                                 "metadata": map[string]interface{}{"verified": true},
 448                                 "value":    "jsmith+123@preferdomainforusername.example.com",
 449                         },
 450                 },
 451         }
 452         state := s.startLogin(c)
 453         s.localdb.Login(context.Background(), arvados.LoginOptions{
 454                 Code:  s.validCode,
 455                 State: state,
 456         })
 457         authinfo := getCallbackAuthInfo(c, s.railsSpy)
 458         c.Check(authinfo.Email, check.Equals, "joe.smith@primary.example.com")
 459         c.Check(authinfo.AlternateEmails, check.DeepEquals, []string{"joe.smith@alternate.example.com", "jsmith+123@preferdomainforusername.example.com"})
 460         c.Check(authinfo.Username, check.Equals, "jsmith")
 461 }
 462
 463 func (s *OIDCLoginSuite) TestGoogleLogin_NoPrimaryEmailAddress(c *check.C) {
 464         s.authEmail = "joe.smith@unverified.example.com"
 465         s.authEmailVerified = false
 466         s.fakePeopleAPIResponse = map[string]interface{}{
 467                 "emailAddresses": []map[string]interface{}{
 468                         {
 469                                 "metadata": map[string]interface{}{"verified": true},
 470                                 "value":    "joe.smith@work.example.com",
 471                         },
 472                         {
 473                                 "metadata": map[string]interface{}{"verified": true},
 474                                 "value":    "joe.smith@home.example.com",
 475                         },
 476                 },
 477         }
 478         state := s.startLogin(c)
 479         s.localdb.Login(context.Background(), arvados.LoginOptions{
 480                 Code:  s.validCode,
 481                 State: state,
 482         })
 483
 484         authinfo := getCallbackAuthInfo(c, s.railsSpy)
 485         c.Check(authinfo.Email, check.Equals, "joe.smith@work.example.com") // first verified email in People response
 486         c.Check(authinfo.AlternateEmails, check.DeepEquals, []string{"joe.smith@home.example.com"})
 487         c.Check(authinfo.Username, check.Equals, "")
 488 }
 489
 490 func (s *OIDCLoginSuite) startLogin(c *check.C) (state string) {
 491         // Initiate login, but instead of following the redirect to
 492         // the provider, just grab state from the redirect URL.
 493         resp, err := s.localdb.Login(context.Background(), arvados.LoginOptions{ReturnTo: "https://app.example.com/foo?bar"})
 494         c.Check(err, check.IsNil)
 495         target, err := url.Parse(resp.RedirectLocation)
 496         c.Check(err, check.IsNil)
 497         state = target.Query().Get("state")
 498         c.Check(state, check.Not(check.Equals), "")
 499         return
 500 }
 501
 502 func (s *OIDCLoginSuite) fakeToken(c *check.C, payload []byte) string {
 503         signer, err := jose.NewSigner(jose.SigningKey{Algorithm: jose.RS256, Key: s.issuerKey}, nil)
 504         if err != nil {
 505                 c.Error(err)
 506         }
 507         object, err := signer.Sign(payload)
 508         if err != nil {
 509                 c.Error(err)
 510         }
 511         t, err := object.CompactSerialize()
 512         if err != nil {
 513                 c.Error(err)
 514         }
 515         c.Logf("fakeToken(%q) == %q", payload, t)
 516         return t
 517 }
 518
 519 func getCallbackAuthInfo(c *check.C, railsSpy *arvadostest.Proxy) (authinfo rpc.UserSessionAuthInfo) {
 520         for _, dump := range railsSpy.RequestDumps {
 521                 c.Logf("spied request: %q", dump)
 522                 split := bytes.Split(dump, []byte("\r\n\r\n"))
 523                 c.Assert(split, check.HasLen, 2)
 524                 hdr, body := string(split[0]), string(split[1])
 525                 if strings.Contains(hdr, "POST /auth/controller/callback") {
 526                         vs, err := url.ParseQuery(body)
 527                         c.Check(json.Unmarshal([]byte(vs.Get("auth_info")), &authinfo), check.IsNil)
 528                         c.Check(err, check.IsNil)
 529                         sort.Strings(authinfo.AlternateEmails)
 530                         return
 531                 }
 532         }
 533         c.Error("callback not found")
 534         return
 535 }