packet-hiding methods for preventing selective jamming attacks

Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031

1. INTRODUCTION

Wireless networks rely on the uninterrupted availability of the wireless medium to

interconnect participating nodes. However, the open nature of this medium leaves it

vulnerable to multiple security threats. Anyone with a transceiver can eavesdrop on wireless

transmissions, inject spurious messages, or jam legitimate ones. While eavesdropping and

message injection can be prevented using cryptographic methods, jamming attacks are much

harder to counter. They have been shown to actualize severe Denial-of-Service (DoS) attacks

against wireless networks. In the simplest form of jamming, the adversary interferes with the

reception of messages by transmitting a continuous jamming signal, or several short jamming

pulses. Typically, jamming attacks have been considered under an external threat model, in

which the jammer is not part of the network. Under this model, jamming strategies include

the continuous or random transmission of high-power interference signals. However,

adopting an “always-on” strategy has several disadvantages. First, the adversary has to

expend a significant amount of energy to jam frequency bands of interest. Second, the

continuous presence of unusually high interference levels makes this type of attacks easy to

detect. Conventional anti-jamming techniques rely extensively on spread-spectrum (SS)

communications, or some form of jamming evasion (e.g., slow frequency hopping, or spatial

retreats). SS techniques provide bit-level protection by spreading bits according to a secret

pseudo-noise (PN) code, known only to the communicating parties. These methods can only

protect wireless transmissions under the external threat model. Potential disclosure of secrets

due to node compromise neutralizes the gains of SS. Broadcast communications are

particularly vulnerable under an internal threat model because all intended receivers must be

aware of the secrets used to protect transmissions. Hence, the compromise of a single receiver

is sufficient to reveal relevant cryptographic information. In this paper, we address the

problem of jamming under an internal threat model. We consider a sophisticated adversary

who is aware of network secrets and the implementation details of network protocols at any

layer in the network stack. The adversary exploits his internal knowledge for launching

selective jamming attacks in which specific messages of “high importance” are targeted. For

example, a jammer can target route-request/route-reply messages at the routing layer to

prevent route discovery, or target TCP acknowledgments in a TCP session to severely

degrade the throughput of an end-to-end flow. To launch selective jamming attacks, the

1


adversary must be capable of implementing a “classify-then-jam” strategy before the

completion of a wireless transmission. Such strategy can be actualized either by classifying

transmitted packets using protocol semantics, or by decoding packets on the fly. In the latter

method, the jammer may decode the first few bits of a packet for recovering useful packet

identifiers such as packet type, source and destination address. After classification, the

adversary must induce a sufficient number of bit errors so that the packet cannot be recovered

at the receiver. Selective jamming requires an intimate knowledge of the physical (PHY)

layer, as well as of the specifics of upper layers.

2


2. SYSTEM ANALYSIS

2.1Algorithm

1. Symmetric encryption algorithm

2. Brute force attacks against block encryption algorithms

Algorithm Description

We propose a solution based on All-Or- Nothing Transformations (AONT) that introduces a

modest communication and computation overhead. Such transformations were originally

proposed by Rivest to slow down brute force attacks against block encryption algorithms . An

AONT serves as a publicly known and completely invertible pre-processing step to a

plaintext before it is passed to an ordinary block encryption algorithm.

2.2Existing System

Jamming attacks are much harder to counter and more security problems. They have

been shown to actualize severe Denial-of-Service (DoS) attacks against wireless networks. In

the simplest form of jamming, the adversary interferes with the reception of messages by

transmitting a continuous jamming signal , or several short jamming pulses jamming attacks

have been considered under an external threat model, in which the jammer is not part of the 3


network. Under this model, jamming strategies include the continuous or random

transmission of highpower interference signals

2.3Proposed System

In this paper, we address the problem of jamming under an internal threat model. We

consider a sophisticated adversary who is aware of network secrets and the implementation

details of network protocols at any layer in the network stack. The adversary exploits his

internal knowledge for launching selective jamming attacks in which specific messages of

“high importance” are targeted. For example, a jammer can target route-request/route-reply

messages at the routing layer to prevent route discovery, or target TCP acknowledgments in a

TCP session to severely degrade the throughput of an end-to-end flow

To launch selective jamming attacks, the adversary must be capable of implementing a

“classify-then-jam” strategy before the completion of a wireless transmission. Such strategy

can be actualized either by classifying transmitted packets using protocol semantics, or by

decoding

packets on the fly. In the latter method, the jammer may decode the first few bits of a packet

for recovering useful packet identifiers such as packet type, source and destination address.

After classification, the adversary must induce a sufficient number of bit errors so that the

packet cannot be recovered at the receiver [34]. Selective jamming requires an intimate

