스프링 security 설정하기

	@Override
	public void addInterceptors(InterceptorRegistry registry) {
		registry.addInterceptor(new SessionIntercepter())
			.addPathPatterns("/user/profile/**")
			.addPathPatterns("/post/write/**")
			.addPathPatterns("/post/update/**")
			.addPathPatterns("/post/delete/**");
		
			// addExcludePatterns() 제외 시킬 때 사용!!
	}
	

 

 

 

1. 시큐리티를 사용하기위한 삭제파일

- WebConfig.java

인터셉터 사용 안함

 

 

 

- SessionIntercepter

통째로 날림, 인터셉터 작동 안함

 

- pom.xml의 security주석 풀기

 

 

비밀번호

 

기본적으로 user, 비밀번호는 콘솔창에 있는것 복붙 하면 나옴!

기본적으로 세션을 열면 제공되는 스프링 시큐리티 컨텍스트 세션

이곳에 어선티케이션이 들어간다.

 

 

 

2. SecurityConfig.java 생성

 

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true) // 진입되기 직전에 메모리에 띄울 것 이다.
public class SecurityConfig extends WebSecurityConfigurerAdapter{
	
	@Override
	protected void configure(HttpSecurity http) throws Exception { //모든 요청을 받는다. 

	    http.csrf().disable();

		http.authorizeRequests()
			.antMatchers("/user/profile/**","/post/write/**","/post/update/**","/post/delete/**","/post/detail/**").authenticated()
			.anyRequest().permitAll()
		.and() //안드로이드 앱 같은 경우는 폼 로그인이 아니다. 웹에서는 폼 로그인방식을 많이 쓴다.
			.formLogin()
			.loginPage("/user/login") //그냥 주소로 가고싶으면 loginProcessingUrl()로 가면 되고, 그 전에 무언갈 수행하고싶으면successHandler을 사용하여 new 할수 있다.
            .loginProcessingUrl("/user/login") // POST만 낚아 챔			
            .successHandler(new AuthenticationSuccessHandler() {
				@Override // authentication에 나의 인증 객체가 들어가 있다.
				public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
						Authentication authentication) throws IOException, ServletException {
					// 그 전의 user의 정보를 보고 블랙리스트, 필터도 할 수 있다.
					response.sendRedirect("/");
				}
			});
	}
}

 

 

package com.cos.blog.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;


@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true) // 진입되기 직전에 메모리에 띄울 것 이다.
public class SecurityConfig extends WebSecurityConfigurerAdapter{
	
	@Override
	protected void configure(HttpSecurity http) throws Exception { //모든 요청을 받는다. 
	    http.csrf().disable();

		http.authorizeRequests()
			.antMatchers("/user/profile/**","/post/write/**","/post/update/**","/post/delete/**","/post/detail/**").authenticated()
			.anyRequest().permitAll()
		.and() //안드로이드 앱 같은 경우는 폼 로그인이 아니다. 웹에서는 폼 로그인방식을 많이 쓴다.
			.formLogin()
			.loginPage("/user/login") // 그냥 주소로 가고싶으면 defaultSuccessUrl()로 가면 되고, 그 전에 무언갈 수행하고싶으면successHandler을 사용하여 new 할수 있다.
			.loginProcessingUrl("/user/login") // POST만 낚아 챔
			.defaultSuccessUrl("/");// successHamdler사용 가능 
	}
}

이때까지 하면 userdetail이 없기때문에 낚아 채질 못한다.

 

detail을 상속받아 구현하는 작업을 하여야 한다.

 

 

 

 

 

3. MyUserDetailService생성(detailservice를 상속받아)

유저네임 패스워드필터가 작동하면서 만든 토큰을 전달 받는다.

- MyUserDetailService.java생성

package com.cos.blog.service;

import org.springframework.beans.factory.annotation.Autowired;
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 com.cos.blog.model.user.User;
import com.cos.blog.repository.UserRepository;

@Service
public class MyUserDetailService implements UserDetailsService{
	
	@Autowired
	private UserRepository userRepository;
	
