April 28, 2019

STEGANOGRAPHY IMPLEMENTATION in java


1. INTRODUCTION

1.1 PROFILE OF THE ORGANIZATION

1.2 ABOUT THE PROJECT

Steganography and steganalysis are beginning to receive increased attention as their applications become more relevant to the needs of governments, business, and individual. As privacy concerns continue to develop along with the digital communication domain, steganography will un doubtly play a growing role in society. For this reason, it is important that we are aware of digital steganography and its implications.

Despite the lack of press given to steganography and steganalysis, these fields present interesting problems whose solutions will have profound effects on the internet and intranet communication. Steganography, as mentioned, enhances rather than replaces encryption. Messages are not secure simply by virtue of being hidden. Likewise; steganography is not about keeping the message from being known-it's about keeping its existence from being known. Although not a substitute for encryption, it provides a means of communicating privately. Of course, this is effective only if the hidden communication is not detected. Hiding data is a good solution for the safety of highly confidential data. The most private communication is the one that never existed. When files are created there are usually some bytes in the file that aren't really needed, or at least aren't that important. These areas of the file can be replaced with the information that is to be hidden, with out altering the file or damaging it. This allows a person to hide information in the file and make sure that no human could detect the change in the file.

The project contains the following modules.

1. Private Data and Encrypted data

The purpose of steganography is not to keep others from knowing the hidden information — it is to keep others from thinking that the information even exists. If a steganography method causes someone to suspect the carrier medium, then the method has failed Encryption encodes data such that an unintended recipient cannot determine its intended meaning. Steganography, in contrast, does not alter data to make it unusable to an unintended recipient. Private data is the data which is going to hide. It can be a wave file, audio data or a image file. Encrypted data is more difficult to differentiate from naturally occurring phenomena than plain text is in the carrier medium.

2. Steganography Implementation

Steganography can also enhance individual privacy. Although not a substitute for encryption, digital steganography provides a means of communicating privately. Of course, this is effective only if the hidden communication is not detected. Images are a good medium for hiding data. Both of these methods alter the image; however, we can explore image degradation using different images and messages of varying length. An alternative, specific to GIF images, is to manipulate an image’s palette in order to hide data. Steghide alters the least significant bits of data in the carrier medium. Although nearly equal in data-hiding potential the large size of meaningful audio files makes them less popular than image files as a steganographic medium

3. Decrypting  THE data

After implementing the steganographic concept, the encrypted data is decrypted into the original data at the last stage of the implementation. It is impossible to view the encrypted image because it is in the form of byte codes. Thus steganography stores information in a way that hides that information’s existence.




 
 
                                 

2. SYSTEM ANALYSIS

2.1 EXISTING SYSTEM
Steganography, in contrast, does not alter data to make it unusable to an unintended recipient. Instead, the steganographer attempts to prevent an unintended recipient from suspecting that the data is there. Hiding data is constrained by the same assumption that exists for encryption. The amount of data that can be effectively hidden in a given medium tends to be restricted by the size of the medium itself. The fewer constraints that exist on the integrity of the medium, the more potential it has for hiding data. The most common technique is to exploit the lenient constraints of popular file formats. Many publicly available software packages use this technique on a variety of media. Images are a good medium for hiding. The more detailed an image, the fewer constraints there are on how much data it can hide before it becomes suspect. Ordering data that does not have an ordering constraint is often an effective method of hiding data. Each permutation of a set of objects can be mapped to a positive integer. This mapping can then be used to encode hidden data by altering the order of objects that are not considered ordered by the carrier medium. While this technique generally does not change the information quality, hidden data can easily be lost if the medium is encoded again. The existing system is constrained by the same assumption that exists for encryption. The amount of data that can be effectively hidden in a given medium tends to be restricted by the size of the medium itself. The fewer constraints that exist on the integrity of the medium, the more potential it has for hiding data.
It is not possible to view the encrypted image because it is in the form of byte code. This is the major drawback in steganography.




2.2 Proposed System
The purpose of proposed system is not to keep others from knowing the hidden information  it is to keep others from thinking that the information even exists. If a method causes someone to suspect the carrier medium, then the method has failed. Hiding of the biometric data success thus relies heavily on the naïveté of human beings. Encryption and steganography achieve separate goals. Encryption encodes data such that an unintended recipient cannot determine its intended meaning. The project, in contrast, does not alter data to make it unusable to an unintended recipient. Instead, the developer attempts to prevent an unintended recipient from suspecting that the data is there.

Digital steganography is a good solution the most private communication is the one that never existed.  The purpose of steganography is not to keep others from knowing the hidden information it is to keep others from thinking that the information even exists. Encryption and steganography achieve separate goals. Encryption encodes data such that an unintended recipient cannot determine its intended meaning. Steganography, in contrast, does not alter data to make it unusable to an unintended recipient. Instead, the steganographer attempts to prevent an unintended recipient from suspecting that the data is there. Encryption and steganography can be combined to obtain greater security for data hiding. The image that is encrypted will be saved as byte codes or machine understandable codes, later it will be decrypted and the image will be placed in the original file.
                                                           



