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.mzph.cn/news/212899.shtml

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

相关文章

作业调度算法（含详细计算过程）和进程调度算法浅析

作业调度算法（含详细计算过程）和进程调度算法浅析

一.作业调度 作业调度算法需要知道以下公式 周转时间完成时间 - 到达时间 带权周转时间周转时间/运行时间 注&#xff1a;带权周转时间越大&#xff0c;作业&#xff08;或进程&#xff09;越短&#xff1b;带权周转时间越小&#xff0c;作业&#xff08;或进程&#xff09;越…
阅读更多...
Redis生产实战-Redis集群故障探测以及降级方案设计

Redis生产实战-Redis集群故障探测以及降级方案设计

Redis 集群故障探测 在生产环境中&#xff0c;如果 Redis 集群崩溃了&#xff0c;那么会导致大量的请求打到数据库中&#xff0c;会导致整个系统都崩溃&#xff0c;所以系统需要可以识别缓存故障&#xff0c;限流保护数据库&#xff0c;并且启动接口的降级机制 降级方案设计 …
阅读更多...
超过 50% 的内部攻击使用特权提升漏洞

超过 50% 的内部攻击使用特权提升漏洞

特权提升漏洞是企业内部人员在网络上进行未经授权的活动时最常见的漏洞&#xff0c;无论是出于恶意目的还是以危险的方式下载有风险的工具。 Crowdstrike 根据 2021 年 1 月至 2023 年 4 月期间收集的数据发布的一份报告显示&#xff0c;内部威胁正在上升&#xff0c;而利用权…
阅读更多...
基于SSM的剧本杀预约系统的设计与实现

基于SSM的剧本杀预约系统的设计与实现

末尾获取源码 开发语言&#xff1a;Java Java开发工具&#xff1a;JDK1.8 后端框架&#xff1a;SSM 前端&#xff1a;Vue 数据库&#xff1a;MySQL5.7和Navicat管理工具结合 服务器&#xff1a;Tomcat8.5 开发软件&#xff1a;IDEA / Eclipse 是否Maven项目&#xff1a;是 目录…
阅读更多...
【第三届】：“玄铁杯”RISC-V应用创新大赛（基于yolov5和OpenCv算法 — 智能警戒哨兵）

【第三届】：“玄铁杯”RISC-V应用创新大赛（基于yolov5和OpenCv算法 — 智能警戒哨兵）

文章目录 前言 一、智能警戒哨兵是什么&#xff1f; 二、方案流程图 三、硬件方案 四、软件方案 五、演示视频链接 总结 前言 最近参加了第三届“玄铁杯”RISC-V应用创新大赛&#xff0c;我的创意题目是基于 yolov5和OpenCv算法 — 智能警戒哨兵 先介绍一下比赛&#xf…
阅读更多...
docker容器配置MySQL与远程连接设置（纯步骤）

docker容器配置MySQL与远程连接设置（纯步骤）

以下为ubuntu20.04环境&#xff0c;默认已安装docker&#xff0c;没安装的网上随便找个教程就好了 拉去mysql镜像 docker pull mysql这样是默认拉取最新的版本latest 这样是指定版本拉取 docker pull mysql:5.7查看已安装的mysql镜像 docker images通过镜像生成容器 docke…
阅读更多...
大数据HCIE成神之路之数据预处理（1）——缺失值处理

大数据HCIE成神之路之数据预处理（1）——缺失值处理

缺失值处理 1.1 删除1.1.1 实验任务1.1.1.1 实验背景1.1.1.2 实验目标1.1.1.3 实验数据解析 1.1.2 实验思路1.1.3 实验操作步骤1.1.4 结果验证 1.2 填充1.2.1 实验任务1.2.1.1 实验背景1.2.1.2 实验目标1.2.1.3 实验数据解析 1.2.2 实验思路1.2.3 实验操作步骤1.2.4 结果验证 1…
阅读更多...
【STM32】ADC模数转换器

【STM32】ADC模数转换器

1 ADC简介 ADC&#xff08;Analog-Digital Converter&#xff09;模拟-数字转换器 ADC可以将引脚上连续变化的模拟电压转换为内存中存储的数字变量&#xff0c;建立模拟电路到数字电路的桥梁 STM32是数字电路&#xff0c;只有高低电平&#xff0c;没有几V电压的概念&#xff…
阅读更多...
安装 DevEco Studio 后不能用本地 Node.js 打开

安装 DevEco Studio 后不能用本地 Node.js 打开

安装 DevEco Studio 后第一次打开时&#xff0c;不能用本地 Node.js 打开 答&#xff1a;因为本地 Node.js 文件夹名字中有空格 Node.js路径只能包含字母、数字、“。”、“_”、“-”、“:”和“V” 解决方法&#xff1a; 1.修改文件夹名称 2.重新下载 注意&#xff1a;找一…
阅读更多...
1-3算法基础-标准模板库STL

