C ++使用按位运算从图像中提取字符

Question

this is my first time here asking a questions, so bear with me! I have a steganography lab that I am nearly complete with. I have completed a program that hides a message in the lower bits of an image, but the program to extract the image is where I am stuck. The image is in a file represented as a 2D matrix, column major order. So here is the code where I am stuck.

void image::reveal_message()
{
    int bitcount = 0;
    char c;
    char *msg;
    while(c != '\0' || bitcount < 1128)
    {
        for(int z = 0; z < cols; z++)
        {
            for(int k = 0; k < 8; k++)
            {
                int i = bitcount % rows ;
                int j = bitcount / rows ;
                int b = c & 1;
                if(img[i][j] % 2 != 0 && b == 0)
                {
                    c = c & (~1);
                }
                else if(img[i][j] % 2 == 0 && b == 1)
                {
                    c = c | 1;
                }
                bitcount++;
                c = c << 1;
            }
            reverse_bits(c);
            cout << c << endl;
            //strncat(msg, &c, 1);
        }
    }
    int i = 0;
    for(int i = 0; i < cols; i++)
    {
        if(!isprint(msg[i]))
        {
            cout << "There is no hidden message" << endl;
        }
    }
    cout << "This is the hidden message" << endl;
    cout << msg;
}

The code is able to loop through and grab all the right number for the bits. The bits are based on if the number in the matrix is odd or even. Where I am having trouble is actually setting the bits of the char to the bits the I extracted from the matrix. I am not the best at bit-wise operations, and we are also not supposed to use any library for this. The reverse_bits function works as well, so it seems to be just my shifting and bit-wise operations are messed up.I also commented out the strcat() line because it was producing a lot of errors due to the fact that char c is incorrect. Also the main error I keep receiving is Segmentation Dump.

Answer 1

You start with undefined data in your char c .

You read from it here int b = c & 1; .

That is clearly nonsense.

            c = c <<1; // shift before, not after
            // if odd clear:
            if(img[i][j] % 2)
            {
                c = c & (~1);
            }
            else // if even set:
            {
                c = c | 1;
            }

the above may not read the data, but at least is not nonesense.

The bitwise operations look otherwise fine.

char *msg; should be std::string , and use += instead of strncat .

Answer 2

My understanding from your code is that you embedded your message as 1 bit per pixel, row by row. For example, if you have a 3x10 image, with pixels

01 02 03 04 05 06 07 08 09 10
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30

the first character of your message resides in the pixels 01-08, the second from 09 to 16, etc. After your message, you embedded an extra null character, which you can use during extraction to know when to stop. With all that in mind, you're looking for something like this.

int bitcount = 0;
int i = 0;
int j = 0;

while(bitcount < 1128)
{
    // this will serve as the ordinal value for the extracted char
    int b = 0;
    for(int k = 0; k < 8; k++)
    {
        b = (b << 1) | (img[i][j] & 1);
        j++;
        if(j == cols)
        {
            i++;
            j = 0;
        }
    }
    bitcount += 8;
    // do whatever you want with this, print it, store it somewhere, etc
    c = (char)b;
    if(c == '\0')
    {
        break;
    }
}

Understanding how the bitshifting work. b starts with the value 0, or 00000000 if you would like to visualise it in binary. Every time, you shift it to the left by one to make room for the new extracted bit, which you OR. No need to check whether it's 1 or 0, it'll just work.

So, imagine you've extracted 5 bits so far, b is 00010011 and the least significant bit of the current image pixel is 1. What will happen is this

b = (b << 1) | 1    // b = 00100110 | 1 = 00100111

And thus you have extracted the 6th bit.

Now, let's say you embedded the character "a" (01100001) in the first 8 pixels.

01 02 03 04 05 06 07 08    \\ pixels
 0  1  1  0  0  0  0  1    \\ least significant bit of each pixel

When you extract the bits with the above, b will equal to 97 and c will give you "a". However, if you embedded your bits in the reverse order, ie,

01 02 03 04 05 06 07 08    \\ pixels
 1  0  0  0  0  1  1  0    \\ least significant bit of each pixel

you should change the extracting algorithm to the following so you won't have to reverse the bits later on

int b = 0;
for(int k = 7; k <= 0; k--)
{
    b = b | ((img[i][j] & 1) << k);
    // etc
}