2.3 SCOPE OF THE PROJECT
Information hiding has become the focus of research today. Hiding data is the art of hiding information in a way that prevents the detection of hidden messages. The term hiding data means  “covered writing” and involves transmission of secret messages through apparently innocent files  without detection of the fact that message was sent. Hiding data is renewed nowadays merging with different fields like Neural Networks, Fuzzy Systems increasing a feasible security and privacy. Using hiding data techniques, Software can easily transmit private user information without user’s knowledge. It is of immense importance and it is indispensable in the fields of Digital Watermarking, Digital Fingerprinting, Internet Security, Network Security, Authentication, Copyright issues, etc.

2.4 FEASIBILITY STUDY
Every project is feasible with unlimited resources and infinite time, Feasibility study is an evaluation of the proposed system regarding its work ability, impact on the organization, ability to meet user needs and effective use of resources. Thus when a new application is proposed it normally has to go through a feasibility study, before it is approved for further development.
The development of a computer based system or product is more likely plagued by scarcity of resources and difficult in delivery dates. It is necessary and prudent to evaluate the feasibility of a project at the earliest possible time.

TECHNICAL FEASIBILITY
During my project I concentrated on the following areas very carefully according to needs of the organization. During technical analysis, the analyst evaluates the technical merits of the system concept, at the same time collects additional information about performance, reliability, maintainability and produce ability.
Technical analyses begin with an assessment of the technical viability of the proposed system. The tools available for technical analysis are derived from mathematical modeling and optimization techniques, probability and statistics, queuing theory and control theory. Modeling is an effective mechanism for technical analysis of computer based system.

OPERATIONAL FEASIBILITY
            This feasibility determines how much effort will be spent in selling and training the user staff about the proposed system. People are inheritably resistant to changes and computers have been known to facilitate changes. An estimate should be made regarding the reaction of the user likely to have towards the system.

ECONOMIC FEASIBILITY
            One of the important information contained in the feasibility study is Economic Analysis – an assessment of the economic justification for the project. Economic analysis reduces the cost for the project development and weighs them against tangible and intangible benefits of the system. Additional cost incurred in the system development, maintenance and mobilizing manpower to work for the big challenge to the organization. Especially in the present scenario where the objective is towards centralization, reduced cost of the software and hardware and cutting exponential growth of the size of the organization. Cost of the proposed system is not very high     

3. SYSTEM DESIGN AND DEVELOPMENT


3.1 OVERVIEW OF THE SYSTEM

To human eyes, data usually contains known forms, like images, e-mail, sounds, and text. Most Internet data naturally includes gratuitous headers, too. These are media exploited using new controversial logical encodings: steganography and marking. Hiding the data is the art of inconspicuously hiding data within data. The project goal in general is to hide data well enough that unintended recipients do not suspect the medium of containing hidden data..  The purpose of hiding data is not to keep others from knowing the hidden information — it is to keep others from thinking that the information even exists. If a steganography method causes someone to suspect the carrier medium, then the method has failed. Steganography’s success thus relies heavily on the naïveté of human beings; for example, when did you last check your e-mail headers for hidden messages? Encryption and steganography achieve separate goals. Encryption encodes data such that an unintended recipient cannot determine its intended meaning. Steganography, in contrast, does not alter data to make it unusable to an unintended recipient. Instead, the steganographer attempts to prevent an unintended recipient from suspecting that the data is there. Hiding data is constrained by the same assumption that exists for encryption. The amount of data that can be effectively hidden in a given medium tends to be restricted by the size of the medium itself. The fewer constraints that exist on the integrity of the medium, the more potential it has for hiding data.
There are many techniques available to the hiding data. The most common technique is to exploit the lenient constraints of popular file formats. Many publicly available software packages use this technique on a variety of media.


3.2 DESIGN OVERVIEW

3.2.1 INPUT DESIGN

Input design is the process of converting user-oriented inputs to a computer-based format. The quality of the system input determines the quality of system output. Input design determines the format and validation criteria for data entering to the system.

Inputs originate with system users; human factors play a significant role in input design. The inputs in this project are as simple as possible and design to reduce the possibility of incorrect data being entered by using validation in each and every module. Users pass input through components created using swing.
           
The input design of this project is constructed with the following principles
ü  Capture only validated data.
ü  Restricted user entry.
ü  The main objectives considered during input design are:
ü  Nature of input processing.
ü  Flexibility and thoroughness of validation rules.
ü  Handling of priorities within the input documents.
ü  Screen design to ensure accuracy and efficiency of input relationship with files.
ü  Careful design of the input also involves attention to error handling, controls, batching and validation procedures.

As the project is system oriented and we deal with security, the input is just the file to be hidden and the secret key for the algorithm which has been selected. The user should not login into the project in order to improve the security of the system. In some cases the enabling options that would affect the performance of your system can be the input. The extracting module is used to extract the hidden information from the project. The user has to give the secret key for the extracting the information from the picture file.


