building-role-mining-for-rbac-optimization

RBAC 最適化のためのロールマイニング

概要

ロールマイニングとは、既存のユーザーと権限の割り当てを分析し、ロールベースのアクセス制御（RBAC）システムに最適なロールを見つけるプロセスです。組織では、異動やプロジェクトへの配属、場当たり的なアクセス権の付与により、過剰な権限が蓄積していきます。その結果、多数の細分化されたロールが存在し、互いに大きく重複する「ロールの爆発」が発生します。ロールマイニングでは、クラスタリングアルゴリズム、形式概念分析、グラフベースの手法などのデータ分析を用いて権限を最小限のロールセットに集約し、最小権限を徹底しながら、業務機能を正確に表現します。

使用する場面

• 環境にロールマイニングによる RBAC 最適化機能を導入または設定する場合
• コンプライアンス要件に沿ったセキュリティ制御を確立する場合
• この分野のセキュリティアーキテクチャを構築または改善する場合
• この実装を必要とするセキュリティ評価を実施する場合

前提条件

• 現在のユーザーと権限の割り当てデータのエクスポート（CSV／データベース）
• ID ガバナンスプラットフォームまたはディレクトリサービスへのアクセス
• pandas、scikit-learn、numpy を含む Python 3.9+
• 組織構造と職務への理解
• ロール検証ワークショップに参加する関係者へのアクセス

主な概念

ロールマイニングのアプローチ

アプローチ	説明	最適な用途
ボトムアップ	既存の権限を分析して共通のパターンを見つけます	権限が自然に増加した大規模なデータセット
トップダウン	業務要件と職務記述書に基づいてロールを設計します	新規の RBAC 導入または組織再編
ハイブリッド	ボトムアップ分析とトップダウンによる業務検証を組み合わせます	ほとんどの本番環境

ロールマイニングアルゴリズム

1. 権限クラスタリング：k-means または階層型クラスタリングを使用して、類似した権限セットを持つユーザーをグループ化します。同じクラスター内のユーザーは、共通のロールを共有します。

2. 形式概念分析（FCA）：ユーザーと権限の二値行列から、完全な概念の集合（まったく同じ権限セットを共有するユーザーグループ）を特定する数学的フレームワークです。

3. グラフベースのマイニング：ユーザーと権限を二部グラフとしてモデル化し、候補ロールを表す密な部分グラフを見つけます。

4. ブール行列分解：ユーザーと権限の行列 U を、U ≈ R × P として分解します。ここで、R はユーザーとロールの対応を、P はロールと権限の対応を表します。

ロールマイニングの指標

指標	数式	目標
ロール数	マイニング後の個別ロールの合計数	最小化
カバレッジ	マイニングしたロールで説明できる権限 / 権限の合計	> 95%
加重構造複雑度（WSC）	ロールとユーザーの割り当て数 + ロールと権限の割り当て数の合計	最小化
逸脱	割り当てたロールでカバーされない余分な権限	< 5%

ワークフロー

ステップ 1：ユーザーと権限のデータを抽出する

すべての ID ソースから現在のアクセス状態を収集します。

import pandas as pd
import numpy as np

# Load user-permission assignments
# Format: user_id, permission_id (one row per assignment)
assignments = pd.read_csv("user_permissions.csv")

# Create binary user-permission matrix (UPA matrix)
upa_matrix = assignments.pivot_table(
    index="user_id",
    columns="permission_id",
    aggfunc="size",
    fill_value=0
)
upa_matrix = (upa_matrix > 0).astype(int)

print(f"Users: {upa_matrix.shape[0]}")
print(f"Permissions: {upa_matrix.shape[1]}")
print(f"Assignments: {assignments.shape[0]}")
print(f"Density: {upa_matrix.values.sum() / upa_matrix.size:.2%}")

ステップ 2：クラスタリングによるボトムアップのロール検出

from sklearn.cluster import AgglomerativeClustering
from sklearn.metrics import silhouette_score

def find_optimal_clusters(matrix, max_k=50):
    """Find optimal number of roles using silhouette analysis."""
    scores = []
    for k in range(2, min(max_k, matrix.shape[0])):
        clustering = AgglomerativeClustering(
            n_clusters=k, metric="jaccard", linkage="average"
        )
        labels = clustering.fit_predict(matrix)
        score = silhouette_score(matrix, labels, metric="jaccard")
        scores.append((k, score))

    optimal_k = max(scores, key=lambda x: x[1])[0]
    return optimal_k, scores

