PROCEDE D'ENCODAGE DE DONNEES SUR UNE CARTE A PUCE PAR DES
CODES DE POIDS CONSTANT
DOMAINE DE L'INVENTION
Le domaine de l'invention est celui de l'encodage de données dans des cartes à puces, pour sécuriser leur utilisation ultérieure, notamment dans des applications de cryptographie.
ETAT DE LA TECHNIQUE
De nombreux composants électroniques, tels que par exemple des cartes à puces, mettent en œuvre des opérations de calcul ou de comparaison sur des données secrètes. Certaines applications de ces opérations sont par exemple des applications bancaires, des applications pour téléphonie mobile, etc.
Les opérations sur les données secrètes peuvent faire l'objet d'attaques pour déterminer lesdites données secrètes.
Certaines de ces attaques, dites « sides channels » en anglais ou encore attaques sur canaux cachés, consistent à étudier le comportement physique du composant électronique, notamment en termes de fuites électromagnétiques, ou encore en termes de variations de consommation électrique, ou de temps de réponse.
D'autres attaques, qualifiées d'attaques « par injection de fautes » ont également été développées, qui consistent en la corruption de certaines données utilisées lors d'un calcul mis en œuvre par le composant électronique pour obtenir les données secrètes. Ces attaques comprennent par exemple le bombardement du composant électronique par laser ou par lumière, la génération de champs électromagnétiques parasites, l'injection de pics de tension dans l'alimentation du composant, etc.
Pour contrer ces types d'attaques, il a été proposé d'ajouter aux données secrètes une valeur aléatoire, décorrélant ainsi les données utilisées de leur valeur d'origine. Cette méthode n'est pourtant pas pleinement efficace car il est possible, à partir de l'observation de plusieurs calculs successifs, de retrouver la donnée secrète d'origine.
Une autre proposition a consisté en l'encodage des données secrètes avec des codes dits « de poids constant », c'est-à-dire des codes associant à chaque donnée un mot de code présentant un poids de Hamming constant prédéterminé. Le poids de Hamming d'une série de bits est le nombre de bits à 1 de la série.
Grâce à cet encodage, toutes les données utilisées présentent le même poids de Hamming, ce qui permet de rendre également constant la consommation électrique du composant électronique lors de l'utilisation desdites données (la consommation électrique du composant dépend en effet du poids de Hamming des données utilisées). Le composant est donc protégé des attaques par canaux cachés.
De plus, il est possible de détecter une attaque par injection de faute si une donnée encodée présente un poids de Hamming différent du poids de Hamming prédéterminé.
Cependant, l'encodage par codes de poids constant ne permet pas actuellement de mettre en œuvre des opérations sur données encodées dans un composant électronique de faible mémoire tel qu'une carte à puce.
Par exemple, on connaît un encodage appelé Dual Rail, qui consiste à encoder un 0 par la combinaison 1 -0 et un 1 par la combinaison 0-1 . Ce procédé double donc la taille de la séquence de bits encodée par rapport à la donnée initiale, et la mise en œuvre d'opérations sur ces données encodées n'est pas possible sur une carte à puce car elle requiert trop de mémoire.
De même, on connaît du brevet FR2855286 un procédé de transmission de données encodées à l'aide de codes de poids constant, mais ce procédé ne permet pas la mise en œuvre d'opérations sur les données encodées, car ces opérations nécessiteraient encore trop de mémoire que la mémoire disponible dans une carte à puce.
PRESENTATION DE L'INVENTION
L'invention a pour but de remédier aux inconvénients de l'art antérieur mentionnés ci-avant, en proposant un procédé d'encodage de données limitant la taille des mots de code obtenus afin de permettre la mise en œuvre ultérieure de calculs à partir desdits mots de code sur un composant électronique de type carte à puce.
L'invention a également pour but de fournir un procédé d'encodage de données permettant de résister à des attaques de types à canaux cachés ou de détecter des attaques par injection de fautes. A cet égard, l'invention a pour objet un procédé de traitement de données comprenant l'encodage d'une pluralité de données de n bits en des mots de code présentant un poids de Hamming constant prédéfini,
le procédé étant caractérisé en ce qu'il comprend en outre la mise en œuvre d'opérations de chiffrement ou d'opérations arithmétiques sur le ou les mots de code obtenus, et en ce que l'encodage de chaque donnée comprend :
la décomposition de la donnée en une pluralité de m séquences de bits à coder, m étant strictement inférieur à n,
le codage de chaque séquence de bits en un mot de code partiel présentant chacun un poids de Hamming prédéfini, de sorte que la somme des poids de Hamming des mots de code partiels soit égale au poids de Hamming du mot de code, et
la concaténation des mots de code partiels pour obtenir le mot de code correspondant à la donnée. Avantageusement, mais facultativement, le procédé de traitement selon l'invention peut en outre comprendre au moins l'une des caractéristiques suivantes : la taille du mot de code obtenu est strictement inférieure à 2n bits.
la taille n des données est une puissance de 2 bits.
la taille des séquences de bits est une puissance de 2 bits.
- les données comprennent 4 bits, chaque donnée étant décomposée en une séquence de 3 bits, et une séquence d'un bit, la première séquence étant codée en un mot de code partiel de taille 5 bits et de poids de Hamming égal à 2 ou 3, et le bit restant étant codé en un mot de code partiel de taille 2 bits et de poids de Hamming égal à 1.
- les données comprennent 8 bits, le procédé comprenant la décomposition de chaque donnée en deux séquences de 4 bits, les deux séquences de 4 bits étant codées en deux mots de code partiels de 6 bits et de poids de
Hamming égal à 3.
L'encodage est mis en œuvre par une première unité de traitement, le procédé comprend en outre la transmission à la seconde unité de traitement d'au moins un mot de code obtenu à partir de la ou les données, et les opérations de chiffrement ou les opérations arithmétiques sont mises en œuvre sur ledit au moins un mot de code par la seconde unité de traitement, le procédé comprend en outre la vérification, par la seconde unité de traitement, de la valeur du poids de Hamming du mot de code reçu, la mise en œuvre des opérations arithmétiques ou les opérations de chiffrement est réalisée sur au moins un mot de code, et produit en sortie le résultat codé de l'opération appliquée à la donnée correspondant au mot de code.
les opérations arithmétiques ou les opérations de chiffrement comprennent des opérations linéaires appliquées sur au moins un mot de code, et la mise en œuvre d'une opération linéaire comprend :
o la génération d'au moins une table prenant en entrée au moins un mot de code partiel, et produisant en sortie le résultat de l'opération appliquée au(x) mot(s) de code partiel(s),
o la décomposition de chaque mot de code sur lequel l'opération est mise en œuvre en mots de code partiels, et
o le calcul de l'opération par application des mots de code partiels aux tables, et la concaténation des résultats obtenus,
les opérations arithmétiques ou les opérations de chiffrement sont non- linéaires, et la mise en œuvre d'une opération non linéaire comprend :
o la génération d'au moins une table prenant en entrée au moins un mot de code partiel d'au moins un mot de code, et produisant en sortie le résultat codé de l'opération appliquée à au moins une donnée complète dont sont tirés les mots de codes partiels,
o la décomposition de chaque mot de code sur lequel l'opération est mise en œuvre en mots de code partiels, et
o le calcul de l'opération par application des mots de code partiels aux tables.
les opérations de chiffrement ou les opérations arithmétiques des étapes de traitement de d'algorithmes cryptographiques, d'algorithmes de calcul de
fonctions de hachage, ou d'algorithmes de calcul d'intégrité adaptés pour recevoir en entrée lesdits mots de code.
L'invention a également pour objet un circuit électronique comprenant :
un module d'encodage comportant une unité de traitement adaptée pour coder des données de n bits en des mots de code présentant un poids de Hamming constant prédéfini et pour mettre en œuvre sur lesdits mots de code des opérations de chiffrement ou des opérations arithmétiques par la mise en œuvre du procédé de traitement décrit ci-avant.
Avantageusement, mais facultativement, le circuit électronique selon l'invention peut en outre comprendre les caractéristiques suivantes : le module d'encodage comporte en outre des moyens de transmission de données, et le circuit comprend en outre :
un module de décodage comportant une unité de traitement adaptée pour décoder un mot de code transmis par le premier module, et
un module de génération de signal d'erreur, adapté pour générer un signal d'erreur lorsque le poids de Hamming d'un mot de code transmis par le premier module est différent d'un poids de Hamming prédéfini.
L'invention a enfin pour objet une carte à puce comportant un tel circuit électronique.
Le procédé de traitement proposé comprend un encodage de données en mots de code de taille suffisamment faible pour que des algorithmes puissent être mis en œuvre sur lesdits mots de code, même dans des unités informatiques à faible mémoire telles que des cartes à puce.
En outre, l'utilisation de codes de poids constant permet de sécuriser les données contre des attaques par canaux cachés comme les attaques nommées SPA, DPA, MIA, CPA, ASCA, car la consommation électrique de la carte à puce est la même pour toutes les données utilisées.
En outre, l'utilisation de codes de poids constant permet de détecter certaines attaques par injection de faute comme notamment les attaques par impulsion laser.
DESCRIPTION DES FIGURES
D'autres caractéristiques, buts et avantages de la présente invention apparaîtront à la lecture de la description détaillée qui va suivre, au regard des figures annexées, données à titre d'exemples non limitatifs et sur lesquelles :
La figure 1 représente schématiquement un exemple de composant électronique traitant une ou plusieurs données secrètes,
La figure 2 représente les principales étapes d'un mode de mise en œuvre d'un procédé d'encodage.
La figure 3 représente un exemple de mise en œuvre du procédé d'encodage.
La figure 4 représente les principales étapes d'un exemple de mise en œuvre d'un procédé de traitement de données.
DESCRIPTION DETAILLEE D'AU MOINS UN MODE DE MISE EN ŒUVRE
Unité informatique d'encodage de données
En référence à la figure 1 , on a représenté un exemple d'unité informatique pouvant encoder des données, dont notamment des données secrètes et réaliser des opérations à partir desdites données. Cette unité informatique est avantageusement une carte à puce 1 , qui comprend un circuit électronique comportant un module d'encodage 10 et un module de décodage 20. Alternativement, le module d'encodage et le module de décodage peuvent appartenir à deux unités informatiques distinctes connectées entre elle pour autoriser une communication de données.
Le module d'encodage 10 est avantageusement intégré à un processeur de la carte à puce, et le module de décodage peut être intégré à un périphérique tel qu'une mémoire ou un coprocesseur de la carte à puce.
Le module d'encodage 10 comporte des moyens de transmission de données, par exemple un bus 1 1 de communication de données, et une unité de traitement 12, adaptée pour mettre en œuvre des opérations d'encodage et de chiffrement sur des données, ladite unité étant avantageusement une unité arithmétique et logique (ALU). Une unité arithmétique et logique est un circuit intégré dans un processeur permettant la mise en œuvre des calculs sur les données.
Le module 20 comporte des moyens de réception de données 21 comme un bus de réception de données, ainsi qu'une unité de traitement 22, configurée pour décoder des données reçues du module d'encodage, l'unité étant avantageusement une unité arithmétique et logique 22.
Procédé d'encodage de données
En référence à la figure 2, l'unité de traitement 12 du module d'encodage 10 est adaptée pour encoder une pluralité de données, dont notamment des données secrètes, afin que ces données ne soient pas obtenues au cours de leur utilisation par une attaque par canaux cachées.
Pour une donnée D de taille égale à n bits, ou n est une puissance de 2, le procédé d'encodage 1000 comporte une étape 100 consistant à scinder la donnée en plusieurs séquences de bits de taille inférieure à n, avantageusement en m séquences de bits di,..., dm, m étant strictement inférieur à n. Il existe donc au moins une séquence de bits comprenant au moins deux bits. Cette décomposition de la donnée est une partition, c'est-à-dire qu'aucun bit de la donnée n'est présent dans deux séquences de bits.
Cette décomposition permet de réduire la taille de chaque séquence de bits pour le calcul ultérieur d'opérations binaires à deux opérandes comme par exemple le ou exclusif.
Les séquences de bits obtenus présentent une taille égale à une puissance de deux bits. Ceci permet d'obtenir un bon compromis entre la capacité de détection de fautes et la mémoire occupée par le procédé. Par exemple, dans la figure 3, on a représenté une donnée D d'une longueur de n = 8 bits, scindée en deux séquences de bits di, d2 de 4 bits chacune.
Selon un autre exemple, une donnée d'une longueur de n=4 bits est scindée en deux séquences de 2 bits chacune.
Au cours d'une étape 200, l'unité de traitement encode la donnée au moyen d'un code de poids constant pour obtenir un mot de code correspondant M, présentant un poids de Hamming ω constant et déterminé.
Dans toute la suite, on note x,y-code la fonction qui transforme une donnée en une donnée de poids de Hamming « x » sur « y » bits. L'ensemble image de
note également "x\, y\ - x2, y2 - code" le codage d'une première partie d'une donnée par un x , y - code et de sa seconde partie par un x2, y2
L'ensemble image de cette fonction contient donc ( ) x ( ) éléments.
Selon la notation précédente, l'unité de traitement met en œuvre, pour réaliser l'encodage de la donnée, un encodage de type x0, y0 - x\, y\ xm> ym — code, où m>0 est le nombre de séquence de bits en lesquelles la donnée a été décomposée. En d'autres termes, l'unité de traitement encode au cours de l'étape 200, au moyen d'un codage de poids constant, chaque séquence de bits di,...,dm de la donnée pour former un mot de code partiel correspondant mi,...mm.
De retour à l'exemple de la figure 3, les séquences de bits di, d2 sont encodées chacune au moyen d'un 3,6-code pour obtenir des mots de codes respectifs m-i, m2.
Le mot de code M correspondant à la donnée totale D est la concaténation des mots de code partiels mi,...mm! réalisée par l'unité de traitement au cours d'une étape 300.
Très avantageusement, la somme des ym, c' est-à-dire des longueurs (en bits) des mots de code partiels, qui correspond à la longueur totale en bits du mot de code obtenu, est strictement inférieure à 2n. Ceci permet d'obtenir un mot de code plus cours que notamment dans le procédé Dual Rail, qui le rend plus simple à mettre en œuvre dans un système informatique à faible mémoire tel qu'une carte à puce.
On donne également des exemples de codes préférés pour la mise en œuvre du procédé ; dans le cas où la taille des données D à encoder est de 4 bits, on emploie de préférence un 3,5-1 ,2-code ou un 2,5-1, 2-code, à permutation du premier et du deuxième codes près, c'est-à-dire que la donnée D est décomposée en une séquence de 3 bits, puis un bit. La première séquence étant codée en un mot de code partiel de taille 5 bits et de poids de Hamming égal à 2 ou 3, et le bit restant étant codé en un mot de code partiel de taille 2 bits et de poids de Hamming égal à 1 .
Dans le cas où la taille des données D à encoder est de 8 bits, on emploie de préférence un 3,6-3,6-code, la donnée D est décomposée en deux séquences de bits de 4 bits, chacune étant codée en un mot de code partiel de 6 bits et de poids de Hamming égal à 3, comme dans l'exemple de la figure 3.
Procédé de traitement de données
Le procédé d'encodage de données 1000 décrit ci-avant permet la transmission sécurisée de données secrètes d'un module à un autre, pour leur utilisation ultérieure, par exemple au cours d'opérations de chiffrement.
II permet également la mise en œuvre d'opérations de chiffrement et/ou d'opérations arithmétiques sur les données encodées, par des unités de traitement à faibles capacités de calcul telles que des cartes à puce.
On a représenté en figure 4 un procédé de traitement de données comprenant l'encodage, la transmission, et l'exploitation ultérieure des données transmises.
Dans l'exemple d'une carte à puce comprenant un module d'encodage 10 et un module de décodage 20 comme illustré en figure 1 , une première étape de transmission de données comprenant l'encodage 1000 desdites données par l'unité de traitement 12 du module d'encodage 20.
Au cours d'une étape 2000, le bus de communication de données 1 1 transfère au bus de réception 21 du module de décodage 20 les mots de code obtenus par l'encodage des données.
Avantageusement, la carte à puce peut également comprendre un module 30 de génération de signal d'erreur, qui peut être intégré au module de décodage (comme illustré sur la figure 1 ) ou connecté à celui-ci. Avantageusement, mais facultativement, ce module 30 vérifie au cours d'une étape 3000 que le poids de Hamming des mots de code transmis par le module d'encodage est égal au poids de Hamming constant ω qui est convenu avant la mise en œuvre du procédé de transmission.
Si le poids de Hamming d'un mot de code diffère du poids de Hamming ω, ou si le mot de code reçu n'est pas conforme au mot attendu (bien que présentant le poids de Hamming ω) le module 30 détecte un signal d'erreur au cours d'une étape 3100. L'étape de vérification du poids de Hamming permet notamment de détecter
une attaque par injection de faute, qui aurait pour conséquence de modifier le poids de Hamming des données transmises.
Si le poids de Hamming est conforme au poids attendu, l'unité de traitement
22 décode les mots de code et/ou les exploite pour mettre en œuvre une opération de chiffrement ou une opération arithmétique, par exemple de type booléenne, au cours d'une étape 4000.
Les résultats des opérations arithmétiques ou de chiffrement appliqués aux données non codées peuvent être obtenus à partir des mots de codes générés à partir desdites données, comme décrit ci-après.
Alternativement, le décodage et/ou l'exploitation 4000 des mots de code pour mettre en œuvre une opération de chiffrement est réalisé sans vérifier au préalable l'exactitude des mots de code.
Alternativement les opérations 4000 de chiffrement et/ou les opérations arithmétiques peuvent être réalisées par la première unité de traitement sans ou avant qu'une étape 2000 de transmission des données à la deuxième unité de traitement soit mise en œuvre.
Par exemple, une opération de chiffrement peut être une étape d'un algorithme cryptographique tel que l'AES (pour « Advanced Encryption Standard » ou « standard de chiffrement avancé ») ou le LED, d'un algorithme de calcul d'une fonction de hachage tel que par exemple SHA-1 ,SHA-2 ou le futur SHA-3, ou encore un algorithme de calcul d'intégrité tel que de contrôle de redondance cyclique (connu sous l'acronyme « CRC ») ou le LRC (acronyme anglais de
« longitudinal redundancy check »), un tel algorithme ayant été préalablement adapté pour recevoir en entrée les mots de code obtenus par le procédé décrit ci- avant.
Plusieurs types d'adaptations peuvent être réalisés en fonction de la nature des opérations mises en œuvre dans les algorithmes.
Dans de nombreux algorithmes, des opérations arithmétiques sont pré calculées sous forme de tableaux ou tables de vérité.
Dans le cas où les fonctions de chiffrement sont des fonctions non linéaires, l'adaptation de la fonction aux mots de code consiste à reprendre les tableaux pré calculés et de les adapter au calcul en prenant pour entrées et sorties les valeurs correspondant aux mots de code sur lesquels on réalise le calcul. En d'autres termes, on génère au moins une table ayant pour entrées les mots de code partiels
sur la base desquels on réalise le calcul ou le mot de code complet, et fournissant en sortie le résultat codé de l'opération appliquée à la donnée complète non codée, qui est la concaténation des séquences de bits dont sont tirés les mots de code partiels. L'opération est donc appliquée à l'ensemble des mots de code partiels.
Ainsi par exemple, on note A une donnée comprenant la concaténation de deux séquences de bits a0, ai de tailles respectives L0 et Li. B est une donnée comprenant la concaténation de deux séquences de bits b0, bi, de tailles respectives L0 et Li.
On note A = ai||a0, et B = bi || b0, où « || » est le symbole de concaténation.
Soit K0 un code prenant L0 bits en entrée fournissant en sortie un mot de code de taille lk0 bits, et K-i un code prenant L-ι bits en entrée, et fournissant en sortie un mot de code de taille lk-ι bits.
On note
|| K0(a0), et CW(B) = K-i (bi) || K0(b0), qui sont de taille Iko+lki bits.
Un premier exemple de calcul d'une opération non-linéaire est donné pour une fonction à un seul opérande. En appelant cette fonction « NLF », on pré-calcule une table T_NLF donnant :
T_NLF [CW(A)] = CW (NLF (A)).
En d'autres termes, T_NLF est une table prenant en entrée un mot de code complet CW(A) et fournissant en sortie le mot de code obtenu par un encodage identique de l'image de A par la fonction NLF.
Un deuxième exemple est donné pour le calcul d'une fonction à deux opérandes, par exemple l'addition modulo 2L0+L1.
On génère trois tables définies comme suit :
- ADD-K0[ K0( a ), K0( b ) ] = K0[ (a+b) modulo 2L0 ]
Cette table prend en entrées deux données codées par K0, et produit en sortie le reste de la division euclidienne de la somme des deux données par 2L0, codé par K0.
- REM-K0[ K0( a ), K0( b ) ] = K,[ (a+b) / 2L0 ]
Cette table prend en entrées deux données codées par K0, et produit le quotient de la division euclidienne de la somme des deux données par 2L0, codé par
- ADD-Ki[ Ki( a ) H Ki( b ) ] = Ki[ (a+b) modulo 2L1 ]
Cette table prend en entrées deux données codées par K1 , et produit le reste de la division euclidienne de la somme des deux données par 2L1, codé par K1 .
On va maintenant décrire l'obtention de CW( A+B modulo 2 L0+L1) en partant de CW(A) et CW(B).
CW(A+B modulo 2L0+L1) est l'encodage de A+B modulo 2L0+L1. En reprenant les mêmes notations que précédemment :
A+B = ai||a0 + bi||b0 = (ai+bi). 2L0 + a0 +b0
Que l'on peut noter : X. 2L0+L1 +Y. 2L0+ R0, d'où A+B mod 2L0+L1 : Y. 2L0+ R0.
Où :
R0 est le résultat de a0+b0 modulo 2L0, c'est-à-dire le reste de la division euclidienne de a0+b0 par 2L0
X est le quotient de la division euclidienne de a+b par 2 L0+L1
Y est le résultat de a+b modulo 2L0+L1, c'est-à-dire le reste de le division euclidienne de a+b par 2L0+L1 , qui se décompose en C0+Ri, où C0 est le quotient de la division euclidienne de a-i+bi par 2L1, et R-ι est la retenue de l'addition a0+b0 modulo 2L0.
CW(A+B modulo 2 L0+L1) est donc égal à K1(Y)+K0(R0). Pour l'obtenir à partir de CW(A) et CW(B), on calcule, avec les tables introduites ci-avant :
Ko(Ro) = ADD-K0[ Ko( a0 ) , b„) ]
Ki(Co) = REM-K0[ K0( a0 ) , K0( b0 ) ]
K1(R1) = ADD-K1[ K1( ai ) , K,( bi ) ]
On a alors CW( (A+B) modulo 2 L0+L1 ) = K1(Y)||K0(R0).
Dans le cas où les fonctions de chiffrement sont des fonctions linéaires, cette étape d'adaptation pour l'exploitation ou le décodage des mots de code peut par
exemple être réalisée en décomposant le mot de code M en les mots de code partiels m-i , . . . , mm qui le composent, et en réalisant l'opération sur chacun des mots de code partiels avant de concaténer les résultats obtenus.
Dans le cas d'une fonction à plusieurs opérandes, chaque mot de code sur lequel l'opération est mise en œuvre est décomposé en ses mots de codes partiels, et l'opération est appliquée de façon séparée sur les mots de codes partiels correspondants de chaque mot de code.
Ainsi par exemple, la mise en œuvre d'une opération de type « ou exclusif » (XOR) sur deux données codées comprend la mise en œuvre d'opérations « ou exclusifs » sur chaque mot de code partiel.
Avec la même notation que précédemment, on note XOR-K0 la fonction ou exclusif appliquée à deux données concaténées, codés par K0, et qui renvoie leur XOR en représentation codée par K0. De même avec XOR-^ qui s'applique à des données codées par K-i et renvoie leur XOR en représentation codée par Ki.
XOR-K0[Ko(a),K0(b)] = K0 [a XOR b]
Le résultat de A XOR B sous forme codée est donc calculé de la manière suivante :
R0= XOR-Ko [Ko (a„) , Ko (b„)]
Ri = XOR-Ki [Ki (a1 ) , Ki (bi)]
R est bien de la même forme que CW(A) et CW(B), c'est-à-dire la concaténation de deux mots de code codés respectivement par K-i et K0.
Dans le cas présent, les tableaux pré calculés présentent des tailles adaptées à celles des mots de code partiels utilisés pour les opérations arithmétiques. A titre d'exemple non limitatif, pour des mots de code M de type 2,5- 1 ,3-2,5-code, sur lesquels on souhaite réaliser une opération « ou exclusif », on précalcule deux tables de type « A XOR B », une pour A et B de poids de Hamming
2 sur une taille de 5 bits, et une pour A et B de poids de Hamming 1 sur une taille de
3 bits.
De la même manière, si l'unité de traitement veut décoder les mots de code, elle sépare chaque mot de code M en les mots de code partiels m, mm, et met en œuvre sur chaque mot de code partiel un décodage correspondant à l'encodage mis en œuvre pour les obtenir. L'algorithme de décodage dépend bien entendu de l'algorithme d'encodage utilisé au préalable.
A titre d'exemples non limitatifs, on décrit ci-après d'autres possibilités d'encodage et de décodage dans le cadre du procédé décrit ci-avant.
Selon un premier exemple, on cherche à coder des données d'un ensemble de départ E contenant les entiers de 0 à 15, c'est-à-dire les entiers binaires représentés sur 4 bits.
On choisit comme code d'arrivée l'ensemble des mots de poids 3 parmi 6 bits, qui est le suivant : {7, 1 1 , 13, 14, 19, 21 , 22, 25, 26, 28, 35, 37, 38, 41 , 42, 44, 49, 50, 52, 56}. Cet ensemble comporte 20 éléments ; il est donc adapté pour coder l'ensemble E qui en contient 16. On note J l'ensemble des 16 premiers éléments du code précédent. En binaire J= [1 1 1 , 101 1 , 1 101 , 1 1 10, 1001 1 , 10101 , 101 10,1 1001 , 1 1010, 1 1 100, 10001 1 , 100101 , 1001 10, 101001 , 101010, 101 100].
A l'élément E[a] (« a-ième » élément de E) est associé l'élément J[a].
Si la table J est conservée en mémoire, alors on obtient le procédé de codage, qui est un simple accès à un tableau. Un mot « a » se code en accédant en mémoire à la valeur J[a].
Pour décoder, on crée la table K, de taille 26 éléments (=64), qui à l'emplacement J[i], i allant de 0 à 15, prendra la valeur de i.
On a alors K[J[i]]=i, donc le décodage du mot de code de « i » permet bien d'obtenir « i » lui-même.
La table K s'écrit alors [X, X, X, X, X, X, X, 0, X, X, X, 1 , X, 2, 3, X, X, X, X, 4,
X, 5, 6, X, X, 7, 8, X, 9, X, X, X, X, X, X, 10, X, 1 1 , 12, X, X, 13, 14, X, 15, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X], où X est une valeur qui n'est pas dans l'ensemble E de départ.
Pour un mot de 8 bits M que l'on souhaite coder, ce mot est scindé en deux séquences de 4 bits chacune, codées chacune sur 6 bits comme décrit précédemment, puis on concatène les mots de code partiels obtenus.
Pour les opérations sur le mot de code, on prépare une table qui reçoit en entrée les mots de code partiels et fournit en sortie le résultat de l'opération appliquée à la concaténation des mots de code partiels.
D'autres possibilités d'encodage et de décodage des données applicables dans le cadre de la présente invention sont connues et à la portée de l'Homme du Métier.