devkuma – Spring Security

Spring Security | Spring Securityとは

kc@example.com (kc kim) — Wed, 04 Oct 2017 22:41:52 +0900

Spring Securityは、Webアプリケーションにセキュリティ機能を追加するSpringプロジェクトの一つです。

CSRFやセッション固定攻撃など、よく知られたさまざまな攻撃に対する保護機能を提供します。

Spring Security | Spring Securityとは | 認証（Authentication）と認可（Authorization）

kc@example.com (kc kim) — Wed, 04 Oct 2017 22:41:52 +0900

認証（Authentication）とは？

認証とは、本人であると主張する人の身元を確認する手続きです。クライアントが、主張しているユーザー本人であるかを確認します。

認証には次の種類があります。

クレデンシャルベース認証
- Webで使用される認証方式の多くは、クレデンシャルベースです。
- 権限を付与する前に認証処理が必要で、通常はユーザー名とパスワードを入力し、保存された情報と一致するか確認します。
- Spring Securityでは、一般にIDをprincipal、パスワードをcredentialと呼びます。
二要素認証
- 2つの方式で認証することを意味します。
- たとえば金融機関や銀行のWebアプリケーションでオンライン取引を行う場合、ログインとセキュリティ証明書の両方で認証することがあります。
- 認証要素を1つ追加するだけに見えますが、プログラム上の変更範囲は広くなります。
物理認証
- Webの領域外ですが、最も効果的なセキュリティ手段の一つです。
- たとえば、コンピューターの起動時に指紋を認識させる方法や、物理キーを挿入する方法があります。

認可（Authorization）とは？

認可とは、目的の場所へのアクセスや必要な情報の取得を許可する処理です。
クライアントが実行しようとしている操作が、そのクライアントに許可されているかを確認します。

認可は大きく2種類に分けられます。

付与された権限（Granted Authority）
- ユーザーが適切な手順で認証されたら、権限を付与します。
- 会員登録などで永続的な権限を付与した場合、その権限をどこかに保存する必要があります。
- ユーザーがログインしてもメインページに移動できない場合は、認可に問題があります。
リソースのインターセプト
- ユーザーに権限があるだけでは十分なセキュリティにはなりません。権限のないユーザーがリソースへアクセスできないよう、最初から防ぐ必要があります。
- 適切な権限を持つユーザーだけがリソースへアクセスできるように外部リクエストを遮断することは、Webセキュリティと認可の中心的な原則です。

認証と認可の違い

認証と認可は区別しにくい場合があります。
認証後に、認証されたユーザーへ特定の権限を付与すると考えると理解しやすくなります。
たとえばACL（Access Control List）では、ユーザーのアクセスレベルに応じて、認証後にアクセス可能な範囲を制限できます。

SpringとKotlinで作成したWebMVC MCP Serverへ認証を追加する

kc@example.com (kc kim) — Sun, 09 Nov 2025 10:06:00 +0900

はじめに

前回はWebMVC MCP Serverを作成しました。ここでは認証を追加します。

Spring AIはSpring Securityを通じてOAuth2とAPIキー認証をサポートします。

2025-11-10時点でMCP Securityは開発中であり、安定版ではありません。

この例ではAPIキー認証を適用します。

認証を追加する

前回のWebMVCプロジェクトをコピーして名前を変更します。

% mv spring-ai-mcp-server-webmvc spring-ai-mcp-server-auth

ルートプロジェクト名を変更します。

rootProject.name = "spring-ai-mcp-server-auth"

Spring SecurityとMCP Server Securityを追加します。

dependencies {
  implementation("org.springframework.ai:spring-ai-starter-mcp-server")
  implementation("org.springframework.ai:spring-ai-starter-mcp-server-webmvc")
  implementation("org.springframework.boot:spring-boot-starter-security")
  implementation("org.springaicommunity:mcp-server-security:0.0.3")
}

ログファイルを変更し、Spring SecurityのTRACEログを有効にします。

spring:
  main:
    banner-mode: off
  ai:
    mcp:
      server:
        name: my-weather-server
        version: 0.0.1
        protocol: STATELESS

logging:
  file:
    name: ./log/spring-ai-starter-mcp-server-auth.log
  level:
    org.springframework.security: TRACE

MCP Serverのセキュリティ設定を作成する

Spring SecurityへMCP APIキーを登録します。

@Configuration
@EnableWebSecurity
class SecurityConfig {
    @Bean
    fun securityFilterChain(http: HttpSecurity): SecurityFilterChain =
        http.authorizeHttpRequests { it.anyRequest().authenticated() }
            .with(mcpServerApiKey()) { apiKey ->
                apiKey.apiKeyRepository(apiKeyRepository())
            }.build()

    private fun apiKeyRepository(): ApiKeyEntityRepository<ApiKeyEntityImpl> {
        val apiKey = ApiKeyEntityImpl.builder()
            .name("test api key")
            .id("api01")
            .secret("mycustomapikey")
            .build()
        return InMemoryApiKeyEntityRepository(listOf(apiKey))
    }
}

例ではID api01とsecret mycustomapikeyをメモリーへ保存します。本番環境ではデータベースや外部APIを使用してください。

テストクライアントを実装する

既存クライアントへAPIキーヘッダーを追加します。

