Réparer un code QR

Magazine
Marque
GNU/Linux Magazine
Numéro
198
Mois de parution
novembre 2016
Spécialité(s)


Résumé

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.


Body

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 𝔽256 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.

1. 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 𝔽256, 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 25=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.

2. Correction de la zone de données

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

linux

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 𝔽256, c’est pourquoi nous avons besoin des deux fonctions message2poly et poly2message qui font l’interface (dans qrcorps.py).

2.1. 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 𝔽256, 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.

2.2. 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 𝔽256,formule1 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 𝔽256 mais sur une plus petite partie, ici du nombre d’octets correcteurs.

2.3. 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 2440 ≈ 2,839 × 10132 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 𝔽256[X]. Ses nracines sont les puissances du générateur 2, de 0 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 syndromeS = [S0 ,S1 , ..., Sn−1] en le polynôme syndpoly ligne 05 donc formule2, c’est-à-dire que le coefficient dominant est Sn−1 et le coefficient constant est S0.

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 pk les positions des erreurs et v le polynôme de degré m tel que formule3.

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 bk, directement reliées aux positions des erreurs (ce sont les inverses, formule4).

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 bk de v, c’est-à-dire formule5.

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.



Article rédigé par

Par le(s) même(s) auteur(s)

Les derniers articles Premiums

Les derniers articles Premium

Stubby : protection de votre vie privée via le chiffrement des requêtes DNS

Magazine
Marque
Contenu Premium
Spécialité(s)
Résumé

Depuis les révélations d’Edward Snowden sur l’espionnage de masse des communications sur Internet par la NSA, un effort massif a été fait pour protéger la vie en ligne des internautes. Cet effort s’est principalement concentré sur les outils de communication avec la généralisation de l’usage du chiffrement sur le web (désormais, plus de 90 % des échanges se font en HTTPS) et l’adoption en masse des messageries utilisant des protocoles de chiffrement de bout en bout. Cependant, toutes ces communications, bien que chiffrées, utilisent un protocole qui, lui, n’est pas chiffré par défaut, loin de là : le DNS. Voyons ensemble quels sont les risques que cela induit pour les internautes et comment nous pouvons améliorer la situation.

Surveillez la consommation énergétique de votre code

Magazine
Marque
Contenu Premium
Spécialité(s)
Résumé

Être en mesure de surveiller la consommation énergétique de nos applications est une idée attrayante, qui n'est que trop souvent mise à la marge aujourd'hui. C'est d'ailleurs paradoxal, quand on pense que de plus en plus de voitures permettent de connaître la consommation instantanée et la consommation moyenne du véhicule, mais que nos chers ordinateurs, fleurons de la technologie, ne le permettent pas pour nos applications... Mais c'est aussi une tendance qui s'affirme petit à petit et à laquelle à terme, il devrait être difficile d'échapper. Car même si ce n'est qu'un effet de bord, elle nous amène à créer des programmes plus efficaces, qui sont également moins chers à exécuter.

Donnez une autre dimension à vos logs avec Vector

Magazine
Marque
Contenu Premium
Spécialité(s)
Résumé

Avoir des informations précises et détaillées sur ce qu’il se passe dans une infrastructure, et sur les applications qu'elle héberge est un enjeu critique pour votre business. Cependant, ça demande du temps, temps qu'on préfère parfois se réserver pour d'autres tâches jugées plus prioritaires. Mais qu'un système plante, qu'une application perde les pédales ou qu'une faille de sécurité soit découverte et c'est la panique à bord ! Alors je vous le demande, qui voudrait rester aveugle quand l'observabilité a tout à vous offrir ?

Les listes de lecture

9 article(s) - ajoutée le 01/07/2020
Vous désirez apprendre le langage Python, mais ne savez pas trop par où commencer ? Cette liste de lecture vous permettra de faire vos premiers pas en découvrant l'écosystème de Python et en écrivant de petits scripts.
11 article(s) - ajoutée le 01/07/2020
La base de tout programme effectuant une tâche un tant soit peu complexe est un algorithme, une méthode permettant de manipuler des données pour obtenir un résultat attendu. Dans cette liste, vous pourrez découvrir quelques spécimens d'algorithmes.
10 article(s) - ajoutée le 01/07/2020
À quoi bon se targuer de posséder des pétaoctets de données si l'on est incapable d'analyser ces dernières ? Cette liste vous aidera à "faire parler" vos données.
Voir les 53 listes de lecture

Abonnez-vous maintenant

et profitez de tous les contenus en illimité

Je découvre les offres

Déjà abonné ? Connectez-vous