Problème décryptage BMP

[Oxmose]

Bonjour chers developpeurs !
Voilà j'ai un petit problème je suis sur un projet de cryptage pour le lycée mais je me heurte à un problème :
J'ai cette image :


Que je réussi a décrypter comme ceci :


Mais je ne sais pas comment passer de celle ci à l'originale ci-dessous :


Pourriez vous m'éclairer ?

[tyrtamos]

Bonjour,

Sans rien connaitre du format BMP, la figure du milieu représente 4 images de serpent, probablement fabriquées avec une ligne sur 4. Il faudrait donc regrouper ces lignes pour n'avoir plus qu'une seule image.

[VinsS]

J'ai l'impression qu'il y a aussi une séparation des componsant R-G-B


Quel est le code qui permet de passer de l'image 0 à l'image 1 ?

[Oxmose]

Voila la fonction qui crypte :

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
112
113
114
115
116
117
def cryptav(namefile, namefileout):#fonction de cryptage
    #initialisation de toutes les variables locales dans def
    image=''
    longueur=0
 
    lignehex=''
    ligne=''
    colonehex=''
    colone=''
 
 
    origin=open(namefile, 'rb')  #Ouverture fichier
    final=open(namefileout, 'wb')   #Ouverture ou creation du fichier   
 
 
    fichier=origin.read() #Lecture du fichier d'origine
    header=fichier[0x0:0x36] #Recuperation du header de l'image
 
 
    image=(str(binascii.hexlify(fichier[0x36:])))[2:]#on traduit en hex et on enlève le b'
    image=image[0:len(image)-1]#on enlève le ' a la fin de la chaine
 
 
    #longueur de la partie à crypter
    longueur=len(image)
 
 
    #récupération de la longeure en pixel d'une ligne
    lignehex=(str(binascii.hexlify(header[0x12:0x16])))[2:len(ligne)-1]
 
    m=0
 
    for i in range(4):
        if (lignehex[8-m-2:8-m]=='00'):
            print('')
        else:
            ligne=ligne+lignehex[8-m-2:8-m]
 
 
        m=m+2
 
    ligne = int(ligne,16)
 
    #récupération de la longeure en pixel d'une colone
    colonehex=(str(binascii.hexlify(header[0x16:0x20])))[2:len(colone)-1]
 
    m=0
 
    for i in range(4):
        if (colonehex[8-m-2:8-m]=='00'):
            print('')
        else:
            colone=colone+colonehex[8-m-2:8-m]
 
 
        m=m+2
 
    colone = int(colone,16)
 
 
    #appiclation cryptage!
 
    #changement de couleur
    k=0
    pim=''
 
    while ((k)!=longueur):
 
        couldec=int(image[k:k+2], 16)
 
        if (couldec<128):
 
            couldec=couldec+128
            newcoul=hex(couldec)[2:]
 
        else:
 
            couldec=couldec-128
            if couldec<=15:
                newcoul='0'+(hex(couldec)[2:])
            else:
                newcoul=hex(couldec)[2:]
 
        pim=pim+newcoul
 
        k=k+2
 
    #décallage
    v=0
    l=1
    newimage=''
    for i in range(ligne):
       if l==1:
           l=2
           newimage=newimage+pim[colone*v*6:colone*(v+1)*6]
       elif l==2:
           l=3
           newimage=pim[colone*v*6:colone*(v+1)*6]+newimage
       elif l==3:
           l=4
           newimage=newimage+pim[longueur-(colone*(v+1)*6):longueur-(colone*(v)*6)]
       else:
           l=1
           newimage=pim[longueur-(colone*(v+1)*6):longueur-(colone*(v)*6)]+newimage
 
       v=v+1
 
 
    #fin de cryptage
    final.write(header+bytes.fromhex(newimage))#ecriture dans le fichier
 
    #on libère les fichiers
    origin.close()
    final.close()
 
    #message d'arret
    print('\n\nFait.\n')

$

