Steganografie
Ich hab mich mal etwas mit Steganografie beschäftigt und mir überlegt sowas zu programmieren.
Also ich möchte in einem bmp-Bild etwas verstecken.
Ich weiß, dass ich den zu versteckenden Text in bytes umwandeln muss.
Aber wo schreib ich das in das Bild und wie kann ich das auch wieder entschlüsseln?
Das Bild sollte sich ja auch nicht sichtbar verändern.
Bin für Tipps dankbar.
Gruß
Michael
Hallo smichae,
Ich denke dieses hier sollte Dir schonmal einen guten Einblick geben
mfg
Hallo smichae,
Für einfache Steganografie würdest du das Bild als 24bpp Bitmap-Objekt erstellen/laden und dir mit LockBits Zugriff auf die Pixelinformation holen. Dort würdest du die niederwertigsten Bits jedes Bytes fortlaufend mit den Bits aus deinen zu versteckenden Daten überschreiben. Zumindest wäre so grob die Vorgehensweise.
Für Bitoperationen siehe [Artikel] Bitoperationen in C#
herbivore
Ich meine das es auf CodeProject sich damit mit einer ganzen Artikelserie drüber beschäftigt hat. Einfach mal suchen. War sehr interessant...
"Jedes Ding hat drei Seiten, eine positive, eine negative und eine komische." (Karl Valentin)
Hallo,
wir haben genau so ein Programm im Rahmen eines Schulprojekt programmieren müssen.
Informier dich erstmal darüber wie eine BMP Datei aufgebaut ist. Du wirst sehen das ein Byte pro Pixel immer ungenutzt ist. Dort kannst du deine Information verstecken. Das Problem ist aber das man die versteckte Information in einem Hex-Editor sofort sehen kann. Wir sind dann noch eine Stufe tiefer gegangen und haben unsere Informatio bitweise versteckt. Wenn man das niederwertigste Bit ändert ist dies vom menschlichen Auge kaum erkennbar.
Gruss
tscherno
To understand recursion you must first understand recursion
Hallo tscherno,
Du wirst sehen das ein Byte pro Pixel immer ungenutzt ist.
das halte ich für ein Gerücht.
herbivore
da ich immer auf solche versteckspiele stehe, musste ich gleich nach schauen.
meinst du das, was unter Beschreibung des BMP-Formates / Farbpalette steht?
http://www.fh-wedel.de/~bek/c/praktika/seminar-iass02.html
das halte ich für ein Gerücht.
Naja Photoshop verwendet es als Alphakanal, aber das ist AFAIK nicht standard.
Unserer Vorgabe war dass die Bilder in Paint auf visuelle unterschiede geprüft werden, deshalb haben wir uns darum nicht weiter gekümmert.
meinst du das, was unter Beschreibung des BMP-Formates / Farbpalette steht?
Nein, ich meinte eigentlich die verbleibenden 8-Bit bei einer 32-Bit Bitmap.
(siehe Wikipedia)
Der Nachteil bei diesem Vorgehen ist halt dass es bei Bitmaps mit kleinerer bpp nicht mehr funktioniert.
Gruss
tscherno
To understand recursion you must first understand recursion
Danke für eure Hilfe, ich kann jetzt die einzelnen Farbanteile eines Pixel ändern.
Also 255,255,255 wird zu 255,255,101 oder so.
Je nach Buchstabe.
Wie bekomm ich aber ein Bild in binäre Form, also z.B. 0101...?
Damit ich das LSB ändern kann.
Ich hab das momentan so:
IS ist der Pfad zum Bild.
MemoryStream IS = new MemoryStream();
Bild.Save(IS, Bildformat);
IS.Flush();
return IS.ToArray();
Dann liegt das Bild aber nicht in binärer Form vor.
Weiß noch jemand Rat?
Danke.
Gruß
Michael
Ich habe System.Collections.BitArray und Bitoperatoren benutzt. Sicherlich währe das ganze auch nur mit Bitoperatoren lösbar und dann auch sicher um einiges schneller.
Gruss
tscherno
To understand recursion you must first understand recursion
Ich versteh immer noch nicht, wie ich an die LSBs aus dem Bild komme.
Hat noch jemand eine Idee?
@tscherno: Wie soll mich das weiterbringen?
Gruß
Michael
Die ganze Datei Bitweise einzulesen (was mit BitArray möglich währe) wird dich nicht weiterbringen da du dann ein Problem beim zurückschreiben haben wirst. Die Lösung stellen wie bereits gesagt die Bitoperatoren dar. Du kannst den LSB mit ihnen setzen.
Es gibt mehrere Möglichkeiten, ich habe es so gemacht:
1.) Das letzte Bit erstmal auf 0 setzen:
Das erreichst du mit einmal nach recht und einmal nach links schieben.
Anfangszustand: : //11111111 (255)
Rechts schieben: (>>): //01111111 (127)
Links schieben: (<<): //11111110 (254)
2.) Jetzt kannst du mit einer ODER-Verknüpfung das letzte Bit auf 1 setzen (byte ODER 1).
Wert: 11111110 (254)
Maske: 00000001 (1)
Ergeb: 11111111 (255)
1 ODER 0 = 1.
Siehe auch: http://de.wikipedia.org/wiki/Bitweiser_Operator
Gruss
tscherno
To understand recursion you must first understand recursion
Ok, das ist ja schon ganz gut als Tipp.
Ich weiß aber noch nicht ganz was ich als "bits" brauche.
Ich hab z.B. das Pixel an der Stelle 0, 0.
Das hat z.B. die Farbe (255, 255, 255) . Von welcher Farbe hol ich mir die bits? Oder von was brauch ich die bits?
Danke.
Gruß
Michael
Hallo,
nehmen wir an du hast deine geheime Information Bitweise. z.b. 1010
Jetzt holst du dir z.b. von jedem Pixel den Blauanteil in einer Schleife. Angenommen du bekommst im ersten Durchlauf eine 255 in diesem fall ist das LSB bereits auf 1. Also kannst du weiter machen. Angenommen du bekommst wieder eine 255 das zweite Bit der geheimen Information ist 0. Also musst du den LSB hier auf 0 setzen (siehe oben).
So machst du weiter bis du die ganze geheime Information durch hast. Damit das auslesen funktioniert musst du irgendwo einen Wert speichern der angibt wie lange die geheime Information ist, oder irgendeine andere Markierugn setzen damit das Ausleseprogramm weis das hier die geheime Information zu ende ist.
Gruss
tscherno
To understand recursion you must first understand recursion
Ok, das mit dem verstecken der Nachricht klappt schon ganz gut.
Ist aber noch nicht ganz ausgereift.
Weiß aber nicht, wie ich die Länge der Nachricht verstecken könnte.
Sollte das im ersten Pixel(0,0) stehen? Im Header der bmp-Datei wird das ja nicht gehen?!
Gruß & Danke
Michael
Hallo smichae,
nicht unbedingt im ersten Pixel aber einfach in den ersten z.B. 64 Bit der Nachricht.
herbivore
Aber ich muss ja wissen wo die Länge steht bzw. ob es 64 Bit Platz benötigt.
Wenn ich 64 Bit für die Länge reserviere weiß ich aber doch nicht, ob ich alle 64 Bit zum Auslesen der Länge benötige.
Also z.B. in den ersten 5 Pixeln! Kann aber doch je nach Länge mal kürzer und mal länger sein wenn die Länge der Nachricht mal 2 ist und mal 1000.
Je nachdem brauch ich ja auch mehr Platz zum abspeichern.
Kann ich in den Header irgendwo auch was schreiben? Eher nicht oder?
Gruß
Michael
Hallo smichae,
Aber ich muss ja wissen wo die Länge steht
als erstes vor oder wenn du so willst als erstes in der Nachricht.
bzw. ob es 64 Bit Platz benötigt.
Das legt man einfach fest.
Wenn ich 64 Bit für die Länge reserviere weiß ich aber doch nicht, ob ich alle 64 Bit zum Auslesen der Länge benötige.
Wie gesagt, man würde die Länge in einer festgelegten Anzahl von Bits speichern.
Also z.B. in den ersten 5 Pixeln! Kann aber doch je nach Länge mal kürzer und mal länger sein wenn die Länge der Nachricht mal 2 ist und mal 1000.
Die Länge der Nachricht kann sich natürlich unterscheiden, aber die Anzahl der Bits, in der man sich diese Länge merkt, legt man fest.
Kann ich in den Header irgendwo auch was schreiben? Eher nicht oder?
In den Header der Bitmap-Datei würde ich nichts schreiben.
herbivore
Wenn ich 64 Bit für die Länge reserviere weiß ich aber doch nicht, ob ich alle 64 Bit zum Auslesen der Länge benötige.
Wie gesagt, man würde die Länge in einer festgelegten Anzahl von Bits speichern.Also z.B. in den ersten 5 Pixeln! Kann aber doch je nach Länge mal kürzer und mal länger sein wenn die Länge der Nachricht mal 2 ist und mal 1000.
Die Länge der Nachricht kann sich natürlich unterscheiden, aber die Anzahl der Bits, in der man sich diese Länge merkt, legt man fest.herbivore
Das heißt ich würde z.B. 64 Bit reservieren. Wenn ich aber für die Länge nur 30 Bit benötige, könnte ich die ersten 34 Bit mit "0" füllen, so dass sich die Länge(der Wert) nicht verändert und immer 64 Bit auslesen?!
Also nach dem Prinzip: "11" ist das gleiche wie "00011". Beides hat dezimal den Wert 3.
Ich hoffe ich hab das endlich richtig verstanden.
Danke für deine Mühe herbivore.
Gruß
Michael
Hallo smichae,
ja, du hast es schon richtig verstanden.
Ich finde es nur sehr kompliziert gedacht. So wie du auch die eigentlichen Daten in der Bitmap speicherst, speicherst einfach als erstes einen Int64 (oder von mir aus auch nur einen Int32), der die Länge enthält. Du musst dir also in dem Sinne nicht um das Auffüllen mit 0-Bits kümmern, sondern speicherst eben immer einfach alle 64 Bits des Int64 und liest später wider alle 64 Bits in einen Int64 aus.
herbivore
Ich speichere momentan die Nachricht genauso ab, wie ich es mit der Länge beschrieben habe.
Also z.B. "e" mit 1100101.
Dann ändere ich das LSB des rot-Anteils falls nötig mit einer oder-Verknüpfung.
Wie kann ich das als Int64 abspeichern, also in das bitmap einfügen ohne es bitweise zu machen, wie ich das mit der Nachricht mach?
Sorry, das ich das grad nicht ganz versteh.
Gruß
Michael
Hallo smichae,
am einfachsten ist es doch deine Nutzdaten immer erst in ein byte[] umzuwandeln und dann das Byte-Array (so wie du es eben beschrieben hast, immer 8bit-weise) zu verstecken. Dann kannst du beliebige Daten verstecken. Einen String wandelst du mit Encoding.GetBytes (String) in ein byte[] um. Einen Int64 mit BitConverter.GetBytes (Int64).
herbivore
Ich mach es bisher so:
private void bit()
{
string nachricht = "e s";
buchs_array = new string[9];
int i = 0;
foreach (char buchstabe in nachricht )
{
//Hier bekomm ich den String bitweise
buchs_array[i] = Convert.ToString(buchstabe, 2);
i++;
}
int counter = i;
}
//Verstecken der Nachricht
private void pixel(Bitmap bitmap)
{
int i, j;
string colorR, colorG, colorB;
int height = bitmap.Height;
int width = bitmap.Width;
string kat = Convert.ToString(bitmap.GetPixel(0, 1).R, 2);
int asd = 0;
char[] char_arr = new char[7];
foreach (char zahl in buchs_array[0])
{
char_arr[asd] = zahl;
asd++;
}
int counter = 0;
for (i = 0; i < height; i++)
{
for (j = 0; j < width; j++)
{
colorR = Convert.ToString(bitmap.GetPixel(i, j).R, 2);
colorG = Convert.ToString(bitmap.GetPixel(i, j).G, 2);
colorB = Convert.ToString(bitmap.GetPixel(i, j).B, 2);
if (colorR.EndsWith(char_arr[counter].ToString()))
{
bitmap.SetPixel(i, j, Color.FromArgb(bitmap.GetPixel(i, j).R, bitmap.GetPixel(i, j).G, bitmap.GetPixel(i, j).B));
}
else
{
if (colorR.EndsWith("0"))
{
colorR = colorR.Insert(7, "1");
colorR = colorR.TrimEnd('0');
}
else
{
colorR = colorR.Insert(7, "0");
colorR = colorR.TrimEnd('1');
}
bitmap.SetPixel(i, j, Color.FromArgb(Convert.ToInt32(colorR, 2), bitmap.GetPixel(i, j).G, bitmap.GetPixel(i, j).B));
}
counter++;
if (counter > 6)
break;
}
if (counter > 6)
break;
}
string end = Convert.ToString(bitmap.GetPixel(0, 1).R, 2);
bitmap.Save("C:\\red2.bmp");
}
Ändert das mit dem byte-Array da was? Kommt das nicht auf das gleiche raus.
Gruß
Michael
Hallo smichae,
Ändert das mit dem byte-Array da was?
ja, du kannst dann wie gesagt auf eine einheitliche Weise beliebige Daten speichern.
Du solltest sowieso besser mit Bitoperationen ([Artikel] Bitoperationen in C#) arbeiten und nicht mit Strings, die binäre Zahlen enthalten, wie du es mit Convert.ToString(buchstabe, 2); machst.
herbivore
Ich komm da nicht ganz mit. Könntest du mir bitte noch ein kleines Bsp. geben,
z.B. mit RGB(255,0,0) und dem Buchstaben e.
Ich wandel das "e" in ein byte-Array um? Richtig?
Dann hab ich 101 in einem byte-Array. Was mach ich dann damit, dass es in das bitmap kommt?
Ich muss doch dann die 101 in bits bekommen, das wäre dann 01100101.
Ist das schon falsch?
Das würde ich ja mit
Convert.ToString("e", 2)
auch erhalten.
Vielen, vielen Dank für deine Hilfe, irgendwie komm ich noch nicht ganz mit. Vielleicht kannst du mir nochmal kurz helfen.
Gruß
Michael
P.S.: Welchen Teil meinst du aus dem Link? Shifting? Aber was bringt mir das?
Hallo smichae,
Ich wandel das "e" in ein byte-Array um? Richtig?
Nein, du wandelst den ganzen Text auf einmal in ein Byte-Array um. Mit welcher Methode das geht, habe ich schon geschrieben.
Dann hab ich 101 in einem byte-Array.
Vergiss mal die 101, also den Zeichencode. Der spielt kein Rolle.
Ich muss doch dann die 101 in bits bekommen, das wäre dann 01100101.
Nein, durch die Umwandlung in das byte-Array ist schon alles erledigt. Jedes Byte hat 8 Bits. Auf die greifst du direkt über die Bitoperationen zu.
Was mach ich dann damit, dass es in das bitmap kommt?
Das was du jetzt auch schon machst, vom Prinzip her, nur dass du das der String-Funktionen wie EndsWith die Bitoperationen verwendest, um zu ermitteln, ob ein Bit gesetzt ist oder nicht.
herbivore
Hallo smichae,
Ich wandel das "e" in ein byte-Array um? Richtig?
Nein, du wandelst den ganzen Text auf einmal in ein Byte-Array um. Mit welcher Methode das geht, habe ich schon geschrieben.herbivore
Aber in dem byte-Array steht ja auch für "e" 101.
Das muss ich dann ja noch bitweise in das bitmap einfügen.
Vielen Dank für deine Hilfe.
Ok, das mit der Bitoperation hab ich jetzt verstanden, denk ich.
Danke für deine Geduld.
Gruß
Michael
Hallo smichae,
Aber in dem byte-Array steht ja auch für "e" 101.
Es mag sein, dass in dem Byte-Array ein Byte mit dem numerischen, dezimalen Wert 101 enthalten ist. Wenn und da du aber über die Bitoperationen sowieso nur auf die Bits des Bytes zugreifst, interessiert der nummerische, dezimale Wert nicht.
Das muss ich dann ja noch bitweise in das bitmap einfügen.
Richtig, das machst du wie gehabt, du musst eben nur die String-Operationen durch die Bitoperationen ersetzen.
herbivore
Klar interessiert der dezimal-Wert nicht.
Das heißt aber, dass ich den Inhalt des byte-Arrays in bit umwandeln muss?! Genau das mach ich ja auch.
Oder bin ich schon wieder falsch?
Aber du meinst, dass es einfach besser ist das über ein byte-Array zu machen als über string?!
Hab ich's jetzt endlich kapiert? Ich hoff schon. Irgendwie steh ich grad total auf dem Schlauch.
Danke für deine Mühe und sorry dafür.
Ich hoff ich hab's jetzt dann endlich verstanden.
Das mit der Länge ist mir aber doch noch nicht ganz klar.
Ich habe meinetwegen einen Text mit der Länge 200.
Wenn ich den jetzt mit
Int64 zahl = 200;
BitConverter.GetBytes (zahl)
umwandel, steht aber immer die Zahl, also in dem Fall "200" im byte-array?
Wie bekomm ich das in die 64 Bits im Bild?
Danke wenn du mir, hoffentlich ein letztes Mal, hilfst.
Gruß und Danke
Michael
Hallo smichae,
Das heißt aber, dass ich den Inhalt des byte-Arrays in bit umwandeln muss?!
nein, musst du nicht. Mit den Bitoperationen kannst du direkt auf die Bits des Bytes zu greifen.
Genau das mach ich ja auch.
Du meinst mit Convert.ToString("e", 2). Damit erzeugst du einen String aus den Ziffern oder noch besser gesagt den Zeichen "0" und "1". Das sind keine Bits.
Aber du meinst, dass es einfach besser ist das über ein byte-Array zu machen als über string?!
Ja!
Wenn ich den jetzt mit ... umwandel, steht aber immer die Zahl, also in dem Fall "200" im byte-array?
Ja, so kann man das sehen. Genaugenommen enthält das Byte-Array die Repräsentation eines Int64 mit dem Wert 200.
Wie bekomm ich das in die 64 Bits im Bild?
Ich dacht, das hättest du jetzt verstanden. Im Prinzip genauso wie du es bisher machst, aber eben mit Bitoperationen statt mit String-Operationen. Den Artikel habe ich ja schon verlinkt. Du kannst aber auch in ein Buch schauen. Bitoperationen sind wichtig. Musst du sowieso lernen, wie das geht.
herbivore
Ok, hoffentlich letzter Versuch, aber ich glaub ich kapier es endlich.
DANKE!!! für deine Geduld mit mir.
//Länge des Textes
Int64 laenge = 100;
byte[] byte_values = BitConverter.GetBytes(laenge);
//Roter Farbanteil des Pixels
byte_values[1] = 150;
byte erg1 = (byte)(byte_values[0] | byte_values[1]); //erg1 = 246
Roten Farbanteil dann ändern nach 246.
Hm, aber woher weiß ich dann die Länge. Stimmt glaub leider noch nicht ganz.
Danke.
Michael
Hallo smichae,
nein, die Programmstruktur musst du schon so lassen, wie du sie oben gepostet hattest. Du darfst byte_values nicht ändern, sondern musst die Bit daraus auslesen.
byte_values entspricht dem bisherigen buchs_array. Und die Verwendung von char_arr wird eben ersetzt durch das direkte Abfragen der Bits per Bitoperation.
herbivore
Achso. Danke.
Und an Stelle 0 im byte-array schreib ich die Länge der Nachricht.
Und die Verwendung von char_arr wird eben ersetzt durch das direkte Abfragen der Bits per Bitoperation.
Was ich aber noch nichz ganz versteh ist, wie ich die einzelnen bits des Inhalts des byte-array mit dem LSB der Pixel vergleich.
Oder verändere ich die ganze Farbe mit der Oder-Verknüpfung?
Gruß
Michael
Hallo smichae,
Und an Stelle 0 im byte-array schreib ich die Länge der Nachricht.
Wenn dir eine Länge von 0-255 reicht, dann ja. Wenn du wie vorgeschlagen einen Int64 verwenden willst, dann würdest du die ersten 8 Stellen des byte-Arrays für die Länge verwenden, bei einem Int32 entsprechend die ersten 4 Stellen. Genau das musst du festlegen.
Was ich aber noch nichz ganz versteh ist, wie ich die einzelnen bits des Inhalts des byte-array mit dem LSB der Pixel vergleich.
Eben mit den Bitoperationen. Mit (byte_values _ & 0x01) == 0x01 prüfst du z.B., ob das LSB des i-ten Bytes gesetzt ist. Aber genau das steht ja in dem Artikel und im Zweifel auch im Galileo <openbook>: Visual C# 2005 von Andreas Kühnel.
herbivore
Ah ok, danke für deine Hilfe.
Wenn ich jetzt die ersten 64 Bit im Bild für die Länge des Textes reserviere, wie weiß ich dann beim Auslesen wie lang der Text ist.
Es gibt ja einen Unterschied zwischen 23 und 2300.
Ich muss ja wissen wo die Länge des Textes im Bild aufhört.
Kann ja bei Bit 5 zu Ende sein oder bei Bit 20.
Es kann ja sein, dass das byte-array nicht voll ist, je nach Zahl.
Die Stellen im byte-array, die leer sind, erkenn ich ja dann im Bild, also den Bits nicht oder? Das sind doch auch nur 0?!!
Ich hoffe das war's dann mit meinen Fragen zu dem Thema. Nochmal sorry für die vielen Fragen.
Gruß und vielen Dank.
Michael
Hallo smichae,
Wenn ich jetzt die ersten 64 Bit im Bild für die Länge des Textes reserviere, wie weiß ich dann beim Auslesen wie lang der Text ist.
jetzt enttäuscht du mich aber. Darüber reden wir doch die ganze Zeit. Du weißt das natürlich, in dem du die Länge (die ja in den ersten 64 Bit gespeichert ist) wieder ausliest. Dazu speicherst du sie doch.
herbivore
Ja klar, aber mein byte-array könnte wie folgt aufgebaut sein.
Int64 zahl = 1234;
byte[] byte_values = BitConverter.GetBytes(zahl);
byte_values sieht dann wie folgt aus:
byte_values[0] = 210
byte_values[1] = 4
byte_values[2] = 0
byte_values[3] = 0
byte_values[4] = 0
byte_values[5] = 0
byte_values[6] = 0
byte_values[7] = 0
Ich vergleich jetzt jedes byte_values[] mit dem Pixel. Aber der Inhalt des byte_values ist ja nicht in bits.
Ich muss ja die Zahlen(z.B. 210) dann noch in das Bild schreiben.
Wie soll denn das dann gehen??
Sorry herbivore, irgendwie kann ich noch nicht ganz folgen.
Bitte noch eine kleine erklärung.
Vielen, vielen DANK.
Gruß
Michael
Hallo smichae,
du musst die Bits ins Bild schreiben, richtig. Das hast du in deinem Programm oben schon gemacht. Ok, da waren es Nullen und Einsen in einem String. Aber das kommt ja auf das gleiche hinaus.
Wir fangen an uns im Kreis zu drehen. Es ist alles gesagt. Lies alles noch mal. Meine Unterstützung endet hier.
herbivore
Danke trotzdem für deine Hilfe.
Vielleicht gibt mir noch jemand anderes nochmal einen letzten Hinweis.
Bitte denkt nicht, dass ich die Antworten bzw. die Links nicht gelesen habe. Ich verbringe schon Stunden damit.
Wär sehr dankbar wenn mir jemand nochmal sagen könnte wie ich auf die einzelnen bits in einem byte-array zugreifen kann.
Wenn mir niemand hilft, muss ich das Projekt leider einstampfen. Schade eigentlich. Hat mich nämlich sehr interessiert.
Gruß
Michael
Hallo,
wenn Du ein Byte Array hast dann benötigst Du Bit-Operationen um auf die Bits des Bytes zuzugreifen - das hat ein Vorposter aber schon einmal erwähnt (Link)
Grüsse,
Egon
egrath's Blog: http://egonrath.eg.funpic.de/wordpress