mirror/ELFIO
1
0
Fork 0
mirror of https://github.com/serge1/ELFIO.git synced 2024-11-19 11:14:46 +00:00
Code Issues Packages Projects Releases Wiki Activity
41f4012d49
ELFIO/tests/ELFIOTest1.cpp
Serge Lamikhov-Center 41f4012d49 Just formatting
2024-06-15 10:58:36 +03:00

896 lines
34 KiB
C++
Raw Blame History

/*
Copyright (C) 2001-present by Serge Lamikhov-Center
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#define ELFIO_NO_INTTYPES
#endif
#include <gtest/gtest.h>
#include <elfio/elfio.hpp>
using namespace ELFIO;
enum Tests
{
SEG_ALIGN = 1
};
////////////////////////////////////////////////////////////////////////////////
bool write_obj_i386( bool is64bit )
{
elfio writer;
writer.create( is64bit ? ELFCLASS64 : ELFCLASS32, ELFDATA2LSB );
writer.set_type( ET_REL );
writer.set_os_abi( ELFOSABI_LINUX );
writer.set_machine( is64bit ? EM_X86_64 : EM_386 );
// Create code section*
section* text_sec = writer.sections.add( ".text" );
text_sec->set_type( SHT_PROGBITS );
text_sec->set_flags( SHF_ALLOC | SHF_EXECINSTR );
text_sec->set_addr_align( 0x10 );
// Add data into it
char text[] = {
'\xB8', '\x04', '\x00', '\x00', '\x00', // mov eax, 4
'\xBB', '\x01', '\x00', '\x00', '\x00', // mov ebx, 1
'\xB9', '\x00', '\x00', '\x00', '\x00', // mov ecx, msg
'\xBA', '\x0E', '\x00', '\x00', '\x00', // mov edx, 14
'\xCD', '\x80', // int 0x80
'\xB8', '\x01', '\x00', '\x00', '\x00', // mov eax, 1
'\xCD', '\x80' // int 0x80
};
text_sec->set_data( text, sizeof( text ) );
// Create data section*
section* data_sec = writer.sections.add( ".data" );
data_sec->set_type( SHT_PROGBITS );
data_sec->set_flags( SHF_ALLOC | SHF_WRITE );
data_sec->set_addr_align( 4 );
char data[] = {
'\x48', '\x65', '\x6C', '\x6C', '\x6F', // msg: db 'Hello, World!', 10
'\x2C', '\x20', '\x57', '\x6F', '\x72',
'\x6C', '\x64', '\x21', '\x0A' };
data_sec->set_data( data, sizeof( data ) );
section* str_sec = writer.sections.add( ".strtab" );
str_sec->set_type( SHT_STRTAB );
str_sec->set_addr_align( 0x1 );
string_section_accessor str_writer( str_sec );
Elf_Word nStrIndex = str_writer.add_string( "msg" );
section* sym_sec = writer.sections.add( ".symtab" );
sym_sec->set_type( SHT_SYMTAB );
sym_sec->set_info( 2 );
sym_sec->set_link( str_sec->get_index() );
sym_sec->set_addr_align( 4 );
sym_sec->set_entry_size( writer.get_default_entry_size( SHT_SYMTAB ) );
symbol_section_accessor symbol_writer( writer, sym_sec );
Elf_Word nSymIndex = symbol_writer.add_symbol(
nStrIndex, 0, 0, STB_LOCAL, STT_NOTYPE, 0, data_sec->get_index() );
// Another way to add symbol
symbol_writer.add_symbol( str_writer, "_start", 0x00000000, 0, STB_WEAK,
STT_FUNC, 0, text_sec->get_index() );
// Create relocation table section*
section* rel_sec = writer.sections.add( ".rel.text" );
rel_sec->set_type( SHT_REL );
rel_sec->set_info( text_sec->get_index() );
rel_sec->set_link( sym_sec->get_index() );
rel_sec->set_addr_align( 4 );
rel_sec->set_entry_size( writer.get_default_entry_size( SHT_REL ) );
relocation_section_accessor rel_writer( writer, rel_sec );
rel_writer.add_entry( 11, nSymIndex, (unsigned char)R_386_RELATIVE );
// Another method to add the same relocation entry
// pRelWriter->AddEntry( pStrWriter, "msg",
// pSymWriter, 29, 0,
// ELF32_ST_INFO( STB_GLOBAL, STT_OBJECT ), 0,
// data_sec->GetIndex(),
// 0, (unsigned char)R_386_RELATIVE );
// Create note section*
section* note_sec = writer.sections.add( ".note" );
note_sec->set_type( SHT_NOTE );
note_sec->set_addr_align( 1 );
// Create notes writer
note_section_accessor note_writer( writer, note_sec );
note_writer.add_note( 0x77, "Created by ELFIO", 0, 0 );
// Create ELF file
writer.save( is64bit ? "elf_examples/write_obj_i386_64.o"
: "elf_examples/write_obj_i386_32.o" );
return true;
}
////////////////////////////////////////////////////////////////////////////////
bool write_exe_i386( const std::string& filename,
bool is64bit,
bool set_addr = false,
Elf64_Addr addr = 0 )
{
elfio writer;
writer.create( is64bit ? ELFCLASS64 : ELFCLASS32, ELFDATA2LSB );
writer.set_os_abi( ELFOSABI_LINUX );
writer.set_type( ET_EXEC );
writer.set_machine( is64bit ? EM_X86_64 : EM_386 );
// Create code section*
section* text_sec = writer.sections.add( ".text" );
text_sec->set_type( SHT_PROGBITS );
text_sec->set_flags( SHF_ALLOC | SHF_EXECINSTR );
text_sec->set_addr_align( 0x10 );
if ( set_addr ) {
text_sec->set_address( addr );
}
// Add data into it
char text[] = {
'\xB8', '\x04', '\x00', '\x00', '\x00', // mov eax, 4
'\xBB', '\x01', '\x00', '\x00', '\x00', // mov ebx, 1
'\xB9', '\x20', '\x80', '\x04', '\x08', // mov ecx, msg
'\xBA', '\x0E', '\x00', '\x00', '\x00', // mov edx, 14
'\xCD', '\x80', // int 0x80
'\xB8', '\x01', '\x00', '\x00', '\x00', // mov eax, 1
'\xCD', '\x80' // int 0x80
};
text_sec->set_data( text, sizeof( text ) );
segment* text_seg = writer.segments.add();
text_seg->set_type( PT_LOAD );
text_seg->set_virtual_address( 0x08048000 );
text_seg->set_physical_address( 0x08048000 );
text_seg->set_flags( PF_X | PF_R );
text_seg->set_align( 0x1000 );
text_seg->add_section( text_sec, text_sec->get_addr_align() );
// Create data section*
section* data_sec = writer.sections.add( ".data" );
data_sec->set_type( SHT_PROGBITS );
data_sec->set_flags( SHF_ALLOC | SHF_WRITE );
data_sec->set_addr_align( 0x4 );
char data[] = {
'\x48', '\x65', '\x6C', '\x6C', '\x6F', // msg: db 'Hello, World!', 10
'\x2C', '\x20', '\x57', '\x6F', '\x72',
'\x6C', '\x64', '\x21', '\x0A' };
data_sec->set_data( data, sizeof( data ) );
segment* data_seg = writer.segments.add();
data_seg->set_type( PT_LOAD );
data_seg->set_virtual_address( 0x08048020 );
data_seg->set_physical_address( 0x08048020 );
data_seg->set_flags( PF_W | PF_R );
data_seg->set_align( 0x10 );
data_seg->add_section_index( data_sec->get_index(),
data_sec->get_addr_align() );
section* note_sec = writer.sections.add( ".note" );
note_sec->set_type( SHT_NOTE );
note_sec->set_addr_align( 1 );
note_section_accessor note_writer( writer, note_sec );
note_writer.add_note( 0x01, "Created by ELFIO", 0, 0 );
char descr[6] = { 0x31, 0x32, 0x33, 0x34, 0x35, 0x36 };
note_writer.add_note( 0x01, "Never easier!", descr, sizeof( descr ) );
// Create ELF file
writer.set_entry( 0x08048000 );
writer.save( filename );
return true;
}
/*
////////////////////////////////////////////////////////////////////////////////
void checkObjestsAreEqual( std::string file_name1, std::string file_name2 )
{
elfio file1;
elfio file2;
ASSERT_EQ( file1.load( file_name1 ), true );
EXPECT_EQ( file1.save( file_name2 ), true );
ASSERT_EQ( file1.load( file_name1 ), true );
ASSERT_EQ( file2.load( file_name2 ), true );
for ( int i = 0; i < file1.sections.size(); ++i ) {
EXPECT_EQ( file1.sections[i]->get_address(),
file2.sections[i]->get_address() );
EXPECT_EQ( file1.sections[i]->get_addr_align(),
file2.sections[i]->get_addr_align() );
EXPECT_EQ( file1.sections[i]->get_entry_size(),
file2.sections[i]->get_entry_size() );
EXPECT_EQ( file1.sections[i]->get_flags(),
file2.sections[i]->get_flags() );
EXPECT_EQ( file1.sections[i]->get_index(),
file2.sections[i]->get_index() );
EXPECT_EQ( file1.sections[i]->get_info(),
file2.sections[i]->get_info() );
EXPECT_EQ( file1.sections[i]->get_link(),
file2.sections[i]->get_link() );
EXPECT_EQ( file1.sections[i]->get_name(),
file2.sections[i]->get_name() );
EXPECT_EQ( file1.sections[i]->get_name_string_offset(),
file2.sections[i]->get_name_string_offset() );
EXPECT_EQ( file1.sections[i]->get_size(),
file2.sections[i]->get_size() );
EXPECT_EQ( file1.sections[i]->get_type(),
file2.sections[i]->get_type() );
if ( file1.sections[i]->get_type() == SHT_NULL ||
file1.sections[i]->get_type() == SHT_NOBITS ) {
continue;
}
ASSERT_NE( file1.sections[i]->get_data(), (const char*)0 );
ASSERT_NE( file2.sections[i]->get_data(), (const char*)0 );
std::string pdata1( file1.sections[i]->get_data(),
file1.sections[i]->get_data() +
file1.sections[i]->get_size() );
std::string pdata2( file2.sections[i]->get_data(),
file2.sections[i]->get_data() +
file2.sections[i]->get_size() );
EXPECT_EQ( file1.sections[i]->get_size(),
file2.sections[i]->get_size() );
if ( ( file2.sections[i]->get_type() != SHT_NULL ) &&
( file2.sections[i]->get_type() != SHT_NOBITS ) ) {
EXPECT_EQ_COLLECTIONS( pdata1.begin(), pdata1.end(), pdata2.begin(),
pdata2.end() );
}
}
}
////////////////////////////////////////////////////////////////////////////////
void checkExeAreEqual( std::string file_name1,
std::string file_name2,
int skipTests = 0 )
{
checkObjestsAreEqual( file_name1, file_name2 );
elfio file1;
elfio file2;
ASSERT_EQ( file1.load( file_name1 ), true );
ASSERT_EQ( file2.load( file_name2 ), true );
for ( int i = 0; i < file1.segments.size(); ++i ) {
if ( !( skipTests & SEG_ALIGN ) )
EXPECT_EQ( file1.segments[i]->get_align(),
file2.segments[i]->get_align() );
EXPECT_EQ( file1.segments[i]->get_file_size(),
file2.segments[i]->get_file_size() );
EXPECT_EQ( file1.segments[i]->get_memory_size(),
file2.segments[i]->get_memory_size() );
EXPECT_EQ( file1.segments[i]->get_type(),
file2.segments[i]->get_type() );
// skip data comparisons of the program header and of empty segments
if ( file1.segments[i]->get_type() == PT_PHDR ||
!file1.segments[i]->get_file_size() )
continue;
ASSERT_NE( file1.segments[i]->get_data(), (const char*)0 );
ASSERT_NE( file2.segments[i]->get_data(), (const char*)0 );
std::string pdata1( file1.segments[i]->get_data(),
file1.segments[i]->get_data() +
file1.segments[i]->get_file_size() );
std::string pdata2( file2.segments[i]->get_data(),
file2.segments[i]->get_data() +
file2.segments[i]->get_file_size() );
// truncate the data if the header and the segment table is
// part of the segment
Elf64_Off afterPHDR =
file1.get_segments_offset() +
file1.get_segment_entry_size() * (Elf64_Off)file1.segments.size();
if ( file1.segments[i]->get_offset() < afterPHDR ) {
pdata1 = pdata1.substr( (unsigned int)afterPHDR );
pdata2 = pdata2.substr( (unsigned int)afterPHDR );
}
EXPECT_EQ_COLLECTIONS( pdata1.begin(), pdata1.end(), pdata2.begin(),
pdata2.end() );
}
}
////////////////////////////////////////////////////////////////////////////////
TEST( ELFIOTest, write_obj_i386_32 )
{
EXPECT_EQ( true, write_obj_i386( false ) );
output_test_stream output( "elf_examples/write_obj_i386_32_match.o", true,
false );
std::ifstream input( "elf_examples/write_obj_i386_32.o", std::ios::binary );
output << input.rdbuf();
BOOST_CHECK( output.match_pattern() );
}
////////////////////////////////////////////////////////////////////////////////
TEST( ELFIOTest, write_obj_i386_64 )
{
EXPECT_EQ( true, write_obj_i386( true ) );
output_test_stream output( "elf_examples/write_obj_i386_64_match.o", true,
false );
std::ifstream input( "elf_examples/write_obj_i386_64.o", std::ios::binary );
output << input.rdbuf();
BOOST_CHECK( output.match_pattern() );
}
////////////////////////////////////////////////////////////////////////////////
TEST( ELFIOTest, write_exe_i386_32 )
{
const std::string generated_file( "elf_examples/write_exe_i386_32" );
const std::string reference_file( "elf_examples/write_exe_i386_32_match" );
EXPECT_EQ( true, write_exe_i386( generated_file, false ) );
output_test_stream output( reference_file, true, false );
std::ifstream input( generated_file, std::ios::binary );
output << input.rdbuf();
BOOST_CHECK_MESSAGE( output.match_pattern(), "Comparing " + generated_file +
" and " + reference_file );
}
////////////////////////////////////////////////////////////////////////////////
TEST( ELFIOTest, elf_object_copy_32 )
{
checkObjestsAreEqual( "elf_examples/hello_32.o",
"elf_examples/hello_32_copy.o" );
checkObjestsAreEqual( "elf_examples/hello_64.o",
"elf_examples/hello_64_copy.o" );
checkObjestsAreEqual( "elf_examples/test_ppc.o",
"elf_examples/test_ppc_copy.o" );
checkObjestsAreEqual( "elf_examples/write_obj_i386_32.o",
"elf_examples/write_obj_i386_32_copy.o" );
checkObjestsAreEqual( "elf_examples/write_obj_i386_64.o",
"elf_examples/write_obj_i386_64_copy.o" );
}
////////////////////////////////////////////////////////////////////////////////
TEST( ELFIOTest, section_header_address_update )
{
elfio reader;
const std::string file_w_addr( "elf_examples/write_exe_i386_32_w_addr" );
write_exe_i386( file_w_addr, false, true, 0x08048100 );
reader.load( file_w_addr );
section* sec = reader.sections[".text"];
ASSERT_NE( sec, (section*)0 );
EXPECT_EQ( sec->get_address(), 0x08048100 );
const std::string file_wo_addr( "elf_examples/write_exe_i386_32_wo_addr" );
write_exe_i386( file_wo_addr, false, false, 0 );
reader.load( file_wo_addr );
sec = reader.sections[".text"];
ASSERT_NE( sec, (section*)0 );
EXPECT_EQ( sec->get_address(), 0x08048000 );
}
////////////////////////////////////////////////////////////////////////////////
TEST( ELFIOTest, elfio_copy )
{
elfio e;
const std::string filename(
"elf_examples/write_exe_i386_32_section_added" );
write_exe_i386( filename, false, true, 0x08048100 );
e.load( filename );
Elf_Half num = e.sections.size();
//section* new_sec =
e.sections.add( "new" );
e.save( filename );
EXPECT_EQ( num + 1, e.sections.size() );
}
////////////////////////////////////////////////////////////////////////////////
TEST( ELFIOTest, elf_exe_copy_64 )
{
checkExeAreEqual( "elf_examples/64bitLOAD.elf",
"elf_examples/64bitLOAD_copy.elf" );
checkExeAreEqual( "elf_examples/asm64", "elf_examples/asm64_copy" );
checkExeAreEqual( "elf_examples/hello_64", "elf_examples/hello_64_copy" );
// The last segment (GNU_RELRO) is bigger than necessary.
// I don't see why but it contains a few bits of the .got.plt section.
// -> load, store, compare cycle fails
// checkExeAreEqual( "elf_examples/main",
// "elf_examples/main_copy" );
// checkExeAreEqual( "elf_examples/ls",
// "elf_examples/ls_copy" );
}
////////////////////////////////////////////////////////////////////////////////
TEST( ELFIOTest, elf_exe_copy_32 )
{
checkExeAreEqual( "elf_examples/asm", "elf_examples/asm_copy" );
checkExeAreEqual( "elf_examples/arm_v7m_test_debug.elf",
"elf_examples/arm_v7m_test_debug_copy.elf" );
checkExeAreEqual( "elf_examples/arm_v7m_test_release.elf",
"elf_examples/arm_v7m_test_release_copy.elf" );
checkExeAreEqual( "elf_examples/hello_32", "elf_examples/hello_32_copy" );
checkExeAreEqual( "elf_examples/hello_arm", "elf_examples/hello_arm_copy" );
checkExeAreEqual( "elf_examples/hello_arm_stripped",
"elf_examples/hello_arm_stripped_copy" );
checkExeAreEqual( "elf_examples/read_write_arm_elf32_input",
"elf_examples/read_write_arm_elf32_input_copy" );
checkExeAreEqual( "elf_examples/test_ppc", "elf_examples/test_ppc_copy" );
}
////////////////////////////////////////////////////////////////////////////////
TEST( ELFIOTest, elf_exe_loadsave_ppc32big3 )
{
std::string in = "elf_examples/ppc-32bit-specimen3.elf";
std::string out = "elf_examples/ppc-32bit-testcopy3.elf";
elfio elf;
ASSERT_EQ( elf.load( in ), true );
ASSERT_EQ( elf.save( out ), true );
checkObjestsAreEqual( in, out );
checkExeAreEqual( in, out, SEG_ALIGN );
}
*/
////////////////////////////////////////////////////////////////////////////////
TEST( ELFIOTest, get_symbol_32 )
{
elfio elf;
std::string name;
ELFIO::Elf_Xword size;
unsigned char bind;
unsigned char type;
ELFIO::Elf_Half section_index;
unsigned char other;
std::string in = "elf_examples/hello_32";
ASSERT_EQ( elf.load( in ), true );
section* psymsec = elf.sections[".symtab"];
const symbol_section_accessor symbols( elf, psymsec );
EXPECT_EQ( true, symbols.get_symbol( 0x08048478, name, size, bind, type,
section_index, other ) );
EXPECT_EQ( "_IO_stdin_used", name );
EXPECT_EQ( 14, section_index );
EXPECT_EQ( 4, size );
}
////////////////////////////////////////////////////////////////////////////////
TEST( ELFIOTest, get_symbol_64 )
{
elfio elf;
std::string name;
ELFIO::Elf_Xword size;
unsigned char bind;
unsigned char type;
ELFIO::Elf_Half section_index;
unsigned char other;
std::string in = "elf_examples/hello_64";
ASSERT_EQ( elf.load( in ), true );
section* psymsec = elf.sections[".symtab"];
const symbol_section_accessor symbols( elf, psymsec );
EXPECT_EQ( true, symbols.get_symbol( 0x00400498, name, size, bind, type,
section_index, other ) );
EXPECT_EQ( "main", name );
EXPECT_EQ( 12, section_index );
EXPECT_EQ( 21, size );
}
////////////////////////////////////////////////////////////////////////////////
TEST( ELFIOTest, null_section_inside_segment )
{
// This test case checks the load/save of SHT_NULL sections in a segment
// See https://github.com/serge1/ELFIO/issues/19
//
// Note: The test case checking the load/save of a segment containing no section
// is covered by elf_object_copy_32: elf_examples/hello_32 has empty segments
// Create an ELF file with SHT_NULL sections at the beginning/middle/end of a segment
elfio writer;
writer.create( ELFCLASS32, ELFDATA2LSB );
writer.set_os_abi( ELFOSABI_LINUX );
writer.set_type( ET_EXEC );
writer.set_machine( EM_386 );
// Create code section 1
section* text_sec1 = writer.sections.add( ".text1" );
text_sec1->set_type( SHT_PROGBITS );
text_sec1->set_flags( SHF_ALLOC | SHF_EXECINSTR );
text_sec1->set_addr_align( 0x10 );
text_sec1->set_address( 0x08048000 );
char text[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
text_sec1->set_data( text, sizeof( text ) );
// Create code section 2
section* text_sec2 = writer.sections.add( ".text2" );
text_sec2->set_type( SHT_PROGBITS );
text_sec2->set_flags( SHF_ALLOC | SHF_EXECINSTR );
text_sec2->set_addr_align( 0x10 );
text_sec2->set_address( 0x08048010 );
text_sec2->set_data( text, sizeof( text ) );
// Create null sections
section* null_sec1 = writer.sections.add( "null" );
null_sec1->set_type( SHT_NULL );
null_sec1->set_flags( SHF_ALLOC | SHF_EXECINSTR );
null_sec1->set_address( 0x08048000 );
section* null_sec2 = writer.sections.add( "null" );
null_sec2->set_type( SHT_NULL );
null_sec2->set_flags( SHF_ALLOC | SHF_EXECINSTR );
null_sec2->set_address( 0x08048010 );
section* null_sec3 = writer.sections.add( "null" );
null_sec3->set_type( SHT_NULL );
null_sec3->set_flags( SHF_ALLOC | SHF_EXECINSTR );
null_sec3->set_address( 0x08048020 );
// Create a loadable segment
segment* text_seg = writer.segments.add();
text_seg->set_type( PT_LOAD );
text_seg->set_virtual_address( 0x08048000 );
text_seg->set_physical_address( 0x08048000 );
text_seg->set_flags( PF_X | PF_R );
text_seg->set_align( 0x1000 );
// Add sections into the loadable segment
text_seg->add_section_index( null_sec1->get_index(),
null_sec1->get_addr_align() );
text_seg->add_section_index( text_sec1->get_index(),
text_sec1->get_addr_align() );
text_seg->add_section_index( null_sec2->get_index(),
null_sec2->get_addr_align() );
text_seg->add_section_index( text_sec2->get_index(),
text_sec2->get_addr_align() );
text_seg->add_section_index( null_sec3->get_index(),
null_sec3->get_addr_align() );
// Setup entry point
writer.set_entry( 0x08048000 );
// Create ELF file
std::string f1 = "elf_examples/null_section_inside_segment1";
std::string f2 = "elf_examples/null_section_inside_segment2";
EXPECT_EQ( writer.save( f1 ), true );
// Load and check the ELF file created above
elfio elf;
EXPECT_EQ( elf.load( f1 ), true );
EXPECT_EQ( elf.save( f2 ), true );
}
////////////////////////////////////////////////////////////////////////////////
TEST( ELFIOTest, invalid_file )
{
elfio elf;
std::string name;
ELFIO::Elf64_Addr value;
ELFIO::Elf_Xword size;
unsigned char bind;
unsigned char type;
ELFIO::Elf_Half section_index;
unsigned char other;
std::string in = "elf_examples/crash.elf";
ASSERT_EQ( elf.load( in ), true );
section* psymsec = elf.sections[".symtab"];
ASSERT_NE( psymsec, (void*)0 );
const symbol_section_accessor symbols( elf, psymsec );
EXPECT_EQ( true, symbols.get_symbol( "main", value, size, bind, type,
section_index, other ) );
EXPECT_EQ( 0x402560, value );
EXPECT_EQ( true, symbols.get_symbol( "frame_dummy", value, size, bind, type,
section_index, other ) );
EXPECT_EQ( 0x402550, value );
EXPECT_EQ( false, symbols.get_symbol( 0x00400498, name, size, bind, type,
section_index, other ) );
}
////////////////////////////////////////////////////////////////////////////////
TEST( ELFIOTest, rearrange_local_symbols )
{
std::string name = "";
ELFIO::Elf64_Addr value = 0;
ELFIO::Elf_Xword size = 0;
unsigned char bind = STB_LOCAL;
unsigned char type = STT_FUNC;
ELFIO::Elf_Half section_index = 0;
unsigned char other = 0;
const std::string file_name = "elf_examples/test_symbols_order.elf";
elfio writer;
writer.create( ELFCLASS64, ELFDATA2LSB );
writer.set_os_abi( ELFOSABI_LINUX );
writer.set_type( ET_EXEC );
writer.set_machine( EM_X86_64 );
section* str_sec = writer.sections.add( ".strtab" );
str_sec->set_type( SHT_STRTAB );
str_sec->set_addr_align( 0x1 );
string_section_accessor str_writer( str_sec );
section* sym_sec = writer.sections.add( ".symtab" );
sym_sec->set_type( SHT_SYMTAB );
sym_sec->set_info( 0 );
sym_sec->set_link( str_sec->get_index() );
sym_sec->set_addr_align( 4 );
sym_sec->set_entry_size( writer.get_default_entry_size( SHT_SYMTAB ) );
symbol_section_accessor symbols( writer, sym_sec );
auto sym_num = symbols.get_symbols_num();
name = "Str1";
bind = STB_GLOBAL;
value = 1;
symbols.add_symbol( str_writer, name.c_str(), value, size, bind, type,
other, section_index );
name = "Str2";
bind = STB_LOCAL;
value = 2;
symbols.add_symbol( str_writer, name.c_str(), value, size, bind, type,
other, section_index );
name = "Str3";
bind = STB_WEAK;
value = 3;
symbols.add_symbol( str_writer, name.c_str(), value, size, bind, type,
other, section_index );
name = "Str4";
bind = STB_LOCAL;
value = 4;
symbols.add_symbol( str_writer, name.c_str(), value, size, bind, type,
other, section_index );
name = "Str5";
bind = STB_LOCAL;
value = 5;
symbols.add_symbol( str_writer, name.c_str(), value, size, bind, type,
other, section_index );
name = "Str6";
bind = STB_GLOBAL;
value = 6;
symbols.add_symbol( str_writer, name.c_str(), value, size, bind, type,
other, section_index );
name = "Str7";
bind = STB_LOCAL;
value = 7;
symbols.add_symbol( str_writer, name.c_str(), value, size, bind, type,
other, section_index );
name = "Str8";
bind = STB_WEAK;
value = 8;
symbols.add_symbol( str_writer, name.c_str(), value, size, bind, type,
other, section_index );
ASSERT_EQ( symbols.get_symbols_num(), sym_num + 9 );
symbols.arrange_local_symbols( [&]( Elf_Xword first, Elf_Xword ) -> void {
static int counter = 0;
EXPECT_EQ( first, ++counter );
} );
ASSERT_EQ( writer.save( file_name ), true );
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
elfio reader;
ASSERT_EQ( reader.load( file_name ), true );
auto psymsec = reader.sections[".symtab"];
ASSERT_NE( psymsec, nullptr );
const_symbol_section_accessor rsymbols( reader, psymsec );
auto bound = psymsec->get_info();
auto num = rsymbols.get_symbols_num();
EXPECT_LE( (Elf_Xword)bound, num );
// Check that all symbols are LOCAL until the bound value
for ( Elf_Word i = 0; i < bound; i++ ) {
rsymbols.get_symbol( i, name, value, size, bind, type, section_index,
other );
EXPECT_EQ( bind, (unsigned char)STB_LOCAL );
}
EXPECT_EQ( name, "Str7" );
// Check that all symbols are not LOCAL after the bound value
for ( Elf_Word i = bound; i < num; i++ ) {
rsymbols.get_symbol( i, name, value, size, bind, type, section_index,
other );
EXPECT_NE( bind, (unsigned char)STB_LOCAL );
}
EXPECT_EQ( name, "Str8" );
}
////////////////////////////////////////////////////////////////////////////////
TEST( ELFIOTest, rearrange_local_symbols_with_reallocation )
{
std::string name = "";
ELFIO::Elf64_Addr value = 0;
ELFIO::Elf_Xword size = 0;
unsigned char bind = STB_LOCAL;
unsigned char type = STT_FUNC;
ELFIO::Elf_Half section_index = 0;
unsigned char other = 0;
const std::string file_name = "elf_examples/test_symbols_order.elf";
elfio writer;
writer.create( ELFCLASS64, ELFDATA2LSB );
writer.set_os_abi( ELFOSABI_LINUX );
writer.set_type( ET_EXEC );
writer.set_machine( EM_X86_64 );
section* text_sec = writer.sections.add( ".text" );
text_sec->set_type( SHT_PROGBITS );
text_sec->set_flags( SHF_ALLOC | SHF_EXECINSTR );
text_sec->set_addr_align( 0x10 );
section* str_sec = writer.sections.add( ".strtab" );
str_sec->set_type( SHT_STRTAB );
str_sec->set_addr_align( 0x1 );
string_section_accessor str_writer( str_sec );
section* sym_sec = writer.sections.add( ".symtab" );
sym_sec->set_type( SHT_SYMTAB );
sym_sec->set_info( 0 );
sym_sec->set_link( str_sec->get_index() );
sym_sec->set_addr_align( 4 );
sym_sec->set_entry_size( writer.get_default_entry_size( SHT_SYMTAB ) );
symbol_section_accessor symbols( writer, sym_sec );
name = "Str1";
bind = STB_GLOBAL;
value = 1;
Elf_Word sym1 = symbols.add_symbol( str_writer, name.c_str(), value, size,
bind, type, other, section_index );
name = "Str2";
bind = STB_LOCAL;
value = 2;
Elf_Word sym2 = symbols.add_symbol( str_writer, name.c_str(), value, size,
bind, type, other, section_index );
name = "Str3";
bind = STB_WEAK;
value = 3;
Elf_Word sym3 = symbols.add_symbol( str_writer, name.c_str(), value, size,
bind, type, other, section_index );
name = "Str4";
bind = STB_LOCAL;
value = 4;
Elf_Word sym4 = symbols.add_symbol( str_writer, name.c_str(), value, size,
bind, type, other, section_index );
name = "Str5";
bind = STB_LOCAL;
value = 5;
Elf_Word sym5 = symbols.add_symbol( str_writer, name.c_str(), value, size,
bind, type, other, section_index );
name = "Str6";
bind = STB_GLOBAL;
value = 6;
Elf_Word sym6 = symbols.add_symbol( str_writer, name.c_str(), value, size,
bind, type, other, section_index );
name = "Str7";
bind = STB_LOCAL;
value = 7;
Elf_Word sym7 = symbols.add_symbol( str_writer, name.c_str(), value, size,
bind, type, other, section_index );
auto sym_num = symbols.get_symbols_num();
name = "Str8";
bind = STB_WEAK;
value = 8;
Elf_Word sym8 = symbols.add_symbol( str_writer, name.c_str(), value, size,
bind, type, other, section_index );
ASSERT_EQ( ( symbols.get_symbols_num() ), ( sym_num + 1 ) );
section* rel_sec = writer.sections.add( ".rel.text" );
rel_sec->set_type( SHT_REL );
rel_sec->set_info( text_sec->get_index() );
rel_sec->set_addr_align( 0x4 );
rel_sec->set_entry_size( writer.get_default_entry_size( SHT_REL ) );
rel_sec->set_link( sym_sec->get_index() );
relocation_section_accessor rela( writer, rel_sec );
// Add relocation entry (adjust address at offset 11)
rela.add_entry( 1, sym1, R_386_RELATIVE );
rela.add_entry( 8, sym8, R_386_RELATIVE );
rela.add_entry( 6, sym6, R_386_RELATIVE );
rela.add_entry( 2, sym2, R_386_RELATIVE );
rela.add_entry( 3, sym3, R_386_RELATIVE );
rela.add_entry( 8, sym8, R_386_RELATIVE );
rela.add_entry( 7, sym7, R_386_RELATIVE );
rela.add_entry( 2, sym2, R_386_RELATIVE );
rela.add_entry( 11, sym1, R_386_RELATIVE );
rela.add_entry( 18, sym8, R_386_RELATIVE );
rela.add_entry( 16, sym6, R_386_RELATIVE );
rela.add_entry( 12, sym2, R_386_RELATIVE );
rela.add_entry( 13, sym3, R_386_RELATIVE );
rela.add_entry( 17, sym7, R_386_RELATIVE );
rela.add_entry( 14, sym4, R_386_RELATIVE );
rela.add_entry( 15, sym5, R_386_RELATIVE );
std::vector<std::string> before;
for ( Elf_Word i = 0; i < rela.get_entries_num(); i++ ) {
Elf64_Addr offset;
Elf_Word symbol;
unsigned rtype;
Elf_Sxword addend;
rela.get_entry( i, offset, symbol, rtype, addend );
symbols.get_symbol( symbol, name, value, size, bind, type,
section_index, other );
before.emplace_back( name );
}
symbols.arrange_local_symbols( [&]( Elf_Xword first, Elf_Xword second ) {
rela.swap_symbols( first, second );
} );
ASSERT_EQ( writer.save( file_name ), true );
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
elfio reader;
ASSERT_EQ( reader.load( file_name ), true );
auto prelsec = reader.sections[".rel.text"];
auto psyms = reader.sections[".symtab"];
ASSERT_NE( prelsec, nullptr );
ASSERT_NE( psyms, nullptr );
const_relocation_section_accessor rel( reader, prelsec );
const_symbol_section_accessor syms( reader, psyms );
std::vector<std::string> after;
for ( Elf_Word i = 0; i < rel.get_entries_num(); i++ ) {
Elf64_Addr offset;
Elf_Word symbol;
unsigned rtype;
Elf_Sxword addend;
rel.get_entry( i, offset, symbol, rtype, addend );
syms.get_symbol( symbol, name, value, size, bind, type, section_index,
other );
after.emplace_back( name );
}
EXPECT_EQ( before, after );
// EXPECT_EQ_COLLECTIONS( before.begin(), before.end(), after.begin(),
// after.end() );
}
TEST( ELFIOTest, detect_mismatched_section_segment_tables )
{
/* This file is a hacked copy of hello_32
* The error introduced is:
* Virtual address of segment 3 (0x804948c) conflicts
* with address of section .ctors (0x804948e) at offset 0x48e
*/
std::string in = "elf_examples/mismatched_segments.elf";
elfio elf;
ASSERT_EQ( elf.load( in ), true );
ASSERT_TRUE( elf.validate().length() > 0 );
}
Reference in New Issue View Git Blame Copy Permalink