et ma fonction qui décrypte : image0->image1

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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
def decryptav(namefile, namefileout): #fonction de décryptage
    #initialisation de toutes les variables locales dans def
 
    image=''
    longueur=0
 
    lignehex=''
    ligne=''
    colonehex=''
    colone=''
 
    newimage=''
 
    origin=open(namefile, 'rb')  #Ouverture fichier
    final=open(namefileout, 'wb')   #Ouverture ou creation du fichier
 
 
    fichier=origin.read() #Lecture du fichier d'origine
    header=fichier[0x0:0x36] #Recuperation du header de l'image
 
 
    image=(str(binascii.hexlify(fichier[0x36:])))[2:]#on traduit en hex et on enlève le b'
    image=image[0:len(image)-1]#on enlève le ' a la fin de la chaine
 
 
    #longueur de la partie à crypter
    longueur=len(image)
 
 
    #récupération de la longeure en pixel d'une ligne
    lignehex=(str(binascii.hexlify(header[0x12:0x16])))[2:len(ligne)-1]
 
    m=0
 
    for i in range(4):
        if (lignehex[8-m-2:8-m]=='00'):
            print('')
        else:
            ligne=ligne+lignehex[8-m-2:8-m]
 
 
        m=m+2
 
    ligne = int(ligne,16)
 
    #récupération de la longeure en pixel d'une colone
    colonehex=(str(binascii.hexlify(header[0x16:0x20])))[2:len(colone)-1]
 
    m=0
 
    for i in range(4):
        if (colonehex[8-m-2:8-m]=='00'):
            print('')
        else:
            colone=colone+colonehex[8-m-2:8-m]
 
 
        m=m+2
 
    colone = int(colone,16)
 
 
    #appiclation décryptage!
 
    #changement de couleur inverse
    k=0
    pim=''
 
    while ((k)!=longueur):
 
        couldec=int(image[k:k+2], 16)
 
        if (couldec<128):
 
            couldec=couldec+128
            newcoul=hex(couldec)[2:]
 
        else:
 
            couldec=couldec-128
            if couldec<=15:
                newcoul='0'+(hex(couldec)[2:])
            else:
                newcoul=hex(couldec)[2:]
 
        pim=pim+newcoul
 
        k=k+2
 
 
 
    #décallage
    v=0
    l=1
    varia=0
    newimage=''
    for i in range(ligne):
        if l==1:
            l=2
            newimage=newimage+pim[longueur-(colone*(v+1)*6):longueur-(colone*(v)*6)]
        elif l==2:
            l=3
            newimage=pim[colone*v*6:colone*(v+1)*6]+newimage
        elif l==3:
            l=4
            newimage=newimage+pim[colone*v*6:colone*(v+1)*6]
        else:
            l=1
            newimage=pim[longueur-(colone*(v+1)*6):longueur-(colone*(v)*6)]+newimage
 
        v=v+1
 
 
        #application de la rotation inverse
    i=1
    j=0
    k=0
    imagerot=''
    for i in range(ligne):
        for j in range(colone):
            imagerot=imagerot+newimage[k:k+6]
            k=k+6
 
    #fin de cryptage
    final.write(header+bytes.fromhex(imagerot))#ecriture dans le fichier
 
    #on libère les fichiers
    origin.close()
    final.close()
 
    #message d'arret
    print('\n\nFait.\n')

[Alliaël]

Bonjour,

je pense que tu devrais commencer par bien comprendre le code de cryptage, le décryptage te viendra naturellement après.

Le code de cryptage est écrit volontairement avec des variables de mer... euh pas claires donc il est complètement illisible. En renommant les variables pour ce qu'elles sont vraiment tu devrais avoir plus de simplicité à comprendre.

Pour t'aider un peu plus,
pim est une string qui représente l'image complète une fois le changement de couleur fait.
newimage représente une string de l'image une fois le décalage fait.

l'écriture

Code :

pim[colonne*v*6:colone*(v+1)*6]

permet de sélectionner les caractères de "pim" entre la position "colone*v*6" et "colonne*(v+1)*6"

Donc il mélange les caractères et toi tu vas devoir les démêler.

[Oxmose]

Merci pour ta réponse justement je comprend à peut prêt le code donc j'arrive a décrypter mais je me retrouve avec les quatre image en une (dont deux violette) et là ben je sèche...

[dividee]

Pour les parties en violet, il semble qu'il y ait une inversion des canaux verts et bleus; vu que la couleur normale est dans les tons jaunes (qui est du rouge + du vert) et la couleur erronée est proche du magenta (du rouge + du bleu).
Voir ici: http://fr.wikipedia.org/wiki/Fichier:Synthese%2B.svg

[plxpy]

Bonjour,

