Ich würde gerne die ImageBase, die ja an der 180. Stelle in der exe ist und 4 bytes lang ist, auslesen.

Bis jetzt sieht mein Programm so aus. Es gibt aber die Adresse im ASCII zeichensatz aus und nicht im hex format:

#include <iostream>
#include <windows.h>
#include <fstream>
#include <vector>

using namespace std;

void getImageBase(ifstream& istream);

int main()
{
    ifstream f1;
    f1.open("test.exe",ios::in | ios::binary);

    if( f1.is_open() != true )
    {
        cerr << "Konnte Datei nicht oeffnen!" << endl;
    }

    getImageBase(f1);

    f1.close();
    return 0;
}

void getImageBase(ifstream& istream)
{
    /*
    size_t size;
    istream.seekg(0, ios::end);
    size = istream.tellg();
    istream.seekg(0, ios::beg);
    */

    istream.seekg(180, ios::beg);

    vector < BYTE > bytes;
    bytes.resize(4);

    istream.read((char* )&bytes[ 0 ], 4);

    for(int i=0;i<bytes.size();i++)
    {
        cout << hex << bytes[i];
    }
}

EDIT: So sieht dein Programm ein wenig aufgeräumter aus:

#include <iostream>
#include <ios>
#include <fstream> 
#include <vector> 

bool GetImageBase(std::ifstream&); 

int main() 
{ 
    std::ifstream f1("test.exe", std::ios::in | std::ios::binary); 
    if(!f1.is_open()) 
        std::cerr << "Konnte Datei nicht oeffnen!"; 

    if(!GetImageBase(f1))
        std::cerr << "Fehler beim Auslesen!";
} 

bool getImageBase(std::ifstream& File) 
{ 
    std::vector<char> Bytes(4); 
    File.seekg(180, std::ios::beg);
    File.read(&Bytes[0], 4); 
    if(!File.good())
        return false;

    std::cout << std::hex;
    for(unsigned i = 0; i < Bytes.size(); i++) 
        std::cout << int(Bytes[i]); 

    return true;
}

Also es funktioniert nicht

cout << hex << setw(2) << fill('0') << static_cast<int>(bytes[i]);

(P.S. Dies wird auf Little-Endian-Systemen die Adresse 'verkehrt herum' ausgeben).

Edit:
Einfacher wäre jedoch, gleich die ImageBase als Zahl auszulesen, d.h.

int imagebase;
istream.read(reinterpret_cast<char*>(&imagebase), sizeof(int)); // Edit: Klammern hinzugefügt ;-)

cout << hex << imagebase;

Nun ist auch die Endianess kein Problem mehr.

Nein, der Fehler ist, daß 'char' als Zeichen ausgegeben werden, nicht als Zahlenwerte.

Oh, das habe ich übersehen. In meinem Code ist es nun gefixt.

Einfacher wäre jedoch, gleich die ImageBase als Zahl auszulesen, d.h.

int imagebase;
istream.read(reinterpret_cast<char*>&imagebase, sizeof(int));

cout << hex << imagebase;

Also das funktioniert nicht. Ich hab jetzt meine funktion so wie EOutOfResources es gemacht hat, jedoch weiß ich nicht wie ich den vector in eine einzele Variable kopieren soll. Ich hab schon es schon über stringstreams probiert, wobei das auch nicht funktioniert.

unsigned long int Foo = *reinterpret_cast<unsigned long int*>(&Bytes[0]);

Wenn es einen komischen Wert ergibt, entfernst du das " unsigned ".

#include <iostream>
#include <ios>
#include <fstream>
#include <vector>
#include <String>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include "PE_Header.h"

using namespace std;

int main()
{
    PE_Header Header("test.exe");

    Header.getEXE();

    Header.print();
}

PE_Header.cpp

#include "PE_Header.h"
#include <iostream>
#include <ios>
#include <fstream>
#include <vector>
#include <sstream>
#include <String>
#include <stdio.h>
#include <stdlib.h>

using namespace std;

