Linux C/C++ 从内存转储中恢复64位ELF可执行文件

ELF（Executable and Linking Format）是一种对象文件的格式，它主要用于定义ELF（Executable and Linking Format）是一种对象文件的格式，它主要用于定义不同类型的对象文件中的内容以及它们的存储方式。一个ELF文件主要包含三个部分：文本段、数据段和堆栈段。

在程序运行时，每个线程都有一个独立的栈空间。这个栈空间用于存储函数调用时的局部变量和返回地址。当一个新的函数被调用时，处理器会将当前的栈指针移动到栈顶，为新的函数调用分配足够的空间来存储其局部变量和返回地址。当函数调用结束时，处理器会将栈指针恢复到原来的值，从而完成函数调用的上下文切换。

ELF文件格式解析

ELF（Executable and Linkable Format）是一种可执行文件和可链接文件的格式，它被广泛用于类Unix系统。ELF文件格式由以下几个部分组成：

  1. ELF头（ELF Header）：包含了文件的基本属性和结构信息，如文件类型、入口地址、程序头表位置等。

  2. 程序头表（Program Header Table）：包含了文件中各个段的信息，如代码段、数据段、堆栈段等。每个段都有一个对应的程序头，其中包含了该段在文件中的位置、大小、读写权限等信息。

  3. 节头表（Section Header Table）：包含了文件中各个节的信息，如符号表、字符串表等。每个节都有一个对应的节头，其中包含了该节在文件中的位置、大小、类型等信息。

  4. 符号表（Symbol Table）：包含了文件中定义的全局变量、函数等符号信息。符号表中的每个符号都有一个对应的符号条目，其中包含了该符号的名称、类型、值等信息。

  5. 字符串表（String Table）：包含了文件中所有的字符串常量。字符串表中的每个字符串都有一个对应的字符串条目，其中包含了该字符串的内容和长度等信息。

ELF节区信息概述

  1. .shstrtab：这是一个字符串表，用于存储程序中的符号名。

  2. .interp：这是一个指向解释器段的指针，用于支持动态链接。

  3. .dynamic：这是一个动态段，包含了程序运行时所需的一些信息，如动态链接库、符号表等。

  4. .note：这是一个注释段，用于存储程序中的各种注释信息。

  5. .tbss：这是一个未初始化的数据段，用于存储程序中未初始化的全局变量和静态变量。

  6. eh_frname：这是一个异常处理程序的名称段，用于存储异常处理程序的名称。

  7. .bss：这是一个未初始化的数据段，用于存储程序中未初始化的全局变量和静态变量。

  8. .init_array：这是一个初始化数组段，用于存储程序的初始化函数地址。

  9. .fini_array：这是一个终止函数数组段，用于存储程序的终止函数地址。

  10. .dynstr：这是一个动态字符串表段，用于存储动态链接库中的字符串。

  11. .dynsym：这是一个动态符号表段，用于存储动态链接库中的符号信息。

  12. .got.plt：这是一个全局偏移表（GOT）和过程链接表（PLT）段，用于存储动态链接库中的全局偏移表和过程链接表的地址。

  13. .data：这是一个数据段，用于存储程序中的常量和静态变量。

  14. .plt：这是一个过程链接表段，用于存储程序中需要调用的外部函数的地址。

  15. .init：这是一个初始化函数段，用于存储程序的初始化函数地址。

  16. .rela.dyn：这是一个重定位动态段，用于存储动态链接库中的重定位信息。

  17. .rel.dyn：这是一个重定位动态段，用于存储动态链接库中的重定位信息。

  18. .rela.plt：这是一个重定位过程链接表段，用于存储程序中需要调用的外部函数的重定位信息。

  19. .rel.plt：这是一个重定位过程链接表段，用于存储程序中需要调用的外部函数的重定位信息。

  20. .text：这是一个代码段，用于存储程序的可执行代码。

  21. .fini：这是一个终止函数段，用于存储程序的终止函数地址。

  22. .gun.version：这是一个版本信息段，用于存储程序的版本信息。

  23. .gun.version_r：这是一个版本信息段，用于存储程序的版本信息。

  24. .gun.hash：这是一个哈希值段，用于存储程序的哈希值。

深入分析ELF文件的可执行栈

ELF文件是一种常见的可执行文件格式，用于在Linux和其他类Unix系统上运行程序。ELF文件包含程序的可执行代码和其他相关信息，如数据段、符号表、重定位表等。

可执行栈是程序运行时用于存储局部变量、函数调用信息等的一块内存区域。ELF文件中的可执行代码被加载到内存中，操作系统会为程序分配一块可执行栈空间。在程序执行过程中，将局部变量等数据保存在栈上，并通过栈来维护函数调用的执行顺序。

