STEGNOGRAPHY

A PROJECT REPORT

Submitted by

ARCHANA SP XXXXXXXX

In partial fulfillment for the award of the degree

Of

BACHELOR OF ENGINEERING

IN

COMPUTER SCIENCE AND ENGINEERING

JCT COLLEGE OF ENGINEERING AND TECHNOLOGY,

PICHANUR, COIMBATORE.

ANNA UNIVERSITY: CHENNAI-600 025

APRIL-2015
 ANNA UNIVERSITY: CHENNAI 600 025

BONAFIDE CERTIFICATE

Certified that this project report titled “STEGNOGRAPHY” is a bonafide

work of S.P ARCHANA who carried out the project work under my
supervision.

SIGNATURE SIGNATURE
Mrs. XXXXXXXXXXX, M.E Mr. XXXXXXXXXXX

Submitted for the Project and Viva-Voce Examination held on

……………..

INTERNAL EXAMINER EXTERNAL EXAMINER

 ACKNOWLEDGEMENT

First and foremost, we consider it is the cardinal duty to thank

ALMIGHTY GOD for his grace and blessings throughout the project. We
express our heart thanks to our Chairman Mr.xxxxxxxxxx, for providing
full facilities and technical environment to start this project work.
We express our heartfelt gratitude to the Senior Director
Prof.xxxxxxxxxxxof our institution for his constant support. We express our
heartfelt gratitude to the Academic Director Mr.xxxxxxxxx of our
institution for his constant support. We express our heartfelt gratitude to the
Principal Dr.xxxxxxxx of our institution for his constant support.
We extend our thanks to ever loving Head of the Department
Mrs. G Hima Simson, Associate Professor, Department of Computer
Science and Engineering, for rendering his full supports both mentally and
technically by encouraging us at all times we needed it.
We would like to express our whole hearted thanks to our
project internal guide Mr. J L Joneston Dhas, Assistant Professor,
Department of Computer Science and Engineering, to meet all challenges
to come up with our project victoriously.
 CONTENTS

1. SYNOPSIS
2. INTRODUCTION

2.1 FEASIBILITY STUDY

3. PROBLEM DEFINITION
3.1 EXISTING SYSTEM

3.2 PROPOSED SYSTEM

4. SYSTEM REQUIREMENT
4.1 SOFTWARE REQUIREMENT

4.2 HARDWARE REQUIREMENT

5. PROGRAM ENVIRONMENT

5.1 LANGUAGE DESCRIPTION

5.2 OPERATING SYSTEM

6. PROJECT DESCRIPTION

7. SOURCE CODE

8. SYSTEM DESIGN

8.1 SYSTEM FLOW DESIGN

8.2 DATA BASE DESIGN

8.3 INPUT DESIGN

8.4 OUTPUT DESIGN

9. SYSTEM TESTING
10.SYSTEM IMPLEMENTATION

11.SYSTEM MAINTENANCE

12.CONCLUSION

13. FUTURE ENHANCEMENT

14. BIBLIOGRAPHY
 1. SYNOPSIS

“Steganography” is the art and science of writing hidden messages in

such a way that no one apart from the intended recipient knows of the
existence of the message. This can be achieving by concealing the existence
of information within seemingly harmless carriers or cover. The detection of
steganographically encoded packages is called Steganalysis.

The art and science of writing hidden messages in such a way that no one
apart from the intended recipient even knows that a message has been sent.
The larger the image size, the more information you can hide. However,
larger images may require compression to avoid detection. The project
“Steganography “includes the following module.

 Encryption

 File format

 Hiding the message

 Decrypt

 Extracting the message

 2. INTRODUCTION

Data hiding is a characteristic of object-oriented programming. The

object can only “know” about the data it needs to know about. All data not
required by an object can be said to be “hidden”. It is used in forensic
applications. Hiding capacity is very important for efficient covert
communications. For JPEG2000 compressed images, it is necessary to
enlarge the hiding capacity because the available redundancy is very limited.
In addition, the bit stream truncation makes it difficult to hide information.
In this paper, a high-capacity steganography scheme is proposed for the
JPEG2000 baseline system, which uses bit-plane encoding procedure twice
to solve the problem due to bit stream truncation. Moreover, embedding
points and their intensity are determined in a well defined quantitative
manner via redundancy evaluation to increase hiding capacity.
Steganography means covered or hidden writing. Steganography is the art
and science of writing hidden messages in such a way that no one apart from
the intended recipient knows of the existence of the message. The proposed
method can be easily integrated into the JPEG2000 image coder, and the
produced stego-bitstream can be decoded normally. Simulation shows that
the proposed method is feasible, effective, and secure.
 2.1 FEASIBILITY STUDY

A feasibility study is a preliminary study undertaken to determine and

document a project's viability. Also known as feasibility analysis .The term
feasibility study is also used to refer to the resulting document. The results
of this study are used to make a decision whether or not to proceed with the
project. If it indeed leads to a project being approved, before the real work of
the proposed project starts be used to ascertain the likelihood of the project's
success. It is an analysis of possible alternative solutions to a problem and a
recommendation on the best alternative. It, for example, can decide whether
an order processing be carried out by a new system more efficiently than the
previous one.

A feasibility study is an important part of creating a business plan for

a new enterprise, since it has been estimated that only one idea in fifty is
commercially viable. If a project is seen to be feasible from the results of the
study, the next logical step is to proceed with it. The research and
information uncovered in the feasibility study will support the detailed
planning and reduce the research time.

Components of Feasibility

This involves questions such as whether the technology needed for the
system exists, how difficult it will be to build, and whether the firm has
enough experience using that technology. The assessment is based on an
outline design of system requirements in terms of Input, Processes, Output,
Fields, Programs, and Procedures. This can be quantified in terms of
volumes of data, trends, frequency of updating, etc in order to estimate if the
new system will perform adequately or not. Three considerations are
involved in the feasibility analysis. They are Technical Feasibility,
Operational Feasibility and Economical Feasibility.

Technical feasibility:

The technical issues usually raised during the feasibility stage of the
investigation include these:
a. Does the necessary technology exist to do what is suggested!
b. Does the proposed equipment have the technical capacity to hold the
data required to use the new system!
c. Will the proposed system provide adequate responses to inquiries,
regardless of the number or location of users!
d. Can be system be expanded if developed!
e. Are the technical guarantees of accuracy, reliability, ease of access,
and data security!
Yes, by using the current technology this software can be developed and
also the Visual basic.NET framework is made to be installed.

Economic Feasibility:

The financial and economic questions raised by analysts during the

preliminary investigation are for the purpose of estimating the following:
a. The cost to conduct a full system investigation
 b. The cost of hardware and software for the class of application being
