Spring Security で OAuth 2.0 Provider する

はじめに

ついに Windows 8 にした。
XP のサポートが終了したというのもあったのだけれども
Java 8 がインストールできなかったのが致命的だった。
.Net Framework 4.5 や PHP 5.5 このあたりが使えなくなったのは耐えていたのだけれど
この春、Java に見捨てられてもう我慢できなくなった。
Java 8 が使えたらきっと今も XP 使ってると思う。

で、OAuth
わたしにとって OAuth といえば Facebook なのですが
以前、Facebook のアプリを作る機会があり OAuth の認証処理に結構悩まされた。
リクエストが行ったり来たり、どのタイミングでが何が送られて来るのか？また何を送るのか？
と同時に向こう側の処理はどうなっているんだ！？
相手を知ればこちら側の処理がもっと明確に見えてくるのではと思ったりした。
そんな訳で今回は、Spring Security OAuth Provider を試してみようと思います。

現段階では、あまり詳しいドキュメントがない。
とりあえずサンプルがあるのでそれを参考にしつつソースを読むことにした。
なのでは、きっと何々だろう的なわたしの想像を元に進めていくことになる。
方針としては、
　・アリものは最大限利用させて頂く
　・データのやり取りを観察したいので InMemory のものでなくデータベースを使う
　・リクエストのやり取りの中でデータが変わりそうにないものは InMemory でもよしとしよう

サンプルで作るアプリをしては２つ
１つは、OAuth Provider として my-sns
想定としては、Facebook とか Twitter になる。
まぁいえばあちら側のサイトになる。
そしてもう１つは、OAuth Client として my-app
これは、自前のサイト、こちら側になる。

Windows 8 にして心機一転、ビルドツールも Maven から Gradle に乗り換えました。
ではでは！Getting Started!!

環境

OS	Windows 8.1
データベース	MySQL 5.6.16
アプリケーションサーバー	Tomcat 7.0.53
Java	JDK 1.8
フレームワーク	Spring Framework 4.0.3.RELEASE
	Spring Security 3.2.3.RELEASE
	Spring Security OAuth 1.0.5.RELEASE
ビルドツール	Gradle 1.11 ※gradle コマンドが実行できるように設定しておきます。

プロジェクト構成

Cドライブ直下に「work」フォルダを作成し各ファイルを以下のように配置します。
ファイルは、すべて UTF-8 で保存します。

C:\work
- studying-spring-security-oauth
  - my-app
    - src
      - main
        
        webapp
        
        WEB-INF
        
        web.xml
        
        index.jsp
    - build.gradle
  - my-sns
    - src
      - main
        
        java
        
        com
        
        mydomain
        
        ApiController.java
        
        resources
        
        META-INF
        
        spring
        
        applicationContext-oauth.xml
        
        log4j.properties
        
        webapp
        
        WEB-INF
        
        studying-oauth-servlet.xml
        
        web.xml
    - build.gradle
- build.gradle
- settings.gradle

データベースとテーブルの作成

データベースユーザとして、パスワードなしのrootユーザが作成済みという前提で
何はともあれデータベースから

DROP DATABASE IF EXISTS studying_oauth;
CREATE DATABASE IF NOT EXISTS studying_oauth DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;
USE studying_oauth;

では、メインの Access Token を保存するテーブルから作成します。
Schema に関しては、JdbcTokenStore(org.springframework.security.oauth2.provider.token パッケージ)を参考に逆算してみた。
恐らく token_id が PK になるだろう。
varchar は、とりあえず255文字あればいいでしょう。
user_name と refresh_token は使わない場合もあるので NULL OK にしてあとは強気に NOT NULL

