source: trunk/grails-app/controllers/dbnp/authentication/LoginController.groovy @ 2083

Last change on this file since 2083 was 2083, checked in by work@…, 11 years ago

shibboleth changes - in development...

  • Property svn:keywords set to Rev Author Date
File size: 8.5 KB
RevLine 
[976]1package dbnp.authentication
2
3import grails.converters.JSON
4
5import org.codehaus.groovy.grails.plugins.springsecurity.SpringSecurityUtils
6
7import org.springframework.security.authentication.AccountExpiredException
8import org.springframework.security.authentication.CredentialsExpiredException
9import org.springframework.security.authentication.DisabledException
10import org.springframework.security.authentication.LockedException
11import org.springframework.security.core.context.SecurityContextHolder as SCH
12import org.springframework.security.web.authentication.AbstractAuthenticationProcessingFilter
13import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter
[1770]14import org.codehaus.groovy.grails.commons.ConfigurationHolder
[976]15
[2080]16import dbnp.authentication.*
17
[976]18class LoginController {
19        /**
20         * Dependency injection for the authenticationTrustResolver.
21         */
22        def authenticationTrustResolver
23
24        /**
25         * Dependency injection for the springSecurityService.
26         */
27        def springSecurityService
28
29        /**
[983]30         * Dependency injection for the GSCF authentication service
31         */
[1588]32        def authenticationService
[983]33
34        /**
[976]35         * Default action; redirects to 'defaultTargetUrl' if logged in, /login/auth otherwise.
36         */
37        def index = {
38                if (springSecurityService.isLoggedIn()) {
39                        redirect uri: SpringSecurityUtils.securityConfig.successHandler.defaultTargetUrl
40                }
41                else {
42                        redirect action: auth, params: params
43                }
44        }
45
46        /**
47         * Show the login page.
48         */
49        def auth = {
50                def config = SpringSecurityUtils.securityConfig
[2080]51
[976]52                if (springSecurityService.isLoggedIn()) {
[1626]53                        if (params.returnURI) {
54                                // see basefilters
55                                redirect uri: params.returnURI
56                        } else {
57                                redirect uri: config.successHandler.defaultTargetUrl
58                        }
[976]59                        return
[2081]60                } else if (request.getHeaderNames().find{ it.toLowerCase() == 'useShibboleth'.toLowerCase() }) {
[2080]61                        // authenticated through shibboleth?
62                        if (request.getHeaderNames().find{ it.toLowerCase() == 'persistent-id'.toLowerCase() }) {
63                                // get shibboleth data
[2081]64                                // note: sometimes apache makes the request headers lowercase, sometimes
65                                //               it doesn't. To make sure it always works we use a case insensitive
66                                //               finder to find the request header name
67                                def shibPersistentId    = request.getHeader(request.getHeaderNames().find{ it.toLowerCase() == 'persistent-id'.toLowerCase() })
[2080]68                                def shibUid                             = request.getHeader("uid")
[2081]69                                def shibEmail                   = request.getHeader(request.getHeaderNames().find{ it.toLowerCase() == 'Shib-InetOrgPerson-mail'.toLowerCase() })
70                                def shibOrganization    = request.getHeader(request.getHeaderNames().find{ it.toLowerCase() == 'schacHomeOrganization'.toLowerCase() })
71                                def shibDisplayName             = request.getHeader(request.getHeaderNames().find{ it.toLowerCase() == 'displayName'.toLowerCase() })
[2080]72
73                                // does a user exist with this username?
74                                def user                                = SecUser.findByUsername(shibPersistentId)
[2082]75println "user: "
76println user
[2080]77                                if (!user) {
[2082]78println "creating user"
[2080]79                                        // no, create a new user
80                                        user = new SecUser()
81                                        user.username           = shibPersistentId
[2081]82                                        user.password           = springSecurityService.encodePassword("myDummyPassword", shibPersistentId)
83                                        user.email                      = shibEmail
84                                        user.displayName        = shibDisplayName
85                                        user.organization       = shibOrganization
86                                        user.uid                        = shibUid
87                                        user.shibbolethUser     = true
[2080]88                                        user.enabled            = true
89                                        user.userConfirmed      = true
90                                        user.adminConfirmed     = true
91                                        user.accountExpired     = false
92                                        user.accountLocked      = false
[2083]93                                        user.save(failOnError:true, flush: true)
[2082]94println user
[2080]95                                }
96
97                                // login user
[2081]98                                springSecurityService.reauthenticate(user.username, user.password)
[2082]99println "bla"
[2081]100                                // redirect user
101                                if (params.returnURI) {
102                                        // see basefilters
103                                        redirect uri: params.returnURI
104                                } else {
105                                        redirect uri: config.successHandler.defaultTargetUrl
106                                }
[2080]107                        }
[2081]108                } else {
109                        println "nope..."
[976]110                }
111
112                String view = 'auth'
113                String postUrl = "${request.contextPath}${config.apf.filterProcessesUrl}"
[1626]114                render view: view, model: [postUrl: postUrl, rememberMeParameter: config.rememberMe.parameter]
[976]115        }
116
[1614]117        /**
118         * Shows the login page for users from a module
119         */
120        def auth_remote = {
121                def consumer = params.consumer
122                def token = params.token
[1770]123               
[1977]124                // Silent means that the user will be sent back, regardless of his login state. He will not
125                // be redirected to the login page.
126                def silent = params.silent ? Boolean.valueOf( params.silent ) : false;
127               
[1614]128                if (consumer == null || token == null) {
129                        throw new Exception("Consumer and Token must be given!");
130                }
131
[1962]132                log.info( "Remote authentication with " + consumer + " and " + token )
133               
[1770]134                def returnUrl;
135               
136                // If no returnUrl is given, find the previous one from the session
137                if( params.returnUrl ) {
138                        returnUrl = params.returnUrl;
139                        session.authRemoteUrl = returnUrl;
140                } else if( session.authRemoteUrl ) {
141                        returnUrl = session.authRemoteUrl;
142                }
[1614]143
144                // If the user is already authenticated with this session_id, redirect
145                // him
146                if (authenticationService.isRemotelyLoggedIn(consumer, token)) {
147                        if (returnUrl) {
148                                redirect url: returnUrl
149                        } else {
150                                redirect controller: 'home'
[983]151                        }
[2020]152                        return;
[1614]153                }
[983]154
[1614]155                // If the user is already logged in locally, we log him in and
156                // immediately redirect him
157                if (authenticationService.isLoggedIn()) {
158                        authenticationService.logInRemotely(consumer, token, authenticationService.getLoggedInUser())
[983]159
[1614]160                        if (returnUrl) {
161                                redirect url: returnUrl
162                        } else {
163                                redirect controller: 'home'
164                        }
[1773]165                        return;
[1614]166                }
[1977]167               
168                // On silent login, the user should be sent back anyway
169                if( silent ) {
170                        if (returnUrl) {
171                                redirect url: returnUrl
172                        } else {
173                                redirect controller: 'home'
174                        }
175                }
176               
[1614]177                // Otherwise we show the login screen
178                def config = SpringSecurityUtils.securityConfig
179                String view = 'auth'
180                String postUrl = "${request.contextPath}${config.apf.filterProcessesUrl}"
[1770]181               
182                String redirectUrl = g.createLink(controller: 'login', action: 'auth_remote', params: [consumer: params.consumer, token: params.token], absolute: true)
[1614]183                render view: view, model: [postUrl: postUrl,
184                        rememberMeParameter: config.rememberMe.parameter, redirectUrl: redirectUrl]
185        }
[983]186
[976]187        /**
188         * Show denied page.
189         */
190        def denied = {
191                if (springSecurityService.isLoggedIn() &&
[1614]192                        authenticationTrustResolver.isRememberMe(SCH.context?.authentication)) {
[976]193                        // have cookie but the page is guarded with IS_AUTHENTICATED_FULLY
194                        redirect action: full, params: params
195                }
196        }
197
198        /**
199         * Login page for users with a remember-me cookie but accessing a IS_AUTHENTICATED_FULLY page.
200         */
201        def full = {
202                def config = SpringSecurityUtils.securityConfig
203                render view: 'auth', params: params,
204                        model: [hasCookie: authenticationTrustResolver.isRememberMe(SCH.context?.authentication),
[1614]205                                postUrl: "${request.contextPath}${config.apf.filterProcessesUrl}"]
[976]206        }
207
208        /**
209         * Callback after a failed login. Redirects to the auth page with a warning message.
210         */
211        def authfail = {
212                def username = session[UsernamePasswordAuthenticationFilter.SPRING_SECURITY_LAST_USERNAME_KEY]
213                String msg = ''
214                def exception = session[AbstractAuthenticationProcessingFilter.SPRING_SECURITY_LAST_EXCEPTION_KEY]
215                if (exception) {
216                        if (exception instanceof AccountExpiredException) {
217                                msg = SpringSecurityUtils.securityConfig.errors.login.expired
218                        }
219                        else if (exception instanceof CredentialsExpiredException) {
220                                msg = SpringSecurityUtils.securityConfig.errors.login.passwordExpired
221                        }
222                        else if (exception instanceof DisabledException) {
223                                msg = SpringSecurityUtils.securityConfig.errors.login.disabled
224                        }
225                        else if (exception instanceof LockedException) {
226                                msg = SpringSecurityUtils.securityConfig.errors.login.locked
227                        }
228                        else {
229                                msg = SpringSecurityUtils.securityConfig.errors.login.fail
230                        }
231                }
232
233                if (springSecurityService.isAjax(request)) {
[1655]234                        // set output header to json
235                        response.contentType = 'application/json'
236
[976]237                        render([error: msg] as JSON)
238                }
239                else {
240                        flash.message = msg
241                        redirect action: auth, params: params
242                }
243        }
244
245        /**
246         * The Ajax success redirect url.
247         */
248        def ajaxSuccess = {
[1655]249                // set output header to json
250                response.contentType = 'application/json'
251
[976]252                render([success: true, username: springSecurityService.authentication.name] as JSON)
253        }
254
255        /**
256         * The Ajax denied redirect url.
257         */
258        def ajaxDenied = {
[1655]259                // set output header to json
260                response.contentType = 'application/json'
261
[976]262                render([error: 'access denied'] as JSON)
263        }
264}
Note: See TracBrowser for help on using the repository browser.