val request = HttpRequest.newBuilder()
    .header("Content-Type", "application/json")
    .header("X-API-key", "api01.mycustomapikey")

val transport = HttpClientStreamableHttpTransport.builder("http://localhost:8080")
    .requestBuilder(request)
    .build()

val client = McpClient.sync(transport).build()
client.initialize()
client.ping()
println("Available Tools = ${client.listTools()}")
println("get_weather Response = ${client.callTool(CallToolRequest("get_weather", mapOf("city" to "seoul")))}")
client.closeGracefully()

クライアントを実行すると、利用可能なツール一覧とget_weatherのレスポンスが表示されます。

参考資料

Spring Security | Spring Securityとは | Hello World

kc@example.com (kc kim) — Wed, 04 Oct 2017 22:41:52 +0900

まず、簡単な例を作成してみましょう。

次のようにファイル構成を作成し、各ファイルを作成します。ファイルを作成できるツールであれば、どれを使用してもかまいません。

ファイル構成

.
├── build.gradle
└── src
    └── main
        └── webapp
            ├── WEB-INF
            │   ├── applicationContext.xml
            │   └── web.xml
            └── index.jsp

ビルドスクリプトでの依存関係

ビルドスクリプトファイルを作成します。

build.gradle

apply plugin: 'war'

sourceCompatibility = '1.8'
targetCompatibility = '1.8'
compileJava.options.encoding = 'UTF-8'

repositories {
    mavenCentral()
}

dependencies {
    providedCompile 'javax.servlet:javax.servlet-api:3.1.0'
    compile 'javax.servlet:jstl:1.2'
    compile 'org.springframework.security:spring-security-web:4.2.1.RELEASE'
    compile 'org.springframework.security:spring-security-config:4.2.1.RELEASE'
}

war.baseName = 'spring-security-sample'

最小構成として、spring-security-webとspring-security-configを依存関係に追加しています。

    compile 'org.springframework.security:spring-security-web:4.2.1.RELEASE'
    compile 'org.springframework.security:spring-security-config:4.2.1.RELEASE'

spring-security-web

FilterやWebアプリケーション関連のコードが含まれています。Web認証機能とURLベースのアクセス制御が必要な場合は、このモジュールが必要です。メインパッケージはorg.springframework.security.webです。

spring-security-config

XMLで定義を書くときに使用するnamespaceを解析するコードや、Java設定のためのコードが含まれています。XMLベースの設定およびJava設定を使用する場合は、このモジュールが必要です。メインパッケージはorg.springframework.security.configです。ここに含まれるクラスをアプリケーションで直接使用するわけではありません。

Springコンテナの初期化

Javaの従来型Web設定ファイルを作成します。

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

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee 
         http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">
    <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>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
</web-app>

Springコンテナの初期化は次のように行います。

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

ContextLoaderListenerをリスナーとして登録することで、Springコンテナ、つまりApplicationContextが初期化されます。

どのApplicationContextクラスを使用するかを明示しない場合、デフォルトではXmlWebApplicationContextが使用されます。

spring-web-x.x.x.RELEASE.jar内のorg/springframework/web/context/ContextLoader.propertiesには次のように定義されており、サーブレットコンテナが初期化されるときにContextLoaderListenerがロードされます。

# Default WebApplicationContext implementation class for ContextLoader.
# Used as fallback when no explicit context implementation has been specified as context-param.
# Not meant to be customized by application developers.

org.springframework.web.context.WebApplicationContext=org.springframework.web.context.support.XmlWebApplicationContext

XmlWebApplicationContextは、デフォルトでWEB-INF/applicationContext.xmlを設定ファイルとして読み込みます。

Spring Securityをアプリケーションへ適用

DelegatingFilterProxyをサーブレットフィルターとしてweb.xmlに定義します。このとき、<filter-name>をspringSecurityFilterChainとして定義します。ここで<filter-mapping>に定義されたURLへアクセスがあると、Spring Securityが適用されます。

DelegatingFilterProxyは、自身の<filter-name>に設定された名前を使用して、Springコンテナからjavax.servlet.Filterを実装したBeanを取得します。そして、そのBeanへ処理を委譲するだけのサーブレットフィルターです。

ここでは<filter-name>にspringSecurityFilterChainを指定しています。この名前は、後で出てくるapplicationContext.xmlで<http>タグを使用するとコンテナに自動登録されるFilterChainProxyのBean名と一致します。

つまり、DelegatingFilterProxyはサーブレットフィルターとSpring Security、つまりFilterChainProxyを仲介する役割を持ちます。

Spring Security設定

src/main/webapp/WEB-INF/applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:sec="http://www.springframework.org/schema/security"
       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-3.0.xsd
         http://www.springframework.org/schema/security
         http://www.springframework.org/schema/security/spring-security.xsd">

    <sec:http>
        <sec:intercept-url pattern="/login" access="permitAll" />
        <sec:intercept-url pattern="/**" access="isAuthenticated()" />
        <sec:form-login />
        <sec:logout />
    </sec:http>

    <sec:authentication-manager>
        <sec:authentication-provider>
            <sec:user-service>
                <sec:user name="devkuma" password="1234" authorities="ROLE_USER" />
            </sec:user-service>
        </sec:authentication-provider>
    </sec:authentication-manager>
</beans>

