Steganography: Hiding Information in Plain Sight

Figure 4: Source code to "unhide" a message image from a cover image

/* This routine pulls the message image out of the cover image
   (the opposite of the cover_image routine) */

int uncover_image(cover_image_name,
                  message_image_name,
                  cover_image,
                  message_image,
                  mlength,
                  mwidth,
                  clength,
                  cwidth,
                  lsb,
                  n)
   char  cover_image_name[],
         message_image_name[];
   int   lsb, n;
   long  clength, cwidth, mlength, mwidth;
   short **cover_image, 
         **message_image;
{
   int h_counter;

   bread_tiff_image(cover_image_name, cover_image);

   for(h_counter=0; h_counter<mwidth; h_counter++){
      uncover_pixels(cover_image, 
                     message_image,
                     h_counter,
                     h_counter*n,
                     lsb,
                     n,
                     mlength);
   }  /* ends loop over h_counter */

   bwrite_tiff_image(message_image_name, message_image);

}  /* ends uncover_image */

/* This routine pulls the eight bits that make up a pixel in the
   message image out of the LSB of the eight pixels in the cover
   image. It is the opposite of the cover_pixels routine. */

int uncover_pixels(cover_image, 
                message_image,
                mie, 
                cie,
                lsb,
                n,
                mlength)
   int   cie, lsb, mie, n;
   long  mlength;
   short **cover_image, 
         **message_image;
{
   char result,
        new_message,
        sample;

   char mask1[EIGHT] =  
                        {0x80,  /* 1000 0000 */
                         0x40,  /* 0100 0000 */
                         0x20,  /* 0010 0000 */
                         0x10,  /* 0001 0000 */
                         0x08,  /* 0000 1000 */
                         0x04,  /* 0000 0100 */
                         0x02,  /* 0000 0010 */
                         0x01}; /* 0000 0001 */

   int c, c_counter, i, j;

   /* If a pixel in the cover image is odd, its lsb has been set,
      so the corresponding bit in the message image should be
      set */

   for(i=0; i<mlength; i++){
      c = n-1;
      new_message = 0x00;
      for(j=0; j<n; j++){
         if(is_odd(cover_image[i][cie+j])){
            /* set bit c */
            if(lsb)
               new_message = new_message | mask1[j];
            else
               new_message = new_message | mask1[c];
         }  /* ends if is_odd */
         c--;
      }  /* ends loop over j */
      message_image[i][mie] = new_message;
   }  /* ends loop over i */
}  /* ends uncover_pixels */

/* is_odd returns 1 if argument is odd, 0 if even */

int is_odd(number)
   short number;
{
   int result = 0;
   result     = number % 2;
   return(result);
}  /* ends is_odd */


/* End of File */