제프의 Study Room

Spring oauth2 server with social login

2020-01-17T00:00:00+00:00

Spring Boot 로 Rest 방식의 소셜 로그인을 만들어보자.

사전에 앞서, 이부분에서 오피셜 플로우가 있는지는 잘 모르겠다.

많이 알려진(?) 방법으로는 social 로그인 후 code 를 서버로 전송 해, 서버가 access token 을 받아, 클라이언트로 넘겨준다는 방식으로 많이 설명하는 것 같던데,

이렇게 되면 소셜 configration 정보를 서버와 클라이언트가 모두 가지고있어야 하는 불편함이 있어, 방법을 찾아보다가 이 방법이 개인적으로 가장 선호하는 방법이 되었다.

사전에 앞서, 기술스택은 다음과 같다.

spring boot
- oauth2-auto-configure
kakao
vue (그냥 포스팅하면 밋밋해서 사용해봤다.)

진행 될 프로세스는 다음과 같다.

클라이언트는 소셜 로그인을 한다.
로그인 후 받은 토큰으로 서버에 인증요청을 한다.
서버는 받은 토큰으로, provider 인증서버로 사용자정보를 요청한다.
받아온 사용자 정보를 토대로, Security Context 로 등록하고 서버전용 토큰을 발급한다.
클라이언트는 provider 에서 발급받은 토큰으로 provider resource 를. 서버에서 발급받은 토큰으로, 서버 resource 를 요청한다.

이제 코딩을 시작하자.

먼저 스프링 부트 프로젝트를 생성한다.

라이브러리는 다음처럼 다운받았다.

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation group: 'org.springframework.security.oauth.boot', name: 'spring-security-oauth2-autoconfigure', version: '2.2.2.RELEASE'
    compileOnly 'org.projectlombok:lombok'
    developmentOnly 'org.springframework.boot:spring-boot-devtools'
    runtimeOnly 'com.h2database:h2'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation('org.springframework.boot:spring-boot-starter-test') {
        exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
    }
}

필요한 라이브러리는 모두 다운받았다.

AuthenticationProvider

AuthenticationProvider 를 만들자.

이 클래스가 할 일은, 사용자 정보를 조회하고, Security Context 에 등록 할 Authentication 객체를 만드는 일이다. 먼저 토큰을 생성 할 인증서버를 만들자.

AuthenticationProvider.java

@Slf4j
@Component
public class UserDetailsServiceProvider implements AuthenticationProvider {

    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {

        // ..TODO DB 처리
        UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(
                authentication.getName(),
                null,
                AuthorityUtils.createAuthorityList("BASIC_UESR")
        );

        return token;
    }

    @Override
    public boolean supports(Class<?> authentication) {
        return authentication.equals(UsernamePasswordAuthenticationToken.class);
    }
}

일단 들어오는 요청마다, 유저를 생성 할 수 있도록 하였다.

다음으로 WebSecurityConfig 를 만들어, 필요한 부품을 꺼내온다.

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private AuthenticationProvider authenticationProvider;

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.authenticationProvider(authenticationProvider)
                .inMemoryAuthentication()
                .withUser("user").password(passwordEncoder().encode("1234")).authorities("BASIC_USER");
    }

    @Override
    public void configure(WebSecurity web) throws Exception {
        super.configure(web);
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    /**
     * @see <a href="https://oddpoet.net/blog/2017/04/27/cors-with-spring-security/">
     * https://oddpoet.net/blog/2017/04/27/cors-with-spring-security/
     * </a>
     */
    @Bean
    public CorsConfigurationSource corsConfigurationSource() {
        CorsConfiguration configuration = new CorsConfiguration();
        configuration.addAllowedOrigin("*");
        configuration.addAllowedMethod("*");
        configuration.addAllowedHeader("*");
        configuration.setAllowCredentials(true);
        configuration.setMaxAge(3600L);
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", configuration);
        return source;
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    
    @Bean
    @Override
    public UserDetailsService userDetailsServiceBean() throws Exception {
        return super.userDetailsServiceBean();
    }

}

위에서 만든 AuthenticationProvider 를 AuthenticationManagerBuilder 에 주입 해 주고, PasswordEncoder, AuthenticationManager, UserDetailsService 를 꺼내왔다.

다음으로, 인증서버를 만들어 앤드포인트를 보호하면서 토큰을 생성 할 수 있는 클래스를 만들자.

@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {

    @Autowired
    private AuthenticationManager authenticationManager;

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        super.configure(security);
    }

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients
                .inMemory()
                .withClient("client")
                .secret(passwordEncoder.encode("secret"))
                .authorities("BASIC_CLIENT")
                .scopes("basic")
                .authorizedGrantTypes("password", "refresh_token");
    }

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints
                .tokenServices(authorizationServerTokenServices())
                .authenticationManager(authenticationManager);
    }

    @Bean
    public AuthorizationServerTokenServices authorizationServerTokenServices() {
        DefaultTokenServices services = new DefaultTokenServices();
        services.setTokenStore(tokenStore());
        services.setTokenEnhancer(tokenConverter());
        services.setSupportRefreshToken(true);
        services.setAuthenticationManager(authenticationManager);
        return services;
    }

    @Bean
    public JwtAccessTokenConverter tokenConverter() {
        return new JwtAccessTokenConverter();
    }

    @Bean
    public TokenStore tokenStore() {
        return new JwtTokenStore(tokenConverter());
    }
}

WebSecurityConfig 에서 꺼내온, PasswordEncoder 와 AuthenticationManager 를 주입 해주고, 가상의 메모리 Client 를 client / secret 으로 생성하였다.

이렇게 만든 이유는, 소셜 인증을 요청 할 경우, 해당 애플리케이션에서 들어 온 요청정보가 우리 애플리케이션이 맞다는 검증을 하기 위해 만든것이다.

또, 토큰 타입을 JWT 타입으로 변경하여, 요청에 필요 한 서버 자원을 절약 하도록 하였다.

마지막으로, ResourceServer 를 구현하여, API 앤드포인트를 보호하자.

@Order(-100)
@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {

    @Override
    public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
        super.configure(resources);
    }

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http
                .requestMatchers()
                .mvcMatchers("/oauth/**", "/api/**")
                .and()
                .cors()
                .and()
                .csrf().disable()
                .authorizeRequests()
                .antMatchers("/oauth/**").hasAuthority("BASIC_CLIENT")
                .antMatchers("/api/**").authenticated()
                .and();
    }
}

기본적인 설정을 마쳤으니, 테스트를 하기 위해 컨트롤러 하나를 생성해보자.

AccountController.java

@RestController
public class AccountController {

    @Autowired
    private TokenEndpoint tokenEndpoint;

    @PostMapping(value = "/oauth/token")
    public ResponseEntity<OAuth2AccessToken> postAccessToken(
            Principal principal,
            @RequestParam Map<String, String> parameters
    ) throws HttpRequestMethodNotSupportedException {
        return tokenEndpoint.postAccessToken(principal, parameters);
    }

    @GetMapping(value = "/api/me")
    public ResponseEntity<Object> me(Principal principal) {
        return ResponseEntity.ok(principal);
    }
}

postman 으로 요청 하여, 토큰을 발급하면 준비는 끝났다.

Kakao Client 에서 유저정보 받아오기

위에서는 토큰 발급을 하기 위한, 기본적인 부분을 만들었고, 이제 실제로 유저 정보를 받아서

우리가 만든 인증시스템에 등록 하는 작업을 해보자.

먼저 클라이언트에서 전달 받은, 토큰으로 카카오 유저 정보를 조회 할 수 있는 Rest Client 를 만들자.

@Service
public class KakaoClient {

    private static final String KAKAO_HOST = "https://kapi.kakao.com";

    public ResponseEntity<HashMap<String, Object>> me(String access_token) {
        RestTemplate template = new RestTemplate();

        MultiValueMap<String, String> headers = new HttpHeaders();
        headers.add("Authorization", "Bearer " + access_token);

        HttpEntity<MultiValueMap<String, String>> entity = new HttpEntity<>(headers);

        ParameterizedTypeReference<HashMap<String, Object>> responseType =
                new ParameterizedTypeReference<HashMap<String, Object>>() {};

        return template.exchange(KAKAO_HOST + "/v2/user/me", HttpMethod.GET, entity, responseType);
    }
}

다음으로, AccountController 에서 만든 postToken method 에 파라메터 하나를 추가 하겠다.

@Slf4j
@RestController
public class AccountController {
    
    // ...other

    @PostMapping(value = "/oauth/token")
    public ResponseEntity<OAuth2AccessToken> postAccessToken(
            // new
            @RequestHeader(name = "x-auth-token", required = false) String xAuthToken,
            @RequestParam Map<String, String> parameters,
            Principal principal
    ) throws HttpRequestMethodNotSupportedException {
        log.info("AccountController");
        // new
        parameters.putIfAbsent("grant_type", "password");
        if (xAuthToken != null) {
            parameters.put("provider_token", xAuthToken);
        }
        return tokenEndpoint.postAccessToken(principal, parameters);
    }
    
    // ...other

}

oauth2 인증 스펙 제약때문에, 기본 grant_type 을 password 로 설정 하였고, header 에 x-auth-token 헤더를 추가했다.

이제 돌아가서 SsoAuthenticationProvider 에 인증 로직을 구현하자.

@Slf4j
@Component
public class UserDetailsServiceProvider implements AuthenticationProvider {

    @Autowired
    private KakaoClient kakaoClient;

    @Autowired
    @Qualifier("userDetailsServiceBean")
    private UserDetailsService userDetailsService;

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {

        HashMap<String, Object> details = (HashMap<String, Object>) authentication.getDetails();

        // provider_token 이 있으면 소셜에서 회원정보를 조회한다.
        if (details.get("provider_token") != null) {
            String sso_user_id = ssoExtractor(details.get("provider_token"));

            if (sso_user_id != null) {
                // ..TODO DB 처리

                return new UsernamePasswordAuthenticationToken(
                        sso_user_id, null, AuthorityUtils.createAuthorityList("BASIC_UESR")
                );
            }
        }

        // 기본인증.
        String user_password = authentication.getCredentials().toString();
        UserDetails userDetails = userDetailsService.loadUserByUsername(authentication.getName());
        if (!passwordEncoder.matches(user_password, userDetails.getPassword())) {
            throw new BadCredentialsException("Password Match Failed");
        }

        return new UsernamePasswordAuthenticationToken(
                userDetails.getUsername(), userDetails.getPassword(), userDetails.getAuthorities()
        );
    }