applicationContext.xmlはSpringのBean定義のための標準設定ファイルであり、Spring Security専用の特別な設定ファイルではありません。

xmlnsでhttp://www.springframework.org/schema/securityを読み込むため、Spring Security用のタグを使用できるようになります。参考までに、このSpring Security専用タグを使用することをnamespaceの使用と呼びます。このタグを使用して、このファイル内でSpring Securityを設定できます。

上記の設定を要約すると、次のような内容です。

/loginには誰でもアクセスできます（permitAll）。
その他すべてのパス（/**）へのアクセスには認証済みである必要があります（isAuthenticated()）。
ログイン方法はフォームログインです。
ログアウトできます。ユーザー情報として、名前はdevkuma、パスワードは1234、ROLE_USERというロールを持つユーザーを定義しています。

次に、各タグについて少し詳しく説明します。

<http>

<http>タグを定義すると、いくつかのBeanが自動的にコンテナへ登録されます。その中でも重要なBeanは次の2種類です。

FilterChainProxy
SecurityFilterChain

FilterChainProxyは、springSecurityFilterChainというBean名でコンテナに登録されます。このクラスはSpring Security処理の入口になります。

SecurityFilterChain自体は単純なインターフェースで、実装クラスとしてDefaultSecurityFilterChainがコンテナに登録されます。SecurityFilterChainは名前のとおり、セキュリティ機能を持つjavax.servlet.Filterをチェーンとしてつなぎ、複数のFilterを内部に保持します。Spring SecurityはFilterを利用してセキュリティ機能を提供しています。

FilterChainProxyは名前にProxyと付いていることからもわかるように、このクラス自体は処理を行いません。具体的な処理は、SecurityFilterChainが保持するFilter群へ委譲します。

<intercept-url>

URLパターンに対して、アクセスに必要な条件、つまりアクセス制御を定義します。

pattern属性はAntパス形式で記述できます。

access属性には、pattern属性で指定したURLへアクセスするために必要な条件を指定します。permitAllは、すべてのアクセスを許可すること、つまり認証不要を意味します。そしてisAuthenticated()は、認証済み、つまりログイン済みであればアクセスを許可することを意味します。

access属性は、Spring Expression Language（SpEL）というSpring独自の式言語を使用して記述します。

フォーム認証が必要であることを定義します。

認証エラーの場合、デフォルトでは/loginへリダイレクトされます。デフォルトの場合、/loginへアクセスするとSpring Securityが提供する簡単なログインページが表示されます。

このデフォルトログインページは、spring-security-web-x.x.x.RELEASE.jar内のDefaultLoginPageGeneratingFilterによって生成されます。

<logout>

このタグを追加することで、ログアウトできるようになります。

デフォルトでは、/logoutに対してPOSTリクエストを実行するとログアウトが行われます。

<authentication-manager>

AuthenticationManagerをBeanとして定義します。AuthenticationManagerは、認証処理を実行するクラスで必ず定義する必要があります。

AuthenticationManager自体はインターフェースで、実装クラスにはProviderManagerが使用されます。 ProviderManager自体は具体的な認証処理を行わず、後で作成するAuthenticationProviderへ認証処理を委譲します。

<authentication-manager>

AuthenticationManagerをBeanとして定義します。 AuthenticationManagerは、認証処理を実行するクラスで必ず定義する必要があります。

AuthenticationManager自体はインターフェースで、実装クラスにはProviderManagerが使用されます。 ProviderManager自体は具体的な認証処理を行わず、後述するAuthenticationProviderへ認証処理を委譲します。

<authentication-provider>

AuthenticationProviderをBeanとして定義します。このインターフェースは、認証の種類に応じた具体的な認証処理を提供します。

例えば、LDAP認証プロセスを提供するクラスはLdapAuthenticationProviderです。

このタグを宣言した場合、DaoAuthenticationProviderがコンテナに登録されます。このクラスはUserDetailsServiceからユーザー情報を取得し、認証処理を行います。

<user-service>

UserDetailsServiceをBeanとして登録します。このインターフェースは、ユーザーの詳細情報、つまりUserDetailsを取得する機能を提供します。

このタグを宣言すると、InMemoryUserDetailsManagerがコンテナに登録されます。このクラスは名前のとおり、メモリ上にユーザー情報を保持できます。通常は動作確認用として実装されます。

<user>

UserDetailsインスタンスを定義します。このインターフェースには、ユーザーの詳細情報へアクセスするためのGetterメソッドなどが定義されています。

このタグを宣言すると、Userクラスのインスタンスが生成されます。

name、password、authorities属性で、ユーザーを識別する名前、パスワード、権限を指定できます。

表示画面

src/main/webapp/index.jsp

<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8" />
        <title>Hello Spring Security!!</title>
    </head>
    <body>
        <h1>Hello Spring Security!!</h1>

        <c:url var="logoutUrl" value="/logout" />
        <form action="${logoutUrl}" method="post">
            <input type="submit" value="logout" />
            <input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}" />
        </form>
    </body>
</html>

CSRF（Cross-site request forgery: クロスサイトリクエストフォージェリ）

デフォルトでは、CSRF対策設定はtrueです。そのため、リクエストを送信するときはCSRF対策としてトークンを渡す必要があります。

トークン値やパラメータ名は、リクエストスコープに_csrfという名前で保存されています。

CSRF対策についての詳しい説明は、後で改めて説明します。

動作確認

gradle warコマンドでWARファイル（spring-security-sample.war）を作成し、Tomcatへデプロイします。デプロイは、{Tomcatインストールパス}/webappsへWARファイルを置くだけです。

ファイルを置いたら、ブラウザでhttp://localhost:8080/spring-security-sampleへアクセスしてみます。

ログイン画面が表示されたら、UserとPasswordにそれぞれdevkuma、1234を入力し、Loginボタンをクリックします。

index.jspの内容が表示されます。その後、ログアウトボタンをクリックします。

ログアウトが完了し、ログインページへ戻ります。

もしログインに失敗すると、上記のようにエラーメッセージが赤い文字で表示されます。

Spring Security | Spring Securityとは | Java Configuration

kc@example.com (kc kim) — Wed, 04 Oct 2017 22:41:52 +0900

Spring Security 3.2は、Spring 3.1で追加されたJava Configurationをサポートします。XMLなしでnamespace相当の設定を記述でき、コンパイル時チェックとリファクタリングが容易になります。

Hello WorldをJava Configurationへ置き換える

web.xmlでXmlWebApplicationContextの代わりにAnnotationConfigWebApplicationContextを使用します。

<context-param>
    <param-name>contextClass</param-name>
    <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
</context-param>
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>sample.spring.security.MySpringSecurityConfig</param-value>
</context-param>

コンテナの実装

@EnableWebSecurity
public class MySpringSecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/login").permitAll()
                .anyRequest().authenticated()
                .and()
                .formLogin();
    }

    @Autowired
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
                .withUser("devkuma").password("1234").roles("USER");
    }
}

Spring Securityを有効化する

AnnotationConfigWebApplicationContextが読み込むクラスへ@EnableWebSecurityを付与します。このアノテーションはWebSecurityConfigurationをimportし、グローバル認証を有効化します。

Spring Securityを設定する

WebSecurityConfigurerAdapterを継承し、configure(HttpSecurity)などをオーバーライドします。HttpSecurityはXMLの<http>要素に対応します。

authorizeRequests()でURL認可設定を開始します。
and()はHttpSecurityを返し、メソッドチェーンを続けます。
formLogin()はフォーム認証を有効化します。

この例は次のXMLに相当します。

<sec:http>
    <sec:intercept-url pattern="/login" access="permitAll" />
    <sec:intercept-url pattern="/**" access="isAuthenticated()" />
    <sec:form-login />
    <sec:logout />
</sec:http>

ユーザー情報を設定する

AuthenticationManagerBuilderはAuthenticationManagerの定義を支援し、UserDetailsServiceをメソッドチェーンで設定できます。Beanを直接定義することもできます。

@Bean
public UserDetailsService userDetailsService() {
    InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
    manager.createUser(User.withUsername("hoge").password("HOGE").roles("USER").build());
    return manager;
}

Spring Security | Spring Securityとは | web.xmlなしで使用する

kc@example.com (kc kim) — Wed, 04 Oct 2017 22:41:52 +0900

アプリケーションサーバーがServlet 3.0以降に対応している場合、web.xmlなしでSpring Securityを使用できます。

.
├── build.gradle
└── src
    └── main
        ├── java
        │   └── sample
        │       └── spring
        │           └── security
        │               ├── MySpringSecurityConfig.java
        │               └── MySpringSecurityInitializer.java
        └── webapp
            └── index.jsp

src/main/java/sample/spring/security/MySpringSecurityInitializer.java

package sample.spring.security;

import org.springframework.security.web.context.AbstractSecurityWebApplicationInitializer;

public class MySpringSecurityInitializer extends AbstractSecurityWebApplicationInitializer {
    public MySpringSecurityInitializer() {
        super(MySpringSecurityConfig.class);
    }
}

MySpringSecurityConfig.javaとindex.jspは変更がないため省略します。

web.xmlを削除し、MySpringSecurityInitializerを追加します。このクラスはAbstractSecurityWebApplicationInitializerを継承し、親コンストラクターへJava設定クラスを渡します。これにより、以前のweb.xml設定は不要になります。

構造

この機能はServlet 3.0で追加されたAPIを使用します。

ServletContainerInitializer

AbstractSecurityWebApplicationInitializerはWebApplicationInitializerを実装します。Javadocには、実装がSpringServletContainerInitializerによって自動検出され、Servlet 3.0コンテナによって自動的に起動されると説明されています。

WebApplicationInitializer.java

/**
 * ...
 *
 * <p>Implementations of this SPI will be detected automatically by {@link
 * SpringServletContainerInitializer}, which itself is bootstrapped automatically
 * by any Servlet 3.0 container. See {@linkplain SpringServletContainerInitializer its
 * Javadoc} for details on this bootstrapping mechanism.
 * ...
 */
