Réparer un code QR

Paru dans GNU/Linux Magazine n°198 de novembre 2016.

Protégé par la licence CC BY-NC-ND 2.0.

Nous terminons cette première série sur la lecture des codes QR par la réparation automatique de sa zone de format et de sa zone de données.

Cet article permet de lire un code QR abîmé ou décoré d’un petit logo en utilisant la correction d’erreur de Reed-Solomon. On corrigera aussi la zone de format.

Dans l’article précédent [1], nous avons codé une bibliothèque qui permet de manipuler le corps 𝔽₂₅₆ et son anneau de polynômes : nous les utilisons pour corriger un code QR défectueux ou muni d’une imagette décorative. Le code est disponible sur GitHub [2].

Deux zones d’un code QR peuvent être corrigées :

• Les zones de format qui contiennent les informations minimales pour commencer à lire les données. Elles sont présentes en double : cinq bits de données et dix de correction.
• La zone centrale qui contient les données découpées en blocs : chacun a ses données brutes et sa correction.

Correction de la zone de format

J’ai utilisé les idées de Wikiversity [3] pour cette partie.

Voici le véritable code de la fonction qui vérifie la validité des zones de format et qui les corrige si possible.

01:   def verifformat(self):
02:     if self.form is None:
03:       self.formats()
04:     r0=bin2dec(self.form[0][5:])
05:     r1=bin2dec(self.form[1][5:])
06:     hamming={i:set() for i in range(16)}

On commence par transformer les deux zones de format en nombres, r0 et r1 lignes 4 et 5. Ce sont en fait des éléments de 𝔽₂₅₆, c’est pourquoi on utilisera plus loin (lignes 9 et 10) le XOR bit à bit.

La table de hashage hamming contient, en fonction du nombre d’erreurs, les formats possibles. Il suffit ainsi de prendre le minimum des clés pour un format correspondant unique (et non vide) pour obtenir le format correct.

07:     for form in range(32):
08:       r=resteformat(form)
09:       reste0=r0^r
10:       reste1=r1^r
11:       c0=bin(reste0).count("1")
12:       c1=bin(reste1).count("1")
13:       hamming[c0].add(form)
14:       hamming[c1].add(form)

On teste alors tous les codes possibles, il n’y en a que 2⁵=32, c’est peu donc la force brute est possible et même souhaitable (contrairement à la section suivante).

On calcule le reste de chaque format possible (une division euclidienne où la soustraction est un XOR binaire) et où le diviseur est le nombre 1335 soit 10100110111 en binaire. La fonction resteformat est dans qrcodestandard.py.

def resteformat(n):
  mod=16*1335 # 0x357
  n*=1024
  for i in range(5):
    if len(bin(n))>=len(bin(mod)):
      n^=mod
    mod//=2
  return n

On le compare aux formats présents et on ajoute sa distance de Hamming (le nombre de bits distincts donc le nombre de 1 dans le XOR des lignes 9 et 10). Les lignes 13 et 14 ajoutent si nécessaire le format aux formats qui ont la même distance dans hamming.

15:     m=min(h for h in hamming if hamming[h])
16:     if m:
17:       self.formatok=False
18:     else:
19:       self.formatok=True
20:     if len(hamming[m])>1:
21:       print("Erreur, conflit de formats.")
22:       exit(1)
23:     self.form[0]=[int(i) for i in bin(hamming[m].pop())[2:]]
24:     self.form[0]=[0]*(5-len(self.form[0]))+self.form[0]

Enfin, ligne 15, on cherche la distance de Hamming la plus petite et pour laquelle au moins un format existe. Si elle est nulle, il n’y a pas eu besoin de corriger. Si elle n’est pas nulle, on teste s’il y a plusieurs formats possibles. Si oui, on ne peut pas corriger, il y a ambiguïté. Sinon, on corrige et on remplace.

Correction de la zone de données

Nous allons lire puis corriger le code QR de la figure 9.

Fig. 9 Le code QR à corriger.

Le principe est de transformer la totalité de chaque bloc du message (chaque bloc en clair plus sa correction concaténée) en un polynôme à coefficients dans 𝔽₂₅₆, c’est pourquoi nous avons besoin des deux fonctions message2poly et poly2message qui font l’interface (dans qrcorps.py).

Interface

