Upload
rakesh-yellapragada
View
1.344
Download
0
Tags:
Embed Size (px)
DESCRIPTION
record
Citation preview
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
3.2Activity Diagram
6
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
3.3Sequence Diagram
7
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
3.4Use case Diagram
8
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
import java.net.*;
import java.io.*;
public class Source1 extends JFrame
{
private JLabel jLabel1;
private JLabel jLabel2;
private JLabel jLabel3;
private JLabel jLabel4;
private JTextField jTextField1;
private JTextArea jTextArea1;
private JScrollPane jScrollPane1;
private JProgressBar jProgressBar1;
private JButton jButton1;
private JButton jButton2;
private JButton jButton3;
private JButton jButton4;
private JButton jButton5;
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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));
jLabel2 = new JLabel();
jLabel2.setFont(new Font("Arial",Font.BOLD,12));
jLabel3 = new JLabel();
jLabel3.setFont(new Font("Arial",Font.BOLD,12));
jLabel4 = new JLabel();
jLabel4.setFont(new Font("Arial",Font.BOLD,12));
jTextField1 = new JTextField();
jTextField1.setFont(new Font("Arial",Font.BOLD,12));
28
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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();
jButton2 = new JButton();
jButton3 = new JButton();
jButton4 = new JButton();
jButton5 = new JButton();
contentPane = (JPanel)this.getContentPane();
jLabel1.setForeground(new Color(0, 0, 102));
jLabel1.setText("SOURCE 1");
jLabel2.setForeground(new Color(0, 0, 102));
jLabel2.setText("Status Information");
jLabel3.setForeground(new Color(0, 0, 102));
jLabel3.setText("Open the Source File : ");
jLabel4.setForeground(new Color(0, 0, 102));
jLabel4.setText("");
jTextField1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e)
{
jTextField1_actionPerformed(e);
}
});
29
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
jScrollPane1.setViewportView(jTextArea1);
//jButton1.setBackground(new Color(102, 102, 255));
jButton1.setForeground(new Color(0, 0, 102));
jButton1.setText("Browse");
jButton1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e)
{
jButton1_actionPerformed(e);
}
});
//jButton2.setBackground(new Color(102, 102, 255));
jButton2.setForeground(new Color(0, 0, 102));
jButton2.setText("Channel Encoding");
jButton2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e)
{
jButton2_actionPerformed(e);
}
});
//jButton3.setBackground(new Color(102, 102, 255));
30
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
jButton3.setForeground(new Color(0, 0, 102));
jButton3.setText("Interleaving");
jButton3.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e)
{
jButton3_actionPerformed(e);
}
});
//jButton4.setBackground(new Color(102, 102, 255));
jButton4.setForeground(new Color(0, 0, 102));
jButton4.setText("Send Packets");
jButton4.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e)
{
jButton4_actionPerformed(e);
}
});
//jButton5.setBackground(new Color(102, 102, 255));
jButton5.setForeground(new Color(0, 0, 102));
jButton5.setText("Exit");
jButton5.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e)
31
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
{
jButton5_actionPerformed(e);
}
});
JLabel imageLabel1 = new JLabel();
ImageIcon v1 = new ImageIcon(this.getClass().getResource("packethiding.JPG"));
imageLabel1.setIcon(v1);
imageLabel1.setBounds(400,208,487,200);
add(imageLabel1);
JLabel imageLabel2 = new JLabel();
ImageIcon v2 = new ImageIcon(this.getClass().getResource("Source1.JPG"));
imageLabel2.setIcon(v2);
imageLabel2.setBounds(0,0,1000,100);
add(imageLabel2);
JLabel imageLabel3 = new JLabel();
ImageIcon v3 = new ImageIcon(this.getClass().getResource("hiding.JPG"));
imageLabel3.setIcon(v3);
imageLabel3.setBounds(360,440,628,258);
add(imageLabel3);
contentPane.setLayout(null);
contentPane.setBackground(new Color(204, 54, 100));
contentPane.setForeground(new Color(51, 51, 51));
32
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
//addComponent(contentPane, jLabel1, 285,10,245,18);
addComponent(contentPane, jLabel2, 90,380,184,18);
addComponent(contentPane, jLabel3, 87,100,240,30);
addComponent(contentPane, jLabel4, 27,410,200,20);
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);
addComponent(contentPane, jButton2, 526,130,150,30);
addComponent(contentPane, jButton3, 90,200,120,30);
addComponent(contentPane, jButton4, 90,270,120,30);
addComponent(contentPane, jButton5, 90,340,120,30);
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
{
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********************");
// TODO: Add any handling code here
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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);
}
}
private void jButton2_actionPerformed(ActionEvent e)
{
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
{
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);
}
catch (Exception er)
{
36
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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++)
{
for(j=0;j<filstr[i].length();j++)
{
System.out.print(filsep[i][j]+" ");
}
System.out.print("\n");
try
{
Thread.sleep(2);
}
37
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
catch (Exception er)
{
System.out.println("Sleep Disturbed : "+er);
}
}
//Adding redundant Data to the Binary values
for(i=0;i<flen;i++)
{
for(j=0;j<filstr[i].length();j++)
{
filsep[i][j]=filsep[i][j]+filsep[i][j]+filsep[i][j];
}
}
//Printing the values
for(i=0;i<flen;i++)
{
for(j=0;j<filstr[i].length();j++)
{
System.out.print(filsep[i][j]+" ");
}
System.out.print("\n");
try
{
Thread.sleep(2);
}
38
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
catch (Exception er)
{
System.out.println("Sleep Disturbed : "+er);
}
}
//Merging for Interleaving
for(i=0;i<flen;i++)
{
filmer[i]="";
for(j=0;j<filstr[i].length();j++)
{
filmer[i]+=filsep[i][j];
}
}
//Printing the values
for(i=0;i<flen;i++)
{
System.out.println(filmer[i]+" ");
try
{
Thread.sleep(2);
}
catch (Exception er)
39
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
{
System.out.println("Sleep Disturbed : "+er);
}
}System.out.println("\n************************Channel Encoding Completed****************");
jTextArea1.append("\n\n Channel Encoding Completed");
}
}
private void jButton3_actionPerformed(ActionEvent e)
{
if (k!=10)
{
String msg="Load The File, Complete the Channel Encoding and then Start Interleaving";
JOptionPane op=new JOptionPane();
op.showMessageDialog(op,msg) ;
}
else
{
k=15;
jTextArea1.append("\n\n Interleaving Process Started");
System.out.println("\n***********************Interleaving Started**************");
// TODO: Add any handling code here
//Seperating the String for Interleaving
for(i=0;i<flen;i++)40
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
{
for(j=0;j<filmer[i].length();j++)
{
pakch[i][j]=filmer[i].charAt(j);
}
}
//Printing the values
for(i=0;i<flen;i++)
{
for(j=0;j<filmer[i].length();j++)
{
System.out.print(pakch[i][j]+" ");
}
System.out.print("\n");
try
{
Thread.sleep(2);
}
catch (Exception er)
{
System.out.println("Sleep Disturbed : "+er);
}
}
for(i=0;i<flen;i++)
{
for(j=0;j<1;j++)
41
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
{
if((filmer[i].length())==21)
{
shufch[i][0]=pakch[i][5];
shufch[i][1]=pakch[i][12];
shufch[i][2]=pakch[i][11];
shufch[i][3]=pakch[i][9];
shufch[i][4]=pakch[i][6];
shufch[i][5]=pakch[i][10];
shufch[i][6]=pakch[i][8];
shufch[i][7]=pakch[i][20];
shufch[i][8]=pakch[i][0];
shufch[i][9]=pakch[i][4];
shufch[i][10]=pakch[i][1];
shufch[i][11]=pakch[i][19];
shufch[i][12]=pakch[i][13];
shufch[i][13]=pakch[i][7];
shufch[i][14]=pakch[i][16];
shufch[i][15]=pakch[i][3];
shufch[i][16]=pakch[i][17];
shufch[i][17]=pakch[i][15];
shufch[i][18]=pakch[i][2];
shufch[i][19]=pakch[i][18];
shufch[i][20]=pakch[i][14];
}
else if((filmer[i].length())==18)
42
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
{
shufch[i][0]=pakch[i][5];
shufch[i][1]=pakch[i][12];
shufch[i][2]=pakch[i][11];
shufch[i][3]=pakch[i][9];
shufch[i][4]=pakch[i][6];
shufch[i][5]=pakch[i][10];
shufch[i][6]=pakch[i][8];
shufch[i][7]=pakch[i][0];
shufch[i][8]=pakch[i][4];
shufch[i][9]=pakch[i][1];
shufch[i][10]=pakch[i][15];
shufch[i][11]=pakch[i][7];
shufch[i][12]=pakch[i][16];
shufch[i][13]=pakch[i][3];
shufch[i][14]=pakch[i][17];
shufch[i][15]=pakch[i][13];
shufch[i][16]=pakch[i][2];
shufch[i][17]=pakch[i][14];
}
else
{
shufch[i][0]=pakch[i][5];
shufch[i][1]=pakch[i][11];
shufch[i][2]=pakch[i][10];
shufch[i][3]=pakch[i][9];
43
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
shufch[i][4]=pakch[i][6];
shufch[i][5]=pakch[i][2];
shufch[i][6]=pakch[i][8];
shufch[i][7]=pakch[i][0];
shufch[i][8]=pakch[i][4];
shufch[i][9]=pakch[i][1];
shufch[i][10]=pakch[i][3];
shufch[i][11]=pakch[i][7];
}
}
}
//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)
{
l=(int)(Math.random()*4);
for(int a=31;a<=10;a+=l)
44
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
{
j=(int)(Math.random()*10);
shufch[a][j]='\0';
}
}
else if(flen>=251&&flen<=500)
{
l=(int)(Math.random()*4);
for(int a=110;a<=192;a+=l)
{
j=(int)(Math.random()*10);
shufch[a][j]='\0';
}
}
else if(flen>=501&&flen<=750)
{
l=(int)(Math.random()*4);
for(int a=440;a<=501;a+=l)
{
j=(int)(Math.random()*10);
shufch[a][j]='\0';
}
}
else if(flen>=751&&flen<=1000)
{
l=(int)(Math.random()*4);
45
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
for(int a=652;a<=751;a+=l)
{
j=(int)(Math.random()*10);
shufch[a][j]='\0';
}
}
else
{
l=(int)(Math.random()*4);
for(int a=500;a<=610;a+=l)
{
j=(int)(Math.random()*10);
shufch[a][j]='\0';
}
}
//Printing the values
for(i=0;i<flen;i++)
{
for(j=0;j<filmer[i].length();j++)
{
System.out.print(shufch[i][j]+" ");
}
System.out.print("\n");
try
{
46
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
Thread.sleep(2);
}
catch (Exception er)
{
System.out.println("Sleep Disturbed : "+er);
}
}
//Merging for Transfering
for(i=0;i<flen;i++)
{
filtfr[i]="";
for(j=0;j<filmer[i].length();j++)
{
filtfr[i]+=shufch[i][j];
}
}
for(i=0;i<flen;i++)
{
System.out.println("Packet ["+i+"] = "+filtfr[i]);
try
{
Thread.sleep(2);
}
catch (Exception er)
{
47
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
System.out.println("Sleep Disturbed : "+er);
}
}
System.out.println("\n********************Interleaving Completed**************");
jTextArea1.append("\n\n Interleaving Process Completed");
}
}
private void jButton4_actionPerformed(ActionEvent e)
{
if (k!=15)
{
final ImageIcon icon = new ImageIcon("attack.png");
JOptionPane op=new JOptionPane();
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
// TODO: Add any handling code here
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]);
}
}
catch (Exception er)
{
System.out.println(er);
}
jTextArea1.append("\n\n Packets Sent to Destination");
System.out.println("\nSending Packets Completed");
49
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
}
}
private void jButton5_actionPerformed(ActionEvent e)
{
System.out.println("\nExit");
// TODO: Add any handling code here
System.exit(0);
}
public static void main(String[] args)
{
new Source1();
}
}
9.RESULTS
Screen shots
50
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
51
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
52
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
[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
Packet-Hiding Methods for Preventing Selective Jamming Attacks Y11MC20031
http://www.java2s.com/
57