ABSTRACT

Steganography is the process of hiding one file inside another such that
others can neither identify the meaning of the embedded object nor
even the embedded object nor even recognize its existence. Current
trends favor using digital image files as the cover file to hide other digital
file that contains the secret message or information. Steganography
becomes more important as more people join the cyberspace revolution.
Steganography is the art of concealing information in ways that
prevent the detection of hidden messages. The goal of
steganography is to avoid drawing suspicion to the existence of a hidden
message. This approach of information hiding technique has recently
become important in a number of application areas. Digital audio,
video, and pictures are increasingly furnished with distinguishing but
imperceptible marks, which may contain a hidden copyright notice or
serial number or even help to prevent unauthorized copying directly.
Military communications systems make increasing use of traffic security
techniques that, rather than merely concealing the content of a message
using encryption, seek to conceal its sender, its receiver, or its very
existence. Similar techniques are used in some mobile phone systems
and schemes proposed for digital elections. One of the most common
methods of implementation is Least Significant Bit Insertion, in which
the least significant bit of every byte is altered by the bit-string
representing the embedded file. This encryption and decryption of the
images will be done using MATLAB code.
 Introduction

The use of multimedia digital signals has grown in popularity over the last
decade as a result of the proliferation of wireless Internet-based services,
such as the introduction of fourth-generation mobile communication
systems that allow users to transfer data at speeds of up to 1Gbps.
Digital data can be easily copied, modified, and retransmitted in the
network by any user thanks to the availability of low-cost editing tools. It
is critical to developing tools that protect and authenticate digital
information in order to effectively support the growth of multimedia
communications. We present a novel embedding scheme based on the
LSB technique in this contribution. It has no effect if the value of a pixel in
an image is changed by a value of '1'.

Steganography types

STEGANOGRAPHY is derived from the Greek words STEGANOS, which

means "covered," and GRAPHIE, which means "writing." In most cases, the
sender composes a seemingly innocuous message before concealing a
hidden message on the same piece of paper. The main goal of
steganography is to communicate securely while remaining completely
undetectable, avoiding suspicion of hidden data transmission. It's not
so much to keep others from knowing the hidden information as it is to
keep them from believing it exists. Data can be hidden in a variety of
formats, including audio, video, text, and images. The following are
examples of steganography:

a) Image Steganography: Image steganography is the process of

concealing data within an image so that the original image does not
appear to have changed. The LSB embedding algorithm is a common

image steganography algorithm.

b) Audio Steganography: Audio Steganography is the application of

steganography to audio files, in which we can hide information in an audio
file. It's important that the audio file is undetectable.
c) Video Steganography: Steganography can also be used to hide
information in video files. Video Steganography is the process of
concealing information in a video file. An attacker should be unable to
detect the video file.

d) Steganography for text files: Steganography can also be used for text
files. Text steganography is the process of concealing information in a text
file.

LSB METHODS

Each pixel in a grayscale image is represented by 8 bits. The last bit in a

pixel is known as the Least Significant bit because its value has only a "1"
effect on the pixel value. As a result, this property is used to hide the
image's data. If the last two bits are considered LSB bits, they will only
affect the pixel value by "3." This aids in the storage of additional
data. He only increased the pixel value by "3." This aids in the storage of
additional data. Least Significant Bit (LSB) steganography is a type of
steganography in which the image's least significant bit is replaced with
data bits. Because this method is vulnerable to steganalysis, we encrypt
the raw data before embedding it in the image to make it more secure.
While the encryption process adds to the complexity of the process, it also
adds to the security. This method is very straightforward. The least
significant bits of some or all of the bytes in an image are replaced with
bits of the secret message using this method. Many techniques for hiding
messages within multimedia carrier data are based on the LSB embedding
approach. LSB embedding can even be used in specific data domains,
such as embedding a hidden message in the RGB bitmap data's
color values or the frequency coefficients of a JPEG image. LSB embedding
can be used with a wide range of data formats and types. As a result, LSB
embedding is one of the most commonly used steganography techniques
today..

