CODEWITHSUNDEEP
jpegsteganography
Rishabh Mamgain
Rishabh Mamgain

Reputation: 23

Image Encryption

i am doing image steganography and if i type message greater than 3 chars to encrypt there is an exception that Quantization table 0x01 is not defined and is message is less than 3 char i got an encrypted image as i needed .I think this is due to JPEG format (I think while injecting bits in image byte array i hv destroyed the property and attributes of an image ).Help me i am sure its something related to metadata but don`t know much about it.

i am adding code what i am doing

 Creating_image()
 {
  File f=new File(file.getParent()+"/encrypt.jpg");
    if(file==null)
    {
        JOptionPane.showMessageDialog(rootPane, "file null ho gyi encrypt mein");
    }
      try{

          FileInputStream imageInFile = new FileInputStream(file);
        byte imageData[] = new byte[(int) file.length()];
        imageInFile.read(imageData);


        // Converting Image byte array into Base64 String
        String imageDataString =  Base64.encode(imageData);

        // Converting a Base64 String into Image byte array
        pixels = Base64.decode(imageDataString);

        // Write a image byte array into file system

        imageInFile.close();

        }
        catch(Exception as)
       {
   JOptionPane.showMessageDialog(rootPane,"Please first select an Image");
       }
   String msg=jTextArea1.getText(); 
   byte[] bmsg=msg.getBytes();
   String as=Base64.encode(bmsg);
  bmsg=Base64.decode(as);

    int len=msg.length();
   byte[] blen=inttobyte(len);
 String sd=Base64.encode(blen);
 blen=Base64.decode(sd);
 pixels=encode(pixels,blen,32);
 pixels=encode(pixels,bmsg,64);

 try{



         // Converting Image byte array into Base64 String
       String imageDataString =  Base64.encode(pixels);

        // Converting a Base64 String into Image byte array
        pixels = Base64.decode(imageDataString);
   InputStream baisData = new ByteArrayInputStream(pixels,0,pixels.length);
        image= ImageIO.read(baisData);
 if(image == null)
 {
     System.out.println("imag is empty");
 }
 ImageIO.write(image, "jpg", f);

 }
 catch(Exception s)
 {
    System.out.println(s.getMessage());
    }
 }

and thats what encode fxn looks like

byte[] encode(byte [] old,byte[] add,int offset)
{ 
try{    if(add.length+offset>old.length)
{
    JOptionPane.showMessageDialog(rootPane, "File too short");
}
}
catch(Exception d)
{
  JOptionPane.showMessageDialog(rootPane, d.getLocalizedMessage()); 
}
byte no;
    for(int i=0;i<add.length;i++)
    {
        no=add[i];
        for(int bit=7;bit>=0;bit--,++offset)
        {
           int  b=(no>>bit)&1;
            old[offset]=(byte)((old[offset]&0xfe)|b);
        }
    } 
    return old;
 }

Upvotes: 0

Views: 735

Answers (1)

Reti43
Reti43

Reputation: 9796

You are correct in that you have disturbed the file structure. The JPEG format contains highly compressed data to the point none of its bytes represent any pixel values directly. In fact, JPEG doesn't even store the pixel values, but the DCT coefficients of pixel blocks.

Your method of reading the raw bytes of the file would work only for a format like BMP, where the pixels are directly stored in the file. However, you'd still have to skip the first few bytes (header), which contain information like the width and height of the image, number of colour planes and bits per pixel.

If you want to embed your message by modifying the least significant bits of pixels, you have to load the actual pixels in a byte array. Then you can modify the pixels with your encode() method. To save the data to a file, convert the byte array to a BuffferedImage object and use ImageIO.write(). However, you must use a format that does not involve lossy compression, because that can distort the pixel values, thereby destroying your message. Losslessly compressed (or uncompressed) file formats include BMP and PNG, while JPEG is lossy.

If you still want to do JPEG steganography, the process is a bit more involving, but this answer pretty much covers what you need to do. Briefly, you want to borrow the source code of a jpeg encoder because writing one is very complex and requires intricate understanding of the whole format. The encoder will convert the pixels to a bunch of different numbers (lossy step) and store them compactly to a file. Your steganography algorithm should then be injected between these two steps, where you can modify those numbers before saving them to file.

Upvotes: 2

Related Questions