	@Override // 패스워드는 간직하고 있고 유저네임만 전달 해준다.
	//유저프로바이더는 유저디테일을 만든다. 
	public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
		System.out.println("username : "+username);
		User user = userRepository.authentication(username);
		if (user==null) {
			throw new UsernameNotFoundException("해당 유저가 없습니다. ");
		}
		return user;
	}
	
}

 

 

내가 사용하던 유저 모델은 유저디테일스를 임플리먼트해야한다.

 

 

-User.java 수정 ( implements UserDetails )

package com.cos.blog.model.user;

import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Collection;

import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

// MaBatis에서 ResultType으로 담을 때 생성자 혹은 Setter중 무엇이 호출되는지 확인 후 Lombok 변경
@Data
@NoArgsConstructor
public class User implements UserDetails{
	private int id;
	private String username;
	private String password;
	private String email;
	private String profile;
	private String role; // USER,MANAGER,ADMIN
	private Timestamp createDate;
	
	@Builder
	public User(String username, String password, String email, String profile, String role) {
		super();
		this.username = username;
		this.password = password;
		this.email = email;
		this.profile = profile;
		this.role = role;
	}
	
    // username과 password의 getter도 만들어져야 하는데
    // 우리는 필드명을 username과 password로 만들었고 lombok 어노테이션을 붙여놔서
    // 안만들어도된다.
	
	// 권한이 몇개 되어있는가? 여러개의 권한을 리턴한다. 
	@Override
	public Collection<? extends GrantedAuthority> getAuthorities() {
		
		Collection<SimpleGrantedAuthority> collectors = new ArrayList<>(); // 내가 GrantedAuthority 상속받는 객체를 new 해도된다.
		collectors.add(new SimpleGrantedAuthority("ROLE_"+role));
		// "ROLE_"+role 로 해야지 스프링이 인식한다. 규칙! 
		return collectors;
	}

	
	// 계정이 만료되었는가를 체크하여 리턴한다(true:만료안됨)
	// 좀 더 깊게 들어가면 마지막 접속시간과 현재 세션을 비교하는 등으로 활용 할 수 있다. 
	@Override
	public boolean isAccountNonExpired() {
		return true;
	}

	// 계정이 잠겨있는지 체크하여 리턴한다(true:잠기지 않음)
	@Override
	public boolean isAccountNonLocked() {
		return true;
	}

	// 비밀번호가 만료되었는지 체크하여 리턴한다.(true:만료안됨)
	@Override
	public boolean isCredentialsNonExpired() {
		return true;
	}

	// 해당계정이 활성화 되어있는지 체크하여 리턴한다(true:활성화)
	@Override
	public boolean isEnabled() {
		return true;
	}
}

 

 

 

username, password의 getter, setter이 만들어져있기때문에 따로 오버라이드 안해도된다.

hasRole이 모이면 getAuthorities로 호출 해야한다.

 

 

이 모든것을 하면 세션에 스프링시큐리티를 넣어놓는다.스프링시큐리티 안에는 어선티가 있다.

 

 

 

 

4. 아이디와 패스워드 저장 시 패스워드 hash로 암호화하기

 

-securityConfig 수정

요즘은 SHA256를 사용한다. 스프링은 BCrypt 암호화 방식을 사용한다.

복호화가 안됨. 즉 비밀번호를 잊어버리면 너도모르고 나도모르고 모두가 모름.

	@Bean
	public BCryptPasswordEncoder Encoded() {
		return new BCryptPasswordEncoder();
	}

 

빈을 붙여야 메모리에 뜬다.

 

-UserService.java

package com.cos.blog.service;

import javax.servlet.http.HttpSession;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.cos.blog.model.ReturnCode;
import com.cos.blog.model.user.User;
import com.cos.blog.model.user.dto.ReqJoinDto;
import com.cos.blog.model.user.dto.ReqLoginDto;
import com.cos.blog.repository.UserRepository;

@Service
public class UserService {

	@Autowired
	private UserRepository userRepository;
	
	@Autowired
	private HttpSession session;
	
	@Autowired
	private BCryptPasswordEncoder passwordEncoder;
	
