Annonce

Réduire
Aucune annonce.

[projet] Chiffre de Vigenère

Réduire
X
Réduire
 
  • Page sur 1
  • Filtre
  • Heure
  • Afficher
Tout nettoyer
nouveaux messages
Précédent template Suivante
  • #1

    [projet] Chiffre de Vigenère

    Bonjour à tous,

    J'ai lu quelques articles sur la cryptologie, et le chiffre de Vigenère me semble être un bon début

    pour s'initier dans la crypto'. J'ai donc pour projet d'implémenter cette manière de crypté en C. Je ne sais pas si c'est

    le meilleur langage pour faire cela, je sais seulement que je suis capable de le faire en C.

    Voici comment le programme devrait se comporté :

    Chiffre de Vigenère :

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

char* inUpperCase(const char chaine[]) {

    char  alphabet[26]  = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',0};
    char  alphabet0[26] = {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',0};
    char     cache[100] = {0};
    int               i = 0;
    int               j = 0;
    int          trouve = 0;

    for(i=0;i<strlen(chaine);i++){
        for(j=0;i<strlen(alphabet) && !trouve;j++) {
            if(chaine[i] == alphabet[j])
            {
                cache[i] = alphabet0[j];
                trouve = 1;
            }
            else
            {
                cache[i] = chaine[i];
            }
        }
        trouve = 0;
    }
    return cache;
}

int main()
{
    char  alphabet0[26]  = {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',0};
    char  alphabet1[26]  = {'B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A',0};
    char  alphabet2[26]  = {'C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B',0};
    char  alphabet3[26]  = {'D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C',0};
    char  alphabet4[26]  = {'E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D',0};
    char  alphabet5[26]  = {'F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E',0};
    char  alphabet6[26]  = {'G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F',0};
    char  alphabet7[26]  = {'H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G',0};
    char  alphabet8[26]  = {'I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H',0};
    char  alphabet9[26]  = {'J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I',0};
    char  alphabet10[26] = {'K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J',0};
    char  alphabet11[26] = {'L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K',0};
    char  alphabet12[26] = {'M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L',0};
    char  alphabet13[26] = {'N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M',0};
    char  alphabet14[26] = {'O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N',0};
    char  alphabet15[26] = {'P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O',0};
    char  alphabet16[26] = {'Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P',0};
    char  alphabet17[26] = {'R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q',0};
    char  alphabet18[26] = {'S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R',0};
    char  alphabet19[26] = {'T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S',0};
    char  alphabet20[26] = {'U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T',0};
    char  alphabet21[26] = {'V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U',0};
    char  alphabet22[26] = {'W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V',0};
    char  alphabet23[26] = {'X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W',0};
    char  alphabet24[26] = {'Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X',0};
    char  alphabet25[26] = {'Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y',0};

    printf("%s",inUpperCase("rouge"));


    return 0;
}
    Le code n'est surement pas optimisé cependant c'est une bonne base pour commencé.

    Le principe du chiffre de Vigenère est le suivant :

    Vous avez 26 alphabets différents sachant qu'elles suivent une même logique, chaque alphabet est décalée de une lettre par rapport à

    la précédente, c'est tout se qu'il faudra retenir.

    Il faudra ensuite choisir un mot clé, secret. Prenons par exemple le mot "salut".

    Il faudra ensuite choisir le message à chiffré, prenons "Bonjour".

    Voici le fonctionnement du chiffre de Vigenère :

    ________________________
    SALUTSALUT
    Bonjour

    SALUTSALUTSALUTSALUTSALUT
    Bonjour comment vas tu
    _________________________

    Nous écrivons le mot secret autant de fois que nécessaire au-dessus du texte à crypté jusqu'à se qu'il n'y est plus de lettre du message à

    crypté sans une autre au-dessus. Ici nous devrons donc écrire deux fois "salut" pour "couvrir" le message "bonjour".

    Ensuite, il faudra aller chercher dans le Carré de Vigenère (nom que l'on donne à la représentation des 26 alphabets) le chiffrement à

    appliqué à la lettre, la première lettre à chiffrée est "b", et la lettre du mot secret qui lui correspond est S, nous allons donc dans le

    carré de Vigenère à l'alphabet qui commencera par S, vous pouvez trouver un carré de Vigenère facilement sur Google.

    Lorsque vous avez repéré cet alphabet, prenez le "b" de l'alphabet en clair( l'alphabet non décalé) et regarder à quoi il correspond.

    Notre "b" correspond à un "T". Faisons de même pour la deuxième lettre "o", la lettre du mot secret qui lui correspond est "A", ici vous

    l'aurez compris la lettre ne changera pas. Passons maintenant à la troisième lettre "n", la lettre du mot secret lui correspondant est "L",

    On va donc chercher l'alphabet qui commencera par "L" dans le carré de Vigenère, lorsqu'on a trouvé cet alphabet, prenez le "n" de

    l'alphabet en clair, et regardez à quoi il correspond dans l'alphabet commençant par "L", le "n" correspond à "Y" dans l'alphabet

    qui commence par "L".

    Au final on obtiendra le message crypté suivant : TOYDHMR pour le message : "bonjour"

    Le code que j'ai joint au poste n'est qu'une partie du code final, il permet juste de répondre aux deux questions qui me préoccupées le plus,

    Faut-il générer les tables ou directement les inclures dans le programme ?

    Comment doit-on traiter le cas où l'utilisateur n'entre pas un mot clé en majuscule ?

    Il faudra ajouter à ce code une interface pour l'utilisateur, la génération du message crypté et vos propres améliorations !
    Dernière modification par shirocen, 17 mai 2015, 13h00.
    deux et deux font cinq
    Tags: chiffre, projet, vigenè
  • #2
    Pour l'alphabet teste ce code

    Code:
    #include <stdio.h>

int main(void)
{
    char alphabet[27];

    int i;
    for (i=0; i<26; i++)
        alphabet[i] = 65+i;

    alphabet[i] = '\0';

    printf("%s\n", alphabet);

    return 0;
}
    Faut-il générer les tables ou directement les inclures dans le programme ?
    Les générer !

    Du coup essayes de faire une fonction qui te permet de générer selon un décalage toutes les lettres de l'alphabet représentant tes alphabetn...

    Pour t'aider voici un bout de code à compléter, essayes d'avoir une réflexion sur papier, te donnant un algorithme que tu pourras utiliser par la suite dans ton code C

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

char *alphabet(int decalage);

int main(void)
{
    char *alpha = alphabet(2);

    printf("%s\n", alpha); /* doit donner CDEFGHIJKLMNOPQRSTUVWXYZAB */

    free(alpha);

    return 0;
}

char *alphabet(int decalage)
{
    char *alpha = malloc(27); /* allocation en mémoire de 27 caractères dont le caractère de fin de chaîne '\0' */
    int i;
    char c; /* caractère qu'on placera dans le tableau alpha */

    for (i=0; i<26; i++)
    {
        /* à compléter en fonction de décalage, exemple décalage de 1 donne BCDEFGHIJKLMNOPQRSTUVWXYZA */
    }

    alpha[i] = '\0';

    return alpha;
}
    Comment doit-on traiter le cas où l'utilisateur n'entre pas un mot clé en majuscule ?
    Vérifier qu'on se trouve entre a-z et si c'est ok, transformer en majuscule avec toupper par exemple...

    Il faudra ajouter à ce code une interface pour l'utilisateur, la génération du message crypté et vos propres améliorations !
    Alors là clairement le C n'est pas ce qu'il te faut, dans ce cas faire une interface avec python par exemple et les calculs avec le C en utilisant cython par exemple, sinon bon amusement avec GTK+
    Dernière modification par fred, 18 mai 2015, 17h09.

    Commentaire

    • #3
      À moins que tu veuilles absolument travailler avec le carré de Vigenère, un algorithme simple avec de simples calculs basiques pourrait suffire.

      Code:
      def crypt(message, clef):
    
    resultat = ''
    longueur = len(clef)
    
    for ind, lettre in enumerate(message):
        code = ord(lettre)
        decalage = ord(clef[ind%longueur])-65
        lettre = chr(65+(code+decalage)%26)
        resultat += lettre
    
    return resultat

print(crypt("LEMESSAGEACRYPTER", "MACLEF"))
      C'est du python, mais c'est lisible même pour quelqu'un qui ne connaît pas le langage. Maintenant il ne reste plus qu'à le retranscrire en C...

      Commentaire

      • #4
        Voici le code "pseudo final", en effet j'ai encore un petit soucis avec la fonction conversionLettre :

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

void  inUpperCase(char chaine[]);
char* chiffrement(const char chaine[],const char cle[]);
char  conversionLettre(char lettre,char lettreCle);
char  *alphabet(char lettre);
int   indiceLettre(char lettre);

void inUpperCase(char chaine[]) {

    char  alphabet[26]  = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',0};
    char  alphabet0[26] = {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',0};
    int               i = 0;
    int               j = 0;
    int          trouve = 0;

    for(i=0;i<strlen(chaine);i++){
        for(j=0;i<strlen(alphabet) && !trouve;j++) {
            if(chaine[i] == alphabet[j])
            {
                chaine[i] = alphabet0[j];
                trouve = 1;
            }
            else
            {
                chaine[i] = chaine[i];
            }
        }
        trouve = 0;
    }
}

char* chiffrement(const char chaine[],const char cle[]) {

	char messageChiffre[100] = {0};
					   int i = 0;
					   int j = 0;
	for(i=0;i<strlen(chaine);i++,j++){
		if(j >= strlen(cle))
			j = 0;
		messageChiffre[i] = conversionLettre(chaine[i],cle[j]);
	}

	return messageChiffre;
}

char conversionLettre(char lettre,char lettreCle) {

	char *alphabetCrypt = alphabet(lettreCle);

    return alphabetCrypt[indiceLettre(lettre)];

}

char *alphabet(char lettre) {

    char  alphabet0[26]  = {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',0};
    char  alphabet1[26]  = {'B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A',0};
    char  alphabet2[26]  = {'C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B',0};
    char  alphabet3[26]  = {'D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C',0};
    char  alphabet4[26]  = {'E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D',0};
    char  alphabet5[26]  = {'F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E',0};
    char  alphabet6[26]  = {'G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F',0};
    char  alphabet7[26]  = {'H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G',0};
    char  alphabet8[26]  = {'I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H',0};
    char  alphabet9[26]  = {'J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I',0};
    char  alphabet10[26] = {'K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J',0};
    char  alphabet11[26] = {'L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K',0};
    char  alphabet12[26] = {'M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L',0};
    char  alphabet13[26] = {'N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M',0};
    char  alphabet14[26] = {'O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N',0};
    char  alphabet15[26] = {'P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O',0};
    char  alphabet16[26] = {'Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P',0};
    char  alphabet17[26] = {'R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q',0};
    char  alphabet18[26] = {'S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R',0};
    char  alphabet19[26] = {'T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S',0};
    char  alphabet20[26] = {'U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T',0};
    char  alphabet21[26] = {'V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U',0};
    char  alphabet22[26] = {'W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V',0};
    char  alphabet23[26] = {'X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W',0};
    char  alphabet24[26] = {'Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X',0};
    char  alphabet25[26] = {'Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y',0};

	switch(lettre)
	{
		case 'A': return alphabet0;
				  break;
		case 'B': return alphabet1;
				  break;
		case 'C': return alphabet2;
				  break;
		case 'D': return alphabet3;
				  break;
		case 'E': return alphabet4;
				  break;
		case 'F': return alphabet5;
				  break;
		case 'G': return alphabet6;
				  break;
		case 'H': return alphabet7;
				  break;
		case 'I': return alphabet8;
				  break;
	        case 'J': return alphabet9;
				  break;
		case 'K': return alphabet10;
				  break;
		case 'L': return alphabet11;
				  break;
		case 'M': return alphabet12;
				  break;
		case 'N': return alphabet13;
				  break;
		case 'O': return alphabet14;
				  break;
		case 'P': return alphabet15;
				  break;
		case 'Q': return alphabet16;
				  break;
		case 'R': return alphabet17;
				  break;
		case 'S': return alphabet18;
				  break;
		case 'T': return alphabet19;
				  break;
		case 'U': return alphabet20;
				  break;
		case 'V': return alphabet21;
				  break;
		case 'W': return alphabet22;
				  break;
		case 'X': return alphabet23;
				  break;
		case 'Y': return alphabet24;
				  break;
                case 'Z': return alphabet25;
				  break;
		default : return -1;
	}
}

int indiceLettre(char lettre) {

	switch(lettre)
	{
		case 'A':0;
				  break;
		case 'B': return 1;
				  break;
		case 'C': return 2;
				  break;
		case 'D': return 3;
				  break;
		case 'E': return 4;
				  break;
		case 'F': return 5;
				  break;
		case 'G': return 6;
				  break;
		case 'H': return 7;
				  break;
		case 'I': return 8;
				  break;
	        case 'J': return 9;
				  break;
		case 'K': return 10;
				  break;
		case 'L': return 11;
				  break;
		case 'M': return 12;
				  break;
		case 'N': return 13;
				  break;
		case 'O': return 14;
				  break;
		case 'P': return 15;
				  break;
		case 'Q': return 16;
				  break;
		case 'R': return 17;
				  break;
		case 'S': return 18;
				  break;
		case 'T': return 19;
				  break;
		case 'U': return 20;
				  break;
		case 'V': return 21;
				  break;
		case 'W': return 22;
				  break;
		case 'X': return 23;
				  break;
		case 'Y': return 24;
				  break;
                case 'Z': return 25;
				  break;
		default : return -1;
	}


}

int main()
{
	char      motcle[50] = {0};
        char    message[100] = {0};


	printf("Entrez le mot cle pour crypter votre message : ");
	scanf("%s",motcle);
	inUpperCase(motcle);
	printf("\n Entrez le message à codé");
	scanf("%s",message);
	printf("\n\nVotre message codé est : %s \n\n",chiffrement(message,motcle));


    return 0;
}
        Ce code n'est VRAIMENT PAS optimisé, c'est simplement le raisonnement que j'ai eu pour l'implémenter en C,

        sachant qu'il serait plus judicieux d'écrire celui-ci en Python comme Fred' l'a démontré dans un post précédent.
        Dernière modification par shirocen, 23 mai 2015, 06h23.
        deux et deux font cinq

        Commentaire

        • #5
          Eh bien ouf !

          En fait faut savoir qu'il faut se méfier des langages interprétés, car même si le code est plus court, et semble plus optimisé, c'est pas forcément plus rapide, mais... il y a un mais ! C'est que les langages interprétés se prêtent facilement aux interfaçages avec le C/C++/... et donc pour des grosses puissances de calculs demandés, on arrive à des codes python plus rapide que le C, et en fait le langage ne s'appelle plus python mais cython, ça crée du code C qui permet ensuite de créer par compilation une librairie pour python.

          À moins de coder du feu de Dieu en C, les codes générés avec cython sont ultra optimisé pour la performance, ce qui rend difficile la concurrence entre le codeur lambda en C et cython.

          Les switch sont contre performants, car la logique veut que les tests soient fait pour chaque tour de boucle, mais dans notre cas, on s'en fou en fait, car Vigenère ne demande pas du tout de performance...

          Je ferais le code en cython, pour le plaisir, parce-que j'adore ce concept, qui pour moi est la meilleure invention pour faire du C avec mon langage préféré ! Il existe aussi l'API C plus complexe, voir plus que le C lui même, pour créer des librairies python optimisées, mais malgré que l'interfaçage est de plus bas niveau, il y a d'énormes chances de faire des fuites mémoires, voir se planter tout court ! Peut-être que je le ferais mais là ça me motive moins, beaucoup moins car c'est assez prenant niveau concentration.

          Bref, ici je ne pense pas que le C, soit la meilleure solution, et j'aurais préféré voir un code cython, voir C++ qui avec les vector, rendra l'exercice d'une simplicité enfantine !

          Il faut savoir adapté le langage à la problématique, et pour Vigenère, le C n'est pas le langage adapté, mais cela tu le sais car dans ton 1er post, tu le dis toi même !

          Voici le code en cython, on voit qu'il y a des ressemblances avec le C, mais aussi python

          Code:
          from libc.stdlib cimport malloc, free
from libc.string cimport strlen
from cpython.bytes cimport PyBytes_FromString

cdef char *crypt_C(char *message, char *clef):
    cdef size_t length = strlen(clef)
    cdef size_t length_message = strlen(message)
    cdef char *resultat = <char *>malloc(length_message * sizeof(char))
    cdef int decalage, i = 0
    cdef char c, lettre
    
    while i < <int>length_message:
        c = message[i]
        decalage = clef[i%length] - 65
        lettre = 65 + (c+decalage)%26
        resultat[i] = lettre
        i += 1
    
    return resultat

def crypt(message, clef):
    cdef char *result = crypt_C(message, clef)
    res = PyBytes_FromString(result)
    free(result)
    return res
          Ensuite on teste comme un simple module python

          Code:
          >>> import myVigenere
>>> print(myVigenere.crypt(b"LEMESSAGEACRYPTER", b"MACLEF"))
b'KRBCJKZTTYTJXCICI'
          Voilà !
          Dernière modification par fred, 23 mai 2015, 11h43.

          Commentaire

          • #6
            *Surtout que mon code ne marche pas* !

            Je me donne les grandes vacances pour apprendre le python, je ne connaissais pas le concept de "cpython", on m'avait parlé du couple python/c mais je ne savais

            qu'on pouvait "convertir" du code !

            Je te remercie pour tes interventions qui me permettent d'avancer et de découvrir de nouvelles choses, j'ai beaucoup appris depuis que je suis ici,

            et je pense n'être encore qu'au début !
            deux et deux font cinq

            Commentaire

            • #7
              Je regarderais, mais vite fait comme cela je vois déjà une erreur, la fonction chiffrement retourne un tableau, hors c'est interdit en C !

              Tu dois absolument retourner un pointeur sur char, ce qui implique l'utilisation de malloc pour allouer dynamiquement, c'est un cours que je vais créer ces vacances scolaires... En attendant tu peux toujours l'étudier

              J'ai remodifié mon code, il est deux fois plus rapide,

              Code:
              from libc.string cimport strlen
from cpython.bytes cimport PyBytes_FromString

cpdef crypt(char *message, char *clef):
    
    cdef int decalage, i=0, length=strlen(clef), length_message=strlen(message)
    cdef char c, lettre
    
    while i < length_message:
        c = message[i]
        decalage = clef[i%length] - 65
        lettre = 65 + (c+decalage)%26
        message[i] = lettre
        i += 1
    
    return PyBytes_FromString(message)
              Dernière modification par fred, 23 mai 2015, 15h03.

              Commentaire

              • #8
                Salut, tu te complique bien la vie
                pour uppercase tu pourrais juste faire :
                Code:
                char Uperlettre= -'a'+'A'+Lowerlettre;
                Ainsi que pour la conversionLettre
                Code:
                char conversionLettre(char lettre,char lettreCle) {
	char c = 'A'+(lettrecle-'A' + lettre-'A')%26;
 	return c;
}
                Si je dis pas de connerie.
                Et quand tu utilises de nombreux tableaux comme tu fait pour tes alphabets, je te conseil de passer par des matrices.
                "Exeunt les délires de l'amour entés sur une pratique non maîtrisée du sexe. Exit derechef la passion voluptueuse qui fait voir l'être aimé toujours autre qu'il n'est et qui pousse à posséder ce qu'on ne peut pas posséder." Epicure

                Commentaire

                • #9
                  Pour uppercase, il faudra tout de même faire attention d'être entre a et z, du coup on a une fonction ressemblant à

                  Code:
                  char uppercase(char letter)
{
    char c;
    if (letter >= 97 && letter <= 122)
        c = 'A'-'a' + letter;
    else
        c = letter;

    return c;
}

                  Commentaire

                  • #10
                    Bonjour,

                    Les codes de chiffrements et de déchiffrements sont terminés, cependant j'aimerais réaliser une interface graphique pour que le programme soit un peu

                    plus "user-friendly", j'ai vu qu'il était possible de manipuler des GUI avec GTK/+ et SDL seulement la plupart des projets qui utilisent ces librairies sont

                    des jeux, j'aimerais juste créer une interface un peu plus évoluée que la console pour finalisé projet ?

                    Est-il possible de réaliser cela avec les libs' SDL / GTK ?
                    deux et deux font cinq

                    Commentaire

                    Précédent template Suivante
                    Projets
                    Cyprium
                    Blog
                    CTF Hackademics
                    Discord
                    Status
                    Mentions légales
                    Politique de confidentialité
                    Conditions générales d'utilisation (CGU)
                    Chargement...
                    X