Pour corriger un code QR qui contient des erreurs, on a besoin de traduire une liste de bits en un polynôme et inversement.

199: def message2poly(message):
200:   poly=[]
201:   for i in range(len(message)//8):
202:     poly.append(F256(bin2dec(message[8*i:8*i+8])))
203:   return Polynome(tuple(poly))

Cette fonction transforme une liste de bits en un polynôme en convertissant chaque octet en un élément de 𝔽₂₅₆, la liste des octets donne les coefficients du polynôme.

205: def poly2message(poly):
206:   mess=poly.coefficients
207:   liste=[]
208:   for c in mess:
209:     b=[int(i) for i in bin(c.val)[2:]]
210:     liste=liste+[0]*(8-len(b))+b
211:   return liste

Cette fonction est la réciproque de la précédente : elle transforme les coefficients d’un polynôme de notre classe en une liste de bits en faisant attention à ce que l’octet ait bien 8 bits.

Principe mathématique

Le principe est le même, en plus complexe, que la preuve par neuf. Par exemple, on doit transmettre un nombre n (par exemple n=457859), on calcule le reste r de sa division euclidienne par 9 qui est 2. Donc le nombre n×10+9−r=4578597 est divisible par 9. Il suffit de vérifier si le nombre transmis est un multiple de 9 pour savoir s’il y a un problème. Bien évidemment, un message trop altéré ne sera pas détectable, pas plus qu’on ne pourra corriger le message mais l’idée est la même. L’ISBN et le numéro de Sécurité Sociale utilisent ce genre de méthode [4].

Si on se donne un message m de n octets et l’erreur e de n octets aussi, le message reçu est r=m+e (l’addition n’est pas la concaténation mais l’addition vectorielle). Autrement dit, comme on est en caractéristique 2, e=r+m. Le message m est fourni avec sa correction construite de manière à ce que si a est notre élément générateur du groupe des inversibles de 𝔽₂₅₆, $\forall \mathrm{x}={\mathrm{a}}^{\mathrm{k}}\in {\mathrm{𝔽}}_{256}^{*}$, $\sum _{\mathrm{j}=0}^{\mathrm{n}-1}{\left({\mathrm{a}}^{\mathrm{k}}\right)}^{\mathrm{j}}{\mathrm{m}}_{\mathrm{j}}$ où m₀ est le dernier élément du message. Autrement dit si le message est altéré (mais pas trop), cette somme n’est plus nulle.

On utilise le principe de la transformée de Fourier discrète dans les corps finis pour déterminer les positions des erreurs puis leur valeur. Ce n’est pas exactement une transformée de Fourier parce qu’on ne calcule pas la somme sur la totalité des éléments de 𝔽₂₅₆ mais sur une plus petite partie, ici du nombre d’octets correcteurs.

Le code

La fonction est dans qrcodestandard.py, je me suis appuyé sur le travail de B. Barras [5]. Il y a plusieurs manières de procéder mais la force brute n’est plus envisageable car si un bloc contient 55 octets soit 440 bits, il faut tester 2⁴⁴⁰ ≈ 2,839 × 10¹³² cas. J’ai choisi, vu le travail mené précédemment, d’utiliser une version modifiée de la division euclidienne :

01: def corrige(clair,redondant):
02:   toutpoly=message2poly(clair+redondant)
03:   syndrome=[toutpoly(F256(F256.exp(i))) for i in range(len(redondant)//8)]
04:   if set(syndrome)!={F256(0)}:
05:     syndpoly=Polynome(tuple(syndrome[::-1]))

Le polynôme toutpoly est donc notre polynôme de 𝔽₂₅₆[X]. Ses n racines sont les puissances du générateur 2, de au nombre d’octets moins 1 de la partie redondante, si le message n’est pas entaché d’erreurs. On calcule donc les n images par la fonction polynôme associée de ces puissances dans le syndrome.

Si toutes les valeurs du syndrome sont nulles, le code QR n’est pas endommagé. Remarquer que les éléments de ma classe sont hashables sinon on ne pourrait pas créer un ensemble qui en contient.

Si le code est endommagé ligne 04, on transforme le syndrome S=[S₀, S₁,... ,S_n−1] en le polynôme syndpoly ligne 05 donc $\mathrm{syndpoly}=\sum _{\mathrm{k}=0}^{\mathrm{n}-1}{\mathrm{S}}_{\mathrm{k}}{\mathrm{X}}^{\mathrm{k}}$, c’est-à-dire que le coefficient dominant est S_n−1 et le coefficient constant est S₀.

06:     r,v=Polynome.construction([1]+[0]*syndpoly.degre()),Polynome.construction([0])07:  rr,vv=syndpoly,Polynome.construction([1])
08:     while r.degre()>=len(syndpoly)//2:
09:       q=r//rr
10:       r,v,rr,vv=rr,vv,r-q*rr,v-q*vv

Appelons p_k les positions des erreurs et v le polynôme de degré m tel que $\mathrm{v}=\prod _{\mathrm{k}=1}^{\mathrm{m}}(1-{\mathrm{a}}^{{\mathrm{p}}_{\mathrm{k}}}{\mathrm{X}}^{\mathrm{k}})$.

L’équation fondamentale est v×syndpoly+vv×Xⁿ=r, ce qui ressemble fort à une égalité de Bezout. Il faut cependant arrêter le calcul avant que le dernier reste ne soit nul et recoder l’algorithme.

11:     vder=v.der()
12:     racines=[i for i in range(255,255-len(toutpoly),-1) if v(F256(F256.exp(i)))==F256(0)]

On détermine la dérivée de v (qui nous servira pour déterminer les erreurs) puis ses racines b_k, directement reliées aux positions des erreurs (ce sont les inverses, ${\mathrm{b}}_{\mathrm{k}}={\left({\mathrm{a}}^{{\mathrm{p}}_{\mathrm{k}}}\right)}^{-1}$).

13:     if 2*len(racines)>=len(syndrome):
14:       print("Il y a trop d’erreurs dans le bloc n°"+str(ii)+".",file=sys.stderr)
15:       exit(1)

S’il y a trop d’erreurs, on précise le bloc concerné et on sort.

16:     erreurs={i:r(F256(F256.exp(i)))/vder(F256(F256.exp(i)))/F256(F256.exp(i)) for i in racines}

On calcule les valeurs des erreurs pour chaque racine b_k de v, c’est-à-dire $\frac{\mathrm{r}\left({\mathrm{b}}_{\mathrm{k}}\right)}{\mathrm{v}\prime \left({\mathrm{b}}_{\mathrm{k}}\right)}$ .

17:     for i in erreurs:
18:       toutpoly[255-i]+=erreurs[i]
19:     toutmessage=poly2message(toutpoly)
20:     return toutmessage[:len(clair)],toutmessage[len(clair):],len(racines)
21:   return clair,redondant,0

On corrige les erreurs du bloc courant et on retourne le bloc en clair corrigé, le bloc redondant corrigé et le nombre d’erreurs corrigées.

Si on n’a pas demandé de corriger, on retourne tout tel quel et 0 (aucune erreur corrigée).

> ./qrdecode.py -i linux.png -a1
Fichier : linux.png
Niveau de correction : Low
Masque :
█··█··
█··█··
█··█··
█··█··
█··█··
█··█··
Dimensions : 105×105
Version : 22
Il y a eu besoin de corriger 61 erreur(s) dans la zone de données.
Mode : Byte
Longueur du message : 949
Message :
Hello everybody out there using minix -

I'm doing a (free) operating system (just a hobby, won't be big and
...

Bon, je coupe, vous avez compris la teneur de la suite du message.

Conclusion

La lecture des codes QR est terminée. On aurait pu coder d’autres algorithmes de correction par curiosité.

Maintenant, il nous reste à créer nos propres codes QR...

Références

1. PATROIS N., « Fabriquer un corps fini », GNU/Linux Magazine n°196, septembre 2016, p. 32 à 37.
2. Le code et les exemples sont présents ici : https://github.com/GLMF/GLMF198
3. Reed–Solomon codes for coders : https://en.wikiversity.org/wiki/Reed%E2%80%93Solomon_codes_for_coders.
4. EVEILLEAU T., « Les clés de détection d'erreur » : http://therese.eveilleau.pagesperso-orange.fr/pages/truc_mat/textes/cles.htm.
5. BARRAS B., « Codes de Reed Solomon », 1999 : http://infoscience.epfl.ch/record/198834/files/rs.pdf?version=1.

Maison