	// result = 0 비정상, 1 정상, -1 DB 오류, -2 아이디 중복
	@Transactional
	public int 회원가입(ReqJoinDto dto) {
		try {
			int result = userRepository.findByUsername(dto.getUsername());
			
			if(result == 1) {
				return ReturnCode.아이디중복;
			}else {
				//패스워드 암호화하기 
				String encodePassword = passwordEncoder.encode(dto.getPassword());
				dto.setPassword(encodePassword);
				return userRepository.save(dto);
			}
			
		} catch (Exception e) {
			throw new RuntimeException();
		}
	}
	
	public User 로그인(ReqLoginDto dto) {
		return userRepository.findByUsernameAndPassword(dto);
	}
	
	public int 수정완료(int id, String password, String profile) {
		
		int result = userRepository.update(id, password, profile);
		
		if(result == 1) { // 수정 성공
			User user = userRepository.findById(id);
			session.setAttribute("principal", user);
			
			return 1;
		}else { // 수정 실패
			return -1;
		}
	}
}

 

 

- SecurityConfig

로그인할때에도 암호화할 수 있게

	@Autowired
	protected UserDetailsService userDetailsService;

	@Override
	protected void configure(AuthenticationManagerBuilder auth) throws Exception {
		auth.userDetailsService(userDetailsService).passwordEncoder(encoded());
	}

 

 

- usercontroller 삭제

	@PostMapping("/user/login")
	public ResponseEntity<?> login(
			@Valid @RequestBody ReqLoginDto dto, 
			BindingResult bindingResult
			) {
		
		// request 검증 = AOP로 처리할 예정
		
		// 서비스 호출
		User principal = userService.로그인(dto);

		if(principal != null) {
			session.setAttribute("principal", principal);
			return new ResponseEntity<RespCM>(new RespCM(200, "ok"), HttpStatus.OK);
		}else {
			return new ResponseEntity<RespCM>(new RespCM(400, "fail"), HttpStatus.BAD_REQUEST);
		}
		
	}

 

 

 

 

 

기존의 에이작스로 요청하고 받앗던 것을 / 로 리턴해주는 것이 아닌 지선 라이브러리를 사용하여 json형태로 변경하거나 해야한다. 매퍼가 들고있는 오브젝트 변환하는것을 사용

 

 

- SecurityConfig.java 수정

package com.cos.blog.config;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;

import com.cos.blog.model.RespCM;
import com.fasterxml.jackson.databind.ObjectMapper;


@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true) // 진입되기 직전에 메모리에 띄울 것 이다.
public class SecurityConfig extends WebSecurityConfigurerAdapter{
	
	@Bean
	public BCryptPasswordEncoder encoded() {
		return new BCryptPasswordEncoder();
	}
	
	@Override
	protected void configure(HttpSecurity http) throws Exception { //모든 요청을 받는다. 
		http.csrf().disable();
		
		http.authorizeRequests()
			.antMatchers("/user/profile/**","/post/write/**","/post/update/**","/post/delete/**","/post/detail/**").authenticated()
			.antMatchers("/amdin/**").access("hasRole('ROLE_ADMIN')or hasRole('ROLE_MANAGER')")//권한 설정,USER.java에서도 설정해주고 access만 해준다.
			.anyRequest().permitAll()
		.and() //안드로이드 앱 같은 경우는 폼 로그인이 아니다. 웹에서는 폼 로그인방식을 많이 쓴다.
			.formLogin()
			.loginPage("/user/login") // 그냥 주소로 가고싶으면 defaultSuccessUrl()로 가면 되고, 그 전에 무언갈 수행하고싶으면successHandler을 사용하여 new 할수 있다.
			.loginProcessingUrl("/user/loginProc") // POST만 낚아 챔
			.failureHandler(new AuthenticationFailureHandler() {
				
				@Override
				public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response,
						AuthenticationException exception) throws IOException, ServletException {
					System.out.println("실패~~~~~~~~~~");
					System.out.println(exception.getMessage());
					System.out.println(exception.getLocalizedMessage());
					System.out.println(exception.toString());
					
				}
			})
			.successHandler(new AuthenticationSuccessHandler() {

				@Override
				public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
						Authentication authentication) throws IOException, ServletException {
				PrintWriter out= response.getWriter();	
				ObjectMapper mapper = new ObjectMapper();
				String jsonString = mapper.writeValueAsString(new RespCM(200,"ok"));
				System.out.println(jsonString);
				out.print(jsonString);
				out.flush();
					
				
				
				}
			});
			//.defaultSuccessUrl("/");// successHamdler사용 가능 , 페이지를 리턴 해준다.
	}
	
	@Autowired
	protected UserDetailsService userDetailsService;
	
	
	@Override
	protected void configure(AuthenticationManagerBuilder auth) throws Exception {
		auth.userDetailsService(userDetailsService).passwordEncoder(encoded());
	}
}

 

 