Déjà je ne comprends pas très bien si tu es, ou non, l'auteur d'un ou des deux bouts de code que tu as postés. Ou est-ce du code qu'on t'a fourni pour en faire un troisième en étudiant la méthode de [dé]chiffrage ? Tu peux retoucher les fonctions que tu as postées ou pas ?

Ensuite, la "fonction de chiffrage" lève systématiquement une exception (je l'ai essayée sur plusieurs images dont celle que tu as postée - en png ... étant donné le sujet, c'est balot !)

Code :

1
2
3
4
5
6
7
8
9
10
plx@sony:~/Bureau/BMP$ python cryptage.py 1355081561-test3.bmp cryptee.bmp
 
 
 
Traceback (most recent call last):
  File "cryptage.py", line 125, in <module>
    cryptav(sys.argv[1],sys.argv[2])
  File "cryptage.py", line 73, in cryptav
    couldec=int(image[k:k+2], 16)
ValueError: invalid literal for int() with base 16: ''

Après, il y aurait beaucoup de choses à dire sur le code, et pas seulement sur les noms de variables, évoqués dans un post précédent.

Autre chose : quel est l'intérêt de cette image intermédiaire que tu sembles vouloir "finir" de décrypter ? C'est un partage à la Salomon d'un travail global à faire à plusieurs ?

Bref, on peut continuer longtemps à émettre des hypothèses mais, le mieux, serait que tu fournisses des indications précises, des éléments de contexte et les vrais bouts de code - qui fonctionnent ! - afin qu'on puisse t'aider efficacement. Tout est affaire de détails ici alors, avec des entrées approximatives, "ça va pas le faire".


[EDIT] le décryptage (partiel) ne fonctionne pas mieux ...

Code :

1
2
3
4
5
6
7
8
9
10
11
plx@sony:~/Bureau/BMP$ python decryptage.py /home/plx/Bureau/BMP/1355081428-t.bmp decryptee.bmp
 
 
 
Traceback (most recent call last):
  File "decryptage.py", line 141, in <module>
    decryptav(sys.argv[1],sys.argv[2])
  File "decryptage.py", line 76, in decryptav
    couldec=int(image[k:k+2], 16)
ValueError: invalid literal for int() with base 16: ''
plx@sony:~/Bureau/BMP$

[Alliaël]

Yop,

Peux tu nous donner ta version de Python ? (ça peut toujours être utile)

Ensuite j'avoue que je ne comprend pas non plus ce que tu ne comprend pas .

Tu ne vois pas pourquoi il y a quatre images ?
Tu ne vois pas comment refaire ta chaine pour avoir une seule image ?
... ton problème est ailleurs ?

[VinsS]

Le code n'est utilisable qu'avec Python 3.

Ceci exclus Python 2:

Code :

1
2
 
final.write(header+bytes.fromhex(newimage))

Mais en fait il y a plusieurs choses à clarifier dans ce code avant d'en comprendre la mécanique.

Le bug remarqué par plxpy:

Code :

1
2
3
4
 
    while ((k)!=longueur):
 
        couldec=int(image[k:k+2], 16)

doit être remplacé par

Code :

1
2
3
4
 
    while ((k) < longueur - 2):
 
        couldec=int(image[k:k+2], 16)

Ensuite l'extraction des dimensions de l'image
La largeur:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
 #récupération de la longeure en pixel d'une ligne
    lignehex=(str(binascii.hexlify(header[0x12:0x16])))[2:len(ligne)-1]
 
    m=0
 
    for i in range(4):
        if (lignehex[8-m-2:8-m]=='00'):
            print('')
        else:
            ligne=ligne+lignehex[8-m-2:8-m]
 
 
        m=m+2
 
    ligne = int(ligne,16)

peut-être simplement remplacé par

Code :

1
2
3
4
5
6
7
 
def bytes2int(bts):
    hexs = [hex(i) for i in bts]
    sum_ = 0
    for x in range(4):
        sum_ += int(hexs[x], 16) * (256**x)
    return sum_

pareil pour la hauteur

Code :

1
2
3
4
5
 
    #récupération de la longeur en pixel d'une ligne
    ligne = bytes2int(header[0x12:0x16])
    #récupération de la longeur en pixel d'une colone
    colone = bytes2int(header[0x16:0x1a])

Notons au passage que c'est [0x16:0x1a] et non pas [0x16:0x20].

