Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
3868 connectés 

  FORUM HardWare.fr
  Programmation

  a l'aide svp , je galere en C sur un projet de steganographie

 
 


Dernière réponse
Sujet : a l'aide svp , je galere en C sur un projet de steganographie
Fork Ca ne marche pas car tu as loupé un point important du cours de C !
L'ADRESSE D'UN TABLEAU, C'EST LE NOM DU TABLEAU TOUT COURT !!
 
Il faut donc que tu remplaces :
 
* scanf("%s",&nomfic);  
* fread(©buf,sizeof(char),1,image_crypt);  
* fwrite(©buf,sizeof(char),1, image_encrypt);  
* etc...
 
par :
 
* scanf("%s",nomfic);  
* fread(copybuf,sizeof(char),1,image_crypt);  
* fwrite(copybuf,sizeof(char),1, image_encrypt);  
* etc...
 
 
Par contre, pour les variables de type int et char, il faut effectivement mettre le '&'.

Votre réponse
Nom d'utilisateur    Pour poster, vous devez être inscrit sur ce forum .... si ce n'est pas le cas, cliquez ici !
Le ton de votre message                        
                       
Votre réponse
[b][i][u][strike][spoiler][fixed][cpp][url][email][img][*]   
 
   [quote]
 
Options

 
Vous avez perdu votre mot de passe ?


Vue Rapide de la discussion
Fork Ca ne marche pas car tu as loupé un point important du cours de C !
L'ADRESSE D'UN TABLEAU, C'EST LE NOM DU TABLEAU TOUT COURT !!
 
Il faut donc que tu remplaces :
 
* scanf("%s",&nomfic);  
* fread(©buf,sizeof(char),1,image_crypt);  
* fwrite(©buf,sizeof(char),1, image_encrypt);  
* etc...
 
par :
 
* scanf("%s",nomfic);  
* fread(copybuf,sizeof(char),1,image_crypt);  
* fwrite(copybuf,sizeof(char),1, image_encrypt);  
* etc...
 
 
Par contre, pour les variables de type int et char, il faut effectivement mettre le '&'.
psebcopathe /*************************************************
*****************************************/
/**********sous programme qui permet de steganografier un texte dans une image*************/
/*************************************************
*****************************************/
 
void encrypt()
{
#define masque_encrypt 0xFE
#define CHARMAX 101
 
 char copybuf[80];
 char nomfic[51];
 unsigned char pixel[4], c;
 unsigned char pixel_code[32];
 int i=0,j=0,k=0;
 char ligne[CHARMAX]="";              /*message saisi par l'utilisateur*/
 int rang=0;        
 int vide=0;
 
 
 FILE *image_crypt; /*ouverture en lecture de l'image initiale*/
    FILE * Temp; /*fichier temporaire ou est stocke le message*/
    FILE *image_encrypt = fopen("out.bmp", "w" );/*ouverture en écriture de l'image finale (avec le message)*/  
   
   
 
 
 printf("indiquez le chemin ou se trouve l'image support de steganographie :" );
 scanf("%s",&nomfic);
    image_crypt=fopen(nomfic, "r" );
 Temp=fopen("message.txt","w" );
 printf(" VEUILLEZ TAPER LE MESSAGE A CODER :" );
 scanf("%d",&vide);      /*vidage à la barbare du buffer */
 gets(ligne);       /*chargement du message dans une string*/  
 fputs(ligne,Temp);      /*copie de la string dans un fichier temp*/
 fclose(Temp);
 printf("\n" );
 
 // sauvegarde de l'entête de l'image:  
 while (j<80)
 {
  fread(©buf,sizeof(char),1,image_crypt);
  fwrite(©buf,sizeof(char),1, image_encrypt);
  j++;
 }
 printf("\n" );
 
 
 // encrypte texte dans image  
    fseek(image_crypt,sizeof(char)*80,0);
 Temp=fopen("message.txt", "r" ); /*ouverture du fichier en lecture pour traitement*/
 while (fread(&c, sizeof(char), 1, Temp))
 {
  for (i = 0; i < 8; i++)
  {
   fread(&pixel,sizeof(char), 4, image_crypt);
   for (j=0; j<3 ; j++)
   {
     pixel_code[j] = pixel[j];
   }
   pixel_code[3] = ((pixel[3])&masque_encrypt) | ((c>>i)&0x01);//remplace le bit de faible poids de pixel par le bit de c
  }
   
  fwrite(&pixel_code, 1, 32, image_encrypt);
 }
 
     //copie fin image
    printf ("copie fin...\n" );
 fseek(image_crypt,sizeof(char)*3200,0);
    while (!feof(image_crypt))
    {
  fread(©buf,sizeof(char),1,image_crypt);
    fwrite(©buf,sizeof(char),1,image_encrypt);
 }
    printf ("done\n" );
 
    // FERMETURE DES FICHIERS  
    fclose (image_crypt);
    fclose (Temp);
    fclose (image_encrypt);
 getch();
 menu();
 
}
 
