STEGANOGRAPHIE SUR BITMAP 24 BITS

###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