•  1. 蠕蟲病毒簡介
• 2. 緩沖區溢出
• 3. 緩沖區溢出舉例
• 4. 緩沖區溢出的危害
• 5. 內存在計算機中的排布方式
• 6. 計算機中越界訪問的后果
• 7. 避免緩沖區溢出的三種方法
  • 7.1 棧隨機化
  • 7.2 檢測棧是否被破壞
  • 7.3 限制可執行代碼區域
• 8. 總結

蠕蟲病毒是一種常見的利用Unix系統中的缺點來進行攻擊的病毒。緩沖區溢出一個常見的后果是：黑客利用函數調用過程中程序的返回地址，將存放這塊地址的指針精準指向計算機中存放攻擊代碼的位置，造成程序異常中止。為了防止發生嚴重的后果，計算機會采用棧隨機化，利用金絲雀值檢查破壞棧，限制代碼可執行區域等方法來盡量避免被攻擊。雖然，現代計算機已經可以“智能”查錯了，但是我們還是要養成良好的編程習慣，盡量避免寫出有漏洞的代碼，以節省寶貴的時間!

1. 蠕蟲病毒簡介

蠕蟲是一種可以自我復制的代碼，并且通過網絡傳播，通常無需人為干預就能傳播。蠕蟲病毒入侵并完全控制一臺計算機之后，就會把這臺機器作為宿主，進而掃描并感染其他計算機。當這些新的被蠕蟲入侵的計算機被控制之后，蠕蟲會以這些計算機為宿主繼續掃描并感染其他計算機，這種行為會一直延續下去。蠕蟲使用這種遞歸的方法進行傳播，按照指數增長的規律分布自己，進而及時控制越來越多的計算機。

2. 緩沖區溢出

緩沖區溢出是指計算機向緩沖區內填充數據位數時超過了緩沖區本身的容量，溢出的數據覆蓋在合法數據上。理想的情況是：程序會檢查數據長度，而且并不允許輸入超過緩沖區長度的字符。但是絕大多數程序都會假設數據長度總是與所分配的儲存空間相匹配，這就為緩沖區溢出埋下隱患。操作系統所使用的緩沖區，又被稱為“堆棧”，在各個操作進程之間，指令會被臨時儲存在“堆棧”當中，“堆棧”也會出現緩沖區溢出。

3. 緩沖區溢出舉例

void echo() 
{ 
  char buf[4];   /*buf故意設置很小*/ 
  gets(buf); 
  puts(buf); 
} 
void call_echo() 
{ 
  echo(); 
} 

反匯編如下：

/*echo*/ 
000000000040069c <echo>:  
40069c:48 83 ec 18         sub $0x18,%rsp  /*0X18 == 24,分配了24字節內存。計算機會多分配一些給緩沖區*/ 
4006a0:48 89 e7            mov %rsp,%rdi    
4006a3:e8 a5 ff ff ff      callq 40064d <gets> 
4006a8::48 89 e7           mov %rsp,%rdi 
4006ab:e8 50  fe ff ff     callq callq 400500 <puts@plt> 
4006b0:48 83 c4 18         add $0x18,%rsp  
4006b4:c3                  retq  

/*call_echo*/ 
4006b5:48 83  ec 08             sub $0x8,%rsp  
4006b9:b8 00 00 00 00           mov $0x0,%eax 
4006be:e8 d9 ff ff ff           callq 40069c <echo> 
4006c3:48 83 c4 08              add $0x8,%rsp  
4006c7:c3                       retq 

在這個例子中，我們故意把buf設置的很小。運行該程序，我們在命令行中輸入012345678901234567890123，程序立馬就會報錯：Segmentation fault。

要想明白為什么會報錯，我們需要通過分析反匯編來了解其在內存是如何分布的。具體如下圖所示：

如下圖所示，此時計算機為buf分配了24字節空間，其中20字節還未使用。

此時，準備調用echo函數，將其返回地址壓棧。

當我們輸入“0123456789012345678 9012"時，緩沖區已經溢出，但是并沒有破壞程序的運行狀態。

當我們輸入：“012345678901234567 890123"。緩沖區溢出，返回地址被破壞，程序返回 0x0400600。

這樣程序就跳轉到了計算機中其他內存的位置，很大可能這塊內存已經被使用。跳轉修改了原來的值，所以程序就會中止運行。

黑客可以利用這個漏洞，將程序精準跳轉到其存放木馬的位置(如nop sled技術)，然后就會執行木馬程序，對我們的計算機造成破壞。

4. 緩沖區溢出的危害

緩沖區溢出可以執行非授權指令，甚至可以取得系統特權，進而進行各種非法操作。第一個緩沖區溢出攻擊--Morris蠕蟲，發生在二十年前，它曾造成了全世界6000多臺網絡服務器癱瘓。

