int main(int argc, char *argv[]){
elfHeader_t elfHeader;
FILE *elf, *bin;
uint32_t numBytesRead, i;
if(argc != 2){
printf("Please specify exactly one input elf file\n");
exit(-1);
}
if((elf = fopen(argv[1],"rb")) == NULL){
printf("Could not open %s\n", argv[1]);
exit(-2);
}
//
// FIXME
// The file name should match the input file excepting
// for the extension.
//
char *outputFileName = (char *)malloc(strlen(argv[1]) + 4);
char *ptr;
if(ptr = strrchr(argv[1], '.')) *ptr = '\0';
sprintf(outputFileName,"%s.img",argv[1]);
if((bin = fopen(outputFileName,"wb")) == NULL){
printf("Could not open file for writing\n");
exit(-3);
}
parseElfHeader(elf,&elfHeader);
if(elfHeader.e_type != ET_EXEC){
printf("Invalid ELF: Non-executable image\n");
exit(-4);
}
if(elfHeader.e_machine != EM_ARM){
printf("Invalid ELF: Not ARM executable\n");
exit(-5);
}
if(elfHeader.e_phoff == 0){
printf("Invalid ELF: Process image cannot be created\n");
exit(-6);
}
for(i=0; i<elfHeader.e_phnum; i++){
programHeader_t *programHeader = (programHeader_t *)malloc(sizeof(programHeader_t));
parseProgramHeader(elf, programHeader);
uint32_t inst;
fseek(elf, programHeader->p_paddr, SEEK_SET);
for(i=0; i<programHeader->p_filesz; i++){
fread(&inst,1,4,elf);
fwrite(&inst,1,4,bin);
}
}
fclose(elf);
fclose(bin);
}
ElfReader::Result ElfReader::readIt()
{
if (!m_elfData.sectionHeaders.isEmpty())
return Ok;
if (!m_elfData.programHeaders.isEmpty())
return Ok;
ElfMapper mapper(this);
if (!mapper.map())
return Corrupt;
const quint64 fdlen = mapper.fdlen;
if (fdlen < 64) {
m_errorString = QStringLiteral("'%1' is not an ELF object (file too small)").arg(QDir::toNativeSeparators(m_binary));
return NotElf;
}
if (strncmp(mapper.start, "\177ELF", 4) != 0) {
m_errorString = QStringLiteral("'%1' is not an ELF object").arg(QDir::toNativeSeparators(m_binary));
return NotElf;
}
// 32 or 64 bit
m_elfData.elfclass = ElfClass(mapper.start[4]);
const bool is64Bit = m_elfData.elfclass == Elf_ELFCLASS64;
if (m_elfData.elfclass != Elf_ELFCLASS32 && m_elfData.elfclass != Elf_ELFCLASS64) {
m_errorString = msgInvalidElfObject(m_binary, QStringLiteral("odd cpu architecture"));
return Corrupt;
}
// int bits = (data[4] << 5);
// If you remove this check to read ELF objects of a different arch,
// please make sure you modify the typedefs
// to match the _plugin_ architecture.
// if ((sizeof(void*) == 4 && bits != 32)
// || (sizeof(void*) == 8 && bits != 64)) {
// if (errorString)
// *errorString = QLibrary::QStringLiteral("'%1' is an invalid ELF object (%2)")
// .arg(m_binary).arg(QLatin1String("wrong cpu architecture"));
// return Corrupt;
// }
// Read Endianhness.
m_elfData.endian = ElfEndian(mapper.ustart[5]);
if (m_elfData.endian != Elf_ELFDATA2LSB && m_elfData.endian != Elf_ELFDATA2MSB) {
m_errorString = msgInvalidElfObject(m_binary, QStringLiteral("odd endianness"));
return Corrupt;
}
const uchar *data = mapper.ustart + 16; // e_ident
m_elfData.elftype = ElfType(getHalfWord(data, m_elfData));
m_elfData.elfmachine = ElfMachine(getHalfWord(data, m_elfData));
/* e_version = */ getWord(data, m_elfData);
m_elfData.entryPoint = getAddress(data, m_elfData);
quint64 e_phoff = getOffset(data, m_elfData);
quint64 e_shoff = getOffset(data, m_elfData);
/* e_flags = */ getWord(data, m_elfData);
quint32 e_shsize = getHalfWord(data, m_elfData);
if (e_shsize > fdlen) {
m_errorString = msgInvalidElfObject(m_binary, QStringLiteral("unexpected e_shsize"));
return Corrupt;
}
quint32 e_phentsize = getHalfWord(data, m_elfData);
if (e_phentsize != (is64Bit ? 56 : 32)) {
m_errorString = msgInvalidElfObject(m_binary, QStringLiteral("invalid structure"));
return ElfReader::Corrupt;
}
quint32 e_phnum = getHalfWord(data, m_elfData);
quint32 e_shentsize = getHalfWord(data, m_elfData);
if (e_shentsize % 4) {
m_errorString = msgInvalidElfObject(m_binary, QStringLiteral("unexpected e_shentsize"));
return Corrupt;
}
quint32 e_shnum = getHalfWord(data, m_elfData);
quint32 e_shtrndx = getHalfWord(data, m_elfData);
if (data != mapper.ustart + (is64Bit ? 64 : 52)) {
m_errorString = msgInvalidElfObject(m_binary, QStringLiteral("unexpected e_phentsize"));
return ElfReader::Corrupt;
}
if (quint64(e_shnum) * e_shentsize > fdlen) {
const QString reason = QStringLiteral("announced %1 sections, each %2 bytes, exceed file size").arg(e_shnum).arg(e_shentsize);
m_errorString = msgInvalidElfObject(m_binary, reason);
return Corrupt;
}
quint64 soff = e_shoff + e_shentsize * e_shtrndx;
// if ((soff + e_shentsize) > fdlen || soff % 4 || soff == 0) {
// m_errorString = QLibrary::QStringLiteral("'%1' is an invalid ELF object (%2)")
// .arg(m_binary)
// .arg(QLatin1String("shstrtab section header seems to be at %1"))
// .arg(QString::number(soff, 16));
// return Corrupt;
// }
if (e_shoff) {
ElfSectionHeader strtab;
parseSectionHeader(mapper.ustart + soff, &strtab, m_elfData);
const quint64 stringTableFileOffset = strtab.offset;
if (quint32(stringTableFileOffset + e_shentsize) >= fdlen
|| stringTableFileOffset == 0) {
const QString reason = QStringLiteral("string table seems to be at 0x%1").arg(soff, 0, 16);
m_errorString = msgInvalidElfObject(m_binary, reason);
return Corrupt;
}
for (quint32 i = 0; i < e_shnum; ++i) {
const uchar *s = mapper.ustart + e_shoff + i * e_shentsize;
ElfSectionHeader sh;
parseSectionHeader(s, &sh, m_elfData);
if (stringTableFileOffset + sh.index > fdlen) {
const QString reason = QStringLiteral("section name %1 of %2 behind end of file")
.arg(i).arg(e_shnum);
m_errorString = msgInvalidElfObject(m_binary, reason);
return Corrupt;
}
sh.name = mapper.start + stringTableFileOffset + sh.index;
if (sh.name == ".gdb_index") {
m_elfData.symbolsType = FastSymbols;
} else if (sh.name == ".debug_info") {
m_elfData.symbolsType = PlainSymbols;
} else if (sh.name == ".gnu_debuglink") {
m_elfData.debugLink = QByteArray(mapper.start + sh.offset);
m_elfData.symbolsType = LinkedSymbols;
} else if (sh.name == ".note.gnu.build-id") {
m_elfData.symbolsType = BuildIdSymbols;
if (sh.size > 16)
m_elfData.buildId = QByteArray(mapper.start + sh.offset + 16,
sh.size - 16).toHex();
}
m_elfData.sectionHeaders.append(sh);
}
}
if (e_phoff) {
for (quint32 i = 0; i < e_phnum; ++i) {
const uchar *s = mapper.ustart + e_phoff + i * e_phentsize;
ElfProgramHeader ph;
parseProgramHeader(s, &ph, m_elfData);
m_elfData.programHeaders.append(ph);
}
}
return Ok;
}
