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 a 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 project, 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

1
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. Selective jamming
requires an intimate knowledge of the physical (PHY) layer, as well as of the
specifics of upper layers.

2
 2. LITERATURE REVIEW

In this section, references of previous research that utilized the concepts in

Introduction are introduced. For each of the concepts, an overview of related
literature is provided. In section 2.1, WLAN is introduced. Specifically, client-
server and ad-hoc networks are explained. In section 2.2, DoS attacks, especially
jamming attacks are presented. In Section 2.3, detection methods of jamming
attacks are analyzed.

2.1 WLAN – Client-Server & Ad-Hoc Network

Because WLAN provides users the mobility to move around within a local area
without a wire and still connect to the network, it is widely used in many important
areas. Banks, governments, corporations, and institutions transmit highly important
data through WLANs. The security problems of WLANs become important for the
users. Most WLANs are based on the IEEE 802.11 standard, which transmits data
in different channels based on frequencies. Due to the ease of installation and
convenience, WLAN is regularly used in daily life. An introduction of WLANs
was done by Gast (2005) and Mark (2005). They presented basic wireless LAN
technology, why the technology had emerged, how it works, the architecture of
WLANs, and the types of WLANs. Because of the popularity of WLANs, security
research must be done in various types of WLANs. Experiments were done by
Varadarajan, Kumar, and Reddy (2011) about improving WLAN performance
under DoS attacks. DoS attacks on the physical layer were analyzed and expanded
to the security of the physical layer of the sensor network model. This research was
done by using the ant system. By using Receiver Operating Characteristics (ROC)
on nodes, DoS 8 attacks can be predicted by formulating the classification of
jammers under various attack scenarios. This approach can help improving
detecting DoS attacks in WLANs. Research in this thesis was focuses on two types
of WLANs: client-server and ad-hoc networks.

3
2.2 Jamming Attacks
The DNS is a hierarchical tree structure whose root node is known as the root
domain. A label in a DNS name directly corresponds with a node in the DNS tree
structure. A label is an alphanumeric string that uniquely identifies that node from
its brothers. Labels are connected together with a dot notation, ".", and a DNS
name containing multiple labels represents its path along the tree to the root.
Labels are written from left to right. Only one zero length label is allowed and is
reserved for the root of the tree. This is commonly referred to as the root zone. Due
to the root label being zero length, all FQDNs end in a dot [RFC 1034].A study
into DoS attacks and defense was done by Raymond and Midkiff (2008). Since
WSNs are used in monitoring medical uses, homeland security, industrial
automation, and military applications, security of WSNs must be guaranteed.
Defeating many threats of DoS attacks on WSNs can be done by encryption and
authentication, but some other techniques still need to be found to prevent from
special DoS attacks, especially Denial of Sleep attacks, which are still critical
threats in WSNs.

2.3 Detection of Jamming

WLANs are built upon a shared medium that makes it easy to launch jamming
attacks. These attacks can be easily accomplished by sending radio frequency
signals that do not follow any MAC protocols. Detection of jamming attacks can
be done in multiple ways. One of the most efficient ways is to jump channels.
Because communication between two legitimate nodes is done through a specific
frequency, the frequency can be changed if necessary. While a jammer is attacking
the wireless network, there are other effective ways to continue legitimate
communication in the network. Engaging the jammer on the jammed channel and
continuing communication in another channel was introduced by Beg, Ahsan, and
Mohsin (2010). When the nodes detected the jamming in the wireless network,
they jumped to another channel to continue legitimate communication. In the
experiments, both 10 and 20 nodes experiments were done, and in both scenarios,

4
after channels were jumped, the network resumes communications as normal. In
both scenarios, the amount of packets dropped reduced immediately. The research
concluded that channel jumping will decrease the throughput of the network. Also,
it was easier to detect jamming through intermitted channel jumping. Concluded,
channel jumping was a superior method of combating network interference, rather
than changing network protocols (Jeung, Jeong, and Lim, 2011).The research
concluded that channel jumping will decrease the throughput of the network. Also,
it was easier to detect jamming through intermitted channel jumping. Concluded,
channel jumping was a superior method of combating network interference, rather
than changing network protocols (Jeung, Jeong, and Lim, 2011).

In order to prevent from multi-channel jamming attacks, a cross-layer

jamming detection method was developed (Chiang and Hu, 2011). Cross-layer
jamming detection is a tree-based approach. A jamming detection algorithm was
utilized in all legitimate nodes; when the communication process began, all the
nodes had the ability to report jamming attacks in different layers, and only the
reports which were generated by nodes with jamming detection algorithm were
accepted by the system in order to avoid error. Research was also done about
multi-channel jamming attacks by Jiang and Xue (2010). The difference from the
jamming detection algorithm was that it focused on network restoration and design
of traffic rerouting.

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 [12],
[17], [36], [37]. In the simplest form of jamming, the adversary interferes with the
reception of messages by transmitting a continuous jamming signal [25], or several
short jamming pulses [17].
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

