Dynamic Multi-Keyword Ranked Search Based on

Bloom Filter over Encrypted Cloud Data

ABSTRACT
Cloud computing has become a well known way to deal with oversee individual information
for the monetary investment funds and the executives adaptability in late year.
Notwithstanding, the touchy information must be scrambled before re-appropriating to cloud
workers for the thought of security, which makes some customary information use capacities,
for example, the plaintext keyword search, unimaginable. To take care of this issue, we
present multi-keyword positioned search plot over scrambled cloud information supporting
unique activities effectively. Our plan uses the vector space model joined with TF IDF rule
and cosine closeness measure to accomplish a multi- keyword positioned search. In any case,
customary arrangements need to endure high computational expenses. So as to accomplish
the sub-direct hunt time, our plan acquaints Bloom channel with construct a pursuit file tree.
Likewise, our plan can bolster dynamic activity appropriately and successfully on the record
of the property of the Bloom channel, which implies that the refreshing expense of our plan is
lower than different plans. We present our essential plan first, which is secure under the
known code text model. At that point, the improved plan is introduced later to ensure security
much under the realized foundation model. The investigations on this present reality
informational collection show that the exhibitions of our proposed plans are agreeable.

Table of Contents
1. INTRODUCTION..................................................................................................................1
EXISTING SYSTEM................................................................................................................4
PROPOSED SYSTEM..............................................................................................................6
2. LITERATURE SURVEY......................................................................................................8
3. SYSTEM STUDY................................................................................................................10
TECHNICAL FEASIBILITY...........................................................................................11
4. SYSTEM REQUIREMENTS..............................................................................................12
5. SOFTWARE ENVIRONMENT..........................................................................................13
Java Technology...................................................................................................................13
IP datagram’s.....................................................................................................................23
UDP...................................................................................................................................23
TCP....................................................................................................................................23
1. Map Visualizations...........................................................................................................25
2. Time Series Chart Interactivity.........................................................................................26
3. Dashboards........................................................................................................................26
4. Property Editors................................................................................................................26
6. IMPLEMENTATION..........................................................................................................31
7. SYSTEM DESIGN..............................................................................................................47
8. SCREEN SHOTS.................................................................................................................50
9. SYSTEM TESTING............................................................................................................57
Integration Testing...................................................................................................................59
TESTING METHODOLOGIES.......................................................................................60
10. CONCLUSIONS................................................................................................................66
11. REFERENCES...................................................................................................................67

1
 1. INTRODUCTION
With the development of cloud computing, more and more people realize the benefits
that can be reaped from it. Mean- while, people have to manage a massive data in this era of
information explosion, which may not only increase the management cost but also lose
efficiency. To solve this problem, people, companies or organizations can take advantage of
cloud computing, which can enable convenient and on-request organize access to a common
pool of configurable computing resources [1]. More specifically, data owners can outsource
their data into cloud servers so that they can get access to these data as they want. Obviously,
cloud computing takes the economic savings and management flexibility for us.

In any case, most information proprietors are not ready to store their information,
particularly for some delicate information, for example, money related records and individual
messages into cloud workers by virtue of the information protection. The cloud worker is
semi-believed, which may spill information security. So it is important for information
proprietors to encode their redistributed information. Sadly, encryption can diminish the
proficiency of information use, particularly for certain administrations that depend on plain
content catchphrase search. For the above issues, accessible encryption can give some helpful
methods to cloud administrations on the fundamental of keyword search. Accessible
encryption permits clients to gain admittance to pertinent information via looking through
their scrambled information.
.
The main accessible encryption plot was proposed by Song et al. [2]. Their plan
uses two-layered encryption, which can ensure the accuracy of the secret entryway. Despite
the fact that this plan is demonstrated to be secure, it depends on a powerless security model.
To address the disadvantages of Song et al. [2], some novel accessible encryption plans [3]
[10] were proposed. These plans assemble scrambled records for looking as opposed to
looking on the encoded information legitimately. Curtmola et al. [4] presented two new ill-
disposed models for accessible encryption, called chosen-keyword attacks (CKA1) and
versatile picked chosen-keyword attacks (CKA2). They are broadly utilized as the standard
definitions to date. Furthermore, two secure plans are proposed against CKA1 and CKA2,
individually. Kamara et al. [10] introduced a powerful inquiry capable symmetric encryption
conspire.

2
 Their plan can fulfill their proposed necessities of the more severe security
definition and bolster dynamic activity, which makes the hunt more adaptable. Be that as it
may, the above accessible encryption plans can just help precise single catchphrase search,
which limits the application scope of the arrangements. The information proprietor likes to
multi-keyword search as opposed to single catchphrase search, and the previous can improve
the inquiry's exactness. So the multi-keyword search has been investigated broadly as of late.
The current multi-keyword search plans [11][14] can understand numerous multi-catchphrase
search related capacities, for example, conjunctive catchphrase search, disjunctive
catchphrase search and subset search. Ballard et al. [11] proposed two distinctive conjunctive
keyword search plans, which just return the records containing all the looked through
catchphrases, based on Shamir mystery sharing and bilinear pairings, separately.
Their plan is demonstrated secure in the standard model. What's more, disjunctive
keyword search plot was proposed in [14] later, which can return records containing the
subset of inquiry catchphrases. Then predicate encryption plans [15][17] were likewise
introduced so as to help both conjunctive catchphrase search and disjunctive keyword search.
As should be obvious, these multi-keyword search plans can't bolster positioned search,
which implies the cloud worker ought to send back the top-k most significant records as
opposed to every pertinent document.
Positioned search is exceptionally attractive in the ''pay-as-you use'' cloud worldview,
in light of the fact that it can improve the precision and productivity of inquiry. The early
positioned search plans [18], [19] can just help single catchphrase search. What's more, Cao
et al. [20] proposed the first multi-catchphrase positioned search conspire (MRSE). Their
plan used ''inward item likeness'' to figure the important scores. Nonetheless, the pursuit time
of MRSE is practically direct to the quantity of records in the informational collection, since
we have to register a significant score on each document, despite the fact that these records
don't contain any looked through catchphrase. So as to improve the inquiry effectiveness, Sun
et al. [21] assembled a tree-based structure for the entire informational collection and their
plan misuses vector space model with cosine measure to assess the closeness.
Despite the fact that the pursuit effectiveness of their plan is improved in reality, the
inquiry accuracy is decreased somewhat. Since the information is encoded, refreshing the
informational collection is troublesome, and bunches of file structure can't bolster elements.
Refreshing information powerfully is a test. At present, numerous analysts are committed to
the dynamic exploration of accessible encryption plans. Fu et al. [22] introduced an

3
equivalent word based multi-catchphrase positioned search plot. This plan can accomplish
more precise output and bolster equivalent word question. Be that as it may, the refreshing
expense of the above plans is over the top.
For instance, if the information proprietor needs to add a document to her or his
informational index, the person in question needs to reproduce the accessible file tree and the
entirety of the encoded record vector to ensure the cloud worker work typically. To manage
this issue, Sun et al. [23] proposed a multi-catchphrase search plot supporting unique activity
well. Be that as it may, in this plan, the information proprietor needs to encode the interior
hubs of list tree as the leaf hubs, which can prompt a high computational expense and a
wastefulness of refreshing. So the viable multi catchphrase positioned search strategies with
low refreshing expense merit considering.
Blossom channel [24] can choose whether a component is actually an individual from
the set effectively and it has been applied to some accessible encryption plans [25][27].
Bearer et al. [25] introduced a mistake open minded accessible encryption conspire and their
plan joins Bloom channel and LSH (territory delicate hashing) to accomplish their blunder
lenient point. Kuzu et al. [26] uses Bloom channel as interpretation work, which maps a
string into a Bloom channel, to help similitude search. By exploiting the space proficiency of
Bloom channel, Poon et al. [27] proposed an expression search plot. Also, their plan requires
a low stockpiling cost contrasting and the current expression search plans.
In any case, these plans can't accomplish multi-catchphrase positioned search.
In this paper, we will propose a protected and compelling multi-catchphrase positioned
search plot supporting update activities productively. The list tree dependent on Bloom
channel will be intended to improve the inquiry productivity. Also, our plan uses vector space
model to fabricate a record vector for each document in the re-appropriating informational
index. The cosine closeness measure is utilized to register the similitude score of one record
to the inquiry question and TF _ IDF weight will be utilized to improve the pursuit precision.