    @Override
    public boolean supports(Class<?> authentication) {
        return authentication.equals(UsernamePasswordAuthenticationToken.class);
    }

    private String ssoExtractor(final Object extractorToken) {
        String convert_str = extractorToken.toString();
        String[] xHeader = convert_str.split(" ");
        if (xHeader.length == 2) {
            String access_token = xHeader[1];
            if (xHeader[0].equalsIgnoreCase("kakao")) {
                // 카카오 헤더일 경우, kakao 유저를 검증한다.
                ResponseEntity<HashMap<String, Object>> response = kakaoClient.me(access_token);
                if (response.hasBody()) {
                    assert response.getBody() != null;
                    return response.getBody().get("id").toString();
                }
            }
        }

        return null;
    }
}

이제 소셜 로그인을 할 수 있는 페이지를 만들자.

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <title>Kakao Login Example</title>
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/css/bootstrap.min.css" integrity="sha384-Vkoo8x4CGsO3+Hhxv8T/Q5PaXtkKtu6ug5TOeNV6gBiFeWPGFN9MuhOf23Q9Ifjh" crossorigin="anonymous">
</head>
<body>
<div id="app" class="container p-5">

    <div v-if="loading" class="spinner-grow" role="status">
        <span class="sr-only">Loading...</span>
    </div>
    <div v-if="!loading" class="col-md-4">
        <button class="btn btn-primary" v-if="isLogined === false" @click="kakaoLogin">카카오 로그인</button>
        <div v-if="isLogined === true">
            <img :src="profile_url" alt="profile image" class="rounded-circle rounded-sm" />
            <a href="#" class="btn btn-dark" @click="kakaoLogout">로그아웃</a>
        </div>
    </div>
</div>
<script src="https://cdnjs.cloudflare.com/ajax/libs/vue/2.6.10/vue.min.js"></script>
<script src="//developers.kakao.com/sdk/js/kakao.min.js"></script>
<script src="https://code.jquery.com/jquery-3.4.1.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/popper.js@1.16.0/dist/umd/popper.min.js" integrity="sha384-Q6E9RHvbIyZFJoft+2mJbHaEWldlvI9IOYy5n3zV9zzTtmI3UksdQRVvoxMfooAo" crossorigin="anonymous"></script>
<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/js/bootstrap.min.js" integrity="sha384-wfSDF2E50Y2D1uUdj0O3uMBJnjuUD4Ih7YwaYd1iqfktj0Uod8GCExl3Og8ifwB6" crossorigin="anonymous"></script>
<script>
    var KAKAO_JS_ID = '20b1fc00b5c01b361c5e74e78f0908b3';
    Kakao.init(KAKAO_JS_ID);

    new Vue({
        el: "#app",
        data: {
            profile_url: null,
            isLogined: false,
            loading: false
        },
        mounted: function () {
            this.getKakaoLoginStatus();
        },
        methods: {
            getKakaoLoginStatus: function () {
                this.loading = true;
                this.$nextTick(function () {

                    /**
                     * @param {Object} statusObj - 카카오 로그인 상태를 체크
                     * @param {("connected" | "not_connected")} statusObj.status - 현재 로그인 상태
                     * @param {Object} statusObj.user - status 가 connected 일 때, 사용자 정보
                     * @param  statusObj.user.properties - 로그인 후 사용자 정보
                     */
                    Kakao.Auth.getStatusInfo(function (statusObj) {
                        this.loading = false;
                        if (statusObj.status === 'connected') {
                            this.isLogined = true;

                            console.log('Login Connected: ', statusObj);
                            console.log(statusObj);
                            this.profile_url = statusObj.user.properties.profile_image;
                        } else {
                            this.isLogined = false;
                            console.log('Login Not Connected: ', statusObj);
                        }
                    }.bind(this));
                })
            },

            /**
             * 카카오 로그인 팝업창을 띄우고, 로그인 프로세스를 진행한다.
             */
            kakaoLogin: function() {
                Kakao.Auth.login({
                    success: this.kakaoLoginSuccessHandler.bind(this),
                    fail: function (err) {
                        alert(JSON.stringify(err));
                    }
                })
            },
            /**
             * 카카오에 연결된 로그인 세션을 해제한다.
             */
            kakaoLogout: function () {
                console.log('logout');
                this.loading = true;
                this.$nextTick(function () {
                    Kakao.Auth.logout(function (logout) {
                        this.loading = false;
                        if (logout) {
                            this.isLogined = false;
                        }
                    }.bind(this));
                });
            },

            /**
             * 카카오에서 발급받은, access_token 으로 서버에 /oauth/kakao 로 인증요청을 한 후,
             * 서버에서 발급받은 토큰을 로컬스토리지로 저장한다.
             *
             * @param  response - 리소스에 접근 할 수 있는 토큰 오브젝
             */
            kakaoLoginSuccessHandler: function (response) {
                this.isLogined = true;
                console.log('kakaoLoginSuccessHandler(): ', response);
                this.$nextTick(function () {
                    this.getKakaoLoginStatus();
                    $.ajax({
                        url: "http://localhost:8080/oauth/token",
                        method: "post",
                        contentType: "application/x-www-form-urlencoded",
                        headers: {
                            'authorization': 'Basic Y2xpZW50OnNlY3JldA==',
                            'x-auth-token': 'Kakao ' + response.access_token
                        },
                        success: function (response) {
                            console.log(response);
                            localStorage.setItem("app_user", JSON.stringify(response));
                        },
                        error: function (err) {
                            alert(JSON.stringify(err));
                        }
                    })
                });
            },
        }
    });
</script>
</body>
</html>

간략하게 설명하자면,

kakao에서 access_token 발급 -> 서버로 엑세스 토큰 전송 -> 서버에서 발급받은 access_token 을 로컬스토리지로 저장 순이다.

이제 카카오 로그인 후, localStorage 에 서버에서 받아 온, 사용자 정보가 들어있으면

성공이다.

source: https://github.com/ziponia/spring-boot-oauth2-server-with-social

[SPRING] Spring Security 사용하기 #12

2019-05-27T00:00:00+00:00

지난 oauth2 client DB 로 관리하기 에서 우리는

ClientDetailsService 인터페이스를 ClientServiceImpl 로 구현하고 loadClientByClientId 를 오버라이드 하여, 제공했었다.

사실 이부분은 매우 큰 결점이 있는데, Security 포스팅과 맞지 않는다고 생각하여, 그냥 넘어가려고 했지만…

다시 생각해 보니 언급하고 넘어가는게 좋을 것 같아서 진행 하려고 한다.

loadByClientByClientId 에서 clientEntity 라인 밑에 콘솔을 찍어보자. (디버깅을 돌려본다면 더 좋다.)

아래 영상을 보자.

이상한 점이 보이는가?

단한번 토큰 발행 요청에 무료 11번 오버히트가 났다.

사실 이건, 같은 행동만 여러번 반복되는것이 아니고,

Securit 내부에서 Scope 를 만들고…인증정보만들고…client 의 각항목을 체크하고.. 권한만들고.. 하면서 나오는 현상인데

사실 우리에게는 매우 불필요하고, SQL 에게도 미안한 행동이다.

이부분을 개선시켜보자.

@Cacheable

사실 앞에서 거창하게 이야기 했지만 복잡한게 아니고 어노테이션 두개면 끝난다.

먼저 maven 에 spring-boot-starter-cache 를 추가 해 주자.

<dependencies>
    <!-- more... -->

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>

    <!-- more.. -->
</dependencies>

다음 메인 클래스에서 @EnableCaching 를 선언 해주자.

// ...
@EnableCaching
@SpringBootApplication
public class SecurityApplication {
    //...
}

ClientDetailsServiceImpl 의 loadByClientByClientId 에다 캐시 처리를 해주면 된다.

ClientDetailsServiceImpl.java

public class ClientDetailsServiceImpl implements ClientDetailsService {

    // ...

    @Cacheable("oauth2-load-client") // new
    public ClientDetails loadClientByClientId(String clientId) throws ClientRegistrationException {
        // ...
    }
}

이제 테스트를 해보자.

이게 끝이다!!! :) happy~

[SPRING] Spring Security 사용하기 #11

2019-05-26T00:00:00+00:00

AuthenticationManager 를 사용하여, 원하는 시점에 로그인을 해보자.

지금은 항상 어떤 로그인이든지, POST /login 경로에서만 로그인이 되었었다.

AuthenticationManager 를 이용하여, 원하는 시점에 로그인이 될 수 있도록 바꿔보자.

먼저, AuthenticationManager 를 외부에서 사용 하기 위해, AuthenticationManagerBean 을 이용하여 Sprint Securtiy 밖으로 AuthenticationManager 빼 내야 한다.

WebSecurityConfig.java

public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    // ...

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // ...
        http
            .requestMatchers()
            .mvcMatchers("/login/**", "/logout/**", "/private/**", "/admin/**", "/", "/profile/**", "/my-login") // /my-login 을 시큐리티 관리포인트에 추가하였다.
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
}

이제 AuthenticationManager 를 밖에서 사용 할 수 있다.

이렇게 하지 않으면 AuthenticationManager 를 injection 할 수 없다. 위 메서드를 주석 처리하고, 컨트롤러에서 AutehtnciationManager 를 @Autowired 하면 컴파일 에러가 난다.

이제 SecurityController 에서 AuthenticationManager 를 inject 하고 /my-login 이라는 경로를 만들자.

SecurityController.java

@RequiredArgsConstructor // add lombok inject
public class SecurityController {

    private final AuthenticationManager authenticationManager; // @Autowired

    // ...

    @PostMapping(value = "/my-login")
    public String customLoginProcess(
            @RequestParam String username,
            @RequestParam String password
    ) {

        // 아이디와 패스워드로, Security 가 알아 볼 수 있는 token 객체로 변경한다.
        UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(username, password);

        // AuthenticationManager 에 token 을 넘기면 UserDetailsService 가 받아 처리하도록 한다.
        Authentication authentication = authenticationManager.authenticate(token);

        // 실제 SecurityContext 에 authentication 정보를 등록한다.
        SecurityContextHolder.getContext().setAuthentication(authentication);

        // 그외
        return "redirect:/";
    }
}

이제 로그인 페이지에서, /login 으로 form 전송을 보내었던 url 을 /my-login 으로 바꿔보자.

