INDEX

ACKNOWLEDGEMENT i
DECLARATION ii
ABSTRACT iii

CHAPTER 1. INTRODUCTION

1.1 INTRODUCTION TO THE AREA

1.2 TECHNOLOGIES
1.3 SECURITY CONSIDERATIONS
1.4 DESIGN ISSUES

CHAPTER 2. SYSTEM STUDY

2.1 EXISTING WORK

2.2 OBJECTIVE OF THE PROPOSED SYSTEM
2.3 PROPOSED SYSTEM
2.4 PROPOSED SYSTEM MODULES
2.5 JUSTIFICATION

CHAPTER 3. REQUIREMENTS ANALYSIS AND SPECIFICATION

3.1 HARDWARE REQUIREMENTS

3.2 SOFTWARE REQUIREMENTS
3.3 JAVA

CHAPTER 4. SYSTEM DESIGN

4.1 FLOW DIAGRAM

4.2 DATA FLOW DIAGRAM
CHAPTER 5. IMPLEMENTATION

5.1 MODULES
5.2 MODULE DESCRIPTION
5.3 SAMPLE CODING

CHAPTER 6. TESTING

6.1 TESTING OBJECTIVES

6.2 PHASES OF TESTING
6.3 SCREEN SHOTS

CHAPTER 7. CONCLUSION

7.1 SUMMARY
7.2 FUTURE ENHANCEMENTS
7.3 BIBLIOGRAPHY
ACKNOWLEDGEMENT
DECLARATION
ABSTRACT

IMPLEMENTATION OF BPCS-STEGANOGRAPHY

Steganography is a technique to hide secret information in some other data (we

call it a vessel) without leaving any apparent evidence of data alteration. All of the
traditional steganographic techniques have limited information-hiding capacity. They can
hide only 10% (or less) of the data amounts of the vessel. This is because the principle of
those techniques was either to replace a special part of the frequency components of the
vessel image, or to replace all the least significant bits of a multivalued image with the
secret information. Our new Steganography uses an image as the vessel data, and we
embed secret information in the bit-planes of the vessel.

This technique makes use of the characteristics of the human vision system whereby a
human cannot perceive any shape information in a very complicated binary pattern. We
can replace all of the “noise-like” regions in the bit-planes of the vessel image with secret
data without deteriorating the image quality. We termed our Steganography “BPCS-
Steganography,” which stands for Bit-Plane Complexity Segmentation Steganography.
CHAPTER 1. INTRODUCTION

1.1 INTRODUCTION TO THE AREA

 Internet communication has become an integral part of the Infrastructure of
today’s world. The information communicated comes in numerous forms and is used in
many applications. In a large number of these applications, it is desired that the
communication be done in secrete. Such secret communication ranges from the obvious
cases of bank transfers, corporate communications, and credit card purchases, on down to
a large percentage o f everyday email. With email, many people wrongly assume that
their communication is safe because it is just a small piece of an enormous amount of
data being sent worldwide. After all, who is going to see it? But in reality, the Internet is
not a secure medium, and there are programs “out there” which just sit and watch
messages go by for interesting information.
Encryption provides an obvious approach to information security, and encryption
programs are readily available. However, encryption clearly marks a message as
containing “interesting” information, and the encrypted message becomes subject to
attack. Furthermore, in many cases it is desirable to send information without anyone
even noticing that information has been sent secret information.
Some of them use the least significant bits of the image data to hide the data.
Other programs embed the secret information in a Steganography presents another
approach to information security. In steganography, data is hidden inside a vessel or
container that looks like it contains only something else. A variety of vessels are possible,
such as digital images, sound clips, and even executable files.
In recent years, several steganographic programs have been posted on Internet
home pages. Most of them use image data for the container of the specific band of the
spatial frequency component of the carrier Some other programs make use of the
sampling error in image digitization. However, all those steganographic techniques are
limited in terms of information hiding capacity. They can embed only 5-15 % of the
vessel image at the best. Therefore, current steganography is more oriented to water
marking of computer data than to secret person-person communication applications. We
have invented a new technique to hide secret information in a color image. This is not
based on a programming technique, but is based on the property of human vision system.
Its information hiding capacity can be as large as 50% of the original image data. This
could open new Applications for steganography leading to a more secure Internet
Communication age.
Digital images are categorized as either binary (black-and-white) or multi-valued
pictures despite their actual color. We can decompose an n-bit image into a set of n binary
images by bit-slicing operations [1][2]. Therefore, binary image analysis is essential to all
digital image processing. Bit slicing is not necessarily the best in the Pure-Binary Coding
system (PBC), but in some cases the Canonical Gray Coding system (CGC) is much
better [3].

1.2 TECHNOLOGIES
This project has been developed to work all in SUN platforms for the client side
and it needs APPLET as the server side platform. We have used JAVA coding AWT and
Swing components and we have implemented these components in JAVA. The windows
API calls are mainly used in all objects to get required systems files.

1.3 SECURITY CONSIDERATIONS

THE RSA ALGORITHM

INTRODUCTION:
The RSA scheme is a block cipher in which the plaintext and cipher text
are integers between 0 and n-1 for some n.A typical size for n is 1024 bits or 309 decimal
digits. The RSA scheme has since that time reigned supreme as the most widely accepted
and implemented general purpose to public key encryption.
DESCRIPTION:
The scheme developed by Rivest, Shamir and Adleman makes use of an
expression with exponentials. Plaintext is encrypted in blocks, with each block having a
binary value less than some number n.That is, the block size must be less than or equal to
log2(n) ; in practice, the block size is k bits, where 2k < n < 2k+1 .Encryption and
decryption are of the following form, for some plaintext block M and cipher text block C:
 C = Me mod n
M = Cd mod n = (Me) d mod n = Med mod n

Both sender and receiver must know the value of n.The sender knows the value of e and
only the receiver knows the value of d.Thus, this is a public key encryption algorithm
with a public key of KU = {d,n}.

For this algorithm to be satisfactory for public key encryption, the following
requirements to be met :
1. It is possible to find the values of e, d, n such that Med = M mod n for all M < n.
2. It is relatively easy to calculate Me and Cd for all values of M < n.
3. It is infeasible to determine d given e and n.

For now,we focus on the first requirement and consider the other questions
later.We need to find a relationship of the form

Med = M mod n
Given two prime numbers and q, and two integers and m, such that n=pq
and 0<m<n, and arbitrary integer k, the following relationships holds:

Mkφ (n)+1 = mk(p-1)(q-1)+1 = m mod n

Where φ(n) is the euler’s totient function, which is the number of positive
integers less than n and relatively prime to n. it is shown that for p,q prime,
φ(p,q)=(p-1)(q-1). Thus we can achieve the desired relationship if

ed = kφ(n)+1
This is equivalent to saying:

ed = 1 mod φ(n)
d = e-1 mod φ(n)
 That is, e and d are multiplicative inverses mod φ (n). Note that, according to the