Our plan can accomplish update activity expressly and the refreshing expense
of our plan is low a direct result of the qualities of the Bloom channel. So also, we will
introduce two secure plans to meet protection prerequisites under two distinctive danger
models. The essential plan is secure under the known code text model, while the improved
plan is secure under the known foundation mode. Our commitments are summed up as
follows: (1) We structure a list tree dependent on Bloom channel to improve the inquiry
proficiency. Our plans can accomplish the sub-direct inquiry time. What's more, both the

4
inquiry productivity and the list tree development proficiency in our plan are superior to other
related plans. (2) We propose our multi-keyword search plans which can bolster dynamic
activities appropriately and the effectiveness of dynamic tasks in our plans is good. (3) The
examinations on this present reality informational collection show that the exhibition of our
proposed plans is palatable.
The remainder of the paper is composed as follows: In Section 2, we quickly present
the correlative definitions about framework model, danger model and the plan objectives of
our plans. In Section 3, the documentations of our plans and starters are presented first. At
that point our proposed plans are depicted in detail, including the essential plan and the
upgraded plot. In Section 4, we present the security investigation of our plans. Segment 5
presents some trial results and examination. Our decisions are introduced in Section 6.

EXISTING SYSTEM

 The first accessible encryption conspire was proposed by Song et al. [2]. Their plan
uses two-layered encryption, which can ensure the accuracy of the hidden entrance. In
spite of the fact that this plan is demonstrated to be secure, it depends on a frail
security model. To address the disadvantages of Song et al. [2], some novel accessible
encryption plans [3][10] were proposed. These plans assemble encoded records for
looking as opposed to looking on the scrambled information straightforwardly.

 Curtmola et al. [4] presented two new ill-disposed models for accessible encryption,
called picked keyword assaults (CKA1) and versatile picked catchphrase assaults
(CKA2). They are generally utilized as the standard definitions to date. What's more,
two secure plans are proposed against CKA1 and CKA2, individually. Kamara et al.
[10] introduced a unique accessible symmetric encryption plot. Their plan can fulfill
their proposed prerequisites of the more severe security definition and bolster
dynamic activity, which makes the pursuit more adaptable.

 Ballard et al. [11] proposed two diverse conjunctive catchphrase search plans, which
just return the documents containing all the looked through keywords, based on
Shamir mystery sharing and bilinear pairings, separately. Their plan is demonstrated
secure in the standard model. Furthermore, disjunctive keyword search conspire was
proposed in [14] later, which can return documents containing the subset of inquiry

5
 catchphrases. In the interim predicate encryption plans [15][17] were additionally
introduced so as to help both conjunctive catchphrase search and disjunctive keyword
search.
 Cao et al. [20] proposed the first multi-catchphrase positioned search plot (MRSE).
Their plan used ''inward item likeness'' to process the pertinent scores. In any case, the
hunt time of MRSE is practically straight to the quantity of documents in the
informational index, since we have to process an applicable score on each record,
despite the fact that these records don't contain any looked through catchphrase. So as
to improve the inquiry effectiveness, Sun et al. [21] fabricated a tree-based structure
for the entire informational index and their plan misuses vector space model with
cosine measure to assess the similitude. Despite the fact that the hunt productivity of
their plan is improved to be sure, the pursuit accuracy is diminished somewhat. Since
the information is scrambled, refreshing the informational index is troublesome, and
bunches of file structure can't bolster elements. Refreshing information powerfully is
a test. At present, numerous analysts are committed to the dynamic examination of
accessible encryption plans. Fu et al. [22] introduced an equivalent word based multi-
keyword positioned search plot. This plan can accomplish more exact item and bolster
equivalent word question. Be that as it may, the refreshing expense of the above plans
is unnecessary.
 For model, if the information proprietor needs to add a record to her or his
informational collection, the person in question needs to reproduce the accessible list
tree and the entirety of the scrambled file vector to ensure the cloud worker work
ordinarily. To manage this issue, Sun et al. [23] proposed a multi-catchphrase search
plot supporting unique activity well. Nonetheless, in this plan, the information
proprietor needs to encode the inner hubs of record tree as the leaf hubs, which can
prompt a high computational expense and a wastefulness of refreshing. So the viable
multi-catchphrase positioned search techniques with low refreshing expense merit
considering.
 Bloom channel [24] can choose whether a component is actually an individual from
the set effectively and it has been applied to some accessible encryption plans [25]
[27]. Bearer et al. [25] introduced a blunder open minded accessible encryption plot
and their plan joins Bloom channel and LSH (locality sensitive hashing) to
accomplish their mistake lenient point. Kuzu et al. [26] uses Bloom channel as
interpretation work, which maps a string into a Bloom channel, to help comparability

6
 search. By exploiting the space productivity of Bloom channel, Poon et al. [27]
proposed an expression search plot. Also, their plan requires a low stockpiling cost
contrasting and the current expression search plans.

Disadvantages
 In the current work, the framework proposed an expression search plot. What's more,
their plan requires a low stockpiling cost contrasting and the current expression search
plans. Be that as it may, these plans can't accomplish multi-catchphrase positioned
search.
 The framework proposes multi-keyword search plot supporting unique activity well.
In any case, in this plan, the information proprietor needs to scramble the inward hubs
of file tree as the leaf hubs, which can prompt a high computational expense and a
wastefulness of refreshing.

PROPOSED SYSTEM
 In the proposed framework, the framework will propose a safe and powerful multi-
catchphrase positioned search plot supporting update activities productively. The record
tree dependent on Bloom channel will be intended to improve the inquiry effectiveness.
Also, our plan uses vector space model to assemble a record vector for each document in
the re-appropriating informational index. The cosine likeness measure is utilized to
process the similitude score of one document to the pursuit question and TF _ IDF
weight will be utilized to improve the inquiry precision.

 Our plan can accomplish update activity expressly and the refreshing expense of our
plan is low a result of the qualities of the Bloom channel. Correspondingly, we will
introduce two secure plans to meet protection prerequisites under two distinctive danger
models. The essential plan is secure under the known ciphertext model, while the
improved plan is secure under the known foundation mode. Our commitments are
summed up as follows:

 The program designs a search efficiency index tree based on Bloom filter. Our
programs should enter the sublinear time of search. And in our system, study
efficiency is higher than other similar schemes, and index tree design efficiency.

7
  The program introduces our search schemes for multi-keywords, which can properly
support dynamic operations and are effective in dynamic operations.
 The real world data set studies have shown the effectiveness of the results of our
proposed schemes.
Advantages

 A cloud server cannot deduce a data user query to any keyword, which means that a
trapdoor cannot leak any query keyword information.
 THE improved scheme is the same as in the basic scheme, the encrypted method of
index vector generation of a Bloom filter. In the known context model, the enhanced
framework will guarantee index privacy.

8
 2. LITERATURE SURVEY
Public key encryption with keyword search
Reference No 5

We study the issue of looking on information that is encoded utilizing an open key
framework. Consider client Bob who sends email to client Alice encoded under Alice's open
key. An email door needs to test whether the email contains the catchphrase "earnest" with
the goal that it could course the email as needs be. Alice, then again doesn't wish to enable
the door to unscramble every one of her messages. We characterize and develop a component
that empowers Alice to give a key to the entryway that empowers the door to test whether
"pressing" is a catchphrase in the email without getting the hang of whatever else about the
email. We allude to this instrument as Public Key Encryption with catchphrase Search. As
another model, consider a mail worker that stores different messages freely encoded for Alice
by others. Utilizing our system Alice can send the mail worker a key that will empower the
worker to recognize all messages containing some particular catchphrase, yet get the hang of
nothing else. We characterize the idea of open key encryption with catchphrase search and
give a few developments.

Predicate encryption supporting disjunctions, polynomial equations, and inner

products,
Reference No: 15
Predicate encryption is another worldview for open key encryption that sums up
character based encryption and that's only the tip of the iceberg. In predicate encryption,
mystery keys compare to predicates and ciphertext are related with characteristics; the
mystery key SK f comparing to a predicate f can be utilized to decode a ciphertext related
with property I if and just if f(I)=1. Developments of such plans are as of now known
uniquely for specific classes of predicates. We develop a plan for predicates comparing to the
assessment of inward items over ℤ N (for some enormous whole number N). This, thusly,
empowers developments in which predicates relate to the assessment of disjunctions,
polynomials, CNF/DNF equations, limits, and that's only the tip of the iceberg. Other than
filling in as a noteworthy advance forward in the hypothesis of predicate encryption, our
outcomes lead to various applications that are fascinating in their own right.