templates/login.html

<form th:action="@{/my-login}" th:method="post">
  <!-- form.... -->
</form>

이제 서버를 부팅 후 loginfrom 에서 로그인 을 한 후, 개인페이지로 들어가면 접근 이 잘 되는 것을 알 수 있다.

다음으로, 정상적으로, 로그인 처리가 되지 않았을 때, Exception 처리를 해보자.

AuthenticationManager 의 authenticate 은 UserDetails 컨텍스트가 내부적으로 잘못 되었다고 판단 되었을 경우,

AuthenticationException 을 throw 하도록 되어있고, AuthenticationException 은 다음 주요 Exception 구현체를 가지고 있다.

DisabledException
LockedException
BadCredentialsException
UsernameNotFoundException

그리고 이중에 UserDetailsServiceImpl throw 했던 UsernameNotFoundException 은 BadCredentialsException 을 호출 하도록 되어있다.

- UsernameNotFoundException
    - DaoAuthenticationProvider
        - AbstractUserDetailsAuthenticationProvider
            - BadCredentialsException

순으로 들어가게 되어 기본적으로 BadCredentialsException 을 호출 하게 되는것이다.

이제 코딩을 해보자.

SecurityController.java

@RequiredArgsConstructor // add lombok inject
public class SecurityController {

    private final AuthenticationManager authenticationManager; // @Autowired

    // ...

    @PostMapping(value = "/my-login")
    public String customLoginProcess(
            @RequestParam String username,
            @RequestParam String password
    ) {
       // 아이디와 패스워드로, Security 가 알아 볼 수 있는 token 객체로 변경한다.
        UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(username, password);
        try {
            // AuthenticationManager 에 token 을 넘기면 UserDetailsService 가 받아 처리하도록 한다.
            Authentication authentication = authenticationManager.authenticate(token);
            // 실제 SecurityContext 에 authentication 정보를 등록한다.
            SecurityContextHolder.getContext().setAuthentication(authentication);
        } catch (DisabledException | LockedException | BadCredentialsException e) {
            String status;
            if (e.getClass().equals(BadCredentialsException.class)) {
                status = "invalid-password";
            } else if (e.getClass().equals(DisabledException.class)) {
                status = "locked";
            } else if (e.getClass().equals(LockedException.class)) {
                status = "disable";
            } else {
                status = "unknown";
            }
            return "redirect:/login?flag=" + status;
        }
        return "redirect:/";
    }
}

각각 throw 된 Exceptino 을 분류 해서, status 파라미터를 나누도록 하였다.

이렇게, authenticationManager 를 이용하여 로그인 프로세스를 커스터마이징 해 보았다.

[SPRING] Spring Security 사용하기 #10

2019-05-25T00:00:00+00:00

source: https://github.com/ziponia/spring-security-example

이번에는 Security Principal 객체를 커스터마이징 해보자.

기존에 로그인 하게 되면 기본적으로 spring security context

package org.springframework.security.core.userdetails.UserDetails; 를 구현하는것이며,

가장 첫 포스트에서 만든 security context 객체 는

Security 의 UserDetails 를 사용하기 쉽게 미리 만들어 둔, UserDetails 의 구현 객체인 User org.springframework.security.core.userdetails.User 객체이다.

이 User 객체를 살펴보게 되면 다음과 같이 생성자가 두개 미리 생성되어있다.

public class User implements UserDetails, CredentialsContainer {
    public User(String username, String password,
			Collection<? extends GrantedAuthority> authorities) {
		// ...
	}

    public User(String username, String password, boolean enabled,
			boolean accountNonExpired, boolean credentialsNonExpired,
			boolean accountNonLocked, Collection<? extends GrantedAuthority> authorities) {

		// ...
	}
}

하나는 단순하게 아이디, 비밀번호, 권한을 생성하는 컨스트럭터이고,

다른 하나는 아이디, 비밀번호, 사용가능여부, 만료여부, 비밀번호가 만려되었는지, 잠겨있는지, 권한 을 생성하는 객체이다.

아이디, 비밀번호, 권한 을 제외하고는 설정하지 않으면 기본적으로 true 이다.

그런데, 왼지 컨텍스트에 위에 정보들만 가지고 다니기 좀 꺼림칙 하다.

예를들면, 우리의 서비스는 임대형이고, 각 페이지를 돌아다니면서 각각 사용자의 맞는 리소스를 가지고 오려면 위의 컨텍스트 객체의 username 을 가지고 온 다음,

DB 에서 username 에 대한 유저 객체를 조회하고, 조회한 유저 객체가 속한 그룹 정보를 가지고 와야 한다.

더 좋은 방법도 있겠지만, 설득을 위해 조금 억지를 부려 보았다. 납득하자.

이걸 security context 에서 바로 해당 유저의 그룹 정보가 ‘미리’ 담겨 있다면, 왼지 더 심플 해 질 것 같다.

예시를 보자.

먼저 사용자가 속한 그룹을 만들자.

GroupEntity.java

package ziponia.spring.security;

import lombok.Getter;
import lombok.Setter;
import org.hibernate.annotations.CreationTimestamp;
import org.hibernate.annotations.UpdateTimestamp;

import javax.persistence.*;
import java.util.Collection;
import java.util.Date;

@Entity
@Getter
@Setter
@Table(name = "tbl_group")
public class GroupEntity {

    @Id
    @GeneratedValue
    private Integer idx;

    private String groupName;

    @OneToMany(mappedBy = "group")
    private Collection<UserEntity> users;

    @CreationTimestamp
    private Date createTime;

    @UpdateTimestamp
    private Date updateTime;
}

그리고 tbl_user 에 group 을 추가하자.

UserEntity.java

public class UserEntity {

    // ...

    @ManyToOne(fetch = FetchType.LAZY)
    private GroupEntity group;
}

GroupEntity 와 UserEntity 는 1:n 양방향 관계로 설정하고, LAZY 로딩을 채택 하였다.

이제 import.sql 구문에 기본 group 을 만들고, user 테이블에 해당 그룹을 설정하겠다.

import.sql

insert into tbl_group (idx, group_name, create_time) values (1, '제프컴퍼니', current_timestamp());
insert into tbl_users (idx, username, password, nick_name, group_idx) values (1, 'user', '{bcrypt}$2a$10$Wyc.IrbO.bqraF58565Yde6J6heWdARvbDUKfaQYr9v/IoHcQ1RlK', '제프', 1);
insert into tbl_users (idx, username, password, nick_name, group_idx) values (2, 'admin', '{bcrypt}$2a$10$Wyc.IrbO.bqraF58565Yde6J6heWdARvbDUKfaQYr9v/IoHcQ1RlK', '블로그 관리자', 1);
insert into tbl_oauth_client (idx, authorities, auto_approve, client_id, client_secret, grant_types, redirect_uri, scope, user_entity_idx) values (1, 'CLIENT', false, 'client', '{bcrypt}$2a$10$cxEU57mmmEm9FfhAJBMW7ec9oG4Y5Uq4Os8CfpxoL6TLzxPCCqzXK', 'client_credentials,authorization_code,refresh_token,password', 'http://localhost:4000/api/callback', 'read,basic,profile', 1);

tbl_group 에 1번 레코드에 ‘제프컴퍼니’ 라는 그룹을 추가하고, user 계정 group 에 제프컴퍼니를 추가 해 주었다.

스크립트 상으로, tbl_group 이 tbl_user 보다 먼저 올라와야 한다.

이제 UserController 에서 유저 그룹 정보를 가지고 오는 GET /profile/group 를 만들고, 그룹정보를 가지고 오자.

UserController.java

public class UserController {

    //...

    @PersistenceContext
    private EntityManager em; // JPA

    @GetMapping(value = "/profile/group")
    @PreAuthorize("isAuthenticated()")
    public String myGroup(
            @AuthenticationPrincipal Authentication authentication,
            Model model
    ) {
        // user 정보를 가지고 온다.
        UserEntity user = em.createQuery("select u from UserEntity u where u.username = :username", UserEntity.class)
                .setParameter("username", authentication.getName()).getSingleResult();

        // group 정보를 가지고 온다.
        GroupEntity group = em.createQuery("select g from GroupEntity g where g.idx = :idx", GroupEntity.class)
                .setParameter("idx", user.getGroup().getIdx()).getSingleResult();

        model.addAttribute("group", group);

        return "user_group";
    }
}

이제 user_group 페이지를 만들고 네비게이션 메뉴에 추가하자.

templates/user_group.html

<template
  xmlns:th="http://www.thymeleaf.org"
  xmlns:layout="http://www.ultraq.net.nz/thymeleaf/layout"
  layout:decorator="layout/layout"
  th:remove="tag"
>
  <th:block layout:fragment="contents">
    <h1>제 그룹은 [[ ${group.groupName} ]] 입니다.</h1>
  </th:block>
</template>

templates/layout/navigation.html

<template
  xmlns:th="http://www.thymeleaf.org"
  xmlns:layout="http://www.ultraq.net.nz/thymeleaf/layout"
  th:remove="tag"
>
  <th:block layout:fragment="navigation">
    <nav class="navbar navbar-default">
      <ul class="nav navbar-nav">
        <li><a th:href="@{/}">홈</a></li>
        <li><a th:href="@{/admin}">관리자 페이지</a></li>
        <li><a th:href="@{/private}">개인 페이지</a></li>
        <li><a th:href="@{/profile}">유저 검색 페이지</a></li>
        <!-- new -->
        <li><a th:href="@{/profile/group}">내 그룹 관리</a></li>
        <li>
          <a href="javascript: void(0);" onclick="document.getElementById('logout-form').submit()">
            로그아웃
          </a>
        </li>
      </ul>
    </nav>
    <form id="logout-form" th:action="@{/logout}" method="post"></form>
  </th:block>
</template>

이제 http://localhost:8080/profile/group 로 들어 가 보면 아래 페이지를 볼 수 있을 것이다.

근데 문제가 있다.

컨트롤러를 살펴 보면

// user 정보를 가지고 온다.
UserEntity user = em.createQuery("select u from UserEntity u where u.username = :username", UserEntity.class)
        .setParameter("username", authentication.getName()).getSingleResult();

// group 정보를 가지고 온다.
GroupEntity group = em.createQuery("select g from GroupEntity g where g.idx = :idx", GroupEntity.class)
        .setParameter("idx", user.getGroup().getIdx()).getSingleResult();