Gray scale
The graph below shows all 256 Gray-scale colors. A two-digit hex
value is used to define up to 256 shades of grey in the gray-scale
color naming scheme. A grayscale digital image is one in which
each pixel's value is a single sample, carrying only intensity
information in photography and computing. Images of this type, also
known as black-and-white, are made up entirely of shades of grey,
ranging from black to white at their most intense. Grayscale images are
distinct from one-bit bi-tonal black- and-white images, which are images
with only two colors, black and white, in the context of computer
imaging (also called bi-level or binary images). There are many shades of
grey in grayscale images. Grayscale images are frequently the result
of measuring the intensity of light at each pixel in a single band of the
electromagnetic spectrum (e.g., infrared, visible light, ultraviolet, etc.),
and they are monochromatic proper when only one frequency is captured
in such cases Figure shows the grayscale shading strengths (0=no colour;
15=full colour).
 Fig 1.1 Pixel Density of grey scale image [0-255]

Block Diagram of Steganography

The stego system encoder embeds a message into the image

using a secret key or password. This password, also known as
a secret key, should be kept private. The resulting stego image
is sent to the receiver over a channel. The stego image will be
decoded by the stego system at the decoder end, using the
same key or password. The figure shows a block diagram.
LSB Decomposition

In the data hiding technique, there are two important components:

cover image and hiding data. The first image on the cover is an 8-bit
grayscale image. The cover image is mn pixels in size. H is a g-bits
bitstream that hides data in Image. To express image C, data D, and each
pixel separately, we use the equation below. The Least Significant Bit
method is one of the simplest methods for embedding digital data into a
digital cover. Consider an NM image in which each pixel value is
represented by a decimal number within the range dictated by the
number of bits used. Each pixel in a gray-scale image with 8-bit precision
assumes a value between [0, 255]. By separating an image into n bit
planes, this property allows it to be decomposed into a collection of binary
images. The secret message is either directly replaced or inserted into the
least-significant bit plane of the cover image in traditional LSB embedding
methods. Depending on the number of pixels chosen, the amount of data
to be embedded may be fixed or variable in size. The main benefit of such
a technique is that changing the LSB plane has no effect on human
perception of overall image quality because the amplitude variation of
pixel values is limitedto 1.

Under normal viewing conditions, the Human Visual System's masking

properties allow significant amounts of embedded information to go
unnoticed by the average observer. The phenomenon of "masking" occurs
when a signal is imperceptible to an observer in the presence of another
signal. In, a thorough examination of these techniques is provided.
High embedding capacity and low computational complexity were also
advantages of LSB data hiding. The weaknesses in terms of robustness,
tampering, geometric attacks, filtering, and compression are the most
significant drawbacks.

LSB method with an example

The least significant bits of the cover media's digital data are used
to conceal the message in LSB steganography. LSB replacement is the
most basic of the LSB steganography techniques. The last bit of
each pixel value is changed in LSB replacement steganography to
reflect the message that needs to be hidden. Consider an

8-bit grayscale bitmap image, in which each pixel is represented by

a byte with a grayscale color value. Assume the following grey color
values for the first eight pixels of the original image:

01010010

01001010

10010111

11001100

11010101

01010111

00100110
We would replace the LSBs of these pixels with the following new values
to hide the letter Z, whose ASCII code binary value is 10110101:

01010011

01001010

10010111

11001101

11010100

01010111

00100110

01000011

It's worth noting that only half of the LSBs need to be changed on
average. The difference between the cover (original) image and the stego
image will be almost imperceptible to the naked eye. One of its major
drawbacks is the small amount of data that can be embedded in such
images using only LSB. Attacks on LSB are extremely common. In
contrast to 8-bit formats, LSB techniques applied to 24-bit formats
for colour images are difficult to detect.
System Specification

A system requirement is the analysis, which is need for the proposed

system to run on particular machine it device the instruction in the
machine.

There are two requirements:

Hardware requirements

Software requirement

Hardware Requirements

RAM :8GBRAM

Processor :INTEL

System type :64bits

Software Requirements

Operating system:windows10

Frontend :python

Backend :My SQL

 Existing System :

Existing system have use the current tracking system for Product
delivery.

In this method the admin can take all the control, so they can modify
the data and also we need go for the third party for trust and making a
security.

This system has a lot possibility to change the real product when it's going
to customer

Disadvantages of steganography

Detectability:

Steganography can be detected with the right tools and techniques.

Complexity:

Steganography can be complex and requires specialized tools and

knowledge.

Transmission time:

Hiding data in an image can be time-consuming, especially for large files.

Data loss: The hidden message may be lost or distorted during