9
Confidentiality-preserving rank-ordered search

Reference No: 18

This paper presents another structure for secrecy protecting position requested inquiry
and recovery over enormous archive assortments. The proposed structure not just ensures
record/question secrecy against an outside interloper, yet additionally forestalls an untrusted
server farm from learning data about the inquiry and the archive assortment. We present
down to earth strategies for appropriate combination of pertinence scoring strategies and
cryptographic methods, for example, request saving encryption, to ensure information
assortments and records and give proficient and precise inquiry abilities to safely rank-
request archives in light of a question. Trial results on the W3C assortment show that these
procedures have equivalent execution to traditional quest frameworks intended for non-
encoded information as far as search exactness. The proposed strategies along these lines
structure the initial steps to unite propelled data recovery and secure quest capacities for a
wide scope of utilizations incorporating overseeing information in government and business
activities, empowering insightful investigation of delicate information, and encouraging the
report disclosure process in suit. Classes and Subject Descriptors: H.3.3 [Information
Systems]: Information Search and Retrieval General Terms: Algorithms, Design, Security

Space/time trade-offs in hash coding with allowable errors,

Reference No: 24

In this paper trade-offs among certain computational factors in hash coding are
analyzed. The paradigm problem considered is that of testing a series of messages one-by-one
for membership in a given set of messages. Two new hash-coding methods are examined and
compared with a particular conventional hash-coding method. The computational factors
considered are the size of the hash area (space), the time required to identify a message as a
nonmember of the given set (reject time), and an allowable error frequency. The new
methods are intended to reduce the amount of space required to contain the hash-coded
information from that associated with conventional methods. The reduction in space is
accomplished by exploiting the possibility that a small fraction of errors of commission may
be tolerable in some applications, in particular, applications in which a large amount of data
is involved and a core resident hash area is consequently not feasible using conventional
methods. In such applications, it is envisaged that overall performance could be improved by
using a smaller core resident hash area in conjunction with the new methods and, when

10
necessary, by using some secondary and perhaps time-consuming test to “catch” the small
fraction of errors associated with the new methods. An example is discussed which illustrates
possible areas of application for the new methods. Analysis of the paradigm problem
demonstrates that allowing a small number of test messages to be falsely identified as
members of the given set will permit a much smaller hash area to be used without increasing
reject time.
A low storage phase search scheme based on bloom filters for encrypted cloud services
Reference No: 27

In spite of the numerous advantages of cloud advancements, there have likewise been
noteworthy concerns with respect to its security and protection. To address the issues,
numerous endeavors have been made towards advancement of a scrambled cloud framework.
One of the key highlights being researched is the capacity to look over scrambled
information. Albeit many have proposed answers for conjunctive keyword search, few have
considered expression looking through methods over encoded information. Because of the
expanded measure of data required to distinguish phrases, existing expression search
calculations require altogether more stockpiling than conjunctive catchphrase search plans. In
this paper, we propose an expression search plot, which exploits the space productivity of
Bloom channels, for applications requiring a low stockpiling cost. It utilizes symmetric
encryption, which gives computational and capacity proficiency over plans dependent on
open key encryption. The plan gives basic positioning capacity, can be adjusted to non-
keyword search and is appropriate against incorporation connection assault.

11
 3. SYSTEM STUDY
3.1 FEASIBILITY STUDY
The practicality of the undertaking is dissected in this stage and strategic agreement is
advanced with an extremely broad arrangement for the venture and some quotes. During
framework investigation the attainability investigation of the proposed framework is to be
completed. This is to guarantee that the proposed framework isn't a weight to the
organization. For possibility examination, some comprehension of the significant
prerequisites for the framework is basic.
Three key contemplations engaged with the plausibility examination are
• ECONOMICAL FEASIBILITY
• TECHNICAL FEASIBILITY
• SOCIAL FEASIBILITY

ECONOMICAL FEASIBILITY

This examination is done to check the monetary effect that the framework will
have on the association. The measure of store that the organization can fill the innovative
work of the framework is constrained. The consumptions must be legitimized. Therefore the
created framework too inside the spending plan and this was accomplished in light of the fact
that the vast majority of the innovations utilized are unreservedly accessible. Just the tweaked
items must be bought.

TECHNICAL FEASIBILITY

This investigation is completed to check the specialized possibility, that is, the
specialized prerequisites of the framework. Any framework created must not have a
popularity on the accessible specialized assets. This will prompt high requests on the
accessible specialized assets. This will prompt high requests being set on the customer. The
created framework must have an unassuming prerequisite, as just insignificant or invalid
changes are required for actualizing this framework.

12
SOCIAL FEASIBILITY

The part of study is to check the degree of acknowledgment of the framework by the
client. This incorporates the way toward preparing the client to utilize the framework
proficiently. The client must not feel undermined by the framework, rather should
acknowledge it as a need. The degree of acknowledgment by the clients exclusively relies
upon the techniques that are utilized to instruct the client about the framework and to make
him acquainted with it. His degree of certainty must be raised with the goal that he is likewise
ready to make some valuable analysis, which is invited, as he is the last client of the
framework.

13
 4. SYSTEM REQUIREMENTS

System Configuration(Hardware):-

➢ Processor - Pentium –IV

➢ RAM - 4 GB (min)
➢ Hard Disk - 20 GB
➢ Key Board - Standard Windows Keyboard
➢ Mouse - Two or Three Button Mouse
➢ Monitor - SVGA

Software Requirements:
 Operating System - Windows XP
 Coding Language - Java/J2EE(JSP,Servlet)
 Front End - J2EE
 Back End - MySQL

14
 5. SOFTWARE ENVIRONMENT
General
This chapter is about the software language and the tools used in the development of the
project. The platform used here is JAVA. The Primary languages are JAVA, J2EE and J2ME.
In this project J2EE is chosen for implementation.
Java is a significant level programming language created by Sun Microsystems. It was
initially intended for creating programs for set-top boxes and handheld gadgets yet later
turned into a well known decision for making web applications. The Java linguistic structure
is like C++, yet is carefully an item situated programming language. The Java Development
Kit (JDK) is a product advancement condition utilized for creating Java applications and
applets. It incorporates the Java Runtime Environment (JRE), a translator/loader (Java), a
compiler (javac), an archiver (container), a documentation generator (Javadoc) and different
instruments required in Java advancement.

There were five essential objectives in the formation of the Java language:
1. It should utilize the article arranged programming system.
2. It ought to permit a similar program to be executed on various working frameworks.
3. It ought to contain worked in help for utilizing PC systems.
4. It ought to be intended to execute code from far off sources safely.
5. It ought to be anything but difficult to use by choosing what were viewed as the great
pieces of other object-arranged dialects

Introduction to  Java:
The first reason for this language was to provide a language independent of the platform
(i.e. design neutral) which could be used to build applications to integrate into different
consumer electronic devices. The first language was called oak. It was renamed "java" in
1995.
 Java is the language of a programmer
 Java is clear and uniform
 With the exception of the limits levied by the Internet. Java gives complete access to
the programmer
 Finally Java is to program the computer, where c was to program the machine.

15
Importance of Java to the Internet
On the Internet, Java has had a profound impact. Since java extends the world of
artifacts in cyberspace that can move freely. Two types of objects between the server and the
personal computer are distributed via a network. They are passive knowledge and complex
active protection and probability systems. Yet Java is tackling this and opening the door to an
innovative new application, the Applet. The java had wide variety of features which makes it
useful for developing applications that run on internet which is shown in the figure given
below:

Fig: Features of Java

Java Architecture
Java architecture provides a compact, scalable, high-performance development
environment. Java provides portability through the compilation of the Java Virtual Machine
byte codes, which are then interpreted in the runtime environment by each platform. Java is a
dynamic framework that can load code in a room or across the globe from a computer if
needed.
Compilation of code
When compiled, Java compiler produces hypothetical Java Virtual Machine(JVM)
computer code (called byte code). The JVM is intended to get the byte code executed. The
JVM is designed to solve the probability problem. The code has been written and compiled
for a single machine, and is read on all computers.

16
Compiling and interpreting java source code.

