CRYPTAGE !!!

Signaler
Messages postés
7
Date d'inscription
mercredi 10 mars 2004
Statut
Membre
Dernière intervention
7 novembre 2006
-
Messages postés
202
Date d'inscription
jeudi 24 juin 2004
Statut
Membre
Dernière intervention
22 janvier 2009
-
Voilà j'essai de faire un log de cryptage à l'aide de fonctions et procédure.

Les fonctions et procédures :

Une fonction qui retourne le nom de fichier
une qui retourne le nombre de char
une qui compte les char
une pour cryptage et une pour décryptage

Biensur pour chacun on ouvre le fichier texte en insérant le nom.
Et j'ai une merde dans mon code pourriez vous m'aider c'est urgent SVP !!!!

#include <stdio.h>
#include 
#include <stdlib.h>
#include <string>
using namespace std;

/*********** RETOUR DU NOM DU FICHIER ********************/

char retournom()
{
char NOMFICH[15]; //nom du fichier
FILE *FICHIER; //pointeur sur fichier

//OUVERTURE DU FICHIER
do{

printf("Tapper le nom du fichier qui doit être traiter : ");
scanf("%s", NOMFICH);
FICHIER = fopen(NOMFICH, "r"); //ouverture en lecture
//TEST D'OUVERTURE DU FICHIER
if(!FICHIER)
printf("\aERREUR: Impossible d'ouvrir "
"le fichier: %s.\n", NOMFICH);
}
while(!FICHIER);
fclose(FICHIER);
return NOMFICH[15];
}

/*********************FIN RETOUR NOM FICHIER ************/

/*********** RETOURNE LE NOMBRE DE CARACTERES **********/

int comptechar()
{
//DECLARATIONS

char NOMFICHIER[15];
FILE *FICHIER; //pointeur sur fichier
char C; //caractères lu dans le fichier
int NTOT=0; //nombre de caractère total et initialisation
NOMFICHIER[15]=retournom();
printf("nom fichier : ",NOMFICHIER);
//DEBUT

//OUVERTURE DU FICHIER
do{

//			printf("Tapper le nom du fichier qui doit être traiter : ");
//		scanf("%s", NOMFICH);
FICHIER = fopen(NOMFICHIER, "r"); //ouverture en lecture

//TEST D'OUVERTURE DU FICHIER
if(!FICHIER)
printf("\aERREUR: Impossible d'ouvrir "
"le fichier: %s.\n", NOMFICHIER);
}
while(!FICHIER);

//COMPTER LES CHARS
while(!feof(FICHIER))
{
C=fgetc(FICHIER);

if(!feof(FICHIER))
{
NTOT++; //incrémente de 1 à chaque fois
}

}
fclose(FICHIER); //FERMETURE DU FICHIER

//RESULTAT
printf("le fichier contient %d ", NTOT);
printf("mots\n");
return NTOT; //retour du nombre de char

}

/******************* FIN FONCTION RETOUR NOMBRE DE CHARS**************/

/********** RETOURNE LE POINTEUR SUR TEXTE ***********/

//char lecturechar(FILE *FICH)
//{
//	char lecture; //stockage des caractères

//	while(!feof(FICH))
//	{
//		lecture=fgetc(FICH);
//	}
//	return lecture;
//	cout<<"*******  : "<<lecture;
//}

/******************** FIN LECTURE ET RETOUR TEXTE *************************/

/******************* CRYPTAGE DU TEXTE *************************/

void crypt(char txt[255])
{
/* DECLARATIONS */
int j=0; //entier pour boucle
int i=0;
int nbrchar; //nombre de char de comptechar()
char crypto[255]; //caractères de cryptage
char txtcrypt[255]; //texte crypté

//DEBUT

nbrchar=comptechar(); //nbrchar prends la val de comptechar()

for(i=0; i<255; i++) //initialisation boucle cryptage
{
crypto[i]=0+i;
}
//FIN

txtcrypt[255]=txt[255];

for(j=0;j<nbrchar;j++)
{

txtcrypt[j]=txtcrypt[j]+crypto[j];

}

//	monfichier1=fopen(fichier1,

cout<<"Voici le texte crypté : "<<txtcrypt;

}

/****** FIN CRYPTAGE ***********************************/

/*********** FONCTION DECRYPTAGE ***********************/