a l'aide gilou ou qqun d'autre , pkoi ca marche pas ??
 :heink:  :??:  :cry:
psebcopathe up!
psebcopathe heu desole , g encore un pb , j'encrypte bien l'image avec mon texte , mais a parement , pas selon la bonne convention , ca j'arrive pas à la decrypter , si qqun pouvait me dire ou est l'erreur , ca serait cool :)
 
/**********************************************
********************************************/
/**********sous programme qui permet de steganografier un texte dans une image*************/
/*************************************************
*****************************************/
 
void encrypt()
{
#define masque_encrypt 0xFE
#define CHARMAX 101
 char  copybuf[80];
 char nomfic[51];
 char pixel[32], c;
 int i=0,j=0,k=0;
 char ligne[CHARMAX]="";              /*message saisi par l'utilisateur*/
 int rang=0;        
 int vide=0;
 
 
 FILE *image_crypt; /*ouverture en lecture de l'image initiale*/
    FILE * TEMP; /*fichier temporaire ou est stocke le message*/
    FILE *image_encrypt = fopen("out.bmp", "w" );/*ouverture en écriture de l'image finale (avec le message)*/  
   
   
 
 
 printf("indiquez le chemin ou se trouve l'image support de steganographie :" );
 scanf("%s",&nomfic);
    image_crypt=fopen(nomfic, "r" );
 
 
 
 
 TEMP=fopen("message.txt","w" );
 printf(" VEUILLEZ TAPER LE MESSAGE A CODER :" );
 
 scanf("%d",&vide);      /*vidage à la barbare du buffer */
 gets(ligne);       /*chargement du message dans une string*/  
 fputs(ligne,TEMP);      /*copie de la string dans un fichier temp*/
 fclose(TEMP);
 
 
 printf("\n" );
 
 // sauvegarde de l'entête de l'image:  
 
 while (j<80)
 {
 fread(©buf,sizeof(char),1,image_crypt);
 
 fwrite(©buf,sizeof(char),1, image_encrypt);
 j++;
 }
 printf("\n" );
 
 
 // encrypte texte dans image  
     
 
 TEMP=fopen("message.txt", "r" ); /*ouverture du fichier en lecture pour traitement*/
 while (fread(&c, sizeof(char), 1, TEMP))
 {
   
  fread(&pixel,sizeof(char), 8, image_crypt);
  for (k=0; k<32; k=k+4)
  {
 
   for (i = 0; i < 8; i++)
   {
 
   pixel[i] = ((pixel[i])&masque_encrypt) | ((c>>i)&1);//remplace le bit de faible poids de pixel par le bit de c
   }
  }
  fwrite(&pixel, 1, 8, image_encrypt);
 }
 
     //copie fin image
     
 printf ("copie fin...\n" );
    while (!feof(image_crypt))
    {
 
    fread(©buf,sizeof(char),1,image_crypt);
   
 fwrite(©buf,sizeof(char),1,image_encrypt);
 
    }
 
 
    printf ("done\n" );
 
    // clean up, such as it is
    fclose (image_crypt);
    fclose (TEMP);
    fclose (image_encrypt);
 
     
}
 