The Java translator tricks the byte code file into believing that it runs on a virtual Java
computer during execution. It could potentially be an Intel Pentium windows 95 or sun SPARC
station, which operates with a running device from Solaris or Apple Macintosh, and everyone
could obtain code via the internet from any machine to run the applets.

Simple
Java has been designed to be easy to understand and use effectively for the
professional programmer. If you know how to build C++, learning Java is geared towards C+
+ features. Most of the confounding C++ concepts are either left out of Java or are more
easily implemented. A few clearly specified ways to perform a particular task are available in
Java.
Object oriented
No other language friendly source code has been built to be Java. This allowed the Java
team to design with a blank state. A clean and rational approach to artifacts was one consequence
of this. It is quick and easy to extend the object model in java while quick types like integers are
kept as non-objects with a high performance.

17
To be an Object Oriented language, any language must follow at any rate the four attributes.
1. Inheritance: It is the way toward making the new classes and utilizing the conduct of the
current classes by extending them just to reuse the current code and including expansion an
element varying.

2. Encapsulation: It is the instrument of joining the data and giving the reflection.

3. Polymorphism: As the name recommend one name various structure, Polymorphism is the
method of giving the diverse usefulness by the capacities having a similar name dependent on the
marks of the techniques.

4. Dynamic binding: Sometimes we don't have the information on objects about their particular
sorts while composing our code. It is the method of giving the most extreme usefulness to a
program about the particular sort at runtime.

Robust
A software is highly challenging since the multi-platform environment in the cloud
will run efficiently across a number of systems. Getting a high priority in Java design was the
ability to build robust programs? Java is strictly typed; at the compile time and during
runtime, it tests the file.

The Java Framework

Java has been developed by James Gosling at Microsystems, and was published in
1995 as a core component of the Java platform of Sun Microsystems. The syntax in the
language is mostly C and C++, but is simpler and less low-level. Java programs typically
have byte code compiled that can operate on any Java Virtual Machine ( JVM), regardless of
the computer architecture. Java is general, competitor, class and object-oriented and has been
specifically built to have as few dependencies as possible in implementation. It is intended to
"write once, run anywhere" for software developers.
The Java programming language, which is considered by many as one of the most
popular programming languages in the twentieth century, is widely used by computer
software to Internet applications. The simplicity, performance, portability and security of
Java technology make it the perfect network computing platform. Java is everywhere, from
laptops to datacenters, gaming consoles to scientific supercomputers and cellular phones!

18
Objectives of Java
Explore Java.com to show places in motion in our daily life. Java has a wide range of
applications in today's world. Java is used, for example, for web applications like Google
docs and mobile games. Most specifically, Java is commonly used as part of the web page for
the creation of small application modules or applets. Developers essentially use it to build
apps on your computer.

Why Software Developers Choose Java?

Java has been tried, refined, broadened, and demonstrated by a devoted network. What's
more, numbering more than 6.5 million designers, it's the biggest and generally dynamic on
earth. With its flexibility, productivity, and versatility, Java has gotten priceless to engineers
by empowering them to:
 Write programming on one stage and run it on for all intents and purposes some other
stage
 Create projects to run inside a Web program and Web administrations
 Develop worker side applications for online discussions, stores, surveys, HTML
structures preparing, and the sky is the limit from there
 Combine applications or administrations utilizing the Java language to make
profoundly tweaked applications or administrations
 Write incredible and proficient applications for cell phones, far off processors, ease
purchaser items, and for all intents and purposes some other gadget with a
computerized heartbeat

Some Ways Software Developers Learn Java

Today, several universities and colleges offer Java application programming courses.
Developers can also develop their Java programming skills by reading Sun's java.sun.com
website and signing up for Online, virtual, or teacher-leaded classes, using the Java Tutorial and
the New to Java Program Center.

Java Swing Overview

Abstract Window Toolkit (AWT) is cross-platform
Swing offers a wide variety of user interface controls and widgets. The names of the
swing class usually start with a J including JButton, JList, JFrame. It is primarily to differentiate

19
them from their AWT counterparts; usually, it is single substitutions. Swing is based on the
Lightweight-Parts-AWT and SWT-Heavyweight-Parts concept.
The difference between the two is that the lightweight elements are rendered using pure
Java code (drawn) such as drawline and drawImage, while the heavyweight elements are
rendered via the native operating system.
In addition, some Swing components are heavy components. The high classes and any
subsequent classes are heavyweight while the AWT models are expanded. This is important as
the parent windows must be supported by the OS at the root of the gui. JWindow, JFrame,
JDialog and JApplet are the main classes. All swing components that must be shown on the
computer must be able to obey the root of one of the classes.
Note: It for the most part it's anything but a smart thought to blend heavyweight segments
in with lightweight segments (other than as recently referenced) as you will experience layering
issues, e.g., a lightweight segment that ought to show up "on top" winds up being clouded by a
heavyweight segment. The couple of exemptions to this incorporate utilizing heavyweight parts
as the root sheet and for popup windows. As a rule, heavyweight segments will deliver on head of
lightweight parts and won't be steady with the look and feel objectified in Swing. There are
special cases, however that is a propelled point. The really bold might need to think about
perusing this article from Sun on blending heavyweight and lightweight parts.

Evolution of Collection Framework

Practically all assortments in Java are gotten from the java.util.Collection interface.
Assortment characterizes the essential pieces all things considered. The interface expresses
the include() and evacuate() strategies for adding to and expelling from an assortment
separately. Additionally required is the toArray() strategy, which changes over the assortment
into a basic exhibit of the considerable number of components in the assortment.
At last, the contains() technique checks if a predetermined component is in the
assortment. The Collection interface is a sub interface of java.util.Iterable, so the iterator()
strategy is additionally given. All assortments have an iterator that experiences the entirety of
the components in the assortment. Also, Collection is a conventional. Any assortment can be
composed to store any class. For instance, Collection<String> can hold strings, and the
components from the assortment can be utilized as strings with no throwing required.
Three key selection forms exist:
Lists: can always be ordered, contain duplicates and can be processed as normal

20
 Sets: can not keep duplicates and give the elements a random access.
Maps: connect unique keys to values, randomly access their keys, and host duplicate
Values.

LIST:
Records are actualized in the JCF through the java.util.List interface. It characterizes a
rundown as basically a more adaptable form of an exhibit. Components have a particular
request, and copy components are permitted. Components can be put in a particular position.
They can likewise be scanned for inside the rundown. Two solid classes actualize List. The
first is java.util.ArrayList, which actualizes the rundown as an exhibit.
At whatever point capacities explicit to a rundown are required, the class moves the
components around inside the cluster so as to do it. The other usage is java.util.LinkedList.
This class stores the components in hubs that each have a pointer to the past and next hubs in
the rundown. The rundown can be navigated by following the pointers, and components can
be included or expelled basically by changing the pointers around to put the hub in its
legitimate spot.

SET:
Java's java.util.Set interface characterizes the set. A set can't have any copy
components in it. Moreover, the set has no set request. All things considered, components
can't be found by file. Set is actualized by java.util.HashSet, java.util.LinkedHashSet, and
java.util.TreeSet. HashSet utilizes a hash table. All the more explicitly, it utilizes a
java.util.HashMap to store the hashes and components and to forestall copies.
Java.util.LinkedHashSet expands this by making a doubly connected rundown that
interfaces the entirety of the components by their inclusion request. This guarantees the
emphasis request over the set is unsurprising. java.util.TreeSet utilizes a red-dark tree
executed by a java.util.TreeMap. The red-black tree ensures that there are no copies.
Moreover, it permits Tree Set to actualize java.util.SortedSet.
The java.util.Set interface is reached out by the java.util.SortedSet interface. In
contrast to an ordinary set, the components in an arranged set are arranged, either by the
component's compareTo() strategy, or a technique gave to the constructor of the arranged set.
The first and last components of the arranged set can be recovered, and subsets can be made

21
by means of least and most extreme qualities, just as starting or completion toward the start
or closure of the arranged set. The SortedSet interface is executed by java.util.TreeSet.
java.util.SortedSet is broadened further by means of the java.util.NavigableSet
interface. It's like SortedSet, however there are a couple of extra techniques. The floor(),
roof(), lower(), and higher() strategies discover a component in the set that is near the
boundary. Moreover, a plummeting iterator over the things in the set is given. As with
SortedSet, java.util.TreeSet executes NavigableSet.

