Partage

zCrypt

Vos codes!

1 2 >>

16 octobre 2010 à 14:33:58

Vous pouvez proposer dans ce sujet vos codes pour l'exercice zCrypt ou poser vos questions si une partie de l'énoncé ne vous paraît pas claire.

Bon courage !

Yannshu

16 octobre 2010 à 17:45:54

Bon, je m'ennuyais...

Et vive unix & Adam Lindsay

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>

int             main(void)
{
  unsigned char key, buffer[BUFSIZ] = {0};
  int           iterator, byteRead;

  printf("GIMMEH buffer\n");
  if ((byteRead = read(STDIN_FILENO, buffer, BUFSIZ)) == -1)
    {
      perror("read:");
      return EXIT_FAILURE;
    }
  srand(time(NULL) * getpid());
  key = rand() % 254 + 1;
  printf("LOL key R %.2X\nVISIBLE Uncrypted string:\n", key);
  for (iterator = 0; iterator < byteRead; iterator++)
    printf("%.2X%c", buffer[iterator], iterator + 1 == byteRead ? '\n' : ' ');
  printf("LOL key R %.2X\nVISIBLE Crypted string:\n", key);
  for (iterator = 0; iterator < byteRead; iterator++)
    printf("%.2X%c", buffer[iterator] ^ key, iterator + 1 == byteRead ? '\n' : ' ');
  return EXIT_SUCCESS;
}

Découvrez un petit jeu Android bien sympa : http://www.siteduzero.com/forum/sujet/appli-jeu-android-cube-racer

Anonyme

16 octobre 2010 à 18:34:40

Voilà la mienne pour l'exercice 2 (en C89) :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

void testDataIntegrity();

/* In this program, we assume the user has a brain. Oh, we don't anymore. */

int main (int argc, const char * argv[]) {
	const char *option = argv[1];
	const char *sourceFilePath = argv[2];
	const char *destinationFilePath = argv[3];
	int currentChar;
	int key;
	int isCrypting;
	testDataIntegrity(option, sourceFilePath, destinationFilePath);
	if ((isCrypting = strcmp(option, "-c")?0:1)) {
		FILE *sourceFile = fopen(sourceFilePath, "r");
		FILE *destinationFile = fopen(destinationFilePath, "w");
		srand(time(NULL));
		key = rand()%253+1;
		fprintf(destinationFile, "%c", key);
		while (fread(&currentChar, 1, 1, sourceFile))
			fputc(currentChar^key, destinationFile);
		fclose(sourceFile);
		fclose(destinationFile);
	} else {
		FILE *sourceFile = fopen(sourceFilePath, "r");
		FILE *destinationFile = fopen(destinationFilePath, "w");
		key = fgetc(sourceFile);
		while (fread(&currentChar, 1, 1, sourceFile))
			fputc(currentChar^key, destinationFile);
		fclose(sourceFile);
		fclose(destinationFile);
	}
    return 0;
}

void testDataIntegrity(char *option, char *sourceFilePath, char *destinationFilePath) {
	FILE *file;
	if (strcmp(option, "-d") && strcmp(option, "-c")) {
		printf("Invalid option.\n");
		exit(0);
	}
	if (!sourceFilePath || !destinationFilePath) {
		printf("Invalid path.\n");
		exit(0);
	}
	if ((file = fopen(destinationFilePath, "r"))) {
		fclose(file);
		printf("Destination file already exists.\n");
		exit(0);
	}
}

EDIT: rajouté le test de l'entrée.
EDIT2: et le binaire.

Tosh

16 octobre 2010 à 19:05:53

Merci pour votre participation.