considered.
c. The benefits in the form of reduced costs or fewer costly errors .
d. The cost if nothing changes(i.e., the proposed system is not
developed).
As this is a simple project, there is no such cost is required. Except the
cost that is needed for the Local Cable wire that has to be connected. From
one system to another the LAN wire is made to be connected and from that
only the Internet Protocol is made to be called. Whereas, the information is
made to be transferred and also retrieved. The cost to hardware is the cable
wire and the cost towards software side is Visual .NET Framework.
Operational Feasibility:
Proposed projects are beneficial projects only if they can be turned
into information systems that will meet the organization’s operating
requirements. Simply stated, this test of feasibility asks if the system will
work when it is developed and installed. Will the system be used if it is
developed and implemented? Will there be resistance from users that will
undermine the possible application benefits?
Issues that appear to be relatively minor in the beginning have ways of
growing into major problems after implementation. Therefore all operational
aspects must be considered carefully. Operational feasibility is looked at the
view of proposed solution fitting with the current operations. This test of
feasibility asks,

1 How long the system will work when it is developed and installed.
2 How will the solution affect the end-users work environment?
 3. PROBLEM DEFINITION

3.1 Existing System:

Hiding capacity is very important for efficient covert

communications. For JPEG compressed images, it is necessary to enlarge
the hiding capacity because the available redundancy is very limited. In
addition, the bit stream truncation makes it difficult to hide information.

Draw Backs:
 Hiding messages in images
 The bit stream truncation makes it difficult to hide information
 Less security
 Less Information Security

In order to overcome these hurdles the computerized is suggested.

3.2 Proposed System:

The proposed system rectifies most of the problem in the present
system. Steganography is the process of hiding of a secret message within
an ordinary message and extracting it at its destination. Anyone else viewing
the message will fail to know it contains hidden/encrypted data. Modern
digital steganography data is encrypted

 then inserted and hidden, using a special algorithm which may add
and/or modify the contents of the file
  This technique may simply append the data to the file, or disperse it
throughout

 Carefully crafted programs apply the encrypted data such that patterns
appear normal.

The main features are:

 The Data Hiding in JPEG Image.
 Our project deals with two important network security concepts -
Steganography and encryption.
 Increased Information Security
 For encryption- DES algorithm is used.
 For Steganography LSB algorithm is used.
 Bit plane encoding procedure twice to solve the problem due to bit
stream truncation.
 4. SYSTEM REQUIREMENT

4.1HARDWARE CONFIGURATION

Processor : Pentium IV 2.4GHZ MHz

Mother Board : Intel 845 GVSR
RAM : 256 MB
Hard Disk : 80 GB
Key board : Samsung keyboard
Monitor : LG 17” Monitor 1024*768 pixels
Mouse : Samsung Optical Mouse

4.2 SOFTWARE CONFIGURATION

Operating system : Windows 7

Web Server : IIS 5.0
Server Side Script : ASP.NET
Client Side Script : C#
Front End : ASP.Net
IDE : VS.Net Framework 4.0
 4. PROGRAM ENVIRONMENT

WINDOWS XP

Windows XP is a full-fledged operating system. Windows XP

Professional, you have faster access to information, and you are able to
accomplish tasks more quickly and easily. You and your network
administrations can work more efficiently now, because many of the most
common computer-management tasks are automated and streamlined. It is
possible to use another operating system on your computer along with
Windows XP.

Windows XP supports a feature called dual-boot or multiple-boot.

Using this, Windows XP will ask you which operating system you want to
use. But to install another operating system, you will need a separate
partition, which will look a separate drive in My Computer.

Windows 2003 Server

It is a good for small sized to medium sized application deployment,

Web Servers, workgroups, and branch offices. Windows 2003 Server
supports uni-processor systems and 4-way Symmetric Multi Processing
(SMP) systems with up to 4 Giga Bytes (GB) of physical memory.

Windows 2003 Advanced Server

More powerful server operating system, providing a comprehensive

clustering infrastructure for high availability and scalability, supporting
memory up to 8 GB. It is designed for demanding enterprise applications.
Advanced server supports new systems with up to 8-way SMP. A more
advanced department and applications server ideal for large, database-
intensive applications.
Windows 2003 Data Center Server

A specialized high-end version of Windows 2000 server, supporting

up to 32- way SMP and up to 64 GB of physical memory. This server
product is targeted at large data warehouses, econometric analysis, large-
scale simulations in science and engineering, On-Line Transaction
Processing (OLTP) and server consolidation projects.

Hardware Requirement for Windows XP Professional

To use Windows XP Professional you should have:

1 A Pentium II Processor

2 500 MB of free hard disk space.

3 64 MB of RAM.

If your computer doesn’t meet the minimum requirements then you

have to beef-up your system before you switch to Windows XP.

What’s new in Windows XP Professional?

1 Easier to use

2 Easier to manage

3 Latest Hardware Support

4 More Reliable

5 More Secure

MICROSOFT.NET FRAMEWORK

The .NET Framework is a new computing platform that simplifies

application development in the highly distributed environment of the
Internet. The .NET Framework is designed to fulfill the following
objectives:

 To provide a consistent object-oriented programming environment

whether object code is stored and executed locally, executed locally
but Internet-distributed, or executed remotely.
 To provide a code-execution environment that minimizes software
deployment and versioning conflicts.
 To provide a code-execution environment that guarantees safe
execution of code, including code created by an unknown or semi-
trusted third party.
 To provide a code-execution environment that eliminates the
performance problems of scripted or interpreted environments.
 To make the developer experience consistent across widely varying
types of applications, such as Windows-based applications and Web-
based applications.
 To build all communication on industry standards to ensure that code
based on the .NET Framework can integrate with any other code.

Features of the Common Language Runtime

The common language runtime manages memory, thread

execution, code execution, code safety verification, compilation, and other
system services. These features are intrinsic to the managed code that runs
on the common language runtime.

The runtime enforces code access security. For example, users

can trust that an executable embedded in a Web page can play an animation
on screen or sing a song, but cannot access their personal data, file system,
or network. The security features of the runtime thus enable legitimate
Internet-deployed software to be exceptionally feature rich.

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
various Microsoft and third-party language compilers

Generate managed code that conforms to the CTS. This means that
managed code can consume other managed types and instances, while
strictly enforcing type fidelity and type safety.

.NET Framework Class Library:

The .NET Framework class library is a collection of reusable types
that tightly integrate with the common language runtime. The class library is
object oriented, providing types from which your own managed code can
derive functionality. This not only makes the .NET Framework types easy to
use, but also reduces the time associated with learning new

features of the .NET Framework. In addition, third-party components can

integrate seamlessly with classes in the .NET Framework. As you would
expect from an object-oriented class library, the .NET Framework types
enable you to accomplish a range of common programming tasks, including
tasks such as string management, data collection, database connectivity, and
file access. In addition to these common tasks, the class library includes
types that support a variety of specialized development scenarios. For
example, you can use the .NET Framework to develop the following types
of applications and services:

 Console applications.
 Scripted or hosted applications.
 Windows GUI applications (Windows Forms).
 ASP.NET applications.
 XML Web services.
 Windows services.