在當前網絡與分布式系統安全中，被廣泛利用的50%以上都是緩沖區溢出，其中最著名的例子是1988年利用fingerd漏洞的蠕蟲。而緩沖區溢出中，最為危險的是堆棧溢出。因為入侵者可以利用堆棧溢出，在函數返回時改變返回程序的地址，讓其跳轉到任意地址。帶來的危害有兩種，一種是程序崩潰導致拒絕服務，另外一種就是跳轉并且執行一段惡意代碼，比如得到shell，然后為所欲為。

5. 內存在計算機中的排布方式

內存在計算機中的排布方式如下，從上到下依次為共享庫，棧，堆，數據段，代碼段。各個段的作用簡介如下：

共享庫:共享庫以.so結尾.(so==share object)在程序的鏈接時候并不像靜態庫那樣在拷貝使用函數的代碼，而只是作些標記。然后在程序開始啟動運行的時候，動態地加載所需模塊。所以，應用程序在運行的時候仍然需要共享庫的支持。共享庫鏈接出來的文件比靜態庫要小得多。

棧：棧又稱堆棧，是用戶存放程序臨時創建的變量，也就是我們函數{}中定義的變量，但不包括static聲明的變量，static意味著在數據段中存放變量。

除此之外，在函數被調用時，其參數也會被壓入發起調用的進程棧中，并且待到調用結束后，函數的返回值也會被存放回棧中，由于棧的先進后出特點，所以棧特別方便用來保存、恢復調用現場。從這個意義上講，我們可以把堆棧看成一個寄存，交換臨時數據的內存區。在X86-64 Linux系統中，棧的大小一般為8M(用ulitmit - a命令可以查看)。

堆：堆是用來存放進程中被動態分配的內存段，它的大小并不固定，可動態擴張或縮減。當進程調用malloc等函數分配內存時，新分配的內存就被動態分配到堆上，當利用free等函數釋放內存時，被釋放的內存從堆中被剔除。

堆存放new出來的對象，棧里面所有對象都是在堆里面有指向的。假如棧里指向堆的指針被刪除，堆里的對象也要釋放(C++需要手動釋放)。當然現在面向對象程序都有'垃圾回收機制'，會定期的把堆里沒用的對象清除出去。

數據段：數據段通常用來存放程序中已初始化的全局變量和已初始化為非0的靜態變量的一塊內存區域，屬于靜態內存分配。直觀理解就是C語言程序中的全局變量(注意：全局變量才算是程序的數據，局部變量不算程序的數據，只能算是函數的數據)

代碼段：代碼段通常用來存放程序執行代碼的一塊區域。這部分區域的大小在程序運行前就已經確定了，通常這塊內存區域屬于只讀，有些架構也允許可寫，在代碼段中也有可能包含以下只讀的常數變量，例如字符串常量等。

下面舉個例子來看下代碼中各個部分在計算機中是如何排布的。

#include <stdio.h> 
#include <stdlib.h> 
 
char big_array[1L<<24];     /*16 MB*/ 
char huge_array[1L<<31];    /*2 GB*/ 
 
int global = 0; 
 
int useless() {return 0;} 
 
int main() 
{ 
  void *phuge1,*psmall2,*phuge3,*psmall4; 
  int local = 0; 
  phuge1 = malloc(1L<<28);    /*256 MB*/ 
  psmall2 = malloc(1L<<8);    /*256 B*/ 
  phuge3 = malloc(1L<<32);    /*4 GB*/ 
  psmall4 = malloc(1L<<8);    /*256 B*/ 
} 

上述代碼中，程序中的各個變量在內存的排布方式如下圖所示。根據顏色可以一一對應起來。由于了local變量存放在棧區，四個指針變量使用了malloc分配了空間， 所以存放在堆上，兩個數組big_ array，huge_array存放在數據段，main，useless函數的其他部分存放在代碼段中。

6. 計算機中越界訪問的后果

下面再看一個例子，看下越界訪問內存會有什么結果。

typedef struct  
{ 
  int a[2]; 
  double d; 
}struct_t; 
 
double fun(int i) 
{ 
  volatile struct_t s; 
  s.d = 3.14; 
  s.a[i] = 1073741824;  /*可能越界*/ 
  return s.d; 
} 
 
int main() 
{ 
  printf("fun(0):%lf\n",fun(0)); 
  printf("fun(1):%lf\n",fun(1)); 
  printf("fun(2):%lf\n",fun(2)); 
  printf("fun(3):%lf\n",fun(3)); 
  printf("fun(6):%lf\n",fun(6)); 
  return 0;  
} 

打印結果如下所示：

fun(0):3.14 
fun(1):3.14 
fun(2):3.1399998664856 
fun(3):2.00000061035156 
fun(6):Segmentation fault 