public interface WebApplicationInitializer {

SpringServletContainerInitializerはServletContainerInitializerを実装し、@HandlesTypesが付与されています。

@HandlesTypes(WebApplicationInitializer.class)
public class SpringServletContainerInitializer implements ServletContainerInitializer {
   ...

サーブレットコンテナの起動時にonStartup(Set<Class<?>>, ServletContext)が実行されます。コンテナは@HandlesTypesで指定された型に関連するクラスを検出し、第1引数へ渡します。SpringServletContainerInitializerはWebApplicationInitializerの実装を受け取り、インスタンスを作成してonStartup(ServletContext)を実行します。

AbstractSecurityWebApplicationInitializer

AbstractSecurityWebApplicationInitializer.onStartup(ServletContext)は、以前web.xmlで定義していた設定を実行します。

public abstract class AbstractSecurityWebApplicationInitializer
        implements WebApplicationInitializer {

    public static final String DEFAULT_FILTER_NAME = "springSecurityFilterChain";

    public final void onStartup(ServletContext servletContext) throws ServletException {
        beforeSpringSecurityFilterChain(servletContext);
        if (this.configurationClasses != null) {
            AnnotationConfigWebApplicationContext rootAppContext = new AnnotationConfigWebApplicationContext();
            rootAppContext.register(this.configurationClasses);
            servletContext.addListener(new ContextLoaderListener(rootAppContext));
        }
        if (enableHttpSessionEventPublisher()) {
            servletContext.addListener(
                    "org.springframework.security.web.session.HttpSessionEventPublisher");
        }
        servletContext.setSessionTrackingModes(getSessionTrackingModes());
        insertSpringSecurityFilterChain(servletContext);
        afterSpringSecurityFilterChain(servletContext);
    }

    private void insertSpringSecurityFilterChain(ServletContext servletContext) {
        String filterName = DEFAULT_FILTER_NAME;
        DelegatingFilterProxy springSecurityFilterChain = new DelegatingFilterProxy(filterName);
        String contextAttribute = getWebApplicationContextAttribute();
        if (contextAttribute != null) {
            springSecurityFilterChain.setContextAttribute(contextAttribute);
        }
        registerFilter(servletContext, true, filterName, springSecurityFilterChain);
    }
}

要点は、以前web.xmlに記述していた設定を実装側で行うことです。

Spring Security | 認証

kc@example.com (kc kim) — Wed, 04 Oct 2017 22:41:52 +0900

Spring Security | 認証 | UserDetailsService: ユーザー情報検索

kc@example.com (kc kim) — Wed, 04 Oct 2017 22:41:52 +0900

ユーザー情報を検索する役割はUserDetailsServiceが担当する。Spring Securityには、UserDetailsServiceを実装したクラスがいくつか含まれている。

メモリを使用

ユーザー情報をメモリに保存する実装である。具体的なクラスはInMemoryUserDetailsManagerである。

XML Configuration

applicationContext.xml

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