user 정보를 가져와, 유저가 가지고 있는 group의 fk 값을 조회하고, 조회 한 fk 값으로 group 정보를 조회하는 쿼리가 2개 인 것이다.

이 부분을 개선하기 위해, SecurityContext 에 저장 될 Context 객체를 수정 해보자.

먼저 Security 의 User 객체를 상속 할 CustomUserDetail 객체를 만들자.

CustomUserDetail.java

package ziponia.spring.security;

public class CustomUserDetail {
}

그리고 이 객체는 User 객체를 상속한다.

public class CustomUserDetail extends User {

    public CustomUserDetail(String username, String password, Collection<? extends GrantedAuthority> authorities) {
        super(username, password, authorities);
    }
}

Security User 의 username 과 password 와 authorities 만 가지고 있는 컨스트럭터를 상속하였다.

그리고 group 아이디 필드를 만들자

public class CustomUserDetail extends User {

    private Integer groupIdx;

    public CustomUserDetail(String username, String password, Collection<? extends GrantedAuthority> authorities, Integer groupIdx) {
        super(username, password, authorities);
        this.groupIdx = groupIdx;
    }

    public Integer getGroupIdx() {
        return groupIdx;
    }
}

컨스트럭터의 4번째 인자값으로, groupIdx 를 넣고, 멤버변수에 groupIdx 로 집어 넣어 준 다음, getter 를 만들었다.

이제 UserDetailsServiceImpl 에서 new User(…) 를 우리가 만든 CustomUserDetail 로 변경하자.

UserDetailsServiceImpl.java

public class UserDetailsServiceImpl implements UserDetailsService {

    // ... some

    @Override
    public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {

        // ... some

        return new CustomUserDetail(userEntity.getUsername(), userEntity.getPassword(), authorities, userEntity.getGroup().getIdx());
    }
}

마지막으로 UserController 에서 /profile/group 에 들어있는 Authentication 객체를 CustomUserDetail 로 변경 하고, 기존에 userEntity 를 가지고 오는 객체를 주석 처리 해주면, 쿼리 한번으로 그룹을 조회 할 수 있다.

UserController.java

public class UserController {

    // ...

    @GetMapping(value = "/profile/group")
    @PreAuthorize("isAuthenticated()")
    public String myGroup(
            // Authentication -> CustomUserDetail
            @AuthenticationPrincipal CustomUserDetail authentication
            Model model
    ) {
        // user 정보를 가지고 온다.
        /*UserEntity user = em.createQuery("select u from UserEntity u where u.username = :username", UserEntity.class)
                .setParameter("username", authentication.getName()).getSingleResult();*/

        // group 정보를 가지고 온다.
        GroupEntity group = em.createQuery("select g from GroupEntity g where g.idx = :idx", GroupEntity.class)
                .setParameter("idx", authentication.getGroupIdx()).getSingleResult();

        model.addAttribute("group", group);

        return "user_group";
    }
}

만약에 서버 부팅 후 에러가 난다면, 홈으로 가서 로그아웃 후 다시 접속 하자. SecurityContext 에 groupIdx 가 담기지 안은 상태로, 컨텍스트 객체가 만들어 지지 않아서 생기는 문제이다.

이렇게 SecurityContext 객체를 입맛대로 수정 해 보았다.

이제 입맛대로 다른 정보들도 관리 해보자.

[SPRING] Spring Security 사용하기 #9

2019-05-24T00:00:00+00:00

@PreAuthorize 와 @PostAuthorize 에 대해서 알아보자.

오늘 할일

현재까지 우리 프로젝트는 접근관리를, configuration 으로 관리했다.

WebSecurityConfig 파일을 보자

WebSecurityConfig.java

public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    // ...
    @Override
    protected void configure(HttpSecurity http) throws Exception {

        http
            .requestMatchers()
            .mvcMatchers("/login/**", "/logout/**", "/private/**", "/admin/**", "/")
            .and()
            .authorizeRequests()
                .antMatchers("/private/**").hasAnyRole("USER")
                .antMatchers("/admin/**").hasAnyRole("ADMIN")
        // ...
    }
}

private/ 경로에응 ROLE_USER 를 가지고 있는 user 만 접근가능하고, /admin 경로는 ROLE_ADMIN 경로만 가지고 있는 사람만 접근 가능하다.

하지만, 항상 url 패턴으로 상세하게 관리하기는 조금 버거운 면이 있다.

이런 시나리오를 생각 해 보자.

zef 라는 유저가 글을 썻다.
zipo 라는 유저가 zef 의 글을 수정한다.

일반 게시판의 위에 시나리오대로 한다면, 누구든지 말이 안되는 것을 인지 하면서도, 시큐리티 입장에서는 허용가능하다.

zef 라는 user 도 USER 역할을 하고있고, zipo 라는 유저도 수정 할 수 있다는 것이다.

코드로 한번 알아보자.

먼저 tbl_user 테이블에 nickname 이라고 만들고, sql 에 nickname 을 추가해보자.

UserEntity.java

public class UserEntity {
    // ...

    private String nickName;

    // ...
}

insert into tbl_users (idx, username, password, nick_name) values (1, 'user', '{bcrypt}$2a$10$Wyc.IrbO.bqraF58565Yde6J6heWdARvbDUKfaQYr9v/IoHcQ1RlK', '제프');
insert into tbl_users (idx, username, password, nick_name) values (2, 'admin', '{bcrypt}$2a$10$Wyc.IrbO.bqraF58565Yde6J6heWdARvbDUKfaQYr9v/IoHcQ1RlK', '블로그 관리자');
insert into tbl_oauth_client (idx, authorities, auto_approve, client_id, client_secret, grant_types, redirect_uri, scope, user_entity_idx) values (1, 'CLIENT', false, 'client', '{bcrypt}$2a$10$cxEU57mmmEm9FfhAJBMW7ec9oG4Y5Uq4Os8CfpxoL6TLzxPCCqzXK', 'client_credentials,authorization_code,refresh_token,password', 'http://localhost:4000/api/callback', 'read,basic,profile', 1);

sql 에 nick_name 부분을 추가하고, value 에다 user 는 제프, admin 은 블로그 관리자 라는 닉네임을 주었다.

다음으로, UserController 를 만들자.

package ziponia.spring.security;

import lombok.RequiredArgsConstructor;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
@RequiredArgsConstructor
public class UserController {

    private final UserRepository userRepository;

    @GetMapping(value = "/profile")
    public String userProfilePage(
            @RequestParam(required = false) String username,
            Model model
    ) {
        UserEntity user = null;

        if (username != null) {
            user = userRepository.findByUsername(username);
        }

        model.addAttribute("user", user);
        return "profile";
    }

    @PostMapping(value = "/profile/update")
    public String userProfileUpdate(UserEntity entity) {
        UserEntity findUser = userRepository.findByUsername(entity.getUsername());
        findUser.setNickName(entity.getNickName());
        userRepository.save(findUser);
        return "redirect:/profile?username=" + findUser.getUsername();
    }
}

username 을 받아, 유저를 검색하고, /profile/update 로 nickname 을 수정 하는 컨트롤러를 만들었다.

이제 profile 화면을 만들자.

profiile.html

<html xmlns:th="http://www.thymeleaf.org"
      xmlns:layout="http://www.ultraq.net.nz/thymeleaf/layout"
      layout:decorator="layout/layout">

<th:block layout:fragment="contents">
    <div class="row">
        <div class="col-md-6">
            <form action="#" th:action="@{/profile}" method="get" class="form-group block">
                <input type="search" name="username" class="form-control" placeholder="찾으시려는 유저를 검색 해주세요." th:value="${#request.getParameter('username')}">
            </form>
        </div>
    </div>

    <h1 th:if="${#request.getParameter('username') == '' and user == null}">
        유저를 찾을 수 없습니다.
    </h1>

    <template th:if="${user != null}" th:remove="tag">
        <h1 th:inline="text">
            [[ ${user.nickName} ]] 님 의 프로필 입니다
        </h1>

        <form action="#" th:object="${user}" th:action="@{/profile/update}" method="post" class="form-group">
            <input type="hidden" th:field="*{username}"/>
            <label th:for="${user.nickName}" class="control-label">
                닉네임
                <input type="text" th:field="*{nickName}" class="form-control"/>
            </label>
            <button type="submit" class="btn btn-primary">수정하기</button>
        </form>
    </template>
</th:block>

</html>

마지막으로, 네비게이션 메뉴에 /profile 경로를 추가하자.

navigation.html

<html xmlns:th="http://www.thymeleaf.org" xmlns:layout="http://www.ultraq.net.nz/thymeleaf/layout">
  <th:block layout:fragment="navigation">
    <nav class="navbar navbar-default">
      <ul class="nav navbar-nav">
        <li><a th:href="@{/}">홈</a></li>
        <li><a th:href="@{/admin}">관리자 페이지</a></li>
        <li><a th:href="@{/private}">개인 페이지</a></li>
        <!-- 여기 -->
        <li><a th:href="@{/profile}">유저 검색 페이지</a></li>
        <li>
          <a href="javascript: void(0);" onclick="document.getElementById('logout-form').submit()">
            로그아웃
          </a>
        </li>
      </ul>
    </nav>
    <form id="logout-form" th:action="@{/logout}" method="post"></form>
  </th:block>
</html>

이제 서버를 부팅하고 http://localhost:8080/profile 로가서 user 를 검색한 후, 닉네임을 수정해보자.

잘된다..

하지만 누구나 알것이다 잘되면 안된다.

로그인도 하지않았고, user 로 로그인 하더라도, admin 닉네임은 수정해서는 안된다.

자, 이제 configuration 은 건드리지 않고, 메서드 별로 처리 해보자.

main application 에서 다음과 같은 어노테이션을 추가하자.

SecurityApplication.java

@SpringBootApplication
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityApplication {
    // ... more..
}

다음으로, userController 에 /profile/update 부분에 다음과 같이 추가하자.

UserController.java

public class UserController {

    // ...

    @PostMapping(value = "/profile/update")
    @PreAuthorize("isAuthenticated() and #entity.username == authentication.principal.username") // <-- here
    public String userProfileUpdate(UserEntity entity) {
        UserEntity findUser = userRepository.findByUsername(entity.getUsername());
        findUser.setNickName(entity.getNickName());
        userRepository.save(findUser);
        return "redirect:/profile?username=" + findUser.getUsername();
    }
}