transmission or processing.

Format and compression:

Converting digital files to different formats or compression levels can

affect the embedded information.

Visual quality:

Embedding data in an image can contaminate smooth or flat regions,

which can lead to poor visual quality.
Security:

Steganography methods like Least Significant Bit (LSB) are vulnerable to

attacks.

Additional information

Steganography is the practice of hiding data within another medium, such

as an image or sound file.

Steganography can be used to hide sensitive information, such as

personal files, payment information, or bank account details.

The use of cryptographic algorithms can increase the security of hidden

data.

Proposed System

Steganography is a method of hiding information in another file, such as

an image, video, or audio file. It can be used to send secret messages
without being detected.

Advantages of steganography

Security:

Steganography can hide information so well that it's difficult for others to
detect.

Capacity:

Steganography can hide large amounts of data.

Covert communication:

Steganography can be used to communicate secretly.

Robustness:

Steganography can hide messages that remain intact even after common
image processing operations.

Resistance to cryptanalysis:

Steganography can make it difficult for cryptanalysts to detect hidden

messages.
 MODULE DESCRIPTION

Image Steganography, as the name implies, is the process of concealing data

within an image file. The image chosen for this purpose is referred to as the
cover image, and the image obtained after steganography is referred to as the
stego image.

This technique relies on the fact that small changes in image color or
noise are very difficult to detect with the human eye. For example, one
image can be concealed within another by using the least significant bits
of each pixel in the image to represent the hidden image instead

Encoding and Decoding frame

1. Select an image to encode
2. Type a message into the message box
3. The message is converted to base64
4. The encoded string is merged into the image
5. The image is saved

Select the encoded image

The base64 string is separated by decoding

The hidden text is shown in the textbox using the Tkinter module
The encoder algorithm is as given below:

1: for i = 1, ..., len (msg) do

2: p = LSB(pixel of the image)

3: if p != message bit then

4: pixel of the image = message bit

5: end if

6: end for

modify the pixels of image

In a steganography image project, modifying pixels of an image involves
subtly changing the values of individual pixels within an image to embed
secret information, like text or another file, without noticeably altering the
image's appearance to the human eye; this is typically achieved by
manipulating the least significant bits (LSBs) of each pixel's color values,
allowing for covert data transmission.

Key points about pixel modification in steganography:

Least Significant Bit (LSB) manipulation:

The most common technique is to replace the LSBs of each color channel
(red, green, blue) in a pixel with the bits of the secret message, as these
small changes are nearly imperceptible to the human eye.

Embedding process:
 Convert data to binary: The secret message is converted into a binary
string.

Iterate through pixels: Each pixel is accessed, and its LSBs are replaced
with corresponding bits from the secret message.

Generating the stego image: The modified pixels form the "stego image"
which appears visually identical to the original image but contains the
hidden data.

Extracting the hidden data:

Access the stego image: The receiver needs the same key or algorithm
used for embedding to extract the hidden data.

Extract LSBs: By reading the LSBs of each pixel in the stego image, the
binary data representing the secret message is retrieved.

Convert back to original format: The extracted binary data is then

converted back to the original format (text, file, etc.).

 System Design:

Concept Exploration:

Understanding the fundamentals of steganography, including different

embedding algorithms (LSB, PVS, DCT) and their strengths and weaknesses.

Investigating the potential applications of image steganography, like secure

data transmission, digital watermarking, and covert communication.
 Cover Image Selection: Choosing suitable image formats (like JPEG, PNG)
and analyzing factors like image complexity and size to optimize data hiding
capacity.

 Data Encryption: Implementing a robust encryption algorithm to secure

the secret data before embedding it within the image.

 Embedding Algorithm: Selecting and implementing a suitable

steganography algorithm to embed the encrypted data into the image
pixels, considering factors like distortion level and capacity.

 Testing and Evaluation:

 Data Hiding Capacity: Assessing how much data can be hidden within a
given image without noticeable distortion.
 Robustness Testing: Evaluating the system's ability to withstand common
image manipulations like resizing, compression, and noise addition.
 Detection Resistance: Analyzing how difficult it is for potential attackers
to detect the presence of hidden data within the stego image.

Usecase diagram
 ActiveDiagram

Architetutre Design
SOFTWARE DESCRIPTION
 Python is an interpreted high-level programming language for general-purpose programming.