rules of modular arithmetic, this is true only if d (and therefore e) is relatively prime to φ
(n). Equivalently, gcd (φ(n),d) = 1.
We are now ready to state the rsa scheme.the ingredients are the following:

P, q, two prime numbers (private, chosen)

n = pq (public, calculated)
e, with gcd(φ(n),e) = 1; 1< e < φ(n) (public, chosen)
d = e-1mod φ(n) (private, calculated)

The private key consist of {d,n} and the public key consists of {e,n}.suppose that
user a has published its public key and that user b wishes to send the message M to A.
then b calculates C = Me (mod n) and transmits C. on receipt of this cipher text, user a
decrypts by calculating M = Cd (mod n).
It is worthwhile to summarize the justification for this algorithm. We have chosen
e and d such that

d = e-1 mod ø (n)

Therefore,
Ed = 1 mod ø (n)
Therefore,ed is of the form kø(n)+1

So M ed = mod n .Now
C = Me mod n
M = Cd mod n = (Me)d mod n = M mod n
The keys were generated as follows:
1. Select two prime numbers p and q
2. Calculate n = pq
3. Calculate ø (n) = (p-1) (q-1)
4. Select e such that e is relatively prime to ø (n) and less than ø(n)
5. Determine d such that de = 1 mod ø (n)

KEY GENERATION

Before the application of the public key cryptosystem, each participant must generate
a pair of keys. This involves the following tasks:
1. Determining two prime numbers, p and q
2. Selecting either e or d and calculating the other

The procedure for picking a prime number is as follows:

1. Pick an odd integer n at random
2. Pick an integer a < n at random
3. Perform the probabilistic primarily test, such as Miller Rabin. If n fails the test, reject
the value n and go to step 1.
4. If n has passed a sufficient number of tests, accept n; otherwise, go to step

THE SECURITY OF RSA

Three possible approaches to attacking the RSA algorithm are as follows :

1. Brute force: This involves trying all possible private keys.
2. Mathematical attacks: There are several approaches, all equivalent in effect to factoring
the product of two primes
3. Timing attacks: These depend on the running time of the decryption algorithm.

1.4 DESIGN ISSUES

 1. EMBEDDING CAPACITY

We have developed BPCS-Steganography programs for both

Windows and Unix. In each program, we took an 8 8 square as the local image
size. Fig. 4 (A) is an example of the original dummy image
(640x588, full color). (B) is the same image with all the information of Fig. 5
embedded in it. As indicated in Fig. 5 this embedded information includes a picture of
Lincoln, the text from four historical documents, and the entire script from seven of
Shakespeare’s plays. Note that the size of the embedded information before
compression is almost as great as the image size itself. Furthermore, the embedding
operation does not increase the size of the image by even a single byte. Yet, even when
viewed on the computer monitor, the images before and after embedding are almost
indistinguishable from one another.
It should also be noted that the image of Fig. 4 contains a number of large
regions that are relatively flat in color. Our BPCS technique made little use of such
regions for embedding, as doing so would introduce noticeable noise in these regions.
Fig.6 presents an example of embedding in a scene with few flat regions. In this case the
image is 617x504 pixels. (A) shows the original image, and (B) shows the image after
embedding all the information of Fig. 5 plus an additional Shakespearean play, “Antony
and Cleopatra” of size 179,900 bytes before compression and 64,184 bytes after.
Therefore the total information embedded in this 933,408 byte image is actually
1,212,744 bytes before compression; i.e., the embedded information exceeds the vessel
size by 30%.

The compressed data size is 505,502 bytes, which is 54% of the vessel size. Even with
this much information embedded in the image, the embedded and original images look
nearly identical when viewed on the monitor.
(A) Original vessel image (B) Embedded vessel image
Fig.4 Example of a vessel image
 Through our embedding experiments, we found that most color images
taken by a digital camera can be used as vessel images. In almost all cases, the
information hiding capacity was nearly 50% of the size of each vessel image. This
capacity is 4 to 5 times as large as currently known steganographic techniques. For a
given image, embedding capacity can be traded with image quality by altering the
complexity threshold. The image of Fig. 4 used a threshold of 24 border pixels per 8
8 region; therefore regions having more border pixels than this were eligible for
embedding. Fig. 7 shows how the capacity changes with threshold for this image. For this
image a threshold of 24 seemed optimal, while lower thresholds introduced some “noise”
to the image.
2. USING GRAY CODED BIT-PLANES FOR COMPLEXITY
SEGMENTATION

The advantage to using Gray Coded bit planes for complexity segmentation. Parts
A through C of this figure show the PBC red bit planes numbered 3 through 5 for the
image of Fig. 5a, while parts D through F show the CGC version of these same planes.
From looking at such bit planes, one can get a pretty good idea of which regions of the bit
plane are complex enough to be replaced with information during BPCS embedding.
Recall that the goal with BPCS Steganography is to use as much of the image as possible
for hiding information without appreciably altering the visual appearance of the image. In
comparing these two sets of bit planes, it is evident that the PBC bit planes provide a
much greater region for embedding.

However, substantial portions of the regions on the higher bit planes deemed
embeddable using PBC are actually relatively flat in color. For example, note the wall in
the background. This is because of the “Hamming Cliffs” which occur with PBC wherein
a small change in color affects many bits of the color value. If embedding were to replace
the bits in such complex looking but actually relative flat regions, then substantial color
changes would occur. As a simple example, consider a region where the blue value
hovers nearly randomly between the binary values of 01111111 and 10000000. In this
region, every bit plane would look complex and would thus appear to be embeddable,
while in practice, it would be prudent to only embed in the lower one or two planes.
Although occurrences such as this where all bits change in a relatively flat region are
rare, the frequency of occurrence doubles on each lower bit plane.

3.CUSTOMIZATION OF THE PROGRAM

The BPCS-Steganography algorithm has several embedding

parameters for a practical program implementation. Some of them are:
(1) The embedding location of the header(s) of the secret file(s)
(2) The embedding threshold, 0.
(3) The sequence in which the 8 8 regions of the vessel image are considered for
embedding.
(4) The encoding of the conjugation map.
(5) Special operations, such as an exclusive-or of the header bytes or embedded data with
pseudo-random numbers.
(6) Encryption parameters of the secret file(s)
(7) The compression parameters of the secret file(s)

It is very easy for a single BPCS Steganography program to allow the user to
customize parameters such as these, producing a very large number of possible
customized programs. In this way, each user or group of users can have their own
program that embeds data in an image in a way that is unreadable by others.
CHAPTER 2. SYSTEM STUDY

2.1 EXISTING WORK

•Information send through any network have a chance to attack by hackers
•Encryption provides an obvious approach to information security, and encryption
programs are readily available. However, encryption clearly marks a message as
containing “interesting” information, and the encrypted message becomes subject to
attack. Furthermore, in many cases it is desirable to send information without anyone
even noticing that information has been sent secret information.