knowledge of the physical (PHY) layer, as well as of the specifics of upper layers

4


3.SYSTEM DESIGN AND ARHITECTURE

The DFD is also called as bubble chart. It is a simple graphical formalism

that can be used to represent a system in terms of the input data to the system,

various processing carried out on these data, and the output data is generated by

the system.

3.1Architecture

5


3.2Activity Diagram

6


3.3Sequence Diagram

7


3.4Use case Diagram

8


4.IMPLEMENTATION

Implementation is the stage of the project when the theoretical design is turned out into a working system. Thus it can be considered to be the most critical stage in achieving a successful new system and in giving the user, confidence that the new system will work and be effective.

The implementation stage involves careful planning, investigation of the existing system and it’s constraints on implementation, designing of methods to achieve changeover and evaluation of changeover methods.

Modules:-

1. Network module

2. Real Time Packet Classification

3. Selective Jamming Module

4.1 Network module–

We address the problem of preventing the jamming node from classifying m in real time, thus

mitigating J’s ability to perform selective jamming.

The network consists of a collection of nodes connected via wireless links. Nodes may

communicate directly if they are within communication range, or indirectly via multiple hops.

Nodes communicate both in unicast mode and broadcast mode. Communications can be

9


either unencrypted or encrypted. For encrypted broadcast communications, symmetric keys

are shared among all intended receivers. These keys are established using preshared pairwise

keys or asymmetric cryptography.

4.2Real Time Packet Classification

Consider the generic communication system depicted in Fig. At the PHY layer, a packet m is

encoded, interleaved, and modulated before it is transmitted over the wireless channel. At the

receiver, the signal is demodulated, deinterleaved, and decoded, to recover the original packet

m.

Moreover, even if the encryption key of a hiding scheme were to remain secret, the static

portions of a transmitted packet could potentially lead to packet classification. This is because

for computationally-efficient encryption methods such as block encryption, the encryption of

a prefix plaintext with the same key yields a static ciphertext prefix. Hence, an adversary who

is aware of the underlying protocol specifics (structure of the frame) can use the static

ciphertext portions of a transmitted packet to classify it.

4.3 Selective Jamming Module10


We illustrate the impact of selective jamming attacks on the network performance.

implement selective jamming attacks in two multi-hop wireless network scenarios. In the first

scenario, the attacker targeted a TCP connection established over a multi-hop wireless route.

In the second scenario, the jammer targeted network-layer control messages transmitted

during the route establishment process

selective jamming would be the encryption of transmitted packets (including headers) with a

static key. However, for broadcast communications, this static decryption key must be known

to all intended receivers and hence, is susceptible to compromise. An adversary in possession

of the decryption key can start decrypting as early as the reception of the first ciphertext

block.

5. System Specifications

11


Hardware Requirements:

• System : Pentium IV 2.4 GHz.

• Hard Disk : 40 GB.

• Floppy Drive : 1.44 Mb.

• Monitor : 15 VGA Colour.

• Mouse : Logitech.

• Ram : 256 Mb.

Software Requirements:

Operating system : Windows XP Professional

Plat form: Java (jdk 1.6)

API : SWINGS, RMI

6.Software Environment12


Java Technology

Java technology is both a programming language and a platform.

The Java Programming Language

The Java programming language is a high-level language that can be characterized by

all of the following buzzwords:

Simple

Architecture neutral

Object oriented

Portable

Distributed

High performance

Interpreted

Multithreaded

Robust

Dynamic

Secure

With most programming languages, you either compile or interpret a program so that

you can run it on your computer. The Java programming language is unusual in that a

program is both compiled and interpreted. With the compiler, first you translate a program

into an intermediate language called Java byte codes —the platform-independent codes

interpreted by the interpreter on the Java platform. The interpreter parses and runs each Java

byte code instruction on the computer. Compilation happens just once; interpretation occurs

each time the program is executed. The following figure illustrates how this works.

13


You can think of Java byte codes as the machine code instructions for the Java

Virtual Machine (Java VM). Every Java interpreter, whether it’s a development tool or a Web

browser that can run applets, is an implementation of the Java VM. Java byte codes help

make “write once, run anywhere” possible. You can compile your program into byte codes on

any platform that has a Java compiler. The byte codes can then be run on any implementation

of the Java VM. That means that as long as a computer has a Java VM, the same program

written in the Java programming language can run on Windows 2000, a Solaris workstation,

or on an iMac.

The Java Platform

A platform is the hardware or software environment in which a program runs.

We’ve already mentioned some of the most popular platforms like Windows 2000,

Linux, Solaris, and MacOS. Most platforms can be described as a combination of the

operating system and hardware. The Java platform differs from most other platforms

14


in that it’s a software-only platform that runs on top of other hardware-based

