Merge branch '16913-logout' closes #16913
[arvados.git] / lib / controller / localdb / login.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         "context"
9         "database/sql"
10         "encoding/json"
11         "errors"
12         "fmt"
13         "net/http"
14         "net/url"
15         "strings"
16
17         "git.arvados.org/arvados.git/lib/controller/rpc"
18         "git.arvados.org/arvados.git/lib/ctrlctx"
19         "git.arvados.org/arvados.git/sdk/go/arvados"
20         "git.arvados.org/arvados.git/sdk/go/auth"
21         "git.arvados.org/arvados.git/sdk/go/httpserver"
22 )
23
24 type loginController interface {
25         Login(ctx context.Context, opts arvados.LoginOptions) (arvados.LoginResponse, error)
26         Logout(ctx context.Context, opts arvados.LogoutOptions) (arvados.LogoutResponse, error)
27         UserAuthenticate(ctx context.Context, options arvados.UserAuthenticateOptions) (arvados.APIClientAuthorization, error)
28 }
29
30 func chooseLoginController(cluster *arvados.Cluster, railsProxy *railsProxy) loginController {
31         wantGoogle := cluster.Login.Google.Enable
32         wantOpenIDConnect := cluster.Login.OpenIDConnect.Enable
33         wantSSO := cluster.Login.SSO.Enable
34         wantPAM := cluster.Login.PAM.Enable
35         wantLDAP := cluster.Login.LDAP.Enable
36         wantTest := cluster.Login.Test.Enable
37         wantLoginCluster := cluster.Login.LoginCluster != "" && cluster.Login.LoginCluster != cluster.ClusterID
38         switch {
39         case 1 != countTrue(wantGoogle, wantOpenIDConnect, wantSSO, wantPAM, wantLDAP, wantTest, wantLoginCluster):
40                 return errorLoginController{
41                         error: errors.New("configuration problem: exactly one of Login.Google, Login.OpenIDConnect, Login.SSO, Login.PAM, Login.LDAP, Login.Test, or Login.LoginCluster must be set"),
42                 }
43         case wantGoogle:
44                 return &oidcLoginController{
45                         Cluster:            cluster,
46                         RailsProxy:         railsProxy,
47                         Issuer:             "https://accounts.google.com",
48                         ClientID:           cluster.Login.Google.ClientID,
49                         ClientSecret:       cluster.Login.Google.ClientSecret,
50                         UseGooglePeopleAPI: cluster.Login.Google.AlternateEmailAddresses,
51                         EmailClaim:         "email",
52                         EmailVerifiedClaim: "email_verified",
53                 }
54         case wantOpenIDConnect:
55                 return &oidcLoginController{
56                         Cluster:            cluster,
57                         RailsProxy:         railsProxy,
58                         Issuer:             cluster.Login.OpenIDConnect.Issuer,
59                         ClientID:           cluster.Login.OpenIDConnect.ClientID,
60                         ClientSecret:       cluster.Login.OpenIDConnect.ClientSecret,
61                         EmailClaim:         cluster.Login.OpenIDConnect.EmailClaim,
62                         EmailVerifiedClaim: cluster.Login.OpenIDConnect.EmailVerifiedClaim,
63                         UsernameClaim:      cluster.Login.OpenIDConnect.UsernameClaim,
64                 }
65         case wantSSO:
66                 return &ssoLoginController{railsProxy}
67         case wantPAM:
68                 return &pamLoginController{Cluster: cluster, RailsProxy: railsProxy}
69         case wantLDAP:
70                 return &ldapLoginController{Cluster: cluster, RailsProxy: railsProxy}
71         case wantTest:
72                 return &testLoginController{Cluster: cluster, RailsProxy: railsProxy}
73         case wantLoginCluster:
74                 return &federatedLoginController{Cluster: cluster}
75         default:
76                 return errorLoginController{
77                         error: errors.New("BUG: missing case in login controller setup switch"),
78                 }
79         }
80 }
81
82 func countTrue(vals ...bool) int {
83         n := 0
84         for _, val := range vals {
85                 if val {
86                         n++
87                 }
88         }
89         return n
90 }
91
92 // Login and Logout are passed through to the wrapped railsProxy;
93 // UserAuthenticate is rejected.
94 type ssoLoginController struct{ *railsProxy }
95
96 func (ctrl *ssoLoginController) UserAuthenticate(ctx context.Context, opts arvados.UserAuthenticateOptions) (arvados.APIClientAuthorization, error) {
97         return arvados.APIClientAuthorization{}, httpserver.ErrorWithStatus(errors.New("username/password authentication is not available"), http.StatusBadRequest)
98 }
99
100 type errorLoginController struct{ error }
101
102 func (ctrl errorLoginController) Login(context.Context, arvados.LoginOptions) (arvados.LoginResponse, error) {
103         return arvados.LoginResponse{}, ctrl.error
104 }
105 func (ctrl errorLoginController) Logout(context.Context, arvados.LogoutOptions) (arvados.LogoutResponse, error) {
106         return arvados.LogoutResponse{}, ctrl.error
107 }
108 func (ctrl errorLoginController) UserAuthenticate(context.Context, arvados.UserAuthenticateOptions) (arvados.APIClientAuthorization, error) {
109         return arvados.APIClientAuthorization{}, ctrl.error
110 }
111
112 type federatedLoginController struct {
113         Cluster *arvados.Cluster
114 }
115
116 func (ctrl federatedLoginController) Login(context.Context, arvados.LoginOptions) (arvados.LoginResponse, error) {
117         return arvados.LoginResponse{}, httpserver.ErrorWithStatus(errors.New("Should have been redirected to login cluster"), http.StatusBadRequest)
118 }
119 func (ctrl federatedLoginController) Logout(_ context.Context, opts arvados.LogoutOptions) (arvados.LogoutResponse, error) {
120         return noopLogout(ctrl.Cluster, opts)
121 }
122 func (ctrl federatedLoginController) UserAuthenticate(context.Context, arvados.UserAuthenticateOptions) (arvados.APIClientAuthorization, error) {
123         return arvados.APIClientAuthorization{}, httpserver.ErrorWithStatus(errors.New("username/password authentication is not available"), http.StatusBadRequest)
124 }
125
126 func noopLogout(cluster *arvados.Cluster, opts arvados.LogoutOptions) (arvados.LogoutResponse, error) {
127         target := opts.ReturnTo
128         if target == "" {
129                 if cluster.Services.Workbench2.ExternalURL.Host != "" {
130                         target = cluster.Services.Workbench2.ExternalURL.String()
131                 } else {
132                         target = cluster.Services.Workbench1.ExternalURL.String()
133                 }
134         }
135         return arvados.LogoutResponse{RedirectLocation: target}, nil
136 }
137
138 func createAPIClientAuthorization(ctx context.Context, conn *rpc.Conn, rootToken string, authinfo rpc.UserSessionAuthInfo) (resp arvados.APIClientAuthorization, err error) {
139         ctxRoot := auth.NewContext(ctx, &auth.Credentials{Tokens: []string{rootToken}})
140         newsession, err := conn.UserSessionCreate(ctxRoot, rpc.UserSessionCreateOptions{
141                 // Send a fake ReturnTo value instead of the caller's
142                 // opts.ReturnTo. We won't follow the resulting
143                 // redirect target anyway.
144                 ReturnTo: ",https://none.invalid",
145                 AuthInfo: authinfo,
146         })
147         if err != nil {
148                 return
149         }
150         target, err := url.Parse(newsession.RedirectLocation)
151         if err != nil {
152                 return
153         }
154         token := target.Query().Get("api_token")
155         tx, err := ctrlctx.CurrentTx(ctx)
156         if err != nil {
157                 return
158         }
159         tokensecret := token
160         if strings.Contains(token, "/") {
161                 tokenparts := strings.Split(token, "/")
162                 if len(tokenparts) >= 3 {
163                         tokensecret = tokenparts[2]
164                 }
165         }
166         var exp sql.NullString
167         var scopes []byte
168         err = tx.QueryRowxContext(ctx, "select uuid, api_token, expires_at, scopes from api_client_authorizations where api_token=$1", tokensecret).Scan(&resp.UUID, &resp.APIToken, &exp, &scopes)
169         if err != nil {
170                 return
171         }
172         resp.ExpiresAt = exp.String
173         if len(scopes) > 0 {
174                 err = json.Unmarshal(scopes, &resp.Scopes)
175                 if err != nil {
176                         return resp, fmt.Errorf("unmarshal scopes: %s", err)
177                 }
178         }
179         return
180 }