在上面的程序中，我們定義了一個結構體，其中 a 數組中包含兩個整數值，還有 d 一個雙精度浮點數。在函數fun中，fun函數根據傳入的參數i來初始化a數組。顯然，i的值只能為0和1。在fun函數中，同時還設置了d的值為3.14。當我們給fun函數傳入0和1時可以打印出正確的結果3.14。但是當我們傳入2,3,6時，奇怪的現象發生了。為什么fun(2)和fun(3)的值會接近3.14，而fun(6)會報錯呢?

要搞清楚這個問題，我們要明白結構體在內存中是如何存儲的，具體如下圖所示。

結構體在內存中的存儲方式

GCC默認不檢查數組越界(除非加編譯選項)。而越界會修改某些內存的值，得出我們意想不到的結果。即使有些數據相隔萬里，也可能受到影響。當一個系統這幾天運行正常時，過幾天可能就會崩潰。(如果這個系統是運行在我們的心臟起搏器，又或者是航天飛行器上，那么這無疑將會造成巨大的損失!)

如上圖所示，對于最下面的兩個元素，每個塊代表 4 字節。a數組占用8個字節，d變量占用8字節，d排布在a數組的上方。所以我們會看到，如果我引用 a[0] 或者 a[1]，會按照正常修改該數組的值。但是當我調用 fun(2) 或者 fun(3)時，實際上修改的是這個浮點數 d 所對應的內存位置。這就是為什么我們打印出來的fun(2)和fun(3)的值如此接近3.14的原因。

當輸入 6 時，就修改了對應的這塊內存的值。原來這塊內存可能存儲了其他用于維持程序運行的內容，而且是已經分配的內存。所以，我們程序就會報出Segmentation fault的錯誤。

7. 避免緩沖區溢出的三種方法

為了在系統中插入攻擊代碼，攻擊者既要插入代碼，也要插入指向這段代碼的指針。這個指針也是攻擊字符串的一部分。產生這個指針需要知道這個字符串放置的棧地址。在過去，程序的棧地址非常容易預測。對于所有運行同樣程序和操作系統版本的系統來說，在不同的機器之間，棧的位置是相當固定的。因此，如果攻擊者可以確定一個常見的Web服務器所使用的棧空間，就可以設計一個在許多機器上都能實施的攻擊。

7.1 棧隨機化

棧隨機化的思想使得棧的位置在程序每次運行時都有變化。因此，即使許多機器都運行同樣的代碼，它們的棧地址都是不同的。實現的方式是：程序開始時，在棧上分配一段0 ~ n字節之間的隨機大小的空間，例如，使用分配函數alloca在棧上分配指定字節數量的空間。程序不使用這段空間，但是它會導致程序每次執行時后續的棧位置發生了變化。分配的范圍n必須足夠大，才能獲得足夠多的棧地址變化，但是又要足夠小，不至于浪費程序太多的空間。

int main() 
{ 
 long local; 
 printf("local at %p\n",&local); 
 return 0; 
} 

這段代碼只是簡單地打印出main函數中局部變量的地址。在32位 Linux上運行這段代碼10000次，這個地址的變化范圍為0xff7fc59c到0xffffd09c，范圍大小大約是。在64位 Linux機器上運行，這個地址的變化范圍為0x7fff0001b698到0x7ffffffaa4a8，范圍大小大約是 。

其實，一個好的黑客專家，可以使用暴力破壞棧的隨機化。對于32位的機器，我們枚舉個地址就能猜出來棧的地址。對于64位的機器，我們需要枚舉次。如此看來，棧的隨機化降低了病毒或者蠕蟲的傳播速度，但是也不能提供完全的安全保障。

7.2 檢測棧是否被破壞

??計算機的第二道防線是能夠檢測到何時棧已經被破壞。我們在echo函數示例中看到，當訪問緩沖區越界時，會破壞程序的運行狀態。在C語言中，沒有可靠的方法來防止對數組的越界寫。但是，我們能夠在發生了越界寫的時候，在造成任何有害結果之前，嘗試檢測到它。

GCC在產生的代碼中加人了一種棧保護者機制，來檢測緩沖區越界。其思想是在棧幀中任何局部緩沖區與棧狀態之間存儲一個特殊的金絲雀值，如下圖所示：

這個金絲雀值，也稱為哨兵值，是在程序每次運行時隨機產生的，因此，攻擊者很難猜出這個哨兵值。在恢復寄存器狀態和從函數返回之前，程序檢查這個金絲雀值是否被該函數的某個操作或者該函數調用的某個函數的某個操作改變了。如果是的，那么程序異常中止。