3.2.2 OUTPUT DESIGN
                  
Output design generally refers to the results and information that are generated by the system. For many end users, outputs are the main reason for developing the system and the basis on which they will evaluate the usefulness of the application. Most end users will noticeably operate the information system or enter data through workstation, but they will use the output from the system.
           
When designing output, system analyst must determine what information is to be presented and decide where to display, print the information and select the output medium. The data produced as output should be accurate and reliable and the output must furnish relevant data. The output should be maintained according to the users needs.

Hiding the data is done in Java, so the output is the GUI interface, which is user-friendly. The project is provided with a separate GUI tool for hiding the data and extracting the data from the project by specifying the related secret key for the algorithm which has been selected by the user. The output is generated in the text file in the encrypted format in order to provide the security for the project. The encrypted information can also be converted into the original picture files by specifying the secret key and the algorithm type.









3.3             SYSTEM FLOW DIAGRAM


4. SYSTEM ENVIRONMENMT


4.1 DEVELOPMENT ENVIRONMENT

            The development environment describes the function and performance of a computer based system and the constraints that will govern its development. The specification bounds each allocated system element. The Programming language used in this project is Java.
 
4.1 Hardware SPECIFICATIONS
           
Processor                     :          Pentium IV
Clock Speed                :          800 MHz
RAM                           :          128 MB
Floppy disk                 :          1.44 MB
Display Adapter         :          VGA display adapter.
Network Connection              :          Should be active
Hard Disk                               :          4 GB
Cache Memory           :         512 kb


4.2 Software SPECIFICATIONS

Language                    :        Java 2.0
Development Kit        :        JDK 1.4
Platform                      :        Independent
Operating System       :        Windows XP




4.3 SOFTWARE overview