要深入分析ELF文件的可执行栈，可以参考以下几个方面：

  1. 栈帧结构：程序的每个函数调用都会在栈上创建一个栈帧。栈帧包含函数的参数、局部变量以及一些与函数调用相关的信息，如返回地址、上一级函数的栈帧指针等。了解栈帧的结构可以帮助分析函数调用过程和内存布局。

  2. 栈指针：程序运行时，栈指针指向当前栈顶的位置。当函数调用时，栈指针会移动到新的栈帧起始位置，分配空间给新的局部变量。了解栈指针的变化可以追踪函数调用的过程。

  3. 缓冲区溢出漏洞：栈溢出是一种常见的安全漏洞，攻击者可以通过向缓冲区输入超出预留空间的数据来破坏程序的执行或注入恶意代码。分析可执行栈可以帮助识别和防止栈溢出漏洞。

  4. 异常处理：当程序运行遇到异常情况时，如除零错误或访问非法内存操作等，操作系统会通过异常处理机制来捕获并处理这些异常。了解可执行栈的结构和异常处理机制可以帮助理解程序运行时的错误处理过程。

Linux内存映射

Linux内存映射是一种将文件或设备映射到进程虚拟内存地址空间的机制。通过内存映射，进程可以像访问内存一样访问文件或设备的内容，而无需进行显式的读写操作。

在Linux中，内存映射主要通过下面两个系统调用来实现：

  1. mmap()：mmap系统调用可以将文件的一部分或整个文件映射到进程的虚拟内存地址空间中。通过mmap，进程可以直接访问文件内容，而不需要使用常规的I/O操作。

  2. munmap()：munmap系统调用用于解除对内存的映射关系。通过munmap，进程可以释放不再需要的内存映射。这样可以及时释放系统资源，避免内存泄漏。

使用内存映射的好处包括：

  1. 避免了频繁的文件I/O操作：内存映射可以将文件内容直接映射到进程的内存中，避免了频繁的读写操作，提高了读写效率。

  2. 简化了对文件数据的访问：通过内存映射，可以直接通过内存地址访问文件的内容，无需使用read()和write()等系统调用。

  3. 允许进程间共享数据：多个进程可以通过将同一个文件映射到它们的地址空间中来共享数据，实现高效的进程间通信。

  4. 方便处理大文件：通过内存映射，即使是超过进程地址空间大小的大文件也可以被处理，而不需要将其一次性读入内存。

二进制修复和重建

二进制修复和重建是指对损坏、缺失或不完整的二进制文件进行修复或重新构建的过程。这通常是在软件开发、系统管理和计算机安全等领域中遇到的问题。

二进制修复通常包括以下几个步骤：

  1. 检测和诊断：首先需要检测二进制文件的问题，并进行诊断。常见的问题包括缺少或损坏的代码、数据、库引用、符号表等。通过分析文件的结构和内容，以及使用相关工具进行静态或动态分析，可以帮助确定问题的位置和性质。

  2. 修复和恢复：一旦问题被确定，就可以进行修复和恢复工作。这可能包括从备份中恢复、重新生成缺失的部分、修复损坏的数据结构等。根据问题的具体性质和复杂程度，可能需要使用特定的工具和技术进行修复。

  3. 验证和测试：修复完成后，需要进行验证和测试，确保二进制文件恢复正常并没有引入新的问题。可以通过运行测试用例、执行静态和动态分析、进行漏洞扫描等方式来验证修复的效果。

二进制重建通常是指从已有的二进制文件中重建出源代码或高层次的抽象表示。这在逆向工程、漏洞分析、恶意软件分析等领域中非常有用。重建二进制文件的源代码可以帮助理解程序的逻辑、进行安全审计和修复漏洞等工作。

二进制重建常用的技术包括：

  1. 反汇编：通过将二进制文件转换为汇编代码，可以获得对程序逻辑的低级别理解。可以使用反汇编器工具来执行这个过程。

  2. 动态分析：通过运行二进制文件，并使用调试器和动态分析工具，可以观察和分析程序的执行行为。这可以帮助理解程序的运行流程、数据处理机制等。

  3. 符号恢复：尝试恢复丢失的符号信息，比如函数名、变量名等。这可以通过对二进制文件进行静态分析，观察函数调用关系、命名模式等来实现。

Linux C/C++ 从内存转储中恢复64位ELF可执行文件

首先，我们需要获得一个程序的核心转储。为此，您可以使用gcore实用程序或提供的示例/dump.sh脚本，在调用gcore之前，它可以确保正确设置了coredump_filter。
dump.sh

#!/bin/sh
echo 0x07 > /proc/$1/coredump_filter
gcore $1

程序的核心转储示例:

...int main(int argc, char *argv[])
{bss_var = 0x13371337;int stack_var = 0xcafecafe;int *heap_var = (int *) malloc(sizeof(int));*heap_var = 0xabcdabcd;printf("bss_var....[%p]=0x%08x\n", &bss_var, bss_var);printf("data_var...[%p]=0x%08x\n", &data_var, data_var);printf("stack_var..[%p]=0x%08x\n", &stack_var, stack_var);printf("heap_var...[%p]=0x%08x\n", heap_var, *heap_var);data_var = 0xaf7e3;   //aftergetc(stdin);return 0;
}

./test &