MAP:
Maps are characterized by the java.util.Map interface in Java. Maps are straightforward
information structures that partner a key with a worth. The component is the worth. This
leaves the map alone entirely adaptable. In the event that the key is the hash code of the
component, the map is basically a set. In the event that it's only an expanding number, it turns
into a rundown. Guides are actualized by java.util.HashMap, java.util.LinkedHashMap, and
java.util.TreeMap. HashMap utilizes a hash table.
The hashes of the keys are utilized to discover the qualities in different pails.
LinkedHashMap expands this by making a doubly connected rundown between the
components. This permits the components to be gotten to in the request wherein they were
embedded into the map. TreeMap, rather than HashMap and LinkedHashMap, utilizes a red-
black tree. The keys are utilized as the qualities for the hubs in the tree, and the hubs
highlight the qualities in the map.

THREAD:
Basically, a thread is a program's way of execution. Most projects composed today run as a
solitary thread, causing issues when numerous occasions or activities need to happen
simultaneously. Suppose, for instance, a program isn't equipped for drawing pictures while
understanding keystrokes. The program must concentrate on the console input coming up
short on the capacity to deal with more than each occasion in turn. The perfect answer for this
issue is the consistent execution of at least two areas of a program simultaneously.

Creating threads
Java's makers have benevolently planned two different ways of making threads: actualizing
an interface and broadening a class. Expanding a class is the manner in which Java acquires
techniques and factors from a parent class. For this situation, one can just broaden or acquire

22
from a solitary parent class. This constraint inside Java can be overwhelmed by executing
interfaces, which is the most well-known approach to make threads. (Note that the
demonstration of acquiring simply permits the class to be run as a thread. It is dependent
upon the class to begin() execution, and so forth.)
Interfaces give an approach to software engineers to lay the foundation of a class.
They are utilized to structure the necessities for a lot of classes to actualize. The interface sets
everything up, and the class or classes that execute the interface accomplish all the work. The
distinctive arrangement of classes that actualize the interface need to adhere to similar
guidelines.

Java Applets
An applet is a program written in the Java programming language that can be remembered for
a HTML page, much similarly a picture is remembered for a page. At the point when you
utilize a Java innovation empowered program to see a page that contains an applet, the
applet's code is moved to your framework and executed by the program's Java Virtual
Machine (JVM). For data and models on the most proficient method to incorporate an applet
in a HTML page, allude to this depiction of the <APPLET> tag. An applet is an extraordinary
sort of Java program that a program empowered with Java innovation can download from the
web and run. An applet is ordinarily implanted inside a site page and runs with regards to the
program. An applet must be a subclass of the java.applet.Applet class, which gives the
standard interface between the applet and the program condition.
A Java applet can have any or the entirety of the accompanying focal points
 It is easy to make it work away at Linux, Windows and Mac OS for example to make
it cross platform.
 A similar applet can work away "by any stretch of the imagination" introduced forms
of Java simultaneously, instead of simply the most recent module form as it were. Be
that as it may, if an applet requires a later form of the JRE the customer will be
compelled to hold up during the huge download.
 It is upheld by most internet browsers.
 It will reserve in most internet browsers, so will rush to stack when coming back to a
site page yet may stall out in the reserve and have issues when new forms come out.
 It can have full access to the machine it is running on if the client concurs.

23
  It can improve with use: after a first applet is run, the JVM is as of now running also,
begins rapidly, profiting ordinary clients of Java yet the JVM should restart each time
the program begins new.
 It can run at a speed that is similar to (yet by and large more slow than) other gathered
dialects, for example, C++, yet ordinarily quicker than JavaScript.
 It can move the work from the worker to the customer, making a web arrangement
more adaptable with the quantity of clients/customers.

MySql Server
MySQL is an Oracle-backed, RDBMS (Structured Query Language) based database
management system (SQL). While MySQL is most commonly associated with online and
web applications, it can be used for a wide variety of applications.
MySQL was released in 1995 and is an open source relational database system. Until
the 1970s-before, connection databases were a computer staple; data was stored as long text
files that were repetitive and nearly impossible to scan.
At the other hand, a relationship database stores data in tables consisting of rows and
columns and sorts them on the basis of how they relate to related data in a collection. These
may be as low as 10 tables or as big as several thousand according to the particular
application.

NetBeans IDE 7.1.2

NetBeans is a Java-based integrated development (IDE) framework. NetBeans allows the
creation of applications from modular software components known as modules. It has
extensions to other languages such as PHP, C , C++, HTML5, and JavaScript, in addition to
the development of Java.

Conclusion
The high versatility of Swing is reflected in its inherent ability to circumvent the GUI
controls for displaying itself in the native host operating system ( OS). Swing "paints,"
instead of calling a native toolkit, its controls through Java 2D APIs. It's really easy to
schedule the Java thread. All threads have a priority value that can be dynamically modified
by calling the threads setPriority). The above concepts will be put into action in our project to
make the server successful.

24
 6. IMPLEMENTATION
 Data Owner
In this module, the information supplier transfers their encoded information in the
Cloud worker. For the security reason the information proprietor scrambles the
information document and afterward store in the worker. The Data proprietor can
have fit for controlling the scrambled information record and plays out the
accompanying tasks Browse and enc and Uploads documents, View all your
transferred documents, Verify File and Other subtleties.
 Cloud Server
The Cloud worker oversees which is to give information stockpiling administration to
the Data Owners. Information proprietors scramble their information documents and
store them in the Server for offering to information buyers. To get to the common
information records, information shoppers download encoded information documents
of their enthusiasm from the Server and afterward Server will decode them. The
worker will produce the total key if the end client demands for record approval to get
to and plays out the accompanying tasks, for example, View all cloud documents,
Capture all assailants, View all aggressors, View every single key assailant, View all
exchanges, View all hunt demands View all inquiry consent demands, View Top k
Searched keywords, View Top k Searched catchphrases graph, View Top k Similar
Search in Chart.
 END User
In this module, the client can just access the information document with the mystery
key. The client can scan the document for a predefined keyword. The information
which matches for a specific keyword will be filed in the cloud worker and afterward
reaction to the end client and can do the accompanying tasks like Register and Login,
Request File Search, Trapdoor and View Response, Search Files by Multikeyword,
Download File.
 Trapdoor Generator
In this module, the TG can just access the information document from cloud worker
and can do the accompanying activities like Register and Login, View Files, View
Transactions, Generate Trapdoor.