    ...

    <sec:authentication-manager>
        <sec:authentication-provider>
            <sec:user-service>
                <sec:user name="hoge" password="HOGE" authorities="ROLE_USER" />
            </sec:user-service>
        </sec:authentication-provider>
    </sec:authentication-manager>
</beans>

<user-service>と<user>タグを使って宣言する。

Java Configuration

MySpringSecurityConfig.java

package sample.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.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@EnableWebSecurity
public class MySpringSecurityConfig extends WebSecurityConfigurerAdapter {

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

    @Autowired
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
                .withUser("hoge").password("HOGE").roles("USER");
    }
}

設定クラスにAuthenticationManagerBuilderを受け取るメソッドを宣言し、@Autowiredアノテーションを付与する。
inMemoryAuthentication()メソッドで定義情報を設定する。

JDBC

データベースからユーザー情報を取得する実装である。実際のクラスはJdbcUserDetailsManagerである。

build.gradle (追加依存関係)

    compile 'org.springframework:spring-jdbc:4.3.6.RELEASE'
    compile 'com.h2database:h2:1.4.193'

確認のため、DBにはH2を追加して使用する。
また、DataSourceを作成するためにspring-jdbcも依存関係に追加している。

src/main/resources/sql/create_database.sql

CREATE TABLE USERS (
    USERNAME VARCHAR_IGNORECASE(50) NOT NULL PRIMARY KEY,
    PASSWORD VARCHAR_IGNORECASE(50) NOT NULL,
    ENABLED  BOOLEAN NOT NULL
);

CREATE TABLE AUTHORITIES (
    USERNAME  VARCHAR_IGNORECASE(50) NOT NULL,
    AUTHORITY VARCHAR_IGNORECASE(50) NOT NULL,
    CONSTRAINT FK_AUTHORITIES_USERS FOREIGN KEY (USERNAME) REFERENCES USERS(USERNAME),
    CONSTRAINT UK_AUTHORITIES UNIQUE (USERNAME, AUTHORITY)
);

INSERT INTO USERS VALUES ('fuga', 'FUGA', true);
INSERT INTO AUTHORITIES VALUES ('fuga', 'USER');

基本的には、上記のようにテーブルカラムを宣言すると、ユーザー情報が自動的に検索される。
設定によって変更することもできる。
ファイルはクラスパス配下に配置する。後でデータソースを作成するときの初期化スクリプトとして使用する。

XML Configuration

applicationContext.xml

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

    ...

    <jdbc:embedded-database id="dataSource" type="H2">
        <jdbc:script location="classpath:/sql/create_database.sql" />
    </jdbc:embedded-database>