platforms.

The Java platform has two components:

The Java Virtual Machine (Java VM)

The Java Application Programming Interface (Java API)

You’ve already been introduced to the Java VM. It’s the base for the Java

platform and is ported onto various hardware-based platforms.

The Java API is a large collection of ready-made software components that

provide many useful capabilities, such as graphical user interface (GUI) widgets. The

Java API is grouped into libraries of related classes and interfaces; these libraries are

known as packages. The next section, What Can Java Technology Do? Highlights

what functionality some of the packages in the Java API provide.

The following figure depicts a program that’s running on the Java platform. As the

figure shows, the Java API and the virtual machine insulate the program from the

hardware.

Native code is code that after you compile it, the compiled code runs on a

specific hardware platform. As a platform-independent environment, the Java

platform can be a bit slower than native code. However, smart compilers, well-tuned

interpreters, and just-in-time byte code compilers can bring performance close to that

of native code without threatening portability.

What Can Java Technology Do?

The most common types of programs written in the Java programming language are

applets and applications. If you’ve surfed the Web, you’re probably already familiar

with applets. An applet is a program that adheres to certain conventions that allow it

to run within a Java-enabled browser.

However, the Java programming language is not just for writing cute, entertaining

applets for the Web. The general-purpose, high-level Java programming language is

also a powerful software platform. Using the generous API, you can write many types

of programs.

15


An application is a standalone program that runs directly on the Java platform. A

special kind of application known as a server serves and supports clients on a

network. Examples of servers are Web servers, proxy servers, mail servers, and print

servers. Another specialized program is a servlet. A servlet can almost be thought of

as an applet that runs on the server side. Java Servlets are a popular choice for

building interactive web applications, replacing the use of CGI scripts. Servlets are

similar to applets in that they are runtime extensions of applications. Instead of

working in browsers, though, servlets run within Java Web servers, configuring or

tailoring the server.

How does the API support all these kinds of programs? It does so with packages of

software components that provides a wide range of functionality. Every full

implementation of the Java platform gives you the following features:

The essentials: Objects, strings, threads, numbers, input and output, data

structures, system properties, date and time, and so on.

Applets: The set of conventions used by applets.

Networking: URLs, TCP (Transmission Control Protocol), UDP (User Data

gram Protocol) sockets, and IP (Internet Protocol) addresses.

Internationalization: Help for writing programs that can be localized for

users worldwide. Programs can automatically adapt to specific locales and be

displayed in the appropriate language.

Security: Both low level and high level, including electronic signatures,

public and private key management, access control, and certificates.

Software components: Known as JavaBeansTM, can plug into existing

component architectures.

Object serialization: Allows lightweight persistence and communication via

Remote Method Invocation (RMI).

Java Database Connectivity (JDBCTM): Provides uniform access to a wide

range of relational databases.

The Java platform also has APIs for 2D and 3D graphics, accessibility, servers,

collaboration, telephony, speech, animation, and more. The following figure depicts

what is included in the Java 2 SDK.

16


ODBC

Microsoft Open Database Connectivity (ODBC) is a standard programming interface

for application developers and database systems providers. Before ODBC became a de facto

standard for Windows programs to interface with database systems, programmers had to use

proprietary languages for each database they wanted to connect to. Now, ODBC has made the

choice of the database system almost irrelevant from a coding perspective, which is as it

should be. Application developers have much more important things to worry about than the

syntax that is needed to port their program from one database to another when business needs

suddenly change.

Through the ODBC Administrator in Control Panel, you can specify the particular

database that is associated with a data source that an ODBC application program is written to

use. Think of an ODBC data source as a door with a name on it. Each door will lead you to a

particular database. For example, the data source named Sales Figures might be a SQL Server

database, whereas the Accounts Payable data source could refer to an Access database. The

physical database referred to by a data source can reside anywhere on the LAN.

The ODBC system files are not installed on your system by Windows 95. Rather, they

are installed when you setup a separate database application, such as SQL Server Client or

Visual Basic 4.0. When the ODBC icon is installed in Control Panel, it uses a file called

ODBCINST.DLL. It is also possible to administer your ODBC data sources through a stand-

alone program called ODBCADM.EXE. There is a 16-bit and a 32-bit version of this

program and each maintains a separate list of ODBC data sources.

17


From a programming perspective, the beauty of ODBC is that the application can be

written to use the same set of function calls to interface with any data source, regardless of

the database vendor. The source code of the application doesn’t change whether it talks to

Oracle or SQL Server. We only mention these two as an example. There are ODBC drivers

available for several dozen popular database systems. Even Excel spreadsheets and plain text

files can be turned into data sources. The operating system uses the Registry information

written by ODBC Administrator to determine which low-level ODBC drivers are needed to

