void* 迷途指针 悬空指针 野指针 缓冲区过读 缓冲区溢出 内存管理

 C++干货系列——起底万能指针void* - 知乎 https://zhuanlan.zhihu.com/p/163676489

 void (C++) | Microsoft Learn https://learn.microsoft.com/en-us/cpp/cpp/void-cpp?view=msvc-170

 

When used as a function return type, the void keyword specifies that the function doesn't return a value. When used for a function's parameter list, void specifies that the function takes no parameters. When used in the declaration of a pointer, void specifies that the pointer is "universal."

If a pointer's type is void*, the pointer can point to any variable that's not declared with the const or volatile keyword. A void* pointer can't be dereferenced unless it's cast to another type. A void* pointer can be converted into any other type of data pointer.

 

Memory management

Manual memory management
Virtual memory
Hardware
Garbage collection
Memory segmentation
Memory safety
Issues
Other

 

 

 

 

https://zh.wikipedia.org/wiki/内存泄漏

 

 https://zh.wikipedia.org/wiki/堆疊溢位

堆栈溢出（英语：stack overflow）在计算机科学中是指使用过多的存储器时导致调用堆栈产生的溢出[1]，也是缓冲区溢出中的一种。堆栈溢出的产生是由于过多的函数调用，导致使用的调用堆栈大小超过事先规划的大小，覆盖其他存储器内的资料，一般在递归中产生。堆栈溢出很可能由无限递归（Infinite recursion）产生，但也可能仅仅是过多的堆栈层级。

堆栈溢出在內核设计中尤其危险，因此很多入门內核设计教程建议用户不要尝试使用递归程序；而是基于安全和性能考量，改用循环处理问题。[2][3][4]

在POSIX兼容平台上，堆栈溢出通常会造成操作系统产生SIGSEGV信号。

递归溢出

无限递归

无限递归是堆栈溢出的最常见原因，如以下的C/C++语言程序会产生堆栈溢出：

int foo()
{
    return foo();  //這裡出現无限重复的自我调用
}

然而有些语言（如Scheme）支持尾部递归优化，在这些语言中只有一般递归会产生堆栈溢出，而尾部递归不会：

(define (foo) (foo))
(define (foo) (+ (foo) 1))

这段代码中，前者（第一句）进入死循环（Infinite loop），但不会产生堆栈溢出；后者（第二句）则会产生堆栈溢出。

防止堆栈溢出

多数无限递归出现原因，都是基于程序本身没有错误检测机制：

int factorial( const int *const n ){
    if ( *n == 0 )
        return 1;
    else
        return *n * factorial( *n-- );  //這裡出現自我呼叫
};

如果在这里的n是负数则会出现无限递归。其实，这段程序可以简单地加以修改，把n的类型由整数改为非负整数即可解决：

unsigned int factorial( const unsigned int *const n ){
    if ( *n == 0 )
        return 1;
    else
        return *n * factorial( *n-- );
};

或者使用循环处理：

unsigned int factorial( const unsigned int *const n ){
    unsigned int i, result;
    for ( i = *n, result = 1; i > 0 ; --i )
        result *= i;
  //自我呼叫部份改為迴圈處理
    return result;
};

参看

 

https://zh.wikipedia.org/wiki/迷途指针

在计算机编程领域中，迷途指针，或称悬空指针、野指针，指的是不指向任何合法的对象的指针。

当所指向的对象被释放或者收回，但是对该指针没有作任何的修改，以至于该指针仍旧指向已经回收的内存地址，此情况下该指针便称迷途指针。若操作系统将这部分已经释放的内存重新分配给另外一个进程，而原来的程序重新引用现在的迷途指针，则将产生无法预料的后果。因为此时迷途指针所指向的内存现在包含的已经完全是不同的数据。通常来说，若原来的程序继续往迷途指针所指向的内存地址写入数据，这些和原来程序不相关的数据将被损坏，进而导致不可预料的程序错误。这种类型的程序错误，不容易找到问题的原因，通常会导致存储器区段错误（Linux系统中）和一般保护错误（Windows系统中）。如果操作系统的内存分配器将已经被覆盖的数据区域再分配，就可能会影响系统的稳定性。

某些编程语言允许未初始化的指针的存在，而这类指针即为野指针。野指针所导致的错误和迷途指针非常相似，但野指针的问题更容易被发现。

迷途指针的成因

在很多编程语言中（如C语言）从内存中删除一个对象或者返回时删除栈帧后，并不会改变相关的指针的值。该指针仍然指向原来的内存地址，即使引用已经删除，现在也可能已经被其它进程使用了。

