首页 > 代码库 > ELF格式解析库之初始化

ELF格式解析库之初始化

2024-07-16 18:56:26   225人阅读

寻宝要先设计路线图

对一个ELF文件来说，它里边装个一个程序的所有信息。我们想要拿的程序信息就在这个ELF文件的某个地址处。可是我们根本就不知道这个具体的地址是哪个，怎么办？举个较形象的例子来描述我们将要的做的事情。峨眉山的山道上放着一大箱金子，我们想搞到这箱黄金。所以在动手之前，我们应该先搞清楚这箱黄金具体位置在哪条山路上，然后设计出几条可行的路线图，接着才是沿着先前设计好的路线去找宝藏。只不过，在这里我们要找的黄金变成了程序某个部分的信息，而那座峨眉山则变成了一个ELF文件。

所以,寻宝要先设计路线图，初始化库要先初始化数据管理句柄。

按照上两篇文章介绍的，ELF的一级数据管理句柄是 ：SEF_ELFHEADER

                                     二级数据管理句柄是：SEF_PROHEADER， SEF_SECHEADER

因此，我们按照顺序依次初始化SEF_ELFHEADER, SEF_PROHEADER, SEF_SECHEADER 三个数据管理句柄（管家婆，哈哈哈）。

初始化ELF header

   1:  long init_elf(char *PBuffer, int nsize, void** phandle)
   2:  {
   3:      int ret = 0;
   4:      if((PBuffer == NULL) || (nsize < 16) || (phandle == NULL))
   5:      {
   6:            ret = -1;
   7:            goto only_out;
   8:      }
   9:      if(is_elf(PBuffer))
  10:      {
  11:          ret = -3;
  12:          goto only_out;
  13:      }
  14:      /*create new memory for SEF_HEADSET     structure and set value
  15:       *create new memory for SEF_ELFHEADER    structure and set value
  16:       */
  17:      SEF_HEADSET *PTemp = (SEF_HEADSET *)malloc(sizeof(SEF_HEADSET));
  18:      SEF_ELFHEADER *handle = (SEF_ELFHEADER *)malloc(sizeof(SEF_ELFHEADER));
  19:      if(handle == NULL || PTemp == NULL)
  20:      {
  21:          ret = -2;
  22:          goto only_out;
  23:      }
  24:      memset(PTemp, 0, sizeof(SEF_HEADSET));
  25:      memset(handle, 0, sizeof(SEF_ELFHEADER));
  26:      
  27:      /* copy elf header from PBuffer */
  28:      uint8_t nBit = PBuffer[4];
  29:      if(nBit == ELFCLASS32)
  30:      {
  31:          handle->nFlag_Bits = ELFCLASS32;
  32:          memcpy(&handle->S_ElfHeader_32, PBuffer, sizeof(SEF_ELFHEADER_32));
  33:      }
  34:      if(nBit == ELFCLASS64)
  35:      {
  36:          handle->nFlag_Bits= ELFCLASS64;
  37:          memcpy(&handle->S_ElfHeader_64, PBuffer, sizeof(SEF_ELFHEADER_64));
  38:      }
  39:      
  40:      handle->nFlag_Data = http://www.mamicode.com/PBuffer[5];
  41:      if((get_local_endding() != PBuffer[5]))
  42:      {
  43:          handle->S_ElfHeader_32.e_type = converu16(handle->S_ElfHeader_32.e_type);
  44:              handle->S_ElfHeader_32.e_machine = converu16(handle->S_ElfHeader_32.e_machine);
  45:              handle->S_ElfHeader_32.e_version = converu32(handle->S_ElfHeader_32.e_version);
  46:              handle->S_ElfHeader_32.e_entry =   converu32(handle->S_ElfHeader_32.e_entry  );
  47:              handle->S_ElfHeader_32.e_phoff   = converu32(handle->S_ElfHeader_32.e_phoff  );
  48:              handle->S_ElfHeader_32.e_shoff   = converu32(handle->S_ElfHeader_32.e_shoff  );
  49:              handle->S_ElfHeader_32.e_flags   = converu32(handle->S_ElfHeader_32.e_flags  );
  50:              handle->S_ElfHeader_32.e_ehsize  = converu16(handle->S_ElfHeader_32.e_ehsize );
  51:              handle->S_ElfHeader_32.e_phentsize = converu16(handle->S_ElfHeader_32.e_phentsize);
  52:              handle->S_ElfHeader_32.e_phnum   = converu16(handle->S_ElfHeader_32.e_phnum  );
  53:              handle->S_ElfHeader_64.e_type = converu32(handle->S_ElfHeader_64.e_type);
  54:              handle->S_ElfHeader_64.e_machine = converu32(handle->S_ElfHeader_64.e_machine);
  55:              handle->S_ElfHeader_64.e_version = converu64(handle->S_ElfHeader_64.e_version);
  56:              handle->S_ElfHeader_64.e_entry =   converu64(handle->S_ElfHeader_64.e_entry  );
  57:              handle->S_ElfHeader_64.e_phoff   = converu64(handle->S_ElfHeader_64.e_phoff  );
  58:              handle->S_ElfHeader_64.e_shoff   = converu64(handle->S_ElfHeader_64.e_shoff  );
  59:              handle->S_ElfHeader_64.e_flags   = converu64(handle->S_ElfHeader_64.e_flags  );
  60:              handle->S_ElfHeader_64.e_ehsize  = converu32(handle->S_ElfHeader_64.e_ehsize );
  61:              handle->S_ElfHeader_64.e_phentsize = converu32(handle->S_ElfHeader_64.e_phentsize);
  62:              handle->S_ElfHeader_64.e_phnum   = converu32(handle->S_ElfHeader_64.e_phnum  );
  63:      }
  64:      PTemp->pS_ElfHeader= handle;
  65:      *phandle = PTemp;
  66:  only_out:
  67:          return ret;
  68:  }
