Le fait de mettre une variable pour la clé c'est pour pouvoir la modifier plus tard. On m'a appris qu'il ne faut pas mettre de "valeur magique" dans un programme sans expliquer à un moment "pourquoi 32 et pourquoi pas 12?"
Pour la fonction je suis d'accord, elle est un peu moche toute seule. J'aurais très bien pu ne pas la faire en effet ^^'
Merci Tosh pour tes indications, le debugeur ne me dit plus rien lorsque que j'utilise fwrite !
Seulement... Y'a rien dans le fichier non plus ! Voici ce que j'utilise :
@Yshelin : Le <= de ta boucle for m'inquiète grandement. J'ai l'impression que tu lis un caractère de trop.
Sinon pour le fwrite je n'ai pas vraiment le temps de me penché dessus je vérais ce soir.
Edit: Dans ton ancien code tu lisais bien un caractère de trop.
🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles- ♡ Copying is an act of love.
Normalement, je devrais avoir des trucs écrits dans mon fichier avant "Crypted text :", mais là, rien du tout !
Et la variable test vaut 1... Donc il n'y a pas d'erreur avec fwrite !
Pourtant, y'a quand même un truc qui cloche non ?
Merci !
fopen fonctionne bien, le fichier est créé.
Quand je dis qu'il n'y a rien, c'est que quand j'ouvre mon fichier (double clique sur title.txt), il n'y a rien avant "Crypted text : 40 23 o3... " qui est rajouté par la deuxième boucle for.
Pourtant, celle de fwrite est placée avant.
Mmh, tu pourrais me filer le prototype des fonctions fwrite et fread s'il te plait ?
Et comment passer de 1001011 à 'b', par exemple ?? (c'est du pif hein ).
Bon, je poste une petite correction, il y a moyen de faire mieux évidemment. J'ai essayé de commenté au maximum, mais vous pouvez toujours poser vos questions si vous ne comprenez pas un passage. (Ou si je me suis planté quelque part ) :
1) Débutant.
#include <stdio.h>
#include <string.h>
#define STR_MAX 128
#define KEY 0xa
/*!
* Fonction affichant les octets d'une chaine (pas forcément terminée par '\0')
* en hexédécimal de taille len.
*/
void print_str(const unsigned char *str, size_t len)
{
size_t i;
for(i = 0; i < len; i++)
{
printf("%.2x ", str[i]);
}
printf("\n");
}
/*!
* Fonction prenant une chaine en paramètre (pas forcément terminée par '\0', vu
* qu'on se base sur le paramètre len pour connaître la fin.) et qui effectue un
* cryptage XOR dessus, avec la clef key passée en paramètre.
*/
void crypt_str(unsigned char *str, size_t len, unsigned char key)
{
size_t i;
for(i = 0; i < len; i++)
{
str[i] ^= key;
}
}
int main(void)
{
char str[STR_MAX];
size_t str_len;
/* On lit une chaine de caractère de maximum STR_MAX-1 caractères (Pour laisser
* de la place pour le '\0' final.) */
printf("Entrez une chaine de caractères :\n>");
fgets(str, STR_MAX, stdin);
printf("\n");
/* On calcule la longueur de la chaine avant de la crypter */
str_len = strlen(str)+1;
/* On affiche la chaine non-cryptée */
printf("Chaine non-cryptée (clef = 0x%x) : \n", KEY);
print_str((unsigned char*)str, str_len);
printf("\n");
/* On crypte la chaine avec la clef KEY (définie en constante)*/
printf("Chaine cryptée (clef = 0x%x) : \n", KEY);
crypt_str((unsigned char*)str, str_len, KEY);
/* On affiche la chaine cryptée */
print_str((unsigned char*)str, str_len);
printf("\n");
return 0;
}
2) Intermédiaire.
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
/*!
* Fonction prenant une chaine en paramètre (pas forcément terminée par '\0', vu
* qu'on se base sur le paramètre len pour connaître la fin.) et qui effectue un
* cryptage XOR dessus, avec la clef key passée en paramètre.
*/
void crypt_str(unsigned char *str, size_t len, unsigned char key)
{
size_t i;
for(i = 0; i < len; i++)
{
str[i] ^= key;
}
}
/*!
* Fonction ouvrant un fichier, et arrêtant l'exécution du programme
* si une erreur se produit dans l'ouverture.
*/
void open_file(const char *name, const char *mode, FILE **file)
{
if((*file = fopen(name, mode)) == NULL)
{
fprintf(stderr, "Impossible d'ouvrir le fichier : %s\n", name);
exit(EXIT_FAILURE);
}
}
/*!
* Fonction cryptant un fichier src en utilisant la clef key, pour au final
* obtenir un fichier dst crypté. (Le fichier source n'étant pas modifié)
*/
void crypt_file(FILE *src, FILE *dst, unsigned char key)
{
unsigned char buff[512];
size_t size_read;
do
{
size_read = fread(buff, sizeof(unsigned char), sizeof(buff), src);
crypt_str(buff, size_read, key);
fwrite(buff, 1, size_read, dst);
}while(size_read >= sizeof(buff));
}
/*!
* Crypte un fichier, en stockant dans le premier octet du fichier crypté, la
* clef nécessaire pour le déchiffrer.
*/
void crypt(const char *src, const char *dst)
{
FILE *f_src, *f_dst;
unsigned char key;
open_file(src, "rb", &f_src);
open_file(dst, "wb", &f_dst);
key = rand() % 255 + 1;
fwrite(&key, sizeof(unsigned char), 1, f_dst);
crypt_file(f_src, f_dst, key);
fclose(f_src);
fclose(f_dst);
}
/*!
* Décrypte un fichier, en récupérant dans le premier octet du fichier, la clef
* nécessaire au décryptage.
*/
void decrypt(const char *src, const char *dst)
{
FILE *f_src, *f_dst;
unsigned char key;
open_file(src, "rb", &f_src);
open_file(dst, "wb", &f_dst);
fread(&key, sizeof(unsigned char), 1, f_src);
crypt_file(f_src, f_dst, key);
fclose(f_src);
fclose(f_dst);
}
int main(int argc, char **argv)
{
/* Initialisation de la graine pour le générateur de nombres
* (pseudo)aléatoires. */
srand(time(NULL));
/* Le programme attends trois arguments (quatres en comptant le nom du programme)
* et les options --crypt ou --decrypt en premier argument.
*/
if(argc != 4 || (strcmp(argv[1], "--crypt") && strcmp(argv[1], "--decrypt")))
{
printf("Usage : %s --crypt | --decrypt <src> <dest>\n", argv[0]);
}
else if(!strcmp(argv[1], "--crypt"))
{
crypt(argv[2], argv[3]);
}
else
{
decrypt(argv[2], argv[3]);
}
return 0;
}
3) Avancé.
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#define MAX_KEY_LEN 512
/*!
* Fonction prenant une chaine en paramètre (pas forcément terminée par '\0', vu
* qu'on se base sur le paramètre len pour connaître la fin.) et qui effectue un
* cryptage XOR dessus, avec la clef key passée en paramètre.
*/
void crypt_str(unsigned char *str, size_t len, const unsigned char *key)
{
size_t i, j;
for(i = 0, j = 0; i < len; i++, j++)
{
str[i] ^= key[j];
if(key[j] == '\0')
{
j = 0;
}
}
}
/*!
* Fonction ouvrant un fichier, et arrêtant l'exécution du programme
* si une erreur se produit dans l'ouverture.
*/
void open_file(const char *name, const char *mode, FILE **file)
{
if((*file = fopen(name, mode)) == NULL)
{
fprintf(stderr, "Impossible d'ouvrir le fichier : %s\n", name);
exit(EXIT_FAILURE);
}
}
/*!
* Fonction cryptant un fichier src en utilisant la clef key, pour au final
* obtenir un fichier dst crypté. (Le fichier source n'étant pas modifié)
*/
void crypt_file(FILE *src, FILE *dst, const unsigned char *key)
{
unsigned char buff[512];
size_t size_read;
do
{
size_read = fread(buff, sizeof(unsigned char), sizeof(buff), src);
crypt_str(buff, size_read, key);
fwrite(buff, 1, size_read, dst);
}while(size_read >= sizeof(buff));
}
/*!
* Fonction effectuant un cryptage XOR sur le fichier src, et écrit le résultat
* dans le fichier dst. La clef utilisé est une chaine de caractères.
*/
void crypt(const char *src, const char *dst, const unsigned char *key)
{
FILE *f_src, *f_dst;
open_file(src, "rb", &f_src);
open_file(dst, "wb", &f_dst);
crypt_file(f_src, f_dst, key);
fclose(f_src);
fclose(f_dst);
}
int main(int argc, char **argv)
{
/* Le programme attends 3 arguments (4 en comptant le nom du programme) :
* - la clef (argv[1])
* - le fichier src (argv[2])
* - le fichier dst (argv[3])
*/
if(argc != 4)
{
printf("Usage : %s <key> <src> <dest>\n", argv[0]);
}
else
{
crypt(argv[2], argv[3], (unsigned char*)argv[1]);
}
return 0;
}
+1 je n'avais tous simplement pas remarqué que l'on pouvait faire ainsi.
Aussi je me demandais si les calculs sont forcément plus rapide que les conditions ? J'ai toujours crus que oui mais c'est juste mon intuitions.
🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles- ♡ Copying is an act of love.
Pourquoi utiliser l'allocation dynamique ici ?
Pourquoi utiliser fscanf à la place de scanf ?
Je trouve tes cast un peu étrange avec tes XOR.
Pourquoi tu utilise un tableau d'int et un tableau de char, ce n'est pas très bon de mélanger les types comme ceci. (On le voit sur l'affichage d'ailleurs)
Ensuite, le %p m'intrigue... Il est en principe utilisé pour une adresse. Peut être que %x ferait mieux l'affaire si tu souhaites récupérer une valeur hexadécimale.
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles - ♡ Copying is an act of love.
Objectif Zéro Bug - le test logiciel professionnel | L'électronique de zéro | Tableaux & pointeurs | Pointeurs sur fonctions | Lecture/écriture binaire
🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles - ♡ Copying is an act of love.