Image Steganography

1.
PROJECT
1.1 INTRODUCTION
In the current trends of the world, the technologies have advanced so much that most of the
individuals prefer using the internet as the primary medium to transfer data from one end to
another across the world. There are many possible ways to transmit data using the internet:
via e-mails, chats, etc. The data transition is made very simple, fast and accurate using the
internet. However, one of the main problems with sending data over the internet is the
„security threat‟ it poses i.e. the personal or confidential data can be stolen or hacked in many
ways. Therefore it becomes very important to take data security into consideration, as it is
one of the most essential factors that need attention during the process of data transferring.
Data security basically means protection of data from unauthorised users or hackers and
providing high security to prevent data modification. This area of data security has gained
more attention over the recent period of time due to the massive increase in data transfer rate
over the internet.
In order to improve the security features in data transfers over the internet, many techniques
have been developed like: Cryptography, Steganography and digital watermarking. While
Cryptography is a method to conceal information by encrypting it to „cipher texts‟ and
transmitting it to the intended receiver using an unknown key, Steganography provides
further security by hiding the cipher text into a seemingly invisible image or other formats.
According to Johnson et al., “Steganography is the art of hiding and transmitting data
through apparently innocuous carriers to conceal the existence of data”. The level of visibility
is decreased using many hiding techniques in „Image Modelling‟ like LSB „Manipulation‟,
„Masking and filtering‟. These techniques are performed by different steganographic
algorithms like F5, LSB, JSteg etc. and the act of detecting the information hidden through
these algorithms is called „Steganalysis‟. “Cryptography” is the art of science used to achieve
security by encoding the data to transform them into non readable formats so that
unauthorized users cannot gain access to it. MSc Information Security and Computer
Forensics
IMAGE STEGANOGRAPHY 1
The encoded text is known as „Cipher text‟ and this technique is known as encryption and
this process is reversed with authorised access using the decryption technique, in which the
encoded data is decoded into readable format
„Steganography‟ and „Cryptography‟ are closely related constructs. The hidden or embedded
image, audio or a video files act as carriers to send the private messages to the destination
without any security breach. Steganography techniques can be implemented on various file
formats such as audio („.mp3‟, „.wmv.‟, etc.), video („.mpeg‟, „.dat‟, etc.) and images
(„.jpeg‟, „.bmp‟, etc.). However, the images are the most preferred file format for this
technique. At present, there are a lot of algorithms that help in executing the steganography
software.
“Digital watermarking” is described as one of the possibilities to close the gap between
copyright issues and digital distribution of data. It is mainly based on Steganographic
techniques and enables useful safety mechanisms It acts as a very good medium for
copyright issues as it embeds a symbol or a logo in the form of a watermark, which cannot be
altered manually.
One critical factor to be kept in mind when using steganography is to prevent any further
alterations to the originality of the image after embedding the data. Whenever the image with
the secret data is transmitted over the internet unauthorised parties may want to hack the data
hidden over the image. So, if the originality of the image has been changed then it will be
easier to hack the information by unauthorised persons. In order to improve the security, the
Digital watermarks are predominantly inserted as transformed digital signal into the source
data using key based embedding algorithm and pseudo noise pattern. While we are discussing
it in terms of computer security, steganography is really nothing new, as it has been around
since the times of ancient Rome. For example, in ancient Rome and Greece, text was
traditionally written on wax that was poured on top of stone tablets. If the sender of the
information wanted to obscure the message - for purposes of military intelligence, for
instance - they would use steganography: the wax would be scraped off and the message
would be inscribed or written directly on the tablet, wax would then be poured on top of the
message, thereby obscuring not just its meaning but its very existence.
FIGURE 1.1 Basic Steganography Frame
1.2 Objective
Like many security tools, steganography can be used for a variety of reasons, some good,
some not so good. Legitimate purposes can include things like watermarking images for
reasons such as copyright protection. Digital watermarks (also known as fingerprinting,
significant especially in copyrighting material) are similar to steganography in that they are
overlaid in files, which appear to be part of the original file and are thus not easily detectable
by the average person. Steganography can also be used as a way to make a substitute for a
one-way hash value (where you take a variable length input and create a static length output
string to verify that no changes have been made to the original variable length input). Further,
steganography can be used to tag notes to online images (like post-it notes attached to paper
files). Finally, steganography can be used to maintain the confidentiality of valuable
information, to protect the data from possible sabotage, theft, or unauthorized viewing.
Unfortunately, steganography can also be used for illegitimate reasons. For instance, if
someone was trying to steal data, they could conceal it in another file or files and send it out
in an innocent looking email or file transfer. Furthermore, a person with a hobby of saving
pornography, or worse, to their hard drive, may choose to hide the evidence through the use
of steganography. And, as was pointed out in the concern for terroristic purposes, it can be
used as a means of covert communication. Of course, this can be both a legitimate and an
illegitimate application.
1.3Scope
Steganography will continue to increase in popularity over cryptography. As it gets more

and more advanced as will the Steganalysis tools for detecting it. Currently although most
specific tools can detect files hidden using themselves in the first place. It is well accepted
though, small sentences and one-word answers (e.g. a ‘yes’) are virtually impossible to find.
This could be an area for further advances as possible compression sizes decrease further.
There also seems very little in terms of tools for hiding data in video. There are some for
audio but this is still an area, which lags behind image steganography. The future may see
audio files and video streams that could possibly be decoded on the fly to form their correct
messages. This could be the ultimate broadcast of secret information Steganography
transmits secrets through apparently innocuous covers in an effort to conceal the existence of
a secret
With the recent advances in Internet computing and its intrusion in our day to day life, the
need for private and personal communication has increased. Privacy in digital communication
is desired when confidential information is being shared between two entities via the
computer communication. Existing technologies like cryptography offer a solution by
scrambling the confidential information such that it cannot be read by anyone else except the
intended recipient. However the issue with encryption is that the significance of the
communication is highlighted because cryptographic data lacks the required logical sense and
can be easily recognized.
messages. This could be the ultimate broadcast of secret information. The scope of the project
is to limit unauthorised access and provide better security during message transmission. To meet
the requirements, I use the simple and basic approach of steganography and digital watermarking.
1.4 Description Of Project