    <sec:authentication-manager>
        <sec:authentication-provider>
            <sec:jdbc-user-service data-source-ref="dataSource"  />
        </sec:authentication-provider>
    </sec:authentication-manager>
</beans>

<jdbc-user-service>タグを使用する。
データソースの定義では、<jdbc:script>タグを使って上記の初期化スクリプトを実行する。

Java Configuration

MySpringSecurityConfig.java

package sample.spring.security;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;
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.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

import javax.sql.DataSource;

@EnableWebSecurity
public class MySpringSecurityConfig extends WebSecurityConfigurerAdapter {

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

    @Bean
    public DataSource dataSource() {
        return new EmbeddedDatabaseBuilder()
                .generateUniqueName(true)
                .setType(EmbeddedDatabaseType.H2)
                .setScriptEncoding("UTF-8")
                .addScript("/sql/create_database.sql")
                .build();
    }

    @Autowired
    public void configure(AuthenticationManagerBuilder auth, DataSource dataSource) throws Exception {
        auth.jdbcAuthentication().dataSource(dataSource);
    }
}

AuthenticationManagerBuilderのjdbcAuthentication()メソッドを使用する。

テーブル名とカラム名の変更

CREATE TABLE USERS (
    LOGIN_ID VARCHAR_IGNORECASE(50) NOT NULL PRIMARY KEY,
    PASSWORD VARCHAR_IGNORECASE(50) NOT NULL,
    ENABLED  BOOLEAN NOT NULL
);

CREATE TABLE AUTHORITIES (
    LOGIN_ID  VARCHAR_IGNORECASE(50) NOT NULL,
    ROLE VARCHAR_IGNORECASE(50) NOT NULL,
    CONSTRAINT FK_AUTHORITIES_USERS FOREIGN KEY (LOGIN_ID) REFERENCES USERS(LOGIN_ID),
    CONSTRAINT UK_AUTHORITIES UNIQUE (LOGIN_ID, ROLE)
);

USERNAMEをLOGIN_IDに、AUTHORITYをROLEに変更してみる。
テーブル名とカラム名を任意のものに変更するには、ユーザー情報を検索するときのSQLを変更する。
検索時に項目の順序だけ一致していれば、カラム名は何でも構わない。

XML Configuration

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:sec="http://www.springframework.org/schema/security"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:jdbc="http://www.springframework.org/schema/jdbc"
       ...>

    ...

    <sec:authentication-manager>
        <sec:authentication-provider>
            <sec:jdbc-user-service
                data-source-ref="dataSource"
                users-by-username-query="SELECT LOGIN_ID, PASSWORD, ENABLED FROM USERS WHERE LOGIN_ID=?"
                authorities-by-username-query="SELECT LOGIN_ID, ROLE FROM AUTHORITIES WHERE LOGIN_ID=?" />
        </sec:authentication-provider>
    </sec:authentication-manager>
</beans>

users-by-username-query属性で、USERNAME、PASSWORD、ENABLEDを検索するクエリを定義する。
authorities-by-username-query属性で、USERNAME、AUTHORITYを検索するクエリを定義する。

Java Configuration

MySpringSecurityConfig.java

package sample.spring.security;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;
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.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

import javax.sql.DataSource;

@EnableWebSecurity
public class MySpringSecurityConfig extends WebSecurityConfigurerAdapter {

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

    @Bean
    public DataSource dataSource() {
        ...
    }

    @Autowired
    public void configure(AuthenticationManagerBuilder auth, DataSource dataSource) throws Exception {
        auth.jdbcAuthentication().dataSource(dataSource)
        .usersByUsernameQuery("SELECT LOGIN_ID, PASSWORD, ENABLED FROM USERS WHERE LOGIN_ID=?")
        .authoritiesByUsernameQuery("SELECT LOGIN_ID, ROLE FROM AUTHORITIES WHERE LOGIN_ID=?");
    }
}

usersByUsernameQuery(String)メソッドで、USERNAME、PASSWORD、ENABLEDを検索するクエリを定義する。
authoritiesByUsernameQuery(String)メソッドで、USERNAME、AUTHORITYを検索するクエリを定義する。

UserDetailsServiceを作る

MyUserDetailsService.java

package sample.spring.security;

import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;

public class MyUserDetailsService implements UserDetailsService {
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        if ("hoge".equals(username)) {
            return new User(username, "HOGE", AuthorityUtils.createAuthorityList("USER"));
        }

        throw new UsernameNotFoundException("not found : " + username);
    }
}

UserDetailsServiceを実装したクラスを作成する。
UserDetailsServiceにはloadUserByUsername(String)というメソッドが一つだけ存在する。
- 引数にはユーザーを識別する文字列、通常はログイン画面などで入力されたユーザー名が入るため、その識別文字列に対応するユーザー情報を返す。
- 該当するユーザー情報がない場合は、UsernameNotFoundExceptionをthrowする。
ユーザー情報はUserDetailsインターフェースを実装したクラスとして作成する。
- 標準でUserというクラスが用意されている。
- 何らかの事情でUserクラスを変更する必要がある場合は、UserDetailsインターフェースを実装したクラスを作成すればよい。

Spring Security | 認証 | BCryptPasswordEncoder: パスワードハッシュ

kc@example.com (kc kim) — Wed, 04 Oct 2017 22:41:52 +0900

パスワードをハッシュ化する理由

データが漏洩した場合、パスワードを平文で保存していると非常に危険です。通常、元の文字列を特定できない形式で保存します。復号が不要な場合は、ハッシュ関数を使用します。

