Steganographie sur bitmap 24 bits
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 ^^
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.
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
- Steganographie sur bitmap 24 bits
- Rib maroc 24 chiffres - Forum Visual Basic 6
- Clé rib - Forum Visual Basic
- Controle et génération d'une clé RIB - Forum Delphi / Pascal
- Calcul de la clé d'un RIB bancaire dans un formulaire PDF - Forum Javascript / DHTML
- Cherche un programmeur ASM (pic12f683)pour 24/48 heures payer 100 euro - Forum ASM
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.