talk to the data source (such as the interface to Oracle or SQL Server). The loading of the

ODBC drivers is transparent to the ODBC application program. In a client/server

environment, the ODBC API even handles many of the network issues for the application

programmer.

The advantages of this scheme are so numerous that you are probably thinking there

must be some catch. The only disadvantage of ODBC is that it isn’t as efficient as talking

directly to the native database interface. ODBC has had many detractors make the charge that

it is too slow. Microsoft has always claimed that the critical factor in performance is the

quality of the driver software that is used. In our humble opinion, this is true. The availability

of good ODBC drivers has improved a great deal recently. And anyway, the criticism about

performance is somewhat analogous to those who said that compilers would never match the

speed of pure assembly language. Maybe not, but the compiler (or ODBC) gives you the

opportunity to write cleaner programs, which means you finish sooner. Meanwhile,

computers get faster every year.

JDBC

In an effort to set an independent database standard API for Java; Sun Microsystems

developed Java Database Connectivity, or JDBC. JDBC offers a generic SQL database access

mechanism that provides a consistent interface to a variety of RDBMSs. This consistent

interface is achieved through the use of “plug-in” database connectivity modules, or drivers.

If a database vendor wishes to have JDBC support, he or she must provide the driver for each

platform that the database and Java run on.

To gain a wider acceptance of JDBC, Sun based JDBC’s framework on ODBC. As

you discovered earlier in this chapter, ODBC has widespread support on a variety of

platforms. Basing JDBC on ODBC will allow vendors to bring JDBC drivers to market much

faster than developing a completely new connectivity solution. 18


JDBC was announced in March of 1996. It was released for a 90 day public review

that ended June 8, 1996. Because of user input, the final JDBC v1.0 specification was

released soon after.

The remainder of this section will cover enough information about JDBC for you to know

what it is about and how to use it effectively. This is by no means a complete overview of

JDBC. That would fill an entire book.

Networking

TCP/IP stack

The TCP/IP stack is shorter than the OSI one:

TCP is a connection-oriented protocol; UDP (User Datagram Protocol) is a

connectionless protocol.

IP datagram’s

The IP layer provides a connectionless and unreliable delivery system. It

considers each datagram independently of the others. Any association between

datagram must be supplied by the higher layers. The IP layer supplies a checksum

19


that includes its own header. The header includes the source and destination

addresses. The IP layer handles routing through an Internet. It is also responsible for

breaking up large datagram into smaller ones for transmission and reassembling

them at the other end.

UDP

UDP is also connectionless and unreliable. What it adds to IP is a checksum for

the contents of the datagram and port numbers. These are used to give a

client/server model - see later.

TCP

TCP supplies logic to give a reliable connection-oriented protocol above IP. It

provides a virtual circuit that two processes can use to communicate.

Internet addresses

In order to use a service, you must be able to find it. The Internet uses an

address scheme for machines so that they can be located. The address is a 32 bit

integer which gives the IP address. This encodes a network ID and more addressing.

The network ID falls into various classes according to the size of the network

address.

Network address

Class A uses 8 bits for the network address with 24 bits left over for other

addressing. Class B uses 16 bit network addressing. Class C uses 24 bit network

addressing and class D uses all 32.

20


Subnet address

Internally, the UNIX network is divided into sub networks. Building 11 is

currently on one sub network and uses 10-bit addressing, allowing 1024 different

hosts.

Host address

8 bits are finally used for host addresses within our subnet. This places a limit of

256 machines that can be on the subnet.

Total address

The 32 bit address is usually written as 4 integers separated by dots.

Port addresses

A service exists on a host, and is identified by its port. This is a 16 bit number.

To send a message to a server, you send it to the port for that service of the host that

it is running on. This is not location transparency! Certain of these ports are "well

known".

21


Sockets

A socket is a data structure maintained by the system to handle network

connections. A socket is created using the call socket. It returns an integer that is

like a file descriptor. In fact, under Windows, this handle can be used with Read

File and Write File functions.

#include <sys/types.h>#include <sys/socket.h>int socket(int family, int type, int protocol);

Here "family" will be AF_INET for IP communications, protocol will be zero,

and type will depend on whether TCP or UDP is used. Two processes wishing to

communicate over a network create a socket each. These are similar to two ends of

a pipe - but the actual pipe does not yet exist.

7. SYSTEM TESTING

The purpose of testing is to discover errors. Testing is the process of trying to discover

every conceivable fault or weakness in a work product. It provides a way to check the

functionality of components, sub assemblies, assemblies and/or a finished product It is the

process of exercising software with the intent of ensuring that the Software system meets its

22


requirements and user expectations and does not fail in an unacceptable manner. There are

various types of test. Each test type addresses a specific testing requirement.

