wie kann ich binary code der im ram liegt ausführen

Hi !

Ich hab ein kleines Prog geschrieben, welches über das Netzwerk eine Binärdatei an einen Client sendet. Jetzt hab ich den BinärCode auf dem Client unter einem Pointer gespeichert. Kann ich den Code nun ohne Probleme irgendwie ausführen, indem ich z.B. einer Methode einfach den entsprechenden Speicherbereich, der den BinärCode enthält, übergebe ?

mfg
tom

SG1

TomatoTom schrieb:

Kann ich den Code nun ohne Probleme irgendwie ausführen, indem ich z.B. einer Methode einfach den entsprechenden Speicherbereich, der den BinärCode enthält, übergebe ?

Du koenntest die call-Anweisung benutzen, das ist aber Assembler

TriPhoenix

Könnte man das nicht vielelicht auch mit einem Funktionspointer regeln?

rüdiger

Könnte man das nicht vielelicht auch mit einem Funktionspointer regeln?

ja, so kann man das machen

zB.

const char code[]={ 
  0x55, // push %ebp
  0x89, 0xE5, // mov %esp,%ebp
  0xB8, 0x0F, 0x00, 0x00, 0x00, // mov $0xF,%eax
  0xC9, //leave
  0xC3  //ret
};

typedef int (*func_t)(void);

int main() {
  func_t f=(func_t)code;
  return f();
}

der Code sollte 0xF (also dezimal 15) ausgeben

> gcc -Wall -W demo.c
> ./a.out
> echo $?
15

wola.

Wichtig ist aber, dass du dich an die gewünschte Funktionsform des Compilers einhält

Hi !

Danke fuer die Antwort. Problem ist, dass der Code nur C Code sein darf. Ist ein Pointer auf eine Funktion nicht erst in C++ def ?

Leider kann ich damit auch nicht soviel anfangen. Was soll das Code Array und welcht Art von Notation ist zB 0x55 (hex?) also insbesondere "0x".

const char code[]={ 
  0x55, // push %ebp
  0x89, 0xE5, // mov %esp,%ebp
  0xB8, 0x0F, 0x00, 0x00, 0x00, // mov $0xF,%eax
  0xC9, //leave
  0xC3  //ret
};

Waer sehr nett, wenn Du mir das ein bisschen genauer erklaeren koenntest.

mfg
tom

DrGreenthumb

Ist eine Funktion nicht etwas anders aufgebaut als ein komplettes Programm??

Ich hab ein kleines Prog geschrieben, welches über das Netzwerk eine Binärdatei an einen Client sendet.

Ich finde, da wäre es ohnehin angebracht die Datei gleich auf die Platte zu schreiben.

rüdiger

Funktionspointer gibt es auch schon in C. 0x bedeutet, dass es sich bei dem Wert um ein Hex-Wert handelt. Die angegebenen Werte sind die Opcodes (also die CPU-Befehle, in den Kommentaren steht der entsprechende Assembler Quellcode).

Aber wenn du ein komplettes Programm verschickst, ist es am besten, wenn du das wie DrGreenthumb auf die Platte schreibst und mit execve(2) ausführst.

Hi !

Vielen Dank für die Antwort. Ich hab allerdings ein neues merkwürdiges Problem. Ich möchte gerne mit malloc Speicher allokaieren. In den Speicher wird dann das Programm im Binärformat abgelegt.

int sizeOfData;

      recv(serverID, &sizeOfData, sizeof(int), 0); // infos vom Server über die Grösse des BinFiles in Bytes

      printf("Client: sizeOfData: %d\n", sizeOfData);

char* binData;
      if( ( binData = malloc(sizeOfData)) < 0 ) // Speicher der Grösse 6660 Bytes sollte nun allokaiert sein
	printf("Client: Error allocating memory.\n");

      printf("client: binData erhalten. Size: %d\n",sizeof(binData) ); // hier erhalte ich die Ausgabe 4 Bytes ??

      recv(serverID, binData, sizeOfData, 0);

Leider wird ein falsche Grösse an Speicher allokaiert, nämlich nur 4 statt 6660 Bytes.
Kann mir jemand erklären, was hier schief geht ?

mfg
tom

rüdiger