sh dump.sh $(pgrep test)


在获得转储之后，为了恢复二进制文件，通过将核心转储文件作为第一参数和输出文件的所需名称作为第二参数来调用core_elf64程序就足够了，Linux C/C++ 从内存转储中恢复64位ELF可执行文件：

int main(int argc, char **argv)
{
...if ( argc != 3 ) printf("Usage: %s <core dump> <output file>", argv[0]);in =  open(argv[1], O_RDONLY);if (in < 0) die("Coudln't open file: %s\n", argv[1]);if (read(in, core_e_ident, sizeof(core_e_ident)) != sizeof(core_e_ident)) printf("Read error\n");if(strncmp(core_e_ident, ELFMAG, SELFMAG))printf("%s is not an ELF file!\n", argv[1]);if(core_e_ident[EI_CLASS] != ELFCLASS64)printf("This version supports only 64 bit core dumps!\n");if(core_e_ident[EI_DATA] != ELFDATA2LSB)printf("This version supports only Little Endian!\n");/* Read ELF header */if (lseek(in, 0, SEEK_SET) < 0) printf("Seek error\n");core_ehdr = (Elf64_Ehdr *) malloc(sizeof(Elf64_Ehdr));if (core_ehdr == NULL) printf("malloc error\n");if (read(in, core_ehdr, sizeof(Elf64_Ehdr)) != sizeof(Elf64_Ehdr)) printf("Read error\n");if (core_ehdr->e_type != ET_CORE) printf("%s is not a core dump!", argv[1]);if (core_ehdr->e_machine != EM_X86_64)printf("This version supports only 64 bit core dumps!");unsigned int core_phdr_size = core_ehdr->e_phentsize*core_ehdr->e_phnum;if (lseek(in, core_ehdr->e_phoff, SEEK_SET) < 0) printf("Seek error\n");core_phdr = (Elf64_Phdr *) malloc(core_phdr_size);if (core_phdr == NULL) printf("malloc error\n");if (read(in, core_phdr, core_phdr_size) < core_phdr_size) printf("Read error\n");printf("\n[*] Core dump contains the following segments:\n\n");printf("Index  %16s   Virt. addr. start    Virt. addr. end      Flags\n", "Type");for(i=0; i<core_ehdr->e_phnum; i++){printf("[%4d] %16s   0x%016lx - 0x%016lx   %c %c %c\n", i,seg_type_to_str(core_phdr[i].p_type),core_phdr[i].p_vaddr, core_phdr[i].p_vaddr+core_phdr[i].p_memsz,core_phdr[i].p_flags & PF_R ? 'R' : ' ',core_phdr[i].p_flags & PF_W ? 'W' : ' ',core_phdr[i].p_flags & PF_X ? 'X' : ' ');}printf("\n[*] Valid text segments: ");for(i=0; i<core_ehdr->e_phnum; i++){/* 读取段的前4个字节，看看它是否为ELF */char *seg_data = xget(in, core_phdr[i].p_offset, SELFMAG);if( core_phdr[i].p_type == PT_LOAD &&core_phdr[i].p_flags == (PF_R | PF_X) &&strncmp(seg_data, ELFMAG, SELFMAG) == 0 ){printf("%d ", i);if ( (core_phdr[i].p_vaddr & (~0xfffff)) == 0x400000 )core_text_seg_index = i;} if(seg_data != NULL) free(seg_data);}printf("\n");if(core_text_seg_index == -1){printf("Unable to find a text segment near virtual address 0x400000, " "please specify a text segment index (usually 1): ");scanf("%d", &core_text_seg_index);}  printf("[*] Text segment index = %d\n", core_text_seg_index);/* 检索文本段数据 */char *text_seg_data = xget(in, core_phdr[core_text_seg_index].p_offset, core_phdr[core_text_seg_index].p_filesz);Elf64_Ehdr *ehdr;Elf64_Phdr *phdr;ehdr = (Elf64_Ehdr *) text_seg_data;phdr = (Elf64_Phdr *) &text_seg_data[ehdr->e_phoff];printf("[*] Reconstructed Program Header:\n\n");printf("Index  %16s   Virt. addr. start    Virt. addr. end      Flags\n", "Type");for(i=0; i<ehdr->e_phnum; i++){printf("[%4d] %16s   0x%016lx - 0x%016lx   %c %c %c\n", i,seg_type_to_str(phdr[i].p_type),phdr[i].p_vaddr, phdr[i].p_vaddr+phdr[i].p_memsz,phdr[i].p_flags & PF_R ? 'R' : ' ',phdr[i].p_flags & PF_W ? 'W' : ' ',phdr[i].p_flags & PF_X ? 'X' : ' ');}for(i=0; i<ehdr->e_phnum; i++){if( phdr[i].p_type == PT_LOAD && phdr[i].p_flags == (PF_R | PF_X) &&phdr[i].p_vaddr < ehdr->e_entry &&phdr[i].p_vaddr + phdr[i].p_memsz > ehdr->e_entry){text_seg_index = i;}if( phdr[i].p_type == PT_LOAD && (phdr[i].p_flags & PF_W) ){data_seg_index = i;}if( phdr[i].p_type == PT_DYNAMIC ){dyn_seg_index = i;}}if(text_seg_index == -1)die("Unable to find text segment");elseprintf("\n[*] Text segment:    0x%lx - 0x%lx\n", phdr[text_seg_index].p_vaddr,phdr[text_seg_index].p_vaddr + phdr[text_seg_index].p_memsz);if(data_seg_index == -1)printf("[*] Unable to find data segment\n");elseprintf("[*] Data segment:    0x%lx - 0x%lx\n", phdr[data_seg_index].p_vaddr,phdr[data_seg_index].p_vaddr + phdr[data_seg_index].p_memsz);if(dyn_seg_index == -1)printf("[*] Unable to find dynamic segment\n");elseprintf("[*] Dynamic segment: 0x%lx - 0x%lx\n", phdr[dyn_seg_index].p_vaddr,phdr[dyn_seg_index].p_vaddr + phdr[dyn_seg_index].p_memsz);/* 恢复找到的分段的内容 */char **seg_data = malloc(sizeof(char *)*ehdr->e_phnum);if(seg_data == NULL) printf("Malloc error\n");for(i=0; i<ehdr->e_phnum; i++){for (j=0; j<core_ehdr->e_phnum; j++)   {/* If executable is PIE */if(ehdr->e_type == ET_DYN){if(  phdr[i].p_vaddr >= core_phdr[j].p_vaddr - core_phdr[core_text_seg_index].p_vaddr &&phdr[i].p_vaddr < core_phdr[j].p_vaddr + core_phdr[j].p_filesz - core_phdr[core_text_seg_index].p_vaddr){//printf("%d recover with %d\n",i,j);seg_data[i] = xget( in,core_phdr[j].p_offset + phdr[i].p_vaddr - (core_phdr[j].p_vaddr - core_phdr[core_text_seg_index].p_vaddr),phdr[i].p_filesz );break;}}else{if(  phdr[i].p_vaddr >= core_phdr[j].p_vaddr &&phdr[i].p_vaddr < core_phdr[j].p_vaddr + core_phdr[j].p_filesz  ){//printf("%d recover with %d\n",i,j);seg_data[i] = xget( in,core_phdr[j].p_offset + phdr[i].p_vaddr - core_phdr[j].p_vaddr,phdr[i].p_filesz );break;}}}}
...written)int out = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IXUSR);if (out < 0) die("Failed to create output file %s", argv[2]);for (i=0; i<ehdr->e_phnum; i++){if (lseek(out, phdr[i].p_offset, SEEK_SET) < 0)die("Error seek");if (write(out, seg_data[i], phdr[i].p_filesz) != phdr[i].p_filesz)die("Write error");if (phdr[i].p_offset + phdr[i].p_filesz > eof)eof = phdr[i].p_offset + phdr[i].p_filesz;}/* Write section strings */if (lseek(out, eof, SEEK_SET) < 0)die("Error Seek");if (write(out, shstr, sizeof(shstr)) != sizeof(shstr))die("Error writing shstr");/* Reset section header offset and number */ehdr->e_shoff = eof + sizeof(shstr);ehdr->e_shnum = 0;ehdr->e_shstrndx = 1;/*********************************//* Section header reconstruction *//*********************************/Elf64_Shdr shdr;Elf64_Word interp_index = 0; //Store interp section index needed below/* Recover simple sections (1:1 matching with segments) */printf("\n[*] Recovered sections:\n");/* NULL section */memset(&shdr, 0, sizeof(shdr));if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr)) die("Write Error");ehdr->e_shnum++;/* .shstrtab */shdr.sh_name = sec_index(".shstrtab");
...if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr)) die("Error .shstrtab");ehdr->e_shnum++;for (i=0; i<ehdr->e_phnum; i++){switch(phdr[i].p_type){/* .interp */case PT_INTERP:shdr.sh_name = sec_index(".interp");
...if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr)) die("Error .interp");ehdr->e_shnum++;printf("\t.interp\n");break;/* .dynamic */case PT_DYNAMIC:shdr.sh_name = sec_index(".dynamic");
...if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr)) die("Error .dynamic");ehdr->e_shnum++;printf("\t.dynamic\n");break;/* .note */case PT_NOTE:shdr.sh_name = sec_index(".note");
...if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr)) die("Error .note");ehdr->e_shnum++;printf("\t.note\n");break;/* .tbss */case PT_TLS:shdr.sh_name = sec_index(".tbss");
...if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr)) die("Error .tbss");ehdr->e_shnum++;printf("\t.tbss\n");break;/* .eh_frame_hdr and .eh_frame */case PT_GNU_EH_FRAME:shdr.sh_name = sec_index(".eh_frame_hdr");
...if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr)) die("Error .eh_frame_hdr");ehdr->e_shnum++;printf("\t.eh_frame\n");shdr.sh_name = sec_index(".eh_frame");
... if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr)) die("Error .eh_frame");ehdr->e_shnum++;printf("\t.eh_frame_hdr\n");break;}}  if(data_seg_index != -1){shdr.sh_name = sec_index(".bss");
...if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr)) die("Error .bss");ehdr->e_shnum++;printf("\t.bss\n");}...for(; dyn->d_tag != DT_NULL; ++dyn){switch(dyn->d_tag){ case DT_BIND_NOW: //Full relrobindnow = 1;break;case DT_INIT:init = dyn->d_un.d_ptr;break;case DT_FINI:fini = dyn->d_un.d_ptr;break;case DT_INIT_ARRAY:init_array = dyn->d_un.d_ptr;break;case DT_INIT_ARRAYSZ:init_arraysz = dyn->d_un.d_val;break;case DT_FINI_ARRAY:fini_array = dyn->d_un.d_ptr;break;case DT_FINI_ARRAYSZ:fini_arraysz = dyn->d_un.d_val;break;case DT_GNU_HASH:if(pie) dyn->d_un.d_ptr -= core_phdr[core_text_seg_index].p_vaddr;gnu_hash = dyn->d_un.d_ptr;break;case DT_STRTAB:if(pie) dyn->d_un.d_ptr -= core_phdr[core_text_seg_index].p_vaddr;strtab = dyn->d_un.d_ptr;break;case DT_SYMTAB:if(pie) dyn->d_un.d_ptr -= core_phdr[core_text_seg_index].p_vaddr;symtab = dyn->d_un.d_ptr;break;case DT_STRSZ:strsz = dyn->d_un.d_val;break;case DT_SYMENT:syment = dyn->d_un.d_val;break;case DT_PLTGOT:if(pie) dyn->d_un.d_ptr -= core_phdr[core_text_seg_index].p_vaddr;pltgot = dyn->d_un.d_ptr;break;case DT_PLTRELSZ:pltrelsz = dyn->d_un.d_val;break;case DT_PLTREL:pltrel = dyn->d_un.d_val;break;case DT_JMPREL:if(pie) dyn->d_un.d_ptr -= core_phdr[core_text_seg_index].p_vaddr;jmprel = dyn->d_un.d_ptr;break;case DT_RELA:if(pie) dyn->d_un.d_ptr -= core_phdr[core_text_seg_index].p_vaddr;rela = dyn->d_un.d_ptr;break;case DT_RELASZ:relasz = dyn->d_un.d_val;break;case DT_RELAENT:relaent = dyn->d_un.d_val;break;case DT_REL:rel = dyn->d_un.d_ptr;break;case DT_RELSZ:relsz = dyn->d_un.d_val;break;case DT_RELENT:relent = dyn->d_un.d_val;break;case DT_VERNEED:verneed = dyn->d_un.d_ptr;break;case DT_VERNEEDNUM:verneednum = dyn->d_un.d_val;break;case DT_VERSYM:if(pie) dyn->d_un.d_ptr -= core_phdr[core_text_seg_index].p_vaddr;versym = dyn->d_un.d_ptr;break;default://printf("%ld\n", dyn->d_tag);break;}}/* 如果PIE将正确的值重写到.dynamic部分 */if(pie){uint64_t fd_pos;if ((fd_pos = lseek(out, 0, SEEK_CUR)) < 0) die("Error seek");if (lseek(out, phdr[dyn_seg_index].p_offset, SEEK_SET) < 0)die("Error seek");if (write(out, seg_data[dyn_seg_index], phdr[dyn_seg_index].p_filesz) != phdr[dyn_seg_index].p_filesz)die("Write error");if (lseek(out, fd_pos, SEEK_SET) < 0)die("Error seek");}    if(init_array != 0 && init_arraysz != 0){shdr.sh_name = sec_index(".init_array");
....if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr)) die("Error .init_array");ehdr->e_shnum++;printf("\t.init_array\n");}/* .fini_array - In data segment, contains pointer to code to be* execute at the end */if(fini_array != 0 && fini_arraysz != 0){shdr.sh_name = sec_index(".fini_array");
....if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr)) die("Error .fini_array");ehdr->e_shnum++;printf("\t.fini_array\n");}/* .dynstr, usually followed by versym */Elf64_Word dynstr_index = 0;if(strtab != 0 && versym != 0){shdr.sh_name = sec_index(".dynstr");
....dynstr_index = ehdr->e_shnum;if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr)) die("Error .dynstr");ehdr->e_shnum++;printf("\t.dynstr\n");}Elf64_Word dynsym_index = 0; if(symtab !=0 && strtab !=0){shdr.sh_name = sec_index(".dynsym");shdr.sh_type = SHT_DYNSYM;....dynsym_index = ehdr->e_shnum;if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr)) die("Error .dynsym");ehdr->e_shnum++;printf("\t.dynsym\n");}uint64_t got_entries = 0;if(pltrel != 0 && pltrelsz !=0 && (relent != 0 || relaent != 0) && pltgot != 0){if(pltrel == DT_RELA)got_entries = ((pltrelsz/relaent) + 3);else got_entries = ((pltrelsz/relent) + 3);shdr.sh_size = got_entries * sizeof(Elf64_Addr);shdr.sh_name = sec_index(".got.plt");
...if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr)) die("Error .got.plt");ehdr->e_shnum++;printf("\t.got.plt\n");}/* .data - resides after .got.plt */if(pltgot != 0 && got_entries != 0){shdr.sh_name = sec_index(".data");
...if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr)) die("Error .data");ehdr->e_shnum++;printf("\t.data\n");}/*.plt*/Elf64_Word plt_addr = 0;Elf64_Word plt_index = 0;/* 从init开始，然后搜索.plt模式 */if(init != 0 && pltgot != 0 && got_entries != 0){
...if(plt_addr == 0)goto section_rebuild_end;shdr.sh_name = sec_index(".plt");...plt_index = ehdr->e_shnum;if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr)) die("Error .got.plt");ehdr->e_shnum++;printf("\t.plt\n");}/* .init - is just before .plt */if(init != 0 && plt_addr != 0){shdr.sh_name = sec_index(".init");
...if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr)) die("Error .got.plt");ehdr->e_shnum++;printf("\t.init\n");}/* .rel.dyn or .rela.dyn */if( (rela != 0 && relaent !=0) || (rel != 0 && relent != 0) ){if(rela != 0 && relaent != 0){shdr.sh_name = sec_index(".rela.dyn");shdr.sh_type = SHT_RELA;shdr.sh_addr = rela;shdr.sh_entsize = relaent; if(jmprel)shdr.sh_size = jmprel - shdr.sh_addr;elseshdr.sh_size = relasz;}else{shdr.sh_name = sec_index(".rel.dyn");shdr.sh_type = SHT_REL;shdr.sh_addr = rel;shdr.sh_entsize = relent;if(jmprel)shdr.sh_size = jmprel - shdr.sh_addr;elseshdr.sh_size = relsz;}...if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr))die("Error .rel.dyn or .rela.dyn");ehdr->e_shnum++;if(rela != 0)printf("\t.rela.dyn\n");elseprintf("\t.rel.dyn\n");}if((relent != 0 || relaent != 0) && init != 0 && jmprel != 0)      {if(pltrel == DT_RELA){shdr.sh_name = sec_index(".rela.plt");shdr.sh_type = SHT_RELA;shdr.sh_entsize = relaent;}else{shdr.sh_name = sec_index(".rel.plt");shdr.sh_type = SHT_REL;shdr.sh_entsize = relent;}
...if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr))die("Error .rel.dyn or .rela.dyn");ehdr->e_shnum++;if(pltrel == DT_RELA)printf("\t.rela.plt\n");elseprintf("\t.rel.plt\n");}if(plt_addr != 0 && got_entries != 0 && fini != 0){shdr.sh_name = sec_index(".text");
...if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr)) die("Error .text");ehdr->e_shnum++;printf("\t.text\n");}/* .fini *//* TODO - find size*/if(fini != 0){shdr.sh_name = sec_index(".fini");
...if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr)) die("Error .fini");ehdr->e_shnum++;printf("\t.fini\n");}/* .gnu.version */if(versym != 0 && strtab != 0 && symtab != 0){shdr.sh_name = sec_index(".gnu.version");
...if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr)) die("Error .gnu.version");ehdr->e_shnum++;printf("\t.gnu.version\n");}/* .gnu_versioni_r - before .rel or .rela */if(verneed != 0 && verneednum != 0 && pltrel != 0){shdr.sh_name = sec_index(".gnu.version_r");
...if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr)) die("Error .gnu_version_r");ehdr->e_shnum++;printf("\t.gnu_version_r\n");}/* .gnu.hash */if(gnu_hash != 0 && symtab != 0){shdr.sh_name = sec_index(".gnu.hash");shdr.sh_type = SHT_GNU_HASH;shdr.sh_addr = gnu_hash;shdr.sh_offset = gnu_hash - phdr[text_seg_index].p_vaddr;shdr.sh_size = symtab - gnu_hash;shdr.sh_flags = SHF_ALLOC;shdr.sh_link = dynsym_index;shdr.sh_info = 0;shdr.sh_addralign = 8;shdr.sh_entsize = 0;if (write(out, &shdr, sizeof(shdr)) != sizeof(shdr)) die("Error .gnu.hash");ehdr->e_shnum++;printf("\t.gnu.hash\n");}if(bindnow){printf("[*] FULL Relro binary, no GOT reconstruction is needed\n");goto section_rebuild_end;}else if(got_entries == 0){printf("[*] WARNING Can't recover GOT entries\n");goto section_rebuild_end;}printf("\n[*] %ld GOT entries found\n", got_entries);uint64_t got_off = phdr[data_seg_index].p_offset +(pltgot - phdr[data_seg_index].p_vaddr);uint64_t got_entry = 0x0;for (i = 1; i < 3; i++){if (lseek(out,got_off + sizeof(Elf64_Addr) * i,SEEK_SET) < 0) 
...}/* 使用恢复的PLT地址恢复GOT部分 */for(i = 3; i < got_entries; i++){if (lseek(out,got_off + sizeof(Elf64_Addr)*i,SEEK_SET) < 0) die("Seek error");...}section_rebuild_end:/* 所有部分都恢复。现在用正确的节数重写ELF头 */if (lseek(out, 0 , SEEK_SET) < 0) die("Seek error");if (write(out, (char *)ehdr, sizeof(Elf64_Ehdr)) != sizeof(Elf64_Ehdr)) die("Write error");/* 释放分配的内存并关闭文件 */ for(i=0; i<ehdr->e_phnum; i++){free(seg_data[i]);}
...return 0;
}