/*************************************************
*****************************************/
/****sous programme qui permet de decrypter le texte à partir d'une image steganografiée***/
/*************************************************
*****************************************/
 
void decrypt()
{
 
#define masque_decrypt 0x01 /* 1 en hexadécimal*/
 
 char octets[32];  /* 8*4 = 32 octets pour coder une lettre */
 char lettre;
 int i, j, cpt; /* compteurs utilisés pour manipuler les bits*/
 FILE *f_encrypt = fopen("out.bmp", "r" ); /* a adapter */
 fseek(f_encrypt,sizeof(char)*80,0) ;/* on zappe l'en tête*/
 cpt = 0; /* compte les lettres lues */
 printf("message decode : \n" );
 
 while (fread(&octets, 1,32,f_encrypt) && (cpt< 100))
 {
  lettre = '\0';
  for (i = 0; i < 8; i++)
  {
   j=4*i+3; /* Cf la ligne suivante, pour bytes[31-j] */
   lettre = ((octets[31-j])&masque_decrypt) | (lettre<<1);
   /* les octets de poids fort sont a la fin, et doivent etre lus en premier */
 
  }
  printf("%c", lettre);
  cpt++;
 }
printf("\n" );
printf("lettres lues " );
printf("%d\n",cpt);
fclose(f_encrypt);
 
}
gilou Au fait, tu peux probablement remplacer:

Code :
  1. for (i = 0; i < 8; i++)
  2. {
  3.   j=4*i+3; 
  4.   letter = ((bytes[31-j])&masque) | (letter<<1);
  5.   /* les octets de poids fort sont a la fin, et doivent etre lus en premier */
  6. }


par:

Code :
  1. for (i = 0; i < 8; i++)
  2. {
  3.   if ((bytes[4*i])& 0x01)
  4.         letter |= 0x80; /* On met 1 dans le bit de poids fort */
  5.   letter>>1;            /* on decale vers le bas */     
  6. }


A+,

 

