Discussion :

[Clopinet85]

Bonsoir à tous;
Dans le cadre d'implémenter le DES, je vous sollicite pour le problème suivant:

Ayant le mot : char msg[8]; (composé de 64 bits donc), et voulant manipuler les bits de ce mots individuellement selon une fonction précise :

Code :

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

1
2
3
4
5
6
7
 
void InitPermut (char msg1[8], char R[4], char L[4]) {
int i;
static char output1[8];
 
for (i = 63; i >= 0 ; i--)
output1[IPDES[i]] = msg1[i];

et tel que:

Code :

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

int IPDES[64] = { 39, 7, 47, 15, 55, 23, 63, 31, 38, 6, 46, 14, 54, 22, 62, 30, 37, 5, 45, 13, 53, 21, 61, 29, 36, 4, 44, 1, 2, 52, 20, 60, 28, 35, 3, 43, 11, 51, 19, 59, 27, 34, 2, 42, 10, 50, 26, 33, 1, 41, 9, 39, 17, 57, 25, 32, 0, 40, 8, 48, 16, 56, 24 };

(les numéro représentent des numéros de bits)

oui je sais, y a un problème majeur là, d'où ma volonté de vouloir convertir le type char en type champs de bits, dans le but de manipuler individuellement des bits dans cette boucle.
Existe-t-il une autre solution pour contourner le problème?

Merci à vous de m'aider.

[ram-0000]

je serais toi, j'oublierais le champs de bits.

Je partirai plutôt sur une/des fonctions qui permettent de manipuler les bits.

Genre :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
int Get(const char msg[8], const unsigned int NoBit)
{
   ...
}
 
void Set(char msg[8], const unsigned int NoBit, const int Value)
{
   ...
}

Tu ne serais pas entrain d'implémenter l'algo DES ?

[Clopinet85]

Bonjour, merci de m'avoir répondu...

Je partirai plutôt sur une/des fonctions qui permettent de manipuler les bits.

Pouvez vous m'en dire plus sur cette fonction.....comment pourrais-je l'utiliser?

Tu ne serais pas entrain d'implémenter l'algo DES ?

si, c'est l cas!

j'attends vos suggestions, merci.

[droggo]

Lai,

Pouvez vous m'en dire plus sur cette fonction.....comment pourrais-je l'utiliser?

Retourne aux bases.

On ne se lance pas dans ce genre de code sans savoir manipuler les bits 1 à 1.

[Clopinet85]

finalement je vois de quelle fonction ram_0000 m parlait (c'est juste q j'ai l'habitude des opérateurs de manipulation de bits ).....je n vois tjrs pas comment ces fonctions peuvent m'être utiles ici.....

donc, est ce qu'il me serait possible de faire une conversion de type : type char à type champs de bits?

[Ozwald]

finalement je vois de quelle fonction ram_0000 m parlait (c'est juste q j'ai l'habitude des opérateurs de manipulation de bits ).....je n vois tjrs pas comment ces fonctions peuvent m'être utiles ici.....

Bah tu essaie de faire des permutations de bit visiblement, donc utiliser des fonctions de type "get" et "set" sur des bits me semble d'un usage plutôt immédiat, non ?

Code :

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

1
2
3
4
5
6
7
8
 
/* Exemple de permutation i<->j */
/* Attention : algo particulièrement sous optimal !!! */
i_bit=get(msg,i) /* mémorise le bit de ième position */
j_bit=get(msg,j) /* mémorise le bit de jème position */
 
set(msg,i,j_bit) /* écrit le bit qui était en "j" à la place "i" */
set(msg,j,i_bit) /* écrit le bit qui était en "i" à la place "j" */

Et voilà tu as fait une permutation...Plus qu'à en faire pleins d'autres pour obtenir ton DES

donc, est ce qu'il me serait possible de faire une conversion de type : type char à type champs de bits?

Oui c'est possible ( "tout est possible, tout est réalisable, c'est le jeu de la vie" ), mais ça reviendrait un peu au même que les "set" et les "get", juste que l'algo central serait un poils moins explicite à la re-lecture (puisqu'il ferait pleins de permutations sur des char...au lieu d'appeler pleins de fonction permutant des bits)

De toute façon ces conversions de bit à int ne seront pas très performantes (c'est le moins qu'on puisse dire).

En résumé : pour faire simple, lisible, et didactique la solution de ram_0000 semble la meilleure, mais pour faire rapide, moins lisible, et moins didactique, il faut sortir un papier un crayon de l'aspirine et les opérateurs bit à bit du C pour faire ta soupe en économisant au maximum les opérations .

Bon bien entendu tu as aussi des solutions intermédiaires, comme écrire directement une fonction de permutation sans séparer les "get" et les "set" dans des fonctions à part, ça donnerait un truc du genre :

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
 
void BitPermut (char msg1[8], int FirstBit, int SecondBit) {
    /* Permute deux bit dans msg1 */
    /* Attention : très sous optimal (et pas relu, ni même tenté de compilé :p ) */
 
    int fchar=FirstBit/8;
    int schar=SecondBit/8;
 
    char fbitmask=1;
    char sbitmask=1;
    int i;
    for(i=0;i<(FirstBit%8);i++)
        fbitmask*=2;
    for(i=0;i<(SecondBit%8);i++)
        sbitmask*=2;
 
    char f_Bit=msg1[fchar]&fbitmask; /* mémorisation du FirstBit */
    char s_Bit=msg1[schar]&sbitmask; /* mémorisation du SecondBit */
 
    msg1[fchar] &= ~fbitmask; /*Mise à zéro du FirstBit*/
    msg1[schar] &= ~sbitmask; /*Mise à zéro du SecondBit*/
 
    msg1[fchar] |= s_Bit; /* Ecriture dans le FirstBit du SecondBit*/
    msg1[schar] |= f_Bit; /* Ecriture dans le SecondBit du FirstBit */
}

Puis il te reste à appeler la fonction de permutation des bits autant de fois que tu veux et ton algo central sera bien lisible ...

Enfin bon si tu tiens à ton champs de bit je te laisse tenter d'écrire la fonction de conversion toi même en t'inspirant d'un peu tout ça, ça fera un bon exercice (poste ton code ici si jamais il ne fonctionne pas, on essaiera de t'aider)

[hartyshow]

Bonjour,

Un champ de bit est très utile pour ton cas. Moi j'utiliserai une union comprenant ton champ de bit et un char :

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
typedef struct
{
   unsigned Ren  : 1 ;
   unsigned Ifc  : 1 ;
   unsigned Srq  : 1 ;
   unsigned Eoi  : 1 ;
   unsigned Nrfd : 1 ;
   unsigned Ndac : 1 ;
   unsigned Dav  : 1 ;
   unsigned Atn  : 1 ;
} GpibBus_t ;
 
typedef union
{
   GpibBus_t Port ;
   unsigned char ValPort ;
} UnionGpibBus_t ;
 
UnionGpibBus_t ValLue ;
 
// Tu lis 
ValLue.ValPort  = 0x55 ;
 
// Tu décomutes
if(ValLue.Port.Nrfd == 1)
{ ... }

C'est simple et rapide
@+

[Clopinet85]

Bonsoir,
merci infiniment pour vos suggestions....j m'y mets tout de suite pour les essayer......et j reviens vous donner l résultat.

merci encore.

[diogene]

Bonjour,

Un champ de bit est très utile pour ton cas. Moi j'utiliserai une union comprenant ton champ de bit et un char :

...

C'est simple et rapide
@+

Mais, ce n'est pas portable.

[Clopinet85]

Bonjour à tous,

Je rappelle donc que mon but est d'arriver à manipuler les bits individuellement (grâce à une boucle), et que mon programme n'accepte que des mots de 64 bits en entrées. ( Il s'agit de l'implémentation du DES).

Voici ce à quoi j'ai pensé, dîtes moi s'il vous plait ce que vous en pensez :

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
void InitPermut (char msg1[8], char R[32], char L[32]) {
int   i, j, y ; 
static char a1, tab[64], output1[64], msg_tps[8];
 
for (x = 0; x < = 7 ; x ++)
msg_tps[x] = msg1[x];
 
y = 0;
for ( i = 0 ; i < = ; i + +) {
 
 for ( j = 0 ; j < = 7 ; j ++) {
a1 = msg1[i] & 2 puiss (7-j) ;  /* et binaire , avec 2 à la puissance (7-j) */
tab[j + y * 8] = a1 >> (7-j); 
msg1[i] = msg_tps[i]; }
 
y = y + 1 ;}
 
for (i = 63; i >= 0 ; i--)
output1[IPDES[i]] = tab[i];
 
for (i = 63; i >= 0; i--)  /* decoupage en L et R */
if (i >= 32)
R[i-32] = output1[i]; 
else
L[i] = output1[i];   }
}

en fait, j'ai pensé à utiliser des masques afin d'extraire chq bit de msg1 (qui contient 64 bits), et le mettre sur un octet (nouveau tableau de 64 octets)à part afin de le manipuler à l'aide d la boucle.

qu'en pensez-vous?

merci d'avance pour les réponses, ça m'aidera beaucoup....

Salutations.