PE_Header::PE_Header(const char* s)
{
    File.open("test.exe", ios::in | ios::binary);
    if(!File.is_open())
    {
        cerr << "Fehler beim oeffnen der Datei" << endl;
    }
    if(!getGlobal(180, 4))
        cerr << "Fehler beim Auslesen!";

    if(!getGlobal(168, 4))
        cerr << "Fehler beim Auslesen!";

    if(!getGlobal(172, 4))
        cerr << "Fehler beim Auslesen!";

    if(!getGlobal(176, 4))
        cerr << "Fehler beim Auslesen!";

    if(!getGlobal(224, 4))
        cerr << "Fehler beim Auslesen!";

    if(!getGlobal(228, 4))
        cerr << "Fehler beim Auslesen!";

    if(!getGlobal(256, 4))
        cerr << "Fehler beim Auslesen!";

    if(!getGlobal(150, 2))
        cerr << "Fehler beim Auslesen!";
}

PE_Header::~PE_Header()
{
    File.close();

}

void PE_Header::getEXE()
{
    size_t size;
    File.seekg(0, ios::end);
    size = File.tellg();
    File.seekg(0, ios::beg);

    datei.resize(size);

    File.read(&datei[0], size);
}

bool PE_Header::getGlobal(int position, int size)
{
    vector<char> Bytes(size);
    File.seekg(position, ios::beg);
    File.read(&Bytes[0], size);

    if(!File.good())
        return false;

    if(position == 180)
    {
        Info.ImageBase = *reinterpret_cast<long int*>(&Bytes[0]);
    }
    else if(position == 168)
    {
        Info.EntryPoint = *reinterpret_cast<long int*>(&Bytes[0]);
    }
    else if(position == 172)
    {
        Info.Base_of_Code = *reinterpret_cast<long int*>(&Bytes[0]);
    }
    else if(position == 176)
    {
        Info.Base_of_Data = *reinterpret_cast<long int*>(&Bytes[0]);
    }
    else if(position == 224)
    {
        Info.Size_of_Image = *reinterpret_cast<long int*>(&Bytes[0]);
    }
    else if(position == 228)
    {
        Info.Size_of_Headers = *reinterpret_cast<long int*>(&Bytes[0]);
    }
    else if(position == 256)
    {
        Info.LoaderFlags = *reinterpret_cast<long int*>(&Bytes[0]);
    }
    else if(position == 150)
    {
        Info.Sections = *reinterpret_cast<long int*>(&Bytes[0]);
    }
    return true;
}

void PE_Header::print()
{
    cout << "Entry Point:     " << hex << showbase << Info.EntryPoint << endl;
    cout << "ImageBase:       " << hex << showbase << Info.ImageBase << endl;
    cout << "Base of Code:    " << hex << showbase << Info.Base_of_Code << endl;
    cout << "Base of Data:    " << hex << showbase << Info.Base_of_Data << endl;
    cout << "Size of Image:   " << hex << showbase << Info.Size_of_Image << endl;
    cout << "Size of Headers: " << hex << showbase << Info.Size_of_Headers << endl;
    cout << "LoaderFlags:     " << hex << showbase << Info.LoaderFlags << endl;
    //cout.unsetf(ios::hex);
    cout << "Sections:        " << Info.Sections << endl;
}

PE_Header.h

#include <iostream>
#include <ios>
#include <fstream>
#include <vector>
#include <String>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>

#ifndef PE_HEADER_H
#define PE_HEADER_H

using namespace std;

class PE_Header
{
    public:
        PE_Header(const char* s);
        virtual ~PE_Header();
        bool getImageBase();
        bool getEntryPoint();
        bool getBase_of_Code();
        bool getBase_of_Data();
        bool getSize_of_Image();
        bool getSize_of_Headers();
        bool getLoaderFlags();
        bool getSections();
        bool getGlobal(int position, int size);
        void getEXE();
        void print();

    private:

        ifstream File;

        struct Header {
            long EntryPoint;
            long ImageBase;
            long Base_of_Code;
            long Base_of_Data;
            long Size_of_Image;
            long Size_of_Headers;
            long LoaderFlags;
            long Sections;
        }Info;

        vector<char>datei;
};

#endif // PE_HEADER_H

Hier ist dann das Ergebniss:
http://www.abload.de/image.php?img=test073h.jpg

Man sieht ja, dass das Programm ab "Size of Image" falsch ausliest, obwohl die Stellen die ich im Code angegeben hab z.B. 150 für die Sections auch richtig sind. Ich hab sie auch im Hex-Editor kontrolliert. Also die müssten stimmen.