5
strategies include the continuous or random transmission of high-power
interference signals [25], [36]. 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 [17],
[36], [37].

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

communications [25], or some form of jamming evasion (e.g., slow frequency
hopping, or spatial retreats [37]). 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 un-der 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.

6
 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 [1], [33], or by decoding packets on the fly [34].
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.

7
 3. ANALYSIS AND DESIGN

3.1 ALGORITHMS

1. Symmetric encryption algorithm

2. Brute force attacks against block encryption algorithms

Algorithm Description

Fig 1: Algorithm

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.

8
3.2 ARCHITECTURE:

Fig 2: Architecture

Fig 2.1: selective jamming attack and a frame format for wireless network

9
3.3 EXISTING 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 network. Under this model,
jamming strategies include the continuous or random transmission of high power
interference signals

3.4 PROPOSED SYSTEM

In this project, 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.

10
3.5 DESIGN

Flow Diagram

The Flow diagram 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.

Architecture

Fig 2: Architecture

11
Use case Diagram

Fig 3: Use Case Diagram

12
Activity Diagram

Fig 4: Activity Diagram

13
Sequence Diagram

Fig 5: Sequence Diagram

14
 4. METHODOLOGY

Methodology 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. Strong Hiding Commitment Scheme (SHCS)

5. Cryptographic Puzzle Hiding Scheme (CPHS)

Module Descriptions

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

15
via multiple hops. Nodes communicate both in unicast mode and broadcast mode.
Communications can be either unencrypted or encrypted. For encrypted broadcast
communications, symmetric keys are shared among all intended receivers. These
keys are established using pre-shared pair wise keys or asymmetric cryptography.

2. Real 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, de-interleaved, and
decoded, to recover the original packet m.

Fig 6: Real Time Classification

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 cipher text prefix. Hence, an adversary who is aware of the
underlying protocol specifics (structure of the frame) can use the static cipher text
portions of a transmitted packet to classify it.

16
3. Selective Jamming Module

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

We 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 cipher text block.

4. Strong Hiding Commitment Scheme (SHCS)

We propose a strong hiding commitment scheme (SHCS), which is based on

symmetric cryptography. Our main motivation is to satisfy the strong hiding
property while keeping the computation and communication overhead to a
minimum.

17
 Fig 7: SHCS Architecture

The computation overhead of SHCS is one symmetric encryption at the sender and
one symmetric decryption at the receiver. Because the header information is
permuted as a trailer and encrypted, all receivers in the vicinity of a sender must
receive the entire packet and decrypt it, before the packet type and destination can
be determined. However, in wireless protocols such as 802.11, the complete packet
is received at the MAC layer before it is decided if the packet must be discarded or
be further processed. If some parts of the MAC header are deemed not to be useful
information to the jammer, they can remain unencrypted in the header of the
packet, thus avoiding the decryption operation at the receiver.

18
5. Cryptographic Puzzle Hiding Scheme (CPHS)

We present a packet hiding scheme based on cryptographic puzzles. The main idea
behind such puzzles is to force the recipient of a puzzle execute a pre-defined set
of computations before he is able to extract a secret of interest. The time required
for obtaining the solution of a puzzle depends on its hardness and the
computational ability of the solver. The advantage of the puzzle based scheme is
that its security does not rely on the PHY layer parameters. However, it has higher
computation and communication overhead

We consider several puzzle schemes as the basis for CPHS. For each scheme, we
analyze the implementation details which impact security and performance.
Cryptographic puzzles are primitives originally suggested by Merkle as a method
for establishing a secret over an insecure channel. They find a wide range of
applications from preventing DoS attacks to providing broadcast authentication
and key escrow schemes

19
 5. RESULTS AND TESTING

Introduction:

The actual working project is materialized in this part where all the work done in
analysis and design part is put onto an appropriate environment. This project is
implemented in java swings and Jcreator.

5.1 RESULTS

5.2.1 Source

Description:

At source, the file is selected and sent it in the form of packets to the destination.
For this first the file is encoded and then it is interleaved and finally sent to the
destination.

20
5.1.2 Destination

Description:

At destination, the file received from the source is de-interleaved and then decoded
to obtain the original file. The result option is used for viewing the file received.

21
5.1.3 Packet Queue

Description:

In the Packet Hiding and Queue, the status information of each packet is
maintained.

22
5.1.4 Result

23
5.2 TESTING

Introduction:

The importance of software testing and its impact on software cannot be under
estimated. Software testing is a fundamental component of software quality
assurance and represents a review of specification, design and coding.
The greater visibility of software systems and the cost associated with software
failure are motivating factors for planning through testing. During testing the
software engineering produces a series of test cases that are used to “rip apart” the
software produced.

TYPES OF TESTS

5.2.1 Functional Testing

Functional tests provide systematic demonstrations that functions tested are

available as specified by the business and technical requirements, system
documentation, and user manuals.

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.

24
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.

5.2.2 System Testing

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.

5.2.3 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.

5.2.4 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, 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.

25
5.2.5 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.

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.

26
5.2.6 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.

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.

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.

5.2.7 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.

27
Channel Encoding:

Channel Interleaving And Sending Packets:

28
Channel Decoding:

Channel De-Interleaving:

29
Channel Decoding And Packets Received:

30
 6. 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 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.

31
6.1 Bibliography

Sites Referred:

http://java.sun.com

http://www.sourcefordgde.com

http://www.networkcomputing.com/

http://www.roseindia.com/

http://www.java2s.com/

32
 7. APPENDIX

7.1 Sample code

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
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[];

33
public String filsep[][];
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();

34
jTextField1.setFont(new Font("Arial",Font.BOLD,12));
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)
{

35
 jTextField1_actionPerformed(e);
}

});

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));

jButton3.setForeground(new Color(0, 0, 102));
jButton3.setText("Interleaving");
jButton3.addActionListener(new ActionListener() {

36
 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)
{
jButton5_actionPerformed(e);
}

});

JLabel imageLabel1 = new JLabel();

37
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));
//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);

38
 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)

{
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

39
 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];
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)

{

40
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
{
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++)
{

41
 System.out.println(filstr[i]);
try
{
Thread.sleep(2);
}
catch (Exception er)
{
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
{

42
 Thread.sleep(2);
}
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);
}
catch (Exception er)
{

43
 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)

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

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

44
 }

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++)
{
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++)

45
 {
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++)
{
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];

46
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)
{
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
{

47
 shufch[i][0]=pakch[i][5];
shufch[i][1]=pakch[i][11];
shufch[i][2]=pakch[i][10];
shufch[i][3]=pakch[i][9];
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);

48
 for(int a=31;a<=10;a+=l)
{
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);
for(int a=652;a<=751;a+=l)
{
j=(int)(Math.random()*10);
shufch[a][j]='\0';
}
}

49
 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
{
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++)

50
 {

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)
{
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();

51
 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");
// 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++)
{

52
 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");
}

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();
}

53
7.2 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.

54
 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 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.

55
 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 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.

Java Technology

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.

56
 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.
TM
 Software components: Known as JavaBeans , can plug into
existing component architectures.
 Object serialization: Allows lightweight persistence and
communication via Remote Method Invocation (RMI).
TM
 Java Database Connectivity (JDBC ): Provides uniform access to
a wide range of relational databases.

57
 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.

 Get started quickly: Although the Java programming language is a

powerful object-oriented language, it’s easy to learn, especially for
programmers already familiar with C or C++.
 Write less code: Comparisons of program metrics (class counts,
method counts, and so on) suggest that a program written in the Java
programming language can be four times smaller than the same
program in C++.
 Write better code: The Java programming language encourages good
coding practices, and its garbage collection helps you avoid memory
leaks. Its object orientation, its JavaBeans component architecture,
and its wide-ranging, easily extendible API let you reuse other
people’s tested code and introduce fewer bugs.
 Develop programs more quickly: Your development time may be as
much as twice as fast versus writing the same program in C++. Why?
You write fewer lines of code and it is a simpler programming
language than C++.
 Avoid platform dependencies with 100% Pure Java: You can keep
your program portable by avoiding the use of libraries written in other
languages. The 100% Pure JavaTM Product Certification Program has a
repository of historical process manuals, white papers, brochures, and
similar materials online.
 Write once, run anywhere: Because 100% Pure Java programs are
compiled into machine-independent byte codes, they run consistently
on any Java platform.
 Distribute software more easily: You can upgrade applets easily
from a central server. Applets take advantage of the feature of
allowing new classes to be loaded “on the fly,” without recompiling
the entire program.

58
7.3 Java Swings:

Java is commonly used for deploying applications across a network.

Compiled Java code may be distributed to different machine architectures, and a
native-code interpreter on each architecture interprets the Java code. The core
functions found in the Java interpreter are called the JFC (Java Foundation
Classes). JFC provides generally useful classes, including classes for GUIs, access
ability and 2D drawing. The original GUI classes in Java are known as AWT – the
Abstract Windowing Toolkit. AWT provides basic GUI functions such as buttons,
frames and dialogs, and is implemented in native code in the Java interpreter. By
contrast, Swing is not implemented in native code - instead it is implemented in
AWT. Swing and AWT can (and normally do) coexist - we may use the buttons
from Swing, alongside AWT event handlers.

