grails - Cómo vincular la autenticación OAuth con Spring Security

spring-security grails-plugin

Question

Tengo una aplicación Grails 2.5.3 que actualmente usa el complemento de seguridad Spring para la autenticación. Los usuarios inician sesión usando un nombre de usuario / pwd.

He actualizado la aplicación ahora para admitir la autenticación OAuth (usando ScribeJava). Los usuarios pueden hacer clic en un enlace que los redirige a la página de proveedores de OAuth y al ingresar con éxito las credenciales, se los redirige a mi aplicación. Sin embargo, no he podido vincular esta funcionalidad con el complemento de seguridad de primavera para que cuando los usuarios vuelvan a mi aplicación (después del inicio de sesión exitoso de OAuth), realmente pueda ver que están conectados y continúan usando toda mi primavera artículos de seguridad como <sec:ifLoggedIn> .

¿Alguien sabe de una manera de hacer esto o tiene un ejemplo que puedo echarle un vistazo?

Así es como autentico a un usuario que usa OAuth:

//called when user clicks "login using oauth"
def authenticate() {
    OAuthService service = new ServiceBuilder()
                              .apiKey(grailsApplication.config.my.sso.clientid)
                              .apiSecret(grailsApplication.config.my.sso.clientsecret)
                              .build(MyApi.instance());
    String url =  service.getAuthorizationUrl();
    return redirect(url: url)
}

//called when oauth provider redirects to my application
def authorization_code() {
    def code = params.code
    OAuthService service = new ServiceBuilder()
                              .apiKey(grailsApplication.config.my.sso.clientid)
                              .apiSecret(grailsApplication.config.my.sso.clientsecret)
                              .build(MyApi.instance());
    println code                          
    OAuth2AccessToken accessToken = service.getAccessToken(code);
    String userProfileUrl = grailsApplication.config.my.sso.authdomain+"/userinfo"
    final OAuthRequest request = new OAuthRequest(Verb.GET, userProfileUrl);
    service.signRequest(accessToken, request);
    final Response response = service.execute(request);
    println(response.getCode());
    println(response.getBody());        
    render (text: code)
}

Answer 1

Suponiendo que obtuvo los detalles del usuario del proveedor de Oauth, solo necesita establecer el contexto de seguridad de ese usuario en particular

Simplemente obtenga los detalles del usuario analizando el JSON como

def oauthResponse = JSON.parse(response?.getBody())
Map data = [
                    id          : oauthResponse.id,
                    email       : oauthResponse.email,
                    name        : oauthResponse.name,
                    first_name  : oauthResponse.given_name,
                    last_name   : oauthResponse.family_name,
                    gender      : oauthResponse.gender,
                    link        : oauthResponse.link
            ]

Bueno, en nuestro caso usamos la identificación del correo electrónico como nombre de usuario.

Entonces, cuando obtengamos los datos del usuario, simplemente verifique si el usuario ya está registrado con el sistema o no, como a continuación

//load the user details service bean
def userDetailsService

//check if user is already registered on our system
User user = User.findByEmail(data?.email)
if (user) {

    //If user exists load his context
    userDetails = userDetailsService.loadUserByUsername(data?.email)
} else {

    //create the new user
    //Assign the role to it

    //load his context as below
   userDetails = userDetailsService.loadUserByUsername(data?.email)
}

Después de que el usuario se haya registrado correctamente, solo tenemos que cargar su contexto como se muestra a continuación.

def password

//setting spring security context
SecurityContextHolder.getContext().setAuthentication(new UsernamePasswordAuthenticationToken(userDetails, password == null ? userDetails.getPassword() : password, userDetails.getAuthorities()))

Una vez que se haya cargado el contexto de seguridad de primavera, puede redirigir al usuario a su página de destino.

Ahora el usuario oauth tendrá acceso a recursos como cualquier otro usuario con el mismo rol.

Answer 2

Cada vez que se autentica a través de OAuth , el servidor remoto le devuelve una unique id (some numeric value) cada vez. Puede usar esa id para verificar al usuario en su extremo y autenticar al usuario utilizando el método springsecurity.reauthenticate() .

Pasos para hacer eso:

1. Cuando el usuario se conecta (autenticación por primera vez) con el proveedor de servicios. El proveedor del servicio le enviará esa unique id . Guarde esa unique id en la tabla de usuario.
2. Y cuando el usuario inicia sesión a través de ese proveedor de servicios. De nuevo, el proveedor de servicios envía esa unique id . Compruebe si existe ese unique id en su sistema, y ​​si el usuario existe con ese ID único, utilice el springsecurity.reauthenticate(userInstance) para autenticar al usuario. Y ahora puedes usar las características de seguridad de primavera.

mira el enlace: http://www.jellyfishtechnologies.com/grails-2-2-0-integration-with-facebook-using-grails-oauth-plugin/