If you need the complete source code, please add the WeChat number (c17865354792)

运行效果：

…/core_elf64 core.2171 rebuild

./rebuild

从转储中恢复二进制文件

从转储中恢复二进制文件的一般步骤如下：

  1. 使用适当的工具（如gcore、windbg等）生成进程的内存转储文件。这需要在合适的时间点进行，以确保转储文件包含了所需的二进制数据。

  2. 确定目标二进制文件的基址，即二进制文件加载到进程内存中的起始地址。可以通过查看进程的内存映射信息或使用调试工具来获取此信息。

  3. 使用适当的工具打开内存转储文件，并根据基址将所需的二进制数据提取出来。这可以通过从内存转储中复制包含目标二进制代码和数据区域的内存块来实现。这需要根据目标平台和文件格式进行解析和提取。

  4. 如果内存转储文件不包含相关的符号信息，则可能需要使用反汇编工具对提取的二进制数据进行反汇编。这样可以获得与汇编指令对应的代码。

  5. 对提取的二进制数据进行适当的修复和调整，以使其成为有效的可执行文件。这可能包括修复段和节表、添加相关的符号信息、修复链接关系等。

  6. 验证并测试恢复的二进制文件。这可以包括使用适当的调试器工具来运行和调试恢复的可执行文件，确保其功能正确。