마지막으로, 접근 거부 창을 띄우기 위해 SecurityController 에 /access_denied 경로를 다음과 같이 변경하자.

SecurityController.java

public class SecurityController {
    // ... more

    //@GetMapping(value = "/access_denied")
    @RequestMapping(value = "/access_denied") // 모든 http method 를 허용했다.
    public String access_denied_page() {
        return "access_denied";
    }
}

이제 다시 요청 해보자.

최종 결과

@PostAuthorize 와 @PreAuthorize 의 차이점은,

메서드를 실행 한 후, 와 메서드 실행 전 의 차이이다.

@PreAuthorize 를 @PostAuthorize 로 변경 한 다음, 메서드 은에 콘솔을 찍어 보자.

[SPRING] Spring Security 사용하기 #8

2019-05-23T00:00:00+00:00

토큰 type 을 jwt 로 변경 해보자.

기존에 인증은, Resource server 가 요청을 받을 때마다, Authorization Server 에게 확인 하는 방식이다.

쉽게 대화형식으로 따지자면…

User - U
ResourceServer - R
AuthorizationServer - A

U - 토큰 발급 부탁드립니다.
A - 여기 토큰나왔습니다.
U - R 님 /api/private 에 대한 리소스를 주세요. (토큰을 건냄)
R - 기달려주세요
R - A 님 여기 토큰(유저가 건넨) 이 사용 가능 한 토큰인가요?
A - 네 사용가능합니다.
R - U 님 A 에게 확인 받았고, 여기 리소스가 있습니다. /api/private 을 건넴

식이다.

매번 요청 할때마다, 지속적으로 검시하므로, AuthorizationServer 에게 부담 일수밖에 없다.

jwt 토큰은 이러한 점을 좀 개선시켰다. token 자체를 인증정보로 나타냈기 때문이다.

이걸 대화형으로 한다면

User - U
ResourceServer - R
AuthorizationServer - A

U - 토큰 발급 부탁드립니다.
A - 여기 토큰나왔습니다.
U - R 님 /api/private 에 대한 리소스를 주세요. (토큰을 건냄)
R - (사전에 A와 규칙을 정한) 토큰이 맞군요! 여기 리소스가 있습니다.

라는 식이다.

조금 웃기긴 하지만, 얼추 비슷하니 재밌게 참조하자.

이제 실제로 코드로 구현 해보겠다.

먼저, AuthorizationServer Config 에 기본 토큰을 담아낼 store 를 만들자.

AuthorizationServerConfig.java

@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {

    // ...

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        super.configure(endpoints);
        endpoints.accessTokenConverter(jwtAccessTokenConverter());
    }

    @Bean
    public JwtAccessTokenConverter jwtAccessTokenConverter() {
        return new JwtAccessTokenConverter();
    }
}

JwtAccessTokenConverter 가 token 을 jwt 형식으로 교환해주고, AuthorizationServerEndpointsConfigurer 에 totkenConverter 를 주입 해주었다.

그럼 토큰 발급시 다음과 같이 변경 되었을 것이다.

다음으로, AuthorizeEndpointController 의 /oauth/confirm_access 를 다음과 같이 바꿔주자.

AuthorizeEndpointController.java

public class AuthorizeEndpointController {

    @SuppressWarnings("unchecked")
    @GetMapping(value = "/oauth/confirm_access")
    public String authorizeConfirmPage(HttpServletRequest request, Model model) {
//        Map<String, Boolean> scopes = (HashMap<String, Boolean>) request.getAttribute("scopes"); remove
        String[] scopes = request.getAttribute("scope").toString().split(" "); // <- here
        model.addAttribute("scopes", scopes);
        return "authorize_confirm";
    }
}

jwt 로 변경하면, 가지고 오는 scope 이름이 scopes 가 scope 로 바뀐다. (사실 이부분은 왜 틀린지 모르겠다..)

view 파일도 form 태그 쪽을 살짝 변경 해주자.

authorize_confirm.html

<!-- before... -->
<form action="#" th:action="@{/oauth/authorize}" th:object="${scopes}" th:method="post">
  <input type="hidden" name="user_oauth_approval" value="true" />
  <h4
    th:text="|${#request.getParameter('client_id')} 에서 회원님에 대한 아래와 같은 정보를 요청합니다|"
  ></h4>
  <div th:each="scope : ${scopes}">
    <label th:for="${scope}" th:text="${scope}">scope.read</label>
    <input type="checkbox" th:id="${scope}" th:name="${scope}" th:value="true" />
  </div>
  <div>
    <button type="submit">동의하기</button>
  </div>
</form>

<!-- after... -->

이제 토큰을 받아보자. 아마 조금 더 길어진 토큰을 볼 수 있을것이다.

토큰을 복사해서 https://jwt.io/ 에 붙혀넣으면 토큰에 대한 정보를 볼 수 있다.

jwt 토큰 키 설정 하기

하나 문제가 있다. 서버를 재부팅 하고, 기존 토큰을 그대로 요청을 해보자.

정상적으로 요청이 안되는 것을 볼 수 있다.

따라서, 이 상태로 서비스를 하려면, 서버가 재부팅 될 때, 우리의 서비스를 사용 하고 있는 사람들 에게 토큰을 다시 받으라고 공지 해야한다.

이게 얼마나 비효율적인 일인지 알 것이다.

왜 이런일이 일어나는가?

토큰을 받게 되면, 우리가 가져 온 토큰정보는, Security context 안에 저장이 된다.

따라서, memory 저장 방식인 것이다.

이는, 서버가 재부팅 될 때, 저장 공간이 갱신 되기 떄문이다.

다음 코드를 추가 해 보자. /oauth/token_key 로 들어 가 보자.

AuthorizationServerConfig.java

public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
    //...
    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        super.configure(security);
        security
                .tokenKeyAccess("isAuthenticated()") // <- here
                .allowFormAuthenticationForClients();
    }
    //...
}

이제 다음 URL 로 들어 가 보자.

http://localhost:8080/oauth/token_key

confirm 창이 나오면 client id 와 client secret 를 넣으면 된다.

그럼 화면상에 다음 과 비슷한 데이터가 나올 것이다.

{ "alg": "HMACSHA256", "value": "Sp3P55" }

서버를 재부팅 하고 다시 들어 가보자.

아마도, value 값이 변할 것이다.

{ "alg": "HMACSHA256", "value": "AM1juH" }

서버를 재부팅 하게 되면, 토큰의 알고리즘 자체가 바뀌게 되어, 기존 토큰으로는 인증이 안된다.

따라서, 우리는 서버가 용납(?) 할 수 있는 키를 만들어야 한다.

적당한 폴더에 다음과 같이 입력 해보자

keytool 이 설치 되어있다는 가정에 따른다. java 가 설치되어있으면, 왼만하면, 동작한다.

PS C:\keys> keytool -genkey -alias jwt -keyalg RSA -keystore jwtkey.jks -keysize 2048
키 저장소 비밀번호 입력:
새 비밀번호 다시 입력:
이름과 성을 입력하십시오.
  [Unknown]:  zef
조직 단위 이름을 입력하십시오.
  [Unknown]:  zef
조직 이름을 입력하십시오.
  [Unknown]:  zef
구/군/시 이름을 입력하십시오?
  [Unknown]:  Seoul
시/도 이름을 입력하십시오.
  [Unknown]:  Seoul
이 조직의 두 자리 국가 코드를 입력하십시오.
  [Unknown]:  KR
CN=zef, OU=zef, O=zef, L=Seoul, ST=Seoul, C=KR이(가) 맞습니까?
  [아니오]:  예

<jwt>에 대한 키 비밀번호를 입력하십시오.
        (키 저장소 비밀번호와 동일한 경우 Enter 키를 누름):

Warning:
JKS 키 저장소는 고유 형식을 사용합니다. "keytool -importkeystore -srckeystore jwtkey.jks -destkeystore jwtkey.jks -deststoretype pkcs12"를 사용하는 산업 표준 형식인 PKCS12로 이전하는 것이 좋습니다.

난 window 환경이라, powershell 로 실행하였다. 명령 행에 따라, 맞춰 쓰면 된다.

위처럼 하였다면, 폴더 안에 jwtkey.jks 라는 파일이 생성 되었을 것이다. 해당 파일을 프로젝트의 classpath (resource) 로 이동 시키자.

이 행동은, 실제 서비스에서는 하지 않는다. key 는 보안규칙에 따라 관리 되어야 한다. (환경변수 등) 여기서는 포스트 용도로 공개한다.

{projectRoot}/src/main/resource/jwtkey.jks

이제 AuthorizationServerConfig 에 jwtAccessTokenConverter 를 다음처럼 변경 해주자.

public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
    //...
    @Bean
    public JwtAccessTokenConverter jwtAccessTokenConverter() {
        String keyPassword = "123456", alias = "jwt", keyFile = "jwtkey.jks";
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        KeyPair keyPair = new KeyStoreKeyFactory(new ClassPathResource(keyFile), keyPassword.toCharArray())
                .getKeyPair(alias, keyPassword.toCharArray());
        converter.setKeyPair(keyPair);
        return converter;
    }
    //...
}

포스트 내용과 똑같이 만들었다면, 위와 같이 설정하면 되고, 아니라면, 각자 환경에 맞게 셋팅하면 된다.

패스워드는 포스팅 용도로 123456 으로 만들었다 실제서비스에서는 당연히 이렇게 하면 안된다.

이제 다시 http://localhost:8080/oauth/token_key 로 들어가 보자.

아까와 조금 다른 값들이 나올것이다.

{
  "alg": "SHA256withRSA",
  "value": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAg14zVmL/2S8xn23iW88vC0l+4PQyWEbYYLgx5phjMbvy8ay/VWyl8SPbZf759t6uG330IWe69gJNs+UNXPnhC8MZ5OxEYzpiUd7IiHVKS+oJRvZPS+F82fS9pWXX0dHtxo1dG/K+IApvumzUFczpmpXHw81RFaZak9hu4u+IkOdYwc5EKPBbN3OHZfKmWJhUtklsncHA8Xm+59P9lokYBBwLgD34RBAASAyNBl02l/kPuWXVtYNktgOiFeARf7hsMV890MG7SSGNjDltbdP51ET0ASGEXX9xYnNBdxfwlLoQYPBVJgdfc18dEuBjPXFpvYIpGKkAuxamPq/q6sFBrQIDAQAB\n-----END PUBLIC KEY-----"
}