BCrypt

MD5やSHAはよく知られたハッシュ関数ですが、パスワードのハッシュ化にはBCryptが便利です。

ハッシュ関数を1回適用するだけでは、総当たり攻撃、辞書攻撃、レインボーテーブルに対して脆弱です。

BCryptはランダムなsaltを追加し、複数回ハッシュ化するため、元のパスワードを推測しにくくします。Spring SecurityもBCryptを推奨しています。

実装

DaoAuthenticationProviderへPasswordEncoderを設定します。BCryptを使用する場合は、BCryptPasswordEncoder実装を使用します。BCryptのハッシュ値は事前に計算して保存します。

XML Configuration

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:sec="http://www.springframework.org/schema/security"
       ...>

    ...

    <bean id="passwordEncoder"
          class="org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder"/>

    <sec:authentication-manager>
        <sec:authentication-provider>
            <sec:user-service>
                <sec:user
                    name="hoge"
                    password="$2a$08$CekzJRYhb5bzp5mx/eZmX.grG92fRXo267QVVyRs0IE.V.zeCIw8S"
                    authorities="ROLE_USER" />
            </sec:user-service>

            <sec:password-encoder ref="passwordEncoder" />
        </sec:authentication-provider>
    </sec:authentication-manager>
</beans>

BCryptPasswordEncoderをBeanとして定義し、<password-encoder>のref属性へ指定します。
<password-encoder>は<authentication-provider>の子要素として設定します。

Java Configuration

MySpringSecurityConfig.java

package sample.spring.security;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
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.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@EnableWebSecurity
public class MySpringSecurityConfig extends WebSecurityConfigurerAdapter {

    ...

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Autowired
    public void configure(AuthenticationManagerBuilder auth, PasswordEncoder passwordEncoder) throws Exception {
        auth.inMemoryAuthentication()
            .passwordEncoder(passwordEncoder)
            .withUser("hoge")
            .password("$2a$08$CekzJRYhb5bzp5mx/eZmX.grG92fRXo267QVVyRs0IE.V.zeCIw8S")
            .roles("USER");
    }
}

AbstractDaoAuthenticationConfigurerのpasswordEncoder()メソッドへPasswordEncoderを指定します。
AbstractDaoAuthenticationConfigurerは、AuthenticationManagerBuilder.inMemoryAuthentication()が返すInMemoryUserDetailsManagerConfigurerの親クラスです。

パスワードのエンコード

パスワードをエンコードするには、コンテナからPasswordEncoderを取得し、encode()を使用します。

EncodePasswordServlet.java

package sample.spring.security.servlet;

import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/encode-password")
public class EncodePasswordServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        WebApplicationContext context = WebApplicationContextUtils.getRequiredWebApplicationContext(req.getServletContext());
        PasswordEncoder passwordEncoder = context.getBean(PasswordEncoder.class);

        String password = req.getParameter("password");
        String encode = passwordEncoder.encode(password);
        System.out.println(encode);
    }
}

設定は前述と同じで、BCryptPasswordEncoderをBeanとして登録します。
例では動作確認のためPasswordEncoderを明示的に取得しています。実際にはコンテナ管理Beanへ注入します。
http://localhost:8080/encode-password?password=fugaへアクセスします。

サーバーコンソール出力

$2a$10$2qVDkAqxp8eDrxR8Be2ZpubYGOCVZ7Qy9uK/XzOIY1ZoxpChtrWDK

Spring Security | 認証 | Authentication

kc@example.com (kc kim) — Wed, 04 Oct 2017 22:41:52 +0900

AuthenticationはSpring Securityを構成する重要なクラスの一つです。ユーザー名や付与された権限など、認証済みユーザーの情報を保持します。

認証に成功すると、AuthenticationProviderは認証済みのAuthenticationオブジェクトを作成して返します。isAuthenticated()はtrueを返します。その後の認可チェックなどで、このオブジェクトを参照します。

Authenticationの取得と参照できる情報

SecurityContextHolderSampleServlet.java

package sample.spring.security.servlet;

import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.web.authentication.WebAuthenticationDetails;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

import static java.util.stream.Collectors.*;

@WebServlet("/authentication")
public class SecurityContextHolderSampleServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        System.out.println("[authorities]");
        System.out.println("  " + auth.getAuthorities().stream()
                                    .map(GrantedAuthority::getAuthority)
                                    .collect(joining("\n  ")));

        WebAuthenticationDetails details = (WebAuthenticationDetails) auth.getDetails();
        System.out.println("[details]");
        System.out.println("  IP Address : " + details.getRemoteAddress());
        System.out.println("  Session ID : " + details.getSessionId());

        UserDetails principal = (UserDetails) auth.getPrincipal();
        System.out.println("[principal]");
        System.out.println("  username : " + principal.getUsername());
        System.out.println("  password : " + principal.getPassword());

        System.out.println("[credentials]");
        System.out.println("  " + auth.getCredentials());
    }
}

実行結果

[authorities]
  USER
[details]
  IP Address : 0:0:0:0:0:0:0:1
  Session ID : 0225051BCDFE2C34D55DF4FA9D9685C2
[principal]
  username : hoge
  password : null
[credentials]
  null