TYPES OF TESTS

Unit testing

Unit testing involves the design of test cases that validate that the internal program

logic is functioning properly, and that program inputs produce valid outputs. All decision

branches and internal code flow should be validated. It is the testing of individual software

units of the application .it is done after the completion of an individual unit before

integration. This is a structural testing, that relies on knowledge of its construction and is

invasive. Unit tests perform basic tests at component level and test a specific business

process, application, and/or system configuration. Unit tests ensure that each unique path of a

business process performs accurately to the documented specifications and contains clearly

defined inputs and expected results.

Integration testing

Integration tests are designed to test integrated software components to determine if

they actually run as one program. Testing is event driven and is more concerned with the

basic outcome of screens or fields. Integration tests demonstrate that although the

components were individually satisfaction, as shown by successfully unit testing, the

combination of components is correct and consistent. Integration testing is specifically aimed

at exposing the problems that arise from the combination of components.

Functional test

Functional tests provide systematic demonstrations that functions tested are available as

specified by the business and technical requirements, system documentation, and user

manuals.23


Functional testing is centered on the following items:

Valid Input : identified classes of valid input must be accepted.

Invalid Input : identified classes of invalid input must be rejected.

Functions : identified functions must be exercised.

Output : identified classes of application outputs must be exercised.

Systems/Procedures: interfacing systems or procedures must be invoked.

Organization and preparation of functional tests is focused on requirements, key functions,

or special test cases. In addition, systematic coverage pertaining to identify Business process

flows; data fields, predefined processes, and successive processes must be considered for

testing. Before functional testing is complete, additional tests are identified and the effective

value of current tests is determined.

System Test

System testing ensures that the entire integrated software system meets requirements. It

tests a configuration to ensure known and predictable results. An example of system testing is

the configuration oriented system integration test. System testing is based on process

descriptions and flows, emphasizing pre-driven process links and integration points.

White Box Testing

White Box Testing is a testing in which in which the software tester has knowledge of

the inner workings, structure and language of the software, or at least its purpose. It is

purpose. It is used to test areas that cannot be reached from a black box level.

Black Box Testing

Black Box Testing is testing the software without any knowledge of the inner workings,

structure or language of the module being tested. Black box tests, as most other kinds of tests,

24


must be written from a definitive source document, such as specification or requirements

document, such as specification or requirements document. It is a testing in which the

software under test is treated, as a black box .you cannot “see” into it. The test provides

inputs and responds to outputs without considering how the software works.

Unit Testing:

Unit testing is usually conducted as part of a combined code and unit test phase of the

software lifecycle, although it is not uncommon for coding and unit testing to be conducted as

two distinct phases.

Test strategy and approach

Field testing will be performed manually and functional tests will be written in detail.

Test objectives

All field entries must work properly.

Pages must be activated from the identified link.

The entry screen, messages and responses must not be delayed.

Features to be tested

Verify that the entries are of the correct format

No duplicate entries should be allowed

All links should take the user to the correct page.

Integration Testing

Software integration testing is the incremental integration testing of two or more

integrated software components on a single platform to produce failures caused by interface

defects.

25


The task of the integration test is to check that components or software applications,

e.g. components in a software system or – one step up – software applications at the company

level – interact without error.

Test Results: All the test cases mentioned above passed successfully. No defects

encountered.

Acceptance Testing

User Acceptance Testing is a critical phase of any project and requires significant

participation by the end user. It also ensures that the system meets the functional

requirements.

Test Results: All the test cases mentioned above passed successfully. No defects

encountered.

8. CODING

SOURCE 1

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

26


import java.net.*;

import java.io.*;

public class Source1 extends JFrame

{

private JLabel jLabel1;




private JTextField jTextField1;

private JTextArea jTextArea1;

private JScrollPane jScrollPane1;

private JProgressBar jProgressBar1;

private JButton jButton1;





private JPanel contentPane;

public String Dest1="";

public byte filebyte[]=new byte[10000];

public int filint[];

public String filstr[];

public String filmer[];

public String filtfr[];

public String filsep[][];

27


public String filorg[];

public char pakch[][];

public char shufch[][];

public int ch;

public int flen;

Socket st;

int i,j,k,l;

public Source1()

{

super();

initializeComponent();

this.setVisible(true);

}

private void initializeComponent()

{

jLabel1 = new JLabel();

jLabel1.setFont(new Font("Arial",Font.BOLD,14));







jTextField1 = new JTextField();

jTextField1.setFont(new Font("Arial",Font.BOLD,12));

28


jTextArea1 = new JTextArea();

jTextArea1.setFont(new Font("Arial",Font.BOLD,12));

jScrollPane1 = new JScrollPane();

jProgressBar1 = new JProgressBar();

jProgressBar1.setMinimum( 0 );

jProgressBar1.setMaximum( 100 );

jButton1 = new JButton();





contentPane = (JPanel)this.getContentPane();

jLabel1.setForeground(new Color(0, 0, 102));

jLabel1.setText("SOURCE 1");


jLabel2.setText("Status Information");


jLabel3.setText("Open the Source File : ");


jLabel4.setText("");

jTextField1.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e)

{

jTextField1_actionPerformed(e);

}

});