이제 다시 토큰을 발급 받은 후, 서버를 재부팅하고 api 요청을 해보자.

성공적으로 재부팅 후에도 토큰이 유효성을 가질 수 있게 되었다.

source https://github.com/ziponia/spring-security-example

[SPRING] Spring Security 사용하기 #7

2019-05-22T00:00:00+00:00

지난포스팅 에서는 Client 를 메모리에 생성하고, access token 을 받아, api 로 접근하는 부분까지 해보았다.

이렇게 클라이언트를 memory 로 관리 할 수도있지만, 사실 이렇게 하면, 새로운 client 가 추가 될 때 마다, 서버를 다시 배포 해 주어야 한다.

오늘은 client 와 DB 를 연결하여, 관리자가 직접 client 를 추가하고, 관리하는 부분까지 해보자.

client db 생성

먼저 클라이언트 DB 를 생성 하도록 해보자.

이전에 WebSecurity 의 UserDetails 를 보면,

UserDetails 가 Security 에 등록 될 Context 객체가 되고, UserDetailsService 가 UserDetails 를 생성하기 위한 부분을 처리 하였다.

client 는 User 를 Client 로 변경 해주기만 하면된다.

먼저 ClientDetails 를 구현 해 보자.

특정 user 가 다수의 client 를 가질 수 있다는 것을 염두하고 하자.

한마디로, user : client 는 1 : N 관계이다.

먼저 테이블을 만들자.

ClientEntity.java

package ziponia.spring.security;

import lombok.Getter;
import lombok.Setter;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.oauth2.provider.ClientDetails;

import javax.persistence.*;
import java.util.*;

@Entity
@Table(name = "tbl_oauth_client")
@Getter
@Setter
public class ClientEntity implements ClientDetails {

    @Id
    @GeneratedValue
    private Integer idx;

    @ManyToOne
    private UserEntity userEntity;

    private String clientId;
    private String resourceIds;
    private String clientSecret;
    private String scope;
    private String grantTypes;
    private String redirectUri;
    private String authorities;
    private Integer accessTokenValiditySeconds;
    private Integer refreshTokenValiditySeconds;
    private Boolean autoApprove;

    @Override
    public String getClientId() {
        return clientId;
    }

    @Override
    public Set<String> getResourceIds() {
        if (resourceIds == null) return null;
        String[] s = resourceIds.split(",");
        return new HashSet<>(Arrays.asList(s));
    }

    @Override
    public boolean isSecretRequired() {
        return clientSecret != null;
    }

    @Override
    public String getClientSecret() {
        return clientSecret;
    }

    @Override
    public boolean isScoped() {
        return scope != null;
    }

    @Override
    public Set<String> getScope() {
        if (scope == null) return null;
        String[] s = scope.split(",");
        return new HashSet<>(Arrays.asList(s));
    }

    @Override
    public Set<String> getAuthorizedGrantTypes() {
        if (grantTypes == null) return null;
        String[] s = grantTypes.split(",");
        return new HashSet<>(Arrays.asList(s));
    }

    @Override
    public Set<String> getRegisteredRedirectUri() {
        if (redirectUri == null) return null;
        String[] s = redirectUri.split(",");
        return new HashSet<>(Arrays.asList(s));
    }

    @Override
    public Collection<GrantedAuthority> getAuthorities() {
        if (authorities == null) return new ArrayList<>();
        return AuthorityUtils.createAuthorityList(authorities.split(","));
    }

    @Override
    public Integer getAccessTokenValiditySeconds() {
        return accessTokenValiditySeconds;
    }

    @Override
    public Integer getRefreshTokenValiditySeconds() {
        return refreshTokenValiditySeconds;
    }

    @Override
    public boolean isAutoApprove(String scope) {
        return autoApprove;
    }

    @Override
    public Map<String, Object> getAdditionalInformation() {
        return null;
    }
}

ClientDetails 구현체로 만들고, userEntity 와 하이버네이트 등록을 위해 @Id 까지 넣어주었다.

다음으로 client 를 DB 에서 조회 하기 위해, JPA Repository 를 만든다.

OAuth2ClientRepository.java

package ziponia.spring.security;

import org.springframework.data.jpa.repository.JpaRepository;

public interface OAuth2ClientRepository extends JpaRepository<ClientEntity, Integer> {

    ClientEntity findByClientId(String clientId);
}

이어서, ClientDetailsService 를 구현하자, UserDetailsService 와 비슷한 개념으로 생각하면 된다.

ClientDetailsServiceImpl.java

package ziponia.spring.security;

import lombok.extern.java.Log;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.oauth2.provider.ClientDetails;
import org.springframework.security.oauth2.provider.ClientDetailsService;
import org.springframework.security.oauth2.provider.ClientRegistrationException;
import org.springframework.security.oauth2.provider.client.BaseClientDetails;
import org.springframework.transaction.annotation.Transactional;

public class ClientDetailsServiceImpl implements ClientDetailsService {

    @Autowired
    private OAuth2ClientRepository oAuth2ClientRepository;

    @Override
    @Transactional
    public ClientDetails loadClientByClientId(String clientId) throws ClientRegistrationException {
        ClientEntity clientEntity = oAuth2ClientRepository.findByClientId(clientId);
        return new BaseClientDetails(clientEntity);
    }
}

마지막으로, AuthorizationServerConfig 에서 기존에 clients.inMemory()….. 부분을 다음처럼 변경 해주자.

AuthorizationServerConfig.java

public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {

    // ...other

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        /*clients
                .inMemory()
                .withClient("client")
                .secret(passwordEncoder.encode("secret"))
                .authorizedGrantTypes("client_credentials", "authorization_code", "refresh_token", "password")
                .authorities("CLIENT")
                .scopes("read", "basic", "profile")
                .redirectUris("http://localhost:4000/api/callback")
                .autoApprove(false);*/

        clients
                .withClientDetails(clientDetailsService());
    }
    // ...other
}

모든 설정이 끝났다.

이제 import.sql 에다 임의로, 레코드를 추가하여, 애플리케이션을 부팅 후 테스트 해보자.

import.sql

insert into tbl_users (idx, username, password) values (1, 'user', '{bcrypt}$2a$10$Wyc.IrbO.bqraF58565Yde6J6heWdARvbDUKfaQYr9v/IoHcQ1RlK');
insert into tbl_users (idx, username, password) values (2, 'admin', '{bcrypt}$2a$10$Wyc.IrbO.bqraF58565Yde6J6heWdARvbDUKfaQYr9v/IoHcQ1RlK');
insert into tbl_oauth_client (idx, authorities, auto_approve, client_id, client_secret, grant_types, redirect_uri, scope, user_entity_idx) values (1, 'CLIENT', false, 'client', '{bcrypt}$2a$10$cxEU57mmmEm9FfhAJBMW7ec9oG4Y5Uq4Os8CfpxoL6TLzxPCCqzXK', 'client_credentials,authorization_code,refresh_token,password', 'http://localhost:4000/api/callback', 'read,basic,profile', 1);

정상적으로 토큰을 받아오는것을 볼 수 있다.

화면은 이전 포스팅 한 것과 동일하니, 참조하자.

[SPRING] Spring Security 사용하기 #6

2019-05-20T00:00:00+00:00

최종 목표

지난번포스팅까지 잘 따라왔다면, 사실 조금 더 서비스에 맞는부분을 커스터마이징 해서 사용하는데 문제가 없다.

근데 이런경우라면 생각해보자.

N 사가 우리의 리소스를 사용하기 위해 회사랑 계약을 하였다.
우리는 내부 소스코드는 노출 하지 않은채, N 사에게 인터페이스만 제공 하여야 한다.
우리는 N 사에게만, 리소스를 제공 하여야 하며, 외부로 오픈되면 안된다.
사용자가 N 사를 통해서 접속 할 때, 우리가 N 사에게 허용 한 리소스만 N 사는 사용자에게 정보를 제공 할 수 있다.

사실 이것을 구현 하는일은, 쉽지 않다.

그래서, 머리 좋은 어떤 사람들이 oauth2 라는 인증 워크 플로우를 만들어 냈고, 이 기술은 표준으로 등록 되어 질 만큼 핫(?) 하다.

이 플로우를 설계 하는데 앞서, 우리는 일단 용어들을 대충이라도 알고 있어야 한다.

이전 포스팅 까지 진행했던 소셜 로그인 서비스 의 facebook 로그인을 살펴보자.

우리는 facebook 측으로 부터 client id 와 client secret 을 발급 받은적이 있다.

이것은 우리가 페이스북 서버에 접속하여, 페이스북 안에 들어있는 사용자 와 관련된 정보를 가져 올 때 사용 하는

일종에 아이디와 패스워드이다.

그리고, facebook 에서 우리 에게 주는 facebook 사용자의 정보들 이메일, 유저 프로필 사진, 아이디 등을 scope 라고 한다.

facebook 에서 발급 한, client id 와 client secret 을 가지고 페이스북에 사용자 정보 요청을 대행(?) 해 주는

우리를 클라이언트 라고 한다.

페이스북에서 우리에게 리소스 서버에 접근 권한을 주고, access_token 이라는 입장권한(?) 을 주는 서버를

Authorization server (권한 서버) 라고 한다.

실제 페이스북 안의 사용자의 리소스를 우리에게 제공해 주는 API 서버를 Resource Server (리소스 서버) 라고 한다.

우리를 통해 facebook 안에 리소스를 요청하고, 리소스의 주인이 되는 User 를 Resource Owner (리소스 주인) 라고 한다.

우리가 Resource Server 에 사용자 정보를 요청하고, 제공 받을 수 있도록 Authorization Server 가 부여 한 입장권을 access token 이라고 한다.

access token 이 유통기한(?) 이 지나, 사용 할 수 없도록 되어 진 것을 access token expired (토큰 만료) 라고 한다.

access token 을 재발급 할 수 있도록 임시로 유통기한이 긴 토큰을 refresh token 이라고 한다.

…

oauth2 에 workflow 에 대한 이미지는 구글에 oauth2 workflow 라고만 검색해도, 엄청난 정보들이 쏟아지니 참고하자.

이제 지루한 이론은 뒤로하고, security 로 구현 방법을 보자.

시큐리티 관리 분리

사전에 해야 할 일은, security 가 관여 해야 할 url 을 분리하는것이다.

RootSecurityConfig class 를 만들자

RootSecurityConfig.java

package ziponia.spring.security;

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableOAuth2Client;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;