请注意，恢复二进制文件可能涉及到操作系统、文件格式和调试方面的复杂知识和技术。因此，在执行此过程时，建议有相关的经验和对底层系统有深入的了解。

总结

从内存转储中恢复64位ELF可执行文件需要以下步骤：

  1. 首先，获取内存转储文件。这可以通过使用操作系统提供的工具（如Windows的Task Manager或Linux的GDB）或专用工具（如Volatility）来完成。

  2. 确定内存转储文件中的ELF可执行文件。这可以通过检查文件的头部信息来完成。ELF文件的头部通常包括魔数、文件类型和机器架构等信息。

  3. 从内存转储文件中提取ELF可执行文件。这可以通过解析文件的节区表和程序头表来完成。节区表描述了不同节区（如代码段、数据段）在文件中的位置和大小，而程序头表则描述了不同的程序段（如可加载的段、动态链接段）。

  4. 重建ELF可执行文件的结构。这包括创建文件头、节区表、程序头表以及各个节区的内容。通过将这些信息写入新的文件中，就能够得到一个完整的ELF可执行文件。

  5. 修复可能损坏的部分。由于从内存转储中恢复ELF可执行文件可能会丢失一些数据，因此可能需要进行一些修复工作。这可能包括修复损坏的符号表、重建重定位表等。

