déclaration de variables de 16, 32 et 128 bits

Version imprimable

27/12/2004, 22h35
samipate

déclaration de variables de 16, 32 et 128 bits

bonsoir
Je suis en train d'essayer de faire une implémentation de l'algo de chiffrfement IDEA en C++.
Mon problème est que je dois manipuler des blocs de 16,32 et 128 bits, mais je sais pas quel type de données utiliser pour mes variables pour être sur qu'ils auront exactement la taille que je veux quelle que soit la machine.

J'ai trouvé qu'il y avait des types Byte word et dword est t il possible de fixer leur taille en bits, et comment est ce que je dois les utiliser, mon compilateur C++ Builder 5 me donne une erreur.

Pour les types char et unsigned char, est ce qu'ils sont toujours défnis sur 8 bits quel que soit le compilateur et la machine?

Int => 32 bits?
short => 16 bits?

Merci de vos réponses.
28/12/2004, 09h53
onap

salut,avec borland tu as les type unsigned __int8, unsigned __int16 et unsigned __int32, pour plus de bit je ne sais pas.
28/12/2004, 17h58
SKZ81

int ne contient pas d'information de taille en lui-même, cela veut dire qu'elle est variable en fonction du compilo.

char -> 8bits
short int -> 16bits
long int -> 32bits
long long int -> 64bits

Je ne suis pas du tout sûr qu'il existe un type entier de 128bits.
Tu peux néanmoins définir une classe (une valeur codée sur plusieurs variables), de lui redéfinir les operator (=, +, *, etc...) utiles.
28/12/2004, 18h08
gege2061

Bonjour,
je propose une idée mais je n'ais aucune idée quand à sa faisabilité:
alloué un bloc de taille correspondante (en C j'utiliserai malloc mais là: : :?: ) et le remplir bit par bit (en espérant que tu n'est besoin que des valeur non signée sinon ça va être drole de jouer avec le complément à 1 :lol: ).

Bonne chance!
28/12/2004, 18h13
Laurent Gomila

Un char fera toujours un octet, tu peux l'utiliser comme brique de base pour faire des structures à taille fixe quelque soit l'architecture.
28/12/2004, 18h43
Selenite

Citation:

Envoyé par SKZ81

int ne contient pas d'information de taille en lui-même, cela veut dire qu'elle est variable en fonction du compilo.

char -> 8bits
short int -> 16bits
long int -> 32bits
long long int -> 64bits

Citation:

Envoyé par Loulou24

Un char fera toujours un octet, tu peux l'utiliser comme brique de base pour faire des structures à taille fixe quelque soit l'architecture.

Respectivement faux, et... faux ;-).

Un char fait toujours 1 byte. Mais qui a dit qu'un byte valait un octet ? Certainement pas la norme en tout cas, même si c'est vrai dans l'écrasante majorité des machines du monde. Par contre, la norme dit qu'il fait au moins 8 bits.

Quand aux plages de valeur, la norme dit ça:
sizeof char <= sizeof short int <= sizeof int <= sizeof long int

Si mes souvenirs sont bons, la norme dit aussi que short fait au moins 8bits, int au moins 16 et long au moins 32.

Quant à long long, ce n'est pas standard du tout.