@Configuration
@EnableOAuth2Client
@EnableWebSecurity
public class RootSecurityConfig {

    @Configuration
    public static class FormSecurityConfigAdapter extends WebSecurityConfig {}

}

기존에 WebSecurityConfig 에서 사용하던 어노테이션들을 옮기고 static class를 만들어 기존에 WebSecurityConfig 를 상속 받도록 하였다.

다음으로 WebSecurityConfig 가 관여 해야 할 path 를 지정하자.

public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .requestMatchers()
            .mvcMatchers("/login/**", "/logout/**", "/private/**", "/admin/**", "/")
            .and()

            // ... other settings....
        ;
    }
}

class 에 어노테이션들을 제거하고, http 바로 아래, requestMatchers 를 추가하였자.

"/login/**", "/logout/**", "/private/**", "/admin/**", "/" 패턴의 URL 들만 기존 시큐리티가 관리하도록 설정하였다.

반드시, 다른 설정보다 위에 있어야 한다. 그렇지 않으면, 기본으로 시큐리티가 모든 path 를 관리한다.

지정하지 않아도 문제가 된다. 한번 / 경로 를 제외 하고 / 경로에서 로그 아웃을 해보라!

Resource Server Config 생성

이제 API 를 요청 할 수 있는 Resource Server 를 생성하자

package ziponia.spring.security;

import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.oauth2.config.annotation.web.configuration.ResourceServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configurers.ResourceServerSecurityConfigurer;

public class ResourceServerConfig extends ResourceServerConfigurerAdapter {

    @Override
    public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
        super.configure(resources);
    }

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http
                .antMatcher("/api/**") // /api/** 경로 관리
                .authorizeRequests()
                .antMatchers("/api/**").hasAuthority("CLIENT");
    }
}

일단 단순 한 형태의 시큐리티 패턴만 주었다.

이제 RootSecurityConfig 에 아래 항목을 추가하자.

RootSecurityConfig

@Configuration
@EnableOAuth2Client
@EnableWebSecurity
public class RootSecurityConfig {

    @Configuration
    public static class FormSecurityConfigAdapter extends WebSecurityConfig {}

    @Configuration
    @EnableResourceServer
    public static class ApiSecurityConfigAdapter extends ResourceServerConfig {}

}

권한 서버(토큰발급 서버) 생성

이제 권한 서버를 생성하자

AuthorizationServerConfig.java

package ziponia.spring.security;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;

@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        // 기본 AuthorizationServer Security 설정은 유지 한채,
        // client 의 인증정보를 Header 가 아닌, form 으로 받을 수 있도록 한다.
        super.configure(security);
        security
                .allowFormAuthenticationForClients();
    }

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients
                .inMemory()
                .withClient("client")
                .secret(passwordEncoder.encode("secret"))
                .authorizedGrantTypes("client_credentials", "authorization_code", "refresh_token", "password")
                .authorities("CLIENT")
                .scopes("read")
                .redirectUris("http://localhost:4000/api/callback")
                .autoApprove(false);
    }

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        super.configure(endpoints);
    }
}

모든 설정이 완료되었다.

이제 postman 에서 테스트를 진행 해 보자.

정상적으로 소셜 로그인도 되고, 토큰방식의 로그인도 되는것을 볼 수 있다.

먼저 기존에 일반적인 로그인 폼이 아닌, 외부에서 제공 할 login form 을 만들자.

oauth_login.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
  <head>
    <meta charset="UTF-8" />
    <meta
      name="viewport"
      content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0"
    />
    <meta http-equiv="X-UA-Compatible" content="ie=edge" />
    <link rel="stylesheet" th:href="@{/css/main.css}" />
    <title>Document</title>
  </head>
  <body>
    <fieldset>
      <legend>제프의 로그인 시스템</legend>
      <form th:action="@{/api/login}" th:method="post">
        <input type="text" name="username" placeholder="아이디를 입력 해 주세요." />
        <br />
        <input type="password" name="password" placeholder="비밀번호를 입력 해 주세요." />
        <br />
        <button type="submit">로그인</button>
      </form>
    </fieldset>
  </body>
</html>

기존 폼에서, 문구만 제프의 로그인 이라는 문구로 변경하고 action 을 /oauth/login 으로 변경 하였다.

다음으로, AuthorizationServerSecurityConfig class 를 만들자.

AuthorizationServerSecurityConfig.java

package ziponia.spring.security;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;

public class AuthorizationServerSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserDetailsService userDetailsService;

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

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .requestMatchers()
                .mvcMatchers("/oauth/authorize/**", "/api/login")
                .and()
                .authorizeRequests()
                .antMatchers("/oauth/authorize/**").authenticated()
            .and()
                .formLogin()
                .loginPage("/api/login");
    }
}

이 클래스의 역할은, grant type : authorization_code 로 요청하면, "User must be authenticated with Spring Security before authorization can be completed."

에러가 뜨게 되는데, 기본적으로 시큐리티 컨텍스트로 인증이 된 후 요청하라는 의미 인 것 같다.

그것을 방지 하기 위한 역할이다. /oauth/authorize/ 경로로 들어오면 로그인이 되어있지 않은경우, /api/login 으로 리다이렉트 시킨다.

로그인 방식은, 기존에 구현 해 둔, UserDetailsService 를 주입 해준다.

이제 RootSecurityConfig 에서, AuthorizationServerSecurityConfig 를 등록하자.

RootSecurityConfig.java

@Configuration
@EnableOAuth2Client
@EnableWebSecurity
public class RootSecurityConfig {

    @Configuration
    public static class FormSecurityConfigAdapter extends WebSecurityConfig {}

    @Order(2)
    @Configuration
    public static class AuthorizationSecurityConfigAdapter extends AuthorizationServerSecurityConfig {}

    @Configuration
    @EnableResourceServer
    public static class ApiSecurityConfigAdapter extends ResourceServerConfig {}

}

이제 아래 URL로 접속 해서, 로그인 해보자.

http://localhost:8080/oauth/authorize
?client_id=client
&redirect_uri=http://localhost:4000/api/callback
&response_type=code

grant_type code

code 방식의 로그인을 살펴 보자.

우리가 카카오 로그인을 하게 되면, 아마 이런 페이지가 처음에 떳을 것이다.

조금씩 내용이 다를 수도있지만, 전체적으로 크게 다르지 않다.

이제 저런 화면을 만들어 볼 것이다.

이미 인증을 해서 로그인시에 위에 이미지가 안보인다면, 자신의 카카오톡의 설정 > 카카오계정 > 연결된 서비스 관리 > [그 외 카카오계정으로 로그인] 항목에 자신의 만든 앱 아이콘이 나올 것이다. 클릭 후 모든 정보 삭제 후 다시 로그인 하면된다.

다시 돌아가서, 브라우저에서 카카오 로그인을 누른 후 URL 을 보면 아래와 비슷한 URL 이 나올것이다.

https://kauth.kakao.com/oauth/authorize?client_id={CLIENT_ID}&redirect_uri=http://localhost:8080/login/kakao&response_type=code&state=5xDqcR

위에서 우리가 요청했던 URL 과 동일하게 생긴것을 볼 수 있다.

인가 페이지를 좀 더 꾸며보자.

인가 페이지를 변경하는 방법은, 그냥 Endpoint 를 오버라이딩 하면 된다고 한다.

스택 오버플로우 Dave Syer 아저씨의 답변

AuthorizeEndpointController class 를 아래처럼 만들어 주자.

AuthorizeEndpointController.java

package ziponia.spring.security;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.SessionAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;

@Controller
@SessionAttributes("authorizationRequest")
public class AuthorizeEndpointController {

    @SuppressWarnings("unchecked")
    @GetMapping(value = "/oauth/confirm_access")
    public String authorizeConfirmPage(HttpServletRequest request, Model model) {
        Map<String, Boolean> scopes = (HashMap<String, Boolean>) request.getAttribute("scopes");
        model.addAttribute("scopes", scopes);
        return "authorize_confirm";
    }
}

위 처럼 하면 scope 를 가져 올 수 있다.

이제 html 만 랜더링 해 주면 끝이다.

authorize_confirm.html

<!DOCTYPE html>
<html lang="ko" xmlns:th="http://www.thymeleaf.org">
  <head>
    <meta charset="UTF-8" />
    <meta
      name="viewport"
      content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0"
    />
    <meta http-equiv="X-UA-Compatible" content="ie=edge" />
    <title>Document</title>
    <style>
      * {
        box-sizing: border-box;
      }
      html,
      body {
        margin: 0;
        padding: 0;
      }
      .wrap {
        width: 100vw;
        height: 100vh;
        background-color: #eeeeee;
        display: flex;
        flex-direction: column;
        justify-content: center;
        align-items: center;
      }

      form {
        display: block;
        width: 600px;
        background-color: #ffffff;
        border: 1px solid #dddddd;
        padding: 20px;
      }
    </style>
  </head>
  <body>
    <div class="wrap">
      <h1>제프의 인증시스템</h1>
      <form action="#" th:action="@{/oauth/authorize}" th:object="${scopes}" th:method="post">
        <input type="hidden" name="user_oauth_approval" value="true" />
        <h4
          th:text="|${#request.getParameter('client_id')} 에서 회원님에 대한 아래와 같은 정보를 요청합니다|"
        ></h4>
        <div th:each="scope : ${scopes.keySet()}">
          <label th:for="${scope}" th:text="${scope}">scope.read</label>
          <input type="checkbox" th:id="${scope}" th:name="${scope}" th:value="true" />
        </div>
        <div>
          <button type="submit">동의하기</button>
        </div>
      </form>
    </div>
  </body>
</html>

이제 url 요청을 하고, 최종결과, parameter 로 code 가 들어온다면, 성공이다.

이제 받아 온 코드로 토큰 발급 요청을 해 보자.

POST http://localhost:8080/oauth/token
[Header]
Content-Type: application/x-www-form-urlencoded

[Params]
grant_type=authorization_code
&client_id=clinet
&clinet_secret=secret
&redirect_uri=http://localhost:4000/api/callback
&code={코드 받기에서 발급받은 code 값}

사실 카카오 로그인 하기

에서 나오는 인증 flow 와 완전히 동일하다. (같은 oauth2 인증 플로우를 사용하니…)

이제 넘어 온 코드로 토큰을 받아보자.

이제 ResourceServerConfig 에 /api/private 경로를 추가하고, 컨트롤러를 만들어 테스트 해보자.