<style></style>

 

初始化segment header

   1:  long ByteAdjust_SegTab32(SEF_PROHEADER *handle, int PhNum,int nFlag_Data)
   2:  {
   3:      int ret = 0;
   4:      int i;
   5:      if((handle == NULL) || (PhNum < 1) || 
   6:          ((nFlag_Data != ELFDATA2MSB) &&
   7:          (nFlag_Data != ELFDATA2LSB) &&
   8:          (nFlag_Data != ELFDATANONE)))
   9:      {
  10:          ret = -1;
  11:          goto GetOut;
  12:      }
  13:      if(get_local_endding() != nFlag_Data)
  14:          {
  15:           for(i=0; i<PhNum; i++)
  16:           {                
  17:          handle->pS_ProHeader_32[i].p_type   = converu32(handle->pS_ProHeader_32[i].p_type);
  18:          handle->pS_ProHeader_32[i].p_flags  = converu32(handle->pS_ProHeader_32[i].p_flags);
  19:          handle->pS_ProHeader_32[i].p_offset = converu32(handle->pS_ProHeader_32[i].p_offset);
  20:          handle->pS_ProHeader_32[i].p_vaddr  = converu32(handle->pS_ProHeader_32[i].p_vaddr);
  21:          handle->pS_ProHeader_32[i].p_paddr  = converu32(handle->pS_ProHeader_32[i].p_paddr);
  22:          handle->pS_ProHeader_32[i].p_filesz = converu32(handle->pS_ProHeader_32[i].p_filesz);
  23:          handle->pS_ProHeader_32[i].p_memsz = converu32(handle->pS_ProHeader_32[i].p_memsz);
  24:          handle->pS_ProHeader_32[i].p_align  = converu32(handle->pS_ProHeader_32[i].p_align);
  25:           }
  26:          }
  27:  GetOut:
  28:      return ret;
  29:  }
  30:   
  31:  long ByteAdjust_SegTab64(SEF_PROHEADER *handle, int PhNum,int nFlag_Data)
  32:  {
  33:      int ret = 0;
  34:      int i;
  35:      if((handle == NULL) || (PhNum < 1) || 
  36:          ((nFlag_Data != ELFDATA2MSB) &&
  37:          (nFlag_Data != ELFDATA2LSB) &&
  38:          (nFlag_Data != ELFDATANONE)))
  39:      {
  40:          ret = -1;
  41:          goto GetOut;
  42:      }
  43:      if(get_local_endding() != nFlag_Data)
  44:          {
  45:           for(i=0; i<PhNum; i++)
  46:           {                
  47:          handle->pS_ProHeader_64[i].p_type   = converu32(handle->pS_ProHeader_64[i].p_type);
  48:          handle->pS_ProHeader_64[i].p_flags  = converu32(handle->pS_ProHeader_64[i].p_flags);
  49:          handle->pS_ProHeader_64[i].p_offset = converu32(handle->pS_ProHeader_64[i].p_offset);
  50:          handle->pS_ProHeader_64[i].p_vaddr  = converu32(handle->pS_ProHeader_64[i].p_vaddr);
  51:          handle->pS_ProHeader_64[i].p_paddr  = converu32(handle->pS_ProHeader_64[i].p_paddr);
  52:          handle->pS_ProHeader_64[i].p_filesz = converu32(handle->pS_ProHeader_64[i].p_filesz);
  53:          handle->pS_ProHeader_64[i].p_memsz = converu32(handle->pS_ProHeader_64[i].p_memsz);
  54:          handle->pS_ProHeader_64[i].p_align  = converu32(handle->pS_ProHeader_64[i].p_align);
  55:           }
  56:          }
  57:  GetOut:
  58:      return ret;
  59:  }
  60:   
  61:  long init_segtab(unsigned char *PBuffer,void *Handle)
  62:  {
  63:      int ret = 0;
  64:      SEF_HEADSET *PHandle = (SEF_HEADSET *)Handle;
  65:      if((Handle == NULL ) && (PHandle->pS_ElfHeader == NULL))
  66:      {
  67:          ret = -1;
  68:          goto GetOut;
  69:      }
  70:   
  71:     int PhNum = 0;
  72:      int i = 0;
  73:      SEF_ELFHEADER * p_ElfHeader = PHandle->pS_ElfHeader;
  74:      
  75:      if((PhNum = p_ElfHeader->S_ElfHeader_32.e_phnum) < 1)
  76:      {
  77:          PHandle->pS_ProHeader = NULL;
  78:          goto GetOut;
  79:      }
  80:      
  81:      SEF_PROHEADER *p_ProHeader = (SEF_PROHEADER *)malloc(sizeof(SEF_PROHEADER));
  82:      
  83:      if(p_ProHeader == NULL)
  84:      {
  85:          ret = -3;
  86:          goto GetOut;
  87:      }
  88:      
  89:    /*start deal 32bits elf file*/
  90:      if(p_ElfHeader->nFlag_Bits == ELFCLASS32)
  91:      {
  92:      SEF_PROHEADER_32 *SArrP_Seg = (SEF_PROHEADER_32 *)malloc(PhNum*sizeof(SEF_PROHEADER_32));
  93:      if(SArrP_Seg == NULL)
  94:      {
  95:          ret = -4;
  96:          goto GetOut;
  97:      }
  98:          
  99:      memcpy(SArrP_Seg,
 100:          (PBuffer+p_ElfHeader->S_ElfHeader_32.e_phoff),
 101:          (PhNum*(p_ElfHeader->S_ElfHeader_32.e_phentsize)));
 102:      if( ByteAdjust_SegTab32(p_ProHeader, PhNum, p_ElfHeader->nFlag_Data) != 0)
 103:          {
 104:              ret = -8;
 105:              goto GetOut;
 106:          }
 107:          
 108:          p_ProHeader->pS_ProHeader_32 = SArrP_Seg;
 109:          p_ProHeader->pS_ProHeader_64 = NULL;
 110:      }
 111:    /*start deal 64bits elf file*/
 112:      else if(p_ElfHeader->nFlag_Bits == ELFCLASS64)
 113:      {
 114:          
 115:      SEF_PROHEADER_64 *SArrP_Seg = (SEF_PROHEADER_64 *)malloc(PhNum*sizeof(SEF_PROHEADER_64));
 116:      if(SArrP_Seg == NULL)
 117:      {
 118:          PHandle->pS_ProHeader = NULL;
 119:          ret = -4;
 120:          goto GetOut;
 121:      }
 122:      /*copy program header table from buffer + offset*/
 123:      memcpy(SArrP_Seg,
 124:              PBuffer+p_ElfHeader->S_ElfHeader_64.e_phoff,
 125:              (PhNum*(p_ElfHeader->S_ElfHeader_64.e_phentsize)));
 126:              
 127:      /*adjust byte order for every segment*/
 128:      if((ret = ByteAdjust_SegTab64(p_ProHeader, PhNum, p_ElfHeader->nFlag_Data)) != 0)
 129:          {
 130:              ret = -8;
 131:              goto GetOut;
 132:          }
 133:          
 134:          p_ProHeader->pS_ProHeader_32 = NULL;
 135:          p_ProHeader->pS_ProHeader_64 = SArrP_Seg;
 136:      }
 137:      else
 138:      {
 139:          ret = -10;
 140:          goto GetOut;
 141:      }
 142:      
 143:      PHandle->pS_ProHeader = p_ProHeader;
 144:   
 145:   
 146:  GetOut:
 147:      return ret;
 148:  }