C#.NET
C# is very much a programming language – a pure object oriented
language from Microsoft, especially designed from the scratch for the
upcoming .NET revolution. C# is one of the most important components of
the .NET revolution in addition to the new Visual Basic.NET and C++.NET.
It has been designed to provide all the good features of the popular
programming language as it adopts its simplicity and productivity from
Visual Basic, power of C++ and elegance of Java. By definition, C# is a
simple, modern, object oriented, and type-safe programming language
derived from C and C++.

The following sections will introduce you to some objects that have evolved,
and some that are new. These objects are:

 Connections. For connection to and managing transactions against

a database.
 Commands. For issuing SQL commands against a database.
  DataReaders. For reading a forward-only stream of data records
from a SQL Server data source.
 DataSets. For storing, remoting and programming against flat data,
XML data and relational data.
 DataAdapters. For pushing data into a DataSet, and reconciling
data against a database.

ASP.Net

ASP.NET is the hosting environment that enables developers to use

the .NET Framework to target Web-based applications. However, ASP.NET
is more than just a runtime host; it is a complete architecture for developing
Web sites and Internet-distributed objects using managed code.

Active Server Pages.NET

ASP.NET is a programming framework built on the common language

runtime that can be used on a server to build powerful Web applications.
ASP.NET offers several important advantages over previous Web
development models:

 Enhanced Performance

 World-Class Tool Support.

 Power and Flexibility.

VISUAL BASIC .NET

 Visual Basic .NET provides the easiest, most productive language and
tool for rapidly building Windows and Web applications. Visual Basic .NET
comes with enhanced visual designers, increased application performance,
and a powerful integrated development environment (IDE). It also supports
creation of applications for wireless, Internet-enabled hand-held devices.
The following are the features of Visual Basic .NET with .NET Framework
1.0 and Visual Basic .NET 2003 with .NET Framework 1.1. This also
answers why should I use Visual Basic .NET, what can I do with it?

Powerful Windows-based Applications

Visual Basic .NET comes with features such as a powerful new forms
designer, an in-place menu editor, and automatic control anchoring and
docking. Visual Basic .NET delivers new productivity features for building
more robust applications easily and quickly. With an improved integrated
development environment (IDE) and a significantly reduced startup time,
Visual Basic .NET offers fast, automatic formatting of code as you type,
improved IntelliSense, an enhanced object browser and XML designer, and
much more.

Building Web-based Applications

With Visual Basic .NET we can create Web applications using the
shared Web Forms Designer and the familiar "drag and drop" feature. You
can double-click and write code to respond to events. Visual Basic .NET
2003 comes with an enhanced HTML Editor for working with complex Web
pages. We can also use IntelliSense technology and tag completion, or
choose the WYSIWYG editor for visual authoring of interactive Web
applications.

Simplified Deployment

With Visual Basic .NET we can build applications more rapidly and
deploy and maintain them with efficiency. Visual Basic .NET 2003
and .NET Framework 1.1 makes "DLL Hell" a thing of the past. Side-by-
side versioning enables multiple versions of the same component to live
safely on the same machine so that applications can use a specific version of
a component. XCOPY-deployment and Web auto-download of Windows-
based applications combine the simplicity of Web page deployment and
maintenance with the power of rich, responsive Windows-based
applications.

Powerful, Flexible, Simplified Data Access

You can tackle any data access scenario easily with ADO.NET and
ADO data access. The flexibility of ADO.NET enables data binding to any
database, as well as classes, collections, and arrays, and provides true XML
representation of data. Seamless access to ADO enables simple data access
for connected data binding scenarios. Using ADO.NET, Visual Basic .NET
can gain high-speed access to MS SQL Server, Oracle, DB2, Microsoft
Access, and more.

Improved Coding
 You can code faster and more effectively. A multitude of
enhancements to the code editor, including enhanced IntelliSense, smart
listing of code for greater readability and a background compiler for real-
time notification of syntax errors transforms into a rapid application
development (RAD) coding machine.

Direct Access to the Platform

Visual Basic developers can have full access to the capabilities

available in .NET Framework 1.1. Developers can easily program system
services including the event log, performance counters and file system. The
new Windows Service project template enables to build real Microsoft
Windows NT Services. Programming against Windows Services and
creating new Windows Services is not available in Visual Basic .NET
Standard, it requires Visual Studio 2003 Professional, or higher.

Full Object-Oriented Constructs

You can create reusable, enterprise-class code using full object-

oriented constructs. Language features include full implementation
inheritance, encapsulation, and polymorphism. Structured exception
handling provides a global error handler and eliminates spaghetti code.

XML Web Services

 XML Web services enable you to call components running on any
platform using open Internet protocols. Working with XML Web services is
easier where enhancements simplify the discovery and consumption of XML
Web services that are located within any firewall. XML Web services can be
built as easily as you would build any class in Visual Basic 6.0. The XML
Web service project template builds all underlying Web service
infrastructure.

Mobile Applications

Visual Basic .NET 2003 and the .NET Framework 1.1 offer integrated
support for developing mobile Web applications for more than 200 Internet-
enabled mobile devices. These new features give developers a single, mobile
Web interface and programming model to support a broad range of Web
devices, including WML 1.1 for WAP—enabled cellular phones, compact
HTML (cHTML) for i-Mode phones, and HTML for Pocket PC, handheld
devices, and pagers. Please note, Pocket PC programming is not available in
Visual Basic .NET Standard, it requires Visual Studio 2003 Professional, or
higher.

COM Interoperability

You can maintain your existing code without the need to recode.
COM interoperability enables you to leverage your existing code assets and
offers seamless bi-directional communication between Visual Basic 6.0 and
Visual Basic .NET applications.

Reuse Existing Investments

 You can reuse all your existing ActiveX Controls. Windows Forms in
Visual Basic .NET 2003 provide a robust container for existing ActiveX
controls. In addition, full support for existing ADO code and data binding
enable a smooth transition to Visual Basic .NET 2003.

Upgrade Wizard

You upgrade your code to receive all of the benefits of Visual

Basic .NET 2003. The Visual Basic .NET Upgrade Wizard, available in
Visual Basic .NET 2003 Standard Edition, and higher, upgrades up to 95
percent of existing Visual Basic code and forms to Visual Basic .NET with
new support for Web classes and User Controls.
 6. PROJECT DESCRIPTION

“Steganography” is the art and science of writing hidden

messages in such a way that no one apart from the intended recipient
knows of the existence of the message.
This can be achieving by concealing the existence of information
within seemingly harmless carriers or cover. The detection of
steganographically encoded packages is called Steganalysis.
The art and science of writing hidden messages in such a way that no
one apart from the intended recipient even knows that a message has
been sent. The larger the image size, the more information you can hide.
However, larger images may require compression to avoid detection. The
project “Steganography “includes the following module.

 Encryption

 File format

 Hiding the message

 Decrypt

 Extracting the message

Encryption
 The process of converting from plaintext to cipher text is known as
