Extracting data from an image (Java Steganography)

Question

Hey all!
I am writing an application in Java that hides bytes in an images pixel's Least Significant Bits.
Here is the embeding function (mind you, its at an early stage). As far as I can tell, it works perfectly...
     public BufferedImage LSB_BufferedImageEmbed(BufferedImage image, byte[] data)
          int imgWidth = image.getWidth(null);
          int imgHeight = image.getHeight(null);
          //preformat the data array and return as an array of ints?
          int[] formated_data = FormatDataArray(data);
          int index = 0;
          try
               for(int i = 0; i < imgHeight; i++)
                    for(int j = 0; j < imgWidth; j++)
                         if(index == formated_data.length)
                              break;
                         System.out.print("Pixel prior Embed: " + image.getRGB(j, i) + "\n");
                         int current_pixel = image.getRGB(j, i);
                         int current_data = formated_data[index++];
                         //Perform bitwise AND on current pixel value - isolating the Least Significant bits.
                         //NB: Mask is = ff fc fc fc [Alpha Byte] [Red] [Green] [Blue]
                         //1111 1111 - 1111 1100 - 1111 1100 - 1111 1100
                         current_pixel &= 0xfffcfcfc;
                         //x << y is "shift x right by y spaces"
                         //Add bits 5,4 of current data to the bottom of the red channel - xx -- xx xx
                         current_pixel = current_pixel + ((current_data & 0x30) << 12);
                         //Add bits 3,2 of current data to the bottom of the green channel - xx xx -- xx
                         current_pixel = current_pixel + ((current_data & 0x0c) << 6);
                         //Add bits 1,0 of current data to the bottom of the blue channel - xx xx xx --
                         current_pixel = current_pixel + (current_data & 0x03);
                         image.setRGB(j, i, current_pixel);
          catch(Exception e)
               System.out.println("Problem with LSB!!");
          return image;
And here's the corresponding extraction method
     public byte[] LSB_ExtractFromBufferedImage(BufferedImage image)
          int imgWidth = image.getWidth(null);
          int imgHeight = image.getHeight(null);
          int index = 0;
          byte[] extracted_bytes;
          byte[] extracted_data = new byte[12];
          try
               for (int i = 0; i < imgHeight; i++)
                    for (int j = 0; j < imgWidth; j++)
                         if(index == extracted_data.length)
                              break;
                         System.out.print("Pixel prior Extract: " + image.getRGB(j, i) + "\n");
                         int current_pixel = image.getRGB(j, i);
                         //Isolate the bit pattern needed for the Int to byte[] method...
                         current_pixel &= 0x00030303;
                         extracted_bytes = IntToByteArray(current_pixel);
                         for(int t = 0; t < 4; t++)
                              extracted_data[index++] = extracted_bytes[t];
          catch(Exception e)
               System.out.println("Problem with LSB Extraction!!");
          return extracted_data;
Unfortunately, this doesn't work all that well (by that, I mean not working at all!) It does return the bits alright, but not the ones that were previosuly embedded. Does anyone have any ideas on any aspect of these methods as to why that shouldn't work??
Any help is greatly appreciated!
Cougaris

Answer 1

Are you sure that you interpret your results correctly ?
Your routines use different data representations and that leads easily to misinterpretation.
Especially as you only use 6 Bits from an int but take 4 Bytes as result.
Post some input and output data. i.e. an array of 3 values for formattedData and the 12 resulting bytes. I expect the data to be correct (relative to your code, probably not to your intentions).
Regards
SH