Comme l'a dit Alliaël, les noms ne sont pas très judicieux, entre autres ici ligne désigne le nombre de colonnes et colone désigne le nombre de lignes.

Le re-codage des composantes couleur est fait ainsi:

Chaque pixels originel est composé des six octets RRVVBB chaque composant nécessitant deux octets parce qu'il doivent être signés.
Lors du re-codage chaque paire est transformée en un entier

Code :

1
2
 
    couldec=int(image[k:k+2], 16)

Ensuite le décallage consiste à combiner des suites d'octets (d'une longueur égale au nombre de lignes) en les doublant pour retrouver un nombre total d'octets, ce qui permet de réenregistrer l'image sans modification des dimensions dans le header.

Exemple avec une image de 5 lignes le re-codage donne ceci

|bloc1|bloc2|bloc3|bloc4|bloc5|bloc6|bloc7|bloc8|bloc9|

Considérant chaque bloc comme étant 5 octets (5 lignes) ils sont redisposé en alternant un bloc compté dans le sens gauche-droit et un bloc dans l'autre sens:

|bloc5|bloc6|bloc4|bloc7|bloc3|bloc8|bloc2|bloc9|bloc1|*|bloc1|bloc9|bloc2|bloc8|bloc3|bloc7|bloc4|bloc6|bloc5|

L'asterisque represente l'axe de symétrie de la répartition.

L'ordre initial peut être récupéré avec ceci:

Code :