29


jScrollPane1.setViewportView(jTextArea1);

//jButton1.setBackground(new Color(102, 102, 255));

jButton1.setForeground(new Color(0, 0, 102));

jButton1.setText("Browse");

jButton1.addActionListener(new ActionListener() {


{

jButton1_actionPerformed(e);

}

});



jButton2.setText("Channel Encoding");



{


}

});


30



jButton3.setText("Interleaving");



{


}

});



jButton4.setText("Send Packets");



{


}

});



jButton5.setText("Exit");



31


{


}

});

JLabel imageLabel1 = new JLabel();

ImageIcon v1 = new ImageIcon(this.getClass().getResource("packethiding.JPG"));

imageLabel1.setIcon(v1);

imageLabel1.setBounds(400,208,487,200);

add(imageLabel1);


ImageIcon v2 = new ImageIcon(this.getClass().getResource("Source1.JPG"));



add(imageLabel2);


ImageIcon v3 = new ImageIcon(this.getClass().getResource("hiding.JPG"));



add(imageLabel3);

contentPane.setLayout(null);

contentPane.setBackground(new Color(204, 54, 100));

contentPane.setForeground(new Color(51, 51, 51));

32


//addComponent(contentPane, jLabel1, 285,10,245,18);

addComponent(contentPane, jLabel2, 90,380,184,18);



addComponent(contentPane, jTextField1, 87,131,240,30);

addComponent(contentPane, jScrollPane1, 17,400,316,303);

//addComponent(contentPane, jProgressBar1, 27,430,600,20);

addComponent(contentPane, jButton1, 376,130,83,32);





this.setTitle("Packet Hiding- Source 1");

//this.setLocation(new Point(0, 450));

this.setSize(new Dimension(1000, 740));

this.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);

}

private void addComponent(Container container,Component c,int x,int y,int width,int height)

{

c.setBounds(x,y,width,height);

container.add(c);

}

private void jTextField1_actionPerformed(ActionEvent e)

33


{

System.out.println("\nBrowse For File");

// TODO: Add any handling code here

}

private void jButton1_actionPerformed(ActionEvent e)

{

k=5;

System.out.println("\n*********************File Loaded********************");


try

{

FileDialog fd=new FileDialog(this,"Open",FileDialog.LOAD);

fd.show();

FileInputStream fin=new FileInputStream(fd.getDirectory()+fd.getFile())

jTextField1.setText(fd.getDirectory()+fd.getFile());

File f = new File(fd.getDirectory()+fd.getFile());

fin.read(filebyte);

flen=(int)f.length();

jTextArea1.setText("\n File Loaded");

filint=new int[flen+1000];

filstr=new String[flen];

34


filmer=new String[flen];

filtfr=new String[flen];

filsep=new String[flen][100];

filorg=new String[flen];

pakch=new char[flen+25][100];

shufch=new char[flen+25][100];

//jTextArea1.append("\n\n File Loaded");

}

catch (Exception er)

{

System.out.println(er);

}

}


{

jTextArea1.append("\n\n Channel Encoding Started");

if (k!=5)

{

String msg="Load The File and then Start Channel Encoding";

JOptionPane op=new JOptionPane();

op.showMessageDialog(op,msg);

}

else

35


{

k=10;

System.out.println("\n************************Channel Encoding Started****************");

//Conversion of Byte to Binary

jTextArea1.append("\n\n Channel Encoding Started");

System.out.println(flen);

for(i=0;i<flen;i++)

{

filint[i]=(int)filebyte[i];

System.out.println("Int Value : ["+i+"] = "+filint[i]);

filstr[i] = Integer.toBinaryString(filint[i]);

//filorg[i] = Integer.toBinaryString(filint[i]);

}

//Printing Binary Values of Each Character

for(i=0;i<flen;i++)

{

System.out.println(filstr[i]);

try

{

Thread.sleep(2);

}


{

36


System.out.println("Sleep Disturbed : "+er);

}

}

//Separation of each binary values in to 2Dimensional String array

for(i=0;i<flen;i++)

{

for(j=0;j<filstr[i].length();j++)

{

filsep[i][j]=Character.toString(filstr[i].charAt(j));

}

}

//Printing This values

for(i=0;i<flen;i++)

{


{

System.out.print(filsep[i][j]+" ");

}

System.out.print("\n");

try

{

Thread.sleep(2);

}

37



{


}

}

//Adding redundant Data to the Binary values

for(i=0;i<flen;i++)

{


{

filsep[i][j]=filsep[i][j]+filsep[i][j]+filsep[i][j];

}

}

//Printing the values

for(i=0;i<flen;i++)

{


{

System.out.print(filsep[i][j]+" ");

}


try

{

Thread.sleep(2);

}

38



{


}

}

//Merging for Interleaving

for(i=0;i<flen;i++)

{

filmer[i]="";


{

filmer[i]+=filsep[i][j];

}

}


for(i=0;i<flen;i++)

{

System.out.println(filmer[i]+" ");

try

{

Thread.sleep(2);

}


39


{


}

}System.out.println("\n************************Channel Encoding Completed****************");

jTextArea1.append("\n\n Channel Encoding Completed");

}

}