英國礦井飼養金絲雀的歷史大約起始1911年。當時，礦井工作條件差，礦工在下井時時常冒著中毒的生命危險。后來，約翰·斯科特·霍爾丹(John Scott Haldane)在經過對一氧化碳一番研究之后，開始推薦在煤礦中使用金絲雀檢測一氧化碳和其他有毒氣體。金絲雀的特點是極易受有毒氣體的侵害，因為它們平常飛行高度很高，需要吸入大量空氣吸入足夠氧氣。因此，相比于老鼠或其他容易攜帶的動物，金絲雀會吸入更多的空氣以及空氣中可能含有的有毒物質。這樣，一旦金絲雀出了事，礦工就會迅速意識到礦井中的有毒氣體濃度過高，他們已經陷入危險之中，從而及時撤離。

GCC會試著確定一個函數是否容易遭受棧溢出攻擊，并且自動插入這種溢出檢測。實際上，對于前面的棧溢出展示，我們可以使用命令行選項“-fno- stack- protector”來阻止GCC產生這種代碼。當用這個選項來編譯echo函數時(允許使用棧保護)，得到下面的匯編代碼

//void echo  
subq $24,%rsp Allocate 24 bytes on stack 
movq  %fs:40,%rax  Retrieve canary  
movq %rax,8(%rsp) Store on stack 
xorl %eax, %eax Zero out register    //從內存中讀出一個值 
movq %rsp, %rdi  Compute buf as %rsp  
call gets Call gets  
movq ‰rsp,%rdi Compute buf as %rsp 
call puts Call puts  
movq 8(%rsp),%rax Retrieve canary  
xorq %fs:40,%rax Compare to stored value   //函數將存儲在棧位置處的值與金絲雀值做比較 
je .L9  If =, goto ok  
call __stack_chk_fail Stack corrupted   
.L9 
addq $24,%rsp Deallocate stack space  
ret 

這個版本的函數從內存中讀出一個值(第4行)，再把它存放在棧中相對于%rsp偏移量為8的地方。指令參數各fs:40指明金絲雀值是用段尋址從內存中讀入的。段尋址機制可以追溯到80286的尋址，而在現代系統上運行的程序中已經很少見到了。將金絲雀值存放在一個特殊的段中，標記為只讀，這樣攻擊者就不能覆蓋存儲金絲雀值。在恢復寄存器狀態和返回前，函數將存儲在棧位置處的值與金絲雀值做比較(通過第10行的xorq指令)。如果兩個數相同，xorq指令就會得到0，函數會按照正常的方式完成。非零的值表明棧上的金絲雀值被修改過,那么代碼就會調用一個錯誤處理例程。

棧保護很好地防止了緩沖區溢出攻擊破壞存儲在程序棧上的狀態。一般只會帶來很小的性能損失。

7.3 限制可執行代碼區域

最后一招是消除攻擊者向系統中插入可執行代碼的能力。一種方法是限制哪些內存區域能夠存放可執行代碼。在典型的程序中，只有保存編譯器產生的代碼的那部分內存才需要是可執行的。其他部分可以被限制為只允許讀和寫。

許多系統都有三種訪問形式：讀(從內存讀數據)、寫(存儲數據到內存)和執行(將內存的內容看作機器級代碼)。以前，x86體系結構將讀和執行訪問控制合并成一個1位的標志，這樣任何被標記為可讀的頁也都是可執行的。棧必須是既可讀又可寫的，因而棧上的字節也都是可執行的。已經實現的很多機制，能夠限制一些頁是可讀但是不可執行的，然而這些機制通常會帶來嚴重的性能損失。

8. 總結

計算機提供了多種方式來彌補我們犯錯可能產生的嚴重后果，但是最關鍵的還是我們盡量減少犯錯。

例如，對于gets，strcpy等函數我們應替換為 fgets，strncpy等。在數組中，我們可以將數組的索引聲明為size_t類型，從根本上防止它傳遞負數。此外，還可以在訪問數組前來加上num小于ARRAY_MAX 語句來檢查數組的上界。總之，要養成良好的編程習慣，這樣可以節省很多寶貴的時間。同時最后也推薦兩本相關書籍如下所示。

代碼大全(第二版)

高質量程序設計指南

本文參考：《深入理解計算機系統》 https://baike.baidu.com/item/%E7%BC%93%E5%86%B2%E5%8C%BA%E6%BA%A2%E5%87%BA/678453?fr=aladdin#reference-[1]-36638-wrap https://baike.baidu.com/item/%E8%A0%95%E8%99%AB%E7%97%85%E6%AF%92/4094075?fr=aladdin https://zhuanlan.zhihu.com/p/185792677

本文轉載自微信公眾號「嵌入式與Linux那些事」，可以通過以下二維碼關注。轉載本文請聯系嵌入式與Linux那些事公眾號。