总结起来，从内存转储中恢复64位ELF可执行文件需要解析内存转储文件的结构，提取ELF文件，并通过重建文件的结构来恢复文件。

Welcome to follow WeChat official account【程序猿编码】

参考：
https://systemoverlord.com/2017/03/19/got-and-plt-for-pwning.html
https://stackoverflow.com/questions/58076539/plt-plt-got-what-is-different

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/264300.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Anaconda文件目录（打开默认路径）更改

Anaconda文件目录（打开默认路径）更改

Anaconda 文件默认目录更改 每次打开 Anaconda 都在C盘怎么办&#xff0c;如何改为D盘或是其他盘符位置&#xff1f; 可以进行下述操作。 1. 单次修改路径 单次修改路径&#xff1a;在 exe 文件(Anaconda Prompt (Anaconda_py))中写入下面代码&#xff1a; jupyter notebook …
阅读更多...
基于OpenCV的流水线包装箱检测计数应用(附源码)

基于OpenCV的流水线包装箱检测计数应用(附源码)

导 读 本文主要介绍基于OpenCV的流水线包装箱检测计数应用，并给出源码。 资源下载 完整代码和视频下载地址： https://github.com/freedomwebtech/rpi4-conveyor-belt-boxces-counter 核心代码如下(cboxtest.py): import cv2import numpy as npfrom tracker import*cap=c…
阅读更多...
持续集成交付CICD：Jenkins配置Nexus制品发布