1-3算法基础-标准模板库STL

1.pair pair用于存储两个不同类型的值&#xff08;元素&#xff09;作为一个单元。它通常用于将两个值捆绑在一起&#xff0c;以便一起传递或返回。 #include <iostream> #include <utility> using namespace std; int main() {pair<int, string> person m…
阅读更多...
ThingWorx 9.2 Windows安装

ThingWorx 9.2 Windows安装

参考官方文档安装配置 1 PostgreSQL 13.X 2 Java, Apache Tomcat, and ThingWorx PTC Help Center 参考这里安装 数据库 C:\ThingworxPostgresqlStorage 设置为任何人可以full control 数据库初始化 pgadmin4 创建用户twadmin并记录口令password Admin Userpostgres Thin…
阅读更多...
漏刻有时百度地图API实战开发(9)Echarts使用bmap.js实现轨迹动画效果

漏刻有时百度地图API实战开发(9)Echarts使用bmap.js实现轨迹动画效果

Bmap.js是Echarts和百度地图相结合开发的一款JavaScript API&#xff0c;它可以帮助用户在web应用中获取包括地图中心点、地图缩放级别、地图当前视野范围、地图上标注点等在内的地图信息&#xff0c;并且支持在地图上添加控件&#xff0c;提供包括智能路线规划、智能导航(驾车…
阅读更多...
C# WPF上位机开发（通讯协议的编写）

C# WPF上位机开发（通讯协议的编写）

【 声明&#xff1a;版权所有&#xff0c;欢迎转载&#xff0c;请勿用于商业用途。 联系信箱&#xff1a;feixiaoxing 163.com】 作为上位机&#xff0c;它很重要的一个部分就是需要和外面的设备进行数据沟通的。很多时候&#xff0c;也就是在这个沟通的过程当中&#xff0c;上…
阅读更多...
PyQt下使用OpenCV实现人脸检测与识别

PyQt下使用OpenCV实现人脸检测与识别

背景&#xff1a; 一 数字图像处理与识别警务应用模型 基于前期所学知识&#xff0c;与公安实践相结合&#xff0c;综合设计数字图像处理与识别警务应用模型,从下列4个研究课题中选择2个进行实验实现&#xff1a;图像增强与复原、人脸检测与识别、虹膜内外圆检测与分割、车牌…
阅读更多...
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、效果展示…
阅读更多...
C语言----文件操作(一)

C语言----文件操作(一)

一&#xff1a;C语言中文件的概念 对于文件想必大家都很熟悉&#xff0c;无论在windows上还是Linux中&#xff0c;我们用文件去存储资料&#xff0c;记录笔记&#xff0c;常见的如txt文件&#xff0c;word文档&#xff0c;log文件等。那么&#xff0c;在C语言中文件是什么样的存…
阅读更多...
微信小程序制作-背单词的小程序制作

微信小程序制作-背单词的小程序制作

微信小程序–背单词的 好久没有发过文章了&#xff0c;但是不代表着我不去学习了喽&#xff0c;以下是我最近做的东西&#xff0c;前端的UI由朋友设计的&#xff0c;目前这个是前端使用的是微信小程序后端是Python的一个轻量型框架&#xff0c;FastApi&#xff0c;嗯&#xff…
阅读更多...
MyBatis 四大核心组件之 Executor 源码解析

MyBatis 四大核心组件之 Executor 源码解析

&#x1f680; 作者主页&#xff1a; 有来技术 &#x1f525; 开源项目&#xff1a; youlai-mall &#x1f343; vue3-element-admin &#x1f343; youlai-boot &#x1f33a; 仓库主页&#xff1a; Gitee &#x1f4ab; Github &#x1f4ab; GitCode &#x1f496; 欢迎点赞…
阅读更多...
List 接口

List 接口

1 List 接口 java.util 中的集合类包含 Java 中某些最常用的类。最常用的集合类是 List 和 Map。 List是一种常用的集合类型&#xff0c;它可以存储任意类型的对象&#xff0c;也可以结合泛型来存储具体的类型对象&#xff0c;本质上就是一个容器。 1.1 List 类型介绍 有序性…
阅读更多...
06-React组件 Redux React-Redux

06-React组件 Redux React-Redux

React组件化&#xff08;以Ant-Design为例&#xff09; 组件化编程&#xff0c;只需要去安装好对应的组件&#xff0c;然后通过各式各样的组件引入&#xff0c;实现快速开发 我们这里学习的是 Ant-design &#xff08;应该是这样&#xff09;&#xff0c;它有很多的组件供我们…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023