🥇Steganografi i GIF

Introduktion

Hej.
För inte så länge sedan, när jag studerade vid universitetet, hade jag en uppsats i ämnet "Programmeringsmetoder för informationsskydd". I uppgiften krävdes det att jag skulle göra ett program som integrerade meddelanden i filer av GIF-format. Jag bestämde mig för att använda Java.

I denna artikel kommer jag att beskriva vissa teoretiska punkter samt hur detta lilla program skapades.

Teoretisk Del

GIF-formatet

GIF (eng. Graphics Interchange Format — bildutbytesformat) är ett format för lagring av grafiska bilder som kan lagra komprimerad data utan kvalitetsförlust i ett format med upp till 256 färger. Detta format utvecklades 1987 (GIF87a) av CompuServe för överföring av rasterbilder över nätverk. År 1989 modifierades formatet (GIF89a) med tillägg av stöd för transparens och animation.

GIF-filer har en blockstruktur. Dessa block har alltid en fast längd (eller den beror på vissa flaggor), så det är praktiskt taget omöjligt att göra fel i var ett block ligger. Strukturen av den enklaste icke-animerade GIF-bilden i GIF89a-formatet:

Av alla block i strukturen kommer vi i detta fall att vara intresserade av blocket för den globala palett och parametrarna som ansvarar för paletten:

CT — närvaro av en global palett. Om denna flagga är inställd, måste den globala paletten börja omedelbart efter beskrivaren för den logiska skärmen.
Size — palettens storlek och antal färger i bilden. Värden för denna parameter:

Size
Antal färger
Palettstorlek, byte

7
256
768

6
128
384

5
64
192

4
32
96

3
16
48

2
8
24

1
4
12

0
2
6

Krypteringsmetoder

Som metoder för att kryptera meddelanden i bildfiler kommer följande att användas:

LSB-metoden (Least Significant Bit, minst signifikanta biten)
Palettkompletteringsmetoden

LSB-metoden — en vanlig metod för steganografi. Den går ut på att ersätta de sista signifikanta bitarna i containern (i vårt fall byte av den globala paletten) med bitarna av det dolda meddelandet.

Metoden kommer att använda de två sista bitarna i varje byte av den globala paletten. Det innebär att för en 24-bitars bild, där färgpaletten består av tre byte för röd, blå och grön, kommer varje färgkomponent efter införandet av meddelandet att ändras med högst 3/255 nyanser. Sådan förändring kommer för det första att vara osynlig eller svår att upptäcka för det mänskliga ögat och för det andra kommer den inte att vara märkbar på lågkvalitativa informationsutmatningsenheter.

Mängden information kommer att bero direkt på storleken av bildpaletten. Eftersom den maximala storleken på paletten är 256 färger, och om man skriver två bitar av meddelandet i varje färgkomponent, kommer den maximala längden på meddelandet (vid maximal palett i bilden) att vara 192 byte. Filstorleken förändras inte efter att meddelandet har införts i bilden.

Palettutvidgningsmetoden, som endast fungerar för GIF-strukturen. Den kommer vara mest effektiv i bilder med små paletter. Dess kärna är att den ökar palettens storlek, vilket ger mer utrymme för att skriva nödvändiga byte på platsen för färgbyte. Med tanke på att den minimi palettstorleken är 2 färger (6 byte), kan den maximala storleken på det infogade meddelandet vara 256×3–6=762 byte. Nackdelen är låg kryptografisk säkerhet; det infogade meddelandet kan läsas med vilken textredigerare som helst, om meddelandet inte har genomgått ytterligare kryptering.

Praktisk del

Programdesign

Alla nödvändiga verktyg för implementeringen av krypterings- och dekrypteringsalgoritmerna kommer att finnas i paketet com.tsarik.steganography. Detta paket inkluderar gränssnittet Encryptor med metoderna encrypt och decrypt, klassen Binary, som ger möjlighet att arbeta med bitarrayer, samt undantagsklasserna UnableToEncryptException och UnableToDecryptException, som ska användas i gränssnittets metoder Encryptor vid kodnings- och avkodningsfel respektive.

Huvudpaketet för programmet com.tsarik.programs.gifed kommer att inkludera den körbara klassens program med den statiska metoden main, som möjliggör programstart; en klass som lagrar programmets parametrar; samt paket med andra klasser.

Implementeringen av algoritmerna presenteras i paketet com.tsarik.programs.gifed.gif klasserna GIFEncryptorByLSBMethod och GIFEncryptorByPaletteExtensionMethod. Båda dessa klasser kommer att implementera gränssnittet Encryptor.