void decrypt(char txt[255]) //fonction de décryptage du texte
{
int i=0;
int j=0;
int nbrchar; //nombre char de compte char
char crypto[255];
char decrypt[255]; //texte decrypté
char crypt[255];

//	FILE *monfichier1; //déclarations pour le fichier séq
//	char *fichier1;    //idem
//	size_t retour1;    //idem
//	fichier1="decrypto.txt"; //idem

nbrchar=comptechar(); //nbrchar prends la valeur de comptechar()

for(i=0; i<255; i++) //initialisation boucle cryptage
{
crypto[i]=0+i;
}

crypt[255]=txt[255];

for(j=0;j<nbrchar;j++)
{

decrypt[j]=crypt[j]-crypto[j];
}

cout<<"voici le fichier decrypter : "<<decrypt;
}

/***************** FIN DECRYPTAGE ***********************/

/***************** PROG APPELANT ************************/

void main()
{
/*DECLARATIONS*/

char txtcrypt[255]; //texte crypté
char txtdecrypt[255]; //texte décrypté
int i=0; //entier pour boucle
int j=0;
int num; //numéro du menu
char yop[15];

//MENU

cout<<"          ****************************************\n";
cout<<"          *                                      *\n";
cout<<"          *               BIENVENUE              *\n";
cout<<"          *                                      *\n";
cout<<"          *        1.  Crypter un texte          *\n";
cout<<"          *        2. Decrypter un texte         *\n";
cout<<"          *        3.   Credits | Aide           *\n";
cout<<"          *        4.      Quitter               *\n";
cout<<"          *                                      *\n";
cout<<"          ****************************************\n";
cout<<endl;
cout<<"Saisir le numero de l'action a effectuer : ";
cin>>num;

int com;
switch(num)
{
case 1: crypt(txtcrypt);

break;
case 2:	decrypt(txtdecrypt);
break;

case 3:  //appel de la fonction
cout<<retournom();
//cout<<comptechar();

break;
}
//FIN MENU

}

/************* FIN APPELANT ***************************/

6 réponses

Messages postés
402
Date d'inscription
samedi 28 décembre 2002
Statut
Membre
Dernière intervention
21 juillet 2005
1
Salut, je n'ai fait que survolé le fichier, alors tout d'abord je ne vois pas trop l'utilité de la fonction retournom( ), vu que c'est DANS la fonction que le nom est donné... elle prendrai un peu de sens si tu avais par exemple une structure LeFichier, qui contient un membre strNom et puis alors la fonction retournerait ce nom etc. ensuite pour les fonction crypt( ) et decrypt( ), tu ne permet de que de crypter/dérypter 254 caractère à la fois, ce qui n'est pas tellement utile vu que beaucoups de fichiers contienne nettement plus :) alors je te conseille un pointeur vers un char.

ensuite la fonction crypt( ) tu affiche le texte crypté à la fin, ce qui n'est pas trop super, car ca peut ralentir le tout car afficher des 1000 de caractere c pas tro rapid (mm si pr le moment tu nen otorise ke 254...) alors je te conseille de declarer ta fonction crypt () de cette facon:
char *crypt( char *in_szTxtToCrypt );

ce qui va donc te permettre de retourner le texte crypté. alors tu auras ta fonction a peu pres comme ca:

char *crypt( char *in_pszTxtToCrypt )
{
    // en esperant ke la fonction est ok...
    int iNmbChar = comptechar( );
    char szCrypto[ 255 ];
    char *pszCrypt = ( char * ) malloc ( strlen( in_pszTxtToCrypt ) + 1 );

    for ( int i = 0; i < 255; i++ )
        szCrypto[ i ] = 0 + i;

    strcpy( pszCrypt, in_pszTxtToCrypt );
    for( int j = 0; j <= iNmbChar; i++ )
    {
        if ( j > 255 )
            pszCrypt[ j ] = pszCrypt[ j ] + szCrypto[ j - 255 ];
        else
            pszCrypt[ j ] = pszCrypt[ j ] + szCrypto[ j ];
    }

    return pszCrypt
}


maintenant je crois ke ca devrait marcher

en recopiant la fonction crypt( ) j'ai vu ke tu avais fait un erreur:

txtcrypt[ 255 ] = txt[ 255 ];

ne veut pas dire ke tu copie les 254 caractères mais ke le DERNIER caractere de txtcrypt est egal au DERNIER de txt!!!

ben look un peu ma fonction et fait a peu pres la mm choz pour le decrypt ;)

ciao :)

[DmX]
Messages postés
7
Date d'inscription
mercredi 10 mars 2004
Statut
Membre
Dernière intervention
7 novembre 2006

merci pour ton aide mais là j'ai un autre prob car j'ai décidé de le faire en objet et je trouve pas le moyen d'écrire dans le fichier sachant que ce n'est pas une structure (je v tester ton truc tout de meme ;) ) pourrait tu jeté un coup d'oeil à cette nouvelle version stp :

le header file : 

/*class*/ /*- "hearder.h" -*/

#include <stdio.h>
#include 
#include <stdlib.h>
#include <string>
using namespace std;