@Yannshu : ça m'a l'air bon, mis à part que je trouve le code un peu trop compact, et que tu utilise des fonctions non-standard. (Enfin ça, ce n'est pas moi qui vais te le reprocher...)

@ttthebest : ça serait intéressant de valider un peu plus les entrées, et ton code ne marche pas sur des fichiers binaires.

Sinon, le code en lui même est assez clair.

@che

16 octobre 2010 à 20:33:24

Ma participation a l'exo (le 1).

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


int main()
{
char crypt[100];
int moyen;
int si;

    printf("Entrer la chaine a crypte\n");
    fgets(crypt, sizeof(crypt), stdin);

    si = strlen(crypt)-1;

    moyen = crypt[si/2];
    printf("\nChaine chiffree:\n");

    for(int i = 0;i < si;i++)
        printf("%.2x ",(crypt[i] ^= moyen));
    printf("\nChaine dechiffree:\n");

    for(int i = 0;i < si;i++)
        printf("%.2x ",(crypt[i] ^= moyen));
    printf(" (");

    for(int i = 0;i < si;i++)
        printf("%c",crypt[i]);

    printf(")\n");
    getchar();
    return 0;
}

🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles - ♡ Copying is an act of love.

Yannshu

16 octobre 2010 à 20:44:05

@ttthebest: N'oublie pas de refermer tes flux de fichiers

Et voila mon implementation de l'exo 2:
(Et oui, j'utilise encore des fonctions non standart, quel vilain fanboy unix je suis).

#include <stdlib.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <time.h>
#include <string.h>

# define ERR_USAGE      "Usage: ./zCrypt --crypt|--decrypt source.txt destination.txt\n"
# define TRUE           1
# define FALSE          0

static unsigned char    getKey(const unsigned char isCrypting, int fdSrc, int fdDest)                                                                                 
{                                                                                                                                                                     
  unsigned char         key;                                                                                                                                          
                                                                                                                                                                      
  if (isCrypting)                                                                                                                                                     
    {                                                                                                                                                                 
      srand(time(NULL) * getpid());                                                                                                                                   
      key = rand() % 254 + 1;                                                                                                                                         
      write(fdDest, &key, 1);                                                                                                                                         
    }                                                                                                                                                                 
  else if (read(fdSrc, &key, 1) == -1)                                                                                                                                
    {                                                                                                                                                                 
      perror("read");                                                                                                                                                 
      exit(-1);                                                                                                                                                       
    }                                                                                                                                                                 
  return key;                                                                                                                                                         
}

static void     writeInFile(int fdSrc, int fdDest, const unsigned char key)                                                                                           
{                                                                                                                                                                     
  unsigned char result, buffer[BUFSIZ];                                                                                                                               
  int           bytesRead, iterator;                                                                                                                                  
                                                                                                                                                                      
  while ((bytesRead = read(fdSrc, buffer, BUFSIZ)) > 0)                                                                                                               
    for (iterator = 0; iterator < bytesRead; iterator++)                                                                                                              
      {                                                                                                                                                               
        result = buffer[iterator] ^ key;                                                                                                                              
        write(fdDest, &result, 1);                                                                                                                                    
      }                                                                                                                                                               
  if (bytesRead == -1)                                                                                                                                                
    {                                                                                                                                                                 
      perror("read");                                                                                                                                                 
      exit(-1);                                                                                                                                                       
    }                                                                                                                                                                 
}

int             main(int ac, char **av)                                                                                                                               
{                                                                                                                                                                     
  int           fdSrc, fdDest;                                                                                                                                        
  unsigned char isCrypting, key;                                                                                                                                      
                                                                                                                                                                      
  if (ac == 4)                                                                                                                                                        
    {                                                                                                                                                                 
      if (strcmp(av[1], "--crypt") == 0)                                                                                                                              
        isCrypting = TRUE;                                                                                                                                            
      else if (strcmp(av[1], "--decrypt") == 0)                                                                                                                       
        isCrypting = FALSE;                                                                                                                                           
      else                                                                                                                                                            
        {                                                                                                                                                             
          write(STDERR_FILENO, ERR_USAGE, strlen(ERR_USAGE));                                                                                                         
          return EXIT_FAILURE;                                                                                                                                        
        }                                                                                                                                                             
      if ((fdSrc = open(av[2], O_RDONLY)) == -1)                                                                                                                      
        {                                                                                                                                                             
          perror(av[2]);                                                                                                                                              
          return EXIT_FAILURE;                                                                                                                                        
        }                                                                                                                                                             
      if ((fdDest = open(av[3], O_WRONLY | O_CREAT | O_TRUNC, 0644)) == -1)                                                                                           
        {                                                                                                                                                             
          perror(av[3]);                                                                                                                                              
          return EXIT_FAILURE;                                                                                                                                        
        }                                                                                                                                                             
      key = getKey(isCrypting, fdSrc, fdDest);                                                                                                                        
      writeInFile(fdSrc, fdDest, key);                                                                                                                                
      close(fdSrc);                                                                                                                                                   
      close(fdDest);                                                                                                                                                  
    }                                                                                                                                                                 
  else                                                                                                                                                                
    write(STDERR_FILENO, ERR_USAGE, strlen(ERR_USAGE));                                                                                                               
  return EXIT_SUCCESS;                                                                                                                                                
}

Découvrez un petit jeu Android bien sympa : http://www.siteduzero.com/forum/sujet/appli-jeu-android-cube-racer

GurneyH

16 octobre 2010 à 21:16:05

Citation : Yannshu

(Et oui, j'utilise encore des fonctions non standart, quel vilain fanboy unix je suis).

Surtout qu'ici tu peux coder en C...

Donc je ne vois pas trop pourquoi employer des fonctions non standard. :-°

Enfin...

Zeste de Savoir, le site qui en a dans le citron !

Yannshu

16 octobre 2010 à 21:20:47

Question de préférences

Découvrez un petit jeu Android bien sympa : http://www.siteduzero.com/forum/sujet/appli-jeu-android-cube-racer

Pouet_forever

16 octobre 2010 à 21:39:05

Pourquoi c'est jamais les débutants qui postent ? o_O

Ah, si ya colbseton qui se prépare !

Yannshu

16 octobre 2010 à 21:51:06

P't'être parce que le sujet a été posté il n'y a pas très longtemps, et qu'il leur faut un peu plus de temps pour comprendre et coder tout ça

Découvrez un petit jeu Android bien sympa : http://www.siteduzero.com/forum/sujet/appli-jeu-android-cube-racer

Tosh

16 octobre 2010 à 21:56:56

Moi j'aime bien la version de Yannshu. Pis POSIX, c'est quand même un standard après tout...

GurneyH

16 octobre 2010 à 22:05:17

Citation : Tosh

Moi j'aime bien la version de Yannshu. Pis POSIX, c'est quand même un standard après tout...

Ce sont des standards. :-°

Meme linux peine à suivre POSIX alors.

Sinon il y a un truc pas mal et portable, le C!

Zeste de Savoir, le site qui en a dans le citron !

CokieForever

17 octobre 2010 à 0:29:08

Citation : Pouet_forever

Pourquoi c'est jamais les débutants qui postent ?

Eh bien, en voilà un

Rq : je suis débutant dans le sens où j'apprends tout seul et en parallèle avec une montagne de maths et de physique, je ne le suis pas dans le sens où je n'en suis plus à mes "débuts". Mais quand même

Mon algo principal pour coder avec un mot de passe :

int OpererFichier(FILE *fichierAOperer, FILE *fichierOpere, int tailleFichier)
{
    if (!fichierAOperer || !fichierOpere)
       return 0;
    
    printf("Veuillez patienter : 0 %%");
    
    int percent = 0,
        lng=strlen(password),
        k=0, i, j,
        read;
    char c[100];
    
    for (i=0 ; (read=fread(c, 1, 100, fichierAOperer)) > 0 && i < tailleFichier ; i += 100)
    {
        for (j=0 ; j<read ; j++)
        {
            c[j] = c[j]^password[k];
            k = (k+1)%lng;
        }
        
        fwrite(c, 1, read, fichierOpere);
        if ((int)((i+1) / (tailleFichier * 0.01)) > percent)
        {
           percent = (i+1) / (tailleFichier * 0.01);
           printf("\rVeuillez patienter : %d %%", percent);
        }
    }
    
    return 1;
}

Où password est évidemment le mot de passe entré par l'utilisateur (une variable globale, car utilisée partout... y en a que deux ! :euh:

)

Sinon, l'implémentation totale est ici (inclus tout le tralala d'interface, donc c'est assez long pour pas grand-chose...) :

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


FILE* RecupererNomFichier(char chaine[], int taille);
void EntrerMotDePasse(char chaine[], int taille);
int OuiOuNon();
int RecupererTailleFichier(char nomFichier[]);
int Quit();
int FichierExiste(char nomFichier[]);
int OpererFichier(FILE *fichierAOperer, FILE *fichierOpere, int tailleFichier);
int EcrireSignature(FILE *fichierCrypte);
int Crypter();
int VerifierMotDePasse(FILE *fichier, char pwd[]);
int Decrypter();
int Operation(char nomFichierAOperer[], FILE *fichierAOperer, int tailleFichier, int ajouterSignature);
void viderBuffer();

char password[100] = "";
char signature[] = "TheSDZIsTheBestOne_[CokieForever]";


int main(int argc, char *argv[])
{
    int done=0;
    while (!done)
    {
         printf("CRYPT@LIAS : codage et decodage faible de petits fichiers\n\n1° Crypter\n2° Decrypter\n\nVeuillez choisir : ");
         char c = 0, mode = 0;
         
         do
         {
             c = getch();
             if (c == '1' || c == '2')
             {
                 printf("%c\b", c);
                 mode = c-'0';
             }
             else if (c == '\b')
                 printf(" \b");
         } while (c != 13 || mode == 0);
            
         if (mode == 1)
             Crypter();
         else Decrypter();
            
         system("cls");
    }
    
    return EXIT_SUCCESS;                
}


FILE* RecupererNomFichier(char chaine[], int taille)
{
      char *p;
      
      while (fgets(chaine, taille, stdin) == NULL);
      if ((p=strchr(chaine, '\n')) != NULL)
           *p = '\0';
      else viderBuffer();
      
      return fopen(chaine, "rb");
}


void EntrerMotDePasse(char chaine[], int taille)
{
     char buffer[100] = "";
     int i;
     
     for (i=0 ; i<100 && (i<1 || buffer[i - 1] != 13) ; i++)
     {
         buffer[i] = getch();
         if (buffer[i] != 13 && buffer[i] != '\b')
            printf("*");
         if (buffer[i] == '\b' && i > 0)
         {
            printf("\b \b");
            i -= 2;
         }
         else if (buffer[i] == '\b' && i <= 0)
            i--;
     }
     
     strncpy(chaine, buffer, taille);
     return;
}

int OuiOuNon()
{
    char c;
    do
    {
         c = toupper(getch());
    } while (c != 'O' && c != 'N');
    
    printf("%c", c);
    if (c=='O')
       return 1;
    else return 0;
}

int RecupererTailleFichier(char nomFichier[])
{
    FILE *fichier = fopen(nomFichier, "r");
    int t, p;
    if (!fichier)
       return -1;
    
    p = ftell(fichier);
    fseek(fichier, 0, SEEK_END);
    t = ftell(fichier);
    fseek(fichier, p, SEEK_SET);
    
    fclose(fichier);
    return t;
}
    
int Quit()
{
     printf("\n\nAbandon de l'operation. Fichier non modifie.\n\nAppuyez sur une touche pour quitter... ");
     getch();
     return 0;
}


int FichierExiste(char nomFichier[])
{
    FILE *fichier = fopen(nomFichier, "r");
    
    if (fichier)
    {
       fclose(fichier);
       return 1;
    }
    else return 0;
}

int OpererFichier(FILE *fichierAOperer, FILE *fichierOpere, int tailleFichier)
{
    if (!fichierAOperer || !fichierOpere)
       return 0;
    
    printf("Veuillez patienter : 0 %%");
    
    int percent = 0,
        lng=strlen(password),
        k=0, i, j,
        read;
    char c[100];
    
    for (i=0 ; (read=fread(c, 1, 100, fichierAOperer)) > 0 && i < tailleFichier ; i += 100)
    {
        for (j=0 ; j<read ; j++)
        {
            c[j] = c[j]^password[k];
            k = (k+1)%lng;
        }
        
        fwrite(c, 1, read, fichierOpere);
        if ((int)((i+1) / (tailleFichier * 0.01)) > percent)
        {
           percent = (i+1) / (tailleFichier * 0.01);
           printf("\rVeuillez patienter : %d %%", percent);
        }
    }
    
    return 1;
}

int EcrireSignature(FILE *fichierCrypte)
{
    if (!fichierCrypte)
       return 0;
    
    int lng=strlen(password),
        k=0, i;
    char c;
    
    rewind(fichierCrypte);
    for (i=0 ; signature[i] ; i++)
    {
        c=signature[i]^password[k];
        fwrite(&c, 1, 1, fichierCrypte);
        k = (k+1)%lng;
    }
    
    return 1;
}


int Crypter()
{
    system("cls");
    
    printf("Bienvenue dans Crypt@lias.\nCe logiciel va vous permettre de crypter faiblement vos fichiers\nafin de les proteger contre d'eventuelles intrusions.\n\n");
    char nomFichierACrypter[1000];
    FILE *fichierACrypter = NULL;
    
    int tailleFichier;
    printf("Veuillez d'abord entrer le nom du fichier a crypter\n(et eventuellement son adresse) :\n");
    do
    {
       if (   !(fichierACrypter = RecupererNomFichier(nomFichierACrypter, 1000))
           ||  (tailleFichier = RecupererTailleFichier(nomFichierACrypter)) < 0  )
          printf("\nCe fichier n'existe pas ou est inacessible.\nVeuillez en choisir un autre :\n");
                           
    } while (!fichierACrypter);
       
    printf("\nLe fichier a ete ouvert avec succes.");
    
    char buffer[100];
    int done=0;
    
    do
    {
        printf("\nVeuillez choisir un mot de passe : ");
        EntrerMotDePasse(buffer, 100);
        printf("\nConfirmez le mot de passe : ");
        EntrerMotDePasse(password, 100);
        
        if (strcmp(password, buffer))
           printf("\n\nLes mots de passe sont differents.\nVeuillez recommencer...\n");
        else done=1;
    
    } while (!done);
         
    printf("\n\nAVERTISSEMENT : en cas de perte de votre mot de passe, vos donnees\nseront impossible a recuperer. N'oubliez pas que les mots\nde passe sont sensibles a la casse.\n\n");
    printf("Confirmez-vous le lancement ? (o/n) : ");
    
    if (!OuiOuNon())
       return Quit();
    
    return Operation(nomFichierACrypter, fichierACrypter, tailleFichier, 1);
}

int VerifierMotDePasse(FILE *fichier, char pwd[])
{
    if (!fichier)
       return -1;
    
    rewind(fichier);
    char c, buffer[100];
    int lng = strlen(pwd),
        slng = strlen(signature),
        k=0, i;
    
    for (i=0 ; i<slng ; i++)
    {
        fread(&c, 1, 1, fichier);
        buffer[i] = c^pwd[k];
        k = (k+1)%lng;
    }
    
    return (!strcmp(buffer, signature));
}


int Decrypter()
{
    system("cls");
    
    printf("Bienvenue dans Crypt@lias.\nCe logiciel va vous permettre de decrypter vos fichiers precedemment encodes.\n\n");
    char nomFichierADecrypter[1000];
    FILE *fichierADecrypter = NULL;
    
    int tailleFichier;
    printf("Veuillez d'abord entrer le nom du fichier a crypter\n(et eventuellement son adresse) :\n");
    do
    {
       if (   !(fichierADecrypter = RecupererNomFichier(nomFichierADecrypter, 1000))
           ||  (tailleFichier = RecupererTailleFichier(nomFichierADecrypter)) < 0    )
          printf("\nCe fichier n'existe pas ou est inacessible.\nVeuillez en choisir un autre :\n");
                           
    } while (!fichierADecrypter);
       
    printf("\nLe fichier a ete ouvert avec succes.\nVeuillez entrer votre mot de passe : ");
    
    int done=0;
    do
    {
        EntrerMotDePasse(password, 100);
        if (!VerifierMotDePasse(fichierADecrypter, password))
           printf("\n\nMot de passe incorrect.\nVeuillez recommencer... : ");
        else done=1;
    } while (!done);
         
    
    printf("\n\nMot de passe correct.");
    fseek(fichierADecrypter, strlen(signature), SEEK_SET);
    return Operation(nomFichierADecrypter, fichierADecrypter, tailleFichier-ftell(fichierADecrypter), 0);
}


int Operation(char nomFichierAOperer[], FILE *fichierAOperer, int tailleFichier, int ajouterSignature)
{
    if (!nomFichierAOperer || !fichierAOperer)
       return 0;
    
    char nomFichierTampon[1010];
    sprintf(nomFichierTampon, "%s.tmp", nomFichierAOperer);
    
    if (FichierExiste(nomFichierTampon))
    {
       printf("\n\nATTENTION !\nLe programme se prepare a ecraser le fichier suivant :\n%s\nContinuer ? (o/n) : ", nomFichierTampon);
       if (!OuiOuNon())
          return Quit();
    }
    
    FILE *fichierOpere = NULL;
    do
    {
        if ((fichierOpere = fopen(nomFichierTampon, "wb+")) == NULL)
        {
            printf("\n\nErreur : Impossible d'ouvrir le fichier temporaire.\nReessayer ? (o/n) : ");
            if (!OuiOuNon())
            {
               fclose(fichierAOperer);
               return Quit();
            }
        }
    } while (fichierOpere == NULL);
    
    printf("\n\nOperation en cours...\n\n");
    if (ajouterSignature)
       EcrireSignature(fichierOpere);
    OpererFichier(fichierAOperer, fichierOpere, tailleFichier);
    
    fclose(fichierAOperer);
    fclose(fichierOpere);
    
    printf("\nOperation terminee avec succes.\n\nRemplacer l'original ? (o/n) : ");
    if (OuiOuNon())
    {
       remove(nomFichierAOperer);
       rename(nomFichierTampon, nomFichierAOperer);
    }
    
    printf("\n\nOperation terminee. Appuyez sur une touche.");
    getch();
    
    return 1;
}


void viderBuffer()
{
    int c = 0;
    while (c != '\n' && c != EOF)
       c = getchar();
}

Lors du cryptage, je crypte en plus une chaine prédéterminée et je la place en tête du fichier de sortie.
Ainsi, lors du décryptage, pour vérifier si un mot de passe donné est bon, il suffit de décrypter les premiers caractères du fichier : si on retrouve la chaine prédéterminée, c'est que c'est bon (sauf si le mot de passe est plus grand que la chaine...)

(Bien entendu, à l'aide de la chaine prédéterminée et de sa version cryptée, on peut donc en déduire le mot de passe... Mais bon, c'est mieux que rien ! :lol:

)

http://ikturm.wordpress.com/ ; http://www.arb-assoc.fr

@che

17 octobre 2010 à 13:34:23

Ma solution a l'exercice 2:

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


int main (int argc, char *argv[])
{
    FILE* fichier = NULL;
    FILE* fichier2 = NULL;
    fichier = fopen(argv[1],"r");
    fichier2 = fopen(argv[2],"w");
    char car = ' ';
    car = fgetc(fichier);
    do
    {
        fputc(car^11,fichier2);
        car = fgetc(fichier);
    }while(car != EOF);
    
    fclose(fichier2);
    fclose(fichier);

    getchar();
    return 0;
}

🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles - ♡ Copying is an act of love.

uknow

17 octobre 2010 à 14:46:43

En fuyant un peu dans ma bibliothèque d'utilitaires j'ai trouvé ceci :

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

#define CLEPUB  "Hello world"
#define sizeCLEPBC 11
#define CLEPRIV "I am UKNOW"
#define sizeCLEPRV 10

typedef struct {
     void * buffer;
     size_t size;
}SData, *p_SData;

void * initData   (p_SData pdata);
void * readData   (p_SData pdata, char * filePAth);
void * saveData   (p_SData pdata, char * filePAth);
void   showData   (p_SData pdata);
void   delete     (p_SData pdata);
void   crypter    (char *buffer,size_t size, char cle_public[],size_t clepub,char cle_privee[],size_t clepriv);
void   decrypter  (char *buffer,size_t size, char cle_public[],size_t clepub,char cle_privee[],size_t clepriv);
size_t getFileSize(FILE *file,char *nom);

int main(void)
{
    /*/---------------------------------------------------*/
    SData data;
    p_SData pdata = &data;
    char filePath[] = "fichier.txt";

    data.size = getFileSize(NULL,filePath);

    if(!initData(pdata)){
        fprintf(stderr,"Erreur d'allocation mémoire\n");
        exit(EXIT_FAILURE);
    }
    if(data.size == 0){
        fprintf(stderr,"Le fichier est introuvable ou vide\n");
        delete(pdata);
        exit(EXIT_FAILURE);
    }

    if(!readData(pdata,filePath)){
        fprintf(stderr,"Erreur d'ouvertur du fichier \"%s\"",filePath);
        delete(pdata);
        exit(EXIT_FAILURE);
    }

    puts("------------Avant----------");
    showData(pdata);

    crypter(data.buffer,data.size,CLEPUB,sizeCLEPBC,CLEPRIV,sizeCLEPRV);

    puts("------------Apres----------");
    showData(pdata);

    decrypter(data.buffer,data.size,CLEPUB,sizeCLEPBC,CLEPRIV,sizeCLEPRV);

    puts("------------Donnees initiales----------");
    showData(pdata);

    delete(pdata);
    /*/---------------------------------------------------*/
    return 0;
}

/**************************************************************/
/**              Initialisations                             **/
/**                                                          **/
/**************************************************************/
void * initData(p_SData pdata){
    pdata->buffer = malloc(pdata->size);

    return pdata->buffer;
}
/**************************************************************/
/**              Lecture des données                         **/
/**                                                          **/
/**************************************************************/
void * readData(p_SData pdata, char * filePAth){
    FILE * file = fopen(filePAth,"rb");

    if(!file) return file;

    fread(pdata->buffer,1,pdata->size,file);
    fclose(file);

    return pdata->buffer;
}
/**************************************************************/
/**              Sauvegarde des données                      **/
/**                                                          **/
/**************************************************************/
void * saveData(p_SData pdata, char * filePAth){
    FILE * file = fopen(filePAth,"wb");

    if(!file) return file;

    fwrite(pdata->buffer,1,pdata->size,file);
    fclose(file);

    return pdata->buffer;
}
/**************************************************************/
/**              Affichage                                   **/
/**                                                          **/
/**************************************************************/
void showData(p_SData pdata){
    size_t i;
    for(i=0 ; i < pdata->size ; i++)
         printf("%.2X ",((char*)pdata->buffer)[i]);

    printf("\n");
}
/**************************************************************/
/**              Libération de mémoire                       **/
/**                                                          **/
/**************************************************************/
void delete(p_SData pdata){
    free(pdata->buffer);
}

/**************************************************************/
/**              Fonction de chiffrement                     **/
/**                                                          **/
/**************************************************************/
void crypter(char *buffer,size_t size, char cle_public[],size_t clepub,char cle_privee[],size_t clepriv){
    size_t i;
    for(i=0;i<size;i++){
        buffer[i]^=cle_public[i%clepub];
        buffer[i]^=cle_privee[i%clepriv];
    }
}
/**************************************************************/
/**              Fonction de déchiffrement                   **/
/**                                                          **/
/**************************************************************/
void decrypter(char *buffer,size_t size, char cle_public[],size_t clepub,char cle_privee[],size_t clepriv){
    size_t i;
    for(i=0;i<size;i++){
        buffer[i]^=cle_public[i%clepub];
        buffer[i]^=cle_privee[i%clepriv];
    }
}

/**************************************************************/
/**           Calcul de la taille d'un fichier               **/
/**           - si le fichier passé en argument est ouvert   **/
/**             le nom sera ignoré                           **/
/**                                                          **/
/**           - si le fichier passé en argument n'est pas    **/
/**             ouvert, le fichier portant le nom "nom"      **/
/**             sera ouvert afin de calculer sa taille       **/
/**             puis fermé.                                  **/
/**************************************************************/
size_t getFileSize(FILE *file,char *nom){   //retourne la taille d'un fichier
    int opened = 1;               //Fichier déjà ouvert par l'appleur
    if(!file){
        opened = 0;
        file = fopen(nom,"r");
        if(!file) return 0;
    }
    fpos_t posInitiale;
    size_t fileSize;
    fgetpos(file,&posInitiale);   //sauvegarde de la position actuelle
    fseek(file,0,SEEK_SET);       //début du flux
    fseek(file,0,SEEK_END);       //Fin du flux
    fileSize = ftell(file);       //Position actuelle
    fsetpos(file,&posInitiale);   //remise en position
    if(opened == 0)
        fclose(file);
    return fileSize;              //retour de la position de fin ( en octets )
}

Edit : rajout de fonction.

Objectif Zéro Bug - le test logiciel professionnel | L'électronique de zéro | Tableaux & pointeurs | Pointeurs sur fonctions | Lecture/écriture binaire

IATGOF

17 octobre 2010 à 14:59:57

Exercice 3 :

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

#define BUFSZ 512

void crypt(void *buf, size_t size, void *key, size_t keysize, int *j)
{
    unsigned char *cbuf = buf, *ckey = key;
    size_t i;

    for (i = 0; i < size; i++)
    {
        cbuf[i] ^= ckey[(*j)++];
        if (*j >= keysize)
            *j = 0;
    }
}

int crypt_files(char *src_fname, char *dest_fname, char *key, int decrypt)
{
    FILE *src, *dest;
    unsigned char buf[BUFSZ];
    size_t keysize, nread;
    unsigned long total = 0;
    int key_index = 0;

    const char *method = decrypt ? "Dechiffrage" : "Chiffrage";

    if (!(src = fopen(src_fname, "rb")))
        exit(printf("Impossible d'ouvrir %s\n", src_fname) & 0);
    if (!(dest = fopen(dest_fname, "wb+")))
        exit(printf("Impossible d'ouvrir %s\n", dest_fname) & 0);

    printf("%s de %s en %s...\n", method, src_fname, dest_fname);

    keysize = strlen(key);
    while (!feof(src))
    {
        nread = fread(buf, 1, BUFSZ, src);
        total += nread;

        if (ferror(src))
            exit(printf("Une erreur est survenue pendant le %s de %s", method, src_fname) & 0);

        crypt(buf, nread, key, keysize, &key_index);
        if (nread != fwrite(buf, 1, nread, dest))
            exit(printf("Une erreur est survenue pendant le %s de %s", method, src_fname) & 0);
    }

    printf("%lu %s.\n", total, total > 1 ? "bytes lus" : "byte lu");

    fclose(src);
    fclose(dest);

    printf("%s reussi.\n", method);

    return 0;
}

static int help(char *pname)
{
    printf("usage: %s -c source destination cle\n"
           "       %s -d source destination cle\n", pname, pname);
    return 0;
}

int main(int ac, char **av)
{
    if ((ac == 5) && (!strcmp(av[1], "-c") || !strcmp(av[1], "-d")))
        return crypt_files(av[2], av[3], av[4], !strcmp(av[1], "-d"));

    return help(*av);
}

@che

17 octobre 2010 à 15:21:18

L'exercice 3:

#include <stdio.h>
#include <string.h>

int main (int argc, char *argv[])
{
    FILE* fichier = NULL;
    FILE* fichier2 = NULL;
    char* mdp = argv[3];

    fichier = fopen(argv[1],"r");
    fichier2 = fopen(argv[2],"w");

    int size = strlen(mdp), car = fgetc(fichier), i;

    for(i = 0;car != EOF;i++)
    {
        fputc(car^mdp[(i<size)?i:(i=0)],fichier2);
        car = fgetc(fichier);
    }
    
    fclose(fichier2);
    fclose(fichier);

    getchar();
    return 0;
}

Ouais je sais je suis partisan du moindre effort moins y a de caractères a tapez mieux c'est

🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles - ♡ Copying is an act of love.

IATGOF

17 octobre 2010 à 15:30:35

char car = ' ';
car = fgetc(fichier);
for(int i = 0;car != EOF;i++)

Ce que tu fais là est faux et je ne pense pas que ça fonctionne correctement lors du déchiffrage d'un fichier.

Citation : man fgetc

fgetc() reads the next character from stream and returns it as an
unsigned char cast to an int, or EOF on end of file or error.

@che

17 octobre 2010 à 15:37:21

Le compilateur ne m'a pas averti mais en effet il devrais être un int.

Cela n'a pas d'importance ici, ça marche tant pour fgetc que pour fputc pour le chiffrage et le déchiffrage.

Le c de fgetc m'a induit en erreur. Je vais tout de même corrigé car c'est bien une erreur.

🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles - ♡ Copying is an act of love.

Yshelin

17 octobre 2010 à 16:54:42

B'soir à tous !

Bon, cet exercice étant sympa, j'ai voulu essayer de le faire.
J'en suis au 2°), mais je crois que j'ai un peu trafiqué l'énoncé :-°

...

Voilà mon code :

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

int main (int argc, const char * argv[]) {
	int i = 0, key = 141;
	int crypt[10000] = {0};
	char uncrypt[10000] = "", title[100] = "";
	
	printf("\nTitle :\t");
	fgets(title, sizeof(title), stdin);
	printf("\nText :\n\t");
	fgets(uncrypt, sizeof(uncrypt), stdin);
	int lenght = strlen(uncrypt);
	
	for (i = 0; i <= lenght; i++)
	{
		crypt[i] = uncrypt[i]^key;
	}
	
	FILE* fichier = NULL;
	fichier = fopen(title, "w+");
	for(i = 0; i <= lenght; i++)
	{
		fprintf(fichier, "%.2x\n", crypt[i]);
	}
	
	
	fclose(fichier);
	
	    return 0;
}

Pour l'instant pas de fonction ni rien, j'essaye d'y arriver d'abord.
Voilà le problème : je demande à l'utilisateur un titre, puis du texte.
Avec le titre, je crée un fichier texte et à l'intérieur de ce fichier, je place le texte codé :

crypt[i] = uncrypt[i]^key

J'ai donc sur chaque ligne de mon fichier chaque caractère du texte de l'utilisateur codé. Par contre, je ne sais pas comment récupérer ces caractères pour ensuite les décoder... Quelqu'un pourrait-'il m'aider ?
Merci à tous !

PS : la clé est 141, j'ai mis ça au grand pif.

Yshelin

18 octobre 2010 à 18:19:31

Help !

Personne n'a d'idée, vraiment ?
J'ai mon tableau de int, je le copie dans le fichier .txt mais après si je récupère j'ai une chaîne de caractère... Et ça va plus pour retranscrire !
Quelqu'un sait comment réussir ? Ou comment procéder autrement ? Merci à tous

Tosh

18 octobre 2010 à 18:30:46

Passe par les fonctions d'écriture/lecture en mode binaire, avec fwrite/fread.
Ici, tu écris le caractère en valeur hexadécimale, hors il faut le stocker directement au format binaire si tu ne veux pas t'embêter avec des conversions inutiles.

Et pourquoi utilise-tu un tableau d'int ? Un tableau de char n'irait pas ?

Yshelin

18 octobre 2010 à 18:41:01

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 :-°

Tosh

18 octobre 2010 à 18:47:25

Le binaire, c'est juste une représentation. 'b' est déjà égaie à 1001011 (je dis aussi au pif), pas besoin de faire quelque chose d'autre.

Pour les prototypes, je te laisse chercher sur le man.

Yshelin

18 octobre 2010 à 21:22:25

Mmh, j'ai cherché sur pas mal de trucs, et ça à rien donné de bon

!
Avec fwrite, on peut écrire sur un fichier .txt ? Mmh...
Et sinon, tu pourrais m'orienter un peu sur cette fonction bizarre particulière

? (bien qu'elle soit totalement normale, j'avais envie de mettre ça !)

Merci bien

quentin-fait-du-c

18 octobre 2010 à 21:29:46

Salut, j'ai pas vraiment respecté les prérogatives de sortie, mais j'ai un souci.
J'ai fait mon code (simpliste), et quand je vois vos codes à vous, j'ai peur °_°

Est-ce que vous pouvez m'expliquer comment ça se fait que j'ai l'impression de m'être planté?

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

#define TYP_LEN 50

unsigned char XOR(unsigned char letter, unsigned char key)
{
    return letter^key;
}

int main()
{
    int i=0, j=0;
    unsigned char xor_key=0x1a;
    unsigned char sentence[TYP_LEN]={0};
    unsigned char crypt_sentence[TYP_LEN]={0};


    printf("Entrez une phrase : ");
    fgets((char*)sentence,TYP_LEN,stdin); //Trouve-t-on un moyen moins moche pour que 
                                          //le param de fgets soit accepté?

    for(i=0;i<TYP_LEN && sentence[i]!='\n';++i)
        crypt_sentence[i]=XOR(sentence[i],xor_key);

    for(j=0;j<i;++j)
        printf("%.2X ",sentence[j]);
    printf("\n\n");
    for(j=0;j<i;++j)
        printf("%.2X ",crypt_sentence[j]);
    printf("\n\n");



    return 0;
}

Tosh

18 octobre 2010 à 21:43:02

@IATOF : Pas grand chose à redire sur ton code.

@che : faire un code compact ne le rend pas meilleur...Mais sinon ça à l'air correct.

@Yshelin : Oui, tu peux utiliser fwrite pour écrire dans un fichier texte. Bon, après il sera sûrement illisible par un éditeur.

fwrite écrit des blocs d'octets dans un fichier passé en paramètre.

Son prototype est :

size_t fwrite (const void *ptr, size_t size, size_t nmemb, FILE *stream);

Le premier paramètre, c'est l'adresse du début du bloc. Par exemple, une chaîne de caractère.

Le deuxième paramètre, c'est la taille d'un bloc. Par exemple sizeof(char) pour un caractère.

Le troisième paramètre, c'est le nombre de bloc à écrire, par exemple la longueur de la chaîne.

Le dernier paramètre, c'est le fichier dans lequel écrire les données.

Pour écrire un caractère dans un fichier :

FILE *file;
char c = 'A';

/* Ouverture de file */

fwrite(&c, sizeof(char), 1, file);

En espérant t'avoir aidé.

EDIT :

@quentin-fait-du-c : Non, très bien ton code, mis à part que le prototype de main est :
int main(void) ou int main(int argc, char **argv)

Et personnellement, le cast ne me dérange pas.

quentin-fait-du-c

18 octobre 2010 à 21:56:37

Bon j'ai toujours pas compris les codes compliqués d'en haut, mais je me permet de vous soumettre celui-là, si je peux l'améliorer de quelque maniète que ce soit, je vous en prie, faites moi grandir

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

#define TYP_LEN 50

unsigned char XOR(unsigned char letter, unsigned char key)
{
    return letter^key;
}

int main()
{
    int i=0, j=0;
    unsigned char xor_key=0x1a;
    unsigned char sentence[TYP_LEN]={0};
    unsigned char crypt_sentence[TYP_LEN]={0};
    FILE *file_out=NULL;

    file_out=fopen("crypted.txt","w");

    printf("Entrez une phrase : ");
    fgets((char*)sentence,TYP_LEN,stdin);

    for(i=0;i<TYP_LEN && sentence[i]!='\n';++i)
        crypt_sentence[i]=XOR(sentence[i],xor_key);

    fprintf(file_out,"Uncrypted sentence :\n");

    for(j=0;j<i;++j)
        fprintf(file_out,"%.2X ",sentence[j]);

    fprintf(file_out,"\n\n");
    for(j=0;j<i;++j)
        fprintf(file_out,"%.2X ",crypt_sentence[j]);

    fclose(file_out);

    return 0;
}

Autre détail, j'ai trouvé sur le net que le ++i était plus rapide que le i++ (le bien nommé), si quelqu'un sait à quelle amplitude il est plus rapide et si ça sert vraiment, je suis toute ouïe

Anonyme

18 octobre 2010 à 22:35:35

J'en profite pour poster une version de mon code pour l'exercice 3 :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

void testDataIntegrity();
void initKey();
void writeToOpenedFile();

/* In this program, we assume the user has a brain. Oh, we don't anymore. */

int main (int argc, const char * argv[]) {
	const char *option = argv[1];
	const char *sourceFilePath = argv[2];
	const char *destinationFilePath = argv[3];
	char key[32];
	
	testDataIntegrity(option, sourceFilePath, destinationFilePath);
	initKey(key);
	
	if (!strcmp(option, "-c")) {
		FILE *sourceFile = fopen(sourceFilePath, "r");
		FILE *destinationFile = fopen(destinationFilePath, "w");
		fwrite(key, 1, 32, destinationFile);
		writeToOpenedFile(sourceFile, destinationFile, key);
		fclose(sourceFile);
		fclose(destinationFile);
	} else {
		FILE *sourceFile = fopen(sourceFilePath, "r");
		FILE *destinationFile = fopen(destinationFilePath, "w");
		fread(key, 1, 32, sourceFile);
		writeToOpenedFile(sourceFile, destinationFile, key);
		fclose(sourceFile);
		fclose(destinationFile);
	}

    return 0;
}

void testDataIntegrity(char *option, char *sourceFilePath, char *destinationFilePath) {
	FILE *file;
	if (strcmp(option, "-d") && strcmp(option, "-c")) {
		printf("Invalid option.\n");
		exit(0);
	}
	if (!sourceFilePath || !destinationFilePath) {
		printf("Invalid path.\n");
		exit(0);
	}
	if ((file = fopen(destinationFilePath, "r"))) {
		fclose(file);
		printf("Destination file already exists.\n");
		exit(0);
	}
}

void initKey(char key[]) {
	int iKey;
	srand(time(NULL));
	for (iKey = 0; iKey < 32; iKey++)
		key[iKey] = rand()%254+1;
}

void writeToOpenedFile(FILE *sourceFile, FILE *destinationFile, char *key) {
	int iKey = 0;
	char currentChar;
	while (fread(&currentChar, 1, 1, sourceFile)) {
		currentChar ^= key[iKey++];
		fwrite(&currentChar, 1, 1, destinationFile);
		if (iKey == 32)
			iKey = 0;
	}
}

@che

19 octobre 2010 à 2:00:00

Citation : Tosh

@che : faire un code compact ne le rend pas meilleur...Mais sinon ça à l'air correct.

Oui en effet

L'envi de faire moins de ligne. J'édite.

@ quentin-fait-du-c: je pense pas que la fonction XOR soit nécessaire et aussi une variable pour la clé est peut-être exagéré, aussi tu pourrais faire un seul tableau de char. Mais ton code est correcte, il fait ce que l'on veut et il n'a pas d'erreur.

🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles - ♡ Copying is an act of love.

1 2 >>

zCrypt

× 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.

zCrypt

Vos codes!

zCrypt

Supprimer

Modérer

Signaler le message aux modérateurs