Open In App
Related Articles
• Write an Interview Experience
• Share Your Campus Experience
• Cryptography Tutorial

# Image Steganography in Cryptography

The word Steganography is derived from two Greek words- ‘stegos’ meaning ‘to cover’ and ‘grayfia’, meaning ‘writing’, thus translating to ‘covered writing’, or ‘hidden writing’. Steganography is a method of hiding secret data, by embedding it into an audio, video, image, or text file. It is one of the methods employed to protect secret or sensitive data from malicious attacks.
How is it different from cryptography?
Cryptography and steganography are both methods used to hide or protect secret data. However, they differ in the respect that cryptography makes the data unreadable, or hides the meaning of the data, while steganography hides the existence of the data.
In layman’s terms, cryptography is similar to writing a letter in a secret language: people can read it, but won’t understand what it means. However, the existence of a (probably secret) message would be obvious to anyone who sees the letter, and if someone either knows or figures out your secret language, then your message can easily be read.
If you were to use steganography in the same situation, you would hide the letter inside a pair of socks that you would be gifting the intended recipient of the letter. To those who don’t know about the message, it would look like there was nothing more to your gift than the socks. But the intended recipient knows what to look for, and finds the message hidden in them.
Similarly, if two users exchanged media files over the internet, it would be more difficult to determine whether these files contain hidden messages than if they were communicating using cryptography.
Cryptography is often used to supplement the security offered by steganography. Cryptography algorithms are used to encrypt secret data before embedding it into cover files.
Image Steganography –
As the name suggests, Image Steganography refers to the process of hiding data within an image file. The image selected for this purpose is called the cover image and the image obtained after steganography is called the stego image
How is it done?
An image is represented as an N*M (in case of grayscale images) or N*M*3 (in case of color images) matrix in memory, with each entry representing the intensity value of a pixel. In image steganography, a message is embedded into an image by altering the values of some pixels, which are chosen by an encryption algorithm. The recipient of the image must be aware of the same algorithm in order to know which pixels he or she must select to extract the message.

Figure – Process of Image Steganography

Is steganography a secure method of communication?

When steganography is employed alone, it is security by obscurity, which might result in the secret message being disclosed. Combining steganography and cryptography is the greatest way to disguise a message from adversaries while still protecting it in case it is detected.

In steganography, what algorithm is used?

His steganography approach entails concealing a huge amount of data (picture, audio, and text) within a colour bitmap (bmp) image. The image will be filtered and segmented in his study, with bits replacement applied to the appropriate pixels. These pixels are chosen at random rather than in order.
Detection of the message within the cover image is done by the process of steganalysis. This can be done through comparison with the cover image, histogram plotting, or noise detection. While efforts are being invested in developing new algorithms with a greater degree of immunity against such attacks, efforts are also being devoted towards improving existing algorithms for steganalysis, to detect the exchange of secret information between terrorists or criminal elements.

#### Here’s an example of how image steganography can be implemented using Python and the ‘`PIL'` (Python Imaging Library) library:

1. Install the required libraries:

Open a command-line interface (CLI) or terminal.

Run the following command to install the ‘`PIL'` library:

`pip install pillow`

2. Import the required libraries:

## Python

 `from` `PIL ``import` `Image`

3. Define the functions for hiding and extracting the secret data:

