はじめに
ついに 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 で保存します。
データベースとテーブルの作成
データベースユーザとして、パスワードなしの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 の開発も着々と進んでそうなのでその時にでも。