In general, security denotes “the quality or state of being secure to be free from danger
Security is classified into different layers depending on the type of content intended to be
secured:
Physical security: Defines the required issues that are needed to protect the physical data or
objects from unauthorized intrusion.
Personal security: It is defined as the security of the individuals who are officially authorized
to access information about the company and its operations
Operational security: It mainly relies on the protection of the information of a particular
operation of the chain of activities.
Communication‟s security: The communication‟s security encompasses the security issues
regarding the organisation‟s communication media, technology and content.
Network security: The network security is responsible for safeguarding the information
regarding the „networking components‟, „connections‟ and contents.
Information security:
Information security is the protection of information and the systems and hardware that use,
store, and transmit that information. Information security can be defined as measures adopted
to prevent the unauthorized use or modification of use of data or capabilities.
The main objective of the project is to propose the method and critically discuss the
properties which help to transmit the data or information over a network without any
modifications. The critical characteristics of information are
1. Availability
2. Accuracy
3. Authenticity
4. Confidentiality
5. Integrity
Availability: prevention of unauthorised disclosure of information. It enables users who need
access the information to do so without any interference or obstruction and to receive it in the
required format. The availability of information requires the verification of the user as one
with authorized access to information
In other words the availability can be defined as “Ensuring timely and reliable access to make
use of information. A loss of availability is the disruption of access to or use of information or
an information system”
Accuracy: The information is deemed accurate if it does not contain any mistakes / errors
and possesses the value that end user expects. If the information holds a value different from
that of the end user‟s expectations because of intentional or unintentional modifications of its
content it becomes no longer accurate
Authenticity: Authenticity refers to the quality or state of being genuine or original. It should
not be a reproduction or fabrication of any previously known data. The Information is
considered authentic when it is originally created, placed, stored or transferred. In general,
authenticity is ensuring that all the data remains in its original state by stopping any ways of
the unauthorised modification of information
Confidentiality: “The confidentiality is the quality or state of preventing disclosure or
exposure to unauthorized individuals or system”. Confidentiality is basically privacy and
secrecy which means protection of personal data or that of data belonging to an organisation.
Confidentiality of information ensures that only those with the rights and privileges access a
particular set of information and prevent from unauthorized access
Steganography in Greek means „covered writing‟. Steganography is the process of hiding
the one information into other sources of information like text, image or audio file, so that it
is not visible to the natural view. There are varieties of steganographic techniques available to
hide the data depending upon the carriers we use.
Steganography and cryptography both are used for the purpose of sending the data securely.
The same approach is followed in Steganography as in cryptography like encryption,
decryption and secret key. In steganography the message is kept secret without any changes
but in cryptography the original content of the message is differed in different stages like
encryption and decryption.
The different types of steganographic techniques that is available are
1. Pure steganography
2. Public key steganography
3. Secret key steganography
Pure steganography: Pure steganography is the process of embedding the data into the
object without using any private keys. This type of steganography entirely depends upon the
secrecy. This type of steganography uses a cover image in which data is to be embedded,
personal information to be transmitted, and encryption decryption algorithms to embed the
message into image.
This type of steganography can‟t provide the better security because it is easy for extracting
the message if the unauthorised person knows the embedding method. It has one advantage
that it reduces the difficulty in key sharing
Secret key steganography: Secret key steganography is another process of steganography
which uses the same procedure other than using secure keys. It uses the individual key for
embedding the data into the object which is similar to symmetric key. For decryption it uses
the same key which is used for encryption. This type of steganography provides better
security compared to pure steganography. The main problem of using this type of
steganographic system is sharing the secret key. If the attacker knows the key it will be easier
to decrypt and access original information
Public key steganography: Public key steganography uses two types of keys: one for
encryption and another for decryption. The key used for encryption is a private key and for
decryption, it is a „public key‟ and is stored in a public database
For encryption and decryption of text messages using the secret keys steganographic system
uses algorithms known as steganographic algorithms.
Types Of Steganography:
Almost all digital file formats can be used for steganography, but the formats that are more
suitable are those with a high degree of redundancy. Redundancy can be defined as the bits of
an object that provide accuracy far greater than necessary for the object’s use and display .
The redundant bits of an object are those bits that can be altered without the alteration being
detected easily . Image and audio files especially comply with this requirement, while
research has also uncovered other file formats that can be used for information hiding.
The four main categories of file formats that can be used for steganography:
1.Text
2.Image
3.Audio
Hiding information in text is historically the most important method of steganography. An
obvious method was to hide a secret message in every nth letter of every word of a text
message. It is only since the beginning of the internet and all the different digital file formats
that is has decreased in importance .
Text: Text steganography using digital files is not used very often since text files have a very
small amount of redundant data.
Image: Digital images, especially on the Internet, and given the large amount of redundant
bits present in the digital representation of an image, images are the most popular cover
objects for steganography.
Audio: To hide information in audio files similar techniques are used as for image files. One
different technique uniqueto audio steganography is masking, which exploits the properties of
the human ear to hide information unnoticeably. A faint, but audible, sound becomes
inaudible in the presence of another louder audible sound .This property creates a channel in
which to hide information. Although nearly equal to images in steganographic potential, the
larger size of meaningful audio files makes them less popular to use than images .
Comparison of Staganography & cryptography
Steganography and cryptography are closely related. Cryptography scrambles messages so it
can’t be understood. Steganography on the other hand, hide the message so there is no
knowledge of the existence of the message. With cryptography, comparison is made
between portions of the plaintext and portions of the cipher text. In steganography,
comparisons may be made between the cover-media, the stego-media, and possible portions
of the message. The end result in cryptography is the cipher text, while the end result in
steganography is the stego-media. The message in steganography may or may not be
encrypted. If it is encrypted, then a cryptanalysis technique is applied to extract the message
LSB algorithm
Least significant bit (LSB) insertion is a common, simple approach to embedding information
in a cover image. The least significant bit (in other words, the 8th bit) of some or all of the
bytes inside an image is changedto a bit of the secret message. When using a 24-bit image, a
bit of each of the red, green and blue color components can be used, since they are each
represented by a byte. In other words, one can store 3 bits in eachpixel. An 800 × 600 pixel
image, can thus store a total amount of 1,440,000 bits or 180,000 bytes of embedded
data . For example a grid for 3 pixels of a 24-bit image can be as follows:
(00101101 00011100 11011100)
(10100110 11000100 00001100)
(11010010 10101101 01100011)
When the number 200, which binary representation is 11001000, is embedded into the least
significant bits of this part of the image, the resulting grid is as follows:
(00101101 00011101 11011100)
(10100110 11000101 00001100)
(11010010 10101100 01100011)
Although the number was embedded into the first 8 bytes of the grid, only the 3 underlined
bits needed to be changed according to the embedded message. On average, only half of the
bits in an image will need to be modified to hide a secret message using the maximum cover
size [19]. Since there are 256 possible intensities ofeach primary colour, changing the LSB of
a pixel results in small changes in the intensity of the colours. Thesechanges cannot be
perceived by the human eye - thus the message is successfully hidden. With a well-chosen
image, one can even hide the message in the least as well as second to least significant bit and
still not see the difference .
Digital Watermarking:
“Watermarking is the practice of imperceptibly altering work to embed a secret message”
„Digital watermarking‟ is the process of inserting information into a digital signal. The main
aim of digital watermarking is to protect the integrity and authenticity of digital media.
Digital watermarking directly embeds a watermark containing owner identification into the
host signal in such a way that the hacker can‟t remove the watermark without reducing the
quality of the signal or an image. Digital watermarks can be used as proof of authorization
and can be used as a signature which shows the ownership of particular asset like images,
video and audio files
2. REQUIREMENT SPECIFICATION
2.1 HARDWARE SPECIFICATION
Processor : Pentium.
RAM : 512 MB.
Hard Disk : 20 GB.
Cache : 512 KB.
2.2 SOFTWARE SPECIFICATION
OPERATING SYSTEM
A multimedia PC running a windows 98 , 2000 or XP operating system .
3. DATA ANALYSIS
3.1DFD
Input Image
Encryption
Program
Hidden Object Keys
Logic
OUTPUT FILE
Image+hidden
ABOUT DFD
A data flow diagram (DFD) is a graphical representation of the "flow" of data through
an information system, modeling its process aspects. Often they are a preliminary step used to
create an overview of the system which can later be elaborated. DFDs can also be used for
the visualization of data processing (structured design).
A DFD shows what kinds of data will be input to and output from the system, where the data
will come from and go to, and where the data will be stored. It does not show information
about the timing of processes, or information about whether processes will operate in
sequence or in parallel (which is shown on a flowchart.
DATA FLOW DIAGRAM (DFDs) are one of the three essential perspectives of the
structured-systems analysis and design method . The sponsor of a project and the end users
will need to be briefed and consulted throughout all stages of a system's evolution. With a
data flow diagram, users are able to visualize how the system will operate, what the system
will accomplish, and how the system will be implemented. The old system's dataflow
diagrams can be drawn up and compared with the new system's data flow diagrams to draw
comparisons to implement a more efficient system. Data flow diagrams can be used to
provide the end user with a physical idea of where the data they input ultimately has an effect
upon the structure of the whole system from order to dispatch to report.
Uses of Data flow diagram

When it comes to conveying how information data flows through system and how that data is
transformed in the process, DFDs are the method of choice over technical descriptions for
three principle reasons.
1. DFDs are easier to understand by technical and non-technical audiences
2. DFDs can provide a high level system overview, complete with boundaries and
connections to other systems
3.DFDs can provide a detailed representation of system components.
A data flow diagram represents the following:

1. External devices sending and receiving data .
2. Processes that change that data.
3. Data flows themselves.
4. Data storage locations.
Data flow diagrams have replaced flowcharts and pseudo code as the tool of choice for
showing program design. A DFD illustrates those functions that must be performed in a
program as well as the data that the function will need. In spite of its strength, the beauty of
DFD lies on its dependence upon just four symbols to express program design.
Symbols of Data Flow Diagram

There are only four symbols used to write Data Flow Diagram as follows:
1. External Entities –> Rectangular box.
2. Data Flow –> Arrow headed lines.
3. Process –> Bubble (Circle or round corner square).
4. Data Store –> Narrow opened rectangle.
D
ESCRIPTION OF DATA FLOW DIAGRAM
In image steganography the text is embedded behind the image, so that the message can be
sent directly to the intended recipient , and no other recipient cannot even get a hint that a
message has been sent .
1.Message is encrypted using encryption keys so that the message cannot be extracted by
any unauthorized user.
2.Encryption of message is done by assigning a password & our text will get encrypted.
3. When we will do decryption then again we have to assign the same password which we
have used during encryption then only we will get our original message.
4.This encryption & decryption method makes project more secure.
In this data flow diagram INPUT FILE is the image under which the text is embedded.
HIDDEN OBJECT is text , which is to be hide behind the image. Hidden object is
embedded behind the input file using ENCRYPTION KEYS. All these files and encryption
keys together forms the PROGRAM LOGIC . The output of this program logic is obtained in
the form of OUTPUT LOGIC , it contains two files that is IMAGE and TEXT .
3.2 Algorithmic Flow Chart
Description Of Algorithmic Flow Chart

Take theinput image(I) and the meesage (n) which is to be send . Now check the condition
that whether I>n or not. If it is greater then further process is continued & it no then process
is aborted.
Now we take input secret key & message is encrypted, after this ASCII value of message is
gentrated & this ASCII value is converted into binary form as our image is in binary form
Take 1 pixel of image of red & take 1 bit of message k=1. Compare this bit with message &
with the LSB of red pixel. If the bit is equal to LSB then insert the bit of message into LSB &
if it no then perform NOT operation in LSB. In this way our 1 bit of message is embedded
into the LSB of RED pixel
The above same process repeated for GREEN pixel & BLUE pixel & futher message bit
insertion takes place
Now this procedure is repeated until k<n & if k<n then continue the process for the second
pixel & if no then process is stopped.
4. SOFTWARE DESIGN
4.1 Development Model
The waterfall model is a model which was developed for software development; that is to
create software. It is called as such because the model develops systematically from one
phase to other in a downward fashion, like a waterfall.
The most probable phases through which it progresses downwards are
• DefinitionStudy/Analysis
• BasicDesign
• TechnicalDesign/DetailedDesign
• Construction
• Testing
• Integration
• Management
• Maintenance.
Figure 4.1: Waterfall Model
Before the advent of this method, the software development in the computer companies suffered from a
haphazard integrated software network like cluttered knitting. However with this method they hoped to
bring clarity in their projects.
About the Phases

As said earlier the waterfall model has been structured on multiple phases especially to help out the
software construction companies to develop an organized system of construction. By following this method,
the project will be divided into many stages thus easing out the whole process. For example you start with
Phase I and according to this model, one only progresses to the next Phase once the previous one has
been completed. This way one moves progressively to the final stage and once that point is reached, you
cannot turn back; similar to the water in a waterfall.
Brief Description of the Phases of Waterfall Model
Definition Study / Analysis: During this phase research is being conducted which includes
brainstorming about the software, what it is going to be and what purpose is it going to fulfill.
Basic Design: If the first phase gets successfully completed and a well thought out plan for
the software development has been laid then the next step involves formulating the basic
design of the software on paper.
Technical Design / Detail Design: After the basic design gets approved, then a more
elaborated technical design can be planned. Here the functions of each of the part are decided
and the engineering units are placed for example modules, programs etc
Construction / Implementation: In this phase the source code of the programs is written.
Testing: At this phase, the whole design and its construction is put under a test to check its
functionality. If there are any errors then they will surface at this point of the process.
Integration: in the phase of Integration, the company puts it in use after the system has been
successfully tested.
Management and Maintenance: Maintenance and management is needed to ensure that the
system will continue to perform as desired.
Through the above mentioned steps it is clearly shown that the Waterfall model was meant to
function in a systematic way that takes the production of the software from the basic step
going downwards towards detailing just like a Waterfall which begins at the top of the cliff
and goes downwards but not backwards.
History of the Waterfall Model
The history of the Waterfall model is somewhat disrupted. It is often said or believed that the
model was first put forth by Winston Royce in 1970 in one of his articles; whereas he did not
even used the word “waterfall.” In fact Royce later presented this model to depict a failure or
a flaw in a non-working model. So later on, this term was mostly used in writing about
something that is often wrongly done in the process of software development – like a
common malpractice.
Royce was more of the opinion that a successful model should have the allowance of
repetition or to go back and forth between phases which the waterfall model does not do. He
examined the first draft of this model and documented that a recurrent method should be
developed in this model. He felt the need of progressing only after a feedback from the
previous stage has been received. This is known as the Iterative model.
As opposed to the Waterfall model, the Iterative model is more practical and has room for
maneuver. Followers of the Iterative method perceive the Waterfall model as inappropriate.
Advantages of the Waterfall Model
Lets look at some of the advantages of this model
• The project requires the fulfillment of one phase, before proceeding to the next. Therefore
if there is a fault in this software it will be detected during one of the initial phases and will
be sealed of for correction.
• A lot of emphasis is laid on paperwork in this method as compared to the newer methods.
When new workers enter the project, it is easier for them to carry on the work from where it
had been left. The newer methods don’t document their developmental process which makes
it difficult for a newer member of the team to understand what step is going to follow next.
The Waterfall Model is a straight forward method and lets one know easily what stage is in
progress.
• The Waterfall method is also well known amongst the software developers therefore it is
easy to use. It is easier to develop various software through this method in short span of time.
Disadvantages of the Waterfall Model
There are many disadvantages to the model as well. Let’s have a look at those,
• Many software projects are dependent upon external factors; out of which the client for
which the software is being designed is the biggest factor. It happens a lot of times, that the
client changes the requirement of the project, thereby influencing an alteration in the normal
plan of construction and hence the functionality as well. The Waterfall Model doesn’t work
well in a situation like this as it assumes no alteration to occur once the process has started
according to plan.
If, for instance, this happens in a Waterfall Model, then a number of steps would go to waste,
and there would arise a need to start everything all over again. Of course this also brings
about the aspect of time and money which will all go to waste. Therefore this method will not
at all prove to be cost effective. It is not even easy to take out the cost estimate of each step,
as each of the phases is quite big.
There are many other software developmental models which include many of the same
aspects of the Waterfall model. But unlike the Waterfall model, these methods are not largely
affected by the outside sources. In the waterfall model, there are many different people
working in the different phases of the project like the designers and builders and each carries
his own opinion regarding his area of expertise. The design, therefore, is bound to be
influenced; however in the Waterfall model, there is no room for that.
• The other negative aspect of this model is that a huge amount of time is also wasted. For
example if we study any software development process, we know that Phase II cannot be
executed until Phase I has been successfully completed; so while the designers are still
designing the software, time of the builders is completely wasted.
• Another disadvantage of this method is that the testing period comes quite late in the
developmental process; whereas in various other developmental programs the designs would
be tested a lot sooner to find the flaw at a time when a lot of time and money has not been
wasted.
• Elaborate documentation during the Waterfall method has its advantages, but it is not
without the disadvantages as well. It takes a lot of effort and time, which is why it is not
suitable for smaller projects.
Modified Waterfall Models
Due to the various disadvantages a lot of other modified versions of this model have also
been put forth and some of these are mentioned below:
• Royce Model
Although not documented as the “Waterfall Model,” Winston W. Royce is credited with the
first formal description of what we no know as the Waterfall Model in 1970. In his original
definition, the model consisted of the following steps: Requirements
specification, Design, Construction (or coding in today’s terms), integration, testing and
debugging, installation, and maintenance.
• Sashimi Model
Sashimi is a true modified version of the Waterfall model. The phases are somewhat the same
as in the Waterfall Model; only this time the phases are overlapping each other which present
many advantages. For example the time won’t be wasted because before Phase I would be
completed, Phase II would already be underway. Moreover, since they overlap, so one can
return to the previous step if desired.
• Aorta Lifecycle Model
The difference in this model is that they rely a lot on the feedback which comes from other
phases before progressing onto the next.
• V Waterfall Model
The V Waterfall Model relies on a linear software developmental program which stresses on
balanced development more than anything else.
4.2 Key Logic
CONCEPTUAL MODEL
This is the conceptual model of the steganography system where user first encrypts the
message and then embeds it into an image and will send it over the internet to the desired user
as per wish. At the other side of the system desired user will same work on steganography
system and will extract the message from the image using stego key and then decrypt the
message to get the original message.
S te g a n o g ra p h y M e s s a g e Im a g e S te g o
E n c ry p tio n E m b e d d in g E x tra c tin g D e c ry p tio n
S y s te m
Figure4.2. Conceptual Diagram
4.3 Architecture
Figure4.3: Steganography Procedure
Description Of Steganography Procedure
There are 3 parties involved in steganography :- Sender , receiver and intruder.
For example , there are 3 persons namely alice , wendy and bob .
Where, alice play the role of sender .
wendy plays the role of intruder .
Bob plays the role of receiver.
At the part of Alice , the image is our cover image behind which the text is hidden , the text
is our hidden object and the text is embedded using a secret key , together all these 3 logics
forms the embedding algorithm .The image with the hidden text together forms the STEGO
OBJECT.
At the part of Wendy, wendy is intruder & an unauthorized user. So she tries to suppressed
the message by unauthorized means. Firstly Wendy checks that whether the message can be
suppressed or not. If yes then she suppres the message & if no then the message is directly
received by the intended recipient Bob.
At the receiver side, Bob is an intendent recipient to which Alice wants to send the message
& finally the mesaage is received by Bob
4.4 Algorithm
Step1: A few least significant bits (LSB) are substituted with in data to be hidden.
Step2: The pixels are arranged in a manner of placing the hidden bits before the pixel of each
cover image to minimize the errors.
Step3: Let n LSBs be substituted in each pixel.
Step4: Let d= decimal value of the pixel after the substitution.
d1 = decimal value of last n bits of the pixel.
d2 = decimal value of n bits hidden in that pixel.
Step5: If (d1~d2)<=(2^n)/2
then no adjustment is made in that pixel.
Else
Step6: If(d1<d2)
d = d – 2^n.
If(d1>d2)
d = d + 2^n.
This ”d” is converted to binary and written back to pixel
This method of substitution is simple and easy to retrieve the data and the image quality
better so that it provides good security.
5. Coding
import java.awt.image.BufferedImage;
import java.io.*;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.*;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
import javax.imageio.ImageIO;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.swing.UIManager;
public class Stego

{
private static List readFormats = null;
private static List writeFormats = null;
private StegoConfig config = null;
public Stego()
{
this.config = new StegoConfig();
}
public Stego(StegoConfig config)

{
this.config = config;
}
public Stego(Map propMap) throws StegoException

{
this.config = new StegoConfig(propMap);
}
public BufferedImage embedData(byte[] data, String dataFileName,

BufferedImage image) throws StegoException
{
StegoOutputStream stegoOS = null;
try
{
// Compress data, if requested
if(config.isUseCompression())
{
ByteArrayOutputStream bos = new
ByteArrayOutputStream();
GZIPOutputStream zos = new GZIPOutputStream(bos);
zos.write(data);
zos.finish();
zos.close();
bos.close();
data = bos.toByteArray();
}
// Encrypt data, if requested

if(config.isUseEncryption())
{
StegoCrypto crypto = new
StegoCrypto(config.getPassword());
data = crypto.encrypt(data);
}
// Generate random image, if input image is not provided

if(image == null)
{
image = generateRandomImage(data.length);
}
stegoOS = new StegoOutputStream(image, data.length,

dataFileName, config);
stegoOS.write(data);
stegoOS.close();
return stegoOS.getImage();
}
catch(StegoException osEx)
{
throw osEx;
}
catch(Exception ex)
{
throw new
StegoException(StegoException.UNHANDLED_EXCEPTION, ex);
}
}
public BufferedImage embedData(File dataFile, File imageFile)

throws StegoException
{
InputStream is = null;
String filename = null;
try
{
if(dataFile == null)
{
is = System.in;
}
else
{
is = new FileInputStream(dataFile);
filename = dataFile.getName();
}
}
catch(IOException ioEx)
{
throw new
StegoException(StegoException.UNHANDLED_EXCEPTION, ioEx);
}
return embedData(getStreamBytes(is), filename,

readImage(imageFile));
}
public List extractData(BufferedImage image) throws

StegoException
{
int bytesRead = 0;
byte[] data = null;
List output = new ArrayList();
DataHeader header = null;
StegoInputStream stegoIS = null;
try
{
stegoIS = new StegoInputStream(image, config);
header = stegoIS.getDataHeader();
// Add file name as first element of output list

output.add(header.getFileName());
data = new byte[header.getDataLength()];
bytesRead = stegoIS.read(data, 0, data.length);

if(bytesRead != data.length)
{
throw new
StegoException(StegoException.ERR_IMAGE_DATA_READ, null);
}
stegoIS.close();
// Decrypt data, if required

if(config.isUseEncryption())
{
StegoCrypto crypto = new
StegoCrypto(config.getPassword());
data = crypto.decrypt(data);
}
// Decompress data, if required

if(config.isUseCompression())
{
ByteArrayInputStream bis = new
ByteArrayInputStream(data);
GZIPInputStream zis = new GZIPInputStream(bis);
data = getStreamBytes(zis);
zis.close();
bis.close();
}
// Add data as second element of output list
output.add(data);
}
{
throw osEx;
}
catch(Exception ex)
{
throw new
}
return output;
}
public List extractData(File imageFile) throws StegoException

{
return extractData(readImage(imageFile));
}
private byte[] getStreamBytes(InputStream is) throws

StegoException
{
final int BUF_SIZE = 512;
ByteArrayOutputStream bos = null;
int bytesRead = 0;
byte[] data = null;
try
{
data = new byte[BUF_SIZE];
bos = new ByteArrayOutputStream();
while((bytesRead = is.read(data, 0, BUF_SIZE)) >= 0)

{
bos.write(data, 0, bytesRead);
}
is.close();
bos.close();
return bos.toByteArray();
}
{
throw new
}
}
public BufferedImage readImage(File imageFile) throws

StegoException
{
BufferedImage image = null;
try
{
if(imageFile == null)
{
return null;
}
image = ImageIO.read(imageFile);
if(image == null)
{
throw new
StegoException(StegoException.IMAGE_FILE_INVALID,
imageFile.getName(), null);
}
return image;
}
{
throw new
}
}
public BufferedImage generateRandomImage(int dataLength) throws

StegoException
{
final double ASPECT_RATIO = 4.0 / 3.0;
int numOfPixels = 0;
int width = 0;
int height = 0;
byte[] rgbValue = new byte[3];
BufferedImage image = null;
SecureRandom random = null;
try
{
random = SecureRandom.getInstance("SHA1PRNG");
numOfPixels = (int) ((DataHeader.getMaxHeaderSize() *

8 / 3.0)
+ (dataLength * 8 / (3.0 *
config.getMaxBitsUsedPerChannel())));
width = (int) Math.ceil(Math.sqrt(numOfPixels *
ASPECT_RATIO));
height = (int) Math.ceil(numOfPixels / (double) width);
image = new BufferedImage(width, height,

BufferedImage.TYPE_INT_RGB);
for(int x = 0; x < width; x++)
{
for(int y = 0; y < height; y++)
{
random.nextBytes(rgbValue);
image.setRGB(x, y,
DataHeader.byteToInt(rgbValue[0])
+
(DataHeader.byteToInt(rgbValue[1]) << 8)
+
(DataHeader.byteToInt(rgbValue[2]) << 16));
}
}
return image;
}
catch(NoSuchAlgorithmException nsaEx)
{
throw new
StegoException(StegoException.UNHANDLED_EXCEPTION, nsaEx);
}
}
public void writeImage(BufferedImage image, String

imageFileName) throws StegoException
{
String imageType = null;
try
{
if(imageFileName != null)
{
imageType =
imageFileName.substring(imageFileName.lastIndexOf('.') +
1).toLowerCase();
if(!getSupportedWriteFormats().contains(imageType))
{
throw new
StegoException(StegoException.IMAGE_TYPE_INVALID, imageType, null);
}
if(imageType.equals("jp2"))
{
imageType = "jpeg 2000";
}
ImageIO.write(image, imageType, new
File(imageFileName));
}
// If file name is not provided then write the image
data to System.out
else
{
ImageIO.write(image, "png", System.out);
}
}
{
throw new
}
}
public StegoConfig getConfig()

{
return config;
}
public static void main(String[] args) throws StegoException

{
int count = 0;
int index = 0;
String msgFileName = null;
String coverFileName = null;
String stegoFileName = null;
String extractDir = null;
String extractFileName = null;
String command = null;
List stegoData = null;
Stego stego = null;
FileOutputStream fos = null;
CmdLineParser parser = null;
CmdLineOptions options = null;
CmdLineOption option = null;
List optionList = null;
try
{
// Parse the command-line
parser = new CmdLineParser(getStdCmdLineOptions(),
args);
if(!parser.isValid())
{
displayUsage();
return;
}
if(parser.getNumOfOptions() == 0) // Start GUI

{
try
{
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
}
catch(Exception e)
{
}
new StegoUI().setVisible(true);
}
else
{
optionList = parser.getParsedOptionsAsList();
options = parser.getParsedOptions();
for(int i = 0; i < optionList.size(); i++)

{
option = (CmdLineOption) optionList.get(i);
if(((i == 0) && (option.getType() !=
CmdLineOption.TYPE_COMMAND))
|| ((i > 0) && (option.getType() ==
CmdLineOption.TYPE_COMMAND)))
{
displayUsage();
return;
}
if(i == 0)
{
command = option.getName();
}
}
// Non-standard options are not allowed

if(parser.getNonStdOptions().size() > 0)
{
displayUsage();
return;
}
// Create main stego object

stego = new Stego(new
StegoConfig(parser.getParsedOptions()));
if(command.equals("embed"))
{
msgFileName = options.getOptionValue("-mf");
coverFileName = options.getOptionValue("-cf");
stegoFileName = options.getOptionValue("-sf");
// Check if we need to prompt for password

if(stego.getConfig().isUseEncryption() &&
stego.getConfig().getPassword() == null)
{
stego.getConfig().setPassword(PasswordInput.readPassword(
LabelUtil.getString("cmd.msg.enterPassword") + " "));

}
stego.writeImage(stego.embedData(
(msgFileName == null ||
msgFileName.equals("-")) ? null : new File(msgFileName),
(coverFileName == null ||
coverFileName.equals("-")) ? null : new File(coverFileName)),
(stegoFileName == null ||
stegoFileName.equals("-")) ? null : stegoFileName);
}
else if(command.equals("extract"))
{
stegoFileName = options.getOptionValue("-sf");
extractDir = options.getOptionValue("-xd");
if(stegoFileName == null)
{
displayUsage();
return;
}
try
{
stegoData = stego.extractData(new
File(stegoFileName));
}
{
if(osEx.getErrorCode() ==
StegoException.INVALID_PASSWORD)
{
if(stego.getConfig().getPassword() ==
null)
{
stego.getConfig().setPassword(PasswordInput.readPassword(
LabelUtil.getString("cmd.msg.enterPassword") + " "));
try
{
stegoData =
stego.extractData(new File(stegoFileName));
}
catch(StegoException inEx)
{
if(inEx.getErrorCode() ==
StegoException.INVALID_PASSWORD)
{
System.err.println(inEx.getMessage());
return;
}
else
{
throw inEx;
}
}
}
else
{
System.err.println(osEx.getMessage());
return;
}
}
else
{
throw osEx;
}
}
extractFileName = options.getOptionValue("-xf");
if(extractFileName == null)
{
extractFileName = (String) stegoData.get(0);
if(extractFileName == null ||
extractFileName.equals(""))
{
extractFileName = "untitled";
}
}
if(extractDir != null)
{
extractFileName = extractDir +
File.separator + extractFileName;
}
fos = new FileOutputStream(extractFileName);

fos.write((byte[]) stegoData.get(1));
fos.close();
System.out.println(LabelUtil.getString("cmd.msg.fileExtracted", new
Object[] { extractFileName }));
}
else if(command.equals("readformats"))
{
List formats = getSupportedReadFormats();
for(int i = 0; i < formats.size(); i++)
{
System.out.println(formats.get(i));
}
}
else if(command.equals("writeformats"))
{
List formats = getSupportedWriteFormats();
for(int i = 0; i < formats.size(); i++)
{
System.out.println(formats.get(i));
}
}
else
{
displayUsage();
return;
}
}
}
{
throw osEx;
}
catch(Exception ex)
{
throw new
}
}
private static void displayUsage()

{
StegoConfig defaultConfig = new StegoConfig();
System.err.print(LabelUtil.getString("versionString"));
System.err.println(LabelUtil.getString("cmd.usage.main", new
Object[] {
File.separator,
new
Integer(defaultConfig.getMaxBitsUsedPerChannel()) }));
}
public static List getSupportedReadFormats()

{
if(readFormats != null)
{
return readFormats;
}
String format = null;

String[] formats = null;
List formatList = new ArrayList();
formats = ImageIO.getReaderFormatNames();
for(int i = 0; i < formats.length; i++)
{
format = formats[i].toLowerCase();
if(format.indexOf("jpeg") >= 0 && format.indexOf("2000")
>= 0)
{
format = "jp2";
}
if(!formatList.contains(format))
{
formatList.add(format);
}
}
Collections.sort(formatList);
readFormats = formatList;
return readFormats;
}
public static List getSupportedWriteFormats()

{
if(writeFormats != null)
{
return writeFormats;
}
String format = null;

String[] formats = null;
String[] compTypes = null;
List formatList = new ArrayList();
Iterator iter = null;
ImageWriteParam writeParam = null;
formats = ImageIO.getWriterFormatNames();
for(int i = 0; i < formats.length; i++)
{
format = formats[i].toLowerCase();
if(format.indexOf("jpeg") >= 0 && format.indexOf("2000")
>= 0)
{
format = "jp2";
}
if(!formatList.contains(format))
{
iter = ImageIO.getImageWritersBySuffix(format);
while(iter.hasNext())
{
writeParam = ((ImageWriter)
iter.next()).getDefaultWriteParam();
try
{
writeParam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
compTypes =
writeParam.getCompressionTypes();
if(compTypes.length > 0)
{
writeParam.setCompressionType(compTypes[0]);
}
}
catch(UnsupportedOperationException uoEx) //
Compression not supported
{
break;
}
// Only lossless image compression is supported

if(writeParam.isCompressionLossless())
{
break;
}
}
}
}
//Expicilty removing GIF and WBMP formats, as they use

unsupported color models
formatList.remove("gif");
formatList.remove("wbmp");
Collections.sort(formatList);
writeFormats = formatList;
return writeFormats;
}
private static CmdLineOptions getStdCmdLineOptions()

{
CmdLineOptions options = new CmdLineOptions();
// Commands
options.add("embed", "--embed", CmdLineOption.TYPE_COMMAND,
false);
options.add("extract", "--extract",
CmdLineOption.TYPE_COMMAND, false);
options.add("readformats", "--readformats",
options.add("writeformats", "--writeformats",
// File options
options.add("-mf", "--messagefile",
CmdLineOption.TYPE_OPTION, true);
options.add("-cf", "--coverfile", CmdLineOption.TYPE_OPTION,
true);
options.add("-sf", "--stegofile", CmdLineOption.TYPE_OPTION,
true);
options.add("-xf", "--extractfile",
options.add("-xd", "--extractdir",
// Command options
options.add("-b", "--maxBitsUsedPerChannel",
options.add("-c", "--compress", CmdLineOption.TYPE_OPTION,
false);
options.add("-C", "--nocompress", CmdLineOption.TYPE_OPTION,
false);
options.add("-e", "--encrypt", CmdLineOption.TYPE_OPTION,
false);
options.add("-E", "--noencrypt", CmdLineOption.TYPE_OPTION,
false);
options.add("-p", "--password", CmdLineOption.TYPE_OPTION,
true);
return options;
}
}
6. SNAPSHOTS
6.1 Inputs
FIGURE 5.1 Embedding Form
SUCCESSFUL DATA EMBEDDING
FIGURE 5.2 Successful Embedding Form
USE OF PASSWORD
FIGURE 5.3 Encryption Form
6.2 Outputs
EXTRACTION
FIGURE 5.4 Extraction Form
SUCCESFUL DATA EXTRACTION
FIGURE 5.5 Successful Extraction Form
EXTRACTION WITH PASSWORD
FIGURE 5.6 Decryption Form
INVALID PASSWORD
FIGURE 5.7 Invalid Password Error Form
INVALID IMAGE
FIGURE 5.8 Invalid Image Error Form
7. TESTING & MODIFICATIONS
7.1 Testing
The numbers of software testing have been proposed in literature. All provide the software
developer with a template for testing and all have the following given characteristics: -
a. Testing begins at the unit level works outward toward the integrations of the entire computer
based system.
b. Different testing techniques are appropriate at different points in time.
c. Testing is conducted by the developer of software (for large projects) and independent test
groups.
d. Testing and debugging are different activities but debugging must be accommodated in any
testing strategy.
Testing objective:
Testing is the objective of executing a program with the intent of finding an error. A good test
case is one that has a high probability of finding undiscovered error. A successful test is one
that uncovers undiscovered error.
Testing principle:
a.All tests should be traceable to customer requirement.
b.Tests should be long planned long before testing begins.
c.Testing should begin “in small” & progress towards testing “in the large”.
d.Exhaustive testing is not possible.
e.To be more effective, testing should be conducted by an independent.
A strategy for software testing must accommodate to level tests that are necessary to verify
that a small source code segment has been correctly implemented as well as high level tests
that validate major system functions. A strategy must provide guidance for the practitioner
and a set of milestones for the manager. Because the steps for test strategy occur at a time
when deadline pressure begins to rise, programs must be measurable and problems must
surface as early as possible. Testing does provide a last bastion from which quality can be
accessed and move pragmatically errors can be uncovered. Software testing can be carried
out at various levels throughout the entire software lifecycle
Unit Testing:
Unit testing is the process of taking a module and running it in isolation from the rest of the
software product by using prepared test cases and comparing the actual results with the
results predicted by the specifications and design of the module.
Testing For Embedding Module:

In this module we mainly submit the cover image and source image and data to be hided. we
then click the button and if the entries are valid then the successful embedding msg will be
displayed else an error message showing wrong entry will be shown.
Testing for Extraction Module:

In this we are providing the image where the data is stored and on pressing the ok button the
successful extraction msg will be displayed otherwise it will show error.
Integration Testing:
In this stage the events and procedures work as a whole in each module and module is
analyzed. Like we will execute each form by giving inputs i.e. by providing necessary
information and can see the integrated result.In case of integration testing hardware and
software elements are combined and tested until the entire program is executed. It ensures
that design objectives are satisfied. After integration testing we can find errors like
a. Interface errors
b. Performance errors
c. Software and hardware errors etc.
which should be corrected properly to get good result
Integration testing is done to after the successful completion of the unit testing. Here the
individual modules that were working properly will be put together to work collectively and
successfully.
The modules that we had tested individually during unit testing will be integrated and put to
work collectively, the information submitted in one module can be seen in other or the
calculation done in one module is not confine to that module only. While testing we find that
our all modules satisfy this criteria and are working successfully together.
In this individual module that are working properly are integrated together and checked that
whether there is proper navigation between pages are there or not. If it is not so then the
linking between pages are checked and correct pages name are mentioned.
System Testing:
The last high-order testing step falls outside the boundary of software engineering and into
tile broader context of computer system engineering. Software, once validated, must be
combined with other system element (e.g., hardware, people, and database).
System testing verifies that all elements mesh properly and that overall system
function/performance is achieved.
It is a series of different tests whose primary purpose is to fully exercise the computer based
system. Although each test has a different purpose all work to verify that system element has
been properly integrated and perform allocated functions.
7.2 Modification
Maintenance involves understanding the existing software (code and related documents),
understanding the effects of change-to both the code and the documents testing the new parts
(changes), and retesting the old parts that were not changed. Because often during
development the needs of the maintenance are not kept in mind, few support documents are
produced during development to help maintainers.
Software maintenance traditionally denotes the process of modifying a software product after
it has been delivered to the customer. Maintenance needs due to wear and tear caused by use
& following three main reasons:-
a. Corrective:
Corrective maintenance of a software product may be necessary either to rectify some bugs
observed while the system is in use, or to enhance the performance of the system.
b. Adaptive:
A software product might need maintenance when the customers need the product to run on
new platforms, on new operating system, or when they need the product to interface with new
hardware or software.
c. Perfective:
A software product needs maintenance to support the new features that the users want or to
change different functionalities of the system according to customer demands. Software
maintenance has become an important area of work for many companies, as the software
product of yester year’s age, it is mostly being carried out as fire-fighting operations, rather
than as systematic and planned activities.
Maintenance is one of the most expensive phases of the software life cycle and therefore it is
usually cost effective to invest in software maintenance activities while developing a product
& emphasize on maintenance of the product in order to reduce the maintenance costs.
7.3User Documentation
1.It is preferred that we use a windows based front end.
2.The user should be able to pick out the image file he wants to use in the hiding process.
3.The format of the image files which can be used for the hiding process should be 24-bit
bitmap.
4.User should be able to enter the text message he wants to hide
5.User should be able to view the image before and after the hiding process is complete. It is
preferable that a new image be created and displayed with the old image which will allow the
user to compare the original image with the new one which will help him to decide whether
his choice of image file was appropriate or whether he needs a new one.
6.User should be able to transfer the image freely without any problems. I.e. he should be
able to copy the new image file. Send or trade it with others without any special hardware
requirements other than the normal communication systems available with a computer.
7.There should be a encryption process to encrypt the text for better security.
7.4 Test Report
A test case in software engineering is a set of conditions or variables under which a tester will
determine whether an application or software system is working correctly or not. The
mechanism for determining whether a software program or system has passed or failed such a
test is known as a test oracle.
Formal test cases
In order to fully test that all the requirements of an application are met, there must be at least
two test cases for each requirement: one positive test and one negative test; unless a
requirement has sub-requirements. In that situation, each sub-requirement must have at least
two test cases. Keeping track of the link between the requirement and the test is frequently
done using a traceability matrix. Written test cases should include a description of the
functionality to be tested, and the preparation required to ensure that the test can be
conducted.
What characterizes a formal, written test case is that there is a known input and an expected
output, which is worked out before the test is executed. The known input should test a
precondition and the expected output should test a postcondition.
Informal test cases
For applications or systems without formal requirements, test cases can be written based on
the accepted normal operation of programs of a similar class. In some schools of testing, test
cases are not written at all but the activities and results are reported after the tests have been
run.
In scenario testing, hypothetical stories are used to help the tester think through a complex
problem or system. These scenarios are usually not written down in any detail. They can be
as simple as a diagram for a testing environment or they could be a description written in
prose. The ideal scenario test is a story that is motivating, credible, complex, and easy to
evaluate. They are usually different from test cases in that test cases are single steps while
scenarios cover a number of steps.
8. BENEFITS
1.Hidden text doesn’t stand out
2.Can be passed in simple content like image
3. By making slight change to color values we can transmit few bits here and there that are
practically undetectable.
4. Speculated use in terrorist activities .
5.Highly used to track and hide illegal content .
6.In media database system
7.Confidential communication and secret data storing.
8.Protection of data alteration.
9. LIMITATION & FUTURE ENHANCEMENTS
9.1 Limitation
There are two types of attacks: Active and Passive.
Active Attack
This involves destroying the hidden message and is more prevalent in such technologies as
digital watermarking where the main purpose is to remove the mark or render it useless.
Active attacks are also useful in situations where steganography is suspected to be in use but
discovering the hidden message is unimportant. It works in that all objects are modified in
such a manner that the object still appears to be the same but any hidden bits of information
will be void. A good example is with images whereby a certain digital effect can be applied to
the image without any human noticeable change but will change the bits of the embedded
secret message and render it unrecoverable.
Passive Attack
A passive attack involves detecting the use of steganography and is a prelude to actually
deciphering the hidden message.
Methods of steganalysis include:
· Viewing the file
· Listening to the file
· Performing comparisons on a file (if you have the original)
· Statistical Attack – this involves detecting changes in the patterns of
pixels of Least Significant Bits.
However, it can also pose serious problems because it's difficult to detect. Network
surveillance and monitoring systems will not flag messages or files that contain
steganographic data. Therefore, if someone attempted to steal confidential data, they could
conceal it within another file and send it in an innocent looking email
9.2 Future Enhancements

messages. This could be the ultimate broadcast of secret information
Future Scope of our application in points:

 Practical systems with aspects of data hiding
 Authentication of multimedia
 Informational-theoretical aspects of data hiding
 New applications, security issues and legal aspects.
10. CONCLUSION
Steganography is a fascinating and effective method of hiding data that has been used
throughout history. Methods that can be employed to uncover such devious tactics, but the
first step are awareness that such methods even exist. There are many good reasons as well to
use this type of data hiding, including watermarking or a more secure central storage method
for such things as passwords, or key processes. Regardless, the technology is easy to use and
difficult to detect. The more that you know about its features and functionality, the more
ahead you will be in the game.
11. BIBLIOGRAPHY
1.Alfred J, M et al., 1996. Hand book of applied Cryptography. First edn.
2.Ali-al, H. Mohammad, A. 2010. Digital Audio Watermarking Based on the Discrete

Wavelets Transform and Singular Value Decomposition, European Journal Of Scientific
Research, vol 39(1), pp 231-239.
3.Amirthanjan,R. Akila,R & Deepikachowdavarapu, P., 2010. A Comparative Analysis of

Image Steganography, International Journal of Computer Application, 2(3), pp.2-10.
4.Arnold, M. 2000. Audio watermarking: Features, applications and algorithms, Proceeding

of the IEEE International Conference on Multimedia and Expo, pp 1013-1016.
5. Bandyopadhyay, S.K., 2010. An Alternative Approach of Steganography Using Reference

Image. International Journal of Advancements in Technology, 1(1), pp.05-11.
Bloom,J. A. et al.,2008. Digital watermarking and Steganography. 2nd ed. Morgan
Kaufmann.
6. Bishop, M., 2005. Introduction to computer security. 1st ed. Pearson publications.
Cachin, C., 2004. Information: Theoretic model for steganography. Work shop on information
hiding, USA.
7.Chan, C.K. Cheng, L.M., 2004. Hiding data in images by simple lsb substitution: pattern
recognition.vol 37. Pergamon.
8. Cox, I. Miller, M. Bloom, J. Fridrich, J & Kalker, T. 2008. Digital watermarking and
Steganography. 2nd Ed. Elsevier.
9. Cummins, J. Diskin, P. Lau, S. & Parett, R., 2004. Steganography and digital
watermarking. School of computer science. Vol 1. MSc Information Security and Computer
Forensics
10. David, W. (2004) Managing information: IT for Business purpose. 3rd edn, pg no. 215,
Elsevier.
11. El-Emam,N.N., 2008. Embedding a large amount of information using high secure neural
based steganography algorithm. International Journal of Signal Processig, 4(2), pp.5-4.
12. Grover,D.,2001. Data Watermarking: Steganography and Watermarking Of Digital Data.

Computer Law & Security Report, 17(2), pp.65-67.
13. Glenford et al., 2004. The art of software testing. 2nd edn, pg no. 183, john wiley.
Hellman, M.E., 2002. An overview of public key cryptography. IEEE communication
magazine.
14. Jeffrey A, Bloom et al., 2008. Digital watermarking and steganography, 2nd edn, Morgan
Kaufmann publications.
15. Johnson, N.F. Jajodia, S., 1998. Exploring Steganography: seeing the unseen computing
practices, IEEE journal, Vol 1.
16. Johnson, N.F. Jajodia, S.& Duric, Z., 2001. information hiding: steganography and
watermarking – attacks and countermeasures. Kluwer academic publishers.

Image Steganography

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Image Steganography

Uploaded by

Copyright:

Available Formats

1.

Steganography will continue to increase in popularity over cryptography. As it gets more

1.4 Description Of Project

2. Public key steganography

3. Secret key steganography

2.1 HARDWARE SPECIFICATION

2.2 SOFTWARE SPECIFICATION

Uses of Data flow diagram

A data flow diagram represents the following:

Symbols of Data Flow Diagram

4.This encryption & decryption method makes project more secure.

Description Of Algorithmic Flow Chart

The most probable phases through which it progresses downwards are

Figure 4.1: Waterfall Model

About the Phases

Brief Description of the Phases of Waterfall Model

History of the Waterfall Model

Advantages of the Waterfall Model

Lets look at some of the advantages of this model

Disadvantages of the Waterfall Model

Modified Waterfall Models

• Aorta Lifecycle Model

Figure4.2. Conceptual Diagram

Figure4.3: Steganography Procedure

public class Stego

private static List writeFormats = null;

private StegoConfig config = null;

public Stego(StegoConfig config)

public Stego(Map propMap) throws StegoException

public BufferedImage embedData(byte[] data, String dataFileName,

// Encrypt data, if requested

// Generate random image, if input image is not provided

stegoOS = new StegoOutputStream(image, data.length,

public BufferedImage embedData(File dataFile, File imageFile)

return embedData(getStreamBytes(is), filename,

public List extractData(BufferedImage image) throws

// Add file name as first element of output list

bytesRead = stegoIS.read(data, 0, data.length);

// Decrypt data, if required

// Decompress data, if required

// Add data as second element of output list

public List extractData(File imageFile) throws StegoException

private byte[] getStreamBytes(InputStream is) throws

while((bytesRead = is.read(data, 0, BUF_SIZE)) >= 0)

public BufferedImage readImage(File imageFile) throws

public BufferedImage generateRandomImage(int dataLength) throws

numOfPixels = (int) ((DataHeader.getMaxHeaderSize() *

image = new BufferedImage(width, height,

public void writeImage(BufferedImage image, String

public StegoConfig getConfig()

public static void main(String[] args) throws StegoException

if(parser.getNumOfOptions() == 0) // Start GUI

for(int i = 0; i < optionList.size(); i++)

// Non-standard options are not allowed

// Create main stego object

// Check if we need to prompt for password

LabelUtil.getString("cmd.msg.enterPassword") + " "));

LabelUtil.getString("cmd.msg.enterPassword") + " "));

fos = new FileOutputStream(extractFileName);

private static void displayUsage()

public static List getSupportedReadFormats()

String format = null;

public static List getSupportedWriteFormats()