encryption or enciphering. The encryption algorithm takes secret key and
plaintext, and produces the cipher text. The cryptographic algorithm
specified in this standard transforms a 64-bit binary value into a unique 64-
bit binary value based on a 56-bit variable. As there are over
70,000,000,000,000,000 (seventy quadrillion) possible keys of 56 bits, the
feasibility of deriving a particular key in this way is extremely unlikely in
typical threat environments. The algorithm is designed to encipher and
decipher blocks of data consisting of 64 bits under control of a 64-bit key.
Permutation is an operation performed by a function, which moves an
element at place j to the place k. The key-dependent computation can be
simply defined in terms of a function f, called the cipher function, and a
function KS, called the key schedule.
• At each iteration a different block K of key bits is chosen from the 64-
bit key designated by KEY.
• Let KS be a function which takes an integer n in the range from 1 to
16 and a 64-bit block KEY as input and yields as output a 48-bit block
Kn which is a permuted selection of bits from KEY. That is
Kn = KS (n, KEY)
• Let the permuted input block be LR.
• Finally, let L0 and R0 be respectively L and R and let Ln and Rn be
respectively L' and R' when L and R are respectively Ln-1 and Rn-1
and K is Rn; that is, when n is in the range from 1 to 16,
Ln = Rn-1
Rn = Ln-1 (+) f (Rn-1, Kn)
• The preoutput block is then R16 L16.
 32 DES algorithms
 32 DES algorithms is used.
 Input is the 64 bit plain text subjected to initial permutation.
 Divide it into left and right each as 32 bit.
 Round operation is performed 16 times
 Output is given to swap function.
 Output of it is given to inverse of initial permutation.
File Format
Steganography Carrier Files
 bmp
 jpeg
 gif
 wav
 mp3
 Amongst others…

Editable JEPG Image:

 Specific type of JPEG Image file.
 Maintain high image quality.
 Support compression- decompression.
LSB Algorithm
If you have a copy of the original (virgin) file, it can be compared to
the modified suspect/carrier file. Many tools can be used for viewing and
comparing the contents of a hidden file. Everything from Notepad to a Hex
Editor can be used to identify inconsistence and patterns. Reviewing
multiple files may identify a signature pattern related to the Steganography
program. After hiding a message with Hiderman, we can review the file with
our favorite Hex Tool. Viewing the Header information (beginning of the
file) we see that it’s a Bitmap as indicated by the “BM” file signature.

 Substitution techniques - LSB algorithm.

 It replaces the least significant bit in some bytes of the cover file to
hide a sequence of bytes containing the hidden data.
 For example, to hide the letter "a" (ASCII code 97, that is 01100001)
inside eight bytes of a cover, you can set the LSB of each byte like
this:

10010010 01010011 10011011 11010010 10001010 00000010

01110010 00101011

Cryptanalysis
 Identify program used to hide message
 Identify the location of the program signature in the file
 Identify the location of the password in the file
 Identify location of the hidden message in the file
 Identify the algorithm used to encrypt the hidden message
Decryption
 The permutation IP-1 applied to the pre output block is the inverse of the
initial permutation IP applied to the input.
R = L'
L = R' (+) f (L', K)
To decipher it is only necessary to apply the very same algorithm to an
enciphered message block.Using the notation of the previous section, this
can be expressed by the equations:
Rn-1 = Ln
Ln-1 = Rn (+) f (Ln, Kn)
where now R16 L16 is the permuted input block for the deciphering
calculation L0 and R0 is the preoutput block.The Cipher Function f : A
sketch of the calculation of f (R, K) is given by

E bit-selection table
32 1 2 3 4 5
4 5 6 7 8 9
 8 9 10 11 12 13
12 13 14 15 16 17
16 17 18 19 20 21
20 21 22 23 24 25
24 25 26 27 28 29
28 29 30 31 32 1

S1
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
0 14 4 13 1 2 15 11 8 3 10 6 12 5 9 0 7
1 0 15 7 4 14 2 13 1 10 6 12 11 9 5 3 8
2 4 1 14 8 13 6 2 11 15 12 9 7 3 10 5 0
3 15 12 8 2 4 9 1 7 5 11 3 14 10 0 6 13
For example, for input 011011 the row is 01, that is row 1, and the
column is determined by 1101, that is column 13. In row 1 column 13
appears 5 so that the output is 0101. The permutation function P yields a 32-
bit output from a 32-bit input by permuting the bits of the input block

P 16 7 20 21
29 12 28 17
1 15 23 26
5 18 31 10
2 8 24 14
32 27 3 9
19 13 30 6
 22 11 4 25
The output P(L) for the function P defined by this table is obtained from
the input L by taking the 16th bit of L as the first bit of P(L), the 7th bit as
the second bit of P(L), and so on until the 25th bit of L is taken as the 32nd
bit of P(L). Now let S1, ..., S8 be eight distinct selection functions, let P be
the permutation function and let E be the function defined above. To define f
(R, K) we first define B1, ..., B8 to be blocks of 6 bits each for which
B1 B2 ... B8 = K (+) E(R)

The block f (R, K) is then defined to be

P (S1 ( B1 ) S2 ( B2 ) ... S 8 ( B8 ))

• Thus K (+) E(R) is first divided into the 8 blocks.

• Then each Bi is taken as an input to Si and the 8 blocks (S1(B1)
S2(B2) ... S8(B8)) of 4 bits each are consolidated into a single block
of 32 bits which forms the input to P
• The output is then the output of the function f for the inputs R and K.
 7. SOURCE CODE