The software interfaces used in this system are Java Runtime Environment (JRE) of at least version 1.1. (Most Windows systems are already has a 1.1 JRE installed, but on Linux/Unix systems this is often not in the case.
Java
Java is an Object-oriented Multithreaded programming language. It is designed to be small, simple and portable across different platforms as well as operating systems. Java became popular because of its three components. One of the components is Applet.
Features of Java

Secure
Java achieves protection by confining a Java program to the Java execution environment and by making it inaccessible to other parts of the computer. Hence Applets can be downloaded without any fear of viral infection or malicious intent.

Portable
Many types of computers and operating systems are in use throughout the world and are connected to the Internet. So, for downloading programs through different platforms connected to the Internet portable, executable code is needed. Java handles these problems efficiently through its well-defined Architecture.

Object-Oriented
Java gives a clean, usable, realistic approach to objects. The object model in Java is simple and easy to extend, while simple types, such as Integers, are kept as high performance non-objects.                                                                                                                                                                                                                                                          
Robust
Most programs used today fail for one of the two reasons: Memory management or Exceptional conditions. Thus the ability to create robust programs was given a high priority in the design of Java.  Java also handles exceptional conditions by providing object oriented exception handling.

Multithreaded
Java was designed to meet the real world requirements of creating interactive, networked programs. To achieve this, Java supports Multithreaded programming, which allows the user to write programs that performs many functions simultaneously Architecture Neutral

Interpreted and high Performance
Java enables the creation of cross-plat formed programs by compiling the code into an intermediate representation called Java byte code. This code can be interpreted on any system that has a Java Virtual Machine. Most of the earlier cross-platform solutions are run at the expense of performance. Java however was designed to perform well on very low power CPU's.

Distributed
Java is designed for the distributed environment of the Internet, because it handles TCP/IP protocols. Java includes features for Intra-address-space messaging in a package called Remote Method Invocation (RMI).
Dynamic
Java programs carry with them extensive amounts of runtime information that is used to verify and resolve accesses to objects at runtime. Using this concept it is possible to dynamically link code. Dynamic property of Java adds strength to the applet environment in which small fragments of byte code may be dynamically updated on a running system.                                                                                                  

The Swing Components
Include everything from buttons to split panes to tables. You can see mug shots of all the components in A Visual Index to the Swing Components.

Pluggable Look and Feel Support
Gives any program that uses Swing components a choice of looks and feels. For example, the same program can use either the Java TM look and feel or the Windo0ws look and feel. We expect many more look-and-feel packages -- including some that use sound instead of a visual "look" -- to become available from various sources.
Accessibility API
Enables assistive technologies such as screen readers and Braille displays to get information from the user interface.

Java 2DTM API (Java 2 Platform only)
Enables developers to easily incorporate high-quality 2D graphics, text, and images in applications and in applets.

Drag and Drop Support (Java 2 Platform only)
Provides the ability to drag and drop between a Java application and a native application.
The first three JFC features were implemented without any native code, relying only on the API defined in JDK 1.1. As a result, they could and did become available as an extension to JDK 1.1. This extension was released as JFC 1.1, which is sometimes called "the Swing release." The API in JFC 1.1 is often called "the Swing API."
"Swing" was the codename of the project that developed the new components. Although it's an unofficial name, it's frequently used to refer to the new components and related API. It's immortalized in the package names for the Swing API, which begin with javax.swing.
This trail concentrates on the Swing components. We help you choose the appropriate ones for your GUI, tell you how to use them, and give you the background information you need to use them effectively. We discuss the Pluggable look and feel and Accessibility support when they affect how you write programs that use Swing components. This trail does not cover the JFC features that appear only in the Java 2 Platform. For information about those, refer to 2D graphics and to the JFC home page.
The following snapshots show three views of a GUI that uses Swing components. Each picture shows the same program, but with a different look and feel. The program, called Converter, is discussed in detail at the end of the next lesson, Swing Features and Concepts.
Java look and feel
CDE/Motif look and feel
Converter with the Java look and feel
Converter with the CDE/Motif look and feel
Windows look and feel
Converter with the Windows look and feel

What Swing Packages Should I Use?

The Swing API is powerful, flexible -- and immense. For example, the 1.1 version of the API has 15 public packages: javax.accessibility, javax.swing, javax.swing.border, javax.swing.colorchooser, javax.swing.event, javax.swing.filechooser, javax.swing.plaf, javax.swing.plaf.basic, javax.swing.plaf.metal, javax.swing.plaf.multi, javax.swing.table, javax.swing.text, javax.swing.text.html, javax.swing.tree, and javax.swing.undo.
Fortunately, most programs use only a small subset of the API. This trail sorts out the API for you, giving you examples of common code and pointing you to methods and classes you're likely to need. Most of the code in this trail uses only one or two Swing packages:
·         javax.swing
·         javax.swing.event (not always required)

How Are Swing Components Different from AWT Components?

If you don't care about the AWT components, skip to the next section. You can get a more general introduction to the Swing components from A Quick Tour of a Swing Application's Code and from the Swing Features and Concepts lesson.
The AWT components are those provided by the JDK 1.0 and 1.1 platforms. Although the Java 2 Platform still supports the AWT components, we strongly encourage you to use Swing components instead. You can identify Swing components because their names start with J. The AWT button class, for example, is named Button, while the Swing button class is named JButton. Additionally, the AWT components are in the java.awt package, while the Swing components are in the javax.swing package.
The biggest difference between the AWT components and Swing components is that the Swing components are implemented with absolutely no native code. Since Swing components aren't restricted to the least common denominator -- the features that are present on every platform -- they can have more functionality than AWT components. Because the Swing components have no native code, they can be shipped as an add-on to JDK 1.1, in addition to being part of the Java 2 Platform.
Even the simplest Swing components have capabilities far beyond what the AWT components offer:
·         Swing buttons and labels can display images instead of, or in addition to, text.
·         You can easily add or change the borders drawn around most Swing components. For example, it's easy to put a box around the outside of a container or label.
·         You can easily change the behavior or appearance of a Swing component by either invoking methods on it or creating a subclass of it.
·         Swing components don't have to be rectangular. Buttons, for example, can be round.
·         Assistive technologies such as screen readers can easily get information from Swing components. For example, a tool can easily get the text that's displayed on a button or label.
Swing lets you specify which look and feel your program's GUI uses. By contrast, AWT components always have the look and feel of the native platform.
Another interesting feature is that Swing components with state use models to keep the state. A JSlider, for instance, uses a BoundedRangeModel object to hold its current value and range of legal values. Models are set up automatically, so you don't have to deal with them unless you want to take advantage of the power they can give you.
If you're used to using AWT components, you need to be aware of a few gotchas when using Swing components:
·         Programs should not, as a rule, use "heavyweight" components alongside Swing components. Heavyweight components include all the ready-to-use AWT components (such as Menu and ScrollPane) and all components that inherit from the AWT Canvas and Panel classes. This restriction exists because when Swing components (and all other "lightweight" components) overlap with heavyweight components, the heavyweight component is always painted on top. For more information, see Mixing Heavy and Light Components, an article in The Swing Connection.
·         Swing components aren't threading safe. If you modify a visible Swing component -- invoking its setText method, for example -- from anywhere but an event handler, then you need to take special steps to make the modification execute on the event-dispatching thread. This isn't an issue for many Swing programs, since component-modifying code is typically in event handlers.
·         The containment hierarchy for any window or applet that contains Swing components must have a Swing top-level container at the root of the hierarchy. For example, a main window should be implemented as a JFrame instance rather than as a Frame instance.
·         You don't add components directly to a top-level container such as a JFrame. Instead, you add components to a container (called the content pane) that is itself contained by the JFrame.
Converting to Swing tells you more about the differences between Swing components and AWT components.

SWING FEATURES AND CONCEPTS
            The features and concepts of swing are
  • Components and Containment Hierarchies
  • Layout Management
  • Event Handling
  • Painting
  • Threads and Swing
  • More Swing Features and Concepts

Swing Components and the Containment Hierarchy

Swing provides many standard GUI components such as buttons, lists, menus, and text areas, which you combine to create your program's GUI. It also includes containers such as windows and tool bars.

Layout Management

Containers use layout managers to determine the size and position of the components they contain. Borders affect the layout of Swing GUIs by making Swing components larger. You can also use invisible components to affect layout.

Event Handling

Event handling is how programs respond to external events, such as the user pressing a mouse button. Swing programs perform all their painting and event handling in the event-dispatching thread.

Painting

Painting means drawing the component on-screen. Although it's easy to customize a component's painting, most programs don't do anything more complicated than customizing a component's border.

Threads and Swing

If you do something to a visible component that might depend on or affect its state, then you need to do it from the event-dispatching thread. This isn't an issue for many simple programs, which generally refer to components only in event-handling code. However, other programs need to use the invokeLater method to execute component-related calls in the event-dispatching thread.

More Swing Features and Concepts

Swing offers many features, many of which rely on support provided by the JComponent class. Some of the interesting features this lesson hasn't discussed yet include support for icons, actions, Pluggable Look & Feel technology, assistive technologies, and separate models.

             Swing is a GUI component kit for building user interfaces and handling end user input.
JButton:
                 JButton is a push button that is a replacement for java.awt.Button. Instances of JButton, like Swing labels, can display text, an icon, or both.
                 Like AWT buttons, Swing button fire action events when they are activated. An action listener can register with a button, and the listener’s actionPerformed method will be invoked whenever the button is activated.

JLabel:
                 Swing labels can be used for many purposes. For example, in addition to serving as a component that can display an icon, labels are also typically used as cell renderers for Swing tables.

JTextField:
                 The JTextField component displays a single line of editable text, using a single font and a single color. Horizontal alignment either LEFT, CENTER, or RIGHT can be specified for a text field’s text. By default, pressing the Enter key (KeyEvent.VK_ENTER) while a text field has focus causes the field to fire action event. The JTextField class is nearly source compatible with the java.awt.TextField class.

JTextArea:
                 Swing text areas, represented by the JTextArea class, can display multiple lines of plain text, which is defined as text with one font and one color. Text areas can wrap lines, either on character or word boundaries. The JTextArea class is nearly source compatible with the java.awt.TextArea class.

Flow Layout:
A flow layout arranges components in a left-to-right flow, much like lines of  text in a paragraph. Each line is centered.

Grid Layout:
The Grid Layout object is a layout manager that lays out a container's components in a rectangular grid. The container is divided into equal-sized rectangles, a and one component is placed in each rectangle.

Border Layout:
A border layout lays out a container, arranging and resizing its components to fit in five regions: north, south, east, west, and center. Each region may contain no more than one component, and is identified by a corresponding constant: NORTH, SOUTH, EAST, WEST, and CENTER.

Null Layout:
A null layout arranges components in a user-defined position.

5. SYSTEM TESTING
5.1 WHY TESTING
GENERIC TEST CONDITIONS
CONDITIONS TO BE TESTED
EXPECTED RESULTS
1) Click on all links
System display appropriate screen. No error message saying ‘not found’ is given
2) Use of empty values in mandatory fields
Display error: Entry missing
3) Use of wrong data type values
Display error: Enter numeric or alpha according to the entry