一个直接的例子，如下所示:

{
   char *cp = NULL;
   /* ... */
   {
       char c;
       cp = &c;
   } /* c falls out of scope */          
     /* cp is now a dangling pointer */
}

上述问题的解决方法是在该部分程序退出之前立即给CP赋0值（NULL）。另一个办法是保证CP在没有初始化之前，将不再被使用。

迷途指针经常出现在混杂使用malloc() 和 free() 库调用: 当指针指向的内存释放了，这时该指针就是迷途的。和前面的例子一样，一个避免这个错误的方法是在释放它的引用后将该指针的值重置为NULL，如下所示：

#include <stdlib.h>
{
    char *cp = malloc ( A_CONST );
    /* ... */
    free ( cp );      /* cp now becomes a dangling pointer */
    cp = NULL;        /* cp is no longer dangling */
    /* ... */
}

有个常见的错误是当返回一个基于栈分配的局部变量的地址时，一旦调用的函数返回，分配给这些变量的空间将被回收，此时它们拥有的是"垃圾值"。

int * func ( void )
{
    int num = 1234;
    /* ... */
    return &num;
}

在调用func之后一段时间，尝试从该指针中读取num的值，可能仍然能够返回正确的值（1234），但是任何接下来的函数调用会覆盖原来的栈为num分配的空间。这时，再从该指针读取num的值就不正确了。如果要使一个指向num的指针都返回正确的num值，则需要将该变量声明为static。

野指针的产生

野指针指的是还没有初始化的指针。严格地说，编程语言中每个指针在初始化前都是野指针。

一般于未初始化时便使用指针就会产生问题。大多数的编译器都能检测到这一问题并警告用户。

int f(int i)
{
    char* cp;    //cp is a wild pointer
    static char* scp;  //scp is not a wild pointer: static variables are initialized to 0
                       //at start and retain their values from the last call afterwards.
                       //Using this feature may be considered bad style if not commented
}

迷途指针导致的安全漏洞

如同缓存溢出错误，迷途指针/野指针这类错误经常会导致安全漏洞。 例如，如果一个指针用来调用一个虚函数，由于vtable指针被覆盖了，因此可能会访问一个不同的地址（指向被利用的代码）。或者，如果该指针用来写入内存，其它的数据结构就有可能损坏了。一旦该指针成为迷途指针，即使这段内存是只读的，仍然会导致信息的泄露（如果感兴趣的数据放在下一个数据结构里面，恰好分配在这段内存之中）或者访问权限的增加（如果现在不可使用的内存恰恰被用来安全检测）。

避免迷途指针的错误

避免迷途指针，有一种受欢迎的方法——即使用智能指针（Smart pointer）。智能指针使用引用计数来回收对象。一些其它的技术包括tombstone法和locks-and-keys法。

另外，可以使用 DieHard 内存分配器[1]，它虚拟消除了类似其它内存错误（不合法或者两次释放内存）的迷途指针错误。

还有一种办法是贝姆垃圾收集器，一种保守的垃圾回收方法，能够替代C和C++中标准内存分配函数。这种方法完全消除了迷途指针的错误，通过去除内存释放的函数代之以垃圾回收器完成对象的回收。

像Java语言，迷途指针这样的错误是不会发生的，因为Java中没有明确地重新分配内存的机制。而且垃圾回收器只会在对象的引用数为零时重新分配内存。

迷途指针的检测

为了能发现迷途指针，一种普遍的编程技术——一旦指针指向的内存空间被释放，就立即把该指针置为空指针或者为一个非法的地址。当空指针被重新引用时，此时程序将会立即停止，这将避免数据损坏或者某些无法预料的后果。这将使接下来的编程过程产生的错误变得容易发现和解决了。这种技术在该指针有多个复制时就无法起到应有的作用了。

一些调试器会自动地用特定的模式来覆盖已经释放的数据，如0xDEADBEEF （Microsoft's Visual C/C++ 调试器，例如，根据哪种类型被释放采用 0xCC，0xCD 或者 0xDD[2]）。这种方法通过将数据无用化，来防止已经释放的数据重新被使用。这种方法的作用是非常显著的（该模式可以帮助程序来区分哪些内存是刚刚释放的）。