[edtdd]--Message édité par gilou--[/edtdd]
gilou Si tu veux une bonne note a ton exo (ainsi qu'un bon entrainement au programmes c sous unix/linux), tu peux:
 
* changer main() en int main() et retourner un code d'erreur si il y a erreur.  
* recuperer un parametre -i nom_de_fichier en entree
* recuperer un parametre -o nom_de_fichier en sortie et le cas echeant, ecrire le texte dans ce fichier en sortie.
* recuperer un parametre -s step et modifier l'algo afin que l'on cherche tout les step octets (ici, step=4)
* recuperer un parametre -h head et modifier l'algo afin que l'on saute les head premiers octets (ici head=80)
* recuperer un parametre -n num et ne decripter que les n premiers caracteres (ici, n=100).
* recuperer un parametre -? et afficher le manuel (resume) d'utilisation. Afficher aussi ce manuel si la ligne de commande est erronnee.
* par defaut, supposer que le fichier en entree est sur stdin (et verifier cela avec la signature du fichier, qui doit demarrer par "BM" ).
* Tester si fopen echoue (ainsi que les autres operations de lecture et positionnement dans le fichier. Ecrire sur stderr un message d'erreur approprié.
 
A+,
psebcopathe j'y suis aussi arrive avec l'algo precedent comme ceci :#include <stdio.h>
#define masque 0x01 /* 1 en hexadécimal*/
main()
{
 
 char bytes[32];  /* 8*4 = 32 octets pour coder une lettre */
 char letter;
 int i, j, count; /* compteurs utilisés pour manipuler les bits*/
 FILE *in = fopen("point.bmp", "r" );  
 fseek(in,sizeof(char)*80,0) ;/* on zappe l'en tête*/
 count = 0; /* compte les lettres lues */
 printf("message decode : \n" );
 
 while (fread(&bytes, 1,32,in) && (count< 100))
 {
  letter = '\0';
  for (i = 0; i < 8; i++)
  {
   j=4*i+3;  
   letter = ((bytes[31-j])&masque) | (letter<<1);
   /* les octets de poids fort sont a la fin, et doivent etre lus en premier */
  }
  printf("%c", letter);
  count++;
 }
printf("\n" );
printf("lettres lues " );
printf("%d\n",count);
fclose(in);
 
}
 
uin tres grand merci
chrisbk bon ben c pas le tout, mais qqun sait comment faire de la steganographie resistant a un algo de compression, comme le jpg ?
gilou Ah OK, je comprends, elle demarre pas au debut du bitmap, OK!
Sachant ca, il est facile de decoder l'image pour trouver le texte suivant:
LE SUJET DU PARTIEL SE TROUVE DANS LE CHATEAU DE ARGHHHHH !
(suffit de remplacer la ligne

Code :
  1. fread(bytes, 1,2,in); /* a adapter. Ca c'est d' apres l' aspect du binaire de l' image qui avait l' air d'etre modifiee de 4 en 4 en demarrant par le 3e octet */


par:

Code :
  1. fread(bytes, 1,26,in); /* 54 + 26 = 80, offset de debut du texte */

 
dans mon post precedent).
 
A+,

 

[edtdd]--Message édité par gilou--[/edtdd]
psebcopathe yes , quel boss!
le pb , du decryptage , c que la convention est :
1- entete = 80octets pour avoir de la marge  
2- l'image en true color (24 bits) : le bit de faible poids tous les 4 octets est remplace par le code binaire du caractere .  
 
 
, un tres tres grand merci , g tout compris now, je devrais pouvoir m'en sortir :jap:
:pouceup:
gilou Pour ton probleme, j' ai essaye un truc comme ca:

Code :
  1. #include <stdio.h>
  3. int main()
  4. {
  5. char buffer[54]; /* Un header de bmp  fait 54 octets */
  6. char bytes[32];  /* 8*4 = 32 octets pour coder une lettre */
  7. char letter;
  8. int i, j, count;
  9. FILE *in = fopen("I:\\image.bmp", "r" ); /* a adapter */
  10. fread(buffer,1,54,in); /* On lit l' en tete*/
  11. count = 0; /* compte les lettres lues */
  12. fread(bytes, 1,2,in); /* a adapter. Ca c'est d' apres l' aspect du binaire de l' image qui avait l' air d'etre modifiee de 4 en 4 en demarrant par le 3e octet */
  13. while (fread(bytes, 1,32,in) && (count< 100))
  14. {
  15.   letter = '\0';
  16.   for (i = 0; i < 8; i++)
  17. {
  18.   j=4*i+3; /* Cf la ligne suivante, pour bytes[31-j] */
  19.   letter = ((bytes[31-j])&0x01) | (letter<<1);
  20.           /* les octets de poids fort sont a la fin, et doivent etre lus en premier */
  21. }
  22.   fprintf(stdout, "letter: %c", letter);
  23.   count++;
  24. }
  25. fclose(in);
  26. return 0;
  27. }


Il a pas l'air de decoder ton image, mais peut etre les infos que tu as donnees sont insuffisantes(ou mon programme estil bugge). Le principe general devrait etre bon. A toi d' adapter a tes donnees.
A+,

 

[edtdd]--Message édité par gilou--[/edtdd]
gilou C' est mon clavier qui deconne entre les majuscules et les minuscules.
A+,
Tetedeiench

gilou a écrit a écrit :

le pb du lien, c'etait la virgule collee a l'url.
A=,  



OUAIIIIIIIIIIIIIIIIIIIII
 
Y SAI ENFIN PLANTAI , Y SAI ENFIN PLANTAI !
 
:lol:  
 
:hello: gilou :D

 

[edtdd]--Message édité par Tetedeiench--[/edtdd]
Tetedeiench

rufo a écrit a écrit :

moi, je suis étonné que cette portion de code marche :
/*texte à crypter*/  
printf("entrez le texte a steganografier :\n" );
scanf("%d",&texte);
 
ta var texte est un tableau....tu mets pas d'indice?
 
et remarque: y'a plusieurs entêtes de bmp :)  




 
euh, comme chacun le sais, un tableau en C est un bete pointeur ...
 
DOnc forcément oui ca amrche :D
 
Enfin sans le & ...

gilou le pb du lien, c'etait la virgule collee a l'url.
A+,

 

[edtdd]--Message édité par gilou--[/edtdd]
psebcopathe enfait , vu que je suis chez un hebergeur un peu special :/ , on est obligé de se connecter à http://www.chez.com/sebien/ , puis de taper ensuite "image.bmp" et on peut la telecharger , desole .
merci bcp à toi aussi . , le programme d'encryptrage marche , reste celui qui permet de decrypter ....
pour l'entete de l'image , je considere qu'il est de 80 octets , comme ca g de la marge :) .

 

[edtdd]--Message édité par gilou--[/edtdd]
HelloWorld ton lien marche pas :(
Forbidden
You don't have permission to access the requested URL on this server.
 
Sinon c cool je viens de decouvrir c koi la s-t-e-g-a-n-o-g-r-a-p-h-i-e (:sweat:) et comment ca fonctionne
 
histoire de contribuer :

Code :
  1. fscanf(fp1, "%1024s", copybuf);


c'est pour sauter l'entete du bitmap (si mes souvenirs sont bons)
car au debut y'a pas les couleurs, mais des indications sur la tailles, le nombre de couleurs ... tu peux trouver tres facilement de la doc dessus si tu veux faire un truc propre (car il peux y avoir une palette en suivant si <= 256 couleurs je crois et dans ce cas ca ferait desordre sur l'image finale

psebcopathe franchement je suis bluffé , je vous remerci tous bcp  
sinon , notre prof à crypter une image , on doit la decrypter , c une image 24bits (true collor) elle a modifie le bit de faible poids tous les 4 octets , normalement le texte fait 100 caractere.  
pour le moment g fait ca :  
#include <stdio.h>  
#include "librairie.h"  
 
void decrypt()  
{  
 
int enteteimage[40]; /* correspond à l'entête de l'image de 80octets */  
int curseur;  
long img_texte; /*correspond à la partie d'image encryptée */  
long masque=1;/*filtre permettant de décrypter l'image */  
long step_one[8];  
int i=0;  
char lettre;  
char mot[100];  
FILE *entree = fopen("image.bmp", "rb" );  
 
 
 
 
/*entete*/  
for (curseur =0 ; curseur< 40 ; curseur++ )  
{  
fread(&enteteimage,sizeof(int),2,entree);  
}  
for (curseur =40 ; curseur< 1640 ; curseur=curseur+16 )  
{  
while (i<8)  
{  
fread(&img_texte,sizeof(long),1,entree);  
step_one[i]=img_texte&masque;  
step_one[i]<<31-i);  
i++;  
lettre=step_one[0]+step_one[1]+step_one[2]+step_one[3]+step_one[4]+step_one[5]+step_one[6]+step_one[7];  
printf("%c",lettre);  
}  
/* mot[]=*/  
}  
 
 
 
 
fclose (entree);  
 
 
}  
 
si vous voulez essayer , l'image est sur www.chez.comsebienimage.bmp
gilou Au fait, l'essentiel de l'algo tient en ceci:
 

Citation :

while (fread(&buf, 1, 1, fp2))
{
    int i;
    for (i = 0; i < 8; i++)
    {
      char b = fgetc(fp1);
      char s = (b&0xFE) | ((buf>>i)&1);
      fwrite(&s, 1, 1, fout);
    }
}


Decomposons:

Citation :

while (fread(&buf, 1, 1, fp2))  {...}

Il boucle en lecture sur fp2, le fichier qui contient le texte a coder, et traite un caractere a la fois.

Citation :

(a&0xFE) | (b&1)

(b&0xFE): on met a 0 le bit de poids faible de a
(b&1): on recupere le bit de poids faible de b
D'ou (a&0xFE) | (b&1) : on met le bit de poids faible de b a la place de celui de a.
 

Citation :

for (i = 0; i < 8; i++) { a>>i; }


Il decale un a un les bits du caractere a.
 
Avec tout ca l'algo est vraiment evident:
On prend un caractere a coder c dans le fichier.  
Pour le coder, on fait:
On prend un pixel de l'image pix (l'algo suppose qu'elle est codee sur un caractere, sinon, il faut adapter)
on prend le bit de poids faible de c, on le met dans le bit de poids faible de pix, on decale les bits de c de un pour traiter le second bit au prochain tour, il est range en bit de poids faible.
On ecrit le pixel modifie, et on recommence 7 fois pour les autres bits de c.
C'est pas tres complique comme algo.
 
Il serait un poil plus efficace ecrit ainsi d'ailleurs, en bossant sur 8 pixels a la fois:
 

Citation :

char pixel[8], c;
int i;
while (fread(&c, 1, 1, fp2))
{
   fread(&pixel, 1, 8, fp1);
   for (i = 0; i < 8; i++)
       pixel[i] = ((pixel[i])&0xFE) | ((c>>i)&1);
   fwrite(&pixel, 1, 8, fout);
}


(Et si tu sais que ton texte est en ascii pur, tu peux bosser sur 7 pixels a la fois, plutot que 8...).
Il faut aussi prevoir un test pour voir si l'image est assez grande pour coder le texte: verifier que le nb de pixels de l'image est superieur a 8 fois la longueur du texte a coder avant de demarrer le codage, ou alors tronquer le texte a coder en fonction de la taille de l'image.
A+,

 

[edtdd]--Message édité par gilou--[/edtdd]
gilou Bon notons certains des pb:
 

Citation :

main()


 
int main() ca te permettra de retourner des codes d'erreurs eventuellement, en sortie.
 
 

Citation :

FILE *entree = fopen("image.bmp", "r" );
FILE *sortie = fopen("sortie.bmp", "w" );


 
FILE *entree = fopen("image.bmp", "rb" );
FILE *sortie = fopen("sortie.bmp", "wb" );
/* Ca change rien mais ca fait pas de mal pour relire */
 
Bon un petit test pour verifier que les operations ont reeussi ca serait pas mal...
 
if (!entree || !sortie)
  {
   /* Ecrire un zoli msg d'erreur */
   exit (0);
   }
 

Citation :

struct pixel  
{  
 long pfort :31;  
 unsigned pfaible:1;  
};  
typedef struct pixel s_pixel;


Bof, je ferais:
typedef struct pixel{  
 long pfort :31;  
 unsigned pfaible:1;  
}pixel;  
 
De toute facon, je vois pas a quoi ca va te servir puisque un masque sera bien plus efficace.
 

Citation :

while (copybuf<40)  
{  
fread(©buf,sizeof(int),1,entree);  
   
fwrite(©buf,sizeof(int),1, sortie);  
}


 
{
  char copybuf[40];
  fread(©buf,sizeof(int),40,entree);  
  fwrite(©buf,sizeof(int),40, sortie);  
}
 

Citation :

printf("entrez le texte a steganografier :\n" );  
scanf("%d",&texte);


 
scanf("%s",&texte);  
Ben oui, car c'est pas un nombre que tu lis en entree.
De plus, scanf s'arretera au premier blanc, ce qui n'est sans doute pas suffisant pour le texte a crypter qui a priori est sans doute compose de plusieurs mots.
 
 
etc.
A+,

 

[edtdd]--Message édité par gilou--[/edtdd]
rufo moi, je suis étonné que cette portion de code marche :
/*texte à crypter*/  
printf("entrez le texte a steganografier :\n" );
scanf("%d",&texte);
 
ta var texte est un tableau....tu mets pas d'indice?
 
et remarque: y'a plusieurs entêtes de bmp :)
gilou Tu essayes le code sur quel format d'image?
Parce qu'il faut tenir compte de l'en-tete...
A+,

 

[edtdd]--Message édité par gilou--[/edtdd]
psebcopathe voila , je dois faire un prog qui encode et decode du texte ds une image , en modifiant le bit de faible poids tous les 4 octets , et je m'embrouille tout seul !
ce que g fait , cad  presque rien :
 
#include <stdio.h>
 
main()
{
    int texte[100];
 int i;
 FILE *entree = fopen("image.bmp", "r" );
    FILE *sortie = fopen("sortie.bmp", "w" );
   long copybuf[25600];
 struct pixel
 {
  long pfort :31;
  unsigned pfaible:1;
 };
 typedef struct pixel s_pixel;
 
   
 /*entete*/
 while (copybuf<40)
 {
 fread(©buf,sizeof(int),1,entree);
   
 fwrite(©buf,sizeof(int),1, sortie);
 }
/*texte à crypter*/  
 printf("entrez le texte a steganografier :\n" );
 scanf("%d",&texte);
 
/*cryptage
 while(fread(©buf,sizeof(int),3200,entree))
 {
  for  
 }
 
 
 
    */
 
 
et voila une source que g trouve, qui est sencée marche mais c pas le cas chez moi :/
 
/* ensteg.c
** do steganography stuff
** note that this assumes a binary-type pnm (P4,P5,P6) without a comment field
**
** usage:
**   steg image.pnm file.dat output.pnm
** enstegs the file in file.dat into image.pnm to form output.pnm.  Assumes
** that the destegged file can have trailing garbage without a problem
** (.tar.gz is fine).
*/
 
#include <stdio.h>
 
int main(int argc, char *argv[])
{
    FILE *fp1 = fopen(argv[1], "r" );
    FILE *fp2 = fopen(argv[2], "r" );
    FILE *fout = fopen(argv[3], "w" );
    int w, h, max;
    char buf, copybuf[1024];
 
    fscanf(fp1, "%1024s", copybuf);
    fscanf(fp1, "%d%d%d\n", &w, &h, &max);
    fprintf(fout, "%s\n%d %d\n%d\n", copybuf, w, h, max);
 
    // ensteg the data
    printf ("enstegging...\n" );
    while (fread(&buf, 1, 1, fp2))
    {
 int i;
 
 for (i = 0; i < 8; i++)
 {
     char b = fgetc(fp1);
     char s = (b&0xFE) | ((buf>>i)&1);
     fwrite(&s, 1, 1, fout);
 }
    }
 
    // copy the remainder of the file (random-pad everything though)
    printf ("copying rest/adding garbage...\n" );
    while ((max = fread(copybuf, 1, 1024, fp1)))
    {
 int i;
 
 for (i = 0; i < 1024; i++)
     copybuf[i] &= (0xFE | (rand()>>3));
 fwrite(copybuf, 1, max, fout);
    }
 
    printf ("done\n" );
 
    // clean up, such as it is
    fclose (fp1);
    fclose (fp2);
    fclose (fout);
 
    return 0;
}
merci a tous .
    fclose (entree);
    fclose (sortie);
     
 
}

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo

Copyright © 1997-2025 Groupe LDLC (Signaler un contenu illicite / Données personnelles)