Utifrån strukturen i GIF-formatet kan en övergripande algoritm för att införa meddelanden i bildpaletten formuleras:

För att bestämma närvaron av ett meddelande i bilden måste en viss sekvens av bitar läggas till början av meddelandet, som avkodaren läser först och kontrollerar för korrekthet. Om den inte stämmer överens, anses det att det inte finns något dolt meddelande i bilden. Därefter måste meddelandets längd anges. Sedan följer själva meddelandetexten.

Klassdiagrammet för hela applikationen:

Programimplementeringen

Implementeringen av hela programmet kan delas upp i två delar: implementering av krypterings- och avkodningsmetoderna för gränssnittet Encryptor, i klasserna GIFEncryptorByLSBMethod och GIFEncryptorByPaletteExtensionMethod, och implementeringen av användargränssnittet.

Låt oss titta på klassen GIFEncryptorByLSBMethod.

Fält firstLSBit och secondLSBit innehåller numren på bitarna av varje byte i bilden där meddelandet ska skrivas in och läsas från. Fältet checkSequence lagrar kontrollsekvensen av bitar för att säkerställa igenkänning av det inbäddade meddelandet. Den statiska metoden getEncryptingFileParameters returnerar parametrarna för den angivna filen och egenskaperna för det potentiella meddelandet.

Algoritmen för metoden encrypt klassen GIFEncryptorByLSBMethod:

Och dess kod:

@Override
public void encrypt(File in, File out, String text) throws UnableToEncodeException, NullPointerException, IOException {
	if (in == null) {
		throw new NullPointerException("Input file is null");
	}
	if (out == null) {
		throw new NullPointerException("Output file is null");
	}
	if (text == null) {
		throw new NullPointerException("Text is null");
	}
	
	// läs byte från inmatningsfil
	byte[] bytes = new byte[(int)in.length()];
	InputStream is = new FileInputStream(in);
	is.read(bytes);
	is.close();
	
	// kontrollera format
	if (!(new String(bytes, 0, 6)).equals("GIF89a")) {
		throw new UnableToEncodeException("Inmatningsfil har fel GIF-format");
	}
	
	// läs palettstorleksegenskap från de första tre bitarna i den 10:e byten från filen
	byte[] b10 = Binary.toBitArray(bytes[10]);
	byte bsize = Binary.toByte(new byte[] {b10[0], b10[1], b10[2]});
	
	// beräkna antalet färger och möjlig meddelandelängd
	int bOrigColorCount = (int)Math.pow(2, bsize+1);
	int possibleMessageLength = bOrigColorCount*3/4;
	int possibleTextLength = possibleMessageLength-2; // en byte för kontroll och en byte för meddelandelängd
	
	if (possibleTextLength < text.length()) {
		throw new UnableToEncodeException("Texten är för stor");
	}
	
	int n = 13;
	
	// skriv kontrollsekvens
	for (int i = 0; i < checkSequence.length/2; i++) {
		byte[] ba = Binary.toBitArray(bytes[n]);
		ba[firstLSBit] = checkSequence[2*i];
		ba[secondLSBit] = checkSequence[2*i+1];
		bytes[n] = Binary.toByte(ba);
		n++;
	}
	
	// skriv textlängd
	byte[] cl = Binary.toBitArray((byte)text.length());
	for (int i = 0; i < cl.length/2; i++) {
		byte[] ba = Binary.toBitArray(bytes[n]);
		ba[firstLSBit] = cl[2*i];
		ba[secondLSBit] = cl[2*i+1];
		bytes[n] = Binary.toByte(ba);
		n++;
	}
	
	// skriv meddelande
	byte[] textBytes = text.getBytes();
	for (int i = 0; i < textBytes.length; i++) {
		byte[] c = Binary.toBitArray(textBytes[i]);
		for (int ci = 0; ci < c.length/2; ci++) {
			byte[] ba = Binary.toBitArray(bytes[n]);
			ba[firstLSBit] = c[2*ci];
			ba[secondLSBit] = c[2*ci+1];
			bytes[n] = Binary.toByte(ba);
			n++;
		}
	}
	
	// skriv utfil
	OutputStream os = new FileOutputStream(out);
	os.write(bytes);
	os.close();
}

Algoritm och källkod för metoden decrypt klassen GIFEncryptorByLSBMethod:

