Discussion :

[DJ Caësar 9114]

Bonjour à tous,
j'ai un petit problème.
je suis en train de faire un algorithme de cryptage. ce n'est pas mon premier j'avais déjà fait le SHA1. j'utilise la meme méthode pour faire le DES (data encryption standard).
A un moment donné je dois permuter les bits d'un mot de 64 bits. J'ai donc commencé par ce module, et j'ai écrit le code suivant:



mais malheur, lord de la compilation, mon gcc me sort: "incompatible types in return".
pourtant il ne me semble pas avoir fait d'erreur de transtypage...
quelqu'un peut-il m'aider?

je vous remercie

[Franck.H]

Salut, dans ta fonction permut, tu retourne une variable et non un pointeur alors que la fonction est censée retourner un pointeur sur __64bits tel que précisé dans sa signature

Par ailleurs, ton main n'est pas tout à fait correct, les deux signatures prises en charges par la norme sont:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
int main (void)
int main (int argc, char ** argv)

Et donc main retourne un entier alors soit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
return 0;
return EXIT_SUCCESS; /* avec stdlib.h. */

[DJ Caësar 9114]

ok, je comprends donc le problème mais je n'arrive pas à le résoudre....
si j'enlève l'étoile dans la signature ca ne marche pas non plus...

[Franck.H]

ok, je comprends donc le problème mais je n'arrive pas à le résoudre....
si j'enlève l'étoile dans la signature ca ne marche pas non plus...

L'as-tu également fait dans le main dans l'appel de la fonction:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

__64bits *binaire_transforme;

D'ailleurs j'ai pû noter deux erreurs supplémentaires, ca se trouve dans tes printf, tu veux afficher une chaîne de caractères mais comme argument tu passes simplement en paramètre ton unio et non pas le membre étant un tableau de char !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 for (i=0;i<=63;i++) {
   printf("%s\n",permute.c);
   permute.l=permute.l|((bitabouger.l & a_chiffrer[i%8])<<IP[i]);
   bitabouger.l=bitabouger.l<<1;
   }

et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

printf("%s - %s\n", argv[1], binaire_transforme.c);

Si c'est bien ce que tu voulais faire

[Gruik]

Au fait, personnellement j'aurais preferé passer la structure __64bits en sortie, plutot que retourner un pointeur sur un objet interne (qui est ecrasé à chaque appel)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void permut(char a_chiffrer[], __64bits * sortie)
{
 __64bits bitabouger;
 bitabouger.l=1;
 sortie->l=0;
 for (i=0;i<=63;i++) {
   printf("%s\n",sortie->c);
   sortie->l=sortie->l|((bitabouger.l & a_chiffrer[i%8])<<IP[i]);
   bitabouger.l=bitabouger.l<<1;
   }
}
 
 
 
main(int argc, char *argv[])
{
__64bits binaire_transforme;
permut(argv[1], &binaire_transforme);
printf("%s - %s\n", argv[1], binaire_transforme.c);
}

[Emmanuel Delahaye]

mais malheur, lord de la compilation, mon gcc me sort: "incompatible types in return".
pourtant il ne me semble pas avoir fait d'erreur de transtypage...
quelqu'un peut-il m'aider?

Ceci a de meilleures chances de fonctionner :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
#include <stdio.h>
 
typedef union
{
   unsigned long long l;
   char c[8];
}
i64_u;
 
unsigned char IP[64] = {
   58, 50, 42, 34, 26, 18, 10, 2,
   60, 52, 44, 36, 28, 20, 12, 4,
   62, 54, 46, 38, 30, 22, 14, 6,
   64, 56, 48, 40, 32, 24, 16, 8,
   57, 49, 41, 33, 25, 17, 9, 1,
   59, 51, 43, 35, 27, 19, 11, 3,
   61, 53, 45, 37, 29, 21, 13, 5,
   63, 55, 47, 39, 31, 23, 15, 7,
};
 
