3. Steganograph

Steganograph

  • T

    Ich progge grade meinen Steganograph, aber schaffe es nicht, die niedrigen Bits einer unsigned int Variable zu manipulieren.

    unsigned char c;
    unsigned int pC;
    --> pC ist in wirklichkeit ein Array, das die Farbwerte enthält

    Wie kann ich mit c den letzten Byte von pC überschreiben?

    und wie kann ich c wieder auslesen?

    Byte:
7 6 5 4 3 2 1 0
---------------
              |
              c
    0
  • J

    Ich glaube, dass was du meinst, geht mit einem reinterpret_cast:

    #include <iostream>

int main(int argc, char *argv[])
{
    unsigned int Zahl = 123;
    unsigned char Byte = 2;
    *(reinterpret_cast<unsigned char*>(&Zahl) + 3) = Byte; // hier der vierte byte
    // das ganze dann so gezählz, dass 0 der byte ist, der bei dir 7 ist.
    std::cout << Zahl;
    system("PAUSE");
    return EXIT_SUCCESS;
}

    mfg.

    0
  • T

    Kommt zum Absturz...

    0
  • T

    War mein Fehler...

    0
  • T

    Und wie bekomme ich meinen char Wert wieder heraus?

    0
  • C

    Tc++H schrieb:

    Und wie bekomme ich meinen char Wert wieder heraus?

    Hallo,
    Ich verstehe nicht ganz, warum man hier einen reinterpret_cast<>() verwendet... Geht doch viel einfacher und schöner mit einfachen Bitmanipulationen.

    Beispiel:

    unsigned int i = 512; // bitmuster: 00000000 00000000 00000010 00000000
unsigned char c = 16; // bitmuster: 00010000

// Letztes Byte eines Ints mit den Bits eines Char-Werts überschreiben.
unsigned int out = i | c; // out enthält den Wert 528, denn bitmuster: 00000000 00000000 00000010 00010000

// Letztes Byte aus dem Int wieder herstellen:
unsigned int out = i & 0xFF; // out enthält den Wert 16, denn bitmuster: 00010000

    Gruß Caipi

    0
  • T

    genau... sowas brauchte ich...

    0
  • T

    Kennt jemand eine gute Beschreibung zu den BItmanipulatoren?

    0
  • ?

    Caipi schrieb:

    Tc++H schrieb:

    Und wie bekomme ich meinen char Wert wieder heraus?

    Hallo,
    Ich verstehe nicht ganz, warum man hier einen reinterpret_cast<>() verwendet... Geht doch viel einfacher und schöner mit einfachen Bitmanipulationen.

    Beispiel:

    unsigned int i = 512; // bitmuster: 00000000 00000000 00000010 00000000
unsigned char c = 16; // bitmuster: 00010000

// Letztes Byte eines Ints mit den Bits eines Char-Werts überschreiben.
unsigned int out = i | c; // out enthält den Wert 528, denn bitmuster: 00000000 00000000 00000010 00010000

