uda.cc

Go to the documentation of this file.

// uda.cc
//
// uda - universal disassembler
// Date: 2003-05-04
//
// Copyright (c) 2002-2003 Ales Smrcka 
//
// This program is licensed under GNU Library GPL. See the file COPYING.
//
// Main program.
//

#include <string>
#include <iomanip>
#include <iostream>
#include <libgen.h>
#include "shared.h"
#include "plugins.h"
#include "sections.h"
#include "symtable.h"
#include "instrset.h"
#include "decoder.h"
using namespace std;

// Parse parameters
int load_parameters(int &argc, char **&argv);

Parameters params;
Parameters *Params=&params;

const char *defaultbasedir="/usr/share/uda/";
string basedir;

const char *par_binfile="-b";

const char *sec_alldata="*data";
const char *sec_allexec="*exec";
const char *sec_all="*";

extern const char *syntax;
extern const char *options;
typedef vector<string> str_list;

//locates address
void locate_address(BinaryFile &binaryfile, const string address);
//prints all sections
void print_sections(BinaryFile &binaryfile);
//prints section's content
void print_content(BinaryFile &binaryfile, const string section);
//prints all symbols from executable
void print_symbols(BinaryFile &binaryfile);
//disassemble section
void disassemble(BinaryFile &binaryfile, const string section, const string scanned);

void set_base_dir(char *dir)
{
    basedir = string(dirname(dir))+"/";
    if (!directory_exists(basedir+instrsetdirectory))
        if (directory_exists(defaultbasedir))
            basedir = defaultbasedir;
}

// M A I N
int main(int argc, char *argv[])
{
    if (sizeof(unsigned)<4)
    {
        cerr<<"This program must be compiled for min. 32bit architecture!\n";
        return 1;
    }
    set_base_dir(argv[0]);
    if (!load_parameters(argc, argv))
        return 1;
    //open plugins
    OpenPlugins();
    if (pdefined("--help"))
    {
        cout<<syntax;
        cout<<options;
        PluginsInfo();
        return 0;
    }
    //prepare binary file
    BinaryFile binaryfile(params[par_binfile]);
    decinfo.binfile=&binaryfile;
    //find appop plugin and load all sections
    if (binaryfile.Init())
    { // binary file loaded
        decinfo.onlyname = pdefined("--onlyname");
        decinfo.address = !pdefined("--noaddress");
        decinfo.hexdump = !pdefined("--nohexdump");
        decinfo.symbolic = !pdefined("--nosymbolic");
        try
        {
            //create symbols and load it from binary file
            symbols = new Symbols(binaryfile.bfdata);
            debug(":loading symbol table from binary file\n");
            symbols->Load();
            //load instruction set 
            instructionset.Load(params["-P"]);            
            if (pdefined("-m")) //load symbols from user symbol table
            {
                debug(":loading symbol table from "<<params["-m"]<<endl);
                symbols->Load(params["-m"].c_str());
            }
            bool symboldefined;
            if (pdefined("-start")) // new starting address
            {
                decinfo.start=symbols->findaddress(params["-start"], symboldefined);
                if (!symboldefined)
                    decinfo.start=hex2uint(params["-start"]);
            }
            if (pdefined("-stop")) // new stopping address
            {
                decinfo.stop=symbols->findaddress(params["-stop"], symboldefined);
                if (!symboldefined)
                    decinfo.stop=hex2uint(params["-stop"]);
            }
            else
            if (pdefined("-size")) // new stopping address (by size from start)
                decinfo.size=number2uint(params["-size"]);
            if (pdefined("-p") || pdefined("--printsymbols")) //print all symbols
                print_symbols(binaryfile);
            else
            if (pdefined("-c")) //print content of section
                print_content(binaryfile, params["-c"]);
            else
            if (pdefined("--sections")) //print all sections' informations
                print_sections(binaryfile);
            else
            if (pdefined("-l")) //locate address
                locate_address(binaryfile, params["-l"]);
            else
            if (pdefined("-d")) //disassemble section
            
                disassemble(binaryfile, params["-d"], params["-s"]);
            else
            if (pdefined("-f")) //print founded symbols
            {
                decinfo.print=false;
                disassemble(binaryfile, params["-f"], params["-s"]);
                print_symbols(binaryfile);
            }
            else
                disassemble(binaryfile, ".text", params["-s"]);
        }
        catch(Exception &exception)
        {
            delete symbols;
            exception.Print();
        }
    }
    else
        cerr<<"Can not open file "<<params[par_binfile]<<endl;
    ClosePlugins();
    debug(":Plugins::Close() ok\n");
    return 0;
}
// M A I N

// Loads and process all parameters
int load_parameters(int &argc, char **&argv)
{
    int actarg=1;
    if (argc>actarg)
        if (argv[actarg][0]!='-')
            params[par_binfile]=argv[actarg++];
    while (argc>actarg)
        if (argv[actarg][0]=='-')
            if (argc>actarg+1)
                if (string(argv[actarg])==par_binfile || argv[actarg+1][0]!='-')
                {
                    params[argv[actarg]]=argv[actarg+1];
                    actarg+=2;
                }
                else
                    params[argv[actarg++]]="";
            else
                params[argv[actarg++]]="";
        else
            params[par_binfile]=argv[actarg++];
    if ((!pdefined(par_binfile) || params[par_binfile]=="") && !pdefined("--help"))
    {
        cout<<syntax;
        return 0;
    }
    return 1;
}