Donc dur de faire un algo de chiffrement portable. C'est pour cela qu'il faudra supposer et essayer de prendre en compte le plus de cas possible avec le preprocesseur. (Sauf, évidemment, si la portabilité n'importe pas.)

Pour gérer les blocs de 128 bits, tu fera donc une structure contenant 4 int's par exemple. (Puisque sur la plupart des processeurs du monde, un int fait 32 bits.)
Je ne connait pas IDEA, mais à mon avis, il ne sera pas la peine d'implémenter les fonctions de calcul, même de base.

Tiens, voilà ce que fait SDL pour définir ses types xInty. Ce qui prouve que les considérations de Loulou24 et de SKZ91 sont en pratique vraie. Mais ce n'est pas portable 64 bits, dans ce cas.

Code:

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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2004 Sam Lantinga
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
    Sam Lantinga
    slouken@libsdl.org
*/
 
#ifdef SAVE_RCSID
static char rcsid =
 "@(#) $Id: SDL_types.h,v 1.11 2004/01/04 16:49:08 slouken Exp $";
#endif
 
/* General data types used by the SDL library */
 
#ifndef _SDL_types_h
#define _SDL_types_h
 
/* The number of elements in a table */
#define SDL_TABLESIZE(table)	(sizeof(table)/sizeof(table[0]))
 
/* Basic data types */
typedef enum {
	SDL_FALSE = 0,
	SDL_TRUE  = 1
} SDL_bool;
typedef unsigned char	Uint8;
typedef signed char	Sint8;
typedef unsigned short	Uint16;
typedef signed short	Sint16;
typedef unsigned int	Uint32;
typedef signed int	Sint32;
 
/* Figure out how to support 64-bit datatypes */
#if !defined(__STRICT_ANSI__)
#if defined(__GNUC__) || defined(__MWERKS__) || defined(__SUNPRO_C) || defined(__DECC)
#define SDL_HAS_64BIT_TYPE	long long
#elif defined(_MSC_VER) /* VC++ */
#define SDL_HAS_64BIT_TYPE	__int64
#endif
#endif /* !__STRICT_ANSI__ */
 
/* The 64-bit type isn't available on EPOC/Symbian OS */
#ifdef __SYMBIAN32__
#undef SDL_HAS_64BIT_TYPE
#endif
 
/* The 64-bit datatype isn't supported on all platforms */
#ifdef SDL_HAS_64BIT_TYPE
#ifndef H_MMBASIC
typedef unsigned SDL_HAS_64BIT_TYPE Uint64;
#endif
typedef SDL_HAS_64BIT_TYPE Sint64;
#else
/* This is really just a hack to prevent the compiler from complaining */
typedef struct {
	Uint32 hi;
	Uint32 lo;
} Uint64, Sint64;
#endif
 
/* Make sure the types really have the right sizes */
#define SDL_COMPILE_TIME_ASSERT(name, x)               \
       typedef int SDL_dummy_ ## name[(x) * 2 - 1]
 
SDL_COMPILE_TIME_ASSERT(uint8, sizeof(Uint8) == 1);
SDL_COMPILE_TIME_ASSERT(sint8, sizeof(Sint8) == 1);
SDL_COMPILE_TIME_ASSERT(uint16, sizeof(Uint16) == 2);
SDL_COMPILE_TIME_ASSERT(sint16, sizeof(Sint16) == 2);
SDL_COMPILE_TIME_ASSERT(uint32, sizeof(Uint32) == 4);
SDL_COMPILE_TIME_ASSERT(sint32, sizeof(Sint32) == 4);
SDL_COMPILE_TIME_ASSERT(uint64, sizeof(Uint64) == 8);
SDL_COMPILE_TIME_ASSERT(sint64, sizeof(Sint64) == 8);
 
/* Check to make sure enums are the size of ints, for structure packing.
   For both Watcom C/C++ and Borland C/C++ the compiler option that makes
   enums having the size of an int must be enabled.
   This is "-b" for Borland C/C++ and "-ei" for Watcom C/C++ (v11).
*/
/* Enable enums always int in CodeWarrior (for MPW use "-enum int") */
#ifdef __MWERKS__
#pragma enumsalwaysint on
#endif
 
typedef enum {
	DUMMY_ENUM_VALUE
} SDL_DUMMY_ENUM;
 
SDL_COMPILE_TIME_ASSERT(enum, sizeof(SDL_DUMMY_ENUM) == sizeof(int));
 
#undef SDL_COMPILE_TIME_ASSERT
 
/* General keyboard/mouse state definitions */
enum { SDL_PRESSED = 0x01, SDL_RELEASED = 0x00 };
 
#endif

29/12/2004, 14h04
SKZ81

Citation:

Envoyé par Selenite

Respectivement faux, et... faux ;-).

