Asegurar las APIs de webservice RESTful de Spring de acceso no autorizado?

He creado con éxito un servicio web Spring RESTful con diferentes API. Ahora debo protegerlos contra el acceso no autorizado. Seguí http://www.beingjavaguys.com/2014/10/spring-security-oauth2-integration.html y la lógica de inicio de sesión es totalmente diferente de la mía. ¿Puede alguien ayudarme a seguir adelante?

Obtener solicitud de inicio de sesión de usuario

@RequestMapping(value = "/login", method = RequestMethod.POST) @ResponseBody @ResponseStatus(HttpStatus.OK) public UserResponse login(@RequestBody final UserLoginRequest userRequest) throws ServletException, IOException { UserResponse userResponse = new UserResponse(); try { userResponse = accessService.login(userRequest); } catch (SQLException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } return userResponse; }

Proceso de solicitud de inicio de sesión de usuario

  @Transactional public UserResponse login(UserLoginRequest userRequest) throws SQLException, ClassNotFoundException, IOException { UserResponse userResponse = new UserResponse(); int status = 0; //boolean isExist = loginDao.isUserExist(userRequest.getUsername(), userRequest.getPassword()); User user = loginDao.getUser(userRequest.getEmailID()); if (user != null) { if (userRequest.getPassword().equals(user.getPassword())) {//Case sensitive password and added to check status //User exist if (user.getStatus().equals("1")) { //Device token check loginDao.isDeviceTokenExists(userRequest, user.getProfileId()); status = 2; } else { status = 3; } } else { status = 4; } } else { status = 1; } if (status == 1) { userResponse.setCode(WeekenterConstants.USER_EMAIL_EXIST_CODE); userResponse.setMessage("User does not exists.Please Register."); } else if (status == 2) { userResponse.setCode(WeekenterConstants.SUCCESS_CODE); userResponse.setMessage("User login success"); userResponse.setId(user.getProfileId()); } else if (status == 3) { userResponse.setCode(WeekenterConstants.FAILURE_CODE); userResponse.setMessage("Your Account is blocked. Please contact Weekenter administrator."); userResponse.setId(user.getProfileId()); } else if (status == 4) { userResponse.setCode(WeekenterConstants.FAILURE_CODE); userResponse.setMessage("Password is wrong."); userResponse.setId(user.getProfileId()); } return userResponse; }

Tengo API para los países de la búsqueda, userlist etc. Esos servicios deben dar solamente datos al cliente de Androide una vez que el usuario es válido. Sé que la autenticación se procesará mediante el uso de token de acceso. ¿Cómo podría hacerlo de una manera estándar?

Puede seguir el mencionado tutorial cambiando la lógica de inicio de sesión en su service.define un servicio de autenticación personalizado en spring-security.xml .

Normalmente, una simple aplicación Spring Security activada utilizaría un servicio de usuario simple como fuente de autenticación:

 <!--Custom User details service which is provide the user data--> <bean id="customUserDetailsService" class="com.yourpackage.CustomUserDetailsService" /> <authentication-manager alias="authenticationManager"> <authentication-provider user-service-ref="customUserDetailsService" /> </authentication-manager>

Su customUserDetailsService debe implementar UserDetailsService disponible en org.springframework.security.core.userdetails.UserDetailsService

 import com.weekenter.www.dao.LoginDao; import java.util.ArrayList; import java.util.Collection; import java.util.List; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.security.core.GrantedAuthority; import org.springframework.security.core.authority.SimpleGrantedAuthority; import org.springframework.security.core.userdetails.User; import org.springframework.security.core.userdetails.UserDetails; import org.springframework.security.core.userdetails.UserDetailsService; import org.springframework.security.core.userdetails.UsernameNotFoundException; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; @Service @Transactional(readOnly = true) public class CustomUserDetailsService implements UserDetailsService { @Autowired private LoginDao loginDao; public UserDetails loadUserByUsername(String login) throws UsernameNotFoundException { boolean enabled = true; boolean accountNonExpired = true; boolean credentialsNonExpired = true; boolean accountNonLocked = true; com.weekenter.www.entity.User user = null; try { user = loginDao.getUser(login);//login variable contain your requested username if (user != null) { if (user.getStatus().equals("1")) { enabled = false; } } else { throw new UsernameNotFoundException(login + " Not found !"); } } catch (Exception ex) { try { throw new Exception(ex.getMessage()); } catch (Exception ex1) { } } <!-- Password comparison will happen here --> return new User( user.getEmail(), user.getPassword(), enabled, accountNonExpired, credentialsNonExpired, accountNonLocked, getAuthorities() ); } public Collection<? extends GrantedAuthority> getAuthorities() { List<GrantedAuthority> authList = getGrantedAuthorities(getRoles()); return authList; } public List<String> getRoles() { List<String> roles = new ArrayList<String>(); roles.add("ROLE_APP"); return roles; } public static List<GrantedAuthority> getGrantedAuthorities(List<String> roles) { List<GrantedAuthority> authorities = new ArrayList<GrantedAuthority>(); for (String role : roles) { authorities.add(new SimpleGrantedAuthority(role)); } return authorities; } }

Y finalmente en spring-security.xml puedes filtrar URL protegidas como las de abajo

 <!-- This is where we tells spring security what URL should be protected and what roles have access to them --> <http pattern="/api/**" create-session="never" entry-point-ref="oauthAuthenticationEntryPoint" access-decision-manager-ref="accessDecisionManager" xmlns="http://www.springframework.org/schema/security"> <anonymous enabled="false" /> <intercept-url pattern="/api/**" access="ROLE_APP" /> <custom-filter ref="resourceServerFilter" before="PRE_AUTH_FILTER" /> <access-denied-handler ref="oauthAccessDeniedHandler" /> </http>

Creo que necesita tener un proceso separado que autorice un dispositivo para su uso en su aplicación.

He trabajado en una aplicación en la que se registran tablets para usar una aplicación. El ID de la tableta se guarda en un archivo de texto simple que es accesible para el servidor Apache. A continuación, todas las solicitudes REST tienen un encabezado especial X_DEVICEID que contiene el ID del dispositivo y un script PHP utilizado por Apache comprueba este ID en el archivo y sólo proporcionará una respuesta si el ID es para un dispositivo registrado.

El archivo de ID de dispositivo permitido actúa como una especie de cortafuegos para bloquear los dispositivos no registrados.