持续集成交付CICD：Jenkins配置Nexus制品发布

目录 一、实验 1.Jenkins配置Nexus制品发布 一、实验 1.Jenkins配置Nexus制品发布 &#xff08;1&#xff09;策略 发布其实就是下载制品&#xff0c;然后将制品发送到目标主机&#xff0c;最后通过脚本或者指令启动程序。 &#xff08;2&#xff09;安装Maven Artifact …
阅读更多...
JavaEE 08 线程池简介

JavaEE 08 线程池简介

前言 前面我们谈完了定时器,单例模式,阻塞队列等的操作并且做了模拟实现,今天我们再来说一说线程池的操作以及一些锁策略. 注:本章几乎均为理论篇,实践较少. 下面就让我们开始吧. 线程池 我们知道因为进程的频繁创建和销毁,带来的开销过大,我们无法接受,所以我们引入了更轻量级…
阅读更多...
[架构之路-261]：目标系统 - 设计方法 - 软件工程 - 软件设计 - 架构设计 - 网络数据交换格式

[架构之路-261]：目标系统 - 设计方法 - 软件工程 - 软件设计 - 架构设计 - 网络数据交换格式

一、网络数据交换格式 1.1 什么是网络数据交换格式 网络数据交换格式指的是在计算机网络中传输和存储数据时所采用的特定格式。 它定义了数据的组织方式、结构和编码规则&#xff0c;以便不同系统和应用程序之间能够准确地解析和处理数据。 网络数据交换格式的主要目的是&a…
阅读更多...
DIP——边缘提取与分割