// Letztes Byte aus dem Int wieder herstellen:
unsigned int out = i & 0xFF; // out enthält den Wert 16, denn bitmuster: 00010000

    Gruß Caipi

    Aber das geht ja jetzt nur für den letzten Byte, oder?

    0
  • ?

    Für die höherwertigen Bytes mußt du c entsprechend weit nach links shiften (dann rechnest du mit c<<n*8 (n-Position im int).

    0
  • T

    Ich habe noch ein kleines Problem mit der Bitmap speicherfunktion...
    Und zwar speichert er die Bitmap in ner falschen Farbe... aber lädt sie richtig, ich habe sie mal ausgegeben mit Hilfe der WinAPI
    Statt GetXValue(...) würde ich auch lieber Bitmanipulatoren verwenden

    #pragma  pack(1)
struct BMFH // BitmapFileHeader
{
	char         bmtype[2];     // 2 bytes - 'B' 'M'
	unsigned int iFileSize;     // 4 bytes
	short int    reserved1;     // 2 bytes
	short int    reserved2;     // 2 bytes
	unsigned int iOffsetBits;   // 4 bytes

};
#pragma pack()

#pragma pack(1)
struct BMIF // BitmapInfoHeader
{
	unsigned int iSizeHeader;    // 4 bytes - 40
	unsigned int iWidth;         // 4 bytes
	unsigned int iHeight;        // 4 bytes
	short int    iPlanes;        // 2 bytes
	short int    iBitCount;      // 2 bytes
	unsigned int Compression;    // 4 bytes
	unsigned int iSizeImage;     // 4 bytes
	unsigned int iXPelsPerMeter; // 4 bytes
	unsigned int iYPelsPerMeter; // 4 bytes
	unsigned int iClrUsed;       // 4 bytes
	unsigned int iClrImportant;  // 4 bytes
};// End of stBMIF structure - size 40 bytes
#pragma pack()

struct Image
{
	unsigned int iWidth;
	unsigned int iHeight;
	unsigned int* pARGB; // Alpha Red Green Blue
};

...
std::basic_fstream<char> in("test1.bmp", std::ios_base::in | std::ios_base::binary);
if(!in)
return -1;

BMFH bMFH;
BMIF bMIF;

in.read((char*) &bMFH, sizeof(BMFH));
in.read((char*) &bMIF, sizeof(BMIF));

Image img;
img.iWidth  = bMIF.iWidth;
img.iHeight = bMIF.iHeight;
img.pARGB	= new(unsigned int[img.iWidth * img.iHeight]);

int iNumPaddedBytes = (img.iWidth * 3) % 4;

in.seekp(bMFH.iOffsetBits);
for(unsigned int h = 0; h < img.iHeight; h ++)
{
	for(unsigned int w = 0; w < img.iWidth; w ++)
	{
		unsigned char r, g, b;

		in.read((char*) &b, sizeof(char));
		in.read((char*) &g, sizeof(char));
		in.read((char*) &r, sizeof(char));

		img.pARGB[w + h * img.iWidth] = (r << 16 | g << 8 | b);
	}

	if(iNumPaddedBytes != 0)
	{
		unsigned char skip[4];
		in.read((char*) &skip, sizeof(skip));
	}
}

//////////////////////////////////////////////////////////////////////////////
// Speichern
std::basic_fstream<char> out("test3.bmp", std::ios_base::out | std::ios_base::binary);
out.write((char*) &bMFH, sizeof(BMFH));
out.write((char*) &bMIF, sizeof(BMIF));

unsigned char r, g, b;
for(unsigned int h = 0; h < img.iHeight; h ++)
{
	for(unsigned int w = 0; w < img.iWidth; w ++)
	{
		r  = img.pARGB[w + h * img.iWidth] = GetRValue(img.pARGB[w + h * img.iWidth]);
		g  = img.pARGB[w + h * img.iWidth] = GetGValue(img.pARGB[w + h * img.iWidth]);
		b  = img.pARGB[w + h * img.iWidth] = GetBValue(img.pARGB[w + h * img.iWidth]);

		out.write((char*) &r, sizeof(char));
		out.write((char*) &g, sizeof(char));
		out.write((char*) &b, sizeof(char));

	}
}

delete[](img.pARGB);
...
    0
  • T

    Kann mir jemand helfen, wie man eine Bitmap speichert?? und acu effizient lädt?

    0
  • J

    Tc++H schrieb:

    Kann mir jemand helfen, wie man eine Bitmap speichert?? und acu effizient lädt?

    Jo, ich hab gerade im anderem Beitrag beim WinAPI Forum geantwortet.

    mfg.

    0
  • T

    Ich habe es mal mit den Bitmanipulatoren getestet aber es funktioniert nicht... bei mir kommt nicht 16, sonder 0 raus.

    int main()
{
	unsigned int i = 512;
	unsigned char c = 16;
	unsigned out1 = i | c;
	cout << out1 << endl;

	unsigned int out2 = i & 0xff;
	cout << out2;

	char a;
	cin >> a;
	return 0;
}
    0
  • B

    Wo soll hier 16 rauskommen?
    Bei out1 muss 528 und bei out2 0 rauskommen.

    0
  • T

    Ja, ich habe was falsch gemacht, mein Fehler.

    Aber ich habe noch ein andres Prob: Warum darf i nur 512 oder 1024 betragen?

    0
Anmelden zum Antworten