Steganograafia GIF-is

Sissejuhatus

Tere.
Hiljuti, kui õppisin ülikoolis, oli mul kursustöö "Tehnilised meetodid teabe kaitsmiseks". Ülesanne oli luua programm, mis sisestaks sõnumi GIF-formaadiga failidesse. Otsustasin teha seda Java keeles.

Selles artiklis kirjeldan mõned teoreetilised punktid ning samuti, kuidas ma selle väikese programmi lõin.

Teoreetiline osa

GIF-formaat

GIF (ingl. k. Graphics Interchange Format — kujutiste vahetamise formaat) on graafiliste kujutiste salvestamise formaat, mis suudab salvestada tihendatud andmeid kvaliteedi kaotamata 256 värvi formatis. See formaat töötati välja 1987. aastal (GIF87a) ettevõtte CompuServe poolt rasterpiltide edastamiseks võrkude kaudu. Aastal 1989 muudeti formaati (GIF89a), lisati toetus läbipaistvusele ja animatsioonile.

GIF-formaadiga failidel on plokkstruktuur. Need andmeplokid on alati fikseeritud pikkusega (või need sõltuvad teatud lippudest), mistõttu on peaaegu võimatu eksida selles, kus mis plokk asub. Kõige lihtsama animatsioonita GIF-pildi struktuur GIF89a formaadis:

Kõigist struktuuri plokkidest huvitavad meid sel juhul globaalne palett ja parameetrid, mis vastutavad palette eest:

• CT — globaalne palett. Kui see lipp on seatud, peab globaalne palett algama kohe pärast loogilise ekraani descriptorit.
• Suurus — paleti suurus ja pildi värvid. Selle parameetri väärtused:

Suurus
Värvide arv
Paleti suurus, baitides

7
256
768

6
128
384

5
64
192

4
32
96

3
16
48

2
8
24

1
4
12

0
2
6

Krüpteerimismeetodid

Kuna meetodeid sõnumite krüpteerimiseks pildifailides kasutatakse:

• LSB meetod (Least Significant Bit, vähim oluline bit)
• Pikenduse meetod paletis

LSB meetod — levinud steganograafia meetod. See seisneb konteineris (meie puhul globaalsete palettide baitides) viimaste olulisemate bittide asendamises peidetud sõnumi bittidega.

Programmis kasutatakse selle meetodi raames kahte viimast bitti globaalsete värvipalettide baitides. See tähendab, et 24-bitise pildi puhul, kus värvipalett koosneb kolmest baitist punase, sinise ja rohelise värvi jaoks, iga värviosade väärtus muutub pärast sõnumi sisestamist maksimaalselt 3/255 kraadi. Selline muudatus on esiteks inimsilma jaoks nähtamatu või raskesti märgatav ja teiseks ei ole see madala kvaliteediga väljundseadmetes eristatav.

Infokogus sõltub otseselt pildi värvipaleti suurusest. Kuna maksimaalne värvipalett on 256 värvi ja kui sisestada sõnumi jaoks iga värvi koostisosasse kaks bitti, siis maksimaalne sõnumi pikkus (maksimaalse paletiga pildis) on 192 baiti. Pärast sõnumi sisestamist pildi sisse ei muutu faili suurus.

Värvipaleti laiendamise meetod, mis töötab ainult GIF-struktuuri korral. See on kõige tõhusam väikeste värvipalettidega piltides. Tema olemus seisneb paleti suuruse suurendamises, pakkudes seeläbi täiendavat ruumi vajalike baitide salvestamiseks värvibaitide kohtades. Kõige väiksema paleti suurusega, mis on 2 värvi (6 baiti), võib maksimaalne sisestatud sõnumi suurus olla 256×3–6=762 baiti. Puudus — madal krüptograafia usaldusväärsus, kuna sisestatud sõnumit saab lugeda mis tahes tekstiredaktoris, kui sõnumit ei ole täiendavalt krüpteeritud.

Praktiline osa

Programmi projekteerimine