## Python

 `def` `hide_text(image_path, secret_text, output_path):``    ``# Open the image``    ``image ``=` `Image.``open``(image_path)` `    ``# Convert the secret text to binary``    ``binary_secret_text ``=` `'``'.join(format(ord(char), '``08b``') ``for` `char ``in` `secret_text)` `    ``# Check if the image can accommodate the secret text``    ``image_capacity ``=` `image.width ``*` `image.height ``*` `3``    ``if` `len``(binary_secret_text) > image_capacity:``        ``raise` `ValueError(``"Image does not have sufficient capacity to hide the secret text."``)` `    ``# Hide the secret text in the image``    ``pixels ``=` `image.load()``    ``index ``=` `0``    ``for` `i ``in` `range``(image.width):``        ``for` `j ``in` `range``(image.height):``            ``r, g, b ``=` `pixels[i, j]` `            ``# Modify the least significant bit of each color channel``            ``if` `index < ``len``(binary_secret_text):``                ``r ``=` `(r & ``0xFE``) | ``int``(binary_secret_text[index])``                ``index ``+``=` `1``            ``if` `index < ``len``(binary_secret_text):``                ``g ``=` `(g & ``0xFE``) | ``int``(binary_secret_text[index])``                ``index ``+``=` `1``            ``if` `index < ``len``(binary_secret_text):``                ``b ``=` `(b & ``0xFE``) | ``int``(binary_secret_text[index])``                ``index ``+``=` `1` `            ``pixels[i, j] ``=` `(r, g, b)` `    ``# Save the image with the hidden secret text``    ``image.save(output_path)` `def` `extract_text(image_path):``    ``# Open the image``    ``image ``=` `Image.``open``(image_path)` `    ``# Extract the secret text from the image``    ``pixels ``=` `image.load()``    ``binary_secret_text ``=` `""``    ``for` `i ``in` `range``(image.width):``        ``for` `j ``in` `range``(image.height):``            ``r, g, b ``=` `pixels[i, j]` `            ``# Extract the least significant bit of each color channel``            ``binary_secret_text ``+``=` `str``(r & ``1``)``            ``binary_secret_text ``+``=` `str``(g & ``1``)``            ``binary_secret_text ``+``=` `str``(b & ``1``)` `    ``# Convert the binary text to ASCII``    ``secret_text ``=` `""``    ``for` `i ``in` `range``(``0``, ``len``(binary_secret_text), ``8``):``        ``char ``=` `chr``(``int``(binary_secret_text[i:i``+``8``], ``2``))``        ``secret_text ``+``=` `char` `    ``return` `secret_text`

4. Hide secret text in an image:

## Python

 `image_path ``=` `'image.jpg'``secret_text ``=` `'This is a secret message.'``output_path ``=` `'output_image.jpg'``hide_text(image_path, secret_text, output_path)`

5. Extract the secret text from the image:

## Python

 `extracted_text ``=` `extract_text(output_path)``print``(``"Extracted text:"``, extracted_text)`

In this example, we first convert the secret text into binary form. We then modify the least significant bit of each color channel (red, green, and blue) of the image pixels to store the binary representation of the secret text. To extract the secret text, we retrieve the least significant bit of each color channel and convert it back to ASCII characters.

### Some of the features of image steganography in cryptography are:

Secrecy: The primary feature of image steganography is secrecy. The secret information is hidden within the image in a way that is not easily detectable by an unauthorized person.

Capacity: The capacity of an image to carry secret information depends on the size of the image and the amount of information to be hidden. Generally, larger images have a higher capacity to carry secret information.

Robustness: The image steganography technique should be robust, i.e., it should be able to withstand image processing techniques like compression, cropping, and resizing without affecting the hidden information.

Security: The security of the hidden information is of utmost importance. The image steganography technique should be designed in such a way that it is resistant to attacks like statistical analysis and brute force attacks.

Efficiency: The image steganography technique should be efficient, i.e., it should be able to hide the secret information in the image quickly and effectively.

Concealment: The hidden information should be concealed in the image in a way that it is not easily distinguishable from the original image.

Retrieval: The hidden information should be retrievable by the authorized party using a decryption key or algorithm.

#### Advantages of Image Steganography:

Security: Image steganography provides a high level of security for secret communication as it hides the secret message within the image, making it difficult for an unauthorized person to detect it.

Capacity: Image steganography has a high capacity to carry secret information as it can hide a large amount of data within an image.

Covert Communication: Image steganography provides a covert means of communication, as the existence of the secret message is hidden within the image.

Robustness: Steganography techniques are often designed to be robust, meaning that the hidden message can remain intact even when the image undergoes common image processing operations like compression or resizing.

Resistance to Cryptanalysis: Steganography can make it difficult for cryptanalysts to detect and analyze hidden messages as the message is camouflaged within the image, making it difficult to separate from the image’s natural features.

#### Disadvantages of Image Steganography:

Detection: Steganography can be detected if a person has the right tools and techniques, so it is not a foolproof method of securing communication.

Complexity: Steganography can be complex and requires specialized tools and knowledge to implement effectively.

Lengthy Transmission Time: Hiding data within an image can be a time-consuming process, especially for large files, which can slow down the transmission of data.

Susceptibility to Data Loss: The hidden message may be lost or distorted during the transmission or processing of the image, resulting in a loss of data.

Misuse: Steganography can be misused for illegal activities, including hiding malicious code or malware within an image, making it difficult to detect and prevent cybersecurity attacks.