25
package distributeddeduplication;
import javax.swing.JFrame;
public class Owner extends javax.swing.JFrame {
public Owner() {
initComponents();
jLabel6.setVisible(false);
}
private void initComponents() {
jLabel1 = new javax.swing.JLabel();
jLabel2 = new javax.swing.JLabel();
jLabel3 = new javax.swing.JLabel();
jTextField1 = new javax.swing.JTextField();
jPasswordField1 = new javax.swing.JPasswordField();
jButton1 = new javax.swing.JButton();
jButton2 = new javax.swing.JButton();
jLabel4 = new javax.swing.JLabel();
jLabel5 = new javax.swing.JLabel();
jLabel6 = new javax.swing.JLabel();
jLabel7 = new javax.swing.JLabel();
jLabel8 = new javax.swing.JLabel();
jLabel9 = new javax.swing.JLabel();
setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);
setMaximumSize(new java.awt.Dimension(600, 380));
setPreferredSize(new java.awt.Dimension(600, 380));
getContentPane().setLayout(null);
jLabel1.setFont(new java.awt.Font("Perpetua Titling MT", 1, 18));
jLabel1.setText("Owner Login");
getContentPane().add(jLabel1);
jLabel1.setBounds(180, 40, 180, 40);
jLabel2.setFont(new java.awt.Font("Perpetua Titling MT", 1, 12));
jLabel2.setText("Username");
getContentPane().add(jLabel2);
jLabel2.setBounds(70, 110, 100, 40);

26
jLabel3.setFont(new java.awt.Font("Perpetua Titling MT", 1, 12));
jLabel3.setText("Password");
getContentPane().add(jLabel3);
jLabel3.setBounds(70, 170, 90, 40);
getContentPane().add(jTextField1);
jTextField1.setBounds(180, 110, 180, 30);
getContentPane().add(jPasswordField1);
jPasswordField1.setBounds(180, 170, 180, 30);
jButton1.setFont(new java.awt.Font("Times New Roman", 1, 14));
jButton1.setText("Login");
jButton1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton1ActionPerformed(evt);
}
});
getContentPane().add(jButton1);
jButton1.setBounds(130, 240, 90, 40);
jButton2.setFont(new java.awt.Font("Times New Roman", 1, 14));
jButton2.setText("Reset");
jButton2.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton2ActionPerformed(evt);
}
});
getContentPane().add(jButton2);
jButton2.setBounds(270, 240, 90, 40);
jLabel4.setFont(new java.awt.Font("Times New Roman", 1, 12));
jLabel4.setText("New User");
getContentPane().add(jLabel4);
jLabel4.setBounds(180, 310, 60, 20);
jLabel5.setFont(new java.awt.Font("Times New Roman", 3, 12));
jLabel5.setText("Click Here");
jLabel5.addMouseListener(new java.awt.event.MouseAdapter() {

27
 public void mouseClicked(java.awt.event.MouseEvent evt) {
jLabel5MouseClicked(evt);
}
});
getContentPane().add(jLabel5);
jLabel5.setBounds(240, 310, 60, 30);
jLabel6.setForeground(new java.awt.Color(255, 51, 102));
jLabel6.setText("jLabel6");
getContentPane().add(jLabel6);
jLabel6.setBounds(150, 80, 390, 20);
jLabel7.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/images/owner.png")));
getContentPane().add(jLabel7);
jLabel7.setBounds(390, 110, 130, 150);
jLabel8.setFont(new java.awt.Font("Times New Roman", 1, 14));
jLabel8.setForeground(new java.awt.Color(255, 0, 102));
jLabel8.setText("Exit");
jLabel8.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
jLabel8MouseClicked(evt);
}
});
getContentPane().add(jLabel8);
jLabel8.setBounds(470, 30, 24, 17);
jLabel9.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/images/backgound.jpg")));
jLabel9.setText("jLabel9");
getContentPane().add(jLabel9);
jLabel9.setBounds(0, 0, 580, 350);
setSize(new java.awt.Dimension(590, 383));
setLocationRelativeTo(null);
}
private void jLabel5MouseClicked(java.awt.event.MouseEvent evt) {
dispose();

28
 new Reg().setVisible(true);
}
public void setTitle() {
new Owner().setTitle("Owner Login");
}
private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {
jTextField1.setText("");
jPasswordField1.setText("");
jLabel6.setText("");
}
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
if (jTextField1.getText() == null || jTextField1.getText().trim().equals("")) {
jLabel6.setText("Please Enter Username");
jLabel6.setVisible(true);
} else if (jPasswordField1.getText() == null ||
jPasswordField1.getText().trim().equals("")) {
jLabel6.setText("Please Enter Password");
jLabel6.setVisible(true);
} else {
RegValidation rv = new RegValidation();
String status = rv.userValidate(jTextField1.getText(), jPasswordField1.getText(), 1);
if (status.equals("Success")) {
dispose();
new Ohome(jTextField1.getText()).setVisible(true);
} else {
jLabel6.setText("Please Enter Correct Username and Password");
jLabel6.setVisible(true);
}
}
}
private void jLabel8MouseClicked(java.awt.event.MouseEvent evt) {
dispose();
new Main().setVisible(true);
}

29
 public static void main(String args[]) {
try {
for (javax.swing.UIManager.LookAndFeelInfo info :
javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {
java.util.logging.Logger.getLogger(Owner.class.getName()).log(java.util.logging.Level.S
EVERE, null, ex);
} catch (InstantiationException ex) {
java.util.logging.Logger.getLogger(Owner.class.getName()).log(java.util.logging.Lev
el.SEVERE, null, ex);
} catch (IllegalAccessException ex) {
java.util.logging.Logger.getLogger(Owner.class.getName()).log(java.util.logging.Level.S
EVERE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {
java.util.logging.Logger.getLogger(Owner.class.getName()).log(java.util.logging.Level.SE
VERE, null, ex);
}
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Owner().setVisible(true);
new Owner().setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
}
});
}
private javax.swing.JButton jButton1;
private javax.swing.JButton jButton2;
private javax.swing.JLabel jLabel1;

30
 private javax.swing.JLabel jLabel2;
private javax.swing.JLabel jLabel3;
private javax.swing.JLabel jLabel4;
private javax.swing.JLabel jLabel5;
private javax.swing.JLabel jLabel6;
private javax.swing.JLabel jLabel7;
private javax.swing.JLabel jLabel8;
private javax.swing.JLabel jLabel9;
private javax.swing.JPasswordField jPasswordField1;
private javax.swing.JTextField jTextField1;
}
package distributeddeduplication;
import javax.swing.JFrame;
public class Main extends javax.swing.JFrame {
public Main() {
initComponents();
}
BEGIN:initComponents
private void initComponents() {
jPanel1 = new javax.swing.JPanel();
jLabel1 = new javax.swing.JLabel();
jLabel2 = new javax.swing.JLabel();
jPanel2 = new javax.swing.JPanel();
jLabel3 = new javax.swing.JLabel();
jLabel4 = new javax.swing.JLabel();
jLabel5 = new javax.swing.JLabel();
jLabel6 = new javax.swing.JLabel();
jLabel7 = new javax.swing.JLabel();
jLabel8 = new javax.swing.JLabel();
setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);
setMaximumSize(new java.awt.Dimension(750, 450));
setPreferredSize(new java.awt.Dimension(750, 450));
getContentPane().setLayout(null);
jPanel1.setBackground(new java.awt.Color(255, 255, 255));

31
 jPanel1.setLayout(null);
jLabel1.setFont(new java.awt.Font("Perpetua Titling MT", 1, 24));
jLabel1.setForeground(new java.awt.Color(255, 0, 51));
jLabel1.setText("Normalization of Duplicate Records");
jPanel1.add(jLabel1);
jLabel1.setBounds(60, 10, 610, 60);
jLabel2.setFont(new java.awt.Font("Perpetua Titling MT", 1, 24));
jLabel2.setForeground(new java.awt.Color(255, 102, 0));
jLabel2.setText("from Multiple Sources");
jPanel1.add(jLabel2);
jLabel2.setBounds(160, 60, 420, 60);
getContentPane().add(jPanel1);
jPanel1.setBounds(10, 20, 710, 120);
jPanel2.setBackground(new java.awt.Color(255, 255, 255));
jPanel2.setLayout(null);
jLabel3.setFont(new java.awt.Font("Perpetua Titling MT", 1, 14));
jLabel3.setText("Owner");
jPanel2.add(jLabel3);
jLabel3.setBounds(80, 30, 80, 30);
jLabel4.setFont(new java.awt.Font("Perpetua Titling MT", 1, 14));
jLabel4.setText("User");
jPanel2.add(jLabel4);
jLabel4.setBounds(270, 30, 70, 30);
jLabel5.setFont(new java.awt.Font("Perpetua Titling MT", 1, 12));
jLabel5.setText("Cloud");
jPanel2.add(jLabel5);
jLabel5.setBounds(450, 30, 60, 30);
jLabel6.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/images/user.png")));
jLabel6.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
jLabel6MouseClicked(evt);
}
});

32
 jPanel2.add(jLabel6);
