elf.cc

Go to the documentation of this file.

// elf.cc
//
// plugin for uda - universal disassembler
// Date: 2003-05-04
//
// Copyright (c) 2002-2003 Ales Smrcka 
//
// This library is licensed under GNU Library GPL. See the file COPYING.
//
// This library makes possible to read unix ELF format.
//

#include <iostream>
#include <libelf.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include "shared.h"
using namespace std;

#define pluginname "elf.so"

Parameters *Params;

extern "C" {

void plugin_init(int &type, const char *&ident, const char *&syntax, Parameters *p)
{
    Params=p;
    if (elf_version(EV_CURRENT) == EV_NONE)
        type=0;
    else
        type=PLUGIN_SECTIONS+PLUGIN_SYMTABLE;
    ident="Universal disassembler plugin for ELF format";
    syntax=NULL;
}

int is_file_defined(const char *file)
{
    debug(pluginname<<": is_file_defined...\n");
    int result=0;
    int fildes=open(file, O_RDONLY);
    if (fildes==-1)
        return 0;
    Elf_Cmd cmd = ELF_C_READ;
    Elf *elf, *arf = elf_begin(fildes, cmd, (Elf*)0);
    if ((elf = elf_begin(fildes, cmd, arf)))
        if (elf_kind(elf)==ELF_K_ELF)
            result=1;
    elf_end(elf);
    elf_end(arf);
    close(fildes);
    if (result)
        debug(pluginname<<": is_file_defined...yes\n");
    else
        debug(pluginname<<": is_file_defined...no\n");
    return result;
}

int load_sections(BinFileData &bfdata)
{
    debug(pluginname<<": load_sections...\n");
    int sectionnum=0;
    if (elf_version(EV_CURRENT)==EV_NONE) return 0;
    Elf32_Ehdr *ehdr; //elf header
    Elf_Scn *scn; //section
    Elf32_Shdr *shdr; //section header
    Elf_Data *strtab; //loaded shstrtab
    debug(pluginname<<": load_sections: opening "<<bfdata.name.c_str()<<endl);
    int fildes=open(bfdata.name.c_str(), O_RDONLY);
    if (fildes==-1)
    {
        debug(pluginname<<": load_sections: can not open "<<bfdata.name.c_str()<<endl);
        return 0;
    }
    Elf_Cmd cmd = ELF_C_READ; //command for elf_begin
    Elf *elf, *arf = elf_begin(fildes, cmd, (Elf*)0); //initiate
    SectionData *sd;
    if ((elf = elf_begin(fildes, cmd, arf)))
    {
        if (elf_kind(elf)!=ELF_K_ELF)
        {
            debug(pluginname<<": load_sections: not an ELF format "<<bfdata.name.c_str()<<endl);
            // not an ELF format
            elf_end(elf);
            elf_end(arf);
            close(fildes);
            return 0;
        }
        ehdr = elf32_getehdr(elf);
        bfdata.entry = ehdr->e_entry; //entry loaded
        scn = elf_getscn(elf, (size_t)ehdr->e_shstrndx); //load shstrtab section
        shdr = elf32_getshdr(scn);
        if (shdr->sh_type != SHT_STRTAB)
        {
            debug(pluginname<<": load_sections: not a string table "<<bfdata.name.c_str()<<endl);
            // not a string table
            elf_end(elf);
            elf_end(arf);
            close(fildes);
            return 0;
        }
        debug(pluginname<<": load_sections: found .shstrtab\n");
        if ((strtab=elf_getdata(scn, (Elf_Data*)0))==0 || strtab->d_size==0)
        {
            debug(pluginname<<": load_sections: .shstrtab no data "<<bfdata.name.c_str()<<endl);
            // error or no data
            elf_end(elf);
            elf_end(arf);
            close(fildes);
            return 0;
        }
        debug(pluginname<<": load_sections: loaded .shstrtab\n");
        //got section .shstrtab in data->d_buf
        scn=0;
        while ((scn=elf_nextscn(elf, scn)))
        {
            shdr=elf32_getshdr(scn);
            if (strtab)
            {
                sd = new SectionData;
                sd->addr=shdr->sh_addr;
                sd->size=shdr->sh_size;
                sd->executable=shdr->sh_flags&SHF_EXECINSTR;
                sd->name=&((char*)(strtab->d_buf))[shdr->sh_name];
                int in=open(bfdata.name.c_str(), O_RDONLY);
                if (in!=-1)
                {
                    lseek(in, shdr->sh_offset, SEEK_SET);
                    sd->content = new byte[shdr->sh_size];
                    read(in, sd->content, shdr->sh_size);
                    close(in);
                    bfdata.Sections.push_back(sd);
                    sectionnum++;
                }
                else
                {
                    elf_end(elf);
                    elf_end(arf);
                    delete sd;
                    return sectionnum;
                }
            }
        }
        cmd=elf_next(elf);
        elf_end(elf);
    }
    elf_end(arf);

    debug(pluginname<<": load_sections "<<sectionnum<<"...ok\n");
    return sectionnum;
}

int load_symbols(AbstractSymbols &Symbols)
{
    Elf32_Sym *sym=NULL;
    char *strtab=NULL;
    int nsym; //number of symbols needs to be load
    for (unsigned i=0;i<Symbols.bfdata.Sections.size();i++)
        if (Symbols.bfdata.Sections[i]!=NULL)
            if (Symbols.bfdata.Sections[i]->name==".symtab")
            {
                sym=(Elf32_Sym*)Symbols.bfdata.Sections[i]->content;
                nsym=Symbols.bfdata.Sections[i]->size/sizeof(Elf32_Sym);
                if (strtab!=NULL) break;
            }
            else
            if (Symbols.bfdata.Sections[i]->name==".strtab")
            {
                strtab=(char*)Symbols.bfdata.Sections[i]->content;
                if (sym!=NULL) break;
            }
    if (sym==NULL||strtab==NULL)
        return 0;
    typedef MSymbols::value_type vt;
    for (int i=0;i<nsym;i++,sym++)
        if (strtab[sym->st_name])
            Symbols.symbols[sym->st_value] = &strtab[sym->st_name];
//            Symbols.symbols.insert(vt(sym->st_value, &strtab[sym->st_name]));
    return nsym;
}

} // extern "C"