SECURITY CHECKS
CONDITIONS TO BE TESTED
EXPECTED RESULTS
1) Provide wrong file name not present in test folder
Display error ‘No such file exist’
2) Provide wrong path of the file to be tested
Display error ‘No such file exist’

The testing phase involves the testing of the developed system using various test data. After preparing the test data the system under study is tested using those test data. While testing the system by using test data, errors were found are corrected. Thus a series of tests were performed for the proposed system before the system was ready for implementation. The various types of testing done on the system are.
5.2 TYPES OF TESTING

5.2.1 UNIT TESTING
Unit testing focuses verification effort on the smallest limit of software design. Using the unit test plan prepared in the design phase of the system, important control paths are tested to uncover the errors within the module. This testing was carried out during the coding itself. In this testing each module is going to be working satisfactorily as the expected output from the module.
Eg: After pressing start button testing is carried out to check whether the image is going to hide or extract.

5.2.2 INTEGRATION TESTING
Integration testing is the systematic technique for constructing the program structure while at the same time conducting test to uncover errors associated with the interface. The objective is to take tested modules and build the program structure that has been dictated by design. All modules are combined in this testing step. Then the entire program is tested as a whole. If a set of errors is encountered correction is difficult because the isolation of causes is complicated by vastness of the entire program. Using integrated test plans prepared in the design phase of the system developed as a guide, the integration was carried out. All the errors found in the system were corrected for the next testing steps.
Eg: Testing is carried out to check the entered encryption key is an eight digit alphanumeric number or not. If so, the encryption process will execute. Otherwise the system shows some error message.

