Steganography: how to change the LSB of a pixel array - c++

Question

I'm using the lodePNG library to encode a png image and change the LSB of the pixels with an imported txt file. I've compiled the program but I'm not sure if the PNG file is actually being encoded according to my bitwise operation.
The lodePNG library decodes/encodes from a PNG image and stores the pixels in the vector "image", 4 bytes per pixel, ordered RGBARGBA...,
void decodeOneStep(const char* filename)
{
unsigned width, height;
//decode
unsigned error = lodepng::decode(image, width, height, filename);
//if there's an error, display it
if (error) std::cout << "decoder error " << error << ": " <<
lodepng_error_text(error) << std::endl;
}
The program takes a command line argument of the text file and the PNG file. I have not included error-checking for arguments yet.
int const MAX_SIZE = 100;
std::vector<unsigned char> image;
int main(int argc, char *argv[])
{
const char* filename;
char* textArray = new char[MAX_SIZE];
std::ifstream textfile;
textfile.open(argv[1]);
int numCount = 0;
while (!textfile.eof() && numCount < MAX_SIZE)
{
textfile.get(textArray[numCount]); //reading single character from file to array
numCount++;
}
textfile.close();
filename = argv[2];
decodeOneStep(filename);
unsigned width = 512, height = 512;
image.resize(width * height * 4);
int pixCount = 0;
for (int i = 0; i < numCount - 1; i++) {
std::cout << textArray[i];
for (int j = 0; j < 8; j++) {
std::cout << ((textArray[i]) & 1); //used to see actual bit value.
image[pixCount++] |= ((textArray[i]) & 1);
(textArray[i]) >>= 1;
}
std::cout << std::endl;
}
encodeOneStep(filename, image, width, height);
In the for-loop, I am going through each pixel in the vector and replacing LSB with a bit from the char. Since a char is 8 bytes, the for-loop loops 8 times. This program should work for most PNG images and texts not exceeding size, but I'm not sure the bitwise operation is actually doing anything. Also, how would I be able to shift the bits so that we store the char bits from MSB to LSB? I feel like I'm understanding something wrong with how the pixel values (bits) are stored in the array.
EDIT: Test i've run on the new bit-operation:
for (int j = 7; j >= 0; j--) {
//These tests were written to see if the 4-bits of the pixels were actually being replaced.
//The LSB of the pixel bits are replaced with the MSB of the text character.
std::cout <<"Initial pixel 4-bits: " << std::bitset <4>(image[pixCount]) << " ";
std::cout << "MSB of char: " << ((textArray[i] >> j) & 0x01) << " ";
std::cout << "Pixel LSB replaced: " << ((image[pixCount] & mask) | ((textArray[i] >> j) & 0x01)) << " ";
image[pixCount] = (image[pixCount] & mask) | ((textArray[i] >> j) & 0x01);
pixCount++;
std::cout << std::endl;
}
Test Result:
For char 'a'
Initial pixel 4-bits : 0000 MSB: 0 Pixel LSB replaced: 0
Initial pixel 4-bits : 0001 MSB: 1 Pixel LSB replaced: 1
Initial pixel 4-bits : 0001 MSB: 1 Pixel LSB replaced: 1
Initial pixel 4-bits : 0000 MSB: 0 Pixel LSB replaced: 0
Initial pixel 4-bits : 0000 MSB: 0 Pixel LSB replaced: 0
Initial pixel 4-bits : 0000 MSB: 0 Pixel LSB replaced: 0
Initial pixel 4-bits : 0000 MSB: 0 Pixel LSB replaced: 0
Initial pixel 4-bits : 0001 MSB: 1 Pixel LSB replaced: 1

Answer 1

You first need to clear out the lsb of the pixel before embedding your secret bit.
unsigned char mask = 0xfe; // in binary 11111110
// and in your loop
image[pixCount] = (image[pixCount] & mask) | (textArray[i] & 1);
pixCount++;
If you want to embed the bits of each character of the secret from the most to the least significant bit, you want to count down the j loop.
for (int j = 7; j >= 0; j--) {
image[pixCount] = (image[pixCount] & mask) | ((textArray[i] >> j) & 0x01);
pixCount++;
}
Edit: To explain the code above, image[pixCount] & mask is an AND operator between your pixel and the chosen mask value (1111110 in binary), so the result is that the lsb is cleared.
(textArray[i] >> j) & 0x01 shifts your char to the left by j and only keeps the lsb. If you map out the maths, this is what you get
// assume our character has the bits `abcdefgh`
j = 7
(character >> j) & 0x01 = 0000000a & 0x01 = a
j = 6
(character >> j) & 0x01 = 000000ab & 0x01 = b
j = 5
(character >> j) & 0x01 = 00000abc & 0x01 = c
// and so on
j = 0
(character >> j) & 0x01 = abcdefgh & 0x01 = h