ResourceServerConfig.java

public class ResourceServerConfig extends ResourceServerConfigurerAdapter {

    @Override
    public void configure(HttpSecurity http) throws Exception {

        http
                .requestMatchers()
                .mvcMatchers("/api/**")
                .and()
                .authorizeRequests()
                .antMatchers("/api/login").permitAll()
                .antMatchers("/api/private").hasAnyRole("USER") // here
                .antMatchers("/api/**").hasAuthority("CLIENT")
                .and()
                .formLogin()
                .loginPage("/api/login")
                .and()
        ;
    }
}

ApiController.java

@RestController
public class ApiController {

    // ...

    @GetMapping(value = "/api/private")
    public Map<String, String> privateApi() {
        Map<String, String> model = new HashMap<>();
        model.put("name", "jihoon");
        model.put("nick", "zef");
        return model;
    }

    // ...

꽤 멋진(?) 인증 시스템이 완료 되었다. 이제 외부로 client id 와 client secret 를 제공하여,

리소스에 접근 권한을 줄 수 있다.

[RN] React Native Build

2019-05-20T00:00:00+00:00

$ yarn install
$ react-native run-android

debugging app export

$ react-native bundle --platform android --dev false --entry-file index.js --bundle-output android/app/src/main/assets/index.android.bundle --assets-dest android/app/src/main/res

$ cd android

window

$ gradlew.bat assembleDebug

Mac OS

$ gradlew assembleDebug

production

참고 http://wagunblog.com/wp/?p=2371

create signkey

$ cd android/app
$ keytool -genkey -v -keystore kr.wise7034.RealTimeEmergencyDepartmentInfo.keystore -alias kr.wise7034.RealTimeEmergencyDepartmentInfo.remote -keyalg RSA -keysize 2048 -validity 10000 -storepass {YOUR_PASSWORD}

set android properties

$ cd android

// open gradle.properties
// add code
MYAPP_RELEASE_STORE_FILE=kr.wise7034.RealTimeEmergencyDepartmentInfo.keystore
MYAPP_RELEASE_KEY_ALIAS=kr.wise7034.RealTimeEmergencyDepartmentInfo.remote
MYAPP_RELEASE_STORE_PASSWORD={keystore password}
MYAPP_RELEASE_KEY_PASSWORD={keystore password}

// open app/build.gradle
android {
    defaultConfig { ... }
    signingConfigs {
        release {
            storeFile file(MYAPP_RELEASE_STORE_FILE)
            storePassword MYAPP_RELEASE_STORE_PASSWORD
            keyAlias MYAPP_RELEASE_KEY_ALIAS
            keyPassword MYAPP_RELEASE_KEY_PASSWORD
        }
    }
    buildTypes {
        release {
            ...
            signingConfig signingConfigs.release
        }
    }
}

build

$ react-native bundle --platform android --dev false --entry-file index.js --bundle-output android/app/src/main/assets/index.android.bundle
$ cd android
$ ./gradlew app:assembleRelease --stacktrace (or window ./gradlew -> gradlew.bat)

build test

$ react-native run-android --variant=release

bug report

[drawable-hdpi-v4/node_modules_reactnavigationstack_src_views_assets_backicon] C:\workspace\image-vision-rn\android\app\src\main\res\drawable-hdpi\node_modules_reactnavigationstack_src_views_assets_backicon.png      [drawable-hdpi-v4/node_modules_reactnavigationstack_src_views_assets_backicon] C:\workspace\image-vision-rn\android\app\build\generated\res\react\release\drawable-hdpi\node_modules_reactnavigationstack_src_views_assets_backicon.png: Error: Duplicate resources
[drawable-mdpi-v4/node_modules_reactnativeratings_src_images_airbnbstar] C:\workspace\image-vision-rn\android\app\src\main\res\drawable-mdpi\node_modules_reactnativeratings_src_images_airbnbstar.png  [drawable-mdpi-v4/node_modules_reactnativeratings_src_images_airbnbstar] C:\workspace\image-vision-rn\android\app\build\generated\res\react\release\drawable-mdpi\node_modules_reactnativeratings_src_images_airbnbstar.png: Error: Duplicate resources

위와 같은 버그가 난다면,

android/app/src/main/res/drawable-* 폴더를 삭제하자

참고 스택오버플로우

MSA 란

2019-05-20T00:00:00+00:00

SKplanet Tacademy 의 임성묵님의 발표자료를 옮겨 둔 내용입니다. 임성묵님과, 자료를 준비 해 주신, SKplanet Tacademy 에 감사드립니다.

자료출처: https://www.youtube.com/watch?v=D6drzNZWs-Y

콘웨이의 법칙

#[모놀리틱 애플리케이션]

모든조직은 조직의 의사소통 구조(communication structure)와 똑같은 구조를 갖는 시스템을 설계한다.
콘웨이의 법칙은 조직도에 초점을 두지않고, “실질적인 소통관계” 에 관심을 둔다. 너무 많은 통신관계를 갖는 것은 프로젝트에 대한 진정한 위험이 된다.

예를들어, 주문팀이 뭔가 해결하려면 정산팀에다도 물어봐야 하고, UI 팀에도 물어봐야 한다. 너무 많은 소통이 필요함.

장점

개발이 단순하다.
배포가 단순하다
스케일-아웃이 단순하다 ( 서버 하나만 복사하면 된다. ) (DB 성능 한계가 있다.)

단점

무겁다. [IDE 가 못받쳐줌]
어플리케이션 시작이 오래걸린다.
기술스택 바꾸기가 어렵다.
다른 서비스와의 높은 결합도
코드베이스의 책임 한계와 소유권이 불투명
레거시를 계속 하고있으면 개발자의 만족도가 굉장히 떨어짐

이쯤.. 회사가 결정하게 된다.

새로운 언어, 깔끔한 코드로 전면 재개편함. ( 차세대 프로젝트, 빅뱅 ) [
MSA 플랫폼을 구축하여, 기존 레거시를 고사(strangle) 시킴

#[MSA]

시스템을 여러개의 독립된 서비스로 나눠서, 서비스를 조합함으로써 기능을 제공하는 아키텍쳐 디자인 패턴

사례1. 제프베조스 의 메일 2002년

제프베조스 - 컴퓨터 공학과 출신 개발자 , 아마존 CEO

모든 팀들은 데이터와 기능들을 서비스 인터페이스로 연결시켜라.
팀들은 이 인터페이스를 통해서만 연락해야한다.
다른 어떤 커뮤니케이션 방법도 허용되지 않는다. 직접 링크를 보내거나 다른팀의 스토리지에 직접 억세스 해서도 안되며, 공유 메모리나, 백도어 같은것도 안된다. 모든 커뮤니케이션은 네트워크를 통한 서비스 인터페이스로 이루어져야한다.
어떤 기술을 쓰든 상관없다. HTTP, Cobra, Pubsub, 독자프로토콜.. 그건상관없다. 베조스는 그런데 관심없다.
모든 서비스 인터페이스는 예외없이 외부에서 이용가능하게 만들어져야한다. 그말은 팀들은 외부 개발자들이 인터페이스를 이용할 수 있게 해야 한다는것이다. 예외는 없다.
이를 실천하지 않는 사람은 누구든 해고될 것이다.

2006년 아마존 웹 서비스 (aws) 릴리즈

사례2 [넷플릭스의 선택]

2008년 데이터베이스에 심각한 문제가 발생해, 고객에게 DVD 를 보낼 수 없는 사태발생 (Single Points of failure)
- Scale-up 확장만 가능한 인프라 스트럭쳐와 단일 장애지점(SPOF) 이라는 한계에서 벗어나길 선언
- 시작은 아파치 카산드라.
2009년 AWS 로 이관시작
- 세가지 목표에 집중. 확장성(Scalability), 성능(Performance), 가용성(Availability)
‘자체 보유 인프라와 솔루션으로는 이렇게 급증한 트래픽을 감당할수 있는 확장성을 확보 할 수 없었을것’ - 유리 이즈라일레프스키(Yuri lzrailevsky), 넷플릭스 클라우드 및 플랫폼 엔지니어링 부문 부사장
온프레미스 환경 -> 클라우드 환경

#[그래서 MSA 란?]

공식적인 정의는 없음. 단지 공감대가 있을뿐 ( 위키피디아 )
각 서비스간 네트워크를 통해 ( 보통 HTTP )
독립된 배포 단위
각서비스는 쉽게 교체 가능
각 서비스는 ‘기능중심’ 으로 구성됨 eg, 프론트엔드, 추천, 정산, 상품 등
각서비스에 적합한 프로그래밍 언어, 데이터베이스, 환경 으로 만들어진다.
서비스는 크기가 작고, 상황에 따라 ‘경계’ 를 정하고, ‘자율적으로 개발’ 되고, ‘독립적으로 배포’ 되고, ‘분산’ 되고, ‘자동화된 프로세스’ 로 구축되고 배포된다.
마이크로 서비스는 한 팀에 의해 개발할 수 있는 크기가 상한선이다. 절대로 3~9명의 사람들이 스스로 더 많은 개발을 할 수 없을 정도로 커지면 안된다.
‘마이크로 서비스는 아직까지 아이디어 수준에서 크게 벗어나 있지 않다. 다양한 산업 분야에서 폭넓게 적용되고 있지만. 그것이 좋은지 나쁜지는 시간이 더 지나봐야 알 수 있다.’ - 조쉬 롱, 케니 바스타니, 피보탈

제프의 Study Room

Spring oauth2 server with social login

AuthenticationProvider

Kakao Client 에서 유저정보 받아오기

Create JS Soical Login Page

[SPRING] Spring Security 사용하기 #12

@Cacheable

[SPRING] Spring Security 사용하기 #11

[SPRING] Spring Security 사용하기 #10

[SPRING] Spring Security 사용하기 #9

[SPRING] Spring Security 사용하기 #8

토큰 type 을 jwt 로 변경 해보자.

jwt 토큰 키 설정 하기

[SPRING] Spring Security 사용하기 #7

client db 생성

[SPRING] Spring Security 사용하기 #6

최종 목표

시큐리티 관리 분리

Resource Server Config 생성

권한 서버(토큰발급 서버) 생성

token 제공 용도의 login page 생성하기

grant_type code

[RN] React Native Build

debugging app export

production

create signkey

set android properties

build

build test

bug report

MSA 란

사례1. 제프베조스 의 메일 2002년

사례2 [넷플릭스의 선택]