jLabel6.setBounds(220, 60, 160, 150);
jLabel7.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/images/owner.png")));
jLabel7.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
jLabel7MouseClicked(evt);
}
});
jPanel2.add(jLabel7);
jLabel7.setBounds(40, 60, 160, 150);
jLabel8.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/images/cloud.png")));
jLabel8.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
jLabel8MouseClicked(evt);
}
});
jPanel2.add(jLabel8);
jLabel8.setBounds(410, 60, 160, 150);
getContentPane().add(jPanel2);
jPanel2.setBounds(70, 170, 590, 210);
setSize(new java.awt.Dimension(746, 438));
setLocationRelativeTo(null);
}
private void jLabel7MouseClicked(java.awt.event.MouseEvent evt) {
dispose();
new Owner().setVisible(true);
}
private void jLabel6MouseClicked(java.awt.event.MouseEvent evt) {
dispose();
new User().setVisible(true);
}
private void jLabel8MouseClicked(java.awt.event.MouseEvent evt) {

33
 dispose();
new Cloud().setVisible(true);
}
public static void main(String args[]) {
try {
for (javax.swing.UIManager.LookAndFeelInfo info :
javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {
java.util.logging.Logger.getLogger(Main.class.getName()).log(java.util.logging.Level.SE
VERE, null, ex);
} catch (InstantiationException ex) {
java.util.logging.Logger.getLogger(Main.class.getName()).log(java.util.logging.Level
.SEVERE, null, ex);
} catch (IllegalAccessException ex) {
java.util.logging.Logger.getLogger(Main.class.getName()).log(java.util.logging.Level.S
EVERE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {
java.util.logging.Logger.getLogger(Main.class.getName()).log(java.util.logging.Level.S
EVERE, null, ex);
}
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Main().setVisible(true);
new Main().setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
});
}
private javax.swing.JLabel jLabel1;
private javax.swing.JLabel jLabel2;

34
 private javax.swing.JLabel jLabel3;
private javax.swing.JLabel jLabel4;
private javax.swing.JLabel jLabel5;
private javax.swing.JLabel jLabel6;
private javax.swing.JLabel jLabel7;
private javax.swing.JLabel jLabel8;
private javax.swing.JPanel jPanel1;
private javax.swing.JPanel jPanel2;
}

35
 7. SYSTEM DESIGN
CLASS DIAGRAM:
A Unified Modeling Langue (UML) class diagram is a sort of static structure diagram
for software engineering which describes the structure of a system by showing system classes
, attributes , operations (or methods) and class relationships. This defines which class
contains knowledge.
The list of classes used in our project are:
(1) Data Owner
(2) Cloud Server
(3) Login
(4) Register
(5) Trapdoor Generator
(6) End user

Class Diagram

36
DATA FLOW DIAGRAM
1. The bubble diagram is also called DFD. It is a simple graphical method that can constitute
a system in respect of the system's input data, specific processing and generation of the
system's output data.

2. One of the most important modeling tools is the DFD (Data Flow Diagram). The machine
components are modeled. Such components are the system process, the process data, an
external entity that communicates with the system and the flow of information.

3. DFD shows how the data moves through the system and how a number of transformations
modify the system. This is an information processing and transformations method used as
data travels from input to output. It's an information management method

The bubble diagram is also referred as DFD. A DFD can be used in any abstraction level
to describe a device. DFD can be distributed into levels reflecting an enhanced flow of
knowledge and functional detail.

Data Flow Diagram

37
USE CASE DIAGRAM:
It represents the behavioral aspects of the system. The list of actors used in this system is:
(1) Cloud Server
(2) Data Owner
(3) End user

Use Case Diagram

38
SEQUENCE DIAGRAM:
A sequence diagram in UML is a sort of interaction diagram showing how and in what
sequencer processes work. A Message Sequence Map construction. Sequence diagrams also
are referred to as event maps, event scenarios, and time charts.

Sequence Diagram

Flow Diagram

39
8. SCREEN SHOTS

40
41
42
43
44
45
46
 9. SYSTEM TESTING
The motivation behind testing is to find mistakes. Testing is the way toward
attempting to find each possible shortcoming or shortcoming in a work item. It gives an
approach to check the usefulness of parts, sub gatherings, congregations or potentially a
completed item It is the way toward practicing programming with the plan of guaranteeing
that the
Programming framework lives up to its necessities and client desires and doesn't
come up short in an unsatisfactory way. There are different kinds of test. Each test type tends
to a particular testing necessity.

TYPES OF TESTS

Unit testing
Unit testing includes the plan of experiments that approve that the inside program
rationale is working appropriately, and that program inputs produce legitimate yields. All
choice branches and interior code stream ought to be approved. It is the trying of individual
programming units of the application. It is done after the fruition of an individual unit before
mix. This is an auxiliary testing, that depends on information on its development and is
obtrusive. Unit tests perform fundamental tests at segment level and test a particular business
procedure, application, or potentially framework arrangement. Unit tests guarantee that every
interesting way of a business procedure performs precisely to the recorded particulars and
contains plainly characterized inputs and anticipated outcomes.

Integration testing
Integration testing are intended to test coordinated programming segments to decide
whether they really run as one program. Testing is occasion driven and is more worried about
the essential result of screens or fields. Reconciliation tests exhibit that despite the fact that
the segments were exclusively fulfillment, as appeared by effectively unit testing, the mix of
parts is right and predictable. Integration testing is explicitly planned for uncovering the
issues that emerge from the blend of parts.

47
Functional test
Functional tests give orderly shows that capacities tried are accessible as determined by the
business and specialized prerequisites, framework documentation, and client manuals.
Functional tests give methodical shows that capacities tried are accessible as determined by
the business and specialized necessities, framework documentation, and client manuals.
Functional testing is focused on the accompanying things:
Legitimate Input : distinguished classes of substantial info must be acknowledged.
Invalid Input : distinguished classes of invalid info must be dismissed.
Capacities : distinguished capacities must be worked out.
Yield : distinguished classes of utilization yields must be worked out.
Frameworks/Procedures: interfacing frameworks or systems must be summoned.

Association and arrangement of practical tests is centered around prerequisites, key

capacities, or unique experiments. Also, orderly inclusion relating to distinguish Business
process streams; information fields, predefined forms, and progressive procedures must be
considered for testing. Before practical testing is finished, extra tests are recognized and the
powerful estimation of current tests is resolved.

System Test
System testing guarantees that the whole coordinated programming framework meets
necessities. It tests a setup to guarantee known and unsurprising outcomes. A case of
framework testing is the arrangement situated framework joining test. System testing depends
on process portrayals and streams, underscoring pre-driven procedure connections and
combination focuses.

White Box Testing

White Box Testing is a trying wherein in which the product analyzer knows about the
internal activities, structure and language of the product, or if nothing else its motivation. It is
reason. It is utilized to test territories that can't be reached from a discovery level.

Black Box Testing

Black box Testing will be trying the product with no information on the inward activities,
structure or language of the module being tried. Discovery tests, as most different sorts of
tests, must be composed from a complete source record, for example, determination or

48
necessities report, for example, detail or prerequisites archive. It is a trying where the product
under test is dealt with, as a discovery .you can't "see" into it. The test gives sources of info
and reacts to yields without thinking about how the product functions.

Test strategy and approach

Field testing will be performed physically and useful tests will be written in detail.
Test objectives

• All field passages must work appropriately.

• Pages must be actuated from the recognized connection.

• The section screen, messages and reactions must not be postponed.

Features to be tested
• Verify that the passages are of the right configuration

• No copy passages ought to be permitted

• All connections should take the client to the right page.

Integration Testing
Programming reconciliation testing is the gradual joining testing of at least two
coordinated programming segments on a solitary stage to deliver disappointments brought
about by interface deserts.
The assignment of the coordination test is to watch that segments or programming
applications, for example parts in a product framework or – one stage up – programming
applications at the organization level – cooperate without mistake.
Test outcomes: All the experiments referenced above passed effectively. No deformities
experienced.

Acceptance Testing
Client Acceptance Testing is a basic period of any task and requires critical interest by
the end client. It likewise guarantees that the framework meets the useful prerequisites.
Test outcomes: All the experiments referenced above passed effectively. No deformities
experienced.

49
SYSTEM TESTING
TESTING METHODOLOGIES
The taxonomy of Testing Methodologies are:
o Unit Testing.
o Integration Testing.
o User Acceptance Testing.
o Output Testing.
o Validation Testing.
Unit Testing
Unit testing centers check exertion around the littlest unit of Software
structure that is the module. Unit testing practices explicit ways in a module's control
structure to guarantee total inclusion and most extreme blunder discovery. This test centers
around every module independently, guaranteeing that it capacities appropriately as a unit.
Henceforth, the naming is Unit Testing.
During this testing, every module is tried separately and the module interfaces are
confirmed for the consistency with plan determination. Exceedingly significant preparing
way are tried for the normal outcomes. All mistake taking care of ways are likewise tried.
Integration Testing
Incorporation testing tends to the issues related with the double issues of check
and program development. After the product has been coordinated a lot of high request tests
are directed. The primary target in this testing procedure is to take unit tried modules and
manufactures a program structure that has been directed by plan.
The following are the types of Integration Testing:
1)Top Down Integration
This strategy is a steady way to deal with the development of program structure.
Modules are coordinated by moving descending through the control order, starting with the
principle program module. The module subordinates to the fundamental program module are
joined into the structure in either a profundity first or expansiveness first way.

