hackedteam/vector-dropper

#ifndef _GENERIC_SECTION_H
#define _GENERIC_SECTION_H

#include <iostream>
#include <string>
using namespace std;

#include "common.h"

class PEObject;

class GenericSection
{
protected:
    char* _data;
    size_t _size;
    
    IMAGE_SECTION_HEADER* _header;
    string _name;
    
    bool _allocated;
    bool _eof; // if true, section is EOF data and should not be added to data directories
    
    PEObject& _pe;
    
    friend class ResourceSection;
    
public:
    GenericSection(PEObject& pe, string name);
    GenericSection(PEObject& pe, string name, IMAGE_SECTION_HEADER* header);
    GenericSection(const GenericSection& rhs)
        : _pe(rhs._pe)
    {
        // cout << __FUNCTION__ << " copy constructor." << endl;

        _size = rhs._size;
        _data = new char[_size];
        memcpy(_data, rhs._data, _size);

        _header = new IMAGE_SECTION_HEADER;
        memcpy(_header, rhs._header, sizeof(IMAGE_SECTION_HEADER));
        
        _name = rhs._name;
        _allocated = rhs._allocated;
    }
    
    GenericSection& operator=(const GenericSection& rhs)
    {
        // cout << __FUNCTION__ << " assignment operator." << endl;

        if (this == &rhs)
            return *this;

        if (_data)
            delete [] _data;
        
        _size = rhs._size;

        if (rhs._data)
        {
            _data = new char[_size];
            memcpy(_data, rhs._data, _size);
        } else {
            _data = NULL;
        }

        _name = rhs._name;
        _allocated = rhs._allocated;
        
        return *this;
    }
    
    virtual ~GenericSection(void);
    
    inline DWORD alignTo( DWORD _size, DWORD _base_size )
    {
        return ( ((_size + _base_size - 1) / _base_size) * _base_size );
    }
    
    inline DWORD alignToDWORD( DWORD _size )
    {
        return (DWORD)( _size + ( sizeof(DWORD) - (_size % (sizeof(DWORD)))));
    }
    
    DWORD FileAlignment();
    DWORD SectionAlignment();
    
    IMAGE_SECTION_HEADER* Header() { return _header; }
    
    void set_data(char *data, size_t size) { _data = data; /*_size = size;*/ _header->SizeOfRawData = size; };
    char * data() { return _data; }
    size_t size() { return _size; }
    
    bool isEof() { return _eof; }
    void setEof(bool value) { _eof = value; }
    bool isAllocated() { return _allocated; }
    
    void SetData(char const * const data, DWORD size);
    
    void SetFilePointer(char * ptr, size_t size) { _data = ptr + _header->PointerToRawData; _size = size; }
    
    DWORD PointerToRawData() { return _header->PointerToRawData; }
    DWORD SizeOfRawData() { return _header->SizeOfRawData; }
    DWORD VirtualAddress() { return _header->VirtualAddress; }
    DWORD VirtualSize() { return _header->Misc.VirtualSize; }
    
    void SetPointerToRawData(DWORD ptr) { _header->PointerToRawData = ptr; }
    void SetSizeOfRawData(DWORD size) { _header->SizeOfRawData = size; }
    void SetVirtualAddress(DWORD address) { _header->VirtualAddress = address; }
    void SetVirtualSize(DWORD size) { _header->Misc.VirtualSize = size; }
    
    DWORD Characteristics() { return _header->Characteristics; };
    void SetCharacteristics(DWORD characteristics) { _header->Characteristics = characteristics; }
    void SetName(std::string name) { memcpy(_header->Name, name.c_str(), name.size() < IMAGE_SIZEOF_SHORT_NAME ? name.size() : IMAGE_SIZEOF_SHORT_NAME); }
    string Name() { return string((char*)_header->Name); }
};

#endif /* _GENERIC_SECTION_H */