現在のリクエストに関連するAuthenticationは、SecurityContextHolder.getContext().getAuthentication()で取得します。
- SecurityContextHolder.getContext()は、現在のリクエストに関連するSecurityContextを返します。
Authentication.getAuthorities()は、ログインユーザーに付与された権限を返します。
Authentication.getDetails()は、デフォルトでWebAuthenticationDetailsを返します。
- IPアドレスとセッションIDを取得できます。
Authentication.getPrincipal()は、ログインユーザーのUserDetailsを返します。
Authentication.getCredentials()は認証に使用する情報、通常はログインパスワードを返します。

安全のため、ログイン成功後にAuthenticationManager（ProviderManager）がパスワード情報をnullへ設定して明示的に削除します。eraseCredentialsAfterAuthenticationオプションで削除を無効にできます。

Authenticationの保存場所

認証後、Authenticationを保持するSecurityContextはデフォルトでHttpSessionへ保存されます。

同じセッションで再度アクセスすると、保存されたSecurityContextが取得され、SecurityContextHolderへ設定されます。

デフォルトでは、SecurityContextHolderはThreadLocalを通じてSecurityContextを保存します。これにより、現在のリクエストに関連するコンテキストへグローバルにアクセスできます。

厳密には、SecurityContextHolderはSecurityContextHolderStrategyのインスタンスを保持します。ThreadLocalSecurityContextHolderStrategyがSecurityContextをThreadLocalへ保存します。

SecurityContextPersistenceFilterがSecurityContextの読み書きとリクエスト単位のThreadLocalのクリアを行います。

ThreadLocal以外の保存方法

SecurityContextHolderStrategyには、ThreadLocalSecurityContextHolderStrategy以外にも2つの実装があります。

GlobalSecurityContextHolderStrategy

アプリケーション全体で1つのSecurityContextを保存します。

実行ユーザーが1人だけの可能性があるスタンドアロンアプリケーションなどで役立ちます。複数のスレッドを作成しても、すべてで同じ認証情報を共有できます。

InheritableThreadLocalSecurityContextHolderStrategy

新しいスレッドを作成した場合に、親スレッドのSecurityContextを共有します。

複数ユーザーが利用するアプリケーションで、ユーザーごとの処理から新しいスレッドを作成し、バックグラウンド処理を実行する場合に役立ちます。スレッドは分かれますが、認証情報は親スレッドから継承します。

保存方式は次のいずれかの方法で変更できます。

システムプロパティで指定する

システムプロパティspring.security.strategyをJVM起動オプションで渡します。

Tomcat起動時に指定する場合

$ set JAVA_OPTS=-Dspring.security.strategy=MODE_INHERITABLETHREADLOCAL

$ cd %TOMCAT_HOME%\bin

$ startup.bat

staticメソッドで指定する

SecurityContextHolder.setStrategyName(SecurityContextHolder.MODE_INHERITABLETHREADLOCAL);

SecurityContextHolderにはsetStrategyName(String)が用意されています。引数にはSecurityContextHolderで定義された定数を指定します。

Spring Security

kc@example.com (kc kim) — Wed, 04 Oct 2017 22:41:52 +0900

Spring Securityは強力な認証システムを提供します。ここでは基本から説明します。

devkuma – Spring Security

Spring Security | Spring Securityとは

Spring Security | Spring Securityとは | 認証（Authentication）と認可（Authorization）

認証（Authentication）とは？

認可（Authorization）とは？

認証と認可の違い

SpringとKotlinで作成したWebMVC MCP Serverへ認証を追加する

はじめに

認証を追加する

MCP Serverのセキュリティ設定を作成する

テストクライアントを実装する

参考資料

Spring Security | Spring Securityとは | Hello World

ビルドスクリプトでの依存関係

spring-security-web

spring-security-config

Springコンテナの初期化

Spring Securityをアプリケーションへ適用

Spring Security設定

<http>

<intercept-url>

<form-login>

<logout>

<authentication-manager>

<authentication-manager>

<authentication-provider>

<user-service>

<user>

表示画面

CSRF（Cross-site request forgery: クロスサイトリクエストフォージェリ）

動作確認

Spring Security | Spring Securityとは | Java Configuration

Hello WorldをJava Configurationへ置き換える

コンテナの実装

Spring Securityを有効化する

Spring Securityを設定する

ユーザー情報を設定する

Spring Security | Spring Securityとは | web.xmlなしで使用する

構造

ServletContainerInitializer

AbstractSecurityWebApplicationInitializer

Spring Security | 認証

Spring Security | 認証 | UserDetailsService: ユーザー情報検索

メモリを使用

XML Configuration

Java Configuration

JDBC

XML Configuration

Java Configuration

テーブル名とカラム名の変更

XML Configuration

Java Configuration

UserDetailsServiceを作る

Spring Security | 認証 | BCryptPasswordEncoder: パスワードハッシュ

パスワードをハッシュ化する理由

BCrypt

実装

XML Configuration

Java Configuration

パスワードのエンコード

Spring Security | 認証 | Authentication

Authenticationの取得と参照できる情報

Authenticationの保存場所

ThreadLocal以外の保存方法

GlobalSecurityContextHolderStrategy

InheritableThreadLocalSecurityContextHolderStrategy

システムプロパティで指定する

Spring Security