Kõik vajalikud tööriistad krüpteerimis- ja dekrüpteerimisalgoritmide rakendamiseks asuvad pakis com.tsarik.steganography. Selle paketi koosseisu kuulub liides Encryptor meetoditega encrypt ja decrypt, klass Binary, mis võimaldab töötada bite massiividega ning erandite klassid UnableToEncryptException ja UnableToDecryptException, mida tuleb kasutada liidese meetodites Encryptor kodeerimise ja dekodeerimise vigade korral vastavalt.

Programmi peamine pakett com.tsarik.programs.gifed sisaldab programmi käivitatavat klassi staatilise meetodiga main, mis võimaldab programmi käivitada; klass, mis salvestab programmi parameetrid; ja teiste klasside pakette.

Alglite sõnumite realiseerimise algoritmid esitatakse paketina com.tsarik.programs.gifed.gif klassides GIFEncryptorByLSBMethod ja GIFEncryptorByPaletteExtensionMethod. Mõlemad klassid realiseerivad liidest Encryptor.

GIF formaadi struktuuri alusel võib koostada üldise algoritmi sõnumi sisestamiseks pildialusesse paletti:

Sõnumi kohaloleku määramiseks pildis tuleb sõnumi algusesse lisada teatud bitijada, mille dekooder loeb esimesena ja kontrollib selle õigsust. Kui see ei kattu, siis loetakse, et pildis ei ole varjatud sõnumit. Edasi tuleb märkida sõnumi pikkus. Seejärel ise sõnumi tekst.

Kogu rakenduse klasside diagramm:

Programmi realiseerimine

Kogu programmi realiseerimine võib jagada kaheks osaks: krüpteerimise ja dekrüpteerimise meetodite realiseerimine liideses Encryptor, klassides GIFEncryptorByLSBMethod ja GIFEncryptorByPaletteExtensionMethod, ja kasutajaliidese realiseerimine.

Vaadakem klassi GIFEncryptorByLSBMethod.

Väljad firstLSBit ja secondLSBit sisaldavad iga pildi byte'i bitide numbreid, kuhu sõnum peab kirjutama ja kust see lugema peab. Väli checkSequence salvestab kontrollimise bitijada, et tagada sisestatud sõnumi tuvastamine. Staatiline meetod getEncryptingFileParameters tagastab määratud faili parameetrid ja potentsiaalse sõnumi omadused.

Meetodi algoritm encrypt klassist GIFEncryptorByLSBMethod:

Ja selle kood:

@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");
	}
	
	// read bytes from input file
	byte[] bytes = new byte[(int)in.length()];
	InputStream is = new FileInputStream(in);
	is.read(bytes);
	is.close();
	
	// check format
	if (!(new String(bytes, 0, 6)).equals("GIF89a")) {
		throw new UnableToEncodeException("Input file has wrong GIF format");
	}
	
	// read palette size property from first three bits in the 10-th byte from the file
	byte[] b10 = Binary.toBitArray(bytes[10]);
	byte bsize = Binary.toByte(new byte[] {b10[0], b10[1], b10[2]});
	
	// calculate color count and possible message length
	int bOrigColorCount = (int)Math.pow(2, bsize + 1);
	int possibleMessageLength = bOrigColorCount * 3 / 4;
	int possibleTextLength = possibleMessageLength - 2; // one byte for check and one byte for message length
	
	if (possibleTextLength < text.length()) {
		throw new UnableToEncodeException("Text is too big");
	}
	
	int n = 13;
	
	// write check sequence
	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++;
	}
	
	// write text length
	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++;
	}
	
	// write message
	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++;
		}
	}
	
	// write output file
	OutputStream os = new FileOutputStream(out);
	os.write(bytes);
	os.close();
}

Algoritm ja meetodi lähtekood decrypt klassist GIFEncryptorByLSBMethod:

@Override
public String decrypt(File in) throws UnableToDecodeException, NullPointerException, IOException {
	if (in == null) {
		throw new NullPointerException("Sisendfail on tühi");
	}
	
	// loe baitid sisendfailist
	byte[] bytes = new byte[(int)in.length()];
	InputStream is = new FileInputStream(in);
	is.read(bytes);
	is.close();
	
	// kontrolli formaati
	if (!(new String(bytes, 0, 6)).equals("GIF89a")) {
		throw new UnableToDecodeException("Sisendfailil on vale GIF formaat");
	}
	
	// loe paleti suuruse omadus esimesest kolmest bitist 10. baitis failist
	byte[] b10 = Binary.toBitArray(bytes[10]);
	byte bsize = Binary.toByte(new byte[] {b10[0], b10[1], b10[2]});
	
	// arvuta värvide arv ja võimaliku sõnumi pikkus
	int bOrigColorCount = (int)Math.pow(2, bsize + 1);
	int possibleMessageLength = bOrigColorCount * 3 / 4;
	int possibleTextLength = possibleMessageLength - 2; // üks bait kontrolliks ja üks bait sõnumi pikkuseks
	
	int n = 13;
	
	// loe kontrolljärjestus
	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("Pildil ei ole krüptitud sõnumit (kontrolljärjestus on vale)");
	}
	
	// loe teksti pikkus
	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("Dekodeeritud teksti pikkus on vähem kui 0");
	}
	if (possibleTextLength < textLength) {
		throw new UnableToDecodeException("Ei ole sõnumeid (Dekodeeritud sõnumi pikkus (" + textLength + ") on väiksem kui Võimalik sõnumi pikkus (" + possibleTextLength + "))");
	}
	
	// loe teksti baitid ja tee teksti baitideks
	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);
}

Klassi rakendus GIFEncryptorByPaletteExtensionMethod on sarnane, ainult salvestamise/loetava teabe meetod erineb.

Klassis MainFrame on kirjeldatud "ümbrismooduseid": encryptImage(Encryptor encryptor) ja decryptImage(Encryptor encryptor), mis töötlevad liidese meetodite tulemusi Encryptor ja võimaldavad kasutajaga suhtlemist, st avavad failide valiku dialooge, kuvavad veateateid jne; samuti teised meetodid: openImage(), mis võimaldab kasutajal koos pilti valida, exit(), mis võimaldab rakendusest väljumist. Need meetodid kutsutakse esile vastava menüüpunkti Toiming‘de kaudu. Selles klassis on samuti rakendatud abimeetodeid: createComponents() — vormi komponentide loomine, loadImageFile(File f) — pildi laadimine spetsiaalsesse komponenti failist. Klasside rakendus GIFEncryptorByPaletteExtensionMethod on sarnane klassi rakendusele GIFEncryptorByLSBMethod, peamine erinevus seisneb sõnumi baitide kirjutamise ja lugemise meetodis paletist.

Programmi töö

LBS meetod

Oletame, et on olemas selline pilt:

Antud pildil on värvipalett, mis koosneb 256 värvist (sellisena salvestab Paint). Esimesed neli värvi: valge, must, punane, roheline. Ülejäänud värvid on mustad. Globaalse paletti bitijärjestus on järgmine:

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

Pärast sõnumi peitmist asendatakse allajoonitud bitid sõnumi bitidega. Saadud pilt ei erine originaalist peaaegu üldse.

Originaal
Pilt peidetud sõnumiga

Värvipaleti laiendamise meetod

Avades pildi, kuhu see meetodiga sõnum on peidetud, võib ette tulla järgmine pilt:

Muidugi ei sobi selline meetod täielikuks luuretegevuseks ja võib-olla vajab see lisakodeerimist.

Krüpteerimine/dekrüpteerimine animeeritud piltides töötab samamoodi nagu tavalistes staatilistes piltides, samas kui animatsioon ei riku.

Kasutatavad allikaid:

• http://ru.wikipedia.org/wiki/Gif
• http://ru.wikipedia.org/wiki/Стеганография
• http://home.onego.ru/~chiezo/gif.htm

Laadi alla:

• Programm
• Algfailid

Allikas: habr.com