class fichier
{				//VARIABLES
protected: 
char file[15]; //nom fichier
char *fileout; //pointeur sur fichier de sortie (crypté ou décrypté)
FILE *FICHIER; //pointeur fichier d'ouverture
FILE *FICHIEROUT;//pointeur sur fileout
char C[65]; // caractère lue dans le fichier
int NTOT; //nombre total de char
int i; //var pour la boucle de cryptage incrémentation
int j; //var d'écriture et compar avec NTOT
char operation[65]; //le char de sorti cryptage ou decryptage
char ope2[65];
char txt[65];

//METHODES

public:
void init1(); //init, saisie nom fichier et open en read
void initC(); //init, Cryptage et open en write
void initD(); // init Décryptage et open write
void chara(); //retourne le nombre de char et stock les char dans Var "char C"
void boucleC(); //boucle de cryptage
void fermeture1(); // effectue un fclose pour fermer le fichier de traitement FICHIER
void fermeture2(); //effectue un fclose pour le fichier de sortie FICHIEROUT
void credits();
};

/************************* INIT1()**************************/
/***********************************************************/
void fichier::init1() //Permet la saisie du nom de fichier voulu et l'ouvre
{
do{
printf("Saisir le nom du fichier a traiter : ");
scanf("%s", file); //saisie du nom du fichier
FICHIER=fopen(file, "r"); //effectue un read du fichier

//Test ouverture du fichier

if(!FICHIER)
printf("\aErreur : IMPOSSIBLE D'OUVRIR " "le fichier : %s.\n", file);
}
while(!FICHIER);

}

/************************* INITC()**************************/
/***********************************************************/
void fichier::initC() //cryptage
{
fileout="crypte.txt"; //génération du fichier de sortie crypte.txt
do{
printf("Creation du fichier de sortie ...\n\n");
printf("Il se situe dans le meme répertoire\n\n");
printf("que le fichier source.\n\n");
//créer fichier de sorti
FICHIEROUT=fopen(fileout, "w"); //ouverture du fichier de sorti en écriture

do{ //cryptage dans la var txt
for(j=0; j<NTOT; j++)
{
txt[j]=C[j]+operation[j];
}
}
while(j<NTOT);

for(j=0; j<NTOT; j++)
{
cout<<txt[j];
}

}
while(!FICHIER);
fprintf(fileout,txt);

//manque écrire dans le put1 de fichier
}

/************************* INITD()**************************/
/***********************************************************/

void fichier::initD()
{
fileout="decrypte.txt"; //création du fichier de sortie decrypte.txt
do{
printf("Creation du fichier de sortie ...\n");
printf("Il se situe dans le meme repertoire\n");
printf("que le fichier source.\n");
//créer le fichier de sorti
FICHIEROUT=fopen(fileout, "a+"); //ouverture de fileout en écriture

do{ //decryptage dans txt
for(j=0; j<NTOT; j++)
{
txt[j]=C[j]-operation[j];
}
}
while(j<NTOT);

//manque écrire dans le putain de fichier
}
while(!FICHIEROUT);
}

/************************* chara()**************************/
/***********************************************************/

void fichier::chara()
{
//compter les chars

while(!feof(FICHIER))
{
C[65]=fgetc(FICHIER); //les chars sont stockés dans C
if(!feof(FICHIER))
{
NTOT++; //incrémentation de 1 //compte les chars
}
}
printf("Le fichier contient %d ", NTOT);
printf(" mots\n");

}

/************************* boucleC()************************/
/***********************************************************/

void fichier::boucleC() //initialisation boucle de cryptage
{
for (i=0; i<NTOT; i++)
{
operation[i]=operation[i]+(65+i);
}
}

/************************* fermeture1()*********************/
/***********************************************************/

void fichier::fermeture1() //fermeture du fichier à traiter
{
fclose(FICHIER);
}

/************************* fermeture2()*********************/
/***********************************************************/

void fichier::fermeture2() //fermeture du fichier de sortie
{
fclose(FICHIEROUT);
}

/***********************************************************/
/***********************************************************/

void fichier::credits()
{
printf("            - Credit -                          \n");
printf("Realise par Sanchez Damien\n");
printf("pour la société Periscope Creation\n\n");
printf("----------------------------------------------\n\n");
printf("             - Aide -                           \n");
printf("Le fichier a crypter ou decrypter doit\n");
printf("ce situer dans le meme repertoire que le\n");
printf("celui de l'application.\n\n");
printf("Le fichier de sortie se nommera selon l'action\n");
printf("effectue 'crypte.txt' ou 'decrypte.txt'\n");
}

-----------------
le *.cpp