<style></style>

初始化section header

   1:  long ByteAdjust_SecTab32(SEF_SECHEADER *handle, int ShNum,int nFlag_Data)
   2:  {
   3:      int ret = 0;
   4:      int i;
   5:      if((handle == NULL) || (ShNum < 1) || 
   6:          ((nFlag_Data != ELFDATA2MSB) &&(nFlag_Data != ELFDATA2LSB) &&(nFlag_Data != ELFDATANONE)))
   7:      {
   8:          ret = -1;
   9:          goto GetOut;
  10:      }
  11:      
  12:      if(get_local_endding() != nFlag_Data)
  13:      {
  14:       for(i=0; i<ShNum; i++)
  15:       {
  16:   
  17:          handle->pS_SecHeader_32[i].sh_name   = converu32(handle->pS_SecHeader_32[i].sh_name);
  18:          handle->pS_SecHeader_32[i].sh_type  = converu32(handle->pS_SecHeader_32[i].sh_type);
  19:          handle->pS_SecHeader_32[i].sh_flags = converu32(handle->pS_SecHeader_32[i].sh_flags);
  20:          handle->pS_SecHeader_32[i].sh_addr  = converu32(handle->pS_SecHeader_32[i].sh_addr);
  21:          handle->pS_SecHeader_32[i].sh_offset  = converu32(handle->pS_SecHeader_32[i].sh_offset);
  22:          handle->pS_SecHeader_32[i].sh_size = converu32(handle->pS_SecHeader_32[i].sh_size);
  23:          handle->pS_SecHeader_32[i].sh_link = converu32(handle->pS_SecHeader_32[i].sh_link);
  24:          handle->pS_SecHeader_32[i].sh_info  = converu32(handle->pS_SecHeader_32[i].sh_info);
  25:          handle->pS_SecHeader_32[i].sh_addralign  = converu32(handle->pS_SecHeader_32[i].sh_addralign);
  26:          handle->pS_SecHeader_32[i].sh_entsize  = converu32(handle->pS_SecHeader_32[i].sh_entsize);
  27:       }
  28:      }
  29:  GetOut:
  30:      return ret;
  31:  }
  32:   
  33:  long ByteAdjust_SecTab64(SEF_SECHEADER *handle, int ShNum,int nFlag_Data)
  34:  {
  35:      int ret = 0;
  36:      int i;
  37:      if((handle == NULL) || (ShNum < 1) || 
  38:          ((nFlag_Data != ELFDATA2MSB) &&(nFlag_Data != ELFDATA2LSB) &&(nFlag_Data != ELFDATANONE)))
  39:      {
  40:          ret = -1;
  41:          goto GetOut;
  42:      }
  43:      
  44:      if(get_local_endding() != nFlag_Data)
  45:      {
  46:       for(i=0; i<ShNum; i++)
  47:       {
  48:          handle->pS_SecHeader_64[i].sh_name   = converu32(handle->pS_SecHeader_64[i].sh_name);
  49:          handle->pS_SecHeader_64[i].sh_type  = converu32(handle->pS_SecHeader_64[i].sh_type);
  50:          handle->pS_SecHeader_64[i].sh_flags = converu32(handle->pS_SecHeader_64[i].sh_flags);
  51:          handle->pS_SecHeader_64[i].sh_addr  = converu32(handle->pS_SecHeader_64[i].sh_addr);
  52:          handle->pS_SecHeader_64[i].sh_offset  = converu32(handle->pS_SecHeader_64[i].sh_offset);
  53:          handle->pS_SecHeader_64[i].sh_size = converu32(handle->pS_SecHeader_64[i].sh_size);
  54:          handle->pS_SecHeader_64[i].sh_link = converu32(handle->pS_SecHeader_64[i].sh_link);
  55:          handle->pS_SecHeader_64[i].sh_info  = converu32(handle->pS_SecHeader_64[i].sh_info);
  56:          handle->pS_SecHeader_64[i].sh_addralign  = converu32(handle->pS_SecHeader_64[i].sh_addralign);
  57:          handle->pS_SecHeader_64[i].sh_entsize  = converu32(handle->pS_SecHeader_64[i].sh_entsize);
  58:       }
  59:      }
  60:  GetOut:
  61:      return ret;
  62:  }
  63:   
  64:  long init_section(unsigned char *pbuffer, void *Handle)
  65:  {
  66:      int ret = 0;
  67:      SEF_HEADSET *pS_HeadSet_Temp = NULL;
  68:      SEF_ELFHEADER *pS_ElfHeader_Temp = NULL;
  69:      SEF_SECHEADER *pS_SecHeader_Temp = NULL;
  70:      unsigned char *    StrSec_Buffer = NULL;
  71:      SEF_SECHEADER_32 *pS_SecHeader_32_Temp = NULL;
  72:      SEF_SECHEADER_64 *pS_SecHeader_64_Temp = NULL;
  73:      
  74:      if((pbuffer == NULL) || (Handle == NULL))
  75:      {
  76:          ret = -1;
  77:          goto GetOut;
  78:      }
  79:      pS_HeadSet_Temp = (SEF_HEADSET *) Handle;
  80:      pS_HeadSet_Temp->pBuffer = pbuffer;
  81:      if(pS_HeadSet_Temp->pS_ElfHeader == NULL)
  82:      {
  83:          ret = -2;
  84:          goto GetOut;
  85:      }
  86:      pS_ElfHeader_Temp = pS_HeadSet_Temp->pS_ElfHeader;
  87:      pS_SecHeader_Temp = (SEF_SECHEADER *)malloc(sizeof(SEF_SECHEADER));
  88:      if(pS_SecHeader_Temp == NULL)
  89:      {
  90:          ret = -4;
  91:          goto GetOut;
  92:      }
  93:      int nShNum;
  94:      /*start deal 32bits elf file*/
  95:      if(pS_ElfHeader_Temp->nFlag_Bits == ELFCLASS32)
  96:      {
  97:      
  98:      if((nShNum = pS_ElfHeader_Temp->S_ElfHeader_32.e_shnum) < 1)
  99:      {
 100:          pS_HeadSet_Temp->pS_SecHeader = NULL;
 101:          goto GetOut;
 102:      }
 103:      /*create new memory for the SEF_SECHEADER_32 structure*/
 104:      pS_SecHeader_32_Temp = (SEF_SECHEADER_32 *)malloc(nShNum * sizeof(SEF_SECHEADER_32));
 105:      if(pS_SecHeader_32_Temp == NULL)
 106:      {
 107:          ret = -3;
 108:          goto GetOut;
 109:      }
 110:      /*copy section header table from buffer + shoffset*/
 111:      memcpy(pS_SecHeader_32_Temp,
 112:          (pbuffer+pS_ElfHeader_Temp->S_ElfHeader_32.e_shoff),
 113:          (nShNum * (pS_ElfHeader_Temp->S_ElfHeader_32.e_shentsize)));
 114:      if(ByteAdjust_SecTab32(pS_SecHeader_Temp, nShNum, pS_ElfHeader_Temp->nFlag_Data) != 0)
 115:      {
 116:          ret = -8;
 117:          goto GetOut;
 118:      }
 119:   
 120:  }
 121:   
 122:      /*start deal 64bits elf file*/
 123:      else if(pS_ElfHeader_Temp->nFlag_Bits == ELFCLASS64)
 124:      {
 125:      if((nShNum = pS_ElfHeader_Temp->S_ElfHeader_64.e_shnum) < 1)
 126:      {
 127:          pS_HeadSet_Temp->pS_SecHeader = NULL;
 128:          goto GetOut;
 129:      }
 130:   
 131:      pS_SecHeader_64_Temp = (SEF_SECHEADER_64 *)malloc(nShNum * sizeof(SEF_SECHEADER_64));
 132:      if(pS_SecHeader_64_Temp == NULL)
 133:      {
 134:          ret = -3;
 135:          goto GetOut;
 136:      }
 137:      /*copy section header table from buffer + shoffset*/
 138:      memcpy(pS_SecHeader_64_Temp,
 139:          (pbuffer+pS_ElfHeader_Temp->S_ElfHeader_64.e_shoff),
 140:          (nShNum * (pS_ElfHeader_Temp->S_ElfHeader_64.e_shentsize)));
 141:      if(ByteAdjust_SecTab64(pS_SecHeader_Temp, nShNum, pS_ElfHeader_Temp->nFlag_Data) != 0)
 142:      {
 143:          ret = -8;
 144:          goto GetOut;
 145:      }
 146:      }
 147:      pS_SecHeader_Temp->pS_SecHeader_32 = pS_SecHeader_32_Temp;
 148:      pS_SecHeader_Temp->pS_SecHeader_64 = pS_SecHeader_64_Temp;
 149:      pS_HeadSet_Temp->pS_SecHeader = pS_SecHeader_Temp;
 150:  GetOut:
 151:      return ret;
 152:  }
 