Created by Guido van Rossum and first released in 1991, Python has a design philosophy thatem
phases code readability, notably using significant whitespace. Python is Interpreted

Python is processed at runtime by the interpreter. You do not need toyour program before
executing it. This is similar to PERL and PHP. Python is Interactive

you can actually sit at a Python prompt and interact with theinterpreter directly to write your
programs.Python also acknowledges that speed of development is important. Readable and terse
codeis part of this, and so is access to powerful constructs that avoid tedious repetition of
code.Maintainability also ties into this may be an all but useless metric, but it does say
somethingabout how much code you have to scan, read and/or understand to troubleshoot problemsor
tweak behaviors. This speed of development, the ease with which a programmer of other languages can
pick up basic Python skills and the huge standard library is key to another areawhere Python excels. All its tools
have been quick to implement, saved a lot of time, andseveral of them have later been patched and
updated by people with no Python background -without breaking.

MySQL is an open-source relational database management

system (RDBMS) that can be used to store and manage data for a
project. It's a popular choice for developers because of its
reliability, performance, and ease of use.

What is MySQL?

 MySQL is based on Structured Query Language (SQL).

 It's a client/server system that supports multiple client programs,

libraries, and APIs.

 It's used to create, modify, and extract data from relational

databases.

 It's used to control user access to databases.

 It's used to implement relational databases in a computer's

storage system.
 It's used to manage users.

 It's used to allow for network access.

 It's used to facilitate testing database integrity and creation of

backups.
How is MySQL used in projects?

 MySQL is used to build and maintain web applications.

 MySQL is used to build and maintain B2B services.

 MySQL is used in many popular software stacks.

 MySQL is used in applications such as Facebook, Netflix, Uber,

Airbnb, Shopify, and Booking.com.

SOURCE CODE :

%Encoding the message original=imread('cat.jpg');

cover=rgb2gray(original); [row,column]=size(cover); L=256;

stego=cover;

message=input('Enter the message to be hidden: ','s');

len=strlength(message)*8; %Each character will take 8 bits so total
number of bits in the message will be len

ascii=uint8(message); %ascii is a vector having the ascii value of each

character

binary_separate=dec2bin(ascii,8); %binary_separate is an array having

the decimal representation of each ascii value binary_all=''; %binary_all
will have the entire sequence of bits of the message

for i=1:strlength(message)
binary_all=append(binary_all,binary_separate(i,:)); end
count=1; %initializing count with 1 for i=1:row

for j=1:column

%Convert%for every character in the message if count<=len

%Obtain the LSB of the grey level of the pixel LSB=mod(cover(i,j),2);

disp(['The original message is: ',original_message]);

the bit from the message to numeric form

a=str2double(binary_all(count));

%Perform XOR operation between the bit and the LSB

temp=double(xor(LSB,a));

%Change the bit of the stego image accordingly stego(i,j)=cover(i,j)

+temp;

count=count+1;

end end end

subplot(1,2,1); imshow(cover); title('Cover Image');

subplot(1,2,2); imshow(stego); title('Stego Image');

%Decoding the message count=1; message_in_bits='';

for i=1:row

for j=1:column

%For all the characters in the message if count<=len

%Retrieve the LSB of the intensity level of the pixel
LSB=mod(stego(i,j),2);

%Append into message_in_bits to get bit sequence of message

message_in_bits=append(message_in_bits,num2str(LSB));

count=count+1;

end end end

%Converting the bit sequence into the original message i=1;

original_message='';

while i<=len

%Take a set of 8 bits at a time

%Convert the set of bits to a decimal number

%Convert the decimal number which is the ascii value to its corresponding
character

%Append the obtained character into the resultant string

original_message=append(original_message,char(bin2dec(message_in_b
its(1,i:i+7)))); i=i+8;

End

#function to decode data

def decode(self, image):

image_data = iter(image.getdata())
data = ''

while (True):

pixels = [value for value in image_data.__next__()[:3] +

image_data.__next__()[:3] +

image_data.__next__()[:3]]

# string of binary data

binary_str = ''

for i in pixels[:8]:

if i % 2 == 0:

binary_str += '0'

else:

binary_str += '1'

data += chr(int(binary_str, 2))

if pixels[-1] % 2 != 0:

return data

#function to generate data