@Override
public String decrypt(File in) throws UnableToDecodeException, NullPointerException, IOException {
	if (in == null) {
		throw new NullPointerException("Inmatfilen är null");
	}
	
	// läser byte från inmatningsfil
	byte[] bytes = new byte[(int)in.length()];
	InputStream is = new FileInputStream(in);
	is.read(bytes);
	is.close();
	
	// kontrollerar format
	if (!(new String(bytes, 0, 6)).equals("GIF89a")) {
		throw new UnableToDecodeException("Inmatfilen har fel GIF-format");
	}
	
	// läser palettens storhetsparameter från de första tre bitarna i den 10:e byten från filen
	byte[] b10 = Binary.toBitArray(bytes[10]);
	byte bsize = Binary.toByte(new byte[] {b10[0], b10[1], b10[2]});
	
	// beräknar färgantal och möjlig meddelandelängd
	int bOrigColorCount = (int)Math.pow(2, bsize+1);
	int possibleMessageLength = bOrigColorCount*3/4;
	int possibleTextLength = possibleMessageLength-2;	// en byte för kontroll och en byte för meddelandelängd
	
	int n = 13;
	
	// läser kontrollsekvens
	byte[] csBits = new byte[checkSequence.length];
	for (int i = 0; i < 4; i++) {
		byte[] ba = Binary.toBitArray(bytes[n]);
		csBits[2*i] = ba[firstLSBit];
		csBits[2*i+1] = ba[secondLSBit];
		n++;
	}
	byte cs = Binary.toByte(csBits);
	
	if (cs != Binary.toByte(checkSequence)) {
		throw new UnableToDecodeException("Det finns inget krypterat meddelande i bilden (Kontrollsekvensen är felaktig)");
	}
	
	// läser textlängd
	byte[] cl = new byte[8];
	for (int i = 0; i < 4; i++) {
		byte[] ba = Binary.toBitArray(bytes[n]);
		cl[2*i] = ba[firstLSBit];
		cl[2*i+1] = ba[secondLSBit];
		n++;
	}
	byte textLength = Binary.toByte(cl);
	
	if (textLength < 0) {
		throw new UnableToDecodeException("Dekodad textlängd är mindre än 0");
	}
	if (possibleTextLength < textLength) {
		throw new UnableToDecodeException("Det finns inga meddelanden (Dekodad meddelandelängd (" + textLength + ") är mindre än möjlig meddelandelängd (" + possibleTextLength + "))");
	}
	
	// läser textbitar och gör textbytes
	byte[] bt = new byte[textLength];
	for (int i = 0; i < bt.length; i++) {
		byte[] bc = new byte[8];
		for (int bci = 0; bci < bc.length/2; bci++) {
			byte[] ba = Binary.toBitArray(bytes[n]);
			bc[2*bci] = ba[firstLSBit];
			bc[2*bci+1] = ba[secondLSBit];
			n++;
		}
		bt[i] = Binary.toByte(bc);
	}
	
	return new String(bt);
}

Implementeringen av klassen GIFEncryptorByPaletteExtensionMethod kommer att vara liknande, skillnaden ligger i metoden för att spara/läsa information.

I klassen MainFrame beskrivs metoderna-"wrapper": encryptImage(Encryptor encryptor) och decryptImage(Encryptor encryptor), som bearbetar resultaten av gränssnittets metoder Encryptor och interagerar med användaren, dvs öppnar dialoger för filval, visar felmeddelanden osv.; samt andra metoder: openImage(), som ger användaren möjlighet att välja en bild, exit(), som möjliggör utloggning från applikationen. Dessa metoder anropas från Action's motsvarande menyval. I denna klass har dessutom hjälpfunktioner implementerats: createComponents() — skapande av formulärkomponenter, loadImageFile(File f) — laddar upp en bild i en speciell komponent från fil. Implementeringen av klassen GIFEncryptorByPaletteExtensionMethod är liknande implementeringen av klassen GIFEncryptorByLSBMethod, den största skillnaden ligger i hur bytes av meddelandet skrivs och läses från paletten.

Programmets arbete

Metod LBS

Anta att det finns en sådan bild:

I denna bild består paletten av 256 färger (som Paint sparar). De första fyra färgerna: vit, svart, röd, grön. Övriga färger är svarta. Sekvensen av bitar i den globala paletten blir följande:

11111111 11111111 11111111 00000000 00000000 00000000 11111111 00000000 00000000 00000000 11111111 00000000…

Efter att meddelandet har införts kommer de understrukna bitarna att ersättas av bitarna från meddelandet. Den resulterande bilden skiljer sig nästan inte från originalet.