void permut (char a_chiffrer[], i64_u * p_permute)
{
   i64_u bitabouger;
int i;
   bitabouger.l = 1;
   p_permute->l = 0;
   for (i = 0; i <= 63; i++)
   {
      p_permute->l =
         p_permute->l | ((bitabouger.l & a_chiffrer[i % 8]) << IP[i]);
      bitabouger.l = bitabouger.l << 1;
   }
}
 
int main (int argc, char *argv[])
{
   if (argc > 1)
   {
      i64_u binaire_transforme;
 
      permut (argv[1], &binaire_transforme);
      printf ("%s - ", argv[1]);
      {
         int i;
         for (i = 0; i < 8; i++)
         {
            printf ("%02X ", (unsigned char)binaire_transforme.c[i]);
         }
         printf ("\n");
      }
   }
   return 0;
}

Attention il n'est pas garanti que unsigned long long fasse exactement 64 bits...

Pose des questions si tu ne comprends pas.

[DJ Caësar 9114]

Bonjour à tous,

tout d'abord merci de votre aide, cette histoire de pointeurs est réglée.
Cependant, l'algorithme ne fait pas exactement ce que je veux.
par exemple quand en entrée je mets "12345678", ce qui me donne "31 32 33 34 35 36 37 38" en hexa, en sortie d'algo j'obtiens "00 00 80 40 00 00 08 04", comme pour plusieurs autres entrées...
Est-ce que celà proviendrait d'une mauvaise utilisation des opérateurs bit à bit? Car il me semble que c'est algorithmiquement juste.

Je reviendrai en soirée je continue à y réfléchir cet après midi et je poste la solution si je trouve!

[Emmanuel Delahaye]

Cependant, l'algorithme ne fait pas exactement ce que je veux.
par exemple quand en entrée je mets "12345678", ce qui me donne "31 32 33 34 35 36 37 38" en hexa, en sortie d'algo j'obtiens "00 00 80 40 00 00 08 04", comme pour plusieurs autres entrées...
Est-ce que celà proviendrait d'une mauvaise utilisation des opérateurs bit à bit?

C'est possible. Tu veux faire quoi exactement ?
EDIT:

permuter les bits d'un mot de 64 bits

Ca veut dire que

8000 0000 0000 0000 devient 0000 0000 0000 0001 ?

Si c'est le cas, je propose ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
#include <stdio.h>
 
#ifdef WIN32
#define LL "I64"
#else
#define LL "ll"
#endif
 
/* 0 | 1 */
#define DBG 1
 
unsigned long long permut64 (unsigned long long n)
{
   unsigned long long perm = 0;
   unsigned long long msk = 1ull << 63;
   int i = 0;
   while (msk != 0)
   {
      unsigned long long bit = !!(n & msk);
      if (bit)
      {
         perm |= (bit << i);
      }
#if DBG
      printf ("%016" LL "X %016" LL "X %d\n", perm, msk, (int) bit);
#endif
      msk >>= 1ull;
      i++;
   }
   return perm;
}
 
int main (void)
{
   unsigned long long n = 0x8000000000000002ull;
   unsigned long long np = permut64 (n);
 
   if (np == 0x4000000000000001ull)
   {
      puts ("OK");
   }
   else
   {
      printf ("%016" LL "X\n", np);
   }
 
   return 0;
}

[DJ Caësar 9114]

Ca veut dire que

8000 0000 0000 0000 devient 0000 0000 0000 0001 ?

en fait, ca veut dire que le i-ème bit du mot de 64 bits se retrouve au IP[i]-ème bit du mot transformé.

il faut que je configure mon accès internet sous linux, je ne peux rien tester maintenant je le fais demain

merci

[Emmanuel Delahaye]

en fait, ca veut dire que le i-ème bit du mot de 64 bits se retrouve au IP[i]-ème bit du mot transformé.

Ah, OK. Le tableau sert au transcodage. C'est tout simple en fait.