Avec les notations ci-dessus, le problème que nous essayons de résoudre ici est que nous avons un vecteur v ∈ Fn
q qui est extrait d’un média de couverture et un message m de
longueur r composé d’élément de Fq. Nous voulons modifier v en s tel que m soit incrusté
dans s en changeant au plus T coordonnées dans v.
Le principe de Fontaine et Galand [39] propose d’utiliser le codage par syndrôme avec un code GRS. Pour cela, on utilise les cosets des codes GRS(n, k) pour introduire le message m et ainsi trouver le vecteur s suffisamment proche de v. Pour cela on prend
k = n − r et ainsi r = n − k et on a la longueur, pour le coset qui nous convient. On
suppose alors que l’on a fixé une famille γ ∈ Fn
q. On construit la matrice Γ comme définie
précédemment et on calcule son inverse Γ−1.
L’extraction sur s contient le message m si s × Ht = m Pour construire s, nous
cherchons un mot y tel que son syndrôme est m − v × Ht. En effet, si on pose s = y + v,
et on a
y = s − v ⇒ y × Ht = (s − v) × Ht= s × Ht− v × Ht = m − v × Ht (3.16)
et
s × Ht = y × Ht+ v × Ht = m − v × Ht+ v × Ht = m (3.17)
Alors le poids de Hamming de y est exactement le nombre de changement effectué pour passer de v à s. On veut que ce poids soit inférieur à T . Or, quand T est inférieur ou égal au rayon de recouvrement du code, un tel vecteur existe toujours, mais le calcul explicite de ce vecteur y est difficile au sens de la complexité. Le calcul de y est le calcul par syndrôme borné, "the bounded syndrome decoding", problème est prouvé NP-dur pour les codes linéaires en général.
Soit le polynôme M(X) qui a pour coefficients mi associés aux monômes Xk+i avec
coefficients de degré au moins k. Maintenant, pour trouver y, il nous suffit de calculer un polynôme P de degré inférieur à k tel que pour au moins k éléments γi de la famille γ
P (γi) = M(γi) − V (γi)
⇔ M(γi) − V (γi) − P (γi) = 0
Ainsi, avec un tel P , on a y = ev(M − V − P ) qui a k coordonnées égales à zéro. Le syndrôme est alors
y × Ht = ev(M − V − P ) × Ht
= (ev(M) − ev(V ) − ev(P )) × Ht
= ev(M) × Ht− ev(V ) × Ht− ev(P ) × Ht = m − v × Ht (3.18)
On pose alors s = y + v et on obtient notre vecteur modifié comme désiré. De plus, on peut remarquer que verrouiller la position i requiert si = vi et que c’est équivalent à
prendre yi = 0 et donc que P (γi) = M(γi) − V (γi) De plus T peut être aussi grand que le
rayon de recouvrement ρ = n − k car on peut verrouiller jusqu’à k positions. La difficulté se trouve maintenant dans le calcul du polynôme P .
3.4.1
Utilisation de l’interpolation de Lagrange
Pour construire P , nous allons utiliser la méthode d’interpolation de Lagrange. On choisit un ensemble de k coordonnées I = {i1, ..., ik} et on calcule
P (X) =X
i∈I
(M(γi) − V (γi)).Lii∈I(X)
où Li
i∈I(X) est l’unique polynôme de degré au plus k − 1 qui prend pour valeur 0 sur
γj, j 6= i et 1 pour γi. Alors on a Li i∈I(X) = Y i∈I\i (γi− γj)−1(X − γj)
P (γi) = M(γi) − V (γi)
On peut ainsi construire y = ev(M − V − P ). Alors pour tout i ∈ I, yi = 0 et donc
si = vi+ yi = vi. Ce qui signifie que l’on a bloqué les positions dont l’indice appartient à
I.
D’après ce qui précède nous pouvons donc introduire r = n − k éléments de Fq en
changeant au plus T = n − k coordonnées parmi n. On en déduit donc que dans le pire des cas, l’efficacité est égale à 1. Le nombre maximal de positions que l’on peut verrouillées à l’aide des codes BCH est k
2 d’après D.Schönfeld et A.Winkler [90].
En fait, en incrustant r = n − k symboles tout en bloquant k symboles parmi n est optimal. Comme nous l’avons écrit précédemment, le blocage des positions d’indice appartenant à I conduit à une équation y × Ht
I = m, où HIt est de dimension (n − k) ×
(n − |I|). Ainsi, pour |I| > k il existe certaines valeurs de m pour lesquelles il n’y a pas de solution. D’autre part, soit nous supposons que nous connaissons un code avec une matrice de contrôle H telle que pour chaque I de taille k et pour chaque m cette équation a une solution, donc HI est inversible. Cela implique que chaque sous matrice de H de
taille (n − k) × (n − k) est inversible. Or cela est équivalent à la définition des codes MDS. Ainsi, les codes GRS sont optimaux dans la mesure où nous pouvons verrouiller autant de position que possible pour un message de longueur r = n − k.
3.4.2
Construction plus efficace
Un moyen d’améliorer les résultats est d’utiliser les algorithmes connus pour les codes GRS. Un tel algorithme calcule à partir d’un vecteur ev(Q), les polynômes P de degré au plus k − 1, tel que ev(P ) soit proche de ev(Q) au sens de la distance de Hamming. Conditionné différemment, il fournit une bonne approximation de Q. L’utilisation de ces algorithmes permettre de diminuer la moyenne du nombre de coordonnées changées et ainsi améliorer l’efficacité moyenne.
La sortie des algorithmes de décodage peut être soit un unique polynôme P tel que le vecteur ev(P ) est à une distance au plus bn−k+1
2 c de ev(Q), soit une liste de polynômes P
Le second cas correspond à ce qu’on appelle le décodage en liste. Un algorithme efficace fut présenté, pour les codes GRS, par Sudan en 1997, et amélioré par Guruswami et Sudan en 1999. Le décodage par liste fournit la solution de poids minimum si elle existe, de plus la possibilité de choisir entre différents vecteurs permet d’améliorer l’indétectabilité.
3.4.3
Algorithme de Guruswami-Sudan :
L’algorithme de Guruswami-Sudan utilise un paramètre appelé paramètre d’interpo- lation de multiplicité µ. Soit un vecteur d’entrée (a0, a1, ..., an−1) l’algorithme calcule un
polynôme R(X, Y ) tel que chaque (γi, ai) est une racine de R de multiplicité µ. Puis l’al-
gorithme calcule la liste des facteurs de R de la forme Y − P (X) avec deg(P ) < k. Cet algorithme peut être utilisé pour le décodage des codes GRS réduits. Pour une famille I d’indices, nous cherchons des polynômes P tel que deg(P ) < k et P (γi) = 0
pour i ∈ I et P (γi) = Q(γi) pour autant de i n ?appartient pas à I que possible. Un tel P
peut alors être écrit : P (X) = F (X)G(X) avec F (X) =Qi∈I(X − γi). Ainsi en décodant
le code réduit on obtient G tel que deg(G) < k − |I| et G(γi) = Q(γF (γii)) pour autant de i
n ?appartient pas à I que l’on peut.
Le schéma généralisé consiste alors a effectuer un décodage en liste sur ev(M − V ), en s’arrangeant pour prendre un P aussi proche que possible de ev(M − V ). Si on échoue, on se replie sur l’interpolation de Lagrange pour calculer P .
En fait, il est encore possible de garder certaines positions bloquées. Soit I la famille de coordonnées qui reste inchangées. On considère alors Y = M − V − P et on utilise l’algorithme de Guruswami-Sudan pour calculer une approximation U de Y de degré au plus k − 1 et telle que U(γi) = 0 pour i ∈ I. Si l’algorithme de Guruswami-Sudan échoue,
alors on ajoute une nouvelle position à I et on recommence jusqu’à ce qu’on réussisse ou que |I| = k. Si |I| = k alors on pose U(X) = 0. Finalement le mot stégo est v + ev(Y − U).
L’algorithme précédent utilise deux procédures externes :
– GSdecode : cette procédure réfère au décodage en liste de Guruswami- Sudan. Il décode le polynôme Y (X) de degré au plus k − 1, dans le respect du code GRS(n, k) défini à partir de l’évaluation sur la famille γet réduit l’ensemble des positions d’in- dice appartenant à I.
Algorithm 5: Dissimulation d’un message de taille n − k avec au plus k positions bloquées en utilisant un code GRS(n, k).
Entree :
m = (m0, ..., mn−k−1) : vecteur du message à insérer de taille n − k ;
v = (v0, ..., vn−1) : // Media de couverture
I :// Famille d’indice restant inchangées (|I| ≤ k)
Sortie : s = (s0, ..., sn−1) // Media stego (s.Ht= m; s i = vi; i ∈ I; dH(s, v) ≤ n − k) Début de l’algorithme : V (X) ← v0+ v1X + ... + vn−1Xn−1; M(X) ← m0Xk+ m1Xk+1+ ... + mn−k−1Xn−1 Y (X) ← M(X) − V (X)
pour tout i ∈ I faire
Li I(X) ← Q j∈I\i(γi− γj)−1(X − γj); fin pour P (X) ←Pi∈IaiLiI(X) Y (X) ← Y (X) − P (X)
tant que |I| < k et GSdecode(Y (X), I) = ∅ faire
i ← selectposition({0, ..., n − 1}\I); I = IS{i}; Li I(X) ← Q j∈I\i(γi− γj)−1(X − γj); Y (X) ← Y (X) − Y (γi).LiI(X)
fin tant que
si GSdecode(Y (X), I) = ∅ alors
U(X) ← GSdecode(Y (X), I); y(X) ← Y (X) − U(X);
fin si
s ← v + ev(Y );
– selectposition : cette procédure renvoie un entier de l’ensemble donné en entrée comme paramètre. Elle est utilisée afin de déterminer la nouvelle position à ver- rouiller.