5.2.3 VALIDATION TESTING
At the end of the integration testing, software is completely assembled as a package, interfacing errors have been uncovered and corrected and final series of software validation testing begins. Validation testing can be defined in many ways, but a simple definition is that validation succeeds then the software functions in a manner that can be reasonably accepted by the user. Software validation is achieved through a series of black box tests that demonstrate conformity the requirements.
After validation test has been completed, one of the following two possible conditions exists:
1.      The function or performance characteristics confirm to specification and are accepted.
2.      A deviation from specification is uncovered and a deficiency list is created. Deviation or errors discovered at this step in this project is corrected prior to the completion of the project is the help of users by negotiating to establish a method of resolving deficiencies.
Thus, the proposed system under consideration has been tested by using validation testing and found to be working satisfactory.
Eg: The encryption key should be an eight digit alphanumeric number. If it is not, the system displays error message.

5.2.4 OUTPUT TESTING
After performing the validation testing the next step is to perform the output testing of the proposed system. Since no system could be useful if it does not produce the required output in the specified format. The output generated are displayed by the system under consideration. They are tested by comparing with the format required by the user. Here the output format is considered in two ways. One is on screen and other is printed format. The output format on the screen is found to be correct as the system design phase according to the user needs for the hard copy also, the output comes out as a specified requirement by the user hence, the output testing does not result in any correction in the system.
Eg: The output should display as a test file which contains byte codes of the specified image.

5.2.5 USER ACCEPTANCE TESTING
User acceptance of a system is a key factor to the success of any system. The system under consideration was tested for user acceptance by constantly keeping in touch with the prospective system user at the time of developing and making changes wherever required. This is done with regard to the following point
Ø  Input screen design and output screen design
Ø  Event driven system
Ø  Format of the reports and other output
Eg: During the decryption process the secret key entering should be same as that entered in the encryption process. Otherwise the system will not accept.

6. IMPLEMENTATION AND MAINTENANCE

6.1 IMPLEMENTATION

Implementation is the process of having the system personal checks out and put flew equipment to use, train the users to use the new system and construct any file that are needed to take it.
            The final and important phase in the system life cycle is the implementation of the new system. The file conversion is the most time consuming and expensive activity in the implementation stage. System implementation refers to the step necessary to install a new system input into operation. The implementation has different meaning, ranging from the conversion of a basic application to complete replacement of computer system. Implementation includes all those activities that take place to convert from old system to new. The new system may be totally new placing an existing module or automated system or it may be major modification to an existing system. The method of implementation and time scale to be adopted is found out initially. The system is tested properly and at the same time the users are trained in the new procedure. Proper implementation is essential to provide a reliable system to meet organization requirements. Successful implementation may not guarantee improvement in the organization using the new system, but it will prevent improper installation. The implementation involves the following things

ü  Careful planning
ü  Investigation of the system and constraints
ü  Design the methods to achieve the change over
ü  Training the staff in the changed place







6.2 MAINTENANCE

The final and important phase in the system life cycle is the maintenance of the new system. System maintenance refers to the step necessary to install a new system to put into operation. The new system may be totally new replacing an existing manual or automated system or it may be major modification to an existing system. The method of maintenance and time scale to be adopted found out initially. The system is tested properly and at the same time the users are trained in the same procedure. Proper maintenance is essential to provide a reliable system to meet organization requirements. The major part of the maintenance of the system is played the user who uses the software frequently. Successful maintenance may not guarantee improvement in the organization, but it prevents improper errors. Thus it can be considered as the most crucial stage in achieving a successful new system and in giving the user confidence that the new system will work and be effective.






                                                           






 
 

7. CONCLUSION

Hiding data is a really interesting subject and outside of the mainstream cryptography and system administration that most of us deal with day after day. Hiding data has its place in security. It is not intended to replace cryptography but supplement it. Hiding a message with some methods reduces the chance of a message being detected. However, if that message is also encrypted, if discovered, it must also be cracked. Modern hiding methods will be replaced with more complicated and secure methods using more robust cover Medias and they will be harder to detect. But with anything secure there are always people out there willing to sit down and run attacks on them and figure out how to defeat the methods and find the hidden data.

 
 
 
 
 
 
 



 


8. FUTURE SCOPE OF THE PROJECT

In this existing project, the hiding data’s seem to have an upper hand over cryptanalysts. Current hiding standards appear nearly unbreakable (unless the programmers know the secret key to break the hidden information).  In the future, the project can be enhanced to a new technology called Quantum Computing, where all currently used hiding process may become instantly outdated. The existing system uses any information like data, picture, audio and video files for the purpose of hiding. But in the Quantum computing, the photons are used for the transmitting the information in the secured manner. A quantum computer would deal with quantum bits (qubits) that can simultaneously represent both 0 and 1 by simultaneously spinning in different directions. In essence, quantum computers can compute faster because they can accept as inputs not one number but many different numbers and subsequently perform a computation on all of these numbers simultaneously. This can be viewed as a massive parallel computation, but instead of having many processors working in parallel we have only one quantum processor performing all computations at once. Some natural applications for a quantum computer would include factoring very big integers (necessary to crack the RCA algorithm), as well as searching lists at an incredibly high speed (necessary to crack the DES algorithm).







9. BIBLIOGRAPHY