{

if (k!=10)

{

String msg="Load The File, Complete the Channel Encoding and then Start Interleaving";


op.showMessageDialog(op,msg) ;

}

else

{

k=15;

jTextArea1.append("\n\n Interleaving Process Started");

System.out.println("\n***********************Interleaving Started**************");


//Seperating the String for Interleaving

for(i=0;i<flen;i++)40


{

for(j=0;j<filmer[i].length();j++)

{

pakch[i][j]=filmer[i].charAt(j);

}

}


for(i=0;i<flen;i++)

{


{

System.out.print(pakch[i][j]+" ");

}


try

{

Thread.sleep(2);

}


{


}

}

for(i=0;i<flen;i++)

{

for(j=0;j<1;j++)

41


{

if((filmer[i].length())==21)

{

shufch[i][0]=pakch[i][5];





















}

else if((filmer[i].length())==18)

42


{



















}

else

{





43










}

}

}

//Bottle neck

if(flen<=50)

{

l=(int)(Math.random()*3);

for(int a=0;a<=3;a+=l)

{

j=(int)(Math.random()*10);

shufch[a][j]='\0';

}

}

else if(flen>=51&&flen<=210)

{


for(int a=31;a<=10;a+=l)

44


{


shufch[a][j]='\0';

}

}


{


for(int a=110;a<=192;a+=l)

{


shufch[a][j]='\0';

}

}


{


for(int a=440;a<=501;a+=l)

{


shufch[a][j]='\0';

}

}


{


45


for(int a=652;a<=751;a+=l)

{


shufch[a][j]='\0';

}

}

else

{


for(int a=500;a<=610;a+=l)

{


shufch[a][j]='\0';

}

}


for(i=0;i<flen;i++)

{


{

System.out.print(shufch[i][j]+" ");

}


try

{

46


Thread.sleep(2);

}


{


}

}

//Merging for Transfering

for(i=0;i<flen;i++)

{

filtfr[i]="";


{

filtfr[i]+=shufch[i][j];

}

}

for(i=0;i<flen;i++)

{

System.out.println("Packet ["+i+"] = "+filtfr[i]);

try

{

Thread.sleep(2);

}


{

47



}

}

System.out.println("\n********************Interleaving Completed**************");

jTextArea1.append("\n\n Interleaving Process Completed");

}

}


{

if (k!=15)

{

final ImageIcon icon = new ImageIcon("attack.png");


op.showMessageDialog(null, "Complete the Channel Encoding, Interleaving and then Send the Packets", "Message", JOptionPane.INFORMATION_MESSAGE, icon);

//String msg="Complete the Channel Encoding, Interleaving and then Send the Packets";

//JOptionPane op=new JOptionPane();

//op.showMessageDialog(op,msg) ;

}

else

{

jTextArea1.append("\n\n Sending Packets to Destination");

System.out.println("\nSending Packets Started");48



try

{

Dest1="";

FileInputStream fis=new FileInputStream("QueueAddress.txt");

while((ch=fis.read())!=-1)

Dest1+=(char)ch;

Dest1.trim();

System.out.println("The Address of Destination : "+Dest1);

st=new Socket(Dest1,4500);

DataOutputStream dos=new DataOutputStream(st.getOutputStream());

dos.writeInt(flen);

dos.writeUTF("Dest1");

for(i=0;i<flen;i++)

{

dos.writeUTF(filtfr[i]);

}

}


{

System.out.println(er);

}

jTextArea1.append("\n\n Packets Sent to Destination");

System.out.println("\nSending Packets Completed");

49


}

}


{

System.out.println("\nExit");


System.exit(0);

}

public static void main(String[] args)

{

new Source1();

}

}

9.RESULTS

Screen shots

50


51


52


10.CONCLUSION