2.2 OBJECTIVE OF THE PROPOSED SYSTEM

The main objective of this system is we never leave any information about
something will be hided in that vessel.
2.3 PROPOSED SYSTEM
•In Steganography, data is hidden inside a vessel or container that looks like it
contains only something else. A variety of vessels are possible, such as digital images,
sound clips, and even executable files.
•All of the traditional steganographic techniques have limited information-hiding
capacity. They can hide only 10% (or less) of the data amounts of the vessel.

•This Technique uses an image as the vessel data, and we embed secret information in the
bit-planes of the vessel.
•We can replace all of the “noise-like” regions in the bit-planes of the vessel
image with secret data without deteriorating the image quality
•We termed our Steganography “BPCS-Steganography,” which stands for Bit-
Plane Complexity Segmentation Steganography
 2.4 PROPOSED SYSTEM MODULES
 Hider
File Segmentation (8 X 8)
Noise Level Identifier
Complexity Identifier
Gray Converter
Noisy level Revalidator
Secret File Segmentor
Text & Image bits replacer
Image Reproducer
 Retriever
Image Scanner
Image Segmentor (8 x 8)
Complex Plan Identifier
Information Retriever
Process State Identifier

2.5 JUSTIFICATION
•In Encryption, Message can be hacked, because some one can easily detect the
encrypted file.
•This technique makes use of the characteristics of the human vision system
whereby a human cannot perceive any shape information in a very complicated binary
pattern.
CHAPTER 3. REQUIREMENTS ANALYSIS AND
SPECIFICATION
3.1 HARDWARE REQUIREMENTS

Processor : Pentium Celeron

Processor Speed : 850 MHZ

Memory Size : 128MB

Hard Disk Drive : 40GB

3.2 SOFTWARE REQUIREMENTS

Operating System : Windows 98/2000/NT

Front End : JAVA 1.5.0

3.3 JAVA
JAVA is an object oriented language, it is basically supports all concepts of
c and c++ with some additional features. Other attractive feature JAVA is a platform
independent language. The genesis of java is complete without a look at the java
buzzwords.
 simple
 secure
 portable
 object-oriented
 robust
 multithreaded
  architecture-neutral
 interpreted
 high performance

 distributed

 dynamic

Java can be used to create two types of programs: applications and applets.

An application is a program that runs on your computer under the operating system
of your computer. An applet is a application designed to transmitted over the internet and
executed by the java compatible web server. An applet is a tiny java program,
dynamically downloaded across the network, just like an image, sound file or video clip.
The important difference is that an applet is an intelligent program, not just an animation
or media file.

Dynamic Link Library

Dynamic link Library is the file extension. it is a block of code containing

Procedures and functions that are useful for more than one program. Linking
Is nothing but getting the prewritten code in our program. The linking is
Done in two ways
1. static Linking
2. Dynamic Linking
Dynamic Linking:
In dynamic linking, the external library file never gets bound in to the final
executable file. It remains outside the program as DLL, hopefully in a place
Where the executable can find it ant it messages. At run time, these messages are function
or procedures calls, requesting that certain parts of the DLL code are executed.
To link your executable and the DLL it needs to run, just take the program
Where the DLL is, and which bit of code we want run from inside it. it is ,as we say,
dynamically linked.
 Advantages of dynamic linking are 1.consistency, 2.Maintenance,
3.Smaller Executables

 Consistency gives more or less common user interface across

application.
 By having a lot of common code in one place, you can update and amend
that code centrally, and changes are reflected all the applications that use
it. That’s why, when you run windows 3.1 applications on Windows 95.
They inherit some user interface features of the new system.
 By moving a lot of the back room business out of another file,rather
than statically linking the functions and procedures, we can reduce
size of your executable.

The windows API

The windows application programmers interface is a collection of ready-
made function and procedures. Most of the API calls are already implemented in
JAVA iun the forms of JAVA commands, keywords, methods and properties.thease are
translated into the corresponding API calls inside the JAVA.

JAVA PACKAGES AND API

AWT

The AWT classes contained by the java.awt package. It is one of the largest
packages. Because it is logically organized in a top-down, hierarchical fashion, it is easier
to understand and use than you might at first believe. AWT contains numerous classes
and methods that allow you to create and manage windows. It also explains further
aspects of of java’s event handling mechanism. The main purpose of the AWT is to
support applet windows, it can be used to create stand –alone windows that run in a GUI
environment such as windows.

APPLET

The applet class is contained by the java.applet package. Applet

contains several methods that give you detailed control over the execution of
your applet. Java.applet also defines three interfaces AppletContext,
AudioClip, AppletStub. All applet must import with java.applet .applets
must also import with the java.awt.

UTIL

The java.util package contains some of the most exiting

enhancements added by java 2 collections .a collections is group of objects
the addition of collections caused fundamental alterations in the structure
and architecture of many elements of java.util.java.util contains a wide
range of functionality.thease classes and interfaces are used throughout core
java packages. These include classes that tokenize the string, work with
dates, compute random numbers and observe events.

NET

The java.net package which provides support of networking. Java is

good language for networking the classes are defined in java.net package.
These networking classes encapsulate the “socket” paradigm pioneered by
the BSD.
ZIP
The java.util.zip package provides the ability to read and write files
in the popular ZIP and GZIP formats. Both ZIP and GZIP input and output
streams are available. Other classes implement the ZLIB algorithms for
compression and decompression.
SWING
The swing is a set of classes that provides more powerful and flexible
components than are possible with the AWT. Unlike AWT components
Swing components are not implemented by platform specific code. They are
written entirely in java and, therefore, are platform-independent. The term
lightweight is used to describe such elements. The number of classes and
interfaces in the swing packages is substancial. Swing is area that you will
want to explore further on your own

APPLICATION PROGRAMMING INTERFACES

Listeners are created by implementing one or more of the interfaces

Defined by the java.awt.event package. When an event occurs, the event
Source invokes the appropriate method defined by the listener.

Action Listener interface

This interface defines the actionPerformed () method that is Invoked when an
action event occurs. Its general form is shown
Void actionPerformed (ActionEvent ae)

The mouselistener interface

Void windowActivated(WindowEvent we)
Void windowActivated(WindowEvent we)
This interface defines five methods.If the mouse is pressed and released at the same
point,mouseClicked() is invoked.Whenthe mouse enters a component,the mouseEntered()
method is called.When it leaves, mouseExited() is called. The mousePressed
andmouseRealeased() methods are invoked when the mouse is pressed andreleased,
respectively.
 The general forms of these methods are shown here:
Void mouseClicked(MouseEvent me)
Void mouseEntered(MouseEvent me)
Void mouseExited(MouseEvent me)
Void mousePressed(MouseEvent me)
Void mouseRealeased(MouseEvent me)

The MouseMotionListener interface