sizeof kannst du hier nicht verwenden, da es dir die größe von char* liefert und nicht von der Menge des allokierten Speichers. Da musst du dich schon auf malloc verlassen, was NULL liefert, wenn es nicht genug Speicher allokieren kann.

btw. solltest du lieber size_t für größen Angaben benutzen!

Hi !

Hab den Code mal mit size_t modifiziert. Allerdings bringt das keine Änderung.

size_t sizeOfData;

      recv(serverID, &sizeOfData, sizeof(size_t), 0); // infos vom Server über die Grösse des BinFiles in Bytes
      printf("Client: sizeOfData: %d\n", sizeOfData);

      char* binData;
      if( ( binData = malloc(sizeOfData)) == NULL ) // Speicher der Grösse 6660 Bytes sollte nun allokaiert sein
	printf("Client: Error allocating memory.\n");
      recv(serverID, binData, sizeOfData, 0);

Trotzdem erhalte ich den selben Fehler wieder. Die Datei wird angelegt aber ist nur 4 Byte groß !?

mfg
tom

rüdiger

sizeof liefert den Wert des Typs. Bei char* liefert sizeof den Wert, wie groß char* ist und nicht wie groß der Speicherbereich ist auf den char* Zeigt! Zeiger sind eigene Typen! char[100] ist was anderes, da ist der Typ eben 100*sizeof(char) (also 100).

Mit sizeof kannst du nicht messen, wie viel Speicher malloc allokiert hat. malloc meldet sich schon, wenn nicht genug Speicher allokiert wurde!

Hi !

Das mit dem sizeof hab ich schon verstanden. Ich hatte nur folgende Zeile übersehen:

write(fh, binData, sizeof(sizeOfData))

:p

Naja, wie dem auch sei. Wenn ich es nun ausführe wird die Datei korrekt angelegt. Allderings kann ich diese seltsamerweise nicht ausführen, obwohl ich sie mit den Rechten 777 angelegt habe.

Folgende Ausgabe erhalte ich:

[tom@Fedora 3prog3]$ make
gcc -o fileViewer -lnsl -lncurses fileViewer.c
fileViewer.c: In function `saveData':
fileViewer.c:61: Warnung: assignment makes pointer from integer without a cast
gcc -o fileReader fileReader.c

Der Code hierzu sieht wie folgt aus:

int saveData(int serverID, char* fileName) {
  size_t sizeOfData;

  recv(serverID, &sizeOfData, sizeof(size_t), 0); 

  void* binData;
  if( ( binData = malloc(sizeOfData)) == NULL ) { //Zeile 61
    printf("Client: Error allocating memory.\n");
    return -1;
  }

  recv(serverID, binData, sizeOfData, 0);

  int fh = creat(fileName, 0777);

  if ( write(fh, binData, sizeOfData) < 0)
    printf("Client: Error writing data into the file.\n");

  realloc(binData, 0); 
  close(fh);
}

Analog habe ich das im Server gemacht:

int sendData(char* fileName, int clientID ) { //clientID ist  socket handler

  int fh = open( fileName , O_RDONLY);
  size_t sizeOfFile = lseek(fh, 0, SEEK_END);
  printf("Server: Filesize in bytes = %d\n", sizeOfFile);

  void* data;
  if ( (data = malloc(sizeOfFile)) == NULL) 
    printf("Server: Error allocating memory for data.\n");

  else {

    if( read(fh , data, sizeOfFile) < 0) 
      printf("Server: Error reading data from file: %s", fileName);

    if( send(clientID, &sizeOfFile, sizeof(int), 0) < 0)
      printf("Server: Error sending information about the size of data: %s", fileName);

    if( send(clientID, data, sizeOfFile, 0) < 0)
      printf("Server: Error sending data: %s.\n", fileName);

  }
  realloc(data, 0);
  close(fh);
  printf("Server: sendData() finished\n");
} //end method sendData

Komisch wenn die das kompiliere meckert er nicht.

mfg
tom

Hi !

Ist die Frage jetzt zu billig ? Tut mir Leid habe aber leider keine Idee was hier los sein könnte.
Für mich sieht das sehr merkwürdig aus: zweimal den selben Code benutzt und bei der einen Version meckert der Compiler bei der anderen nicht und das Prog ist nicht ausführbar !!!???

mfg
tom