memcpy 内存越界分析

memcpy 内存越界

• 本文主要分析memcpy为什么会导致内存越界，在什么场景下会导致越界，为什么memcpy越界之后并没有必现coredump

memcpy 源码

void *memcpy(void *dst, const void *src, size_t len)
{  
    if(NULL == dst || NULL == src){  
        return NULL;  
    }  
    void *ret = dst;  
    if(dst <= src || (char *)dst >= (char *)src + len){  
        //没有内存重叠，从低地址开始复制  
        while(len--){  
            *(char *)dst = *(char *)src;  
            dst = (char *)dst + 1;  
            src = (char *)src + 1;  
        }  
    }else{  
        //有内存重叠，从高地址开始复制  
        src = (char *)src + len - 1;  
        dst = (char *)dst + len - 1;  
        while(len--){  
            *(char *)dst = *(char *)src;  
            dst = (char *)dst - 1;  
            src = (char *)src - 1;  
        }  
    }  
    return ret;  
}

一个简单的实例

• 代码

#include <string>
#include <string.h>
#include <iostream>
using namespace std;

int main()
{
    string s = "testmemcpy";
    int string_len = s.length();
    {
        char buf[5];
        memcpy(buf, s.c_str(), string_len);
        cout << buf << endl;
        cout << s << endl;
    }
    return 0;
}

• 编译
  g++ main.cpp -std=c++11 -o main
• 运行
  ./main
• 结果

testmemcpy�4}��qv�
testmemcpy
*** stack smashing detected ***: ./ttt terminated
Aborted (core dumped)

分析

源码分析

• 函数申明
  void *memcpy(void *dst, const void *src, size_t len)
• 参数

dst		目标地址
src		源地址
len		从源地址拷贝的长度

• 分析，从没有内存重叠的拷贝

1.    while(len--){  
2.        *(char *)dst = *(char *)src;  
3.        dst = (char *)dst + 1;  
4.        src = (char *)src + 1;  
5.    }

* 从源码来看，拷贝的长度只是关心len的长度，所以会造成两个问题
* 1. src的内存长度小于len，这就会造成源地址src已经产生内存越界
* 2. dst的内存长度小于len，这就会造成目标地址dst产生内存越界

结论

• memcpy内存越界并不总是会coredump的，内存越界只是使用了并非自己的内存，会造成内存乱掉。在释放的时候，如果越界的内存已经被释放，就会导致coredump了