DROP TABLE IF EXISTS `oauth_access_token`;
CREATE TABLE `oauth_access_token` (
  `token_id`          varchar(255) NOT NULL,
  `token`             blob         NOT NULL,
  `authentication_id` varchar(255) NOT NULL,
  `user_name`         varchar(255) NULL,
  `client_id`         varchar(255) NOT NULL,
  `authentication`    blob         NOT NULL,
  `refresh_token`     varchar(255) NULL,
  PRIMARY KEY (`token_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

次に Refresh Token を保存するテーブルを作成します。
同様に JdbcTokenStore から Schema を逆算してみた。
ここは token_id が PK で問題ないでしょう。

DROP TABLE IF EXISTS `oauth_refresh_token`;
CREATE TABLE `oauth_refresh_token` (
  `token_id`       varchar(255) NOT NULL,
  `token`          blob         NOT NULL,
  `authentication` blob         NOT NULL,
  PRIMARY KEY (`token_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

最後に Authorization Code Grant（認可コードグラント）で使用する Request Token を保存するテーブルを作成します。
Schema は、JdbcAuthorizationCodeServices(org.springframework.security.oauth2.provider.code パッケージ)から逆算した。
code が PK で問題ないでしょう。

DROP TABLE IF EXISTS `oauth_code`;
CREATE TABLE `oauth_code` (
  `code`           varchar(255) NOT NULL,
  `authentication` blob         NOT NULL,
  PRIMARY KEY (`code`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

ServletとLoggerの設定

OAuth Provider あちら側 my-sns の設定から始めます。

my-sns/src/main/webapp/WEB-INF/web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="3.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns="http://java.sun.com/xml/ns/javaee"
  xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
  xsi:schemaLocation="
    http://java.sun.com/xml/ns/javaee
    http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
  
  <display-name>studying-oauth</display-name>
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath*:META-INF/spring/applicationContext*.xml</param-value>
  </context-param>
    
  <filter>
    <filter-name>springSecurityFilterChain</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>springSecurityFilterChain</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <!-- Filter 設定 -->
  <filter>
    <filter-name>CorsFilter</filter-name>
    <filter-class>org.apache.catalina.filters.CorsFilter</filter-class>
    <init-param>
      <param-name>cors.allowed.origins</param-name>
      <param-value>*</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>CorsFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  
  <servlet>
    <servlet-name>studying-oauth</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>studying-oauth</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  
  <session-config>
    <cookie-config>
      <http-only>true</http-only>
    </cookie-config>
    <tracking-mode>COOKIE</tracking-mode>
  </session-config>
</web-app>

Filter 設定

クロスドメインで javascript から json データのやりとりをできるようにするための Filter を追加しています。
Response ヘッダーに「Access-Control-Allow-Origin: *」を出力しています。
今回、Tomcat を my-sns と my-app で port を変えて２つ起動します。
ドメインが同じでも Port が違うとクロスドメインと扱われるようです。
Tomcat で用意されてるアリものの Filter を使わせてもらっています。

どの処理でどのクラスが呼び出されるか知りたいので
とりあえず springframework.security.oauth パッケージ以下にあるクラスの
デバッグログを出力するようにしています。

my-sns/src/main/resources/log4j.properties

log4j.rootLogger=error, stdout
 
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
 
# Print the date in ISO 8601 format
log4j.appender.stdout.layout.ConversionPattern=%d [%t] %-5p %c - %m%n
 
log4j.appender.R=org.apache.log4j.RollingFileAppender
log4j.appender.R.File=application.log
 
log4j.appender.R.MaxFileSize=100KB
# Keep one backup file
log4j.appender.R.MaxBackupIndex=1
 
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n

log4j.logger.org.springframework.security.oauth2=debug, stdout

Spring Security の設定

あちら側 my-sns の OAuth Provider としてのメインの設定をします。
この設定が今回のキモになります。

my-sns/src/main/resources/META-INF/spring/applicationContext-oauth.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans
  xmlns="http://www.springframework.org/schema/security" 
  xmlns:oauth="http://www.springframework.org/schema/security/oauth2" 
  xmlns:beans="http://www.springframework.org/schema/beans" 
  xmlns:context="http://www.springframework.org/schema/context"
  xmlns:mvc="http://www.springframework.org/schema/mvc"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.2.xsd
    http://www.springframework.org/schema/security
    http://www.springframework.org/schema/security/spring-security.xsd
    http://www.springframework.org/schema/security/oauth2
    http://www.springframework.org/schema/security/spring-security-oauth2.xsd
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc.xsd">

  <!-- URL 設定① -->
  <http pattern="/members/**" create-session="stateless"
    entry-point-ref="myOauthAuthenticationEntryPoint"
    authentication-manager-ref="myOAuth2AuthenticationManager"
    access-decision-manager-ref="accessDecisionManager">
    <anonymous enabled="false" />
    <intercept-url pattern="/members/**" access="SCOPE_TRUST" />
    <custom-filter ref="myOauth2ProviderFilter" before="PRE_AUTH_FILTER" />
  </http>
  
  <!-- URL 設定② -->
  <http pattern="/oauth/token*" create-session="stateless" 
    entry-point-ref="myOauthAuthenticationEntryPoint"
    authentication-manager-ref="myClientAuthenticationManager">
    <custom-filter ref="myClientCredentialsTokenEndpointFilter" position="BASIC_AUTH_FILTER"/>
  </http>

  <!-- URL 設定③ -->
  <http pattern="/**"
    authentication-manager-ref="resourceOwner" 
    disable-url-rewriting="true">
    <intercept-url pattern="/oauth/authorize*" access="ROLE_USER" />
    <form-login />
  </http>


  <beans:bean
    id="myOauthAuthenticationEntryPoint"
    class="org.springframework.security.oauth2.provider.error.OAuth2AuthenticationEntryPoint" />

  <beans:bean
    id="myOAuth2AuthenticationManager"
    class="org.springframework.security.oauth2.provider.authentication.OAuth2AuthenticationManager">
    <beans:property name="tokenServices" ref="myTokenServices"/>
  </beans:bean>
  
  <beans:bean
    id="myTokenServices"
    class="org.springframework.security.oauth2.provider.token.DefaultTokenServices">
    <beans:property name="tokenStore" ref="myTokenStore" />
    <beans:property name="clientDetailsService" ref="myClientDetailsService" />
    <beans:property name="supportRefreshToken" value="true"/>
  </beans:bean>
  
  <!-- Access Token 設定 -->
  <beans:bean
    id="myTokenStore"
    class="org.springframework.security.oauth2.provider.token.JdbcTokenStore" >
    <beans:constructor-arg name="dataSource" ref="myDataSource"/>
  </beans:bean>
  
  <!-- 連携アプリ設定 -->
  <oauth:client-details-service
    id="myClientDetailsService" >
    <oauth:client
      client-id="my-auth"
      secret="pass123"
      scope="trust" 
      authorized-grant-types="authorization_code,implicit,password,client_credentials,refresh_token"
      authorities="ROLE_CLIENT"
      resource-ids="myResource" />
  </oauth:client-details-service>

  <!-- 権限設定 -->
  <beans:bean
    id="accessDecisionManager"
    class="org.springframework.security.access.vote.UnanimousBased">
    <beans:constructor-arg>
      <beans:list>
        <beans:bean class="org.springframework.security.oauth2.provider.vote.ScopeVoter" />
        <beans:bean class="org.springframework.security.access.vote.RoleVoter" />
        <beans:bean class="org.springframework.security.access.vote.AuthenticatedVoter" />
      </beans:list>
    </beans:constructor-arg>
  </beans:bean>

  <oauth:resource-server
    id="myOauth2ProviderFilter" resource-id="myResource" token-services-ref="myTokenServices" />


  <authentication-manager id="myClientAuthenticationManager">
    <authentication-provider user-service-ref="myClientDetailsUserService" />
  </authentication-manager>

  <beans:bean
    id="myClientDetailsUserService"
    class="org.springframework.security.oauth2.provider.client.ClientDetailsUserDetailsService">
    <beans:constructor-arg ref="myClientDetailsService" />
  </beans:bean>
  
  <beans:bean
    id="myClientCredentialsTokenEndpointFilter"
    class="org.springframework.security.oauth2.provider.client.ClientCredentialsTokenEndpointFilter">
    <beans:property name="authenticationManager" ref="myClientAuthenticationManager" />
    <beans:property name="authenticationEntryPoint" ref="myOauthAuthenticationEntryPoint" />
  </beans:bean>


  <!-- ユーザアカウント 設定 -->
  <authentication-manager id="resourceOwner">
    <authentication-provider>
      <user-service id="userDetailsService">
        <user name="user01" password="pass01" authorities="ROLE_USER" />
        <user name="user02" password="pass02" authorities="ROLE_USER" />
      </user-service>
    </authentication-provider>
  </authentication-manager>


  <!-- OAuth Provider 全体設定 -->
  <oauth:authorization-server
    client-details-service-ref="myClientDetailsService"
    token-services-ref="myTokenServices"
    user-approval-handler-ref="myUserApprovalHandler">
    <oauth:authorization-code authorization-code-services-ref="myAuthorizationCodeServices"/>
    <oauth:implicit />
    <oauth:refresh-token />
    <oauth:client-credentials />
    <oauth:password authentication-manager-ref="resourceOwner"/>
  </oauth:authorization-server>
  
  <beans:bean
    id="myUserApprovalHandler"
    class="org.springframework.security.oauth2.provider.approval.TokenServicesUserApprovalHandler">
    <beans:property name="tokenServices" ref="myTokenServices"/>
  </beans:bean>
   
  <!-- Request Token 設定 -->
  <beans:bean
    id="myAuthorizationCodeServices"
    class="org.springframework.security.oauth2.provider.code.JdbcAuthorizationCodeServices" >
    <beans:constructor-arg name="dataSource" ref="myDataSource"/>
  </beans:bean>


  <beans:bean
    id="oauthAccessDeniedHandler"
    class="org.springframework.security.oauth2.provider.error.OAuth2AccessDeniedHandler" />

  <beans:bean
    id="myDataSource"
    class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    <beans:property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <beans:property name="url" value="jdbc:mysql://localhost:3306/studying_oauth"/>
    <beans:property name="username" value="root"/>
    <beans:property name="password" value=""/>
  </beans:bean>

  <context:component-scan base-package="com.mydomain" />
  <mvc:annotation-driven />

</beans:beans>

URL 設定①

Access Token が必要な URL
ここはセッション管理しないので強気に stateless とした。

URL 設定②

Access Token を発行する URL
この段階でどのユーザアカウントが Access Token を求めてきているか
なにかしらの方法で分かるはずなのでここもセッションは stateless とした。

URL 設定③

あちら側 my-sns のログイン画面、アプリ承認画面を表示するURL
Authorization Code Grant であれば Request Token を
Implicit Grant であれば Access Token を発行する URL になる。
ここはログイン画面などを使ってどのユーザアカウントであるか
判別する必要があるだろうからセッション管理は通常どうりとした。

Access Token 設定

ここのデータのやりとりを観察したいのでデータベース用のもを使った。

連携アプリ設定

こちら側 my-app があちら側 my-sns の認証が必要な URL に
アクセスするためのサイトのアカウント登録になる。
Facebook、Twitter でいうアプリの登録になると思う。
client-id、secret がアカウントIDとパスワードになる。
ここは InMemory のものを使った。
データベース用のものも用意されているので
JdbcClientDetailsService(org.springframework.security.oauth2.provider パッケージ)
あたりを解析すればテーブル Schema が割り出せると思う。

権限設定

ScopeVoter によって Access Token の scope が Spring Security の Role に変換される。
Access Token 取得時に Request パラメータで scope=trust というように指定された場合
prefix 「SCOPE_」が付けられ「SCOPE_TRUST」というような Role になる。

ユーザアカウント設定

あちら側 my-sns のユーザアカウントになる。
ユーザアカウントは２つ、IDとパスワードはそれぞれ「user01/pass01」「user02/pass02」を登録した。
ここも InMemory のものを使った。
ここは Spring Security 本体でデータベース用のもが用意されている。

OAuth Provider 全体設定

OAuth の４つの Grant と Refresh Token が試せるように設定した。

Request Token 設定

このあたりもデータのやりとりを観察したいのでデータベース用のもを使った。

内容は空なのですが「アプリケーションコンテキスト名-servlet.xml」ファイルがないと
うまく動かないようなので一応作成しておきます。

my-sns/src/main/webapp/WEB-INF/studying-oauth-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans
  xmlns="http://www.springframework.org/schema/security" 
  xmlns:oauth="http://www.springframework.org/schema/security/oauth2" 
  xmlns:beans="http://www.springframework.org/schema/beans" 
  xmlns:mvc="http://www.springframework.org/schema/mvc"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/security
    http://www.springframework.org/schema/security/spring-security.xsd
    http://www.springframework.org/schema/security/oauth2
    http://www.springframework.org/schema/security/spring-security-oauth2.xsd
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc.xsd">
</beans:beans>

Controller クラスの作成

「/my-sns/members」でログインユーザ情報を json 形式で返すようにします。

my-sns/src/main/java/com/mydomain/ApiController.java

package com.mydomain.web;

import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;


@Controller
public class ApiController {

  @RequestMapping("/members")
  @ResponseBody
  public UserDetails members() {
    Authentication auth = SecurityContextHolder.getContext().getAuthentication();
    return (UserDetails)auth.getPrincipal();
  }
}

my-app の設定

こちら側 my-app の設定をします。
以下のような内容でOAuthのテストページを作成します。

my-app/src/main/webapp/index.jspx

<%@ page contentType="text/html; charset=UTF-8" %>
<html>
  <head>
    <title>OAuthのテスト</title>
  </head>
  <body>
    <h2>OAuthのテスト</h2>
  </body>
</html>

いらないかもしれないけど以下のような内容で web.xml も作成しておきます。

my-app/src/main/webapp/WEB-INF/web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="3.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns="http://java.sun.com/xml/ns/javaee"
  xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
  xsi:schemaLocation="
    http://java.sun.com/xml/ns/javaee
    http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">

  <session-config>
    <cookie-config>
      <http-only>true</http-only>
    </cookie-config>
    <tracking-mode>COOKIE</tracking-mode>
  </session-config>
</web-app>

ビルドスクリプトの作成

まずは Top プロジェクトのビルドスクリプトを以下の内容で作成します。

settings.gradle

include 'my-app', 'my-sns'

build.gradle

ext { 
  springVersion = '4.0.3.RELEASE'
  springSecurityVersion = '3.2.3.RELEASE'
  springSecurityOAuth2Version = '1.0.5.RELEASE'
  tomcatVersion = '7.0.53'
}

allprojects {
  repositories {
    mavenCentral()
  }
}

subprojects {
  apply plugin: 'war'
  apply plugin: 'tomcat'
  
  dependencies {
    compile "org.springframework:spring-context:${springVersion}"
    compile "org.springframework:spring-webmvc:${springVersion}"
    compile "org.springframework:spring-jdbc:${springVersion}"    
    
    compile "org.springframework.security:spring-security-web:${springSecurityVersion}"
    compile "org.springframework.security:spring-security-config:${springSecurityVersion}"
    compile "org.springframework.security:spring-security-taglibs:${springSecurityVersion}"   
    
    compile "org.springframework.security.oauth:spring-security-oauth2:${springSecurityOAuth2Version}"
    
    compile 'commons-dbcp:commons-dbcp:1.4'
    compile 'mysql:mysql-connector-java:5.1.30'
    compile 'log4j:log4j:1.2.17'
    
    tomcat "org.apache.tomcat.embed:tomcat-embed-core:${tomcatVersion}",
           "org.apache.tomcat.embed:tomcat-embed-logging-juli:${tomcatVersion}"
    tomcat("org.apache.tomcat.embed:tomcat-embed-jasper:${tomcatVersion}") {
           exclude group: 'org.eclipse.jdt.core.compiler', module: 'ecj'
    }
  }
  
  sourceCompatibility = '1.8'
  targetCompatibility = '1.8'
  [compileJava, compileTestJava]*.options*.encoding = 'UTF-8'
}

buildscript {
  repositories {
    jcenter()
  }

  dependencies {
    classpath 'org.gradle.api.plugins:gradle-tomcat-plugin:1.2.3'
  }
}

次は my-sns プロジェクトのビルドスクリプトを以下の内容で作成します。

my-sns/build.gradle

war {
  baseName = 'my-sns'
}

最後は my-app プロジェクトのビルドスクリプトを以下の内容で作成します。
Tomcat を２つ起動することになるので my-sns とは違う port を指定しています。

my-app/build.gradle

war {
  baseName = 'my-app'
}

tomcat {
  httpPort  = 15080
  httpsPort = 15443
  ajpPort   = 15009
  stopPort  = 15081
}

OAuth 認証を試す準備

とりあえずデータベースのデータを削除します。

DELETE FROM oauth_access_token;
DELETE FROM oauth_code;
DELETE FROM oauth_refresh_token;

そしてそれぞれの Tomcat を起動します。
まずは my-sns から
コマンドプロンプトを起動して以下を入力する。

cd /d C:\work\studying-spring-security-oauth
gradle :my-sns:clean :my-sns:tomcatRun

次は my-app 
もう一枚コマンドプロンプトを起動して以下を入力する。

cd /d C:\work\studying-spring-security-oauth
gradle :my-app:clean :my-app:tomcatRun

Authorization Code Grant を試す

手始めに一番一般的な方法、認可コードグラントで Access Token 取得をしてみます。

OAuthのテストに用意した my-app のページ「http://localhost:15080/my-app/」を開きます。
認可コードグラントの場合、Access Token の取得に Request Token が必要になってくるので
Request Token から取得してみます。
以下のURLをアドレスバーに入力して my-sns にアクセスします。

http://localhost:8080/my-sns/oauth/authorize?client_id=my-auth&scope=trust&response_type=code&redirect_uri=http://localhost:15080/my-app/

Request パラメータにはアプリのID(client_id)は必要なのですがこの段階ではまだアプリのパスワード(client_secret)は不要です。

上記のURLにアクセスするとログイン画面が表示されると思います。
my-sns のユーザアカウント「user01/pass01」または「user02/pass02」でログインします。

ログインするとアプリの承認画面が表示されると思います。
「Authorize」ボタンを押してアプリを承認します。

今度は my-sns から my-app にリダイレクトされます。
この時 URL に ?code=XXXXX のような形で Request Token が送られてきているかと思います。
ここで oauth_code テーブルを見てみると送られてきた Request Token が登録されていると思います。

次に取得した Request Token から Access Token 取得をしてみます。
以下のURLをアドレスバーに入力して my-sns にアクセスします。

http://localhost:8080/my-sns/oauth/token?client_id=my-auth&client_secret=pass123&grant_type=authorization_code&redirect_uri=http://localhost:15080/my-app/&code=XXXXX

この段階で Request パラメータにアプリのID(client_id)と共にアプリのパスワード(client_secret)が必要になります。
最後の部分 code=XXXXX で取得した Request Token を指定します。

レスポンスデータとして Access Token が json 形式で画面に表示されると思います。
表示された access_token と refresh_token をメモしておきます。
ここで oauth_access_token テーブルと oauth_refresh_token テーブルを見てみると
Access Token と Refresh Token が登録されていると思います。
また一回使った Request Token でもう一度 Access Token 取得しようとすると
"error":"invalid_grant" とかになり Access Token が取得できないようになっていると思います。
また oauth_code テーブルを見てみると先ほどの Request Token 削除されていると思います。

これで Access Token を使って my-sns のユーザ認証が必要な情報にアクセスができるように
なっていると思います。
以下のURLをアドレスバーに入力して my-sns にアクセスしてログインユーザ情報が取得してみます。

http://localhost:8080/my-sns/members/?access_token=YYYYY

?access_token=YYYYY で取得した Request Token を指定します。

レスポンスデータとして ログインユーザ情報 が json 形式で画面に表示されると思います。
また、Request Token なしでアクセスしてみると 
An Authentication object was not found in the SecurityContext 的なデータが表示されると思います。

Refresh Token を試す

リフレッシュトークンも試してみたいと思います。
先ほどと同様に認可コードグラントを使います。

Access Token の有効期間は初期値で12時間になっている。
ここではそんなに待てないので1分にしてみる。
「applicationContext-oauth.xml」の myTokenServices に以下を追加する。

my-sns/src/main/resources/META-INF/spring/applicationContext-oauth.xml

  ...
  <beans:bean
    id="myTokenServices"
    class="org.springframework.security.oauth2.provider.token.DefaultTokenServices">
    ...
    <beans:property name="accessTokenValiditySeconds" value="60"/>
  </beans:bean>
  ...

OAuth 認証を試す準備で行ったデータベースの削除と my-sns の Tomcat を再起動してから
認可コードグラントの手順で Access Token と Refresh Token を取得します。
一応取得した Access Token で my-sns からログインユーザ情報が取得してみます。
それで待つこと1分以下のURLでログインユーザ情報が取得してみます。

http://localhost:8080/my-sns/members/?access_token=YYYYY

Access token expired: 的なデータが表示されると思います。
以下のURLをアドレスバーに入力して my-sns から Access Token を再取得してみます。

http://localhost:8080/my-sns/oauth/token?client_id=my-auth&client_secret=pass123&scope=trust&grant_type=refresh_token&refresh_token=ZZZZZ

Request パラメータにアプリのID(client_id)とアプリのパスワード(client_secret)が必要になります。
?refresh_token=ZZZZZ で取得した Refresh Token を指定します。

レスポンスデータとして Access Token が json 形式で画面に表示されると思います。
ここは手際よく再取得した Access Token で my-sns からログインユーザ情報を取得してみてください。

Implicit Grant を試す

インプリシットグラントで Access Token 取得をしてみます。
テストデータをリセットしたいのでOAuth 認証を試す準備で行った
データベースの削除と my-sns の Tomcat を再起動を行います。

OAuthのテストに用意した my-app のページ「http://localhost:15080/my-app/」を開きます。
以下のURLをアドレスバーに入力して my-sns にアクセスします。

http://localhost:8080/my-sns/oauth/authorize?client_id=my-auth&scope=trust&response_type=token&redirect_uri=http://localhost:15080/my-app/

Request パラメータにアプリのID(client_id)は必要なのですがアプリのパスワード(client_secret)は不要なようです。

認可コードグラントの時と同様に my-sns のユーザアカウントのログイン、アプリの承認と進むのですが
インプリシットグラントの場合、Access Token の取得に Request Token がいらないので
直接 Access Token が指定した call back に指定した URL に送られてきます。

ここで注意が必要なのですが、?access_token=YYYYY の形ではなく #access_token=YYYYY で送られてくるので
通常の Request パラメータの取り出し方法では Access Token が取り出せない。
URL のハッシュ「#」以降を自力で解析して Access Token を取り出さないといけないようです。

また Access Token の取得にアプリのパスワードが不要なところも微妙だと思う。
さらに認可コードグラントのように Access Token をレスポンスデータでなく
call back URL の Request パラメータ(厳密には Request パラメータではない？)から
取得するところもどうかと思う。
call back URL といえど他の URL と変わらないので
悪意？のあるサイトが #access_token=YYYYY 的な Request パラメータで
関係ない(なりすまし用？) Access Token 直接送り付けてくることも考えられる。
とりあえず、こちら側のサイト my-app 側も送られてくる Request パラメータを無条件に信用するのでなく
何かしらのチェックは必要になるでしょう。

Resource Owner Password Credentials Grant を試す

リソースオーナーパスワードクレデンシャルグラントで Access Token 取得をしてみます。
まず試す前にテストデータのリセットを行います。
OAuth 認証を試す準備で行ったデータベースの削除と my-sns の Tomcat を再起動をします。

OAuthのテストに用意した my-app のページ「http://localhost:15080/my-app/」から
以下のURLをアドレスバーに入力して my-sns にアクセスします。

http://localhost:8080/my-sns/oauth/token?client_id=my-auth&client_secret=pass123&scope=trust&grant_type=password&username=user01&password=pass01

Request パラメータ username、password で my-sns のユーザアカウントのログインID、パスワードを指定します。
またアプリのIDとパスワードも必要になるようです。

ユーザアカウントのログイン画面が無ければアプリ承認画面もなく
レスポンスデータとして Access Token が json 形式で画面に表示されると思います。
まぁ username、password を Request パラメータで送っていくるのだから
あちら側 my-sns としてはログイン画面は必要ないのでしょう。

ここで微妙な仕様に気づくと思います。
あちら側 my-sns のユーザアカウントのログインID、パスワードを 
こちら側 my-app でどうやって知りえるのか？
たぶん、こちら側 my-app でログイン画面を用意して
あちら側 my-sns の ログインID、パスワード入力してもらい
こちら側 my-app で送られてきたログインID、パスワードを Request パラメータに付けて 
Access Token 取得 URL を呼び出すことになるのだろう。
本来 OAuth こちら側 my-app があちら側 my-sns のユーザアカウントのログインID、パスワードを知ることなく
あちら側 my-sns のユーザ認証の必要なデータにアクセスするということだと思う。
微妙な仕様だ。
アプリ承認画面に関してもきっとこちら側 my-app で用意する仕様なのだろう。

Client Credentials Grant を試す

クライアントクレデンシャルグラントで Access Token 取得をしてみます。
例によってテストデータのリセットのためにデータベースの削除と my-sns の Tomcat を再起動を行います。

OAuthのテストに用意した my-app のページ「http://localhost:15080/my-app/」から
以下のURLをアドレスバーに入力して my-sns にアクセスします。

http://localhost:8080/my-sns/oauth/token?client_id=my-auth&client_secret=pass123&scope=trust&grant_type=client_credentials

Request パラメータには、アプリのIDとパスワードが必要になるようです。

先ほどのリソースオーナーパスワードクレデンシャルグラントと同様に
ユーザアカウントのログイン画面が無ければアプリ承認画面もなく
レスポンスデータとして Access Token が json 形式で画面に表示されると思います。

クライアントクレデンシャルグラントの場合、特定のユーザアカウントとという訳でなく
アプリのIDとパスワードに対して Access Token 発行されるような感じになるようです。
なのでこの場合 Access Token でログインユーザ情報が取得できないようです。
まぁこれも微妙といえば微妙な仕様だなぁ。

おわりに

触ってみて、なるほどと思うところとやっぱりそうなっていたのかと思うところがあった。
あたり前だけど発行した Token をユーザと紐づけてデータベースで管理する。
OAuth Provider の実装は、他にもいろいろある(java 以外を含めて)とあると思うけど
このあたりはどれも変わらないのだろう。

今回は、Access Token を Request パラメータで渡していたけど
Restful な API を目指すなら Basic認証、Digest認証と同じように
Request ヘッダーでやりとりするのが正しいようだ。
この辺は、Client 側の対応になりそうだ。
それは、また次回に。
次の Version の開発も着々と進んでそうなのでその時にでも。

参考URL: http://www.atmarkit.co.jp/ait/articles/1209/10/news105.html; http://penq.co.jp/blog/engineer/amazon-web-service/3113

諸行無常 - As Time Goes By -

2014年4月23日水曜日