Partage
  • Partager sur Facebook
  • Partager sur Twitter

zCrypt

Vos codes!

    19 octobre 2010 à 6:51:20

    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 ^^'
    • Partager sur Facebook
    • Partager sur Twitter
      19 octobre 2010 à 9:04:14

      Tu aurais pût utiliser une constante symbolique par exemple, elles servent à ça. :)
      • Partager sur Facebook
      • Partager sur Twitter
        19 octobre 2010 à 11:48:59

        Re-bonjour à tous !

        Merci Tosh pour tes indications, le debugeur ne me dit plus rien lorsque que j'utilise fwrite :D !
        Seulement... Y'a rien dans le fichier non plus :o ! Voici ce que j'utilise :
        for(j = 0; j <= lenght; ++j)
                fwrite(&crypt_text[i], sizeof(char), 1, file);
        


        Normalement, il devrait me mettre dans le fichier tous les caractères un à un de crypt_text, non ?
        Voici comment es rempli crypt_text :
        for(i = 0; i <= lenght; ++i)
                crypt_text[i] = uncrypt_text[i]^key;
        

        Pourquoi je n'ai rien dans mon fichier ?
        Merci :) !
        • Partager sur Facebook
        • Partager sur Twitter
          19 octobre 2010 à 12:09:21

          @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.
          • Partager sur Facebook
          • Partager sur Twitter
          🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
            19 octobre 2010 à 12:20:59

            Je ne lis pas un caractère de trop car
            lenght = strlen(uncrypt_text) - 1;
            

            C'est pour enlever le '\0' de fin de chaîne ;)
            • Partager sur Facebook
            • Partager sur Twitter
              19 octobre 2010 à 12:52:49

              Ouvre-tu bien ton fichier en écriture ?

              Sinon, tu peux tester le retour de fwrite. Si une taille plus petite à sizeof(char) est renvoyé, c'est qu'une erreur s'est produite.
              • Partager sur Facebook
              • Partager sur Twitter
                19 octobre 2010 à 13:04:29

                Voici mon code :

                #include <stdio.h>
                #include <stdlib.h>
                #include <string.h>
                
                
                int main(int argc, char **argv)
                {
                    int i = 0, j = 0, lenght = 0, test = 0;
                    unsigned char key = 0x1a;
                	unsigned char title[100] = {0};
                    unsigned char uncrypt_text[100000] = {0};
                    unsigned char crypt_text[100000] = {0};
                    FILE *file = NULL;
                	
                	printf("\nTitle :\t");
                	fgets(title, sizeof(title), stdin);
                	printf("\nText :\n\t");
                	fgets(uncrypt_text, sizeof(uncrypt_text), stdin);
                	lenght = strlen(uncrypt_text) - 1;
                	
                    for(i = 0; i <= lenght; ++i)
                        crypt_text[i] = uncrypt_text[i]^key;
                	
                	file = fopen(title,"w+");
                	for(j = 0; j < i; ++j)
                		test = fwrite(&crypt_text[i], sizeof(char), 1, file);
                	
                    fprintf(file,"Crypted text :\n");
                	
                    for(j = 0; j < i; ++j)
                        fprintf(file,"%.2X ",crypt_text[j]);
                	
                	fprintf(file, "\n\n");
                	
                
                    fclose(file);
                	printf("%d", test);
                    return 0;
                }
                


                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 ;) !
                • Partager sur Facebook
                • Partager sur Twitter
                  19 octobre 2010 à 13:42:14

                  Tu devrais nettoyer le '\n' du buffer title, mis par la fonction fgets().

                  Je te conseille aussi de tester le retour de fopen(), même si ici on dirait que ça fonctionne.

                  Et quand tu dis qu'il n'y a rien dedans, tu vérifie la taille ou tu tente de l'ouvrir avec un éditeur ?
                  • Partager sur Facebook
                  • Partager sur Twitter
                    19 octobre 2010 à 13:47:45

                    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. :(
                    • Partager sur Facebook
                    • Partager sur Twitter
                      19 octobre 2010 à 13:55:27

                      Chez moi, ça fonctionne, mais avant Crypted, c'est remplit d'octets nuls. (Tu peux le voir avec un éditeur héxadécimal)

                      Tu t'es trompé à la ligne :

                      test = fwrite(&crypt_text[i], sizeof(char), 1, file);
                      


                      Ce n'est pas l'indice i, mais j !

                      :)
                      • Partager sur Facebook
                      • Partager sur Twitter
                        19 octobre 2010 à 14:03:40

                        :lol::lol::lol:
                        La bonne blague ! En plus il s'avère que la plupart du temps c'est des bêtises pareils :p
                        Merci bien pour ta patience ! ;)
                        • Partager sur Facebook
                        • Partager sur Twitter
                          Staff 19 octobre 2010 à 20:02:35

                          Citation : Yshelin

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



                          Il y a un cours ici.

                          Edit :

                          Citation : @che

                          fputc(car^mdp[(i<size)?i:(i=0)],fichier2);
                          


                          Pourquoi pas :

                          fputc(car^mdp[i%size],fichier2);
                          
                          • Partager sur Facebook
                          • Partager sur Twitter
                            3 novembre 2010 à 22:04:10

                            Je remonte ce topic, si jamais il y a des débutants qui l'ont loupé et qui veulent essayer de résoudre l'exercice. :)

                            (Si personne ne se manifeste, je rédigerais une petite correction)
                            • Partager sur Facebook
                            • Partager sur Twitter
                              11 novembre 2010 à 16:51:41

                              Voilà mon code pour l'exercice 1 :

                              #include <stdio.h>
                              #include <stdlib.h>
                              #include <string.h>
                              
                              #define S_MAX   50
                              
                              void afficherHex(char * s, int sz) {
                                int i;
                                
                                if (sz <= 0)
                                  sz = strlen(s);
                                
                                for (i = 0; i <= sz; i++)
                                  printf("%.2X ", (unsigned char) s[i]);
                                puts("");
                              }
                              
                              int crypter(char * s, int cle) {
                                int i;
                                int sz = strlen(s);
                                
                                for (i = 0; i <= sz; i++)
                                  s[i] ^= (unsigned char) cle;
                                
                                return sz;
                              }
                              
                              int main(void) {
                                char s[S_MAX] = "";
                                int sz, cle;
                                
                                printf("Entrez la clé : ");
                                scanf("%i", &cle);
                                while (getchar() != '\n')
                                  ;
                                
                                printf("Entrez une chaîne : ");
                                fgets(s, S_MAX, stdin);
                                
                                printf("Cle : %#.2X\n", cle);
                                afficherHex(s, 0);
                                sz = crypter(s, cle);
                                afficherHex(s, sz);
                                return EXIT_SUCCESS;
                              }
                              

                              Entrez la clé : 0x0A
                              Entrez une chaîne : Je suis une chaine.
                              Cle : 0X0A
                              4A 65 20 73 75 69 73 20 75 6E 65 20 63 68 61 69 6E 65 2E 0A 00 
                              40 6F 2A 79 7F 63 79 2A 7F 64 6F 2A 69 62 6B 63 64 6F 24 00 0A
                              • Partager sur Facebook
                              • Partager sur Twitter
                                19 novembre 2010 à 19:12:09

                                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;
                                }
                                
                                • Partager sur Facebook
                                • Partager sur Twitter
                                  19 novembre 2010 à 20:38:56

                                  Merci Tosh!

                                  Par contre les exos en C, sont (encore) disparus des post-it... o_O
                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                  Zeste de Savoir, le site qui en a dans le citron !
                                    20 novembre 2010 à 13:34:21

                                    Citation : uknow


                                    Edit :

                                    Citation : @che

                                    fputc(car^mdp[(i<size)?i:(i=0)],fichier2);
                                    



                                    Pourquoi pas :

                                    fputc(car^mdp[i%size],fichier2);
                                    


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


                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                    🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
                                      10 décembre 2010 à 21:00:00

                                      Zscript - mon petit code ^^



                                      Bonjour,
                                      C'est la première fois que je viens sur ce topic.
                                      Pour tester j'ai coder Zscript :

                                      pour crypter un fichier :

                                      nom_du_prog.exe < fichier_a_crypter.txt >fichier_destionation.txt ( windows)

                                      le fichier doit avec la clé tout au début du fichier (première ligne) et tout ce qui commence à partir de la deuxième ligne va être crypté.
                                      exemple

                                      Citation : doc.txt

                                      salut
                                      test



                                      Salut va être la clé et test va être crypté.

                                      Code :

                                      #include <stdio.h>
                                      #include <stdlib.h>
                                      
                                      int main(void) {
                                          char *chaine2,caract;
                                          int *chaine_nbr,i,nbr_caract=0;
                                      
                                           chaine2 = (char*)calloc(100,sizeof(char));
                                           chaine_nbr = (int*)calloc(100,sizeof(int));
                                      
                                         fscanf(stdin,"%s",chaine2);
                                      
                                         caract = fgetc(stdin);
                                         for(i=0;caract != EOF;i++,nbr_caract++){
                                             chaine_nbr[i] = (int)caract ^ (char)chaine2;
                                             caract = fgetc(stdin);
                                         }
                                          printf("%s\n",chaine2);
                                          printf("%d\n",nbr_caract);
                                           for(i=0;i<100;i++){
                                            if(chaine_nbr[i] != 0)
                                              printf("%x\n",chaine_nbr[i]);
                                           }
                                      
                                        return 0;
                                      }
                                      


                                      Pour le décrypteur (je sais pas si ça se dit) :

                                      nom_du_prog.exe < fichier_a_décrypter.txt >fichier_destionation.txt ( windows)

                                      et le code :


                                      #include <stdio.h>
                                      #include <stdlib.h>
                                      
                                      int main(void) {
                                          int nbr_line,i,chiffre;
                                          char *chaine2;
                                      
                                          chaine2 = (char*)calloc(100,sizeof(char));
                                      
                                      fscanf(stdin,"%s",chaine2);
                                      fscanf(stdin,"%d",&nbr_line);
                                      
                                      printf("%s",chaine2);
                                      for(i=0;i<nbr_line;i++){
                                          fscanf(stdin,"%p",&chiffre);
                                          printf("%c",(char)chiffre ^ (char)chaine2);
                                      }
                                      
                                      return 0;
                                      }
                                      



                                      Exemple du programme :

                                      salut
                                      test


                                      va devenir :

                                      salut
                                      5
                                      ffffffc2
                                      ffffffbc
                                      ffffffad
                                      ffffffbb
                                      ffffffbc


                                      et décrypter ça donne:

                                      test


                                      Voilà c'est tout pour aujourd'hui

                                      Bonne journée
                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        10 décembre 2010 à 21:11:14

                                        Plusieurs remarques :

                                        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.

                                        Merci pour ta participation en tout cas ;) .
                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                          10 décembre 2010 à 21:23:55

                                          Citation : Tosh

                                          Pourquoi utiliser l'allocation dynamique ici ?
                                          Pourquoi utiliser fscanf à la place de scanf ?




                                          L'allocation dynamique c'est juste que j'ai pris l'habitude de le faire alors je change pas.

                                          J'utilise fscanf comme ça on peut crypter des fichiers grâce à :
                                          nom_du_prog.exe < fichier_a_décrypter.txt >fichier_destionation.txt ( windows)

                                          Pour les cast, je trouvais ça aussi bizarre mais bon ça fonctionnait alors j'ai pas chipoté.

                                          Ben en faite à chaque caractère je prends son code ascii et je fais un xor avec la clé.

                                          je l'enregistre dans le tableau de int.

                                          %p C'est pas en hexedécimal sur 8 bit ???
                                          • Partager sur Facebook
                                          • Partager sur Twitter

                                          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.
                                          • Editeur
                                          • Markdown