This interface defines two methods. The mouseDragged() method is
called multiple times as the mouse is dragged. The mouseMoved() method
multiple times as the mouse is moved. Their general forms are shown here:
Void mouseDraged(MouseEvent me)
Void mouseMoved(MouseEvent me)

The TextListener interface

This interface defines the textChanged() method that is invoked when a
change occurs in a text area or text field. Its general form is shown here:
Void textChanged(TextEvent te)

The WindowListener interface

This interface defines seven methods. The windowActivated() and
windowDeactivated() methods are invoked when a window is activated or
deactivated, respectively. If a window is iconified, the windowIconifed()
method is called. When a window is deiconified, the windowDeiconified()
method is called. When a window is opened or closed, the windowOpened()
or windowClosed() methods are called, respectively. The windowClosing()
method is called when a window is being closed. The general forms of these
methods are
Void windowActivated(WindowEvent we)
Void windowClosed(WindowEvent we)
Void windowClosing(WindowEvent we)
Void windowDeactivated(WindowEvent we)
Void windowDeiconified(WindowEvent we)
Void windowIconified(WindowEvent we)
Void windowOpened(WindowEvent we)

Using the delegation event model

Now that you have learned the theory behind the delegation event model
and have had an over view of its various components,it is time to see it in
practice.appletprogramming using the delegation event model is actually
quite easy.just follow these two steps:
1.implement the appropriate interface in the listener so that it will receive the
type of event desired.
2.implement code to register and unregister(if necessary)the listener as a
recipient for the event notifications.
Remember that a source may generate several types of events.each event
must be registered separately.also,an object may register to receive several
types of events,but it must implement all of the interfaces that are required to
receive these events.
To see how the delegation model works in practice,we will look at
examples that handle the two most commonly used event generators:the
mouse and keyboard.

BASIC FOUNDATION CLASSES

Applet
Applet provides all necessary support for execution, such as starting
and stoping.it also provides methods that load and display images and
methods that load and play audio clips. Applet extends the AWT class
panel. In turn panel extends container, which extends component. These
classes provide support java’s window based, graphical interface. Thus
applet provides all of the necessary support for window-based activities.
image
This class provides support foe imaging. Images are objects of the
Image class, which is a part of the java.awt package. There are a large
number of imaging classes and interfaces defined by java.awt.image and its
not possible to examine them all.
event
The classes that represent events are at the core of java’s events
handling mechanisms. They provide a consistent, easy-to-use means of
encapsulating events. At the root of the java event class hierarchy is
EventObject, which is in java.util. it is the super class for all events. Its one
constructor is shown
EventObject(Object src)
 CHAPTER 4. SYSTEM DESIGN

4.1 FLOW DIAGRAM

SERVER SIDE

Encryption key,
Other keys

Cover Embedding Marked

media algorithm media

(Images.
Audio files,
Network packets, (Stego
Circuitry/software Information
media)
Text) to hide
 CLIENT SIDE

Decryption key,
Other keys

Stego Extraction Extracted

media algorithm message
 4.2 DATA FLOW DIAGRAM

FLOW DIAGRAM
(Client Side)

HOME
PAGE

LOGIN REGISTER ABOUT

US

HOME User
PAGE Exist

User Interaction

Stego-image

Encryption

Decompression

decryption

Original Message
 FLOW DIAGRAM
(Server Side)

HOME
PAGE

LOGIN REGISTER ABOUT

US

HOME User
PAGE Exist

User Interaction

Choose Vessel Secret File

Image

Encryption

Compression

Data Hiding into

Vessel Image

Sign Out
CHAPER 5. IMPLEMENTATION

5.1 MODULES
Bit-Plane Complexity Segmentation Steganography is our new
steganographic technique, which has a large information hiding capacity. As was shown
in the previous section, the replacement of the complex regions in each bit-plane of a
color image with random binary patterns is invisible to the human eye. We can use this
property for our information hiding (embedding) strategy. Our practical method is as
follows.
In our method we call a carrier image a “vessel” or“dummy” image. It is a color image in
BMP file format, which hides (or,embeds) the secret information (files in any format). We
segment each secretfile to be embedded into a series of blocks having 8 bytes of data
each.
These blocks are regarded as 8 8 image patterns. We call such blocks the secret
blocks. We embed these secret blocks into the vessel image using the following steps.
1.Transform the dummy image from PBC to CGC system.
2. Segment each bit-plane of the dummy image into informative and noise-like regions by
using a threshold value (a0). A
typical value is a0 = 0.3.
3. Group the bytes of the secret file into a series of secret blocks.
4. If a block (S) is less complex than the threshold (0), then Conjugate it to make it a
more complex block (S*). The conjugated block Must be more complex than 0 as
shown by equation .
5. Embedded each secret block into the noise-like regions of the bit-
planes (or, replace all the noise-like regions with a series of secret blocks). If the block
is conjugated, then record this fact in a “conjugation map.”
6. Also embed the conjugation map as was done with the secret blocks
7. Convert the embedded dummy image from CGC back to PBC.
 The Decoding algorithm (i.e., the extracting operation of the secret
information from an embedded dummy image) is just the reverse procedure of the
embedding steps.
The novelty in BPCS-Steganography is itemized in the following.

A) Segmentation of each bit-plane of a color image into “Informative” and “Noise-like”

regions.
B) Introduction of the B-W boarder based complexity measure () for region
segmentation
C) Introduction of the conjugation operation to convert simple secret blocks to complex
blocks.
D) Using CGC image plane instead of PBC plane

Modules Names

 Hider
 Retriver
5.2 MODULE DESCRIPTION

HIDER

1. Load Image

2. Load Source

3. Choose Encryption
Keys

4. File Compressor

5. Image Analyzer

6.File Hider
RETRIEVER

1. Choose Embedded
Image

2. Choose Text File /

Directory

3. File Extractor

4. Content Displayer
 BPCS

1. Load Image 1. Choose Embedded

Image

2. Load Source
2. Choose Text File /
Directory
3. Choose Encryption
Keys 3. File Extractor

4. File Compressor
4. Content Displayer

6.File Hider
MODULES SPECIFICATIONS

HIDER
File Segmentation (8 X 8)
Noise Level Identifier
Complexity Identifier
Gray Converter
Noisy level Revalidator
Secret File Segmentor
Text & Image bits replacer
Image Reproducer

RETRIEVER
Image Scanner
Image Segmentor (8 x 8)
Complex Plan Identifier
Information Retriever
Process State Identifier
SUB MODULES

ENCRYPTOR
Public key Exponent Finder
Private Key Exponent Finder
File Reader
File Text Encryption
Encrypted File Storage

FILE COMPRESSOR
Get Encrypted file from Encryptor
File compression
Store compressed File
IMAGE ANALYSER
Identifier
File size
IMAGE LIST VIEWER
Database Connector
Image List Displayer
File Name Container
5.3 SAMPLING CODING

import java.applet.*; import java.awt.*; import java.awt.image.*;