-login.jsp

로그인 폼도 폼을 전송할수있게 수정!

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<%@include file="../include/nav.jsp"%>

<div class="container">

	<form>
		<div class="form-group">
			<label for="username">유저네임</label> 
			<input type="text" class="form-control" placeholder="Enter Username" id="username">
		</div>
		<div class="form-group">
			<label for="password">패스워드</label> 
			<input type="password" class="form-control" placeholder="Enter password" id="password">
		</div>
		
	</form>
	<button id="login--submit" class="btn btn-primary">로그인</button>


</div>

<script>
	$('#login--submit').on('click', function(e){
		// e.preventDefault();
		var data = {
			username: $('#username').val(),
			password: $('#password').val()
		};

		alert(data.username);
		alert(data.password);
		$.ajax({
			type: 'POST',
			url: '/user/loginProc',
			data: data,
			contentType : 'application/x-www-form-urlencoded',
			dataType : 'json'
		}).done(function(r){
			console.log(r);
			alert("로그인 성공");
			location.href = '/';
		}).fail(function(r){
			console.log(r);
			alert("로그인 실패");
		});
	});


</script>

<%@include file="../include/footer.jsp"%>

 

 

 

 

 

5. 기존의 세션 코드 수정

 

pom.xml에 추가

        <dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-taglibs</artifactId>
		</dependency>

아래의 시큐리티 태그를 위에 붙이면 시큐리티 전용 태그를 사용할 수 있다.

<%@ taglib prefix="sec" uri="http://www.springframework.org/security/tags" %>

 

<sec:authorize access="isAuthenticated()">
    <sec:authentication property="principal" var="principal" />
</sec:authorize>

 

스프링시큐리티에 있는 정보가 있는지를 확인해줌 true가 떨어지면 있는 것이다.

그 세션 값을 principal에 넣는다는 뜻

원래는 principal의 이름을 지정해주었지만 이 태그를 쓰면 자동으로 principal이라고 지정이 된다.

 

 

 

- nav.jsp 수정

sessionScope.principal을 전부 변경해 준다.

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<%@ taglib prefix="sec" uri="http://www.springframework.org/security/tags" %>

<sec:authorize access="isAuthenticated()">
    <sec:authentication property="principal" var="principal" />
</sec:authorize>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>블로그</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.4.1/css/bootstrap.min.css">
<link rel="stylesheet" href="/css/style.css" />
</head>
<body>
	<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.4.1/jquery.min.js"></script>
	<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.16.0/umd/popper.min.js"></script>
	<script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.4.1/js/bootstrap.min.js"></script>

	<nav class="navbar navbar-expand-md bg-info navbar-dark">
		<!-- Brand -->
		<a class="navbar-brand" href="/">Cos</a>

		<!-- Toggler/collapsibe Button -->
		<button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#collapsibleNavbar">
			<span class="navbar-toggler-icon"></span>
		</button>

		<!-- Navbar links -->
		<div class="collapse navbar-collapse" id="collapsibleNavbar">
			<ul class="navbar-nav">

				<c:choose>
					<c:when test="${not empty principal}">
						<li class="nav-item">
						<a class="nav-link" href="/post/write">글쓰기</a></li>

						<li class="nav-item">
						<a class="nav-link" href="/user/profile/${principal.id}">회원정보수정</a></li>
						
						<li class="nav-item">
						<a class="nav-link" href="/user/logout">로그아웃</a></li>
					</c:when>
					<c:otherwise>
						<li class="nav-item">
						<a class="nav-link" href="/user/join">회원가입</a></li>

						<li class="nav-item">
						<a class="nav-link" href="/user/login">로그인</a></li>
					</c:otherwise>
				</c:choose>

			</ul>
			<img src="/media/${principal.profile}"  class="rounded-circle my__img ml-auto" 
			     width="30px" height="30px" onerror="javascript:this.src = '/images/unknown.jpg' " />
		</div>
	</nav>
	<br />

 

