TITANIUM_PROPERTY_GETTER(TableView, sections)
{
std::vector<JSValue> section_array;
const auto section_objects = get_sections();
for (auto section : section_objects) {
section_array.push_back(section->get_object());
}
return get_context().CreateArray(section_array);
}
/** Get the list of sections defined in the ELF Segment Table */
SgAsmGenericSectionPtrList
SgAsmElfFileHeader::get_segtab_sections()
{
SgAsmGenericSectionPtrList retval;
SgAsmGenericSectionPtrList sections = get_sections()->get_sections();
for (size_t i=0; i<sections.size(); i++) {
SgAsmElfSection *elfsec = dynamic_cast<SgAsmElfSection*>(sections[i]);
if (elfsec && elfsec->get_segment_entry()!=NULL)
retval.push_back(elfsec);
}
return retval;
}
PoolStringArray ConfigFile::_get_sections() const {
List<String> s;
get_sections(&s);
PoolStringArray arr;
arr.resize(s.size());
int idx = 0;
for (const List<String>::Element *E = s.front(); E; E = E->next()) {
arr.set(idx++, E->get());
}
return arr;
}
int do_board_upgrade_check(char *img)
{
if (is_authentication_check_enabled()) {
if (!get_sections()) {
printf("Error: %s is not a signed image\n", img);
return 1;
}
if (!is_image_authenticated()) {
printf("Error: \"%s\" couldn't be authenticated. Abort...\n", img);
return 1;
}
if (!check_image_version()) {
printf("Error: \"%s\" couldn't be upgraded. Abort...\n", img);
return 1;
}
}
return 0;
}
int has_valuable_info(const char *menu) {
FILE *f = fopen(menu, "r");
if(!f)
return 1;
char *menu_contents = file_to_str(f);
fclose(f);
section_node_t *secs = get_sections(menu_contents);
for(section_node_t *cur = secs; cur; cur = cur->next) {
section_t *sec = cur->val;
if(sec->type != S_HEADER && sec->type != S_FOOTER) {
free_section_node_t(secs);
free(menu_contents);
return 1;
}
}
free_section_node_t(secs);
free(menu_contents);
return 0;
}
/* Write the PE file header back to disk and all that it references */
void
SgAsmPEFileHeader::unparse(std::ostream &f) const
{
/* Write unreferenced areas back to the file before anything else. */
unparse_holes(f);
/* Write sections in the order of specialization, from least specialized to most specialized. This gives more specialized
* sections a chance to overwrite the less specialized sections. */
const SgAsmGenericSectionPtrList §ions = get_sections()->get_sections();
for (SgAsmGenericSectionPtrList::const_iterator si=sections.begin(); si!=sections.end(); ++si) {
if (V_SgAsmGenericSection==(*si)->variantT())
(*si)->unparse(f);
}
for (SgAsmGenericSectionPtrList::const_iterator si=sections.begin(); si!=sections.end(); ++si) {
if (V_SgAsmPESection==(*si)->variantT())
(*si)->unparse(f);
}
for (SgAsmGenericSectionPtrList::const_iterator si=sections.begin(); si!=sections.end(); ++si) {
if (V_SgAsmGenericSection!=(*si)->variantT() && V_SgAsmPESection!=(*si)->variantT())
(*si)->unparse(f);
}
/* Encode the "NT Optional Header" before the COFF Header since the latter depends on the former. Adjust the COFF Header's
* e_nt_hdr_size to accommodate the NT Optional Header in such a way that EXEs from tinype.com don't change (i.e., don't
* increase e_nt_hdr_size if the bytes beyond it are zero anyway, and if they aren't then adjust it as little as possible.
* The RVA/Size pairs are considered to be part of the NT Optional Header. */
size_t oh_size = p_rvasize_pairs->get_pairs().size() * sizeof(SgAsmPERVASizePair::RVASizePair_disk);
size_t rvasize_offset; /*offset with respect to "oh" buffer allocated below*/
if (4==get_word_size()) {
oh_size += sizeof(PE32OptHeader_disk);
} else if (8==get_word_size()) {
oh_size += sizeof(PE64OptHeader_disk);
} else {
throw FormatError("unsupported PE word size");
}
unsigned char *oh = new unsigned char[oh_size];
if (4==get_word_size()) {
encode((PE32OptHeader_disk*)oh);
rvasize_offset = sizeof(PE32OptHeader_disk);
} else if (8==get_word_size()) {
encode((PE64OptHeader_disk*)oh);
rvasize_offset = sizeof(PE64OptHeader_disk);
} else {
throw FormatError("unsupported PE word size");
}
for (size_t i=0; i<p_rvasize_pairs->get_pairs().size(); i++, rvasize_offset+=sizeof(SgAsmPERVASizePair::RVASizePair_disk)) {
SgAsmPERVASizePair::RVASizePair_disk *rvasize_disk = (SgAsmPERVASizePair::RVASizePair_disk*)(oh+rvasize_offset);
p_rvasize_pairs->get_pairs()[i]->encode(rvasize_disk);
}
while (oh_size>p_e_nt_hdr_size) {
if (0!=oh[oh_size-1]) break;
--oh_size;
}
ROSE_ASSERT(p_e_nt_hdr_size==oh_size); /*set in reallocate()*/
/* Write the fixed-length COFF Header */
PEFileHeader_disk fh;
encode(&fh);
rose_addr_t spos = write(f, 0, sizeof fh, &fh);
/* Write the following "NT Optional Header" */
spos = write(f, spos, oh_size, oh);
}
/* Change size of PE header based on word size */
bool
SgAsmPEFileHeader::reallocate()
{
bool reallocated = SgAsmGenericHeader::reallocate();
/* Resize if necessary */
rose_addr_t need = sizeof(PEFileHeader_disk);
if (4==get_word_size()) {
need += sizeof(PE32OptHeader_disk);
} else if (8==get_word_size()) {
need += sizeof(PE64OptHeader_disk);
} else {
throw FormatError("unsupported PE word size");
}
need += p_rvasize_pairs->get_pairs().size() * sizeof(SgAsmPERVASizePair::RVASizePair_disk);
if (need<get_size()) {
if (is_mapped()) {
ROSE_ASSERT(get_mapped_size()==get_size());
set_mapped_size(need);
}
set_size(need);
reallocated = true;
} else if (need>get_size()) {
get_file()->shift_extend(this, 0, need-get_size(), SgAsmGenericFile::ADDRSP_ALL, SgAsmGenericFile::ELASTIC_HOLE);
reallocated = true;
}
/* Make sure the RVA/Size pairs at the end of the header are consistent with the sections to which they point. Reallocate()
* has already been called recursively for the sections. */
update_rvasize_pairs();
/* Make sure header is consistent with sections. Reallocate() has already been called recursively for the sections.
* Count the number of sections in the table and update the header's e_nsections member. */
if (p_section_table) {
ROSE_ASSERT(p_section_table->get_header()==this);
SgAsmGenericSectionList *all = get_sections();
p_e_nsections = 0;
for (size_t i=0; i<all->get_sections().size(); i++) {
SgAsmPESection *pesec = dynamic_cast<SgAsmPESection*>(all->get_sections()[i]);
if (pesec && pesec->get_section_entry()!=NULL)
p_e_nsections++;
}
rose_addr_t header_size = ALIGN_UP(p_section_table->get_offset() + p_section_table->get_size(),
p_e_file_align>0 ? p_e_file_align : 1);
#if 1
/* The PE Specification regarding e_header_size (known as "SizeOfHeader" on page 14 of "Microsoft Portable Executable
* and Common Object File Format Specification: Revision 8.1 February 15, 2008" is not always followed. We recompute
* it here as being the minimum RVA from all the sections defined in the PE Section Table, but not smaller
* than the value according to the specification. This alternate value is kept if it's already in the parse tree,
* otherwise we use the correct value. (RPM 2008-10-21) */
rose_addr_t min_offset = 0;
for (size_t i=0, nfound=0; i<all->get_sections().size(); i++) {
SgAsmPESection *pesec = dynamic_cast<SgAsmPESection*>(all->get_sections()[i]);
if (pesec && pesec->get_section_entry()!=NULL) {
if (0==nfound++) {
min_offset = pesec->get_offset();
} else {
min_offset = std::min(min_offset, pesec->get_offset() );
}
}
}
rose_addr_t header_size2 = std::max(header_size, min_offset);
if (p_e_header_size==header_size2)
header_size = header_size2;
/* If the original header size was zero then don't change that--leave it at zero. Some tiny executables have a zero
* value here and as a result, since this is near the end of the NT Optional Header, they can truncate the file and
* the loader will fill the optional header with zeros when reading. (RPM 2008-11-11) */
if (p_e_header_size==0)
header_size = 0;
#endif
p_e_header_size = header_size;
}
/* The size of the optional header. If there's a section table then we use its offset to calculate the optional header
* size in order to be compatible with the PE loader. Otherwise use the actual optional header size. */
if (p_section_table) {
ROSE_ASSERT(p_section_table->get_offset() >= get_offset() + sizeof(PEFileHeader_disk));
p_e_nt_hdr_size = p_section_table->get_offset() - (get_offset() + sizeof(PEFileHeader_disk));
} else if (4==get_word_size()) {
p_e_nt_hdr_size = sizeof(PE32OptHeader_disk);
} else if (8==get_word_size()) {
p_e_nt_hdr_size = sizeof(PE64OptHeader_disk);
} else {
throw FormatError("invalid PE word size");
}
/* Update COFF symbol table related data members in the file header */
if (get_coff_symtab()) {
ROSE_ASSERT(get_coff_symtab()->get_header()==this);
set_e_coff_symtab(get_coff_symtab()->get_offset());
set_e_coff_nsyms(get_coff_symtab()->get_nslots());
}
/* Update some additional header fields */
set_e_num_rvasize_pairs(get_rvasize_pairs()->get_pairs().size());
set_e_opt_magic(4==get_word_size() ? 0x010b : 0x020b);
set_e_lmajor((get_exec_format()->get_version() >> 16) & 0xffff);
set_e_lminor(get_exec_format()->get_version() & 0xffff);
/* Adjust the COFF Header's e_nt_hdr_size to accommodate the NT Optional Header in such a way that EXEs from tinype.com
* don't change (i.e., don't increase e_nt_hdr_size if the bytes beyond it are zero anyway, and if they aren't then adjust
* it as little as possible. The RVA/Size pairs are considered to be part of the NT Optional Header. */
size_t oh_size = p_rvasize_pairs->get_pairs().size() * sizeof(SgAsmPERVASizePair::RVASizePair_disk);
size_t rvasize_offset; /*offset with respect to "oh" buffer allocated below*/
if (4==get_word_size()) {
oh_size += sizeof(PE32OptHeader_disk);
} else if (8==get_word_size()) {
oh_size += sizeof(PE64OptHeader_disk);
} else {
throw FormatError("unsupported PE word size");
}
unsigned char *oh = new unsigned char[oh_size];
if (4==get_word_size()) {
encode((PE32OptHeader_disk*)oh);
rvasize_offset = sizeof(PE32OptHeader_disk);
} else if (8==get_word_size()) {
encode((PE64OptHeader_disk*)oh);
rvasize_offset = sizeof(PE64OptHeader_disk);
} else {
delete[] oh;
throw FormatError("unsupported PE word size");
}
while (oh_size>p_e_nt_hdr_size) {
if (0!=oh[oh_size-1]) break;
--oh_size;
}
set_e_nt_hdr_size(oh_size);
return reallocated;
}
/* Looks at the RVA/Size pairs in the PE header and creates an SgAsmGenericSection object for each one. This must be done
* after we build the mapping from virtual addresses to file offsets. */
void
SgAsmPEFileHeader::create_table_sections()
{
/* First, only create the sections. */
for (size_t i=0; i<p_rvasize_pairs->get_pairs().size(); i++) {
SgAsmPERVASizePair *pair = p_rvasize_pairs->get_pairs()[i];
if (0==pair->get_e_size())
continue;
/* Table names come from PE file specification and are hard coded by RVA/Size pair index */
const char *tabname_short;
std::string tabname = rvasize_pair_name((PairPurpose)i, &tabname_short);
/* Find the starting offset in the file.
* FIXME: We have a potential problem here in that ROSE sections are always contiguous in the file but a section created
* from an RVA/Size pair is not necessarily contiguous in the file. Normally such sections are in fact
* contiguous and we'll just ignore this for now. In any case, as long as these sections only ever read their
* data via the same MemoryMap that we use here, everything should be fine. [RPM 2009-08-17] */
MemoryMap *map = get_loader_map();
ROSE_ASSERT(map!=NULL);
const MemoryMap::MapElement *elmt = map->find(get_base_va() + pair->get_e_rva());
if (!elmt) {
fprintf(stderr, "SgAsmPEFileHeader::create_table_sections: warning: pair-%zu, rva=0x%08"PRIx64", size=%"PRIu64
" bytes \"%s\": unable to find a mapping for the virtual address (skipping)\n",
i, pair->get_e_rva().get_rva(), pair->get_e_size(), tabname.c_str());
continue;
}
rose_addr_t file_offset = elmt->is_anonymous() ? 0 : elmt->get_va_offset(get_base_va() + pair->get_e_rva(), 1);
/* Create the new section */
SgAsmGenericSection *tabsec = NULL;
switch (i) {
case 0: {
/* Sometimes export sections are represented by a ".edata" section, and sometimes they're represented by an
* RVA/Size pair, and sometimes both point to the same part of the file. We don't want the exports duplicated
* in the AST, so we only create this table as exports if we haven't already seen some other export section. */
SgAsmGenericSectionPtrList §ions = get_sections()->get_sections();
bool seen_exports = false;
for (SgAsmGenericSectionPtrList::iterator si=sections.begin(); !seen_exports && si!=sections.end(); ++si)
seen_exports = isSgAsmPEExportSection(*si);
if (seen_exports) {
tabsec = new SgAsmGenericSection(get_file(), this);
} else {
tabsec = new SgAsmPEExportSection(this);
}
break;
}
case 1: {
/* Sometimes import sections are represented by a ".idata" section, and sometimes they're represented by an
* RVA/Size pair, and sometimes both point to the same part of the file. We don't want the imports duplicated
* in the AST, so we only create this table as imports if we haven't already seen some other import section. */
SgAsmGenericSectionPtrList §ions = get_sections()->get_sections();
bool seen_imports = false;
for (SgAsmGenericSectionPtrList::iterator si=sections.begin(); !seen_imports && si!=sections.end(); ++si)
seen_imports = isSgAsmPEImportSection(*si);
if (seen_imports) {
tabsec = new SgAsmGenericSection(get_file(), this);
} else {
tabsec = new SgAsmPEImportSection(this);
}
break;
}
default: {
tabsec = new SgAsmGenericSection(get_file(), this);
break;
}
}
tabsec->set_name(new SgAsmBasicString(tabname));
tabsec->set_short_name(tabname_short);
tabsec->set_synthesized(true);
tabsec->set_purpose(SP_HEADER);
tabsec->set_offset(file_offset);
tabsec->set_size(pair->get_e_size());
tabsec->set_file_alignment(1);
tabsec->set_mapped_alignment(1);
tabsec->set_mapped_preferred_rva(pair->get_e_rva().get_rva());
tabsec->set_mapped_actual_va(pair->get_e_rva().get_rva()+get_base_va()); /*FIXME: not sure this is correct. [RPM 2009-09-11]*/
tabsec->set_mapped_size(pair->get_e_size());
tabsec->set_mapped_rperm(true);
tabsec->set_mapped_wperm(false);
tabsec->set_mapped_xperm(false);
pair->set_section(tabsec);
pair->set_e_rva(pair->get_e_rva().set_section(tabsec));
}
/* Now parse the sections */
for (size_t i=0; i<p_rvasize_pairs->get_pairs().size(); i++) {
SgAsmPERVASizePair *pair = p_rvasize_pairs->get_pairs()[i];
SgAsmGenericSection *tabsec = pair->get_section();
if (tabsec)
tabsec->parse();
}
}