import java.util.*; import java.io.*; import java.net.*; /*import
ImageEncoder; import GifEncoder; import EzStegoEncoder; import
DynamicFilterInputStream; */ //to get around image loading bug import
sun.awt.image.FileImageSource; public class EzStego extends Applet
implements Runnable, ImageConsumer {

private Image image = null;

DynamicFilterInputStream cDynamicFilterInputStream;

EndsWithFilter cEndsWithFilter;

EzStegoEncoder cEzStegoEncoder;

RGBPaletteSorter cRGBPaletteSorter;

static final private boolean DEBUG = true;

private static boolean NOGUI = false;

private static boolean UNSTEG = false;

private static boolean VERBOSE = false;

static private EzStego stego;

Image splashImage;

private String imageDirString,imageFileString;

private Panel buttonBox;

StegoCanvas canvas;

Label statusLabel; private Button openGIFButton;

private Button stegButton;

private Button unstegButton;

private Button fetchButton;

private Button urlButton;

private TextField urlTextField; StegoPanel statusPanel; Color

foreColor, errColor, buttonColor; ImageScrollbar horizontalSB,
verticalSB; /*for getting color table*/ ImageProducer pro; int[]
rgbPalette; int numRGBvalues; int bitDepth; private
EzStegoEncoder ie; int spaceAvail; public EzStego() {
}
public void init2() {
/*stego.start();
if
(NOGUI) {
stego.init_nogui(); }

else {

StegoFrame f = new StegoFrame(versionString);

f.add("Center",stego);

f.resize( 400, 400);

f.show(); }
*/ if (!NOGUI) {

String dfltFont = "TimesRoman";

Font font = new Font(dfltFont,Font.PLAIN,12);

foreColor = Color.black;

buttonColor = new Color(0xFFCCFF);

errColor = Color.red; Color backColor = Color.white;

setLayout(new BorderLayout(0,0));

setBackground(backColor);

setForeground(foreColor);

StegoPanel topBox = new StegoPanel(); //Set constraints for

button box

topBox.setBackground(backColor);

topBox.setForeground(foreColor);

add( "North",topBox);

topBox.setLayout(new BorderLayout());

Panel urlBox = new Panel();

GridBagLayout urlBoxLayout = new GridBagLayout();

GridBagConstraints gbc = new GridBagConstraints();

urlBox.setLayout( urlBoxLayout );

urlBox.setBackground(backColor);

urlBox.setForeground(foreColor);

Label urlLabel = new Label("URL:");

urlLabel.setBackground(backColor);

urlLabel.setForeground(foreColor);

urlLabel.setAlignment(Label.LEFT);

urlLabel.setFont(font);
gbc.gridheight = 1;

gbc.fill = GridBagConstraints.NONE;

gbc.anchor = GridBagConstraints.WEST;

gbc.weightx = 0;

gbc.insets = new Insets(5,1,5,3); urlBox.add(urlLabel);

urlBoxLayout.setConstraints(urlLabel,gbc);

urlBox.add(urlTextField = new TextField());

urlTextField.setEditable(true);

urlTextField.minimumSize(50);

urlTextField.preferredSize(50);

urlTextField.setFont(new

Font(dfltFont,Font.PLAIN,12));

gbc.gridx = GridBagConstraints.RELATIVE; //

gbc.gridwidth = 4;

gbc.gridheight = 1;

gbc.fill = GridBagConstraints.HORIZONTAL;
gbc.anchor = GridBagConstraints.EAST;

gbc.weightx = 0.80;

urlBox.add(urlTextField);

urlBoxLayout.setConstraints(urlTextField,gbc);

urlButton = new Button("Fetch GIF");

urlBox.add(urlButton);

gbc.gridx = GridBagConstraints.RELATIVE; //

gbc.gridwidth = 4;

gbc.gridheight = 1;

gbc.fill = GridBagConstraints.NONE;

gbc.anchor = GridBagConstraints.EAST;

gbc.weightx = 0.20;

gbc.insets = new Insets(5,4,5,3);

urlBox.add(urlButton);

gbl.setConstraints(openGIFButton,gbc);

buttonBox.add(stegButton = new Button("Steg"));

stegButton.setForeground(Color.black);

stegButton.setBackground(buttonColor);

stegButton.setFont(font);

gbl.setConstraints(stegButton,gbc);

buttonBox.add(unstegButton = new Button("Unsteg"));

c.gridy = 0;

gridBag.setConstraints(verticalSB, c);

canvasBox.add(verticalSB);

add("Center",canvasBox);

statusPanel = new StegoPanel();

statusPanel.setBackground(backColor);

statusPanel.setForeground(foreColor);

gbl = new GridBagLayout();

statusPanel.setLayout(gbl);

statusLabel = new Label(versionString ,Label.LEFT);

Font msgfont = new Font(dfltFont,Font.PLAIN,12);

statusLabel.setFont(msgfont);

statusLabel.setBackground(backColor);

statusLabel.setForeground(foreColor);

gbl.setConstraints(statusLabel,gbc);

statusPanel.add(statusLabel);

add("South", statusPanel);

f.show(); }
}

topBox.setLayout(new BorderLayout());

Panel urlBox = new Panel();

GridBagLayout urlBoxLayout = new GridBagLayout();

GridBagConstraints gbc = new GridBagConstraints();

urlBox.setLayout( urlBoxLayout );

urlBox.setBackground(backColor);

urlBox.setForeground(foreColor);

Label urlLabel = new Label("URL:");

urlLabel.setBackground(backColor);

urlLabel.setForeground(foreColor);

urlLabel.setAlignment(Label.LEFT);

urlLabel.setFont(font);

gbc.gridheight = 1;

gbc.fill = GridBagConstraints.NONE;

gbc.anchor = GridBagConstraints.WEST;

gbc.weightx = 0;

gbc.insets = new Insets(5,1,5,3);

urlBox.add(urlLabel);

urlBoxLayout.setConstraints(urlLabel,gbc);

urlBox.add(urlTextField = new TextField());

urlTextField.setEditable(true);

urlTextField.minimumSize(50);

urlTextField.preferredSize(50);

urlTextField.setFont(new
Font(dfltFont,Font.PLAIN,12));

gbc.gridx = GridBagConstraints.RELATIVE; //

gbc.gridwidth = 4;

gbc.gridheight = 1;

gbc.fill = GridBagConstraints.HORIZONTAL;

gbc.anchor = GridBagConstraints.EAST;

gbc.weightx = 0.80;

urlBox.add(urlTextField);

urlBoxLayout.setConstraints(urlTextField,gbc);

urlButton = new Button("Fetch GIF");

urlBox.add(urlButton);

gbc.gridx = GridBagConstraints.RELATIVE; //

gbc.gridwidth = 4;

gbc.gridheight = 1;

gbc.fill = GridBagConstraints.NONE;
gbc.anchor = GridBagConstraints.EAST;

gbc.weightx = 0.20;

gbc.insets = new Insets(5,4,5,3);

urlBox.add(urlButton);

urlBoxLayout.setConstraints(urlButton,gbc);

urlButton.setForeground(Color.black);

urlButton.setBackground(buttonColor);

urlButton.setFont(font);

topBox.add("South",urlBox);

buttonBox = new StegoPanel();

GridBagLayout gbl = new GridBagLayout();

buttonBox.setLayout(gbl);
//
GridBagConstraints

gbc = new GridBagConstraints();

gbc.insets = new Insets(5,5,5,5);

gbc.weighty = 1.0;

gbc.weightx = 1.0;

GridBagLayout gridBag = new GridBagLayout();

canvasBox.setLayout(gridBag); //
first the canvas

GridBagConstraints c = new GridBagConstraints();

c.weightx = 1.0;

c.weighty = 1.0;

c.fill = GridBagConstraints.BOTH;

gridBag.setConstraints(canvas, c);

canvasBox.add(canvas); //
then the horizontal Scrollbar

c.weightx = 0.0;

c.weighty = 0.0;

c.gridx = 0; c.gridy = 1;

gridBag.setConstraints(horizontalSB, c);
canvasBox.add(horizontalSB); //
finally, the vertical Scrollbar

c.gridx = 1;

c.gridy = 0;

gridBag.setConstraints(verticalSB, c);

canvasBox.add(verticalSB); add("Center",canvasBox);

statusPanel = new StegoPanel();

statusPanel.setBackground(backColor);

statusPanel.setForeground(foreColor);

gbl = new GridBagLayout();

statusPanel.setLayout(gbl);

statusLabel = new Label(versionString ,Label.LEFT);

Font msgfont = new Font(dfltFont,Font.PLAIN,12);

statusLabel.setFont(msgfont);

statusLabel.setBackground(backColor);

statusLabel.setForeground(foreColor);
gbl.setConstraints(statusLabel,gbc);

statusPanel.add(statusLabel); add("South", statusPanel);

stego.start();
if
(NOGUI)

stego.init_nogui(); }