def generate_Data(self,data):

# list of binary codes of given data

new_data = []

for i in data:

new_data.append(format(ord(i), '08b')
#function to modify the pixels of image

def modify_Pix(self,pix, data):

dataList = self.generate_Data(data)

dataLen = len(dataList)

imgData = iter(pix)

for i in range(dataLen):

pix = [value for value in imgData.__next__()[:3] +

imgData.__next__()[:3] +

imgData.__next__()[:3]]

for j in range(0, 8):

if (dataList[i][j] == '0') and (pix[j] % 2 != 0):

if (pix[j] % 2 != 0):

pix[j] -= 1

elif (dataList[i][j] == '1') and (pix[j] % 2 == 0):

pix[j] -= 1

if (i == dataLen - 1):

if (pix[-1] % 2 == 0):

pix[-1] -= 1

else:

if (pix[-1] % 2 != 0):

pix[-1] -= 1

pix = tuple(pix)

yield pix[0:3]
yield pix[3:6]

yield pix[6:9]

from PIL import Image

import numpy as np

# Function to encode the message into the image

def encode_image(image_path, message, output_path):

# Open the image

image = Image.open(image_path)

# Convert image to numpy array for manipulation

image_array = np.array(image)

# Convert the message to binary

message_binary = ''.join(format(ord(char), '08b') for char in message)

# Make sure the message is not too long for the image to hold

if len(message_binary) > image_array.size:

raise ValueError("Message is too large to be hidden in this image")

# Flatten the image array and replace the least significant bit with the
message binary

flattened_image = image_array.flatten()
 # Embed the message bits into the least significant bit of each pixel

for i in range(len(message_binary)):

flattened_image[i] = (flattened_image[i] & 0xFE) |

int(message_binary[i])

# Reshape the flattened array back to the original image shape

image_array = flattened_image.reshape(image_array.shape)

# Save the new image with the encoded message

encoded_image = Image.fromarray(image_array.astype(np.uint8))

encoded_image.save(output_path)

print(f"Message successfully encoded into {output_path}")

# Function to decode the hidden message from the image

def decode_image(image_path):

# Open the image

image = Image.open(image_path)

# Convert image to numpy array for manipulation

image_array = np.array(image)
 # Flatten the image array and extract the least significant bit from each
pixel

flattened_image = image_array.flatten()

# Extract the message binary from the least significant bits

message_binary = ''.join(str(flattened_image[i] & 1) for i in

range(len(flattened_image)))

# Group the binary into 8-bit chunks and convert to characters

message = ''

for i in range(0, len(message_binary), 8):

byte = message_binary[i:i+8]

char = chr(int(byte, 2))

if char == '\0': # End of message

break

message += char

return message

# Example usage

if __name__ == "__main__":

message = "Hello, Steganography!" # The message you want to hide

input_image = "input_image.png" # Input image file path

 output_image = "encoded_image.png" # Output image with hidden
message

# Encode the message into the image

encode_image(input_image, message, output_image)

# Decode the hidden message from the image

decoded_message = decode_image(output_image)

print("Decoded message:", decoded_message)

Explanation of the Code:

1. Encoding the Message:

Opening and Manipulating the Image: The image is loaded using Pillow
and converted to a numpy array for easier manipulation of pixel values.

Converting the Message to Binary: Each character in the message is

converted to its binary representation using format(ord(char), '08b').

Embedding the Message in the Image: The binary message is encoded

into the least significant bit (LSB) of each pixel in the image. This is done
by using bitwise operations (& 0xFE to clear the LSB and | to set it to the
binary value of the message).

2. Decoding the Message:

Extracting the Hidden Message: The LSB of each pixel is extracted and
concatenated to form the binary string of the hidden message.
Converting Binary to Text: The binary string is then grouped into 8-bit
chunks and converted back to text using chr(int(byte, 2)). The message is
terminated when a null byte ('\0') is encountered.

Step 3: Example Images

Input Image (input_image.png): This is the image in which the message

will be hidden. It should be a relatively large image, as the message will
be hidden in the least significant bit of each pixel.

Encoded Image (encoded_image.png): This is the output image with the

hidden message encoded in its pixels.

Step 4: Test the Code

Prepare an Image: Create or choose a PNG or BMP image (other formats

might work, but PNG/BMP are lossless and are preferred for
steganography).

Set the message: Define the message you want to hide.

Run the Code: When you run the script, the message will be hidden in the
image, and you can later decode it.

Example Use Case:

Encoding:

Input Image: input_image.png

Message: "Hello, Steganography!"

Output Image: encoded_image.png

Decoding:
Decode the message from encoded_image.png and the result will be:
"Hello, Steganography!".

Notes:

Message Size: The message's size is constrained by the size of the image.
For example, if the image has 1,000,000 pixels, you can hide up to
1,000,000 bits (or about 125,000 bytes). Be sure to check the message
length before attempting to encode.

Image Format: Lossy formats like JPEG are not suitable for steganography
as they may alter pixel values during compression. Use lossless formats
like PNG or BMP.
 TESTING

Methods of Testing Software testing is an investigation conducted to provide

stakeholders with information about the quality of the product or service
under test. Software testing can also provide an objective,independent view
of the software to allow the business to appreciate and understand the risks
of software implementation. Test techniques include the process of executing
a program or application with the intent of finding software bugs (errors or
other defects). Software testing involves the execution of a software
component or system component to evaluate one or moreproperties of
interest. In general, these properties indicate the extent to which the
component or system under test

. • meets the requirements that guided its design and development, responds
correctly to all kinds of inputs.

• performs its functions within an acceptable time, issufficiently usable,

• can be installed and run in its intended environments, and

• Achieves the generalresult its stakeholder’s desire. As the number of

possible tests for even simple software components is practically infinite,
allsoftware testing uses some strategy to select tests that are feasible for the
available time and resources. As a result, software testing typically (but not
exclusively) attempts to execute a program or application with the intent of
finding software bugs (errors or other defects). The job of testing is an
iterative process as when one bug is fixed; it can illuminate other, deeper
bugs, or can even create new ones. Software testing can provide objective,
independent information about the quality of softwareand risk of its failure to
users and/or sponsors. Software testing can be conducted as soon.
Software testing can be conducted as soon as executable software (even if
partially

complete) exists. The overall approach to software development often

determines when and

how testing is conducted. For example, in a phased process, most testing

occurs after system

requirements have been defined and then implemented in testable programs.

In contrast,

under an Agile approach, requirements, programming, and testing are often

done

concurrently.

The main aim of testing

The main aim of testing is to analyze the performance and to evaluate the
errors that

occur when the program is executed with different input sources and running
in different

operating environments.

The testing steps are:

• Unit Testing.

• Integration Testing.

• Validation Testing.
 • User Acceptance Testing.

UNIT TESTING

Unit testing, also known as component testing refers to tests that verify the

functionality of a specific section of code, usually at the function level. In an

object-oriented

environment, this is usually at the class level, and the minimal unit tests
include the

constructors and destructors. Which helps in analyzing the Unit testing is a

software

development process that involves synchronized application of a broad

spectrum of defect

prevention and detection strategies in order to reduce software development

risks, time, and

costs. The following Unit Testing shows the functions that were tested at the
time of

programming which helps in maintaining the manufacturer, retailer,

consumer, provider.

Steganography image project testing involves ensuring that the

application is functional, reliable, and secure. This includes encoding and
decoding messages of varying lengths and content.

Testing steps

Functionality: Test the application to ensure it functions as expected

Reliability: Test the application to ensure it is reliable

Security: Test the application to ensure it is secure

Performance: Validate the system's performance by encoding and

decoding messages of varying lengths and content
Bugs: Address any identified issues or bugs through debugging and
refinement of the implementation

Steganography overview

Steganography is a technique for hiding secret messages in cover images

The sender conceals the secret message in a cover image, then transfers
the stego image to the receiver

The receiver can then reveal the secret message

Steganalysis is an attack on the steganography algorithm

Steganography project ideas

Use the least significant bit (LSB) technique to hide secret messages in
images

Use gray scale images and separate images into RGB layers to increase
embedding capacity

Use Python to hide secret data in images

Implementation

The image that will be used for steganography will be shown first.

Fig 1.3 Original Colored Image for LSB Steganography

After that, the user should type in the message to be hidden.

 Fig 1.5 Cover and Stego Image for LSB Steganography

Key steps in a steganography image project implementation:

Choose a steganography algorithm: The most common method for

beginners is the Least Significant Bit (LSB) technique, where the least
significant bit of each pixel is replaced with a bit from the secret message.

Import libraries: Utilize libraries like Pillow (PIL) in Python to handle image
manipulation, and potentially additional libraries for encryption if you
want to add an extra security layer to the secret message.

Load the cover image: Read the image file into your program using the
image processing library functions.
Prepare the secret message: Convert the secret message (text, file, etc.)
into a binary string.

Data embedding (Encoding):

Loop through the image pixels.

Access the LSB of each pixel.

Replace the LSB with the corresponding bit from the secret message.

Update the pixel value with the modified LSB.

Save the stego-image: Save the modified image with the embedded
secret message.

Data extraction (Decoding):

Load the stego-image.

Loop through the pixels.

Extract the LSBs of each pixel.

Reconstruct the original secret message from the extracted LSBs.

CONCLUSION

From this implementation of image steganography using LSB and DCT

techniques, conclusion is, for the technique

LSB using XOR gave MSE and PSNR values which decreases as number of bits
substituted are increases. For good quality of stego image, MSE should be low
and PSNR should be high. This is achieved in both the techniques i.e.

LSB and DCT. DCT method gives better performance than LSB technique. Only
the two distinct transformations were

limited to this research. Furthermore, to discover some other form

transformation that causes stronger efficiency, further

study is needed.

LSB and DWT approaches have been used to successfully develop

image steganography. This report also highlighted its merits and
disadvantages. Despite this, efforts must be made to increase
embedding capacity while maintaining secrecy. We can use this
method to hide text files that are the same size as the image. It is
possible to hide text files that are larger than the image size.
Both the sender and the receiver must be aware of the secret
keys. The keys are not included in the cover images and must
be requested separately. These keys can be generated and
distributed invisibly using a technique that has yet to be
developed. If you need more security, you can use the Transform
Domain method. When Steganography is combined with
Cryptography, it becomes an unbeatable tool for establishing secure
communication links. Advanced cryptography techniques can
improve the scheme's security, while data compression techniques
can improve its efficiency.
Refernces

Mujtiba, Syed & Yousu, Salihah & Bisma, Syed & Siddiqi, Mehvish & Khaki,
Zahidgulzar. (2017). COMPARISION OF LSB AND DWT STEGANOGRAPHY
TECHNIQUES. 10.21090/IJAERD.ETIECE08.

Macit, Hüseyin & Koyun, Arif & Güngör, Orhan. (2018). A

REVIEW AND COMPARISON OF STEGANOGRAPHY TECHNIQUES.

Fahim Irfan et. Al. ‘s (2011) “An Investigation into Encrypted

Message Hiding through Images Using LSB ”, International Journal of EST,

Rajkumar Yadav, (2011) “A Novel Approach For Image

Steganography In Spatial

Domain Using Last Two Bits of Pixel Values”, International Journal of

Security, Vol.5

Iss. 2 pp. 51-61.

Steganography Image Process”, International Journal of Research and

Analytical Reviews (IJRAR) ISSN: 2349-5138, Volume-06, Issue-02,

May-2019.

2. Mohamed Buker; Hakan Tora; Erhan Gokcay, “Effect of Secret

Image Transformation on the Steganography Process,” 24th IEEE

International Conference on Electronics, Circuits and Systems

(ICECS), pp. 351-355,2017.

3. Deepesh Rawat and Vijaya Bhandari, “A Steganography Technique

for Hiding Image in an Image using LSB Technique for 24 Bit Colour

Image’’, International Journal of Computer Applications (0975-8887)

Volume 64- No.20, February 2013.

4. Sheidaee, A., & Farzinvash, L., “A novel image steganography

technique based on DCT and LSB,” 9th International Conference on

Information and Knowledge Technology (IKT), 2017.

5. Ms. G. S. Sravanti, Mrs. B. Sunitha Devi, S.M.Riyazoddin & M.

Janga Reddy, “A Spatial Domain Image Steganography Technique

Based on Plan Bit Substitution Technique”, Global Journal of

Computer Science and Technology Graphics & Vision Volume 12

Issue 15 Version 1.0 , 2012.

6. A.SaiKrishna Shankar Parimi G. Manikandan. Sairam. N, “A

Clustering Based Steganographic Approach for Secure Data

Communication”, International Conference on Circuit, Power and

Computing Technologies [ICCPCT], 2015.