- postController.java 수정

세션을 지우고 아래처럼 매개변수에 어노테이션을 걸어 사용하여도된다.

// 인증 체크
	@PostMapping("/post/write")
	public ResponseEntity<?> write(@RequestBody ReqWriteDto dto,@AuthenticationPrincipal User principal) {
		
	
		dto.setUserId(principal.getId());
		
		int result = postService.글쓰기(dto);
		
		if(result == 1) {
			return new ResponseEntity<RespCM>(new RespCM(200, "ok"), HttpStatus.OK);	
		}else {
			return new ResponseEntity<RespCM>(new RespCM(400, "fail"), HttpStatus.BAD_REQUEST);
		}
		
		
	}

 

 

 

- userController수정

package com.cos.blog.controller;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.UUID;

import javax.validation.Valid;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

import com.cos.blog.model.RespCM;
import com.cos.blog.model.ReturnCode;
import com.cos.blog.model.user.User;
import com.cos.blog.model.user.dto.ReqJoinDto;
import com.cos.blog.service.UserService;
import com.cos.blog.util.Script;

@Controller
public class UserController {
	
	@Value("${file.path}")
	private String fileRealPath;  // 서버에 배포하면 경로 변경해야함.
	
	@Autowired
	private UserService userService;
	
	@GetMapping("/user/join")
	public String join() {
		return "/user/join";
	}
	
	@GetMapping("/user/login")
	public String login() {
		return "/user/login";
	}

	
	// 인증, 동일인 체크
	@GetMapping("/user/profile/{id}")
	public  String profile(@PathVariable int id,@AuthenticationPrincipal User principal) {
		
		System.out.println("UserController : profile :  "+principal.getProfile());
		if(principal.getId() == id) {
			return "/user/profile";
		}else {
			// 잘못된 접근입니다. 권한이 없습니다.
			return "/user/login";
		}
	
	}
	
	// form:form 사용함!!
	@PutMapping("/user/profile")
	public @ResponseBody String profile(
			@RequestParam int id, 
			@RequestParam String password,
			@RequestParam MultipartFile profile){
		
		UUID uuid = UUID.randomUUID();
		String uuidFilename = uuid+"_"+profile.getOriginalFilename();
		
		// nio 객체!!
		Path filePath = Paths.get(fileRealPath+uuidFilename);
		try {
			Files.write(filePath, profile.getBytes());
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		int result = userService.수정완료(id, password, uuidFilename);
		
		if(result == 1) {
			return Script.href("수정완료", "/");
		}else {
			return Script.back("수정실패");
		}	

	}
	
	// 메시지 컨버터(Jackson Mapper)는 request받을 때 setter로 호출한다.
	@PostMapping("/user/join")
	public ResponseEntity<?> join(@Valid @RequestBody ReqJoinDto dto, BindingResult bindingResult) {
		
		int result = userService.회원가입(dto);
		
		if(result == ReturnCode.아이디중복) {
			return new ResponseEntity<RespCM>(new RespCM(ReturnCode.아이디중복, "아이디중복"), HttpStatus.OK);
		}else if(result == ReturnCode.성공) {
			return new ResponseEntity<RespCM>(new RespCM(200, "ok"), HttpStatus.OK);
		}else {
			return new ResponseEntity<RespCM>(new RespCM(500, "fail"), HttpStatus.INTERNAL_SERVER_ERROR);
		}	
	}
	
}

 

등 session을 쓰는 모든 곳에 사용하면 된다.

 

 

마지막 수업 :-)

수고하셧습니당 헿