1. أهلا وسهلاً بكم في :: IQ-TeaM FORUM :: .
    إذا كانت هذه الزيارة الأولى أو لديك الرغبة بالانضمام لأعضاء شبكة عراق تيم فيجب الاطلاع على خصوصية الشبكه فربما بقائك زائر افضل لك من الانضمام بحيث أن قوانين شبكة عراق تيم لا تتناسب مع اهتماماتك .
    • للأطلاع على الخصوصية وسياسة الاستخدام - التفاصيل
    • بعد الاطلاع على سياسة الموقع وقوانين شبكة عراق تيم يمكنك التسجيل معنا - تسجيل عضو جديد
    إستبعاد الملاحظة
الكاتب : AhMeD 23 | المشاهدات : 1,902 | الردود : 8
حالة الموضوع:
مغلق
  1. AhMeD 23 Developer

    الأنتساب:
    ‏16 يوليو 2013
    المشاركات:
    62
    الإعجابات المتلقاة:
    2
    نقاط الجائزة:
    30
    [​IMG]
    [​IMG]


    بسم الله الرحمن الرحيم
    الموضوع واضح من العنوان


    كود PHP:
    Linux Kernel 2.6.32 Local Root Exploit (x86_642013
    كود PHP:
    #define _GNU_SOURCE

    #include <stdio.h>

     #include <stdlib.h>

     #include <string.h>

     #include <ctype.h>

    #define KSYM_NAME_LEN        127

    struct sym_entry {

     
    unsigned long long addr;

     
    unsigned int len;

     
    unsigned char *sym;

     };



    static 
    struct sym_entry *table;

     static 
    unsigned int table_sizetable_cnt;

     static 
    unsigned long long _text_stext_etext_sinittext_einittext_***tratext_eextratext;

     static 
    int all_symbols 0;

     static 
    char symbol_prefix_char ;



    int token_profit[0x10000];



    /* the table that holds the result of the compression */

     
    unsigned char best_table[256][2];

     
    unsigned char best_table_len[256];



    static 
    void usage(void)

     {

     
    fprintf(stderr“Usagekallsyms [--all-symbols] [--symbol-prefix=<prefix char>] < in.map out.Sn”);

     exit(
    1);

     }



    /*

     * This ignores the intensely annoying “mapping symbols” found

     * in ARM ELF files: $a, $t and $d.

     */

     
    static inline int is_arm_mapping_symbol(const char *str)

     {

     return 
    str[0] == ‘$’ && strchr(“atd”str[1])

     && (
    str[2] == ” || str[2] == .);

     }



    static 
    int read_symbol(FILE *instruct sym_entry *s)

     {

     
    char str[500];

     
    char *symstype;

     
    int rc;



    rc fscanf(in%llx %%499sn”, &s->addr, &stypestr);

     if (
    rc != 3) {

     if (
    rc != EOF) {

     
    /* skip line */

     
    fgets(str500in);

     }

     return -
    1;

     }



    sym str;

     
    /* skip prefix char */

     
    if (symbol_prefix_char && str[0] == symbol_prefix_char)

     
    sym++;



    /* Ignore most absolute/undefined (?) symbols. */

     
    if (strcmp(sym“_text”) == 0)

     
    _text s->addr;

     else if (
    strcmp(sym“_stext”) == 0)

     
    _stext s->addr;

     else if (
    strcmp(sym“_etext”) == 0)

     
    _etext s->addr;

     else if (
    strcmp(sym“_sinittext”) == 0)

     
    _sinittext s->addr;

     else if (
    strcmp(sym“_einittext”) == 0)

     
    _einittext s->addr;

     else if (
    strcmp(sym“_***tratext”) == 0)

     
    _***tratext s->addr;

     else if (
    strcmp(sym“_eextratext”) == 0)

     
    _eextratext s->addr;

     else if (
    toupper(stype) == ‘A’)

     {

     
    /* Keep these useful absolute symbols */

     
    if (strcmp(sym“__kernel_syscall_via_break”) &&

     
    strcmp(sym“__kernel_syscall_via_epc”) &&

     
    strcmp(sym“__kernel_sigtramp”) &&

     
    strcmp(sym“__gp”))

     return -
    1;



    }

     else if (
    toupper(stype) == ‘U’ ||

     
    is_arm_mapping_symbol(sym))

     return -
    1;

     
    /* exclude also MIPS ELF local symbols ($L123 instead of .L123) */

     
    else if (str[0] == ‘$’)

     return -
    1;



    /* include the type field in the symbol name, so that it gets

     * compressed together */

     
    s->len strlen(str) + 1;

     
    s->sym malloc(s->len 1);

     if (!
    s->sym) {

     
    fprintf(stderr“kallsyms failure

     “unable to allocate required amount of memoryn”
    );

     exit(
    EXIT_FAILURE);

     }

     
    strcpy((char *)s->sym 1str);

     
    s->sym[0] = stype;



    return 
    0;

     }



    static 
    int symbol_valid(struct sym_entry *s)

     {

     
    /* Symbols which vary between passes.  Passes 1 and 2 must have

     * identical symbol lists.  The kallsyms_* symbols below are only added

     * after pass 1, they would be included in pass 2 when –all-symbols is

     * specified so exclude them to get a stable symbol list.

     */

     
    static char *special_symbols[] = {

     
    “kallsyms_addresses”,

     
    “kallsyms_num_syms”,

     
    “kallsyms_names”,

     
    “kallsyms_markers”,

     
    “kallsyms_token_table”,

     
    “kallsyms_token_index”,



    /* Exclude linker generated symbols which vary between passes */

     
    “_SDA_BASE_”,        /* ppc */

     
    “_SDA2_BASE_”,        /* ppc */

     
    NULL };

     
    int i;

     
    int offset 1;



    /* skip prefix char */

     
    if (symbol_prefix_char && *(s->sym 1) == symbol_prefix_char)

     
    offset++;



    /* if –all-symbols is not specified, then symbols outside the text

     * and inittext sections are discarded */

     
    if (!all_symbols) {

     if ((
    s->addr _stext || s->addr _etext)

     && (
    s->addr _sinittext || s->addr _einittext)

     && (
    s->addr _***tratext || s->addr _eextratext))

     return 
    0;

     
    /* Corner case.  Discard any symbols with the same value as

     * _etext _einittext or _eextratext; they can move between pass

     * 1 and 2 when the kallsyms data are added.  If these symbols

     * move then they may get dropped in pass 2, which breaks the

     * kallsyms rules.

     */

     
    if ((s->addr == _etext && strcmp((char*)s->sym offset“_etext”)) ||

     (
    s->addr == _einittext && strcmp((char*)s->sym offset“_einittext”)) ||

     (
    s->addr == _eextratext && strcmp((char*)s->sym offset“_eextratext”)))

     return 
    0;

     }



    /* Exclude symbols which vary between passes. */

     
    if (strstr((char *)s->sym offset“_compiled.))

     return 
    0;



    for (
    0special_symbols[i]; i++)

     if( 
    strcmp((char *)s->sym offsetspecial_symbols[i]) == )

     return 
    0;



    return 
    1;

     }



    static 
    void read_map(FILE *in)

     {

     while (!
    feof(in)) {

     if (
    table_cnt >= table_size) {

     
    table_size += 10000;

     
    table realloc(tablesizeof(*table) * table_size);

     if (!
    table) {

     
    fprintf(stderr“out of memoryn”);

     exit (
    1);

     }

     }

     if (
    read_symbol(in, &table[table_cnt]) == 0)

     
    table_cnt++;

     }

     }



    static 
    void output_label(char *label)

     {

     if (
    symbol_prefix_char)

     
    printf(.globl %c%sn”symbol_prefix_charlabel);

     else

     
    printf(.globl %sn”label);

     
    printf(“tALGNn”);

     if (
    symbol_prefix_char)

     
    printf(%c%s:n”symbol_prefix_charlabel);

     else

     
    printf(%s:n”label);

     }



    /* uncompress a compressed symbol. When this function is called, the best table

     * might still be compressed itself, so the function needs to be recursive */

     
    static int expand_symbol(unsigned char *dataint lenchar *result)

     {

     
    int crlentotal=0;



    while (
    len) {

     
    = *data;

     
    /* if the table holds a single char that is the same as the one

     * we are looking for, then end the search */

     
    if (best_table[c][0]==&& best_table_len[c]==1) {

     *
    result++ = c;

     
    total++;

     } else {

     
    /* if not, recurse and expand */

     
    rlen expand_symbol(best_table[c], best_table_len[c], result);

     
    total += rlen;

     
    result += rlen;

     }

     
    data++;

     
    len–;

     }

     *
    result=0;



    return 
    total;

     }



    static 
    void write_src(void)

     {

     
    unsigned int ikoff;

     
    unsigned int best_idx[256];

     
    unsigned int *markers;

     
    char buf[KSYM_NAME_LEN+1];



    printf(#include <asm/types.h>\n”);

     
    printf(#if BITS_PER_LONG == 64\n”);

     
    printf(#define PTR .quad\n”);

     
    printf(#define ALGN .align 8\n”);

     
    printf(#else\n”);

     
    printf(#define PTR .long\n”);

     
    printf(#define ALGN .align 4\n”);

     
    printf(#endif\n”);



    printf(.datan”);



    /* Provide proper symbols relocatability by their ‘_text’

     * relativeness.  The symbol names cannot be used to construct

     * normal symbol references as the list of symbols contains

     * symbols that are declared static and are private to their

     * .o files.  This prevents .tmp_kallsyms.o or any other

     * object from referencing them.

     */

     
    output_label(“kallsyms_addresses”);

     for (
    0table_cnti++) {

     if (
    toupper(table[i].sym[0]) != ‘A’) {

     
    printf(“tPTRt_text + %#llx\n”,

     
    table[i].addr – _text);

     } else {

     
    printf(“tPTRt%#llx\n”, table[i].addr);

     
    }

     }

     
    printf(“n”);



    output_label(“kallsyms_num_syms”);

     
    printf(“tPTRt%dn”table_cnt);

     
    printf(“n”);



    /* table of offset markers, that give the offset in the compressed stream

     * every 256 symbols */

     
    markers malloc(sizeof(unsigned int) * ((table_cnt 255) / 256));







     if (!
    markers) {

     
    fprintf(stderr“kallsyms failure

     “unable to allocate required memoryn”
    );

     exit(
    EXIT_FAILURE);

     }



    output_label(“kallsyms_names”);

     
    off 0;

     for (
    0table_cnti++) {

     if ((
    0xFF) == 0)

     
    markers[>> 8] = off;



    printf(“t.byte 0x%02x”table[i].len);

     for (
    0table[i].lenk++)

     
    printf(0x%02x”table[i].sym[k]);

     
    printf(“n”);



    off += table[i].len 1;

     }

     
    printf(“n”);



    output_label(“kallsyms_markers”);

     for (
    0< ((table_cnt 255) >> 8); i++)







     
    printf(“tPTRt%dn”markers[i]);

     
    printf(“n”);



    free(markers);



    output_label(“kallsyms_token_table”);

     
    off 0;

     for (
    0256i++) {

     
    best_idx[i] = off;

     
    expand_symbol(best_table[i], best_table_len[i], buf);

     
    printf(“t.ascizt”%s”n”buf);

     
    off += strlen(buf) + 1;

     }

     
    printf(“n”);



    output_label(“kallsyms_token_index”);

     for (
    0256i++)

     
    printf(“t.shortt%dn”best_idx[i]);

     
    printf(“n”);

     }



    /* table lookup compression functions */



    /* count all the possible tokens in a symbol */

     
    static void learn_symbol(unsigned char *symbolint len)

     {

     
    int i;



    for (
    0len – 1i++)

     
    token_profitsymbol[i] + (symbol[1] << 8) ]++;

     }



    /* decrease the count for all the possible tokens in a symbol */

     
    static void forget_symbol(unsigned char *symbolint len)

     {

     
    int i;



    for (
    0len – 1i++)

     
    token_profitsymbol[i] + (symbol[1] << 8) ];

     }



    /* remove all the invalid symbols from the table and do the initial token count */

     
    static void build_initial_tok_table(void)

     {

     
    unsigned int ipos;



    pos 0;

     for (
    0table_cnti++) {

     if ( 
    symbol_valid(&table[i]) ) {

     if (
    pos != i)

     
    table[pos] = table[i];

     
    learn_symbol(table[pos].symtable[pos].len);

     
    pos++;

     }

     }

     
    table_cnt pos;

     }



    /* replace a given token in all the valid symbols. Use the sampled symbols

     * to update the counts */

     
    static void compress_symbols(unsigned char *strint idx)

     {

     
    unsigned int ilensize;

     
    unsigned char *p1, *p2;



    for (
    0table_cnti++) {



    len table[i].len;

     
    p1 table[i].sym;



    /* find the token on the symbol */

     
    p2 memmem(p1lenstr2);

     if (!
    p2) continue;



    /* decrease the counts for this symbol’s tokens */

     
    forget_symbol(table[i].symlen);



    size len;



    do {

     *
    p2 idx;

     
    p2++;

     
    size -= (p2 – p1);

     
    memmove(p2p2 1size);

     
    p1 p2;

     
    len–;



    if (
    size 2) break;



    /* find the token on the symbol */

     
    p2 memmem(p1sizestr2);



    } while (
    p2);



    table[i].len len;



    /* increase the counts for this symbol’s new tokens */

     
    learn_symbol(table[i].symlen);

     }

     }



    /* search the token with the maximum profit */

     
    static int find_best_token(void)

     {

     
    int ibestbestprofit;



    bestprofit=-10000;

     
    best 0;



    for (
    00×10000i++) {

     if (
    token_profit[i] > bestprofit) {

     
    best i;

     
    bestprofit token_profit[i];

     }

     }

     return 
    best;

     }



    /* this is the core of the algorithm: calculate the “best” table */

     
    static void optimize_result(void)

     {

     
    int ibest;



    /* using the ” symbol last allows compress_symbols to use standard

     * fast string functions */

     
    for (255>= 0i–) {


    /* if this table slot is empty (it is not used by an actual

     * original char code */

     
    if (!best_table_len[i]) {



    /* find the token with the breates profit value */

     
    best find_best_token();

    /* place it in the “best” table */

     
    best_table_len[i] = 2;

     
    best_table[i][0] = best 0xFF;

     
    best_table[i][1] = (best >> 8) & 0xFF;

    /* replace this token in all the valid symbols */

     
    compress_symbols(best_table[i], i);

     }

     }

     }

    /* start by placing the symbols that are actually used on the table */

     
    static void insert_real_symbols_in_table(void)

     {

     
    unsigned int ijc;

    memset(best_table0sizeof(best_table));

     
    memset(best_table_len0sizeof(best_table_len));

    for (
    0table_cnti++) {

     for (
    0table[i].lenj++) {

     
    table[i].sym[j];

     
    best_table[c][0]=c;

     
    best_table_len[c]=1;

     }

     }

     }

    static 
    void optimize_token_table(void)

     {

     
    build_initial_tok_table();

    insert_real_symbols_in_table();

    /* When valid symbol is not registered, exit to error */

     
    if (!table_cnt) {

     
    fprintf(stderr“No valid symbol.n”);

     exit(
    1);

     }

    optimize_result();

     }

    int main(int argcchar **argv)

     {

     if (
    argc >= 2) {

     
    int i;

     for (
    1argci++) {

     if(
    strcmp(argv[i], “–all-symbols”) == 0)

     
    all_symbols 1;

     else if (
    strncmp(argv[i], “–symbol-prefix=16) == 0) {

     
    char *= &argv[i][16];

     
    /* skip quote */

     
    if ((*== ‘”‘ && *(p+2) == ‘”‘) || (*== ‘” && *(p+2) == ‘”))

     
    p++;

     
    symbol_prefix_char = *p;

     } else

     
    usage();

     }

     } else if (
    argc != 1)

     
    usage();

    read_map(stdin);

     
    optimize_token_table();

     
    write_src();

    return 
    0;

     } 
    1337day Inj3ct0r Exploit Database : vulnerability : 0day : shellcode by Inj3ct0r Team

    [​IMG]
     
  2. بــرهــومــي Developer

    الأنتساب:
    ‏9 أغسطس 2012
    المشاركات:
    61
    الإعجابات المتلقاة:
    5
    نقاط الجائزة:
    30
    الإقامة:
    K.$.A
    رد: قنبلة شهر رمضان Linux Kernel 2.6.32 Local Root Exploit (x86_64) 2013

    وعليكم السلام ورحمة الله وبركآته .. ^:"
    مبـدع ياوحش , الله يعطيك الف عآفيه
    تستاهل أحلى فايف ستآر + لآيك + تقيم
     
  3. Ňą∂-ĦÂĊ Developer

    الأنتساب:
    ‏8 نوفمبر 2012
    المشاركات:
    27
    الإعجابات المتلقاة:
    0
    نقاط الجائزة:
    5
    رد: قنبلة شهر رمضان Linux Kernel 2.6.32 Local Root Exploit (x86_64) 2013

    كفو يآبطل .. :{1}:
    \
    لاهنت على الموضوع
     
  4. Egy HacKerS DeveloPer Plus

    الأنتساب:
    ‏1 ديسمبر 2012
    المشاركات:
    117
    الإعجابات المتلقاة:
    13
    نقاط الجائزة:
    50
    الوظيفة:
    HacKer
    الإقامة:
    Egy
    رد: قنبلة شهر رمضان Linux Kernel 2.6.32 Local Root Exploit (x86_64) 2013

    سلمت يمنآكـــ ي بطــل
     
  5. صلاح الدين الأيوبي Active DeveloPer

    الأنتساب:
    ‏18 مارس 2013
    المشاركات:
    95
    الإعجابات المتلقاة:
    1
    نقاط الجائزة:
    30
    رد: قنبلة شهر رمضان Linux Kernel 2.6.32 Local Root Exploit (x86_64) 2013

    مشكور حبيبي تسلم
    :!." ​
     
  6. D 1 r k DeveloPer Plus

    الأنتساب:
    ‏9 ابريل 2012
    المشاركات:
    141
    الإعجابات المتلقاة:
    5
    نقاط الجائزة:
    50
    الوظيفة:
    Currently Student
    الإقامة:
    United States
    رد: قنبلة شهر رمضان Linux Kernel 2.6.32 Local Root Exploit (x86_64) 2013

    .~
    بارك الله فيك ,
    و يعطيك الف عافيه يابطل
     
  7. th3j0cker Developer

    الأنتساب:
    ‏28 ديسمبر 2011
    المشاركات:
    58
    الإعجابات المتلقاة:
    0
    نقاط الجائزة:
    20
    رد: قنبلة شهر رمضان Linux Kernel 2.6.32 Local Root Exploit (x86_64) 2013

    بارك الله فيك يالغالي​
     
  8. a1do Developer

    الأنتساب:
    ‏16 مارس 2013
    المشاركات:
    2
    الإعجابات المتلقاة:
    0
    نقاط الجائزة:
    5
    رد: قنبلة شهر رمضان Linux Kernel 2.6.32 Local Root Exploit (x86_64) 2013

    جميل اخي واصل
     
  9. иαѕѕєя Active DeveloPer

    الأنتساب:
    ‏19 يوليو 2012
    المشاركات:
    80
    الإعجابات المتلقاة:
    0
    نقاط الجائزة:
    20
    الوظيفة:
    موضف صيانة
    الإقامة:
    الأردن
    رد: قنبلة شهر رمضان Linux Kernel 2.6.32 Local Root Exploit (x86_64) 2013

    تسلم يعطيك العافيه
     
حالة الموضوع:
مغلق

مشاركة هذه الصفحة