// start with some value

uint numBytes = 10;



// declare a field with my uint value

byte[] myData = new byte[numBytes];



// allocate memory

myData = malloc(numBytes * sizeof(byte));



// do decrypt stuff

[..]

File f = new File("win32exec.exe");



// wrap a stream for reading the data

ByteArrayInputStream bis = new ByteArrayInputStream(f);



// let the stream read all data

while(bis.read() !=0)) {

}



byte[] myWin32Exec = bis.toByteArray();



// offset of the uint

int offSetNumSize = ??????;



// offset of the array

int offSetDataArray = ??????;



String randomString = "encrypted_data";



byte[] encryptedData = randomString.getBytes();



// assign new field length to offset of uint

myWin32Exec[offSetNumSize] = encryptedData.length;



// assign new data to array



for(int i=0;  i < encryptedData.length; i++) {

myWin32Exec[offsetDataArray + i] = encryptedData[I];

}



// done save the file

[..]

static byte mydata[1]

// after compile this file will be 1000 bits (guess)

static int myWin32OriginalFileSize = 1000;

main {

 // open in read mode - win32proc.exe is THIS program currently

FILE *fp = fopen ("win32proc.exe", "rb";



// seek to the original exec end

fseek (fp, myWin32OriginalFileSize, SEEK_SET);





int len;

char buffer[1024];

// the data i appended at the end of the file will be written to mydata.bin

FILE *patchedData = fopen("mydata.bin","w";



// read everything from original end of exe till the new end of the exec

while((len = fread(buffer,1,sizeof(buffer),fp)) > 0)

{

   // write to temp file mydata.bin for further processing

   fwrite(buffer,1,len,patchedData);

}



// done i now have my data original data in a file called mydata.bin



}

#include <io.h>

#include <stdio.h>

#include <malloc.h>





static long execOriginalFileSize = 32768;

static char *execFileName = "Win32Wrapper.exe";



int main () {

  FILE * pFile;

  long execModifiedFileSize;

  char * buffer;

  long appendedDataSize;

  size_t bytesRead;



  pFile = fopen ( execFileName , "rb" );



  if (pFile==NULL) {

	  printf("Could not open %s!\n",execFileName);

	  return -1;

  }



  // obtain file size.

  fseek (pFile , 0 , SEEK_END);

  execModifiedFileSize = ftell (pFile);  

  rewind (pFile);



  // seek to original size

  fseek (pFile, execOriginalFileSize, SEEK_SET);



  appendedDataSize = (execModifiedFileSize - execOriginalFileSize);



  printf("Original File Size : %i\n",execOriginalFileSize);

  printf("Modified File Size : %i\n",execModifiedFileSize);

  printf("Appended Data Size : %i\n",appendedDataSize);



  // allocate memory to contain the whole appended data

  buffer = (char*) malloc (appendedDataSize);



  if (buffer == NULL) {

	  printf("Could not allocate any buffer for fread!";

	  return -1;

  }



  // copy the file into the buffer.

  bytesRead = fread (buffer,1,appendedDataSize,pFile);



  /*** the whole file is loaded in the buffer. ***/



  printf("Read %i bytes, expected %i bytes!\n",bytesRead, appendedDataSize);



  // santiy check here

  if((long)bytesRead == appendedDataSize) {

	  ;

  } else {

	  printf("Result differs, exiting!";

	  return -1;

  }



  printf("Read Data : %s",buffer);



  // terminate

  fclose (pFile);

  free (buffer);

  return 0;

}

ExtendedRegisters: array [0..511] of Byte;