DIP——边缘提取与分割

1.使用canny算法进行边缘提取 本实验比较简单&#xff0c;基本思路是对原图像进行一个高斯模糊处理&#xff0c;用于去噪&#xff0c;之后转换为灰度图&#xff0c;直接调用cv库中的canny记性边缘提取。若想直接得到彩色边缘&#xff0c;则通过按位与操作&#xff0c;将原始彩色…
阅读更多...
人工智能原理复习--机器学习

人工智能原理复习--机器学习

文章目录 上一篇机器学习概述归纳(示例)学习ID3决策树算法K近邻算法下一篇 上一篇 人工智能原理复习–搜索策略&#xff08;二&#xff09; 机器学习概述 学习系统的基本结构&#xff1a; #mermaid-svg-JMjIZHjVOirLolvu {font-family:"trebuchet ms",verdana,ari…
阅读更多...
CV计算机视觉每日开源代码Paper with code速览-2023.12.5

CV计算机视觉每日开源代码Paper with code速览-2023.12.5

点击计算机视觉&#xff0c;关注更多CV干货 论文已打包&#xff0c;点击进入—>下载界面 点击加入—>CV计算机视觉交流群 1.【基础网络架构&#xff1a;Transformer】GIFT: Generative Interpretable Fine-Tuning Transformers 论文地址&#xff1a;https://arxiv.org…
阅读更多...
pytorch中的归一化：BatchNorm、LayerNorm 和 GroupNorm

pytorch中的归一化：BatchNorm、LayerNorm 和 GroupNorm

1 归一化概述 训练深度神经网络是一项具有挑战性的任务。 多年来&#xff0c;研究人员提出了不同的方法来加速和稳定学习过程。 归一化是一种被证明在这方面非常有效的技术。 1.1 为什么要归一化 数据的归一化操作是数据处理的一项基础性工作&#xff0c;在一些实际问题中&am…
阅读更多...
【参天引擎】华为参天引擎内核架构专栏开始更新了，多主分布式数据库的特点，类oracle RAC国产数据开始出现了

【参天引擎】华为参天引擎内核架构专栏开始更新了，多主分布式数据库的特点，类oracle RAC国产数据开始出现了

cantian引擎的介绍 ​专栏内容&#xff1a; 参天引擎内核架构 本专栏一起来聊聊参天引擎内核架构&#xff0c;以及如何实现多机的数据库节点的多读多写&#xff0c;与传统主备&#xff0c;MPP的区别&#xff0c;技术难点的分析&#xff0c;数据元数据同步&#xff0c;多主节点的…
阅读更多...
Html转PDF，前端JS实现Html页面导出PDF（html2canvas+jspdf）

Html转PDF，前端JS实现Html页面导出PDF（html2canvas+jspdf）

Html转PDF&#xff0c;前端JS实现Html页面导出PDF&#xff08;html2canvasjspdf&#xff09; 文章目录 Html转PDF&#xff0c;前端JS实现Html页面导出PDF&#xff08;html2canvasjspdf&#xff09;一、背景介绍二、疑问三、所使用技术html2canvasjspdf 四、展示开始1、效果展示…
阅读更多...
【基于Flask、MySQL和Echarts的热门游戏数据可视化平台设计与实现】

【基于Flask、MySQL和Echarts的热门游戏数据可视化平台设计与实现】

基于Flask、MySQL和Echarts的热门游戏数据可视化平台设计与实现 前言数据获取与清洗数据集数据获取数据清洗 数据分析与可视化数据分析功能可视化功能 创新点结语 前言 随着游戏产业的蓬勃发展&#xff0c;了解游戏销售数据对于游戏从业者和游戏爱好者都至关重要。为了更好地分…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023