StegnoClass.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Collections;
using System.Security.Cryptography;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Reflection;
using System.Security.Permissions;
namespace Steganography
{

#region PartOne

#region class Bit

public class Bit
{

public static void Replace(ref byte b, int pos, byte value)

{
b = (byte)(value == 1 ? b | (1 << pos) : b & ~(1 << pos));
}

public static byte Extract(byte b, int pos)

{
return (byte)((b & (1 << pos)) >> pos);
}

}
#endregion

#region class CryptoHelper

public class CryptoHelper
 {

public static byte[] Encrypt(byte[] message, string password)

{
return EncryptDecrypt(message, password);
}

public static byte[] Decrypt(byte[] message, string password)

{
return EncryptDecrypt(message, password);
}

private static byte[] EncryptDecrypt(byte[] message, string password)

{

int passwordLength = password.Length;

if (passwordLength == 0)
password = "devx";

byte[] salt = { 31, 1, 76 };

PasswordDeriveBytes pdb = new PasswordDeriveBytes(password, salt);
byte[] key = pdb.GetBytes(128);

byte[] retMessage = new byte[message.Length];

for (int i = 0; i < message.Length; i++)
{
int index = i % key.Length;
retMessage[i] = (Byte)(key[index] ^ message[i]);
}

return retMessage;
}

}
#endregion

#region class LSBHelper

public class LSBHelper
{
// Create a Stream which hides the bytes contained
// in "message" by using the LSB method
public static void Encode(Stream inStream, byte[] message, Stream
outStream)
{

int byteRead;
byte byteWrite;
int i = 0;
int j = 0;
byte bit;

while ((byteRead = inStream.ReadByte()) != -1)

{

byteWrite = (byte)byteRead;

if (i < message.Length)
{

// Extract the bit at the j position

bit = Bit.Extract(message[i], j++);

// Replace the LSB of byteWrite with "bit"

Bit.Replace(ref byteWrite, 0, bit);

// Every 8 bits process another byte of "message"

if (j == 8) { j = 0; i++; }
}

outStream.WriteByte(byteWrite);
}

if (i < message.Length)
throw new Exception("The cover is too small to contain the message to
hide");
}

// Return the hidden bytes for a Stream

public static byte[] Decode(Stream stream, int length)
{

byte[] hidden = new byte[length];

int i = 0;
int j = 0;
byte bit;
int byteRead;

while ((byteRead = stream.ReadByte()) != -1)

{

// Extract the LSB of byteRead

bit = Bit.Extract((byte)byteRead, 0);

// Replace the bit at the j position with "bit"

Bit.Replace(ref hidden[i], j++, bit);

// Every 8 bits process another byte of "hidden"

if (j == 8) { j = 0; i++; }

// Check bytes left

if (i == length) break;
}

// The hidden var contains the hidden bytes

return hidden;

}
#endregion

#region interface ICoverFile

public interface ICoverFile
{
IStegoFile CreateStegoFile(string stegoFileName, string message, string
pwd);
}
#endregion
#region class BMPCoverFile : ICoverFile
public class BMPCoverFile : ICoverFile
{

private string fileName;

public BMPCoverFile(string fileName)

{
this.fileName = fileName;
}

public IStegoFile CreateStegoFile(string stegoFileName, string message,

string password)
{

// Open the cover

FileStream inStream = new FileStream(fileName, FileMode.Open,
FileAccess.Read);

// Check whether the cover is a bmp file

char b = (char)inStream.ReadByte();
char m = (char)inStream.ReadByte();

// Check whether the bitmap is 24bit

byte[] buffer = new byte[2];
inStream.Seek(28, 0);
inStream.Read(buffer, 0, 2);
Int16 nBit = BitConverter.ToInt16(buffer, 0);

// Read the header from the cover

int offset = 54; // Header Size
byte[] header = new byte[offset];
inStream.Seek(0, 0);
inStream.Read(header, 0, offset);

// Write the header to the stego file

FileStream outStream = new FileStream(stegoFileName, FileMode.Create,
FileAccess.Write);

outStream.Write(header, 0, offset);
// Create the unicode encoding
UnicodeEncoding unicode = new UnicodeEncoding();

// Add the length of the message inside the first 4 bytes

byte[] messageBytes = AddLengthAhead(unicode.GetBytes(message));

// Encrypt the message

messageBytes = CryptoHelper.Encrypt(messageBytes, password);

// Encode the cover using the LSB method

inStream.Seek(offset, 0);
LSBHelper.Encode(inStream, messageBytes, outStream);

inStream.Close();
outStream.Close();

// Return a new BMPStegoFile

return new BMPStegoFile(stegoFileName, password);

private byte[] AddLengthAhead(byte[] messageBytes)

{
int len = messageBytes.Length;
byte[] bLen = BitConverter.GetBytes(len);
byte[] ret = new byte[len + bLen.Length];
for (int i = 0; i < bLen.Length; i++)
ret[i] = bLen[i];
for (int i = 0; i < messageBytes.Length; i++)
ret[i + bLen.Length] = messageBytes[i];
return ret;
}

}
#endregion

#region interface IStegoFile

public interface IStegoFile
{
string HiddenMessage
{
get;
}
}
#endregion

#region class BMPStegoFile : IStegoFile

public class BMPStegoFile : IStegoFile
{

private string fileName;

private string password;
private string hiddenMessage;

public BMPStegoFile(string fileName, string password)

{
this.fileName = fileName;
this.password = password;
}

// Return the hidden message

public string HiddenMessage
{
get
{
if (hiddenMessage == null)
ExtractHiddenMessage();
return hiddenMessage;
}
}

protected void ExtractHiddenMessage()

{

// Open the bmp file

Stream inStream = new FileStream(fileName, FileMode.Open,
FileAccess.Read);

// Data starts at byte 54

int offset = 54;
inStream.Seek(offset, 0);

// Decode the first 4 bytes which contain

// the length of the message, using the LSB method
byte[] bLen = LSBHelper.Decode(inStream, 4);

// Decript the length

bLen = CryptoHelper.Decrypt(bLen, password);
int len = BitConverter.ToInt32(bLen, 0);

// Decode the message using the LSB method

inStream.Seek(offset + 4 * 8, 0);

byte[] buffer;

try
{
buffer = LSBHelper.Decode(inStream, len);
}
catch
{
throw new Exception("Wrong password or not a stego file!");
}

// Add the length ahead (4 bytes)

buffer = ConcatByteArray(bLen, buffer);

// Decript the message (including the first 4 bytes)

buffer = CryptoHelper.Decrypt(buffer, password);

// Extract only the message (without the first 4 bytes)

byte[] byteMessage = GetByteMessage(buffer);

// Get the hidden unicode message

UnicodeEncoding unicode = new UnicodeEncoding();
hiddenMessage = unicode.GetString(byteMessage);

inStream.Close();
}

// Concatenate two byte arrays

private byte[] ConcatByteArray(byte[] a, byte[] b)
{
byte[] ret = new byte[a.Length + b.Length];
for (int i = 0; i < a.Length; i++)
ret[i] = a[i];
for (int i = 0; i < b.Length; i++)
ret[i + a.Length] = b[i];
return ret;
}

// Return a the byte array in input without

// the first 4 bytes which represent the
// length of the message
private byte[] GetByteMessage(byte[] buffer)
{
byte[] ret = new byte[buffer.Length - 4];
for (int i = 4; i < buffer.Length; i++)
ret[i - 4] = buffer[i];
return ret;
}
}
#endregion

#endregion

#region PartTwo

#region class DecodedInfo

class Encoding : Compression

{

public static byte[] Encode(DecodedInfo decodedInfo, ProgressBar

progressBar)
{
progressBar.Value = 0;
progressBar.Maximum = (int)(0.1 *
(double)decodedInfo.decodedData.Length) + 1;
int step = decodedInfo.decodedData.Length / progressBar.Maximum;

string decodedData = string.Empty;

ArrayList encodedData = new ArrayList();
ulong totalBits = 0;

for (int i = 0; i < decodedInfo.decodedData.Length; i++)

{
for (int bit = 0; bit < 8; bit++)
{
decodedData += (((int)decodedInfo.decodedData[i] & (1 << bit)) != 0) ? '1' :
'0';
totalBits++;

for (int j = 0; j < decodedInfo.codeMap.Length; j++)

{
if (decodedData == decodedInfo.codeMap[j])
{
encodedData.Add((byte)j);
decodedData = string.Empty;
break;
}
}

if (decodedInfo.totalBits == totalBits)
{
break;
}
}

if (decodedInfo.totalBits == totalBits)
{
break;
}

if (i % step == 0)
{
progressBar.Value = Math.Min(progressBar.Value + 1,
progressBar.Maximum - 1);
}
}

byte[] res = new byte[encodedData.Count];

for (int i = 0; i < res.Length; i++)
{
res[i] = (byte)encodedData[i];
}

if (decodedInfo.twinFileName != string.Empty)
{
FileStream fs = new FileStream(decodedInfo.twinFileName,
FileMode.Open);
byte[] twin = new byte[fs.Length];
fs.Read(twin, 0, twin.Length);
fs.Close();
Compression.Xor(res, twin, res);
}

progressBar.Value = progressBar.Maximum - 1;

return res;

} // Encode

public static void Save(DecodedInfo decodedInfo, string outFileName)

{
FileStream fs = new FileStream(outFileName, FileMode.CreateNew);
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(fs, decodedInfo);
fs.Close();

} // Save

public static void Load(out DecodedInfo decodedInfo, string inFileName)

{
FileStream fs = new FileStream(inFileName, FileMode.Open);
BinaryFormatter formatter = new BinaryFormatter();
formatter.Binder = new ClassDeserializationBinder();
decodedInfo = (DecodedInfo)formatter.Deserialize(fs);
fs.Close();

} // Load

} // Encoding

[Serializable]
class DecodedInfo
{
public byte[] decodedData = null;
public string[] codeMap = null;
public ulong totalBits = 0;
public string twinFileName = string.Empty;
public string originalFileName = string.Empty;

} // DecodedInfo

#endregion // class DecodedInfo

#region class EncodedInfo

class EncodedInfo
{
public byte[] ecodedData = null;
public string originalFileName = string.Empty;

} // EncodedInfo

#endregion // class EncodedInfo

#region Serialization

public sealed class ClassDeserializationBinder : SerializationBinder

{
public override Type BindToType(string assemblyName, string typeName)
{
return Type.GetType(String.Format("{0}, {1}", typeName,
Assembly.GetEntryAssembly().FullName.Split(',')[0]));
} // BindToType

} // ClassDeserializationBinder

#endregion // Serialization

#region class Accumulator

class Accumulator
{
private ArrayList eMsg = new ArrayList();
int curBit = 0;

public byte[] AccumulatedData

{
get
{
byte[] res = new byte[this.eMsg.Count];
for (int i = 0; i < this.eMsg.Count; i++)
{
res[i] = (byte)this.eMsg[i];
}

return res;
}

} // AccumulatedData

public void AddWord(string word)

{
if (this.eMsg.Count == 0)
{
this.eMsg.Add(new Byte());
this.curBit = 0x1;
}

for (int i = 0; i < word.Length; i++)

{
if (this.curBit == 0)
{
this.eMsg.Add(new Byte());
this.curBit = 0x1;
}

if (word[i] == '1')
{
this.eMsg[this.eMsg.Count - 1] = (Byte)((int)
(Byte)this.eMsg[this.eMsg.Count - 1] | this.curBit);
}

this.curBit = (this.curBit << 1) % 0x100;

}

} // AddWord

} //class Accumulator

#endregion // class Accumulator

#region class Compression

class Compression
{
public static void Xor(byte[] source1, byte[] source2, byte[] destenation)
{
if (destenation.Length == source1.Length)
{
for (int i = 0; i < destenation.Length; i++)
{
destenation[i] = (byte)(source1[i] ^ source2[i % source2.Length]);
}
}
else if (destenation.Length == source2.Length)
{
for (int i = 0; i < destenation.Length; i++)
{
destenation[i] = (byte)(source2[i] ^ source1[i % source1.Length]);
}
}
else
{
for (int i = 0; i < destenation.Length; i++)
{
destenation[i] = (byte)(source2[i % source2.Length] ^ source1[i %
source1.Length]);
}
}

} // Xor

} // class Compression
#endregion

#region class Hamming

class Hamming
{
#region Data Structure

public class VertexBase

{
public enum VertexType
{
Leaf,
Vertex,
Unknown
}

protected VertexType vertexType = VertexType.Unknown;

public VertexType GetVType

{
get
{
return this.vertexType;
}
}

public long property = 0;

public VertexBase(long property)

{
this.property = property;
}
}

public class Vertex : VertexBase

{
public VertexBase left = null;
public VertexBase right = null;

public Vertex(long property, VertexBase left, VertexBase right)

: base(property)
{
this.left = left;
this.right = right;
base.vertexType = VertexType.Vertex;
}
}

public class Leaf : VertexBase

{
public byte value = 0;
public string code = string.Empty;

public Leaf(long property, byte value)

: base(property)
{
this.value = value;
base.vertexType = VertexType.Leaf;
}
}

#endregion // Data Structure

#region Member Variables

private ArrayList view = new ArrayList();

private ArrayList leafs = new ArrayList();

#endregion // Member Variables

#region Properties

public string[] CodeMap

{
get
{
string[] res = new string[256];
foreach (Leaf leaf in this.leafs)
{
res[leaf.value] = leaf.code;
}

return res;
}

} // CodeMap

#endregion // Properties

#region Construction

public Hamming(long[] dictionary)

{
for (int i = 0; i < dictionary.Length; i++)
{
if (dictionary[i] != 0)
{
Leaf newLeaf = new Leaf(dictionary[i], (byte)i);
this.view.Add(newLeaf);
this.leafs.Add(newLeaf);
}
}
}

#endregion // Construction

#region Public Methods

public void Decode()

{
this.BuildTree();
if (((VertexBase)this.view[0]).GetVType == VertexBase.VertexType.Leaf)
{
((Leaf)this.view[0]).code = "0";
}
else
{
this.CalcCode((VertexBase)this.view[0], string.Empty);
}
}

#endregion // Public Methods

#region Private Methods

private void BuildTree()

{
while (this.view.Count > 1)
{
VertexBase min1 = (VertexBase)this.view[0];
VertexBase min2 = (VertexBase)this.view[1];

for (int i = 2; i < this.view.Count; i++)

{
VertexBase ver = (VertexBase)this.view[i];

if (ver.property < min1.property)

{
if (min1.property < min2.property)
{
min2 = min1;
}
min1 = ver;
}
else if (ver.property < min2.property)
{
if (min2.property < min1.property)
{
min1 = min2;
}
min2 = ver;
}
}

this.view.Remove(min1);
this.view.Remove(min2);
this.view.Add(new Vertex(min1.property + min2.property, min1, min2));
}
}

private void CalcCode(VertexBase root, string code)

{
if (root.GetVType == VertexBase.VertexType.Leaf)
{
((Leaf)root).code = code;
System.Diagnostics.Debug.WriteLine(((Leaf)root).value.ToString() + ": " +
((Leaf)root).property + ", " + code);
return;
}

this.CalcCode(((Vertex)root).left, code + "1");

this.CalcCode(((Vertex)root).right, code + "0");

} // CalcCode

#endregion // Private Methods

} // class Hamming
#endregion

#region class Decoding

class Decoding : Compression
{
public static byte[] bytes = ASCIIEncoding.ASCII.GetBytes("ZeroCool");

#region Member Variables

private long[] histogram = new long[256];

byte[] inputData = null;
private byte[] tempVector = null;

#endregion // Member Variables

#region Properties

public byte[] InputData

{
get
{
return this.inputData;
}

} // InputData

public long[] Histogram

{
get
{
return this.histogram;
}

} // Histogram

#endregion // Properties

#region Construction

public Decoding(byte[] data)

{
this.inputData = data;
this.CalcHistogram();

} // Decoding

#endregion // Construction

#region Public Methods

public double CalcEntropy()

{
long sum = 0;
for (int i = 0; i < this.histogram.Length; i++)
{
sum += this.histogram[i];
}

double H = 0;
double log2 = Math.Log(2);
for (int i = 0; i < this.histogram.Length; i++)
{
if (this.histogram[i] == 0)
{
continue;
}

H += ((double)this.histogram[i] / sum) * Math.Log((double)sum /

this.histogram[i]) / log2;
}

return H;

} // CalcEntropy

public double CalcEntropyByTwin(byte[] twin)

{
if (this.tempVector == null)
{
this.tempVector = new byte[this.inputData.Length];
}

Compression.Xor(this.inputData, twin, this.tempVector);

Decoding temp = new Decoding(this.tempVector);

return temp.CalcEntropy();

} // CalcEntropyByTwin

public void Decode(byte[] data, out DecodedInfo decodedInfo, ProgressBar

progressBar)
{
progressBar.Value = 0;
progressBar.Maximum = (int)(0.1 * (double)data.Length) + 1;
int step = data.Length / progressBar.Maximum;

Hamming hamming = new Hamming(this.histogram);

hamming.Decode();

Accumulator accumulator = new Accumulator();

string[] codeMap = hamming.CodeMap;

ulong totalBits = 0;
for (int i = 0; i < data.Length; i++)
{
accumulator.AddWord(codeMap[data[i]]);
totalBits += (ulong)codeMap[data[i]].Length;

if (i % step == 0)
{
progressBar.Value = Math.Min(progressBar.Value + 1,
progressBar.Maximum - 1);
}
}

decodedInfo = new DecodedInfo();

decodedInfo.decodedData = accumulator.AccumulatedData;
decodedInfo.codeMap = codeMap;
decodedInfo.totalBits = totalBits;

progressBar.Value = progressBar.Maximum - 1;

} // Decode

public static string Encrypt(string originalString)

{
if (String.IsNullOrEmpty(originalString))
{
MessageBox.Show("Please type your message....!!!");
return string.Empty;
}
else
{
DESCryptoServiceProvider cryptoProvider = new
DESCryptoServiceProvider();
MemoryStream memoryStream = new MemoryStream();
CryptoStream cryptoStream = new CryptoStream(memoryStream,
cryptoProvider.CreateEncryptor(bytes, bytes), CryptoStreamMode.Write);

StreamWriter writer = new StreamWriter(cryptoStream);

writer.Write(originalString);
writer.Flush();
cryptoStream.FlushFinalBlock();
writer.Flush();

return Convert.ToBase64String(memoryStream.GetBuffer(), 0,
(int)memoryStream.Length);
}
}

public static string Decrypt(string cryptedString)

{
if (String.IsNullOrEmpty(cryptedString))
{
MessageBox.Show("There is no hidded message in the steganofile");
return string.Empty;
}
else
{
DESCryptoServiceProvider cryptoProvider = new
DESCryptoServiceProvider();
MemoryStream memoryStream = new
MemoryStream(Convert.FromBase64String(cryptedString));
CryptoStream cryptoStream = new CryptoStream(memoryStream,
cryptoProvider.CreateDecryptor(bytes, bytes), CryptoStreamMode.Read);
StreamReader reader = new StreamReader(cryptoStream);

return reader.ReadToEnd();
}
}
#endregion // Public Methods
#region Private Methods

private void CalcHistogram()

{
// Clear histogram
for (int i = 0; i < this.histogram.Length; i++)
{
this.histogram[i] = 0;
}

// Calc histogram
for (int i = 0; i < this.inputData.Length; i++)
{
this.histogram[this.inputData[i]]++;
}

} // CalcHistogram

#endregion // Private Methods

} // class Decoding
#endregion

#endregion

} // namespace Steganography
 8. SYSTEM DESIGN

8.1 System Flow Diagram

8.2 Data Flow Diagram
 8.3 INPUT DESIGN

Login

]
\
Main Page
Image Compression
Save .ham file
Decompression
Save Stegno Image
View Hidden Information
 9. SYSTEM TESTING

Objective of Testing

Testing, which consumes a considerable amount of the development

time, is essential in improving the reliability of the system and in identifying
further refinements to the system. Testing allows detection of design faults,
if any, which can be rectified. The first test of a system is to see whether it
produces the correct output. Proper choice of test data is as important as the
test itself in this phase of testing. If the test data given as input are not valid
are representative of the data to be provided then the user suspects the
reliability of the output.

Test data may be artificial (created solely for test purpose) or live
(representing actual data that the user will provide). Properly created data
should provide all combination of values and formats and make it possible to
test all logical paths that the system can take. These data should take care of
all analysis like worst-case analysis, best-case analysis, etc. unlike live data,
which are biased toward typical values artificial data provide extreme values
for testing the limits of the system.
TESTING PLAN

Code testing and specification testing

Code testing and specification testing are the two general strategies
used for testing software. In code testing, the logic of the program is
examined i.e., every instruction in the program is executed using test cases.
Although code testing seems ideal for testing software, it fails to uncover all
the software errors. Moreover this test does not check whether the code
meets all its specifications. For this reason the specification test is carried
out.

In specification testing, the specifications stating what the program

should do and how it should perform under various conditions are examined.
To carry out this test, test cases are developed for each condition or
combination of conditions and submitted for processing. The result of the
processing is analyzed to determine whether the program performs
according to its specified requirements.

Levels of Testing
Whichever testing strategy is followed, both unit and system testing
needs to be performed.

Unit Testing:
In unit testing, each module of the software is tested independently to
locate errors in them. This ensures that the module functions properly as a
unit. This enables the tester to look out for errors in the coding and logic of
that particular alone. The following steps are carried out to ensure the
validity of each module. The module interface is tested to ensure that
information flows properly into and out of the program under test.
The local data structures are examined to ensure that the data stored
temporarily or permanently maintain their integrity. Boundary conditions are
tested to ensure that the module operates properly at the boundaries. All the
independent logical paths that the program takes are exercised to ensure that
all statements in a module have been tested.
All error-handing paths are also tested.
Unit testing focuses on verification and validations effort on the
smallest unit of software design (i.e.) the module.

Integrated Testing

The objective of the integrated testing is to take all the unit tested
modules and combine them into a single, integrated whole and test this
resultant product. This testing enables the tester to ensure that the main
model has been designed as dictated by the software specifications. In this
project all unit tested modules are combined and tested whether perfectly
integrated or not using the concept of test driver and stubs concept in a top
down integration.
System Testing
Implementing software testing in a structured manner involves the
preparation of well-designed test plans and test cases for checking the
functionality of the software. Though mechanisms like automation of test
cases for increasing the efficiency of testing are available that critical
success or success factors of an effective testing lies the test plan and test
case design to meet the objective of testing.
Recovery testing:

The recovery testing is a system testing that forces the software to fail
in a variety of ways and verifies that recovery is properly performed. (While
running the software, if there is no proper connection to the back end, error
message will be fired and on debugging this error could be detected and
rectified).
 10. SYSTEM IMPLEMENTATION

IIS (Internet Information Server)

IIS is a group of Internet server (web or HTTP, FTP and Gopher) and
other capabilities for Microsoft Windows NT server operating system. IIS is
Microsoft bid to dominate the Internet server market that is also addressed
by Netscape, Sun Microsystems and other. With IIS, Microsoft includes a
set of programs for building and administrating web site, a search engine and
support for writing web based applications that access database. Microsoft
points out that IIS is a tightly integrated with the Windows NT server with a
number of ways, resulting in faster web page services.
A typical company that buys IIS can create pages for web sites using
Microsoft Front Page product (with its WYSIWYG user interface). Web
developers can use Microsoft Active server pages (ASP) technology, which
means that applications including Active X control can be embedded web
pages that modify the content sent back to users. Developers can also write
programs that filter request and get the correct web pages for different users
by using Microsoft ISAPI interface. ASP’s and ISAPI programs run more
efficiently that common gateway interface (CGI) and server side interface
(SSI) programs, for current technologies.
Microsoft includes special capabilities for server administrators
designed to appeal to Internet service providers (ISP’S). It includes a single
window (or “console”) from which all services and users can be
administrated. It’s designed to be easy to add components as “snap-ins” that
you didn’t initially install. Individual customers can customizes the
administrative windows for access,
 IIS includes security features and promises that is easy to install. It
works closely with the Microsoft Transaction server to access databases and
provides control at the transaction level. It also work with Microsoft‘s NET
show in the delivery of streaming audio and video, delayed or live. Internet
Information Server 4.0 and windows NT server 4.0 provides the best
platform for developing your website.
Microsoft Internet Information server (IIS) is the only World Wide
Web server that is tightly integrated with the Microsoft Windows NT server
operating system and is designed to deliver the wide range of internet and
intranet server capabilities. By optimizing around the Windows NT server
platform, internet information server delivers high performance excellent
security ease of management and is up and running in minutes. It serves as
best platform for both integrating with existing solutions and for delivering a
new generation of web applications.
Microsoft Internet Information server has established a reputation for
speed, ease of operation, and unparallel integration with Windows NT
server. IIS 4.0 makes I even easier to create rich and dynamic content and to
build server based web applications and, because it is integrated with
windows NT server, you can have a website up and running in minutes. IIS
4.0 is an upgrade to IIS 3.0 and includes the following functionalities:
Active server page (ASP) is an open, compile free application
environment that allows organization to combine HTML, scripts and Active
X sever components to easily build powerful web based applications. Active
server pages include native support for VB script and J script. Active server
page will enable many more people to create server side web application for
the first time.
 Microsoft Index Server is an integrated search engine that provides
full text indexing and querying of documents in any format. It includes built
in support for HTML, text, and Microsoft office documents. Index Server
enables users to quickly locate specific information on their Intranet or
Internet sites.
Microsoft Transaction Server is a component-based transaction
processing system for developing deploying and managing high
performance, scalable, and robust enterprise, Internet, and intranet server
application- programming model for developing distributed component-
based applications. Microsoft News Server for IIS 4.0 uses Network News
Transport Protocol (NNTP) command to define the communication between
hosts.
 11. SYSTEM MAINTENANCE

The objectives of this maintenance work are to make sure that the
system gets into work all time without any bug. Provision must be for
environmental changes which may affect the computer or software system.
This is called the maintenance of the system. Nowadays there is the rapid
change in the software world. Due to this rapid change, the system should be
capable of adapting these changes. In our project the process can be added
without affecting other parts of the system.

Maintenance plays a vital role. The system liable to accept any

modification after its implementation. This system has been designed to
favor all new changes. Doing this will not affect the system’s performance
or its accuracy.
 12. CONCLUSION

The software has been successfully implemented and has been found

to replace the existing system effectively. It has also possible methods to

eliminate the human errors likely to creep in to this kind of work in which

bulk quantity of data has been processed. This application as been designed

to suit exact needs.

It is user friendly providing graphical user interface. Its interface

conforms to the standard windows interface. So the user is at ease the

system. It provides the selection of the data wherever possible instead of

typing it.

The software is developed with scalability in mind. Additional

modules can be easily added when necessary. The software is developed

with modular approach. Additional reports can be easily added. Most of

decision rules are not statically coded. It can be changed running the

software.

As already mentioned no system is perfect. This project has been

developed with the intention to provide the management with useful

software.
 13. Future Enhancement

This system is very flexible and changes can be made without

affecting the existing system according to the future requirements. The
system is designed in such a way that any changes can be made to the
existing module or we can add any new module to the system in future,
without affecting the present one.

The System design is in such a way so that any new development can
make any changes in the future according to the requirements in future. The
system can be upgraded easily to the newer version of the software.

This project can be further developed by

 Adding separate Roles and Authentication.

 This project can also be done in online through ASP.net

 We can also add separate module for Visitors

 We can also add Online voting regarding call center query

 News and Events updates

 We can also add online call center training.

 Forums can also be implemented

 Online Exam schedule information

 Career
 14. BIBILOGRAPHY

Books:

 COMPUTER NETWORKS (Third Edition) by Andrew S

Tanenbaum.

 SOFTWARE ENGINEERING By Roger.S. Pressman, 2nd

Edition

 SQL FOR PROFESSIONALS By Jain, First Eition

 VISUAL BASIC.NET Black Book By Evangeleous Petereous,

First Edition

 ASP.Net Professional By Wrox Publications , 2nd Edition

 MSDN 2002 By Microsoft, First Edition

Website References:

 http://messenger.com/
 http://www.lan-messenger.com/lanmessenger.html
 http://en.kioskea.net/vinitiation/lan.php3
 http://WWW.Wikipedia.Org
 http://en.wikipedia.org/wiki/testing
 World Wide Web Consortium WWW site , (http://w3.org/).
 www.vb.net