Operator 보안 — 최소권한 RBAC, 멀티테넌시, 공급망

공격 경로 1: 컨트롤러 Pod 침해
  애플리케이션 취약점(RCE) → 컨트롤러 Pod 셸 획득
  → ServiceAccount 토큰 탈취(/var/run/secrets/...)
  → Operator의 모든 RBAC 권한 행사
  → 예: 전 네임스페이스 Secret 읽기, ClusterRoleBinding 생성

공격 경로 2: CR을 통한 권한 상승
  악의적 사용자가 CR을 생성/수정
  → Operator가 그 CR을 신뢰하고 RBAC 객체를 생성
  → 사용자가 직접 가질 수 없던 권한을 우회 획득

공격 경로 3: 공급망(supply chain)
  Operator 이미지 빌드 파이프라인 또는 베이스 이미지 침해
  → 악성 코드가 포함된 이미지가 클러스터에 배포
  → 정상 Operator처럼 보이지만 백도어 포함

공격 경로 4: 메트릭/웹훅 엔드포인트
  인증 없는 메트릭 엔드포인트 노출 → 내부 정보 유출
  TLS 미적용 웹훅 → 중간자 공격으로 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        → 특정 네임스페이스 안에서만 유효
ClusterRole + ClusterRoleBinding → 클러스터 전역에서 유효
ClusterRole + RoleBinding → ClusterRole 정의를 특정 네임스페이스에 한정 적용

mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{
	Scheme: scheme,
	// 캐시를 특정 네임스페이스로 한정 — 전 클러스터 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로 nonResourceURL /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 — 웹훅 서버 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 인스턴스가 모든 테넌트 네임스페이스의 CR을 처리
  장점: 운영 단순, 리소스 절약
  단점: Operator 침해 시 모든 테넌트 영향, 격리 약함

전략 B: 테넌트별 Operator (전용 Operator)
  테넌트 네임스페이스마다 독립적인 Operator 인스턴스
  장점: 강한 격리, 폭발 반경 최소화
  단점: 운영 복잡, 리소스 오버헤드

apiVersion: operators.coreos.com/v1
kind: OperatorGroup
metadata:
  name: tenant-a-operatorgroup
  namespace: tenant-a
spec:
  # 이 Operator는 tenant-a 네임스페이스만 감시
  targetNamespaces:
    - tenant-a

# 테넌트 네임스페이스로의 인바운드를 같은 테넌트로만 제한
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-only 업데이트로 인한 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로 충분하지 않은가

[ 범위 / 멀티테넌시 ]
  □ 매니저 캐시를 필요한 네임스페이스로 한정했는가
  □ 테넌트 격리가 필요하면 테넌트별 Operator를 검토했는가
  □ NetworkPolicy / ResourceQuota / LimitRange를 적용했는가
  □ CR 개수에도 quota를 걸었는가

[ 메트릭 / 웹훅 ]
  □ 메트릭 엔드포인트에 WithAuthenticationAndAuthorization 적용
  □ kube-rbac-proxy 사이드카를 제거했는가 (2026)
  □ TLS 1.3 최소 버전을 강제했는가
  □ 웹훅 인증서를 cert-manager로 자동 회전하는가
  □ 보안 웹훅의 failurePolicy=Fail + 고가용성 확보

[ 권한 상승 방지 ]
  □ Operator가 RBAC를 동적 생성하지 않게 설계했는가
  □ CR이 요청 가능한 권한을 웹훅으로 화이트리스트했는가
  □ escalate/bind/impersonate 동사를 차단했는가

[ 공급망 ]
  □ 이미지를 cosign으로 서명하는가
  □ SBOM을 생성/첨부/서명하는가
  □ admission 정책으로 서명 검증을 강제하는가
  □ distroless/nonroot 베이스 이미지를 쓰는가

[ Secret / 감사 ]
  □ Secret을 로그에 평문으로 남기지 않는가
  □ Secret RBAC를 네임스페이스/이름으로 좁혔는가
  □ etcd encryption at rest (KMS)를 켰는가
  □ audit policy로 Operator의 RBAC 변경을 RequestResponse로 기록하는가