The advantages of Swing are:

1. Consistent look-and-feel - The look and feel is consistent across platforms.
2. Pluggable look-and-feel - The look and feel can be switched on-the-fly.
3. High-level widgets - the Swing components are useful and flexible.

In general, the Swing components are easier to use than similar AWT components.
The top level components provided by Swing are:
1. JApplet - for applets within web pages
2. JDialog - for dialog boxes
3. JFrame - for building applications
All other Swing components derive from the JComponent class. JComponent
provides
Tool tips - little windows with explanations
Pluggable look and feel - as described
Layer management - items within the component
Keyboard action management - Hot keys and so on.
And other facilities like Swing implements an MVC architecture.

59
7.4 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
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.

60
 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.

61
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.

62
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".

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.

63
 8. REFERENCES

[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 anti-jamming

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. Cam-bridge

University Press, 2004.

[8] B. Greenstein, D. Mccoy, J. Pang, T. Kohno, S. Seshan, and D. Wether-all.

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

[9] IEEE. IEEE 802.11 standard. http://standards.ieee.org/getieee802/

download/802.11-2007.pdf, 2007.

[10] A. Juels and J. Brainard. Client puzzles: A cryptographic counter-measure

64
 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. ACM Transactions 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.

[18] OPNET. OPNETtm modeler 14.5. http://www.opnet.com/.

[19] C. Perkins, E. Belding-Royer, and S. Das. RFC 3561: Ad hoc on-
demand distance vector (AODV) routing. Internet RFCs, 2003.
ˇ
[20] C. P¨opper, M. Strasser, and S. Capkun. Jamming-resistant broadcast
communication without shared keys. In Proceedings of the USENIX Security

65
 Symposium, 2009.

[21] R. Rivest. All-or-nothing encryption and the package transform.

Lecture Notes in Computer Science, pages 210–218, 1997.

[22] R. Rivest, A. Shamir, and D. Wagner. Time-lock puzzles and timed-release

crypto. Massachusetts Institute of Technology, 1996.

[23] B. Schneier. Applied cryptography: protocols, algorithms, and source code in

C. John Wiley & Sons, 2007.

[24] SciEngines. Break DES in less than a single day. http://www. sciengines.com,
2010.

[25] M. K. Simon, J. K. Omura, R. A. Scholtz, and B. K. Levitt. Spread Spectrum

Communications Handbook. McGraw-Hill, 2001.

[26] D. Stinson. Something about all or nothing (transforms). Designs, Codes and
Cryptography, 22(2):133–138, 2001.

[27] D. Stinson. Cryptography: theory and practice. CRC press, 2006.

ˇ
[28] M. Strasser, C. P¨opper, and S. Capkun. Efficient uncoordinated fhss anti-
jamming communication. In Proceedings of MobiHoc, pages 207– 218, 2009.
ˇ
[29] M. Strasser, C. P¨opper, S. Capkun, and M. Cagalj. Jamming-resistant key
establishment using uncoordinated frequency hopping. In Pro-ceedings of IEEE
Symposium on Security and Privacy, 2008.

[30] P. Tague, M. Li, and R. Poovendran. Probabilistic mitigation of control

channel jamming via random key distribution. In Proceedings of PIMRC, 2007.

[31] P. Tague, M. Li, and R. Poovendran. Mitigation of control channel jamming

under node capture attacks. IEEE Transactions on Mobile Computing,

66
 8(9):1221–1234, 2009.

[32] B. Thapa, G. Noubir, R. Rajaramanand, and B. Sheng. On the robustness of

IEEE802.11 rate adaptation algorithms against smart jamming. In Proceedings
of WiSec, 2011.

[33] D. Thuente and M. Acharya. Intelligent jamming in wireless networks with

applications to 802.11 b and other networks. In Proceedings of the IEEE
Military Communications Conference MILCOM, 2006.

[34] M. Wilhelm, I. Martinovic, J. Schmitt, and V. Lenders. Reactive jamming in

wireless networks: How realistic is the threat? In
Proceedings of WiSec, 2011.

[35] W. Xu, W. Trappe, and Y. Zhang. Anti-jamming timing channels for wireless
networks. InProceedings of WiSec, pages 203–213, 2008.

[36] W. Xu, W. Trappe, Y. Zhang, and T. Wood. The feasibility of launching and
detecting jamming attacks in wireless networks. In Proceedings of MobiHoc,
pages 46–57, 2005.

[37] W. Xu, T. Wood, W. Trappe, and Y. Zhang. Channel surfing and spatial
retreats: defenses against wireless denial of service. In Proceedings of the 3rd
ACM workshop on Wireless security, pages 80–89, 2004.

67