def mine_roles_clustering(upa_matrix, n_clusters):
    """Mine roles using hierarchical clustering on Jaccard distance."""
    clustering = AgglomerativeClustering(
        n_clusters=n_clusters, metric="jaccard", linkage="average"
    )
    user_matrix = upa_matrix.values
    labels = clustering.fit_predict(user_matrix)

    roles = {}
    for cluster_id in range(n_clusters):
        cluster_users = upa_matrix.index[labels == cluster_id]
        cluster_permissions = upa_matrix.loc[cluster_users]

        # Core role = permissions held by >80% of cluster members
        permission_frequency = cluster_permissions.mean()
        core_permissions = permission_frequency[permission_frequency >= 0.8].index.tolist()

        roles[f"Role_{cluster_id}"] = {
            "permissions": core_permissions,
            "user_count": len(cluster_users),
            "users": cluster_users.tolist(),
            "coverage": permission_frequency[permission_frequency >= 0.8].mean()
        }

    return roles, labels

ステップ 3：形式概念分析

def mine_roles_fca(upa_matrix, min_support=3):
    """Mine roles using Formal Concept Analysis (frequent closed itemsets)."""
    from itertools import combinations

    users = upa_matrix.index.tolist()
    permissions = upa_matrix.columns.tolist()

    concepts = []

    # Find all maximal permission sets shared by at least min_support users
    for size in range(len(permissions), 0, -1):
        for perm_combo in combinations(permissions, size):
            perm_set = set(perm_combo)
            # Find users who have ALL permissions in this set
            matching_users = []
            for user in users:
                user_perms = set(upa_matrix.columns[upa_matrix.loc[user] == 1])
                if perm_set.issubset(user_perms):
                    matching_users.append(user)

            if len(matching_users) >= min_support:
                # Check if this is a closed concept (no superset with same extent)
                is_closed = True
                for concept in concepts:
                    if set(matching_users) == set(concept["users"]) and \
                       perm_set.issubset(set(concept["permissions"])):
                        is_closed = False
                        break

                if is_closed:
                    concepts.append({
                        "permissions": list(perm_set),
                        "users": matching_users,
                        "support": len(matching_users)
                    })

        if len(concepts) > 100:  # Limit for performance
            break

    return concepts

ステップ 4：ロールを評価して選択する

def evaluate_role_set(roles, upa_matrix):
    """Evaluate the quality of a mined role set."""
    total_assignments = upa_matrix.values.sum()
    covered_assignments = 0
    extra_assignments = 0

    for role_name, role_data in roles.items():
        role_perms = set(role_data["permissions"])
        for user in role_data["users"]:
            user_perms = set(upa_matrix.columns[upa_matrix.loc[user] == 1])
            covered = role_perms.intersection(user_perms)
            extra = role_perms - user_perms
            covered_assignments += len(covered)
            extra_assignments += len(extra)

    metrics = {
        "total_roles": len(roles),
        "total_assignments": total_assignments,
        "covered_assignments": covered_assignments,
        "coverage_rate": covered_assignments / total_assignments if total_assignments else 0,
        "extra_permissions": extra_assignments,
        "deviation_rate": extra_assignments / (covered_assignments + extra_assignments) if (covered_assignments + extra_assignments) else 0,
        "avg_role_size": np.mean([len(r["permissions"]) for r in roles.values()]),
        "avg_users_per_role": np.mean([r["user_count"] for r in roles.values()]),
    }
    return metrics

ステップ 5：業務検証

候補ロールをマイニングした後、次の作業を行います。

1. マイニングしたロールを業務機能（部門、役職）に対応付けます
2. 部門管理者とのワークショップを実施し、ロール定義を検証します
3. 設定ミスを示す可能性のある外れ値の権限を特定します
4. フィードバックに基づいてロールを調整し、指標を再評価します
5. 業務上の根拠を添えてロール定義を文書化します

検証チェックリスト

• すべてのアイデンティティソースからユーザー権限マトリックスを抽出済み
• 複数のマイニングアルゴリズム（クラスタリング、FCA）を比較済み
• シルエット分析またはWSCを用いて最適なロール数を決定済み
• カバレッジ率が既存の割り当ての95%を超えている
• 逸脱率が5%未満（追加権限を最小限に抑えている）
• マイニングしたロールをビジネス関係者が検証済み
• ロール階層を定義済み（親子間の継承）
• 例外／外れ値となる権限を文書化済み
• 新しいロールモデルへの移行計画を作成済み
• 継続的なロールガバナンスプロセスを定義済み

参考資料

• ロールマイニング：RBACの最適化 - NIST
• RBAC標準 - ANSI/INCITS 359-2012
• ロールエンジニアリングのための形式概念分析
• scikit-learnのクラスタリングに関するドキュメント