str_list parse_sectionname(BinaryFile &binaryfile, const string section)
{
    str_list sec;
    bool only_data = section==sec_alldata || section==sec_all;
    bool only_executable =  section==sec_allexec || section==sec_all;
    if (only_data || only_executable)
    {
        MSections::iterator i;
        for (i=binaryfile.sections.begin();i!=binaryfile.sections.end();i++)
            if ((i->second.data->executable && only_executable) || (!i->second.data->executable && only_data))
                sec.push_back(i->second.data->name);
    }
    else
    {
        string s;
        const char *c=section.c_str();
        while (*c)
        {
            s="";
            while (*c && *c!=',')
                s+=*c++;
            sec.push_back(s);
            if (*c)
                c++;
        }
    }
    return sec;    
}

void print_sections_header()
{
    cout<<"no.   section name        start       size (hex)  size (dec)  executable"<<endl;
}

void print_sections_info(unsigned n, const string name, Address start, unsigned size, bool executable)
{
    cout<<"["<<setw(2)<<dec<<setfill('0')<<n<<"]  "<<name;
    int j=20-name.length();
    for (;j>0;j--)
        cout<<" ";
    cout<<"0x"<<setw(8)<<setfill('0')<<hex<<start<<
    "  0x"<<setw(8)<<setfill('0')<<hex<<size<<"  "<<
    setw(8)<<setfill(' ')<<dec<<size<<"        ";
    if (executable)
        cout<<"Y";
    else
        cout<<"N";
    cout<<endl;
}

//locates address
void locate_address(BinaryFile &binaryfile, const string address)
{
    MSections::iterator i;
    bool symboldefined;
    Address addr;
    // find as symbol
    addr=symbols->findaddress(address, symboldefined);
    // not found -> use as address
    if (!symboldefined)
        addr=hex2uint(address);
    int n=1;
    for (i=binaryfile.sections.begin();i!=binaryfile.sections.end();i++,n++)
        if (addr>=i->second.data->addr && addr<i->second.data->addr+i->second.data->size)
        {
            if (pdefined("-v"))
            {
                cout<<"Symbol "<<address;
                if (symboldefined)
                    cout<<"(0x"<<hex<<setw(8)<<setfill('0')<<addr<<")";
                cout<<" belongs to the section "<<i->first<<endl<<"Section information:"<<endl;
                print_sections_header();
                print_sections_info(n, i->first, i->second.data->addr, i->second.data->size, i->second.data->executable);
            }
            else
                cout<<i->first<<endl;
            break;
        }
}

//prints all sections
void print_sections(BinaryFile &binaryfile)
{
    MSections::iterator i;
    int n=1;
    print_sections_header();
    for (i=binaryfile.sections.begin();i!=binaryfile.sections.end();i++)
        print_sections_info(n++, i->first, i->second.data->addr, i->second.data->size, i->second.data->executable);
}

//prints section's content
void print_content(BinaryFile &binaryfile, const string sec)
{
    if (binaryfile.sections.find(sec)!=binaryfile.sections.end())
    {
        Section &section=binaryfile[sec];
        Address addr=section.data->addr;
        while (section.ValidAddress(addr))
            cout<<section[addr++];
    }
}

//prints all symbols from executable
void print_symbols(BinaryFile &binaryfile)
{
    typedef MSymbols::iterator it;
    for (it i=symbols->symbols.begin();i!=symbols->symbols.end();i++)
        cout<<"0x"<<hex<<i->first<<"=\""<<i->second<<"\";"<<endl;
}

//disassemble section
void disasm_section(BinaryFile &binaryfile, const string section)
{
    debug(":disassembling section "<<section<<endl);
    if (decinfo.print)
    {
        for (int i=0;i<78;i++)
            cout<<'#';
        cout<<endl<<"section "<<section<<":"<<endl;
    }
    decinfo.section = &binaryfile[section];
    decoder.Decode();
}

// disassemble section(s)
void disassemble(BinaryFile &binaryfile, const string section, const string scanned)
{
    str_list scan = parse_sectionname(binaryfile, scanned); // e.g. from "*exec" to (.text .init .plt)
    str_list s = parse_sectionname(binaryfile, section);
    str_list::iterator i;
    for (i=scan.begin();i!=scan.end();i++)
        binaryfile[*i]->scanaddress=true;
    for (i=s.begin();i!=s.end();i++)
        disasm_section(binaryfile, *i);
}

const char *syntax = "\
Usage: uda binary [options]\n\
       uda --help\n";

const char *options = "\
Options:\n\
    -b binary       use this when you can't use binary as the first parameter\n\
    -m mapfile      use mapfile as an additional symbol table\n\
    -p              load symbols from binary file (if found\n\
                    corresponding plugin) and print them on standart output\n\
    -d section(s)   disassemble section(s)\n\
    -f section(s)   find all handled addresses and print them\n\
                    on standart output\n\
    -s section(s)   scan addresses as immediate data for theese sections\n\
    -l address, -l symbol\n\
                    print a section containing this address/symbol\n\
    -c section      print a content of section\n\
    --sections      print the sections informations\n\
    -start address, -start symbol\n\
                    start disassembling from this address\n\
    -stop address, -stop symbol\n\
                    stop disassembling at this address\n\
    -size number    disassemble this number of bytes\n\
    --noaddress     print disassembling info without addresses\n\
    --nohexdump     print disassembling info without hexdump\n\
    --nosymbolic    print disassembling info without symbolic instruction\n\
    --onlyname      in symbolic address print only symbolic name\n\
    -v              verbosely print the process information\n\
    --debug         print all debug informations\n\
    --help          print uda options and plugins' informations\n\
sections could be:\n\
    section               section with name \"section\"\n\
    .fini,.init,.text     three sections (.fini, .init and .text)\n\
    *data                 all data sections\n\
    *exec                 all executable sections\n\
    *                     all sections\n";