MYGROUPPROJECT
MYGROUPPROJECT
CHAPTER 1
INTRODUCTION
1.1 GENERAL
With the increasing number of information technology devices on the internet, the amount of
data that must be maintained has dramatically increased over the years. One of the options to
resolve this issue is to use cloud storage technology by outsourcing a cloud server to store
data and retrieve them from the cloud when needed. Storing the data in the plaintext format
would put the confidentiality of the data owner at risk, but storing the data in the encrypted
format
would pose a significant problem when searching for data on the cloud.
To overcome this challenge, searchable encryption (SE) scheme was introduced by [1] to
search over encrypted data. A searchable encryption scheme allows a server to search for the
data in the encrypted form on behalf of a client without learning any information about the
plaintext data and thus, with the smallest possible loss of data confidentiality [2]. Figure 1
shows the general structure of the searchable encryption scheme. It consists of three main
entities, data owner, data user, and cloud server. Data owner: the one who encrypts the data
and index before uploading to the cloud server. Data user: the one who generates the
trapdoor to enable the server to search over the encrypted data. Cloud server: the server
stores the encrypted data and helps to perform searching operations on the cloud using the
trapdoor. There are two types of searchable encryption scheme. 1) Symmetric searchable
encryption (SSE) In the SSE scheme, the data is encrypted with user's secret key before
outsourcing. The first SSE scheme was proposed by Song et al. [1]. The advantage of this
scheme is its efficiency because the SSE scheme is based on symmetric primitives; thus, it
requires less computational overhead. The disadvantage of this scheme is that its functionality
is usually applicable only to single user scenario.
2) Public Key Encryption with Keyword Search (PEKS) In the PEKS scheme, the data is
encrypted with user's public key before outsourcing. The first PEKS scheme was proposed by
Bone et al. [3]. The advantage of this scheme is its functionality, because it can be used in a
multiuser setting. However, this scheme exhibits a low efficiency. According to Kamara and
Lauter [4], most of the PEKS schemes require the evaluation of pairings on elliptic curves,
which is relatively slow. Current research works focus on improving the security and
practicality of the PEKS scheme before deploying it in real-world applications. A keyword
guessing attack (KGA)
allows the attacker to successfully guess the correct keyword encrypted in a searchable cipher
text and trapdoor. To overcome this vulnerability, security notions such as keyword privacy
and trapdoor privacy were introduced. Keyword privacy prevents any information leaked
from the keyword itself, and similarly trapdoor privacy prevents any information leaked from
the trapdoor side. Trapdoor privacy is an important property that needs to be satisfied by a
PEKS scheme so that it is secure against keyword guessing attack.
1.2 OBJECTIVE
The objective of this project is Keyword privacy prevents any information leaked from the
keyword itself, and similarly trapdoor privacy prevents any information leaked from the
trapdoor side. Trapdoor privacy is an important property that needs to be satisfied by a PEKS
scheme so that it is secure against keyword guessing attack.
1.3SCOPE OF THE PROJECT
In this paper, our survey is mainly focused on the trapdoor privacy of various types of PEKS
schemes. First, we provide a summary on the development of PEKS schemes. We then
introduce the property of trapdoor privacy followed by a comparison analysis on various
PEKS schemes in terms of their underlying tools, computational hardness, system model,
search function, security properties of keyword privacy and trapdoor privacy, and the security
against offline KGA and online KGA. Subsequently, we outline some potential research
directions for the PEKS scheme and conclude this review
1.4EXISTING SYSTEM:
The proposed a PP-CSA scheme for data sharing, where only the authorized user can
access the data, and there is no need to establish a secure channel between the data owner
and the sanitizer.
These schemes provide a function to hide sensitive information but have limitations in not
providing user revocation or data dynamics.
In addition, the integrity auditing scheme using keywords in encrypted data and a more
secure auditing scheme providing forward security have been recently proposed, but these
schemes are not suitable for our target environment.
1.5LITERATURE SURVEY
TITLE : Public-key authenticated encryption with keyword search revisited: Security model
and constructions
AUTHOR : B. Qin, Y. Chen, Q. Huang, X. Liu, and D. Zheng
YEAR :2021
DESCRIPTION :
In cloud era, it is necessary to store sensitive data in an encrypted form. This arises the
interesting and challenging problem of searching on encrypted data. However, previous
Public-key Encryption with Keyword Search (PEKS) inherently cannot resist against inside
keyword guessing attacks. To alleviate this issue, recently Huang and Li proposed the notion
of Public-key Authenticated Encryption with Keyword Search (PAEKS), which requires the
data sender not only encrypting a keyword using the receiver’s public key, but also
authenticating it using his secret key. This paper first revisits HL-PAEKS security model and
finds that it did not capture a realistic threat, called (outside) chosen multi-cipher text attacks.
That is, an outside adversary can decide whether two encrypted files share some identical
keywords or not. To resolve this issue, we propose a new PAEKS security model that
captures both (outside) chosen multi-cipher text attacks and (inside) keyword guessing
attacks. Then, we give a concrete PAEKS scheme and prove its security in the new PAEKS
security model. We also propose a method to simplify data sender’s key management using
identity-based key exchange protocol. Finally, we provide implementation results of our
schemes to show the comparable efficiency of our schemes with previous PEKS/PAEKS
schemes..
TITLE : Lightweight public key authenticated encryption with keyword search against
adaptively-chosen-targets adversaries for mobile devices
AUTHOR : Y. Lu and J. Li,
YEAR : 2021
DESCRIPTION :
Cloud storage services have grown extensively in recent years. For security and privacy
purposes, sensitive data need to be outsourced to clouds in encrypted form. Searchable public
key encryption (SPKE) enables data ciphertexts to be retrieved by keyword(s) without
decryption. Unfortunately, most of the existing SPKE schemes cannot withstand the keyword
guessing attack. To combat such attack, public key authenticated encryption with keyword
search (PAEKS) was presented. However, the existing PAEKS schemes were proven secure
under a designated-targets security model, in which an adversary only can attack a sender and
a recipient designated by the challenger. Our cryptanalysis indicates that such a scheme may
be insecure against the practical attacks where the adversaries choose their targets by
themselves. To fight against adaptively-chosen-targets adversaries, we refine the adversary
model for PAEKS by permitting the adversaries to choose their targets adaptively, and then
formalize the security definitions under the improved security model. After that, we devise a
lightweight PAEKS scheme that avoids the time-consuming bilinear pairing operations and
give the security proofs. The comparisons show that it outperforms the existing bilinear
pairing-based PAEKS schemes in both the computation and communication performance, and
therefore is more suitable for the resource-constrained mobile devices.
TITLE : Public key authenticated encryption with multiple keywords search using
Mamdani system
AUTHOR : Y. Ma and H. Kazemian
YEAR : 2021
DESCRIPTION :
The public cloud environment has attracted massive attackers to exploit insecure ports and
access to data, services and other resources. Techniques, such as Public Key Encryption with
Keyword Search (PEKS), could be deployed in cloud security to avoid accidents. PEKS
allows users to search encrypted documents by a specific keyword without compromising the
original data security. The first PEKS scheme was proposed in 2004, since then, PEKS has
been experienced a great progress. Recently, Kazemian and Ma firstly incorporated with
Fuzzy Logic technique to PEKS scheme, namely “Public Key Encryption with Multi-
keywords Search using Mamdani System (m-PEMKS)”, in order to support Fuzzy Keyword
(i.e. “latest”, “biggest”) Search. However, the m-PEMKS scheme has the ability to prevent
Off-line Keyword Guessing Attack (OKGA) but it may suffer Inside Keyword Guessing
Attack (IKGA). This paper will revisit the m-PEMKS scheme and propose a robust m-
PEMKS mechanism. The proposed scheme has the properties of Cipher text
Indistinguishability, Trapdoor Indistinguishability and User Authentication which can prevent
OKGA and IKGA. Besides, the proposed scheme supports both Fuzzy Keyword Search and
Multiple Keywords Search and therefore, it is more practical and could be applied to the
general public networks.
CHAPTER 2
PROJECT DESCRIPTION
2.1 GENERAL:
The First type of searchable encryption construction SSE is based on symmetric encryption,
where only a secret key is involved in the encryption and decryption processes. Owing to the
nature of symmetric encryption, it is not favorable for multiuser settings, and it has a secret
key distribution issue. To resolve the problem of SSE, public key encryption with keyword
search was subsequently introduced. The construction is based on asymmetric encryption,
where a pair of public and private keys is involved in the encryption and decryption
processes, which is suitable for multiuser of the PEKS scheme.
2.2 METHODOLOGIES
2.2.1MODULES NAME:
1. User Interface Design
2. Public Cloud Server
3. Trapdoor Key Centre
4. Data Controller
5.Data Receiver
Home
Page
Server
User
Database
Login
Register
&Login
Page
Public Cloud
Server Login
Stored File
Information
Data Base
Trapdoor Key
Centre
Register
Login
Data Base
4. Data Controller
This is the third module of this project. In this project data controller has a register with all
details and login with a user id and password. The Data controller has a store a file the file
has an upload with a text file to the data.
Login
Store File
Data Base
5. Data Receiver
This is the fourth module of this project. Data Receiver has a register with all details and
then login with an email id and password. Data receiver has a search the data controller has a
store we can search a data. The trapdoor key response it will get a key response. Data receiver
has a key verification the keys are verify the correct then it will have a decrypt a file
download.
Data Receiver
Register
Login
Data Base
3. Trapdoor Generation:
The data owner generates a trapdoor for a specific keyword using their private key.
CHAPTER 3
REQUIREMENTS ENGINEERING
3.1 GENERAL
We have conducted experiments on our collected dataset and extensive results have
demonstrated that our model outperforms all other existing models. In the future, we will
investigate more tasks under this framework, such as event summarization and event attribute
mining in social media.
3.2 HARDWARE REQUIREMENTS
The hardware requirements may serve as the basis for a contract for the implementation of
the system and should therefore be a complete and consistent specification of the whole
system. They are used by software engineers as the starting point for the system design. It
should what the system does and not how it should be implemented.
PROCESSOR : DUAL CORE 2 DUOS.
RAM : 8GB DD RAM
HARD DISK : 250 GB
SOFTWARE REQUIREMENTS
FRONT END : J2EE (JSP, SERVLET)
BACK END : MY SQL 5.5
OPERATING SYSTEM : WINDOWS 10
IDE : ECLIPSE
3.3.1 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.
3.3.2 FEATURES OF JAVA
3.3.3 THE JAVA FRAMEWORK
Java is a programming language originally developed by James
Gosling at Microsystems and released in 1995 as a core component of Sun Microsystems'
Java platform. The language derives much of its syntax from C and C++ but has a simpler
object model and fewer low-level facilities. Java applications are typically compiled to byte
code that can run on any Java Virtual Machine (JVM) regardless of computer architecture.
Java is general-purpose, concurrent, class-based, and object-oriented, and is specifically
designed to have as few implementation dependencies as possible. It is intended to let
application developers "write once, run anywhere".
Java is considered by many as one of the most influential programming languages of
the 20th century, and is widely used from application software to web applications the java
framework is a new platform independent that simplifies application development internet.
Java technology's versatility, efficiency, platform portability, and security make it the ideal
technology for network computing. From laptops to datacenters, game consoles to scientific
supercomputers, cell phones to the Internet, Java is everywhere!
3.3.4 OBJECTIVES OF JAVA
To see places of Java in Action in our daily life, explore java.com.
Write powerful and efficient applications for mobile phones, remote processors, low-
cost consumer products, and practically any other device with a digital heartbeat
the UI, the parent windows need to be provided by the OS. These top-level classes
include JWindow, JFrame, JDialog and JApplet. All Swing components to be
rendered to the screen must be able to trace their way to a root window of one of those
classes.
NOTE: It generally it is not a good idea to mix heavyweight components with
lightweight components (other than as previously mentioned) as you will encounter
layering issues, e.g., a lightweight component that should appear "on top" ends up
being obscured by a heavyweight component. The few exceptions to this include using
heavyweight components as the root pane and for popup windows. Generally
speaking, heavyweight components will render on top of lightweight components and
will not be consistent with the look and feel being used in Swing. There are
exceptions, but that is an advanced topic. The truly adventurous may want to consider
reading this article from Sun on mixing heavyweight and lightweight components.
3.3.6 EVOLUTION OF COLLECTION FRAMEWORK:
Almost all collections in Java are derived from the java.util.Collection interface. Collection
defines the basic parts of all collections. The interface states the add() and remove() methods
for adding to and removing from a collection respectively. Also required is the toArray()
method, which converts the collection into a simple array of all the elements in the collection.
Finally, the contains() method checks if a specified element is in the collection. The
Collection interface is a subinterface of java.util.Iterable, so the iterator() method is also
provided. All collections have an iterator that goes through all of the elements in the
collection. Additionally, Collection is a generic. Any collection can be written to store any
class. For example, Collection<String> can hold strings, and the elements from the collection
can be used as strings without any casting required.
There are three main types of collections:
Lists: always ordered, may contain duplicates and can be handled the same way as
usual arrays
Sets: cannot contain duplicates and provide random access to their elements
Maps: connect unique keys with values, provide random access to its keys and may
host duplicate values
LIST
Lists are implemented in the JCF via the java.util.List interface. It defines a list as essentially
a more flexible version of an array. Elements have a specific order, and duplicate elements
are allowed. Elements can be placed in a specific position. They can also be searched for
within the list. Two concrete classes implement List. The first is java.util.ArrayList, which
implements the list as an array. Whenever functions specific to a list are required, the class
moves the elements around within the array in order to do it. The other implementation
is java.util.LinkedList. This class stores the elements in nodes that each have a pointer to the
previous and next nodes in the list. The list can be traversed by following the pointers, and
elements can be added or removed simply by changing the pointers around to place the node
in its proper place.
SET:
Java's java.util.Set interface defines the set. A set can't have any duplicate elements in it.
Additionally, the set has no set order. As such, elements can't be found by index. Set is
implemented by java.util.HashSet,java.util.LinkedHashSet, and java.util.TreeSet. HashSet
uses a hash table. More specifically, it uses a java.util.HashMap to store the hashes and
elements and to prevent duplicates. Java.util.LinkedHashSet extends this by creating a doubly
linked list that links all of the elements by their insertion order. This ensures that the iteration
order over the set is predictable. java.util.TreeSet uses a red-black tree implemented by
a java.util.TreeMap. The red-black tree makes sure that there are no duplicates. Additionally,
it allows Tree Set to implement java.util.SortedSet.
The java.util.Set interface is extended by the java.util.SortedSet interface. Unlike a regular
set, the elements in a sorted set are sorted, either by the element's compareTo() method, or a
method provided to the constructor of the sorted set. The first and last elements of the sorted
set can be retrieved, and subsets can be created via minimum and maximum values, as well as
beginning or ending at the beginning or ending of the sorted set. The SortedSet interface is
implemented by java.util.TreeSet
java.util.SortedSet is extended further via the java.util.NavigableSet interface. It's similar to
SortedSet, but there are a few additional methods. The floor(), ceiling(), lower(), and higher()
methods find an element in the set that's close to the parameter. Additionally, a descending
iterator over the items in the set is provided. As with SortedSet, java.util.TreeSet implements
NavigableSet.
MAP:
Maps are defined by the java.util.Map interface in Java. Maps are simple data structures that
associate a key with a value. The element is the value. This lets the map be very flexible. If
the key is the hash code of the element, the map is essentially a set. If it's just an increasing
number, it becomes a list. Maps are implemented
by java.util.HashMap, java.util.LinkedHashMap, and java.util.TreeMap. HashMap uses a
hash table. The hashes of the keys are used to find the values in various buckets.
LinkedHashMap extends this by creating a doubly linked list between the elements. This
allows the elements to be accessed in the order in which they were inserted into the map.
TreeMap, in contrast to HashMap and LinkedHashMap, uses a red-black tree. The keys are
used as the values for the nodes in the tree, and the nodes point to the values in the map
THREAD:
Simply put, a thread is a program's path of execution. Most programs written today run as a
single thread, causing problems when multiple events or actions need to occur at the same
time. Let's say, for example, a program is not capable of drawing pictures while reading
keystrokes. The program must give its full attention to the keyboard input lacking the ability
to handle more than one event at a time. The ideal solution to this problem is the seamless
execution of two or more sections of a program at the same time.
CREATING THREADS
Java's creators have graciously designed two ways of creating threads: implementing an
interface and extending a class. Extending a class is the way Java inherits methods and
variables from a parent class. In this case, one can only extend or inherit from a single parent
class. This limitation within Java can be overcome by implementing interfaces, which is the
most common way to create threads. (Note that the act of inheriting merely allows the class
to be run as a thread. It is up to the class to start() execution, etc.)
Interfaces provide a way for programmers to lay the groundwork of a class. They are used to
design the requirements for a set of classes to implement. The interface sets everything up,
and the class or classes that implement the interface do all the work. The different set of
classes that implement the interface have to follow the same rules.
3.3.7 CONCLUSION
Swing's high level of flexibility is reflected in its inherent ability to override the native
host operating system (OS)'s GUI controls for displaying itself. Swing "paints" its controls
using the Java 2D APIs, rather than calling a native user interface toolkit. The Java thread
scheduler is very simple. All threads have a priority value which can be changed dynamically
by calls to the threads setPriority() method . Implementing the above concepts in our project
to do the efficient work among the Server.
Data controllers must be able to upload text files to the system for storage.
3. File Management:
Data controllers must have the ability to view, delete, or manage their
uploaded files.
Module 4: Data Receiver
1. User Registration and Login:
Data receivers must be able to register with their details and log in using an
email ID and password.
2. Data Search:
Data receivers must be able to search for stored files from data controllers.
3. Key Response Handling:
The system must respond to key requests from data receivers.
4. Key Verification:
Data receivers must be able to verify the correctness of the keys received.
5. File Decryption and Download:
Upon successful key verification, data receivers must be able to decrypt and
download the files.
3.5 NON-FUNCTIONAL REQUIREMENTS
1 Security:
User credentials must be stored securely using encryption methods.
All data transfers must be encrypted to protect sensitive information.
2. Performance:
The system should handle a specified number of concurrent users (e.g., 500) without
significant performance degradation.
File uploads and searches should be completed within a reasonable time frame (e.g.,
under 5 seconds for files under 10MB).
3. Scalability:
The system must be designed to scale horizontally to accommodate an increasing
number of users and files without significant changes to the architecture.
4. Usability:
The user interface must be intuitive and easy to navigate for all user types (public
cloud server users, data controllers, data receivers).
Help documentation must be available to assist users in navigating the system.
5.Reliability:
The system should have a high uptime percentage (e.g., 99.9%).
Regular backups should be conducted to prevent data loss.
6. Compliance:
The system must comply with relevant data protection regulations (e.g., GDPR,
HIPAA) to ensure user privacy and data security.
7. Maintainability:
The system should be modular, making it easy to update or add new features with
minimal disruption.
Code should be well-documented to facilitate maintenance and future development.
CHAPTER 4
DESIGN ENGINEERING
4.1 GENERAL
Design Engineering deals with the various UML [Unified Modelling language]
diagrams for the implementation of project. Design is a meaningful engineering
representation of a thing that is to be built. Software design is a process through which the
requirements are translated into representation of the software. Design is the place where
quality is rendered in software engineering. Design is the means to accurately translate
customer requirements into finished product.
Login Register/Login
Data Controller
Data Controller Information Store File
Public Cloud
Server
Trapdoor Key
DR Register
Database
PC Request
DR Login
Data Receiver
TKC Login Trapdoor Key Response
Key Verification
Key Test
Trapdoor Key
Centre
EXPLANATION:
The main purpose of a use case diagram is to show that a we have an actor is a data user, data
owner and Cloud server. Different types of actions perform. Data user is an actor to perform
some actions on search file, View responses and View search keywords. Data owner is is an
actor. it will have an action on an upload file and view uploaded files. Cloud server can also
an actor. It will have an action on view responses, View files, Match keywords, view data
users and view data owners this all perform by the actor.
Data Receiver
register
login
searc()
trapdoorkeyresponse()
Database
keyverification()
cloudserver decryptfiledownload()
trapdoorkeycentre
datacontroller Data Controller
datareceiver register
login
trapdoorkey()
requests() storefile()
keyverified()
decryptfiledownload()
EXPLANATION
In this class diagram represents how the classes with attributes and methods are linked
together to perform the verification with security. From the above diagram shown the various
classes involved in our project data user has a class it has a attributes and operations. data
user has a login is an attribute in the class. Search files, view responses and view search
keywords this all are operations. data owner is a class. Registration and login are the
attributes. Upload files and View Uploaded files these are the are the operations. Cloud server
and database with the linking together all information’s storing at a database.
Data Receiver
Data Controller
Database
EXPLANATION:
In the above digram tells about the flow of objects between the classes. It is a diagram that
shows a complete or partial view of the structure of a modeled system. In this object diagram
represents how the classes with attributes and methods are linked together to perform the
verification with security. Data user is link with a data owner information. Data user and data
owner is with a cloud server. All information gathers at a database.
EXPLANATION
In the Unified Modeling Language, a component diagram depicts how components are wired
together to form larger components and or software systems. User gives main query and it
converted into sub queries and sends through data dissemination to data aggregators. Data
user can connect with a data owner information. Data owner can also a depend on a cloud
server all store at a database. Results are to be showed to user by database aggregators. All
boxes are components and arrow indicates dependencies.
Register
Data Receiver
Login
EXPLANATION:
Deployment Diagram is a type of diagram that specifies the physical hardware on which the
software system will execute. It also determines how the software is deployed on the
underlying hardware. Data user can first login.Afterwords it will connect with a database.
Register
Register
Login
Login
Login
Login
Search
Store File
Key Test
Stored File Information
Key Verification
Request
Verify Key
EXPLANATION:
Sequence diagrams are graphical representations of workflows of stepwise activities
and actions with support for choice, iteration and concurrency. In the Unified Modeling
Language, sequence diagrams can be sequential sequence diagram data user data owner and
cloud server in connected with a database. It is used to describe the business and operational
step-by-step workflows of components in a system. In the Uml has clearly in sequence order.
1: Register
9: Store File
Data
13: Trapdoor Key
Receiver
5: Login 17: Verify Key
2: Register
Public Cloud 8: Search
Server 15: Key Verification
Database 18: Decrypt File Download
3: Login
7: Data Controller info
11: Stored File Information
14: Data Receiver Info
16: Request
EXPLANATION:
A collaboration diagram, also called a communication diagram or interaction diagram,
It is also a communicate with a data user data owner with a database. Cloud server has
communicated with a database. It is an illustration of the relationships and interactions among
software objects in the Unified Modeling Language (UML).
Database
Traapdoor key
Request
Database
EXPLANATION:
State diagram are a loosely defined diagram to show workflows of stepwise activities and
actions, with support for choice, iteration and concurrency. State diagrams require that the
system described a Data user has a login. After it has a performs an action. Data owner has
alogin.Data owner can have an upload data and view uploaded data operation. Cloud server
has also a perform an action it will have an action on a database.
Database
Register
Login
Trapdoor Key
Search
Key Test
Data Controller Information
Store File Trapdoor Key Response
Request
Database
EXPLANATION:
Activity diagrams are graphical representations of workflows of stepwise activities of
a data user data owner and cloud server actions with support for choice, iteration and
concurrency. In the Unified Modeling Language, activity diagrams can be used to describe
the business and operational step-by-step workflows of components in a system. Data user
can also a search a file view a responses file and it will search with a keyword. Data owner
can also an upload a file and then view uploaded file the information was a gather at a
database. Cloud server can also have a view request view files and Matched keyword it was
perform at step wise manner. An activity diagram shows the overall flow of control.
Verify
Home Page Detail Error page
s
Trapdoor Key
Register
Public Cloud
Server
Data Receiver
Login
Request
DEPARTMENT OF CSE (SCET) 39 | P a g e
Search File
Information
Trapdoor Privacy Data In PKE With Keyword Search
EXPLANATION:
A data flow diagram (DFD) is a graphical representation of the "flow" of data through an
information system, modeling its process aspects. Often they are a preliminary step used to
create an overview of the system which can later be elaborated. DFDs can also be used for
the visualization of data processing (structured design).
A DFD shows what kinds of data will be input to and output from the system, where
the data will come from and go to, and where the data will be stored. data user can also a
login. Data user can have a search keyword and have a requested file. Data owner can also
have a login. Data owner can also have an uploaded file and data user request. Cloud server
can also a login. Cloud server can also have a data owner information data users information
data .Cloud server can also have a keys. Cloud server can also have a a file attacker details.
All information is gathered and store at a database.
Name Passwor
Nam Passwor
Verify
Trapdoor Login Data base
Key Centre Detail
Passwor Data
Name Login
d Controller
EXPLANATION:
Entity-Relationship Model (ERM) is a data user has a username and password if the user’s
name and password have a correct then it will login. After login data user can search file and
have a requested file. Data owner has a username and password the username and password
has correct it will verify with a database. Data owner can also have an upload a file and then
have a requested send. Cloud server can also have a username and password user name and
password has a correct it will verify from the database. Cloud server can also have a data
owner information. Cloud server can also have a data user information. Cloud server can also
have a stored a files information details. Cloud server can also have a send keys. Cloud server
can also have an attacker detail.
Request
Key Test
Trapdoor Key
Login
Centre Verify Key
Database
Login
Search
Register
Trapdoor Key Response
Data Receiver
EXPLANATION
In this project public cloud server has a login with a user id and password. It will validate the
user id and password has a given correct. After successfully it will be login home page. It will
display a data controller information of all details. It has a Trapdoor Key. The public cloud
server has a data receiver information details. The public cloud server has a request to the
receiver key. It will have a Store all file information which has a stored in a data controller.
Trapdoor key centre has a login with a user id and password. It will validate the user id and
password has a given correct. After successfully it will be login home page. It will display a
key test whether it is a correct key are not. It will verify a key. Data controller has a register
with a detail and then login with a user id and password. Data controller has a store a file it
will be stores at a database. Data receiver has a register with a details and then login with a
user id and password. Data receiver has a search a file it will search from the database. Then
we have a get a key response. The data receiver has a key has a verification whether it has a
correct keyword or not. Then the data receiver has a decrypt a file download from the
database.
CHAPTER 5
IMPLEMENTATION
5.1 GENERAL
CODING:
1.OWNERBEAN
package com.beans;
2.UPLOADBEAN
package com.beans;
import java.io.InputStream;
3.ALGORITHM.JAVA
package com.servlets;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.KeySpec;
import java.util.Base64;
import javax.crypto.BadPaddingException;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
public class Algorithm
{
/* Private variable declaration */
private static final String SECRET_KEY = "123456789";
private static final String SALTVALUE = "abcdefg";
/* Encryption Method */
public static String encrypt(String strToEncrypt)
{
try
{
/* Declare a byte array. */
byte[] iv = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
IvParameterSpec ivspec = new IvParameterSpec(iv);
/* Create factory for secret keys. */
SecretKeyFactory factory =
SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
/* PBEKeySpec class implements KeySpec interface. */
KeySpec spec = new PBEKeySpec(SECRET_KEY.toCharArray(),
SALTVALUE.getBytes(), 65536, 256);
SecretKey tmp = factory.generateSecret(spec);
SecretKeySpec secretKey = new SecretKeySpec(tmp.getEncoded(), "AES");
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivspec);
/* Retruns encrypted value. */
return Base64.getEncoder()
.encodeToString(cipher.doFinal(strToEncrypt.getBytes(StandardCharsets.UTF_8)));
}
catch (InvalidAlgorithmParameterException | InvalidKeyException |
NoSuchAlgorithmException | InvalidKeySpecException | BadPaddingException |
IllegalBlockSizeException | NoSuchPaddingException e)
{
System.out.println("Error occured during encryption: " + e.toString());
}
return null;
}
/* Decryption Method */
public static String decrypt(String strToDecrypt)
{
try
{
/* Declare a byte array. */
byte[] iv = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
IvParameterSpec ivspec = new IvParameterSpec(iv);
/* Create factory for secret keys. */
SecretKeyFactory factory =
SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
/* PBEKeySpec class implements KeySpec interface. */
4. GENERATE TRAPDOOR.JAVA
package com.servlets;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import com.Dao.DBConnection;
/**
* Servlet implementation class GTrapdoor
*/
@WebServlet("/GTrapdoor")
public class GTrapdoor extends HttpServlet {
private static final long serialVersionUID = 1L;
/**
* @see HttpServlet#HttpServlet()
*/
public GTrapdoor() {
super();
// TODO Auto-generated constructor stub
}
/**
Statement st=con.createStatement();
int i=st.executeUpdate("insert into keygen
values('"+sk+"','"+mk+"','"+uid+"') ");
pw.println("<script type=\"text/javascript\">");
pw.println("alert('sk and mk Keys For Data User("+uid+") are
Generated Successfully');");
pw.println("location='Setup1.jsp';");
pw.println("</script>");
} }catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse
response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// TODO Auto-generated method stub
}
5.SEARCHRESULT.JSP
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta charset="utf-8">
<meta content="width=device-width, initial-scale=1.0" name="viewport">
<title>DATA MINING</title>
<meta content="" name="description">
<meta content="" name="keywords">
<!-- Favicons
<link href="assets/img/favicon.png" rel="icon">
<link href="assets/img/apple-touch-icon.png" rel="apple-touch-icon">
Google Fonts
<link href="https://fonts.googleapis.com/css?
family=Open+Sans:300,300i,400,400i,600,600i,700,700i|
Roboto:300,300i,400,400i,500,500i,600,600i,700,700i|
Poppins:300,300i,400,400i,500,500i,600,600i,700,700i" rel="stylesheet">
-->
<!-- Vendor CSS Files -->
<link href="assets/vendor/aos/aos.css" rel="stylesheet">
<link href="assets/vendor/bootstrap/css/bootstrap.min.css" rel="stylesheet">
<link href="assets/vendor/bootstrap-icons/bootstrap-icons.css" rel="stylesheet">
<link href="assets/vendor/boxicons/css/boxicons.min.css" rel="stylesheet">
<link href="assets/vendor/glightbox/css/glightbox.min.css" rel="stylesheet">
<link href="assets/vendor/swiper/swiper-bundle.min.css" rel="stylesheet">
<!-- =======================================================
* Template Name: BizLand - v3.9.1
* Template URL: https://bootstrapmade.com/bizland-bootstrap-business-template/
* Author: BootstrapMade.com
* License: https://bootstrapmade.com/license/ -->
<!-- ======================================================== -->
</head>
<body>
<form action="SResult.jsp">
<table
width="100%" border="1 solid red">
<tr><td>File
Name</td>
<td><input
type="text" name="filename" value="" placeholder="Search filename" />
<td><input
type="submit" value="Search" class="special" /></td></tr>
</table>
</form>
</body> </html>
CHAPTER 6
SNAPSHOTS6
6.1 GENERAL:
The final screenshot in this module shows the management interface for uploaded files. Users
can see a list of their files, including file names and upload dates, with action buttons
available for viewing or deleting specific files.
6.2 OUTPUT SNAPSHOTS
Figure 6.2.7 Search File -> Search With File Name -> It Shows
Encrypted Data -> Send
DEPARTMENT OF CSE (SCET) 62 | P a g e
Trapdoor Privacy Data In PKE With Keyword Search
Figure 6.2.12 : Trapdoor Key Response -> Decrypt Key -> Copy
Figure 6.2.13 : Key verification -> Give key -> Paste -> Send
CHAPTER 7
SOFTWARE TESTING
7.1 GENERAL
The purpose of testing is to discover errors. Testing is the process of trying to discover
every conceivable fault or weakness in a work product. It provides a way to check the
functionality of components, sub assemblies, assemblies and/or a finished product It is the
process of exercising software with the intent of ensuring that the Software system meets its
requirements and user expectations and does not fail in an unacceptable manner. There are
various types of test. Each test type addresses a specific testing requirement.
7.3TYPES OF TESTS
7.3.1 UNIT TESTING
Unit testing involves the design of test cases that validate that
the internal program logic is functioning properly, and that program input produce valid
outputs. All decision branches and internal code flow should be validated. It is the testing of
individual software units of the application .it is done after the completion of an individual
unit before integration. This is a structural testing, that relies on knowledge of its construction
and is invasive. Unit tests perform basic tests at component level and test a specific business
process, application, and/or system configuration. Unit tests ensure that each unique path of a
business process performs accurately to the documented specifications and contains clearly
defined inputs and expected results.
Non-Functional Testing
Focuses on the performance, reliability, and usability of the software.
•Performance Testing: Ensures the system performs well under load (e.g., load testing,
stress testing).
•Security Testing: Identifies vulnerabilities and ensures data protection.
•Usability Testing: Validates user-friendliness and intuitive design.
•Compatibility Testing: Checks software compatibility across different devices,
browsers, and operating systems.
•Scalability Testing: Ensures the application can scale under increased workload.
Regression Testing
Ensures new changes (like bug fixes or enhancements) don’t break existing
functionality.
Exploratory Testing
Tests the software without predefined test cases to discover unexpected issues.
Automated Testing
Uses tools and scripts to automate repetitive testing tasks (e.g., Selenium, JUnit).
Smoke Testing Performs basic tests to verify the stability of the software build.
Sanity Testing
Checks specific functionalities after minor changes to ensure they are working.
Alpha and Beta Testing
End-to-End Testing
Tests the entire workflow of the system, simulating real-world scenarios.
Ad-hoc Testing
Informal testing without a structured plan to identify random issues.
Penetration Testing
Simulates attacks to identify and address security vulnerabilities.
TEST CASES:
Test cases can be divided in to two types. First one is Positive test cases and second
one is negative test cases. In positive test cases are conducted by the developer
intention is to get the output. In negative test cases are conducted by the developer
intention is to don’t get the output.
In software testing, assigning test case points usually refers to evaluating and
prioritizing test cases based on factors like complexity, effort, or risk. Here’s an
overview of how test case points might be used:
criteria:
• Risk/Impact
• Effort Needed
• Priority
Complexity 1 3 5
Risk/Impact 1 3 5
Effort (Time/Steps) 1 3 5
Example:
Total Points = 5 + 5 + 3 = 13
TEST PLAN
The test procedure is started by building up a thorough arrangement to test the
general usefulness and extraordinary highlights on an assortment of stage mixes.
Exacting quality control methods are utilized. The procedure checks that the
application meets the necessities indicated in the framework prerequisites report and
is sans bug.
Any project can be separated into units that can be further performed for detailed
processing. Then a testing strategy for each of this unit is carried out. Unit testing
serves to character the potential bugs in the individual segment, so the segment that
has bugs can be recognized and can be redressed from mistakes.
1.0 INTRODUCTION
1.1 Objective
1.2 Reference Document
1.2.1 Project Plan
1.2.2 SRS
2.0 Coverage Of Testing
2.1 Features to be tested.
2.2 features not to be tested
3.0) Test Strategy
3.1 Levels of testing
3.2 Types of testing
3.3 Test design Technique
3.4 Configuration Management
3.5 Test Matrix
3.6 Termonology
3.7 Automation Plan
3.8 List of Automated Tools.
TEST CASES
AND
CHECK FOR
THE
ENABLED
PROPERTY
OF CLEAR
BUTTON
14. POSITIVE ENTER CORRESPO CORRESPOND PASS
USER NDING ING PAGES
NAME, PAGE MUST AREDISPLAYE
PASSWORD BE D AS PER THE
AS PER THE DISPLAYED VIP TABLE
VIP TABLE, AS PER THE
AND CLICK VIP TABLE
ON LOG-IN
BUTTON
VIP TABLE
15. POSITIVE ENTER ALL THE ALL THE FAIL
SOME FIELDS FIELDS ARE
INFORMATI MUST BE CLEAR, BUT
ON INTO CLEAR & THE CURSUR
ANY OF CURSUR IS NOT
THE FIELDS SHOULD BE PLACED IN
AND CLICK PLACED IN USER NAME
ON THE THE USER FIELD
CLEAR NAME
BUTTON FIELD
16. POSITIVE CLICK ON LOG-IN LOG-IN PASS
THE SCREEN SCREEN IS
CANCEL MUST BE CLOSED
BUTTON CLOSED
CHECK FOR
THE
ENABLED
PROPERTY
OF LOG-IN
BUTTON
CHAPTER 8
APPLICATION
8.1 GENERAL
The computational cost of key generation in all schemes for each user is constant,
which have significantly efficiency for lightweight devices in e-healthcare system, the
computation cost increases linearly with the growth of users. However, these results
are acceptable since these costs are one-time, that is, users only need to take the
corresponding costs when joining the system and uploading the e-healthcare records.
CHAPTER 9
9.1 CONCLUSION
The security properties of keyword privacy and trapdoor privacy are essential for the PEKS
schemes to be secure against offline keyword attack from outsider attacker. In this paper, we
have performed comparison analysis on various types of PEKS schemes. We have drawn
some potential research directions for future research
9.2 REFERENCES
[1] D. X. Song, D. Wagner, and A. Perrig, ``Practical techniques for searches on encrypted
data,'' in Proc. IEEE Symp. Secur. Privacy (SP), May 2000, pp. 44_55.
[2] C. Bösch, P. Hartel,W. Jonker, and A. Peter, ``A survey of provably secure searchable
encryption,'' ACM Comput. Surv., vol. 47, no. 2, pp. 1_51, Jan. 2015.
[3] D. Boneh, G. D. Crescenzo, R. Ostrovsky, and G. Persiano, ``Public key encryption with
keyword search,'' in Proc. Int. Conf. Theory Appl. Cryptograph. Techn. Berlin, Germany:
Springer, 2004, pp. 506_522.
[4] S. Kamara and K. Lauter, ``Cryptographic cloud storage,'' in Proc. Int. Conf. Financial
Cryptogr. Data Secur. Berlin, Germany: Springer, 2010, pp. 136_149.
[5] J. W. Byun, H. S. Rhee, H.-A. Park, and D. H. Lee, ``Off-line keyword guessing attacks
on recent keyword search schemes over encrypted data,'' in Proc.Workshop Secure Data
Manage. Berlin, Germany: Springer, 2006, pp. 75_83.
[6] D. J. Park, K. Kim, and P. J. Lee, ``Public key encryption with conjunctive _eld keyword
search,'' in Proc. Int. Workshop Inf. Secur. Appl. Berlin, Germany: Springer, 2004, pp. 73_86.
[7] W.-C.Yau, S.-H. Heng, and B.-M. Goi, ``Off-line keyword guessing attacks on recent
public key encryption with keyword search schemes,'' in Proc. Int. Conf. Autonomic Trusted
Comput. Berlin, Germany: Springer, 2008, pp. 100_105.
[8] J. Baek, R. S. Naini, and W. Susilo, ``Public key encryption with keyword search
revisited,'' in Proc. Int. Conf. Comput. Sci. Appl. Berlin, Germany: Springer, 2008, pp.
1249_1259.
[9] I. R. Jeong, J. O. Kwon, D. Hong, and D. H. Lee, ``Constructing PEKS schemes secure
against keyword guessing attacks is possible?'' Comput. Commun., vol. 32, no. 2, pp.
394_396, Feb. 2009.
[10] W.-C.Yau, R. C.-W. Phan, S.-H. Heng, and B.-M. Goi, ``Keyword guessing attacks on
secure searchable public key encryption schemes with a designated tester,'' Int. J. Comput.
Math., vol. 90, no. 12, pp. 2581_2587, 2013.
[11] H. S. Rhee, J. H. Park, W. Susilo, and D. H. Lee, ``Improved searchable public key
encryption with designated tester,'' in Proc. 4th Int. Symp. Inf., Comput., Commun. Secur.,
2009, pp. 376_379.
[12] D. Boneh and M. Franklin, ``Identity-based encryption from the Weil pairing,'' in Proc.
Annu. Int. Cryptol. Conf. Berlin, Germany: Springer, 2001, pp. 213_229.
[13] M. Abdalla, M. Bellare, D. Catalano, E. Kiltz, T. Kohno, T. Lange, J. Malone-Lee, G.
Neven, P. Paillier, and H. Shi, ``Searchable encryption revisited: Consistency properties,
relation to anonymous IBE, and extensions,'' in Proc. Annu. Int. Cryptol. Conf. Berlin,
Germany: Springer, 2005, pp. 205_222.
[14] C. Gu, Y. Zhu, and H. Pan, ``Ef_cient public key encryption with keyword search
schemes from pairings,'' in Proc. Int. Conf. Inf. Secur. Cryptol. Berlin, Germany: Springer,
2007, pp. 372_383.
[15] L. Sun, C. Xu, M. Zhang, K. Chen, and H. Li, ``Secure searchable public key encryption
against insider keyword guessing attacks from indistinguishability obfuscation,'' Sci. China
Inf. Sci., vol. 61, no. 3, pp. 1_3, Mar. 2018.
[16] J. Zhang, C. Song, Z. Wang, T. Yang, and W. Ma, ``Ef_cient and provable security
searchable asymmetric encryption in the cloud,'' IEEE Access, vol. 6, pp. 68384_68393,
2018.
[17] L. Fang, W. Susilo, C. Ge, and J. Wang, ``A secure channel free public key encryption
with keyword search scheme without random Oracle,'' in Proc. Int. Conf. Cryptol. Netw.
Secur. Berlin, Germany: Springer, 2009, pp. 248_258.
[18] H. S. Rhee, J. H. Park, W. Susilo, and D. H. Lee, ``Trapdoor security in a searchable
public-key encryption scheme with a designated tester,'' J. Syst. Softw., vol. 83, no. 5, pp.
763_771, 2010.
[19] W. Bingjian, C. Tzungher, and J. Fuhgwo, ``Security improvement against malicious
server's attack for a dPEKS scheme,'' Int. J. Inf. Educ. Technol., vol. 1, no. 4, pp. 350_353,
2011.
[20] H. S. Rhee, J. H. Park, and D. H. Lee, ``Generic construction of designated tester public-
key encryption with keyword search,'' Inf. Sci., vol. 205, pp. 93_109, Nov. 2012.