else {

StegoFrame f = new StegoFrame(versionString);

f.add("Center",stego);

f.resize( 400, 400);

f.show(); }
}

public static void parseCmdLine(String args[]) { int

i = 0;

String arg;

while (i < args.length && args[i].startsWith("-")) {

arg = args[i++];
//S
ystem.out.println(arg); //
use this type of check for "wordy" arguments if
(arg.equals("-verbose")) {

System.out.println("Verbose mode on");

VERBOSE = true; }
if (arg.equals("-nogui")) { if (VERBOSE) {System.out.println("Batch
mode on");} NOGUI = true; } if (arg.equals("-unsteg")) { if
(VERBOSE) {System.out.println("Unsteg mode on");} UNSTEG =
true; } // use this type of check for arguments that require

arguments else if (arg.equals("-image")) { if (i < args.length)

imagefile = args[i++]; else System.err.println("-image always
requires a URL

after it"); if (VERBOSE) {System.out.println("image file = " +

imagefile);} } else if (arg.equals("-input")) { if (UNSTEG)

System.err.println("-input not needed for

unstegging"); if (i < args.length) inputfile = args[i++]; else

System.err.println("-input always requires a file name); if (VERBOSE)
{System.out.println("input file = " + inputfile);} } else if
(arg.equals("-output")) { if (i < args.length) outputfile = args[i++];
else System.err.println("-output always requires a file name"); if
(VERBOSE) {System.out.println("output file = " + outputfile);} }
else if (arg.equals("-filter")) { if (i < args.length) filtername =
args[i++]; else System.err.println("-filter requires a class name"); if
(VERBOSE) {System.out.println("filter = " + filtername);} }
} //
while if
(args.length != 0) {
if
(i == args.length) System.err.println("Usage: EzStego -nogui [-verbose]
[-unsteg] -image filename -input filename [-filter
classname] -output filename"); else if (VERBOSE)
{System.out.println("Arguments successfully read.");} }
}
/* main */

Public static void main(String argv[]) {

parseCmdLine(argv);

stego = new EzStego(); stego.init2();

stego.start();
if
(NOGUI) {

stego.init_nogui(); }

else {

StegoFrame f = new StegoFrame(versionString);

f.add("Center",stego);
f.resize( 400, 400);

f.show(); }
}

public void start() {

super.start();
//p
reload all classes to avoid Win95 FileDialog bug

cEndsWithFilter = new EndsWithFilter();

cEzStegoEncoder = new EzStegoEncoder(null,null);

cRGBPaletteSorter = new RGBPaletteSorter(); }

public void init_nogui() {

openImageFile(); if
(UNSTEG) unSteg();

else doSteg(); }

public Image image() {

return image; }

public Image splashImage() {

return splashImage; }

static public EzStego app()

catch (Exception e)

{ setStatus( "Could not construct URL: "+urlString,true);

return; }
try
{

String mimetype = imageURLC.getContentType(); if

(! (mimetype.equals("image/gif"))) {

return; }

Object content = imageURLC.getContent();

image = createImage((ImageProducer) content);

waitForImage(this,image);
}

catch (Exception e)

{ setStatus( "Could not download image: "+imageURL.getFile(),true);

return; }
if
(image == null)

{ setStatus( "Unable to load image: "+imageURL.getFile(),true);

return; }

getImageStats(image); spaceAvail = (image.getHeight(this) *

image.getWidth(this))/8; setStatus("File: "+imageURL.getFile()+"
Space available: "+spaceAvail+"

bytes",false); if
(!NOGUI) {

canvas.setImage(image);

invalidate();

getParent().layout();

canvas.repaint();

repaint(); }
} public void openImageFile() { if (!NOGUI) {
setStatus( "Select a GIF image file.",false); Container f = getParent();
while (f != null && !(f instanceof Frame)) f = f.getParent();
setStatus("Enter a name for the new GIF file.",false); repaint();
Container f = getParent(); myfileDialog.setFile("output.gif");
myfileDialog.show(); repaint(); //Workaround Win95 FileDialog
bug // If user cancels from dialog, return if (myfileDialog.getFile()
== null) return; InputStream myFileInputStream = getFiletoHide();
if (myFileInputStream == null) return; // Create output file & try to
open a stream to it setStatus("Opening output file stream. ",false);
File destination_file = null; if (outputfile != null)
{ destination_file = new File(outputfile); try { destination =
new FileOutputStream(destination_file); } catch (Exception e)
return; } } } OutputStream destination = System.out; if (outputfile
!= null) { File destination_file = new File(outputfile); try
{ destination = new FileOutputStream(destination_file); catch
(IOException e) { SetStatus("Error while saving file.
"+e.getMessage(),true); return; } } try { ie = new
EzStegoEncoder( image, destination, null, rgbPalette); } Catch
(Exception e) { setStatus( "Could not initialize image
encoder."+e.getMessage(),true);

return; }
/**
Try to encode the .gif */

ie.setFunction( EzStegoEncoder.UNSTEG); try

{

ie.encode(); }

catch (IOException e) {
setStatus( "Stego recovery failed: "+e.getMessage(),true);

return; };
}
void setHorizontalScrollbar(int value, int visible, int
min, int max) {

horizontalSB.setValues(value, visible, min, max); }

void setVerticalScrollbar(int value, int visible, int min, int max) {

verticalSB.setValues(value, visible, min, max); } int
getHorizontalValue() { return horizontalSB.getValue(); } int
getVerticalValue() { return verticalSB.getValue(); } }; class StegoFrame
extends Frame { public StegoFrame(String aString){ Super(aString); }
class EndsWithFilter implements FilenameFilter { /** A simple filename
filter class. It checks the extension. It's case-insensitive. */ private String
extension; public EndsWithFilter(String extension) { this.extension =
extension.toUpperCase(); } public EndsWithFilter() { } public boolean
accept(File dir,String name) { name = name.toUpperCase(); if
(name.endsWith(extension)) return true; else return (new File(dir,
name)).isDirectory(); } }; class StegoPanel extends Panel { StegoPanel()
{ super(); } public void paint(Graphics g) { Graphics panel_g =
getGraphics(); Dimension d = size(); g.setColor(brightColor); for (int i =
0; i< (thick/2); ++i) g.drawRect(x+i,y+i,(d.width - thick),(d.height -
thick)); g.setColor(darkColor); for (int i = 0; i< (thick/2); ++i)
g.drawRect(x+(thick/2)+i,y+(thick/2)+i,(d.width - thick),(d.height -
thick)); } class StegoCanvas extends Canvas { Image curImage = null;
public StegoCanvas() { super(); } public void setImage(Image i)
{ curImage = i; } public void paintSplashInfo(Graphics g) { Graphics
canvas_g = getGraphics(); Dimension d = size(); FontMetrics fm =
getFontMetrics(getFont()); String label = "EzStego"; int lx =
labelX(label); int ascent = fm.getAscent(); int spacing = 5; ly = ly +
ascent + spacing; label = ""; lx = labelX(label);
canvas_g.drawString(label,lx,ly); ly = ly + ascent + spacing; label = "";
lx = labelX(label); Canvas_g.drawString(label,lx,ly); } int labelX(String
lstring) //Centers the labelstring { Dimension d = size(); FontMetrics fm
= getFontMetrics(getFont()); int x = (d.width/2) -
(fm.stringWidth(lstring)/2); return x; } public void paint(Graphics g)
{ int x, y; int imageWidth, imageHeight; int top = 0, left = 0; int width =
200, height = 200; x = EzStego.app().getHorizontalValue(); y =
EzStego.app().getVerticalValue(); Dimension d = size(); if (curImage !=
null) { try {
imageHeight = curImage.getHeight(this); imageWidth =
curImage.getWidth(this); g.drawImage(curImage, -x,-y,
imageWidth,imageHeight, Color.black, this); height = this.size().height;
width = this.size().width; canvas = c; } public boolean
handleEvent(Event evt) { switch (evt.id) { case
Event.SCROLL_LINE_DOWN: scrollLineDown(); break; case
Event.SCROLL_LINE_UP: scrollLineUp(); break; case
Event.SCROLL_PAGE_DOWN: scrollPageDown(); break; case
Event.SCROLL_PAGE_UP: scrollPageUp(); break; case
Event.SCROLL_ABSOLUTE: scrollAbsolute(); break; } return false;
} protected void scrollLineUp() { canvas.repaint(); } protected void
scrollLineDown() { canvas.repaint(); } protected void scrollPageUp() {
canvas.repaint(); } protected void scrollPageDown()
{ canvas.repaint(); } protected void scrollAbsolute()
{ canvas.repaint(); } }
CHAPTER 6. TESTING

6.1 TESTING OBJECTIVES

In light of the diversity of existing software testing, it is advantageous to consider
the types of tests as they become available to a designer. This will also help identify the
scope of a particular test and clarify its main advantages and disadvantages as well as
make the developer aware about the limitations of this test.

Functional Tests are used to exercise the code with nominal inputs (input values)
for which the expected values are available. We also know the boundary conditions for
these inputs. For instance, functional testing of matrix multiplication can involve some
data (matrices) for which the results are known in advance.

Performance Tests are utilized in order to determine the widely defined

performance of the software system such as an execution time associated with various
parts of the code, response time(in case of embedded systems),and device utilization. The
intent of this type of testing is to identify weak points of a software system and
quantifying its shortcomings, leading to further improvements.

Stress Tests are designed to break a software module. This type of testing
determines the strengths and limitations of the software.
Structure Tests are aimed at exercising the internal logic of a software system.

Testing In Small-Testing In The Large. The underlying criterion concerns

which part of the system is subject to testing. If we are concerned with individual
modules, procedures, and functions, this lead to testing in the small. Testing in the large is
primarily devoted to integration testing when the system is developed out of some
already constructed modules.

Black Box-White(Glass)Box Testing. As the name suggests, the criterion leading

to this type of discrimination specifies whether the internal(logical)structure of the
system is available for testing purposes. if so,we are concerned with white box testing. If
the internal structure is not available or exercised when developing the test suite, we
confine ourselves to black box testing. Depending which way was selected, the points of
view on testing are also radically different. In black box testing we are interested to test
what the system is supposed to do. The testing is worked out from input data perspective;
subsequently we see if the outputs (actions) of the software match the expected values.
Functional, stress, and performance tests fall under this general category. In white box
testing, testing concentrates on what the system does.essentially, using detailed
knowledge of code, one creates a battery of tests in such a way that they exercise all
components of the code (say, statements, branches, paths).structural testing sub schemes
white box testing.

TEST ACTIVITIES

In software testing we encounter a number of key activities:

Test plans
Test design
Test cases
Test procedure
Test execution
Test report

A test plan indicates the scope, approach, resources and the schedule of testing
activity. At this stage, one indicates what is to be or not to be tested and which tasks to
perform. In addition, it is necessary to identify the sources and levels of risk in testing.
Software testers are also identified. Test planning may begin as soon as the requirements
are completed. The key features in a test plan are
Transitioning
Estimates
Completion
Risk analysis allocation

it is difficult to determine when to stop testing or when a reasonable number of

faults have been detected. For these reasons, criteria should be provided as a guideline for
test completion. A test design refines the approach in a test plan. Test design also
identifies specific features to be tested by the design, and define the associated test cases.
It is strongly suggested that tests should be designed for regression testing (test
previously executed can be repeated at a later point in development and maintenance).the
test cases and test procedures are constructed in a implementation phase. One should
strive for the most compact (smallest)collection of test cases (batteries) that still meet the
goal. Good test cases have a high probability of detecting undiscovered errors. A test
procedure identifies all steps required to operate the system and exercise the specified test
cases to implement the already defined test design. Test execution is the exercising of the
test procedures. Test execution starts from the component level and moves up to the
integration, system and acceptance level. a test report summarizes all outcomes of testing
and highlights the discrepancies detected. Sting activities are distributed across the entire
software life-cycle as shown in the figure
 Test plan
generatio
n
Requirements

Design Test design

Generation

Test case
Implementation Generation

Test
Test procedure
Generation

Test
execution
 6.2 PHASES OF TESTING
Testing can be divided into a number of phases as shown below:
 Program Testing
 System Testing
 User Acceptance Testing

Program Testing:
The purpose of program testing is to check out whether the program is working
accordingly to the specification given. This phase ensures that the program or modules
function ass expected. In this phase, all parts of the program are checked thoroughly

System Testing:
System testing should prove that the computer system work as intended and are
acceptable to user operations and audit. It would also show that the system would
interface correctly with other existing computer systems. The running of system test
should be under the control of operations, it can also prove that all the operations, so that
operating procedures can prove to be correct. There should be sufficient volume of data
to demonstrate that the system meets the performance constraints.

User Acceptance Testing:

User acceptance testing to be performed must be established and agreed during

analysis. It may be urn in parallel with the existing system so that users will create
special test data. The key difference between system testing and user acceptance testing
is that the user are interested in the inputs and outputs. The inputs and outputs are
verified with existing system and checked to see if it is the same.
Level of Testing:
There are two levels of testing used the package they are:
 Unit Testing
 System Testing

Unit Testing:
Unit testing focuses verification effort on the smallest unit of software design. Unit
testing is simplified when a module with high cohesion is designed. In unit testing
various programs, which comprises the system are tested separately. So unit testing is
sometimes called as “Program Testing”. This reduces the error produced by the larger
program.
The system testing is used to find the integration of each module in the system. It is
also tested to find discrepancies between the system and its original objectives, current
specification and system documentation. System testing is a series of different test
whose primary purpose is to fully exercise the computer-based system. Testing is used
to find the compatibility between the various programs units available in the system.

Testing Strategies:
Testing of the software ids done in the aim of finding errors. Test cases are devised to
bring out errors in the system. The test data are created with the intention of
determining whether the system will program will handle them appropriately. There are
two general testing strategies for testing software namely:
 Code Testing
 Specification Testing
Code Testing:
The code testing strategy examines the logic of the program. Test cases are devised
such that they result in executing every instruction in the program (i.e.) every path of
the program is tested. Specification testing handles all these problems.

Specification Testing:
Specification Testing involve stating what the program should and how it should
perform under various conditions. The test are developed for each condition or
combination of condition and submitted for processing. By examining the results we can
determine where the program performs according to its specified requirements.

Validation Testing:

Validation can be defined in many ways, but a simple definitions is that validation
succeeds when software functions in a manner that can be reasonable expected by the
customer. Software validation is achieved through a series of black box tests that
demonstrate conformity with requirements.
6.3 SCREEN SHOTS
CHAPTER 7. CONCLUSION

7.1 SUMMARY
The objective of this paper was to demonstrate our BPCS-Steganography, which is based
on a property of the human visual system. The most important point for this technique is
that humans cannot see any information in the bit-planes of a color image if it is very
complex. We have discussed the following points and showed our experiments.
(1) We can categorize the bit-planes of a natural image as informative areas and noise-
like areas by the complexity thresholding.
(2) Humans see informative information only in a very simple binary pattern.
(3) We can replace complex regions with secret information in the bit-planes of a natural
image without changing the image quality. This leads to our BPCS-Steganography.
(4) Gray coding provides a better means of identifying which regions of the higher bit
planes can be embedded.
(5) A BPCS-Steganography program can be customized for each user. Thus it guarantees
secret Internet communication. We are very convinced that this steganography is a very
strong information security technique, especially when combined with encrypted
embedded data.
.
Furthermore, it can be applied to areas other than secret communication. Future research
will include the application to vessels other than 24-bit images, identifying and
formalizing the customization parameters, and developing new applications.

Using the delegation event model

Now that you have learned the theory behind the delegation event model
and have had an over view of its various components,it is time to see it in
practice.appletprogramming using the delegation event model is actually
quite easy.just follow these two steps:
1. implement the appropriate interface in the listener so that it will receive the
type of event desired.
2. implement code to register and unregistered(if necessary)the listener as a
recipient for the event notifications.
Remember that a source may generate several types of events. each event
must be registered separately.also,an object may register to receive several
types of events, but it must implement all of the interfaces that are required to
receive these events.
To see how the delegation model works in practice,we will look at
examples that handle the two most commonly used event generators:the
mouse and keyboard.

7.2 FUTURE ENHANCEMENTS

In discussing applications of BPCS Steganography, it is instructive to note that it differs
from digital watermarking in two undamental ways. The first is that for full color (e.g.,
24-bit) images, it has a very large embedding capacity. As described previously, our
experiments with BMP images have shown capacities exceeding 50% of the original
image size. Although the results presented in this paper are for 24-bit images, we have
also been working with other formats, such as 256 color images, which utilize a palette.
Although the capacity is lower, the same concepts can be applied.
The second difference is that BPCS Steganography is not robust to even
small changes in the image. This can be viewed as a good thing in applications where an
unknowing user might acquire an embedded image. Any alteration, such as clipping,
sharpening or lossy compression, would "destroy the evidence" and make it unusable for
later extraction. Extracting the embedded information requires a deliberate attempt by a
knowledgeable user on an unaltered image. The lack of robustness also ties in to the fact
that a malicious user cannot alter the embedded data without knowledge of the
customization parameters.
The more obvious applications of BPCS Steganography relate to secret
communications. For example a person, group, or company can have a web page
containing secret information meant for another. Anyone can download the web page, so
when the intended recipient does so, it does not draw any attention. Extracting the
embedded information would require software customized with the proper parameters.
Encryption of the embedded data would further improve security. This scenario is
analogous to putting something in a very secure safe and then hiding the safe in a hard to
find place.
In some applications, the presence of the embedded data may be known,
but without the customization parameters, the data is inseparable from the image. In such
cases, the image can be viewable by regular means, but the data is tied to the image and
can't readily be replaced with other data. Others may know the data is there, but without
the customization parameters, they cannot alter it and still make it readable by the
customized software.
Applications of BPCS Steganography are not limited to those related to
secrecy. For such applications, the presence of the embedded data may be known, and the
software for extraction and embedding can be standardized to a common set of
customization parameters. An example of this is a digital photo album, where information
related to a photo, such as date and time taken, exposure parameters, and scene content,
can be embedded in the photo itself.

7.3 BIBLIOGRAPHY

1. The Complete Reference-Java Third Edition By

Patrick Naughton
Herbert Schildt

2. Unleashed JAVA 2 By
Jamie jaworski

3. Java server faces programming By

Budi kurniawan