BOOKS REFERED
  1. The Complete Reference JAVA Herbert Schildt 5th edition
  2. Software Engineering a Practitioners Approach Roger.S.Pressman  5th edition, MCGraw Hill
  3. Modern System Analysis and Design 3rd edition    Pearson's education    Jeffrey.A.Hoffer, Joey.F.george, Joseph.S.Valacich

WEBSITE VISITED
  1. http://nif.www.media.mit.edu/DataHiding/
  2. http://www.cl.cam.ac.uk/~fapp2/steganography/
  3. http://www.jjtc.com/Steganalysis/
  4. http://www.jjtc.com/Steganography/
  5. http://steganography.tripod.com/stego.html
  6. http://www.watermarkingworld.org/ml.html









10. APPENDIX

10.1 SAMPLE SCREENS









HIDING BIOMETRIC DATA (STEGANOGRAPHY)














SELECT THE ENCRYPTION SCHEME





Enter Encryption Key And Select The File For Encryption













ENCRYPTION PROCESS BEING EXECUTED





















HIDING THE ENCRYPTED IMAGE




















EXTRACTING THE IMAGE















ENTER DECRYPTION KEY





EXTRACTION PROCESS COMPLETE















HIDING DATA USING TRIPLE DES ALGORITHM












10.2 SAMPLE CODING

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class mainframe1 extends JFrame implements ActionListener{
    JButton button_1;
    JLabel label_1;
    JLabel label_2;
    JLabel label_3;
    JLabel label_4;
    JButton button_2;
    JButton button_3;
    JButton button_4;

    public mainframe1() {
        mainframe1Layout customLayout = new mainframe1Layout();

        getContentPane().setFont(new Font("Helvetica", Font.PLAIN, 12));
        getContentPane().setLayout(customLayout);

        button_1 = new JButton("OK");
        getContentPane().add(button_1);

        label_1 = new JLabel("HIDING BIOMETRIC DATA");
        getContentPane().add(label_1);

        label_2 = new JLabel("SLECT : HIDE or EXTRACT DATA");
        getContentPane().add(label_2);

        label_3 = new JLabel("HIDE DATA");
        getContentPane().add(label_3);

        label_4 = new JLabel("EXTRACT DATA");
        getContentPane().add(label_4);

        button_2 = new JButton("OK");
        getContentPane().add(button_2);

        button_3 = new JButton("<< BACK");
        getContentPane().add(button_3);

        button_4 = new JButton("CANCEL");
        getContentPane().add(button_4);

        setSize(getPreferredSize());

                        button_1.addActionListener(this);
                        button_2.addActionListener(this);
                        button_3.addActionListener(this);
                        button_4.addActionListener(this);

        addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
    }


            public void actionPerformed(ActionEvent e)
            {
                        if (e.getSource()==button_1) // ok hide
                        {
                                    setVisible(false);
                                    Gui1_1_1 f2=new Gui1_1_1();
                                    f2.setTitle("DataSecure");
                                    f2.pack();
                                    f2.show();
            }
                        if (e.getSource()==button_2) // ok extract
                        {
                                    setVisible(false);
                                    Gui1_0_0 win4 = new Gui1_0_0();
                    win4.setTitle("DataSecure");
                            win4.pack();
                                    win4.show();
                        }
                        if (e.getSource()==button_3) // back
                        {
                                    setVisible(false);
                                    MainGui1 win2 = new MainGui1();
                    win2.setTitle("DataSecure");
                            win2.pack();
                                    win2.show();
            }
                        if (e.getSource()==button_4) //cancel
                        {
                                    System.exit(1);
                        }

            }
           
            public static void main(String args[]) {
        mainframe1 window = new mainframe1();

        window.setTitle("DataSecure");
        window.pack();
        window.show();
    }
}

class mainframe1Layout implements LayoutManager {

    public mainframe1Layout() {
    }

    public void addLayoutComponent(String name, Component comp) {
    }

    public void removeLayoutComponent(Component comp) {
    }

    public Dimension preferredLayoutSize(Container parent) {
        Dimension dim = new Dimension(0, 0);

        Insets insets = parent.getInsets();
        dim.width = 495 + insets.left + insets.right;
        dim.height = 370 + insets.top + insets.bottom;

        return dim;
    }

    public Dimension minimumLayoutSize(Container parent) {
        Dimension dim = new Dimension(0, 0);
        return dim;
    }

    public void layoutContainer(Container parent) {
        Insets insets = parent.getInsets();

        Component c;
        c = parent.getComponent(0);
        if (c.isVisible()) {c.setBounds(insets.left+288,insets.top+184,72,24);}
        c = parent.getComponent(1);
        if (c.isVisible()) {c.setBounds(insets.left+16,insets.top+8,480,32);}
        c = parent.getComponent(2);
        if (c.isVisible()) {c.setBounds(insets.left+168,insets.top+96,288,32);}
        c = parent.getComponent(3);
        if (c.isVisible()) {c.setBounds(insets.left+136,insets.top+184,120,24);}
        c = parent.getComponent(4);
        if (c.isVisible()) {c.setBounds(insets.left+136,insets.top+232,120,24);}
        c = parent.getComponent(5);
        if (c.isVisible()) {c.setBounds(insets.left+288,insets.top+232,72,24);}
        c = parent.getComponent(6);
        if (c.isVisible()) {c.setBounds(insets.left+24,insets.top+320,88,24);}
        c = parent.getComponent(7);
        if (c.isVisible()) {c.setBounds(insets.left+376,insets.top+320,88,24);}
    }
}


