Steganographie sur bitmap 24 bits

Soyez le premier à donner votre avis sur cette source.

Vue 9 012 fois - Téléchargée 531 fois

Description

Programme de stegano : Permet de cacher nimporte quel fichier dans une image en le cryptant (c pas vraiment le plus interessant ça c juste un pti + [c du cryptage XOR dc pas ultra efficace ^^]). On choisi le nombre de bit sur lequel on veut coder le fichier. Plus vous laugmenter plus limage sera alteré. (jusqua 2-3 bits utilisés on ne voit presque qu'aucune différence, à 8 vs avez la representation graphique de votre fichier ^^).
Vous choisissez aussi un mot de passe pour crypter les donnees pour que seul qqn possedant la cle puisse retrouver le fichier.

PS : l'alteration maximal, c'est seulement si tout les bits sont changés pour coder le fichier, ce qui arrive pas vraiment ^^ dc le chiffre est plus là pour faire zolie.

Bref ce code c'est surtout interessant pour les manipulations binaires en tout genre : or, shifting, and et xor ^^

Source / Exemple :


###fonction qui cache

def cache(self, bitUsed, filesize):
        """cache le fichier ds limage
        """
        table=[0xFF, 0xFE, 0xFC, 0xF8, 0xF0, 0xE0, 0xC0, 128, 0]
        #11111111, 11111110, 11111100, 11111000, 11110000, 11100000, 11000000, 10000000, 00000000
        table2=[0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF]
        #0, 1, 11, 111, 1111, 11111, 111111, 1111111, 11111111
        
        header=self.img.getHeader()
        header=header[:6]+s.pack('L', filesize)+header[10:] #ecriture de la taille du fichier
        
        self.dest.setHeader(header)
        self.dest.setPalette(self.img.getPalette())
        
        filebuf=self.fichier.read(4096)
        lbuf=len(filebuf)
        octet=ord(filebuf[0])
        pos=1
        bit=0
        firsttouse=0
        
        writeBuf=''
        self.dest.writeBuf(chr((ord(self.img.getBuffer(1))&0xF8)+bitUsed-1)) #ecriture du nombre de bits utilisés pour le codage ds la premier couleur du premier pixel (sur 3bits)
        buf=self.img.getBuffer()

        while 1:
            while 1:
                if(lbuf==0) : break
                for c in buf:

                    bitis=(octet&(table2[bitUsed]<<(8-bit-bitUsed)))>>(8-bit-bitUsed)
                    writeBuf+=chr((ord(c)&table[bitUsed]) | bitis) 

                    #### putain de partie
                    bit+=bitUsed
                    if(bit+bitUsed>8):
                        if(lbuf==0) : writeBuf+=buf[len(writeBuf):]; break 
                        if((8-bit)+(8-firsttouse)>=8) : #si ce qui reste ds octet + premier octet de filebuf <8 il faut un autre pctet de filebuf pour remplir octet
                            #ce qui reste doctet calé à gauche

                            rest=table2[8-bit]&octet
                            octet=0|(rest<<bit)
                            if(pos==lbuf) : filebuf=self.fichier.read(4096); lbuf=len(filebuf); pos=0
                            if(lbuf==0) : bit=0; continue
                            
                            aprendre=((table2[bit]<<(8-firsttouse-bit))&ord(filebuf[pos]))>>(8-firsttouse-bit)
                            
                            octet=octet|aprendre
                            firsttouse+=bit
                            
                            if(firsttouse>7) :
                                pos+=1
                                if(pos==lbuf) : filebuf=self.fichier.read(4096); lbuf=len(filebuf); pos=0
                                if(lbuf==0) : bit=0; continue
                                if(len(filebuf)!=4096) : filebuf+='\x00'; lbuf+=1 #ça c pour eviter que le dernier car soit changé
                                firsttouse=0
                        else :
                            #besoin de ce qui reste du premier octet +un peu dun autre
                            #dabord on prend ce qui reste et on cale à gauche
                            
                            #recuperation des bits restant ds octet
                            bitrest=octet&table2[8-bit]
                            #on met à gauche
                            octet=0|(bitrest<<bit)
                            #lecture de ce qui reste de filebuf[pos]
                            bitrest=ord(filebuf[pos])&table2[8-firsttouse]
                            #on cale apres ce qui a ete ecri
                            octet|=bitrest<<(bit-(8-firsttouse))
                            #on met a jour la position ds le buffer
                            pos+=1
                            if(pos==lbuf) : filebuf=self.fichier.read(4096); lbuf=len(filebuf); pos=0
                            if(lbuf==0) : bit=0; continue
                            if(len(filebuf)!=4096) : filebuf+='\x00'; lbuf+=1 #ça c pour eviter que le dernier car soit changé
                            #on lit ce qui reste à lire ds le nouveau octet
                            mask=table2[8-(8-bit)-(8-firsttouse)]<<(8-(8-((8-bit)+(8-firsttouse)) )) #goldeneye powaaa
                            bits=mask&ord(filebuf[pos])
                            #decale à droite
                            bits=bits>>(8-(8-((8-bit)+(8-firsttouse)) ))
                            #on met a la suite ds octet
                            octet|=bits
                            #new firsttouse
                            firsttouse=8-(8-bit+8-firsttouse)
                    ####pfiou c t dur cette parti là, a mon avis moyen de faire plus simple sans ces recreation doctet ou ya des bouts de partout
                        
                        bit=0
                        if(pos==lbuf) : filebuf=self.fichier.read(4096); lbuf=len(filebuf)
                        if(lbuf==0) : bit=0; continue
                        if(len(filebuf)!=4096) : filebuf+='\x00'; lbuf+=1 #ça c pour eviter que le dernier car soit changé
                
                self.dest.writeBuf(writeBuf)
                if(lbuf==0) : break #a faire ecriture de la fin de octet
                writeBuf=''
                buf=self.img.getBuffer()
                if not buf : break #ne devrait JAMAIS arriver
                
            buf=self.img.getBuffer()
            if not buf : break
            self.dest.writeBuf(buf)

        self.dest.stopWrite()
        self.fichier.close()

###fonction qui decache
    def decache(self):
        #lecture du header pour connaitre la taille du fichier
        imgsize=self.img.getSize()
        filesize=self.img.getFileSize()
        type=self.img.getReso()

        table=[0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF]

        writeBuf=''        
        if(type==24):
            #lecture du nombre de bits utilisés pour le codage
            bitUsed=(ord(self.img.getBuffer(1))&7)+1

            stop=False
            i=0
            written=0
            
            octet=0
            bit=0

            while 1:
                buf=self.img.getBuffer()
                if not buf : break
                for c in buf:
                    if(bit+bitUsed>8):
                        #la va falloir commencer un autre octet
                        
                        #dabord on prend le nbre de bit qu'il reste de bit libre octet cad, 8-bit
                        data=ord(c)&(table[bitUsed])
                        prremplir=data&(table[8-bit]<<(bitUsed-(8-bit)))
                        #on bouge a droite et on met ds octet
                        octet|=(prremplir>>(bitUsed-(8-bit)))
                        writeBuf+=chr(octet)
                        if((written+len(writeBuf))==filesize) : stop=True; break
                        octet=0
                        #on prend ce qui reste à prendre
                        rest=data&table[bitUsed-(8-bit)]
                        #on le bouge au debut
                        rest=rest<<(8-(bitUsed-(8-bit)))
                        octet=octet|rest
                        bit=bitUsed-(8-bit)
                        
                    else:
                        #recuperation des bits interessants
                        bitis=ord(c)&table[bitUsed]
                        #on bouge la ou y faut cad premier emplacement vide ds octet
                        bitis=bitis<<(8-bit-bitUsed)
                        #on met ds octet
                        octet=octet|bitis
                        
                        bit+=bitUsed
                        if(bit>7):
                            writeBuf+=chr(octet)
                            if((written+len(writeBuf))==filesize) : stop=True; break
                            octet=0
                            bit=0
                i+=1
                self.file.write(writeBuf)
                written+=len(writeBuf)
                writeBuf=''
                if(stop==True) : break
        self.file.close()

# c juste un apercu les autres fichiers --> zip

Conclusion :


Comme amelioration possible : travailler sur des blocs de 32 bits plutot que 8, ce qui accelairerait le traitement. Koike là c'est assez rapide, environ 3 seconde pour cacher 250ko ds une image de 650*650 pixels.

Codes Sources

A voir également

Ajouter un commentaire

Commentaire

saigneurdushi
Messages postés
45
Date d'inscription
samedi 3 mai 2003
Statut
Membre
Dernière intervention
25 janvier 2011

C'est bon ! mais saurais tu adapter ce code à des formats d'images compressées ?
Saurais tu si c'est la même démarche pour un stokage dans des fichiers sons (wav,mp3) ??
Merci en tout cas pour cette source :-)
Bonne journée :-)

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.