最后附上头文件：elf_analysis.h
   1:  #ifndef _ELF_ANALYSIS_H
   2:  #define _ELF_ANALYSIS_H
   3:  #include<stdio.h>
   4:  #include<stdlib.h>
   5:  #include<string.h>
   6:  #include "../../include/elf_type.h"
   7:  #include "../../include/adt.h"
   8:   
   9:  /*
  10:        function: initialize the handle structer
  11:        input:     the arguments1 pbuffer is a data buffer,and 
  12:                   the arguments2 nsize that is the total bytes of the buffer.
  13:        return:    the arguments3 phandle inclued these data that the user care about.
  14:                   and the return long number is the errorcode:
  15:                        -1           invalid argument
  16:                        -2           alloc memory failed
  17:                        -3           the data inside the buffer not is ELF file
  18:                        0            function operated success
  19:        readme:     no
  20:  */
  21:  long init_elf(char * pbuffer, int nsize,void** phandle);
  22:   
  23:  long ByteAdjust_SegTab32(SEF_PROHEADER *handle, int PhNum,int nFlag_Data);
  24:   
  25:  long ByteAdjust_SegTab64(SEF_PROHEADER *handle, int PhNum,int nFlag_Data);
  26:   
  27:  long init_segtab( unsigned char *pBuffer, void *Handle);
  28:   
  29:  long ByteAdjust_SecTab32(SEF_SECHEADER *handle, int ShNum,int nFlag_Data);
  30:   
  31:  long ByteAdjust_SecTab64(SEF_SECHEADER *handle, int ShNum,int nFlag_Data);
  32:   
  33:  long init_section(unsigned char *pbuffer, void *Handle);
  34:   
  35:  #endif
<style></style><style></style>


联系
我们