1
2
3
4
5
6
7
8
9
 
    cryp = image[ln//2:]
    beg, end = '', ''
    while len(cryp):
        beg += cryp[:rows]
        end = cryp[rows:rows*2] + end
        cryp = cryp[rows*2:]
 
    decryp = beg + end

Où rows est le nombre de lignes de l'image (appellé colone pour ceux qui suivent)

Pour le décodage des couleurs par contre, je suis encore dans le brouillard.

[Oxmose]

Merci pour vos réponses !
Notre prof s'est enfin rendu compte que le code était bien trop horrible à déchirer du coup il n'est plus question de finir cet exercice que même lui ne semblait pas bien comprendre.
Cependant je vais clarifier le code et essayer de décrypter l'image merci à tout le monde pour vos indications qui vont m'aider pour la suite !
PS :
Alliaël je ne vois pas comment reconstruire l'image qui est diviser en quatre pour en faire une seule.
Désolé pour les format poster mais je ne trouve pas d'hébergeur qui garde les images en .bmp. Pour le format c'est du bitmap windows 24bit

[plxpy]

Envoyé par Oxmose

Cependant je vais clarifier le code et essayer de décrypter l'image

Si c'est pour apprendre Python, je te déconseille d'utiliser ce code qui est vraiment un contre-exemple (un exemple de ce qu'il ne faut pas faire). Ce ne sont pas les aspects Python auxquels tu vas te heurter mais plus à la façon déplorable de coder de l'auteur.

Si, par contre, c'est l'aspect manipulation d'un fichier .bmp qui t'intéresse, c'est autre chose. Mais faudrait alors revoir assez sérieusement le code : en l'état, c'est une horrible usine à gaz, mal foutue de surcroit ! Tu pourrais aussi, tout simplement, oublier ce code et t'essayer à des choses comme séparer les canaux (R,V,B), retourner l'image (miroir horizontal / vertical), etc...

Désolé pour les format poster mais je ne trouve pas d'hébergeur qui garde les images en .bmp

Ok

[Papy Octet]

Envoyé par Oxmose

...Désolé pour les format poster mais je ne trouve pas d'hébergeur qui garde les images en .bmp. Pour le format c'est du bitmap windows 24bit

Il y a ImageShack qui l'autorise. Enfin, ça, c'est mon dépôt sur ce site.
Mais il te suffit de créer un compte et, avec la version de base, tu peux déjà déposer un paquet d'images.

Which file types am I allowed to upload?

ImageShack supports all major image formats including jpeg, png, gif, ico, bmp, and tiff. ImageShack also supports video formats including avi, mkv, mpeg, mp4, mov, wm, 3gp, flv, and many others. Please note, animated gifs are only available to premium users.

A+

[plxpy]

Le code, en dehors des défauts déjà évoqués, est buggé, notamment la fonction qui fait un "décalage" dans le premier bout de code que tu as posté. Donc, toute tentative d'arriver à un résultat correct est voué à l'échec.

J'ai repris le bout de code qui fait le décalage, en ai fait une fonction (vu que ce n'était pas fait ... faute !) et l'ai appliqué à une "image" que j'ai construite à la mano : c'est une "chaine hexa" remplie de caractères 0.

Lors de la copie de pim vers newimg, je marque aussi les caractères utilisés dans pim avec des '1' qui viennent remplacer les '0' :

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
# -*- coding:utf-8 -*-
 
def mise_a_jour_chaine(chaine,start,end):
    return chaine[:start] + '1'*(end-start) + chaine[end:]
 
def fonction_decalage():
 
    # je me mets dans les conditions de l'execution
    # avec ton image de depart 400x400, 3 couleurs,
    # chaque couleur unitaire etant une chaine (hexa) de 2 octets
    ligne = colone = 400
    longueur = ligne * colone * 3 * 2
 
    # je ne charge pas d'image
    # mon image sera une chaine de caracteres '0', avec la bonne taille
    pim = '0'*longueur
 
    #décallage
    v=0
    l=1
 
    newimage=''
 
    for i in range(ligne):
       if l==1:
           l=2
           newimage=newimage+pim[colone*v*6:colone*(v+1)*6]
           # nelle ligne suivante : je mets des "pixels" a '1'
           # pour indiquer/retenir que ces pixels ont ete copies
           pim = mise_a_jour_chaine(pim,colone*v*6,colone*(v+1)*6)
 
       elif l==2:
           l=3
           newimage=pim[colone*v*6:colone*(v+1)*6]+newimage
           # nelle ligne suivante : ... idem ...
           pim = mise_a_jour_chaine(pim,colone*v*6,colone*(v+1)*6)
 
       elif l==3:
           l=4
           newimage=newimage+pim[longueur-(colone*(v+1)*6):longueur-(colone*(v)*6)]
           # nelle ligne suivante : ... idem ...
           pim = mise_a_jour_chaine(pim,longueur-(colone*(v+1)*6),longueur-(colone*(v)*6))
 
       else:
           l=1
           newimage=pim[longueur-(colone*(v+1)*6):longueur-(colone*(v)*6)]+newimage
           # nelle ligne suivante : ... idem ...
           pim = mise_a_jour_chaine(pim,longueur-(colone*(v+1)*6),longueur-(colone*(v)*6))
 
       v=v+1
 
    # je retourne pim qui ne devrait plus contenir que des '1' (si chaque pixel de base a ete utilise ...)
    # et newimg qui ne devrait contenir que des '0' (si on n'a pas utilise plusieurs fois le meme pixel)
    return pim, newimage

et patatras ...

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
plx@sony:~/Bureau/BMP$ python3
Python 3.2.3 (default, Oct 19 2012, 20:13:42) 
[GCC 4.6.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import decalage
>>> 
>>> pim, new = decalage.fonction_decalage()
>>> len(pim), len(new), 400*400*3*2
(960000, 960000, 960000)
>>> 
>>> pim.count('0')
480000
>>> pim.count('1')
480000
>>> 
>>> new.count('0')
480000
>>> new.count('1')
480000
>>>

l'image décalée est construite avec la moitié des pixels de l'image en entrée, chacun servant deux fois.

et encore, je ne suis pas allé voir si les 6 caractères associés à un même pixel restaient groupés, mais à vue de nez je pense que oui

Alors pour revenir à un beau python tout propre et tout pareil à celui d'origine ... c'est tout simplement impossible vu que l'on perd de l'information dans cette partie (au moins celle-là ...)


[EDIT] j'ai laissé le plus possible le code d'origine, donc dans un état ..., pour ne pas pouvoir imputer aux instructions ajoutées le problème soulevé.

[plxpy]

J'ai modifié légèrement mon code en laissant, dans pim, des pixels rouges là où ils ont été transférés à la nouvelle image puis sauvegardé pim et la nouvelle image :

pim après utilisation :



et l'image résultat du décalage :



Sur l'image résultat, on voit bien où est mise l'information en double (d'où les 4 pythons aplatis dans la deuxième image du début de la discussioon : les deux du milieu sont la moitié des vraies informations/pixels, ceux du bas et du haut une redite). Et sur l'image origine, on voit très bien aussi que tous les pixels n'ont pas été transférés (on reconnait bien le bestiau !)