/* APPLICATION CRYPTO - OBJET */ /*- APP-Crypto.cpp -*/

#include "hearder.h" // appel du fichier hearder.h

fichier FICHIER; //déclaration de FICHIER de type class fichier

void main()
{

//VARS
int num; //Sélection du menu
int men;

//MENU

cout<<"          ****************************************\n";
cout<<"          *                                      *\n";
cout<<"          *               BIENVENUE              *\n";
cout<<"          *                                      *\n";
cout<<"          *        1.  Crypter un texte          *\n";
cout<<"          *        2. Decrypter un texte         *\n";
cout<<"          *        3.   Credits | Aide           *\n";
cout<<"          *        4.      Quitter               *\n";
cout<<"          *                                      *\n";
cout<<"          ****************************************\n";
cout<<endl;
cout<<"Saisir le numero de l'action a effectuer : ";
cin>>num;

switch(num)
{
case 1:
FICHIER.init1();
FICHIER.chara();
FICHIER.fermeture1();
FICHIER.boucleC();
FICHIER.initC();
FICHIER.fermeture2();
break;
case 2:
FICHIER.init1();
FICHIER.chara();
FICHIER.fermeture1();
FICHIER.initD();
FICHIER.fermeture2();
break;

case 3:
FICHIER.credits();
printf("\n");
printf("Revenir au menu principal ? : ");
cin>>men;

switch(men)
{
case 1:
main();
break;
case 2:
//quitter
break;
}
break;

case 4:
//quitter
break;
}
//FIN MENU
}


je pense pas que le cpp te soit d'une grande utilité mais on ne sait jamais
Messages postés
402
Date d'inscription
samedi 28 décembre 2002
Statut
Membre
Dernière intervention
21 juillet 2005
1
Salut,
bonne idee de le faire en objet c'est mieux lol :) enfin deja tu n'as pa de constructeur pour ta class fichier !! ce ki fait ke tu ne sais pas creer d'objet pour celle-ci, le constructeur te permettrait de laisser tomber les fonction init( ) :) enfin alors tu pourrais par exemple choisir une fonction init par défaut (une ki doit TOUJOURS etre executee avant ke les otres ne puisse letre) par exemple alors le code de init1( ) tu le remplace par le constructeur de la fonction et comme ca chaque fois que tu creera un objet le fichier sera ouvert! et le destructeur de ta class tu peux lutiliser pour fclose() les 2 fichiers!

bon esaye deja de faire ca et reecris apres ;)

ciao ;)

[DmXx]
Messages postés
7
Date d'inscription
mercredi 10 mars 2004
Statut
Membre
Dernière intervention
7 novembre 2006

merci ça marche ;) sinon comment je fais pour affecter un ofstream pour écire dans le fichier car j'ai trouvé un truc dans un bouquin mais ça ne marche pas pour une affectation :

ofstream FichierSortie("C:\\TEST.TXT");
if(!FIchierSortie)
{
printf("Impossible ouvrir fichier IN");
return 1;
}
FichierSortie<<"taux=\n"<<20.6;
FichierSortie.close();



car je veux que mon fichier créée aléatoirement par le user devienne de type ifstream afin de lire correctement dans le fichier (je sais que ça le fait déjà sinon je n'arriverais pas retourner le bon nombre de char du fichier.
Messages postés
402
Date d'inscription
samedi 28 décembre 2002
Statut
Membre
Dernière intervention
21 juillet 2005
1
salut pour pouvoir faire cela par exemple tu pourrais faire dans ta class un operateur '<<' ke tu declare alors ds ta class ensuite tu met come parametre un std::string (ou un char* comme tu prefere) et pi tu fais kil ajoute ce string dans le fichier...

si t'as des problemes tu demande!! ( je v pas te fair tout ton code alors je te donne les details ;) si ta encore rien vu sur les operator dis le et laiss tn mail jtenverai un tuto! :)

ciao ;)
Messages postés
202
Date d'inscription
jeudi 24 juin 2004
Statut
Membre
Dernière intervention
22 janvier 2009
1
Dites moi, il y a ce morceau de code :
do{
printf("Saisir le nom du fichier a traiter : ");
scanf("%s", file); //saisie du nom du fichier
FICHIER=fopen(file, "r"); //effectue un read du fichier

//Test ouverture du fichier

if(!FICHIER)
printf("\aErreur : IMPOSSIBLE D'OUVRIR " "le fichier : %s.\n", file);
}
while(!FICHIER);

Si je rentre un nomde fichier erroné, ca ne boucle pas ?!
Je fais un prog qui utilises un truc a peu pres pareil mais avec des nombres. Et lorsque je boucle parce que la saisie n'est pas correct, il ne s'arrete plus au scanf, je comprends pas pourquoi