In this strategy, the product is tried from principle module and individual stubs are supplanted
when the test continues downwards.
2. Bottom-up Integration
This strategy starts the development and testing with the modules at the most minimal
level in the program structure. Since the modules are coordinated from the base up, preparing

50
required for modules subordinate to a given level is consistently accessible and the
requirement for nails is disposed of. The base up combination procedure might be executed
with the accompanying advances:

 The low-level modules are joined into groups into bunches that perform a
particular Software sub-work.
 A driver (i.e.) the control program for testing is composed to facilitate test
case information and yield.
 The bunch is tried.
 Drivers are evacuated and bunches are joined moving upward in the program
structure.
The base up approaches tests every module independently and afterward every module will
be module is coordinated with a principle module and tried for usefulness.

OTHER TESTING METHODOLOGIES

User Acceptance Testing
Client Acceptance of a framework is the key factor for the accomplishment of any
framework. The framework viable is tried for client acknowledgment by continually staying
in contact with the forthcoming framework clients at the hour of creating and making changes
any place required. The framework created gives a well disposed UI that can without much of
a stretch be seen even by an individual who is new to the framework.
Output Testing
In the wake of playing out the approval testing, the subsequent stage is yield trying of
the proposed framework, since no framework could be helpful on the off chance that it
doesn't create the necessary yield in the predefined position. Getting some information about
the organization required by them tests the yields produced or showed by the framework
viable. Thus the yield group is considered in 2 different ways – one is on screen and another
in printed position.

Validation Checking
Validation checks are performed on the following fields.
Text Field:

51
 The content field can contain just the quantity of characters lesser than or equivalent
to its size. The content fields are alphanumeric in certain tables and alphabetic in different
tables. Mistaken passage consistently glimmers and blunder message.

Numeric Field:
The numeric field can contain just numbers from 0 to 9. A passage of any character
streaks a blunder messages. The individual modules are checked for exactness and what it
needs to perform. Every module is exposed to trial alongside test information. The
independently tried modules are coordinated into a solitary framework. Testing includes
executing the genuine information data is utilized in the program the presence of any program
imperfection is surmised from the yield. The testing ought to be arranged with the goal that
all the prerequisites are exclusively tried.

An effective test is one that gives out the imperfections for the wrong information and
delivers and yield uncovering the blunders in the framework.

Preparation of Test Data

Stepping through different sorts of exam information does the above testing.
Readiness of test information assumes a crucial job in the framework testing. Subsequent to
setting up the test information the framework under examination is tried utilizing that test
information. While testing the framework by utilizing test information blunders are again
revealed and adjusted by utilizing above testing steps and redresses are likewise noted for
sometime later.
Using Live Test Data:
Live test information are those that are really removed from association records. After
a framework is incompletely built, software engineers or investigators frequently request that
clients key in a lot of information from their typical exercises. At that point, the frameworks
individual uses this information as an approach to incompletely test the framework. In
different examples, developers or investigators separate a lot of live information from the
records and have them entered themselves.

It is hard to get live information in adequate adds up to lead broad testing. What's more,
despite the fact that it is reasonable information that will show how the framework will
perform for the common handling necessity, expecting that the live information entered are in
reality run of the mill, such information for the most part won't test all blends or

52
configurations that can enter the framework. This predisposition toward run of the mill
esteems at that point doesn't give a genuine frameworks test and in truth overlooks the cases
well on the way to cause framework disappointment.

Using Artificial Test Data:

Counterfeit test information are made exclusively for test purposes, since they can be
created to test all blends of configurations and qualities. At the end of the day, the counterfeit
information, which can rapidly be set up by an information creating utility program in the
data frameworks division, make conceivable the testing of all login and control ways through
the program.
The best test programs utilize counterfeit test information created by people other than the
individuals who composed the projects. Regularly, an autonomous group of analyzers details
a testing plan, utilizing the frameworks particulars.

The bundle "Virtual Private Network" has fulfilled all the prerequisites determined according
to programming necessity determination and was acknowledged.
USER TRAINING
At whatever point another framework is created, client preparing is required to teach
them about the working of the framework with the goal that it tends to be put to proficient use
by those for whom the framework has been principally structured. For this reason the
ordinary working of the task was exhibited to the imminent clients. Its working is effectively
justifiable and since the normal clients are individuals who have great information on PCs,
the utilization of this framework is extremely simple.
MAINTENANCE
This covers a wide scope of exercises including rectifying code and structure
mistakes. To decrease the requirement for support over the long haul, we have all the more
precisely characterized the client's necessities during the procedure of framework
improvement. Contingent upon the necessities, this framework has been created to fulfill the
requirements to the biggest conceivable degree. With advancement in innovation, it might be
conceivable to include a lot more highlights based the prerequisites in future. The coding and
structuring is basic and straightforward which will make upkeep simpler.
TESTING STRATEGY :
A procedure for framework testing coordinates framework experiments and structure
methods into an all around arranged arrangement of steps that outcomes in the fruitful
development of programming. The testing methodology must co-work test arranging,

53
experiment configuration, test execution, and the resultant information assortment and
assessment.
A technique for programming testing must oblige low-level tests that are important to
check that a little source code section has been effectively actualized just as elevated level
tests that approve significant framework capacities against client prerequisites.
Programming testing is a basic component of programming quality confirmation and
speaks to a definitive survey of determination structure and coding. Testing speaks to a
fascinating oddity for the product. In this manner, a progression of testing are performed for
the proposed framework before the framework is prepared for client acknowledgment testing.
SYSTEM TESTING:
Programming once approved must be joined with other framework components (for
example Equipment, individuals, database). Framework testing confirms that all the
components are legitimate and that general framework work execution is accomplished. It
additionally tests to discover inconsistencies between the framework and its unique target,
current details and framework documentation.
UNIT TESTING:
In unit testing distinctive are modules are tried against the particulars delivered during
the plan for the modules. Unit testing is fundamental for confirmation of the code delivered
during the coding stage, and thus the objectives to test the inside rationale of the modules.
Utilizing the point by point structure portrayal as a guide, significant Conrail ways are tried to
reveal blunders inside the limit of the modules. This testing is completed during the
programming stage itself. In this sort of testing step, every module was seen as working
sufficiently as respects to the normal yield from the module.
In Due Course, most recent innovation progressions will be thought about. As a
feature of specialized develop numerous segments of the systems administration framework
will be nonexclusive in nature so future activities can either utilize or collaborate with this.
The future holds a ton to offer to the turn of events and refinement of this undertaking.

54
 10. CONCLUSIONS

In this paper, we proposed a protected and viable, multi-catchphrase, positioned search

conspire over scrambled cloud information. Likewise, our plan all the more effectively
underpins dynamic tasks that contain cancellations or additions in a record. To play out a
multi-keyword positioned search, our plan uses the vector space model joined with the TF-
IDF rule and the cosine likeness measure to assess the closeness between the reports and the
inquiry demand. To improve the productivity of the hunt, an inquiry record tree dependent on
the Bloom channel is worked to decide the important reports. What's more, the pursuit list
tree likewise can decrease the expense of dynamic tasks as a result of the properties of the
Bloom channel. At long last, the trial results show that our plan can accomplish the structure
objectives proficiently and successfully.

55
 11. REFERENCES

[1] L. M. Vaquero, L. Rodero-Merino, J. Caceres, and M. Lindner, ``A break in the clouds:
Towards a cloud de_nition,'' ACM SIGCOMM Comput. Commun. Rev., vol. 39, no. 1, pp.
50_55, 2008.

[2] D. X. Song, D. Wagner, and A. Perrig, ``Practical techniques for searches on encrypted
data,'' in Proc. IEEE Symp. Secur. Privacy, May 2000, pp. 44_55.

[3] Z. Xia, X. Wang, X. Sun, and Q. Wang, ``A secure and dynamic multi- keyword ranked
search scheme over encrypted cloud data,'' IEEE Trans. Parallel Distrib. Syst., vol. 27, no. 2,
pp. 340_352, Jan. 2016.

[4] R. Curtmola, J. A. Garay, S. Kamara, and R. Ostrovsky, ``Searchable symmetric

encryption: Improved de_nitions and ef_cient constructions,'' in Proc. 13th ACM Conf.
Comput. Commun. Secur. (CCS), 2006, vol. 19, no. 5, pp. 79_88.

56