We addressed the problem of selective jamming attacks in wireless networks. We considered

an internal adversary model in which the jammer is part of the network under attack, thus

being aware of the protocol specifications and shared network secrets. We showed that the

jammer can classify transmitted packets in real time by decoding the first few symbols of an

ongoing transmission. We evaluated the impact of selective jamming attacks on network

protocols such as TCP and routing. Our findings show that a selective jammer can

significantly impact performance with very low effort. We developed three schemes that

transform a selective jammer to a random one by preventing real-time packet classification.

Our schemes combine cryptographic primitives such as commitment schemes, cryptographic

53


puzzles, and all-or-nothing transformations (AONTs) with physical layer characteristics. We

analyzed the security of our schemes and quantified their computational and communication

overhead.

11. BIBLIOGRAPHY

Good Teachers are worth more than thousand books, we have them in Our Department

1. Abbreviations

OOPS Object Oriented Programming Concepts

TCP/IP Transmission Control Protocol/Internet Protocol

JDBC Java Data Base Connectivity

EIS Enterprise Information Systems

54


BIOS Basic Input/Output System

RMI Remote Method Invocation

JNDI Java Naming and Directory Interface

ORDBMS Object Relational Database Management System

2. References Made From:

[1] T. X. Brown, J. E. James, and A. Sethi. Jamming and sensing of encrypted wireless ad

hoc networks. In Proceedings of MobiHoc, pages 120–130, 2006.

[2] M. Cagalj, S. Capkun, and J.-P. Hubaux. Wormhole-based antijamming techniques in

sensor networks. IEEE Transactions on Mobile Computing, 6(1):100–114, 2007.

[3] A. Chan, X. Liu, G. Noubir, and B. Thapa. Control channel jamming: Resilience and

identification of traitors. In Proceedings of ISIT, 2007.

[4] T. Dempsey, G. Sahin, Y. Morton, and C. Hopper. Intelligent sensing and classification in

ad hoc networks: a case study. Aerospace and Electronic Systems Magazine, IEEE, 24(8):23–

30, August 2009.

[5] Y. Desmedt. Broadcast anti-jamming systems. Computer Networks, 35(2-3):223–236,

February 2001.

[6] K. Gaj and P. Chodowiec. FPGA and ASIC implementations of AES. Cryptographic

Engineering, pages 235–294, 2009.

[7] O. Goldreich. Foundations of cryptography: Basic applications. Cambridge University

Press, 2004.

[8] B. Greenstein, D. Mccoy, J. Pang, T. Kohno, S. Seshan, and D. Wetherall. Improving

wireless privacy with an identifier-free link layer protocol. In Proceedings of MobiSys, 2008.

[9]IEEE.IEEE802.11standard. http://standards.ieee.org/getieee802/ download/802.11-

2007.pdf, 2007.

55

http://standards.ieee.org/getieee802/


[10] A. Juels and J. Brainard. Client puzzles: A cryptographic countermeasure against

connection depletion attacks. In Proceedings of NDSS, pages 151–165, 1999.

[11] Y. W. Law, M. Palaniswami, L. V. Hoesel, J. Doumen, P. Hartel, and P. Havinga.

Energy-efficient link-layer jamming attacks against WSN MAC protocols. ACMTransactions

on Sensors Networks, 5(1):1–38, 2009.

[12] L. Lazos, S. Liu, and M. Krunz. Mitigating control-channel jamming attacks in multi-

channel ad hoc networks. In Proceedings of the 2nd ACM conference on wireless network

security, pages 169–180, 2009.

[13] G. Lin and G. Noubir. On link layer denial of service in data wireless LANs. Wireless

Communications and Mobile Computing, 5(3):273–284, May 2004.

[14] X. Liu, G. Noubir, and R. Sundaram. Spread: Foiling smart jammers using multi-layer

agility. In Proceedings of INFOCOM, pages 2536– 2540, 2007.

[15] Y. Liu, P. Ning, H. Dai, and A. Liu. Randomized differential DSSS: Jamming-resistant

wireless broadcast communication. In Proceedings of INFOCOM, San Diego, 2010.

[16] R. C. Merkle. Secure communications over insecure channels. Com- munications of the

ACM, 21(4):294–299, 1978.

[17] G. Noubir and G. Lin. Low-power DoS attacks in data wireless lans and

countermeasures. Mobile Computing and Communications Review, 7(3):29–30, 2003.

3. Sites Referred:

http://java.sun.com

http://www.sourcefordgde.com

http://www.networkcomputing.com/

http://www.roseindia.com/

56

http://www.roseindia.com/

http://www.networkcomputing.com/

http://www.sourcefordgde.com/

http://java.sun.com/


http://www.java2s.com/

57

http://www.java2s.com/