Operator セキュリティ — 最小権限 RBAC、マルチテナンシー、サプライチェーン

攻撃経路 1: コントローラ Pod の侵害
  アプリケーション脆弱性(RCE) -> コントローラ Pod のシェル取得
  -> ServiceAccount トークンの窃取(/var/run/secrets/...)
  -> Operator のすべての RBAC 権限を行使
  -> 例: 全 namespace の Secret 読み取り、ClusterRoleBinding 作成

攻撃経路 2: CR を通じた権限昇格
  悪意あるユーザーが CR を作成/変更
  -> Operator がその CR を信頼して RBAC オブジェクトを作成
  -> ユーザーが直接持てなかった権限を迂回して取得

攻撃経路 3: サプライチェーン
  Operator イメージのビルドパイプラインまたはベースイメージの侵害
  -> 悪意あるコードを含むイメージがクラスタにデプロイ
  -> 正常な Operator に見えるがバックドアを含む

攻撃経路 4: メトリクス/Webhook エンドポイント
  認証なしのメトリクスエンドポイント公開 -> 内部情報の漏洩
  TLS 非適用の Webhook -> 中間者攻撃で admission を迂回

// WidgetReconciler は Widget カスタムリソースを reconcile します。
type WidgetReconciler struct {
	client.Client
	Scheme *runtime.Scheme
}

// +kubebuilder:rbac:groups=apps.example.com,resources=widgets,verbs=get;list;watch;create;update;patch;delete
// +kubebuilder:rbac:groups=apps.example.com,resources=widgets/status,verbs=get;update;patch
// +kubebuilder:rbac:groups=apps.example.com,resources=widgets/finalizers,verbs=update
// +kubebuilder:rbac:groups=apps,resources=deployments,verbs=get;list;watch;create;update;patch;delete
// +kubebuilder:rbac:groups=core,resources=services,verbs=get;list;watch;create;update;patch;delete
// +kubebuilder:rbac:groups=core,resources=events,verbs=create;patch
func (r *WidgetReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
	log := logf.FromContext(ctx)

	var widget appsv1alpha1.Widget
	if err := r.Get(ctx, req.NamespacedName, &widget); err != nil {
		// NotFound は正常 — 削除済みオブジェクトの再キューイングの可能性
		return ctrl.Result{}, client.IgnoreNotFound(err)
	}

	// 望ましい状態(desired state)を計算し、Deployment を保証
	desired := r.buildDeployment(&widget)
	if err := r.ensureDeployment(ctx, desired); err != nil {
		log.Error(err, "deployment の保証に失敗")
		return ctrl.Result{}, err
	}

	return ctrl.Result{}, nil
}

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: widget-manager-role
rules:
  - apiGroups: ["apps.example.com"]
    resources: ["widgets"]
    verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
  - apiGroups: ["apps.example.com"]
    resources: ["widgets/status"]
    verbs: ["get", "update", "patch"]
  - apiGroups: ["apps.example.com"]
    resources: ["widgets/finalizers"]
    verbs: ["update"]
  - apiGroups: ["apps"]
    resources: ["deployments"]
    verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
  - apiGroups: [""]
    resources: ["services"]
    verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
  - apiGroups: [""]
    resources: ["events"]
    verbs: ["create", "patch"]

# リーダー選出専用 Role — 名前が明示された Lease 一つだけを変更可能
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: widget-leader-election-role
  namespace: widget-system
rules:
  - apiGroups: ["coordination.k8s.io"]
    resources: ["leases"]
    verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
    resourceNames: ["widget-operator-leader"]

Role + RoleBinding             -> 特定の namespace 内でのみ有効
ClusterRole + ClusterRoleBinding -> クラスタ全体で有効
ClusterRole + RoleBinding      -> ClusterRole 定義を特定 namespace に限定して適用

mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{
	Scheme: scheme,
	// キャッシュを特定 namespace に限定 — クラスタ全体の watch をしない
	Cache: cache.Options{
		DefaultNamespaces: map[string]cache.Config{
			"widget-system": {},
			"tenant-a":      {},
		},
	},
	Metrics: server.Options{
		BindAddress: ":8443",
	},
})
if err != nil {
	setupLog.Error(err, "マネージャーの生成に失敗")
	os.Exit(1)
}

import (
	"crypto/tls"

	"sigs.k8s.io/controller-runtime/pkg/metrics/filters"
	metricsserver "sigs.k8s.io/controller-runtime/pkg/metrics/server"
)

func main() {
	// ... scheme 登録などは省略 ...

	metricsServerOptions := metricsserver.Options{
		BindAddress:   ":8443",
		SecureServing: true,
		// 入ってくるメトリクススクレイプ要求を認証/認可
		// SubjectAccessReview で非リソース URL /metrics へのアクセス権を確認
		FilterProvider: filters.WithAuthenticationAndAuthorization,
		TLSOpts: []func(*tls.Config){
			func(c *tls.Config) {
				c.MinVersion = tls.VersionTLS13
			},
		},
	}

	mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{
		Scheme:                 scheme,
		Metrics:                metricsServerOptions,
		HealthProbeBindAddress: ":8081",
		LeaderElection:         true,
		LeaderElectionID:       "widget-operator-leader",
	})
	if err != nil {
		setupLog.Error(err, "マネージャーの生成に失敗")
		os.Exit(1)
	}

	// ... コントローラ登録、mgr.Start(...) ...
}

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: widget-metrics-reader
rules:
  - nonResourceURLs: ["/metrics"]
    verbs: ["get"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: widget-metrics-reader-binding
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: widget-metrics-reader
subjects:
  - kind: ServiceAccount
    name: prometheus
    namespace: monitoring

# cert-manager Certificate — Webhook サーバー TLS 証明書
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: widget-serving-cert
  namespace: widget-system
spec:
  dnsNames:
    - widget-webhook-service.widget-system.svc
    - widget-webhook-service.widget-system.svc.cluster.local
  issuerRef:
    kind: Issuer
    name: widget-selfsigned-issuer
  secretName: widget-webhook-server-cert
  duration: 2160h    # 90 日
  renewBefore: 360h  # 失効 15 日前に更新

# ca-injector が caBundle を自動注入するようアノテーションを付与
apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingWebhookConfiguration
metadata:
  name: widget-validating-webhook
  annotations:
    cert-manager.io/inject-ca-from: widget-system/widget-serving-cert
webhooks:
  - name: vwidget.kb.io
    failurePolicy: Fail
    sideEffects: None
    admissionReviewVersions: ["v1"]
    clientConfig:
      service:
        name: widget-webhook-service
        namespace: widget-system
        path: /validate-apps-example-com-v1alpha1-widget
    rules:
      - apiGroups: ["apps.example.com"]
        apiVersions: ["v1alpha1"]
        operations: ["CREATE", "UPDATE"]
        resources: ["widgets"]

func (v *WidgetValidator) ValidateCreate(ctx context.Context, obj runtime.Object) (admission.Warnings, error) {
	widget, ok := obj.(*appsv1alpha1.Widget)
	if !ok {
		return nil, fmt.Errorf("Widget 型ではありません")
	}

	// セキュリティポリシー: 特権モードの要求を拒否
	if widget.Spec.Privileged {
		return nil, field.Forbidden(
			field.NewPath("spec", "privileged"),
			"特権モードはこのクラスタでは許可されていません",
		)
	}

	// セキュリティポリシー: 信頼されたレジストリのイメージのみ許可
	if !strings.HasPrefix(widget.Spec.Image, "registry.internal.example.com/") {
		return nil, field.Invalid(
			field.NewPath("spec", "image"),
			widget.Spec.Image,
			"内部レジストリのイメージのみ許可されます",
		)
	}

	return nil, nil
}

正常経路(ブロック):
  ユーザー -> 直接 RoleBinding 作成を試行(cluster-admin 付与)
  -> API サーバー: "あなたは cluster-admin を持たないので付与不可" -> 拒否

迂回経路(危険):
  ユーザー -> CR 作成(spec で cluster-admin を要求)
  -> Operator(強力な SA) -> CR を信頼して RoleBinding 作成
  -> ユーザーが迂回路で cluster-admin を取得

var forbiddenVerbs = map[string]bool{
	"escalate":    true,
	"bind":        true,
	"impersonate": true,
}

func (v *TenantRoleValidator) ValidateCreate(ctx context.Context, obj runtime.Object) (admission.Warnings, error) {
	tr, ok := obj.(*appsv1alpha1.TenantRole)
	if !ok {
		return nil, fmt.Errorf("TenantRole 型ではありません")
	}

	for _, rule := range tr.Spec.Rules {
		for _, verb := range rule.Verbs {
			if forbiddenVerbs[verb] {
				return nil, field.Forbidden(
					field.NewPath("spec", "rules"),
					fmt.Sprintf("動詞 %q はテナント Role では許可されていません", verb),
				)
			}
		}
		// cluster-scoped RBAC リソースの要求をブロック
		for _, res := range rule.Resources {
			if res == "clusterroles" || res == "clusterrolebindings" {
				return nil, field.Forbidden(
					field.NewPath("spec", "rules"),
					"cluster-scoped RBAC リソースはテナント Role では許可されていません",
				)
			}
		}
	}
	return nil, nil
}

戦略 A: 単一 Operator、多テナント(共有 Operator)
  一つの Operator インスタンスがすべてのテナント namespace の CR を処理
  利点: 運用がシンプル、リソース節約
  欠点: Operator 侵害時に全テナントに影響、分離が弱い

戦略 B: テナント別 Operator(専用 Operator)
  テナント namespace ごとに独立した Operator インスタンス
  利点: 強い分離、影響範囲の最小化
  欠点: 運用が複雑、リソースのオーバーヘッド

apiVersion: operators.coreos.com/v1
kind: OperatorGroup
metadata:
  name: tenant-a-operatorgroup
  namespace: tenant-a
spec:
  # この Operator は tenant-a namespace のみ監視
  targetNamespaces:
    - tenant-a

# テナント namespace へのインバウンドを同じテナントのみに制限
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: tenant-a-isolation
  namespace: tenant-a
spec:
  podSelector: {}
  policyTypes: ["Ingress"]
  ingress:
    - from:
        - namespaceSelector:
            matchLabels:
              tenant: tenant-a

# テナント別のリソース上限
apiVersion: v1
kind: ResourceQuota
metadata:
  name: tenant-a-quota
  namespace: tenant-a
spec:
  hard:
    requests.cpu: "20"
    requests.memory: 40Gi
    limits.cpu: "40"
    limits.memory: 80Gi
    count/widgets.apps.example.com: "50"

# cosign でイメージに署名(キーレス — OIDC アイデンティティを使用)
cosign sign --yes \
  registry.internal.example.com/widget-operator:v1.4.0

# SBOM を生成してイメージに添付
syft registry.internal.example.com/widget-operator:v1.4.0 \
  -o spdx-json > sbom.spdx.json
cosign attach sbom --sbom sbom.spdx.json \
  registry.internal.example.com/widget-operator:v1.4.0

# SBOM 自体にも署名
cosign attest --yes \
  --predicate sbom.spdx.json --type spdxjson \
  registry.internal.example.com/widget-operator:v1.4.0

# sigstore policy-controller — 信頼されたアイデンティティで署名されたイメージのみ許可
apiVersion: policy.sigstore.dev/v1beta1
kind: ClusterImagePolicy
metadata:
  name: require-signed-operator-images
spec:
  images:
    - glob: "registry.internal.example.com/widget-operator*"
  authorities:
    - keyless:
        identities:
          - issuer: https://token.actions.githubusercontent.com
            subject: https://github.com/example/widget-operator/.github/workflows/release.yml@refs/tags/v1.4.0

# マルチステージビルド — 最終イメージは distroless
FROM golang:1.26 AS builder
WORKDIR /workspace
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -a -o manager cmd/main.go

FROM gcr.io/distroless/static:nonroot
WORKDIR /
COPY --from=builder /workspace/manager .
USER 65532:65532
ENTRYPOINT ["/manager"]

// 悪い例: Secret 全体をロギング — 値が露出する
// log.Info("secret を取得", "secret", secret)

// 良い例: メタデータのみロギング、値は絶対に出力しない
log.Info("secret を取得",
	"name", secret.Name,
	"namespace", secret.Namespace,
	"keys", maps.Keys(secret.Data), // キー名のみ、値は除外
)

# API サーバーの EncryptionConfiguration — KMS provider で Secret を暗号化
apiVersion: apiserver.config.k8s.io/v1
kind: EncryptionConfiguration
resources:
  - resources: ["secrets"]
    providers:
      - kms:
          apiVersion: v2
          name: cluster-kms
          endpoint: unix:///var/run/kmsplugin/socket.sock
      - identity: {}

# API サーバー audit policy 抜粋 — Operator の書き込み操作を詳細に記録
apiVersion: audit.k8s.io/v1
kind: Policy
rules:
  # Operator SA の RBAC オブジェクト変更は RequestResponse レベルで全記録
  - level: RequestResponse
    users: ["system:serviceaccount:widget-system:widget-controller-manager"]
    verbs: ["create", "update", "patch", "delete"]
    resources:
      - group: "rbac.authorization.k8s.io"
        resources: ["roles", "rolebindings", "clusterroles", "clusterrolebindings"]
  # Secret アクセスは Metadata レベル(値はログに残さない)
  - level: Metadata
    resources:
      - group: ""
        resources: ["secrets"]
  # その他の Operator 書き込み操作は Request レベル
  - level: Request
    users: ["system:serviceaccount:widget-system:widget-controller-manager"]
    verbs: ["create", "update", "patch", "delete"]

// predicate で spec 変更にのみ反応 — status のみの更新による reconcile 暴走を防止
func (r *WidgetReconciler) SetupWithManager(mgr ctrl.Manager) error {
	return ctrl.NewControllerManagedBy(mgr).
		For(&appsv1alpha1.Widget{}).
		WithEventFilter(predicate.GenerationChangedPredicate{}).
		Owns(&appsv1.Deployment{}).
		Complete(r)
}

[ RBAC 最小権限 ]
  - すべての RBAC マーカーが実際にコードが使う動詞/リソースのみを付与しているか
  - verbs=* または resources=* ワイルドカードを除去したか
  - delete 権限は本当に必要か(ownerReference で代替できるか)
  - リーダー選出 Lease は resourceNames で限定したか
  - ClusterRole は本当に必要か、Role で十分ではないか

[ 範囲 / マルチテナンシー ]
  - マネージャーのキャッシュを必要な namespace に限定したか
  - テナント分離が必要ならテナント別 Operator を検討したか
  - NetworkPolicy / ResourceQuota / LimitRange を適用したか
  - CR の個数にも quota をかけたか

[ メトリクス / Webhook ]
  - メトリクスエンドポイントに WithAuthenticationAndAuthorization を適用
  - kube-rbac-proxy サイドカーを除去したか(2026)
  - TLS 1.3 の最低バージョンを強制したか
  - Webhook 証明書を cert-manager で自動ローテーションしているか
  - セキュリティ Webhook の failurePolicy=Fail + 高可用性を確保

[ 権限昇格の防止 ]
  - Operator が RBAC を動的生成しないように設計したか
  - CR が要求可能な権限を Webhook でホワイトリスト化したか
  - escalate/bind/impersonate 動詞をブロックしたか

[ サプライチェーン ]
  - イメージを cosign で署名しているか
  - SBOM を生成/添付/署名しているか
  - admission ポリシーで署名検証を強制しているか
  - distroless/nonroot ベースイメージを使っているか

[ Secret / 監査 ]
  - Secret を平文でログに残していないか
  - Secret RBAC を namespace/名前で絞ったか
  - etcd encryption at rest (KMS) を有効にしたか
  - audit policy で Operator の RBAC 変更を RequestResponse で記録しているか