Un char fait toujours 1 byte.

Exact... Et autant pour moi :oops: Quoiqu'à ma décharge byte est quand même très souvent traduit par "octet"...
De la même manière qu'en pratique int a pour taille celle des registres du processeur (WORD) (donc 32 bits sur une majorité des machines actuelles (oublions les 64 pour encore 1/2 ans))
D'ailleurs méfiez vous dans vos codes, les jeux de caractères 16 bits risque de mettre à mal certains modules qui on assumé (quel anglicisme!) trop vite que sizeof(char)=1...
Je pense qu'en pratique, on va introduire un nouveau type pour gérer ça (si on ne l'encapsule pas dans des classes et définitivement aux oubliettes!!).

Et tout ça finira, j'en suis sûr, dans la norme, tout comme long long... :wink:

Implémentation

Bonsoir et merci de vos réponses.

Finalement, j'ai choisi d'utiliser comme base le type unsigned short qui sur machine fait 16 bits.
Pour la portabilité, il vaut mieux en effect avoir recours aux macros.

Voila mon code pour une fonction de genération de 52 clés de 16 bits à partir de la clé donnée par l'utilisateur qui est de 128 bits. Ces 52 clés sont obtenues par décalage de la clé initiale de 25 bits à chaque nouvelle itération.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 void generateKey(unsigned short *userKey, unsigned short *encryptionKey) { int i,j; for(i=0;i<8;i++) encryptionKey[i] = userKey[i]; for(j=8;j<52;j++) { if ((j%8)==0) encryptionKey[j] = (encryptionKey[j-2]<<7) | (encryptionKey[j-1]>>9); else if ((j%8)==1) encryptionKey[j] = (encryptionKey[j-2]<<7) | (encryptionKey[j-9]>>9); else encryptionKey[j] = (encryptionKey[j-10]<<7) | (encryptionKey[j-9]>>9); } }
Cependant j'ai trouvé un code sur inernet qui fait appremment la meme chose (sauf qu'il décale à gauche), mais j'ai pas bien compris son fonctionnement:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 static void en_key_idea(word16 *userkey, word16 *Z) { int i,j; /* shifts */ for (j=0;j<8;j++) Z[j]=*userkey++; for (i=0;j<KEYLEN;j++) { i++; Z[i+7]=((Z[i&7] << 9) | (Z[i+1 & 7] >> 7)); [color=green]//Pkoi utiliser un & au lieu du modulo?[/color] Z+=i&8; //? i&=7; //? } }
Merci

30/12/2004, 20h39
SKZ81

Re: Implémentation
Citation:

Envoyé par samipate

Z[i+7]=((Z[i&7] << 9) | (Z[i+1 & 7] >> 7)); //Pkoi utiliser un & au lieu du modulo?

Opération ET BINAIRE :
Code:

1 2 3 4 5 6 ABCD WXYZ (une variable écrite en binaire) & 0000 0111 (=7) --------- 0000 0XYZ
On récupère bien le reste...
En fait x % y équivaut à x & y si y est de la forme y=(2^n)-1

Citation:

Envoyé par samipate

Z+=i&8; //?

même chose, avec 0000 1000
Soit +=0 ou +=8 en fonction de la valeur de i

Citation:

Envoyé par samipate

i&=7; //?

i = i&7;

Par contre j'ai pas décortiquer l'algo, je vois donc pas PKOI on fait tout ça... Dzol...
30/12/2004, 22h33
samipate

Et une fonction qui fonctionne, une!!

Merci

J'ai enfin réussi à finir cette &#!@!!! de fonction de génération de clés, mais ce n'est qu'une partie de l'algo de chiffrement IDEA. Je risque fort d'avoir encore besoin de vos services! :)
(Au fait c pour un projet à la fac)

Pour ceux que IDEA interesse:
http://www.uqtr.ca/~delisle/Crypto/p...blocs_idea.php