10 Aug 2012
9 Aug 2012
Catching Packet Droppers and Modifiers in Wireless Sensor Networks
Introduction:
In a wireless sensor network, sensor nodes monitor the environment, detect events of interest, produce data and collaborate in forwarding the data towards a sink, which could be a gateway, base station, storage node, or querying user. Because of the ease of deployment, the low cost of sensor nodes and the capability of self-organization, a sensor network is often deployed in an unattended and hostile environment to perform the monitoring and data collection tasks. When it is deployed in such an environment, it lacks physical protection and is subject to node compromise. After compromising one or multiple sensor nodes, an adversary may launch various attacks to disrupt the in-network communication. Among these attacks, two common ones are dropping packets and modifying packets, i.e., compromised nodes drop or modify the packets that they are supposed to forward. To deal with packet droppers, a widely adopted countermeasure is multi-path forwarding, in which each packet is forwarded along multiple redundant paths and hence packet dropping in some but not all of these paths can be tolerated. To deal with packet modifiers, most of existing countermeasures aim to filter modified messages en-route within a certain number of hops. These countermeasures can tolerate or mitigate the packet dropping and modification attacks, but the intruders are still there and can continue attacking the network without being caught. In this paper, we propose a simple yet effective scheme to catch both packet droppers and modifiers.
Scope of the Project:
Our proposed scheme has the following features: (i) being effective in identifying both packet droppers and modifiers, (ii) low communication and energy overheads, and (iii) being compatible with existing false packet filtering schemes; that is, it can be deployed together with the false packet filtering schemes, and therefore it can not only identify intruders but also filter modified packets immediately after the modification is detected.
Deriving Concept-Based User Profiles from Search Engine Logs
ABSTRACT:
User profiling is a fundamental component of any personalization applications. Most existing user profiling strategies are based on objects that users are interested in (i.e., positive references), but not the objects that users dislike (i.e., negative preferences). In this paper, we focus on search engine personalization and develop several concept-based user profiling methods that are based on both positive and negative preferences. We evaluate the proposed methods against our previously proposed personalized query clustering method. Experimental results show that profiles which capture and utilize both of the user’s positive and negative preferences perform the best. An important result from the experiments is that profiles with negative preferences can increase the separation between similar and dissimilar queries. The separation provides a clear threshold for an agglomerative clustering algorithm to terminate and improve the overall quality of the resulting query clusters.
SOFTWARE
Front End : JAVA, J2EE (JSP, SERVLETS, EJB)
Back End : MS SQL 2005
Operating System : Windows XP/07
IDE : Net Beans, Eclipse
Web Server : Tomcat 5.5.
A Web Search Engine-Based Approach to Measure Semantic Similarity between Words
ACCURATELY measuring the semantic similarity between words is an important problem in web mining, information retrieval, and natural language processing.Web mining applications such as, community extraction, relation detection, and entity disambiguation, require the ability to accurately measure the semantic similarity between concepts or entities. In information retrieval, one of the main problems is to retrieve a set of documents that is semantically related to a given user query. Efficient estimation of semantic similarity between words is critical for various natural language processing tasks such as word sense disambiguation (WSD), textual entailment, and automatic text summarization. Semantically related words of a particular word are listed in manually created general-purpose lexical ontologies such as WordNet.1 In WordNet, a synset contains a set of synonymous words for a particular sense of a word. However, semantic similarity between entities changes over time and across domains. For example, apple is frequently associated with computers on the web. However, this sense of apple is not listed in most general-purpose thesauri or dictionaries. A user who searches for apple on the web, might be interested in this sense of apple and not apple as a fruit. New words are constantly being created as well as new senses are assigned to existing words. Manually maintaining ontologies to capture these new words and senses is costly if not impossible. We propose an automatic method to estimate the semantic similarity between words or entities using web search engines. Because of the vastly numerous documents and the high growth rate of the web, it is time consuming to analyze each document separately. Web search engines provide an efficient interface to this vast information. Page counts and snippets are two useful information sources provided by most web search engines. Page count of a query is an estimate of the number of pages that contain the query words. In general, page count may not necessarily be equal to the word frequency because the queried word might appear many times on one page. Page count for the query P AND Q can be considered as a global measure of cooccurrence of words P and Q. For example, the page count of the query “apple” AND “computer” in Google is 288,000,000, whereas the same for “banana” AND “computer” is only 3,590,000. The more than 80 times more numerous page counts for “apple” AND “computer” indicate that apple is more semantically similar to computer than is banana. Despite its simplicity, using page counts alone as a measure of co-occurrence of two words presents several drawbacks. First, page count analysis ignores the position of a wordin a page. Therefore, even though two words appear in a page, they might not be actually related. Second, page count of a polysemous word (a word with multiple senses) might contain a combination of all its senses. For example, page counts for apple contain page counts for apple as a fruit and apple as a company. Moreover, given the scale and noise on the web, some words might co-occur on some pages without being actually related. For those reasons, page counts alone are unreliable when measuring semantic similarity.
P2P Reputation Management Using Distributed Identities and Decentralized Recommendation Chains
Abstract:
Peer-to-peer (P2P) networks are vulnerable to peers who cheat, propagate malicious code, leech on the network, or simply do not cooperate. The traditional security techniques developed for the centralized distributed systems like client-server networks are insufficient for P2P networks by the virtue of their centralized nature. The absence of a central authority in a P2P network poses unique challenges for reputation management in the network. These challenges include identity management of the peers, secure reputation data management, Sybil attacks, and above all, availability of reputation data. In this paper, we present a cryptographic protocol for ensuring secure and timely availability of the reputation data of a peer to other peers at extremely low costs. The past behavior of the peer is encapsulated in its digital reputation, and is subsequently used to predict its future actions. As a result, a peer’s reputation motivates it to cooperate and desist from malicious activities. The cryptographic protocol is coupled with self-certification and cryptographic mechanisms for identity management and countering Sybil attack. We illustrate the security and the efficiency of the system analytically and by means of simulations in a completely decentralized Gnutella-like P2P network.
Cloud Computing for Agent-Based Urban Transportation Systems
Abstract:
Agent-based traffic management systems can use the autonomy, mobility, and adaptability of mobile agents to deal with dynamic traffic environments. Cloud computing can help such systems cope with the large amounts of storage and computing resources required to use traffic strategy agents and mass transport data effectively. This article reviews the history of the development of traffic control and management systems within the evolving computing paradigm and shows the state of traffic control and management systems based on mobile multi agent technology. Intelligent transportation clouds could provide services such as decision support, a standard development environment for traffic management strategies, and so on. With mobile agent technology, an urban-traffic management system based on Agent-Based Distributed and Adaptive Platforms for Transportation Systems (Adapts) is both feasible and effective. However, the large-scale use of mobile agents will lead to the emergence of a complex, powerful organization layer that requires enormous computing and power resources. To deal with this problem, we propose a prototype urban-traffic management system using intelligent traffic clouds.
Data Leakage Detection
ABSTRACT:
A data distributor has given sensitive data to a set of supposedly trusted agents (third parties). Some of the data is leaked and found in an unauthorized place (e.g., on the web or somebody’s laptop). The distributor must assess the likelihood that the leaked data came from one or more agents, as opposed to having been independently gathered by other means. We propose data allocation strategies (across the agents) that improve the probability of identifying leakages. These methods do not rely on alterations of the released data (e.g., watermarks). In some cases we can also inject “realistic but fake” data records to further improve our chances of detecting leakage and identifying the guilty party.
In the course of doing business, sometimes sensitive data must be handed over to supposedly trusted third parties. For example, a hospital may give patient records to researchers who will devise new treatments. Similarly, a company may have partnerships with other companies that require sharing customer data. Another enterprise may outsource its data processing, so data must be given to various other companies.We call the owner of the data the distributor and the supposedly trusted third parties the agents. Our goal is to detect when the distributor’s sensitive data has been leaked by agents, and if possible to identify the agent that leaked the data. We consider applications where the original sensitive data cannot be perturbed. Perturbation is a very useful technique where the data is modified and made “less sensitive” before being handed to agents. For example, one can add random noise to certain attributes, or one can replace exact values by ranges . However, in some cases it is important not to alter the original distributor’s data. For example, if an outsourcer is doing our payroll, he must have the exact salary and customer bank account numbers. If medical researchers will be treating patients (as opposed to simply computing statistics), they may need accurate data for the patients. Traditionally, leakage detection is handled by watermarking, e.g., a unique code is embedded in each distributed copy. If that copy is later discovered in the hands of an unauthorized party, the leaker can be identified. Watermarks can be very useful in some cases, but again, involve some modification of the original data.
Furthermore, watermarks can sometimes be destroyed if the data recipient is malicious. In this paper we study unobtrusive techniques for detecting leakage of a set of objects or records. Specifically, we study the following scenario: After giving a set of objects to agents, the distributor discovers some of those same objects in an unauthorized place. (For example, the data may be found on a web site, or may be obtained through a legal discovery process.) At this point the distributor can assess the likelihood that the leaked data came from one or more agents, as opposed to having been independently gathered by other means. Using an analogy with cookies stolen from a cookie jar, if we catch Freddie with a single cookie, he can argue that a friend gave him the cookie. But if we catch Freddie with 5 cookies, it will be much harder for him to argue that his hands were not in the cookie jar. If the distributor sees “enough evidence” that an agent leaked data, he may stop doing business with him, or may initiate legal proceedings. In this paper we develop a model for assessing the “guilt” of agents. We also present algorithms for distributing objects to agents, in a way that improves our chances of identifying a leaker. Finally, we also consider the option of adding “fake” objects to the distributed set. Such objects do not correspond to real entities but appear realistic to the agents. In a sense, the fake objects acts as a type of watermark for the entire set, without modifying any individual members. If it turns out an agent was given one or more fake objects that were leaked, then the distributor can be more confident that agent was guilty.
Decision Trees for Uncertain Data
ABSTRACT:
Traditional decision tree classifiers work with data whose values are known and precise. We extend such classifiers to handle data with uncertain information. Value uncertainty arises in many applications during the data collection process. Example sources of uncertainty include measurement/quantization errors, data staleness, and multiple repeated measurements. With uncertainty, the value of a data item is often represented not by one single value, but by multiple values forming a probability distribution. Rather than abstracting uncertain data by statistical derivatives (such as mean and median), we discover that the accuracy of a decision tree classifier can be much improved if the “complete information” of a data item (taking into account the probability density function (pdf)) is utilized.
We extend classical decision tree building algorithms to handle data tuples with uncertain values. Extensive experiments have been conducted that show that the resulting classifiers are more accurate than those using value averages. Since processing pdf’s is computationally more costly than processing single values (e.g., averages), decision tree construction on uncertain data is more CPU demanding than that for certain data. To tackle this problem, we propose a series of pruning techniques that can greatly improve construction efficiency.
8 Aug 2012
6 Aug 2012
applet in java with examples
An Applet is a java program that can be included in an HTML page which always runs in the context of browser such as mozilla and internet explorer, etc. Applet is designed to run remotely on the client browser, so there are some restrictions on it. Applet can't access system resources on the local computer.
In order to develop any distributed applications using applets concept,we must use a predefined class called java.applet.Applet.
All the life cycle methods of applet concept are present in a predefined class called java.applet.Applet.
This class contains four life cycle methods .They are
1. public void init()
2. public void start()
3. public void stop()
4. public void destroy()
1. public void init(): This is one of the predefined method available in Applet class.This method will be called by browser only once when an applet is loaded in the browser window.
In this method we write the block of statements which will perform only one time operations such as obtaining database connection, initializing parameters, etc.
2. public void start(): This is one of the predefined method available in Applet class.After executing init() first time, the start() is called immediately by the browser window. From the second request to further subsequent request start() only will be called bt the browser.
In this method , we write the block of statements which will perform repeated operations such as reading records from the files, etc. In general, start() always contains business logic.
3. public void stop(): This is one of the predefined method available in Applet class. This method will be called by browser automatically, when we minimize the applet window or applet-> stop.
.4. public void destroy(): This is one of the predefined method available in Applet class. This method will be called by browser automatically, when we terminate the applet window.
All life cycle methods are defined in java.applet.Applet class with null body. In order to develop our own applet applications, we must override the required life cycle methods of applet class into our class by inheriting from Applet class and that class modifier must be public.
ex:
import java.applet.Applet;
public class myapplet extends Applet
{
//override required life cycle methods of Applet class.
}
In order to display the result of an applet we use the following method
public void paint(Graphics)
{
}
paint() is the predefined method available in Applet class and it is defined with null body. This method will be called by the browser automatically after executing start() since the result is ready. paint() is taking Graphics class object as a parameter and this class present in java.awt package. Graphics class contains the following instance method which is used in the body of paint() for displaying the result of an applet.
public void drawString(String,int,int).
Here, the String parameter represents result of an applet.
first int parameter represents x-coordinate of the browser. second int parameter represents y-coordinate of the browser. Finally the result of an applet must be displaying in the browser window at the intersection point of x and y coordinates.
ex:
import java.applet.Applet;
import java.awt.Graphics;
public class myapplet extends Applet
{
//override required life cycle methods of Applet class.
public void paint(Graphics g)
{
g.drawString("Hello Applet",100,100);
}
}
In order to to run applet programs in the browser Sun micro system has developed a tag
<applet code="name of the class which extends Applet class" height=" x-coordinate of the browser" width="y-coordinate of the browser">
</applet>
ex:
<applet code="myapplet" height="100" width="100">
</applet>
The above tag must be written in the <body> of HTML program or in the java program within the comments(/* ....*/ or //).
ex:
/* <applet code="myapplet" height="100" width="100">
</applet> */
C:\javac myapplet.java
C:\appletviewer myapplet.java