This is the hide section , here we select the encryption scheme

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Gui1_1_1 extends JFrame implements ActionListener {
    JLabel label_1;
    JLabel label_2;
    JLabel label_3;
    JButton button_1;
    JLabel label_4;
    JButton button_2;
    JButton button_3;
    JButton button_4;

    public Gui1_1_1() {
        Gui1_1_1Layout customLayout = new Gui1_1_1Layout();

        getContentPane().setFont(new Font("Helvetica", Font.PLAIN, 12));
        getContentPane().setLayout(customLayout);

        label_1 = new JLabel("HIDING BIOMETRIC DATA");
        getContentPane().add(label_1);

        label_2 = new JLabel("Select the Encryption Scheme:");
        getContentPane().add(label_2);

        label_3 = new JLabel("DES");
        getContentPane().add(label_3);

        button_1 = new JButton("Ok");
        getContentPane().add(button_1);

        label_4 = new JLabel("Triple DES");
        getContentPane().add(label_4);

        button_2 = new JButton("Ok");
        getContentPane().add(button_2);

        button_3 = new JButton("<< Back");
        getContentPane().add(button_3);

        button_4 = new JButton("Cancel");
        getContentPane().add(button_4);

        setSize(getPreferredSize());

                        button_4.addActionListener(this);
                        button_3.addActionListener(this);
                        button_2.addActionListener(this);
                        button_1.addActionListener(this);

        addWindowListener(new WindowAdapter() {

            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
    }
           
            public void actionPerformed(ActionEvent e)
            {
                        if(e.getSource()==button_4) // Cancel clicked
                        {
                                    System.exit(1);
                        }
                        if (e.getSource()==button_3) // << Back clicked
                        {
                                    setVisible(false);
                                    mainframe1 mf=new mainframe1();
                                    mf.setTitle("DataSecure");
                                    mf.pack();
                                    mf.show();
                        }
                        if (e.getSource()==button_2) // Triple DES clicked
                        {
                                    setVisible(false);
                                    Gui1_1_3_0 b=new Gui1_1_3_0();
                                    b.setTitle("DataSecure");
                                    b.pack();
                                    b.show();
                        }
                        if (e.getSource()==button_1) // DES clicked
                        {
                                   
                                    setVisible(false);
                                    Gui1_1_2 a=new Gui1_1_2();
                                    a.setTitle("DataSecure");
                                    a.pack();
                                    a.show();
                        }
            }

    public static void main(String args[]) {
        Gui1_1_1 window = new Gui1_1_1();

        window.setTitle("Gui1_1_1");
        window.pack();
        window.show();
    }
}

class Gui1_1_1Layout implements LayoutManager {

    public Gui1_1_1Layout() {
    }
    public void addLayoutComponent(String name, Component comp) {
    }
    public void removeLayoutComponent(Component comp) {
    }
    public Dimension preferredLayoutSize(Container parent) {
        Dimension dim = new Dimension(0, 0);

        Insets insets = parent.getInsets();
        dim.width = 432 + insets.left + insets.right;
        dim.height = 353 + insets.top + insets.bottom;
        return dim;
    }
    public Dimension minimumLayoutSize(Container parent) {
        Dimension dim = new Dimension(0, 0);
        return dim;
    }
    public void layoutContainer(Container parent) {
        Insets insets = parent.getInsets();
        Component c;
        c = parent.getComponent(0);
        if (c.isVisible()) {c.setBounds(insets.left+16,insets.top+16,392,32);}
        c = parent.getComponent(1);
        if (c.isVisible()) {c.setBounds(insets.left+136,insets.top+96,224,32);}
        c = parent.getComponent(2);
        if (c.isVisible()) {c.setBounds(insets.left+104,insets.top+160,96,24);}
        c = parent.getComponent(3);
        if (c.isVisible()) {c.setBounds(insets.left+208,insets.top+160,72,24);}
        c = parent.getComponent(4);
        if (c.isVisible()) {c.setBounds(insets.left+104,insets.top+200,96,24);}
        c = parent.getComponent(5);
        if (c.isVisible()) {c.setBounds(insets.left+208,insets.top+200,72,24);}
        c = parent.getComponent(6);
        if (c.isVisible()) {c.setBounds(insets.left+32,insets.top+296,88,24);}
        c = parent.getComponent(7);
        if (c.isVisible()) {c.setBounds(insets.left+312,insets.top+296,88,24);}
    }
}



No comments:

Post a Comment

Your feedback may help others !!!

Facebook comments