值名字描述
0xCD Clean Memory Allocated memory via malloc or new but never written by the application.
0xDD Dead Memory Memory that has been released with delete or free. Used to detect writing through dangling pointers.
0xFD Fence Memory Also known as "no mans land." This is used to wrap the allocated memory (surrounding it with a fence) and is used to detect indexing arrays out of bounds or other accesses (especially writes) past the end (or start) of an allocated block.
0xCC   When the code is compiled with the /GZ option, uninitialized variables are automatically assigned to this value (at byte level).
0xAB   Memory allocated by LocalAlloc().
0xBAADF00D Bad Food Memory allocated by LocalAlloc() with LMEM_FIXED,but not yet written to.
0xFEEEFEEE   OS fill heap memory, which was marked for usage, but wasn't allocated by HeapAlloc() or LocalAlloc(). Or that memory just has been freed by HeapFree().

某些工具，如Valgrind， Mudflap[3] 或者 LLVM[4] 可以用来检测迷途指针的使用。

 

https://zh.wikipedia.org/wiki/缓冲区过读

在计算机安全和程序设计中，缓冲区过读[1]是一类程序错误，即程序从缓冲器读出数据时超出了边界，而读取了（或试图读取）相邻的内存。这是有违内存安全的一个例子。

通过构造恶意输入，使得缺乏边界检查的程序读取不该访问到的内存，可以触发缓冲区过读，如在心脏出血漏洞里的那样。引发的原因也可能仅仅是编程中的错误。这可能会导致异常的程序行为，包括内存访问错误、不正确的结果、崩溃或系统安全性损害。因而，有许多漏洞都因其而生，还可能被恶意利用以访问特权信息。

通常与缓冲区过读相联系的编程语言语言包括C和C++，这些语言都没有提供内置的保护机制，以防止使用指针访问虚拟内存任意位置的数据，并且不会自动检查读取该内存块的数据是否安全；对应的例子如试图读取比数组更多的元素，以及没有向空终止字符串末尾追加终止符。边界检查可以防止缓冲区过读[2]，而模糊测试有助于检测出这些错误。

参见

参考

  1. ^ CWE – CWE-126: Buffer Over-read (2.6). Cwe.mitre.org. February 18, 2014 [April 10, 2014]. （原始内容存档于2018-02-08）.
  2. ^ Yves Younan; Wouter Joosen; Frank Piessens. Efficient protection against heap-based buffer overflows without resorting to magic (PDF). Dept. of Computer Science, Katholieke Universiteit Leuven. 2013-02-25 [2014-04-24]. （原始内容 (PDF)存档于2013-09-05）.

外部链接

 

 

https://zh.wikipedia.org/wiki/缓冲区溢出

缓冲区溢出（buffer overflow），在电脑学上是指针对程序设计缺陷，向程序输入缓冲区写入使之溢出的内容（通常是超过缓冲区能保存的最大数据量的数据），从而破坏程序运行、趁著中断之际并获取程序乃至系统的控制权。

缓冲区溢出原指当某个数据超过了处理程序回传堆栈地址限制的范围时，程序出现的异常操作。造成此现象的原因有：

因黑客在Unix的内核发现通过缓冲区溢出可以获得系统的最高等级权限，而成为攻击手段之一。也有人发现相同的问题也会出现在Windows操作系统上，以致其成为黑客最为常用的攻击手段，蠕虫病毒利用操作系统高危漏洞进行的破坏与大规模传播均是利用此技术。比较知名的蠕虫病毒冲击波蠕虫，就基于Windows操作系统的缓冲区溢出漏洞。

例如一个用途是对SONY的掌上游戏机PSP-3000的破解，通过特殊的溢出图片，PSP可以运行非官方的程序与游戏。同样在诺基亚智能手机操作系统Symbian OS中发现漏洞用户可以突破限制运行需要DRM权限或文件系统权限等系统权限的应用程序。

缓冲区溢出攻击从理论上来讲可以用于攻击任何有相关缺陷的程序，包括对杀毒软件、防火墙等安全产品的攻击以及对银行程序的攻击。在嵌入式设备系统上也可能被利用，例如PSP、智能手机等。

在部分情况下，当一般程序（除了驱动和操作系统内核）发生此类问题时，C++运行时库通常会终止程序的执行。

操作系统层级的保护[编辑]

目前OpenBSD、Linux、Windows、Mac OS等操作系统都具有buffer overflow protection（缓存溢出保护/存储器位置重新定向）功能[来源请求]，在某种程度上可以保护操作系统，但仍还是有办法让溢出的代码到正确的位置上。其作用原理是：存储器跟进程在memory中受到保护。内对外的access memory对象位置会被核心（调度器）随机定向，使其无法正确溢出。

参见[编辑]

外部链接[编辑]

 

posted @ 2019-03-05 11:34  papering  阅读(359)  评论(0)  编辑  收藏  举报