Text Hiding System
Text Hiding System
Abstract
Steganography in the modern day sense of the word usually refers to information or a file
that has been concealed inside a digital Picture, Video or Audio file. What Steganography
essentially does is exploit human perception, human senses are not trained to look for files that
have information hidden inside of them, although there are programs available that can do what
is called Steganalysis (Detecting use of Steganography.)
The most common use of Steganography is to hide a file inside another file. When
information or a file is hidden inside a carrier file, the data is usually encrypted with a password.
Existing System
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, without significantly altering the file or damaging it.
Injection is quite a simple method which simply involves directly injecting the secret
information into the carrier file. The main problem with this method is that it can
significantly increase the size of the carrier file.
In cryptography, the individuals perceive the information by considering the implied
information but they will not be able to realize the information.
Steganography become more important as more people join the cyberspace revolution.
Military communications system make increasing use of traffic security technique which,
rather than merely concealing the content of a message using encryption, seek to conceal
its sender, its receiver or its very existence.
Disadvantages:
It can significantly increase the size of the carrier file.
Existing system will not be able to realize the information.
The file can be replaced with the information that is to be hidden, without
significantly altering the file or damaging it.
Proposed System
The main aim of steganography is to hide information in the other wrap media so that
other persons will not observe the existence of the information.
When hiding information inside Audio files the technique usually used is low bit
encoding which is some what similar to LSB that is generally used in Images.
When only a small amount of information is hidden inside of video it generally isn’t
noticeable at all, however the more information that is hidden the more noticeable it will
become.
Advantages:
The advantage of using video files in hiding information is to be added security
against hacker attacks due to the relative complexity of video compared to image
files and audio files.
Other persons will not observe the existence of the information.
SYSTEM REQUIREMENTS
SOFTWARE REQUIREMENTS
HARDWARE REQUIREMENTS
• SYSTEM : PENTIUM IV
• HARD DISK : 40 GB
• RAM : 512 MB
• MONITOR : 17”MONITOR
Modules:
File upload
Attach with text file
Searching
Key generation
FILE UPLOAD:
In this process the file is uploaded to server and key server respectively. There are n
numbers of file uploaded to server and a key server. The upload file is stored in different storage
server which is randomly chosen by the user.
When the user is uploading the file, text file also attached with the original file. So, the
user file is secured in the database and can’t access another user easily.
SEARCHING:
When the user is need some file in the database, the user is searching from the database and
Retrieve the file from database.
KEY GENERATION:
When the user is extract the file from database, the user is gives the key. The key is randomly
generated.
Architecture Diagram:
Data Flow Diagram:
Use Case diagram:
Login
select audio
set key
send
Extract
Sequence Diagram:
login select Audio Select text to Hide the Data Set key receiver Extact
hide
select
hide
Encrypt
send
extract
Class Diagram:
Activity Diagram:
login
select audio
select data
Send
Extract
INTRODUCTION:
Steganography is an art of sending hidden data or secret Messages over a public channel so that
a third party cannot detect the presence of the secret messages. The goal of steganography is
different from classical encryption, which Seeks to conceal the content of secret messages;
steganography is about hiding the very existence of the secret messages. Modern steganography
is generally understood to deal with electronic media rather than physical objects. There have
been numerous proposals for protocols to hide data in channels containing pictures video [3, 4],
audio and even typeset text. This makes sense for a number of reasons. First of all, because the
size of the information is generally quite small compared to the size of the data in which it must
be hidden (the cover text), electronic media is much easier to manipulate in order to hide data
and extract messages. Secondly, extraction itself can be automated when the data is electronic,
since computers can efficiently manipulate the data and execute the algorithms necessary to
retrieve the messages. Electronic data also often includes redundant, unnecessary and unnoticed
data spaces which can be manipulated in order to hide messages. The main goal of this paper was
to find a way so that an audio file can be used as a host media to hide textual message without
affecting the file structure and content of the audio file. Because degradation in the perceptual
quality of the cover object may leads to a noticeable change in the cover object which may leads
to the failure of objective of steganography.
LANGUAGE SPECIFICATION:
There are different types of application, such as Windows-based applications and Web-
based applications.
The common language runtime is the foundation of the .NET Framework. It manages
code at execution time, providing important services such as memory management, thread
management, and remoting and also ensures more security and robustness. The concept of code
management is a fundamental principle of the runtime. Code that targets the runtime is known as
managed code, while code that does not target the runtime is known as unmanaged code.
The .NET Framework can be hosted by unmanaged components that load the common
language runtime into their processes and initiate the execution of managed code, thereby
creating a software environment that can exploit both managed and unmanaged features. The
.NET Framework not only provides several runtime hosts, but also supports the development of
third-party runtime hosts.
Internet Explorer is an example of an unmanaged application that hosts the runtime (in
the form of a MIME type extension). Using Internet Explorer to host the runtime to enables
embeds managed components or Windows Forms controls in HTML documents.
The common language runtime manages memory; thread execution, code execution, code
safety verification, compilation, and other system services these are all run on CLR.
Security.
Robustness.
Productivity.
Performance.
SECURITY:
The runtime enforces code access security. The security features of the runtime thus
enable legitimate Internet-deployed software to be exceptionally feature rich. With regards to
security, managed components are awarded varying degrees of trust, depending on a number of
factors that include their origin to perform file-access operations, registry-access operations, or
other sensitive functions.
ROBUSTNESS:
The runtime also enforces code robustness by implementing a strict type- and code-
verification infrastructure called the common type system (CTS). The CTS ensures that all
managed code is self-describing. The managed environment of the runtime eliminates many
common software issues.
PRODUCTIVITY:
The runtime also accelerates developer productivity. For example, programmers can
write applications in their development language of choice, yet take full advantage of the
runtime, the class library, and components written in other languages by other developers.
PERFORMANCE:
FEATURES OF ASP.NET
ASP.NET
ASP.NET is the next version of Active Server Pages (ASP); it is a unified Web
development platform that provides the services necessary for developers to build enterprise-
class Web applications. While ASP.NET is largely syntax compatible, it also provides a new
programming model and infrastructure for more secure, scalable, and stable applications.
ASP.NET has been designed to work seamlessly with WYSIWYG HTML editors and
other programming tools, including Microsoft Visual Studio .NET. Not only does this make Web
development easier, but it also provides all the benefits that these tools have to offer, including a
GUI that developers can use to drop server controls onto a Web page and fully integrated
debugging support. Developers can choose from the following two features when creating an
ASP.NET application. Web Forms and Web services, or combine these in any way they see fit.
Each is supported by the same infrastructure that allows you to use authentication schemes,
cache frequently used data, or customize your application's configuration, to name only a few
possibilities. Web Forms allows us to build powerful forms-based Web pages. When building
these pages, we can use ASP.NET server controls to create common UI elements, and program
them for common tasks. These controls allow we to rapidly build a Web Form out of reusable
built-in or custom components, simplifying the code of a page.
An XML Web service provides the means to access server functionality remotely. Using
Web services, businesses can expose programmatic interfaces to their data or business logic,
which in turn can be obtained and manipulated by client and server applications. XML Web
services enable the exchange of data in client-server or server-server scenarios, using standards
like HTTP and XML messaging to move data across firewalls. XML Web services are not tied to
a particular component technology or object-calling convention.
As a result, programs written in any language, using any component model, and running
on any operating system can access XML Web services
Each of these models can take full advantage of all ASP.NET features, as well as the
power of the .NET Framework and .NET Framework common language runtime. Accessing
databases from ASP.NET applications is an often-used technique for displaying data to Web site
visitors. ASP.NET makes it easier than ever to access databases for this purpose. It also allows
us to manage the database from your code .
ASP.NET provides a simple model that enables Web developers to write logic that runs
at the application level. Developers can write this code in the global.aspx text file or in a
compiled class deployed as an assembly. This logic can include application-level events, but
developers can easily extend this model to suit the needs of their Web application.
ASP.NET provides easy-to-use application and session-state facilities that are familiar to
ASP developers and are readily compatible with all other .NET Framework APIs.ASP.NET
offers the IHttpHandler and IHttpModule interfaces. Implementing the IHttpHandler interface
gives you a means of interacting with the low-level request and response services of the IIS Web
server and provides functionality much like ISAPI extensions, but with a simpler programming
model. Implementing the IHttpModule interface allows you to include custom events that
participate in every request made to your application.
ASP.NET provides extensive caching services (both built-in services and caching APIs).
ASP.NET also ships with performance counters that developers and system administrators can
monitor to test new applications and gather metrics on existing applications.
Writing custom debug statements to your Web page can help immensely in
troubleshooting your application's code. However, it can cause embarrassment if it is not
removed. The problem is that removing the debug statements from your pages when your
application is ready to be ported to a production server can require significant effort.
ASP.NET offers the Trace Context class, which allows us to write custom debug
statements to our pages as we develop them. They appear only when you have enabled tracing
for a page or entire application. Enabling tracing also appends details about a request to the page,
or, if you so specify, to a custom trace viewer that is stored in the root directory of your
application. The .NET Framework and ASP.NET provide default authorization and
authentication schemes for Web applications. we can easily remove, add to, or replace these
schemes, depending upon the needs of our application .
ASP.NET configuration settings are stored in XML-based files, which are human
readable and writable. Each of our applications can have a distinct configuration file and we can
extend the configuration scheme to suit our requirements.
DATA ACCESS WITH ADO.NET:
As you develop applications using ADO.NET, you will have different requirements for
working with data. You might never need to directly edit an XML file containing data - but it is
very useful to understand the data architecture in ADO.NET.
Interoperability
Maintainability
Programmability
Performance Scalab
INTEROPERABILITY:
ADO.NET applications can take advantage of the flexibility and broad acceptance of
XML. Because XML is the format for transmitting datasets across the network, any component
that can read the XML format can process data. The receiving component need not be an
ADO.NET component.
The transmitting component can simply transmit the dataset to its destination without
regard to how the receiving component is implemented. The destination component might be a
Visual Studio application or any other application implemented with any tool whatsoever.
The only requirement is that the receiving component be able to read XML. SO, XML was
designed with exactly this kind of interoperability in mind.
MAINTAINABILITY:
In the life of a deployed system, modest changes are possible, but substantial,
Architectural changes are rarely attempted because they are so difficult. As the performance load
on a deployed application server grows, system resources can become scarce and response time
or throughput can suffer. Faced with this problem, software architects can choose to divide the
server's business-logic processing and user-interface processing onto separate tiers on separate
machines. In effect, the application server tier is replaced with two tiers, alleviating the shortage
of system resources. If the original application is implemented in ADO.NET using datasets, this
transformation is made easier.
PERFORMANCE:
ADO.NET datasets offer performance advantages over ADO disconnected record sets. In
ADO.NET data-type conversion is not necessary.
SCALABILITY:
Visual Studio .NET is a complete set of development tools for building ASP Web
applications, XML Web services, desktop applications, and mobile applications In addition to
building high-performing desktop applications, you can use Visual Studio's powerful
component-based development tools and other technologies to simplify team-based design,
development, and deployment of Enterprise solutions. Visual Basic .NET, Visual C++ .NET, and
Visual C# .NET all use the same integrated development environment (IDE), which allows them
to share tools and facilitates in the creation of mixed-language solutions.
In addition, these languages leverage the functionality of the .NET Framework and
simplify the development of ASP Web applications and XML Web services.
Visual Studio supports the .NET Framework, which provides a common language
runtime and unified programming classes; ASP.NET uses these components to create ASP Web
applications and XML Web services. Also it includes MSDN Library, which contains all the
documentation for these development tools.
The OLAP Services feature available in SQL Server version 7.0 is now called SQL
Server 2005 Analysis Services. The term OLAP Services has been replaced with the term
Analysis Services. Analysis Services also includes a new data mining component. The
Repository component available in SQL Server version 7.0 is now called Microsoft SQL Server
2005 Meta Data Services. References to the component now use the term Meta Data Services.
The term repository is used only in reference to the repository engine within Meta Data Services
SQL-SERVER database consist of six type of objects,
They are,
TABLE
QUERY
FORM
REPORT
MACRO
TABLE:
VIEWS OF TABLE:
Design View
Datasheet View
Design View
To build or modify the structure of a table we work in the table design view. We can
specify what kind of data will be hold.
Datasheet View
To add, edit or analyses the data itself we work in tables datasheet view mode.
QUERY:
A query is a question that has to be asked the data. Access gathers data that answers the
question from one or more table. The data that make up the answer is either dynaset (if you edit
it) or a snapshot(it cannot be edited).Each time we run query, we get latest information in the
dynaset.Access either displays the dynaset or snapshot for us to view or perform an action on it
,such as deleting or updating.
FORMS:
A form is used to view and edit information in the database record by record .A form
displays only the information we want to see in the way we want to see it. Forms use the familiar
controls such as textboxes and checkboxes. This makes viewing and entering data easy.
Views of Form:
We can work with forms in several primarily there are two views:
Design View
Form View
Design View:
To build or modify the structure of a form, we work in forms design view. We can add
control to the form that are bound to fields in a table or query, includes textboxes, option buttons,
graphs and pictures.
Form View:
The form view which display the whole design of the form.
REPORT:
A report is used to vies and print information from the database. The report can ground
records into many levels and compute totals and average by checking values from many records
at once. Also the report is attractive and distinctive because we have control over the size and
appearance of it.
MACRO:
A macro is a set of actions. Each action in macros does something. Such as opening a form or
printing a report .We write macros to automate the common tasks the work easy and save the
time.
MODULE:
Modules are units of code written in access basic language. We can write and use module to
automate and customize the database in very sophisticated ways. It is a personal computer based
RDBMS. This provides most of the features available in the high-end RDBMS products like
Oracle, Sybase, and Ingress etc. VB keeps access as its native database. Developer can create a
database for development & further can create. The tables are required to store data. During the
initial Development phase data can be stored in the access database & during the implementation
phase depending on the volume data can use a higher – end database.
SYSTEM STUDY:
FEASIBILTY STUDY:
The feasibility of the project is analyzed in this phase and business proposal is put forth
with a very general plan for the project and some cost estimates. During system analysis the
feasibility study of the proposed system is to be carried out. This is to ensure that the proposed
system is not a burden to the company. For feasibility analysis, some understanding of the major
requirements for the system is essential.
Three key considerations involved in the feasibility analysis are
ECONOMICAL FEASIBILITY
TECHNICAL FEASIBILITY
SOCIAL FEASIBILITY
ECONOMICAL FEASIBILITY:
This study is carried out to check the economic impact that the system will have on the
organization. The amount of fund that the company can pour into the research and development
of the system is limited. The expenditures must be justified. Thus the developed system as well
within the budget and this was achieved because most of the technologies used are freely
available. Only the customized products had to be purchased.
TECHNICAL FEASIBILITY
This study is carried out to check the technical feasibility, that is, the technical
requirements of the system. Any system developed must not have a high demand on the available
technical resources. This will lead to high demands on the available technical resources. This
will lead to high demands being placed on the client. The developed system must have a modest
requirement, as only minimal or null changes are required for implementing this system.
SOCIAL FEASIBILITY:
The aspect of study is to check the level of acceptance of the system by the user. This
includes the process of training the user to use the system efficiently. The user must not feel
threatened by the system, instead must accept it as a necessity.
The level of acceptance by the users solely depends on the methods that are employed to
educate the user about the system and to make him familiar with it. His level of confidence must
be raised so that he is also able to make some constructive criticism, which is welcomed, as he is
the final user of the system.
Testing is vital to the success of the system. System testing makes a logical assumption
that if all parts of the system are correct, the goal will be successfully achieved. In the testing
process we test the actual system in an organization and gather errors from the new system
operates in full efficiency as stated. System testing is the stage of implementation, which is
aimed to ensuring that the system works accurately and efficiently.
In the testing process we test the actual system in an organization and gather errors from
the new system and take initiatives to correct the same. All the front-end and back-end
connectivity are tested to be sure that the new system operates in full efficiency as stated. System
testing is the stage of implementation, which is aimed at ensuring that the system works
accurately and efficiently.
The main objective of testing is to uncover errors from the system. For the uncovering
process we have to give proper input data to the system. So we should have more conscious to
give input data. It is important to give correct inputs to efficient testing.
Testing is done for each module. After testing all the modules, the modules are integrated
and testing of the final system is done with the test data, specially designed to show that the
system will operate successfully in all its aspects conditions. Thus the system testing is a
confirmation that all is correct and an opportunity to show the user that the system works.
Inadequate testing or non-testing leads to errors that may appear few months later.
This will create two problems, Time delay between the cause and appearance of the
problem. The effect of the system errors on files and records within the system. The purpose of
the system testing is to consider all the likely variations to which it will be suggested and push
the system to its limits.
The testing process focuses on logical intervals of the software ensuring that all the
statements have been tested and on the function intervals (i.e.,) conducting tests to uncover errors
and ensure that defined inputs will produce actual results that agree with the required results.
Testing has to be done using the two common steps Unit testing and Integration testing. In the
project system testing is made as follows:
The procedure level testing is made first. By giving improper inputs, the errors occurred
are noted and eliminated. This is the final step in system life cycle. Here we implement the tested
error-free system into real-life environment and make necessary changes, which runs in an online
fashion. Here system maintenance is done every months or year based on company policies, and
is checked for errors like runtime errors, long run errors and other maintenances like table
verification and reports.
UNIT TESTING:
Unit testing verification efforts on the smallest unit of software design, module. This is
known as “Module Testing”. The modules are tested separately. This testing is carried out during
programming stage itself. In these testing steps, each module is found to be working
satisfactorily as regard to the expected output from the module.
INTEGRATION TESTING:
Login Coding:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Data.SqlClient;
namespace SteganoDemo
{
public partial class Login : Form
{
SqlConnection con = new SqlConnection("server=FABSYS1-PC;initial catalog=hide;
Persist security info=true;user id= sa; password=saadmin;");
SqlCommand cmd;
SqlDataReader dr;
public Login()
{
InitializeComponent();
}
con.Open();
cmd = new SqlCommand("select * from login where Name='" + txt_user.Text +
"' and password='" + txt_pass.Text + "'", con);
dr = cmd.ExecuteReader();
if (dr.Read())
{
txt_user.Text = "";
txt_pass.Text = "";
MessageBox.Show("Welcome User");
MainForm main = new MainForm();
main.Show();
this.Visible = false;
}
else
{
MessageBox.Show("Enter correct username & password");
txt_user.Text = "";
txt_pass.Text = "";
txt_user.Focus();
}
con.Close();
}
}
}
}
}
Main Form:
using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Text;
using System.IO;
using System.Diagnostics;
using System.Net;
using System.Collections.Generic;
namespace SteganoDemo
{
public class MainForm : System.Windows.Forms.Form
{
private System.Windows.Forms.Panel panelKeyFiles;
private System.Windows.Forms.Label label1;
private System.Windows.Forms.Splitter splitter1;
private System.Windows.Forms.ColumnHeader clmKeyFileName;
private System.Windows.Forms.ListView lvKeyFiles;
private System.Windows.Forms.Button btnKeyFileAdd;
private System.Windows.Forms.Button btnKeyFileRemove;
private OpenFileDialog openFileDialog1;
private TabPage tabExtract;
private Button btnExtract;
private TextBox txtExtractMsgText;
private TextBox txtExtractMsgFile;
private Button btnExtractMsgFileBrowse;
private RadioButton rdoExtractMsgText;
private RadioButton rdoExtractMsgFile;
private Label label4;
private Panel panel1;
private ListView lvExtractCarriers;
private ColumnHeader clmExtractFileName;
private ColumnHeader clmExtractCarrierUnits;
private Button btnExtractAddCarrierFile;
private Button btnExtractRemoveCarrierFile;
private Label label2;
private TabPage tabHide;
private Panel panelHide;
private Button btnHide;
private TextBox txtHideMsgText;
private Button btnHideMsgFileBrowse;
private TextBox txtHideMsgFile;
private RadioButton rdoHideMsgText;
private RadioButton rdoHideMsgFile;
private Label label3;
private Panel panelHideCarriers;
private Button btnHideEditCarrierFile;
private ListView lvHideCarriers;
private ColumnHeader clmFileName;
private ColumnHeader clmSaveAs;
private ColumnHeader clmCarrierUnits;
private ColumnHeader clmUseableCarrierUnits;
private ColumnHeader clmCreateNoise;
private Button btnHideAddCarrierFile;
private Button btnHideRemoveCarrierFile;
private CountOfUnitsDisplayControl displayCountOfUnitsHide;
private TabControl tabctlTasks;
private Button btnEncrypt;
private Button button4;
private System.ComponentModel.Container components = null;
public MainForm()
{
InitializeComponent();
}
#endregion
[STAThread]
static void Main()
{
Application.Run(new Login());
}
long maxLength = 0;
foreach (Stream stream in keyStreams)
{
if (stream.Length > maxLength)
{
maxLength = stream.Length;
}
}
int readByte = 0;
for (long n = 0; n <= maxLength; n++)
{
for (int streamIndex = 0; streamIndex < keyStreams.Length; streamIndex++)
{
if (keyStreams[streamIndex] != null)
{
readByte = keyStreams[streamIndex].ReadByte();
if (readByte < 0)
{
keyStreams[streamIndex].Close();
keyStreams[streamIndex] = null;
}
else
{
resultKeyStream.WriteByte((byte)readByte);
}
}
}
}
resultKeyStream.Seek(0, SeekOrigin.Begin);
return resultKeyStream;
}
isOkay = true;
if (carrierFile.CountUseableCarrierUnits < 5)
{
if (MessageBox.Show(this,
carrierFile.SourceFileName + " is too small. Remove it from
the list?",
"File cannot be used",
MessageBoxButtons.YesNo) == DialogResult.Yes)
{
lvHideCarriers.Items.RemoveAt(n);
n--;
isOkay = false;
}
}
if (isOkay)
{
lvHideCarriers.Items[n].Tag = carrierFile;
lvHideCarriers.Items[n].SubItems[clmUseableCarrierUnits.Index].Text =
carrierFile.CountUseableCarrierUnits.ToString();
countAvailableUnits += carrierFile.CountUseableCarrierUnits;
}
}
displayCountOfUnitsHide.CountAvailableCarrierUnits = countAvailableUnits;
}
else
{ //no key selected
displayCountOfUnitsHide.CountAvailableCarrierUnits = 0;
}
}
SetExtractButtonEnabled();
CountAvailableCarrierUnits();
}
SetExtractButtonEnabled();
CountAvailableCarrierUnits();
}
if (lvKeyFiles.Items.Count > 0)
{
CountAvailableCarrierUnits();
}
}
else
{
MessageBox.Show(selectedFile.SourceFileName + " is already in use.");
HideAddCarrierControl ctl = new HideAddCarrierControl(selectedFile);
ShowCarrierControl(ctl);
}
}
this.Cursor = Cursors.WaitCursor;
CarrierFile carrierFile;
ListViewItem item;
foreach (String fileName in fileNames)
{
carrierFile = new CarrierFile(fileName, String.Empty, 0, 0, 0);
FileUtility utility = FileUtility.CreateFileUtility(carrierFile);
carrierFile.CountCarrierUnits = utility.CountUnits();
utility = null;
SetExtractButtonEnabled();
this.Cursor = Cursors.Default;
}
ShowCarrierControl(ctl);
lvHideCarriers.Items.Remove(lvHideCarriers.SelectedItems[0]);
}
float countAvailableUnits =
displayCountOfUnitsHide.CountAvailableCarrierUnits;
FileUtility utility;
FileUtility utility;
Stream messagePart = new MemoryStream();
byte[] buffer;
for (int n = 0; n < carrierFiles.Length; n++)
{
utility = FileUtility.CreateFileUtility(carrierFiles[n]);
messagePart.SetLength(0);
utility.Extract(messagePart, key);
messagePart.Close();
message.Seek(0, SeekOrigin.Begin);
if (rdoExtractMsgFile.Checked)
{
FileStream fs = new FileStream(txtExtractMsgFile.Text, FileMode.Create);
buffer = new byte[message.Length];
message.Read(buffer, 0, buffer.Length);
fs.Write(buffer, 0, buffer.Length);
fs.Close();
message.Close();
}
else
{
StreamReader reader = new StreamReader(message, Encoding.Unicode);
txtExtractMsgText.Text = reader.ReadToEnd();
reader.Close();
}
MessageBox.Show("Data Extracted");
}
if (messageLength > 0)
{
carrierFiles[n].CountBytesToHide =
(Int32)Math.Ceiling((float)messageLength *
((float)carrierFiles[n].CountUseableCarrierUnits / countAvailableUnits));
sumCountBytesToHide += carrierFiles[n].CountBytesToHide;
if (carrierFiles[n].CountBytesToHide > maxCountBytesToHide)
{
maxCountBytesToHide = carrierFiles[n].CountBytesToHide;
indexMaxCountBytesToHide = n;
}
}
else
{
carrierFiles[n].CountBytesToHide = 0;
}
}
return carrierFiles;
}
Screen Shots:
CONCLUSION:
A method of embedding text-based data into a host audio file using the method of bit
modification has been presented in this paper. A procedure has been developed in which the data
field is edited to embed intended data into the audio file. To proceed with this, the header section
of the audio has been checked perfectly because a minimal change in the header section may
leads to a corruption of whole audio file. In this algorithm, as an experiment first 50 bytes have
been left untouched and starting from the 51st bytes every alternate sample has been modified to
embed textual information. How the performance is affected by changing different bit fields has
not been reported in this work. However a rough study was made to see how the changing of a
specific bit field creates degradation in the host audio file and in which point it leads to
perceptible change in the audible sound quality to any other third party other than the sender or
receiver. It was noticed that changing the least significant bit of the bytes gave the best results.
An audio file with size 952 KB has been used. The maximum text file size that can be embedded
in this audio file without degrading the file structure can be traced through a survey. The main
goal of this research work was embedding of text into audio as a case of steganography. The two
primary criteria for successful steganography are that the stego signal resulting from embedding
is perceptually indistinguishable from the host audio signal, and the embedded message is
recovered correctly at the receiver. In test cases the text-based data has been successfully