ABSTRACT

Cloud computing has been a prominent technology that allows users to store their data
and outsource intensive computations. However, users of cloud services are also
concerned about protecting the confidentiality of their data against attacks that can
leak sensitive information. Although traditional cryptography can be used to protect
static data or data being transmitted over a network, it does not support processing of
encrypted data. Homomorphic encryption can be used to allow processing directly on
encrypted data, but a dishonest cloud provider can alter the computations performed,
thus violating the integrity of the results. To overcome these issues, we propose PEEV
(Parse, Encrypt, Execute, Verify), a framework that allows a developer with no
background in cryptography to write programs operating on encrypted data, outsource
computations to a remote server, and verify the correctness of the computations. The
proposed framework relies on homomorphic encryption techniques as well as zero-
knowledge proofs to achieve verifiable privacy-preserving computation. It supports
practical deployments with low performance overheads and allows developers to
express their encrypted programs in a high-level language, abstracting away the
complexities of encryption and verification.
 CHAPTER 1
INTRODUCTION
1.1 GENERAL
Cloud computing has been rapidly growing and adopted by many organizations to
outsource heavy computations to high-performance servers that are provided through
services maintained and operated by third parties. This removes the burden of creating
and maintaining costly computing infrastructure for an organization. Also, it provides
people and businesses with increased productivity, speed and efficiency, and cost
savings . However, end users keep voicing concerns about their sensitive data, as
cloud level threats can put their privacy at risk. In this case, a cloud user cannot fully
trust a cloud provider; for example, since the client’s data are stored and processed on
the cloud’s servers, a curious service provider could read the user’s data. This can
potentially lead the service provider to learn secret information about individuals and
organizations. (such as financial information and health records). Likewise, a curious
provider can use their clients’ data for online advertising [58]. In addition, cloud
computing is susceptible to a variety of cyberattacks including network attacks and
account hijacking [21], [36], [51]. While numerous research efforts have been
proposed to counter cloud attacks [19], [38], [44], deploying these defenses in practice
is limited and doesn’t fully prevent a curious provider from reading the client’s data.
A potential solution to mitigate these issues is using modern cryptography: end users
can encrypt their data using algorithms like AES and upload it to remote cloud
servers. However, this method is only suitable for protecting static data, which limits
usability and prevents the server from performing any meaningful computation on the
outsourced data. But what if end users need to process their data after being uploaded
to the cloud and also preserve their privacy? In this case, traditional cryptography
cannot help To address this challenge of privacy-preserving computation on the cloud,
we need to employ advanced cryptography that allows a cloud provider to perform
computations directly over encrypted data without revealing the underlying sensitive
plaintexts. A promising solution is Fully Homomorphic Encryption (FHE), which
allows performing meaningful computations over encrypted data without decrypting
it; specifically, the decryption of a processed FHE ciphertext equals the output of an
equivalent computation over plaintext data. For example, suppose that a user has two
plaintext values, x and y, and a function F as in Equation 1: z = F(x, y) = x + y (1)
Here, we assume that the values x and y are confidential, and the user does not have
the computational resources to compute the function F locally. If the user does not
trust a cloud provider with her data in plaintext, FHE offers a viable solution. The
client can outsource the computation of F by homomorphically encrypting x and y to x
′ and y ′ and introducing an equivalent homomorphic function F ′ , as shown in
Equation 2: z ′ = F ′ (x ′ , y ′ ) = x ′ + y ′ (2) and by decrypting z ′ , we get x + y, as
shown in Equation 3. Decrypt(z ′ ) = z = x + y (3) Essentially, as shown in Equation 4,
FHE ensures that a computation over a homomorphic ciphertext is equivalent to the
same computation over the original plaintext. F(plaintext) = Decrypt(F ′ (ciphertext))
(4) Although FHE offers a paradigm-shift in privacypreserving computation, it has
considerable difficulties that hinder developers from creating scalable and reliable
trustworthy cloud services. These difficulties include the correct setup of encryption
parameters, translating plaintext data into ciphertext data, and converting a program
that operates on the plaintext data into a version that supports ciphertext data. While
there are several homomorphic encryption implementations available [5], [41], [62],
they are not trivial to use without a thorough understanding of the cryptographic
primitives. On top of that, writing and maintaining a consistent program flow is
challenging, especially considering these libraries offer different APIs and some of the
common programming primitives (e.g., loops) are not directly supported. In addition
to the low-level homomorphic libraries, state-of-the-art compilers have emerged that
translate a program written in a high-level language into its FHE equivalent [12], [29],
[30], [31], [54], [71]. Therefore, FHE has become a powerful new tool for running
computations over encrypted data. However, one major challenge still remains: how
can the users be assured that the encrypted computation was performed faithfully?
Indeed, a client cannot be sure that all steps of the outsourced function were correctly
followed; for example, when a client sends ciphertexts x ′ and y ′ to the cloud and
request to compute F ′ (x ′ , y ′ ), an untrusted cloud server can cheat and compute
another arbitrary function G ′ (x ′ , y ′ ). In this case, the user receives and decrypts the
resulting ciphertext, and instead of getting the sum x + y, she may get the difference x
− y. Verifying that the outsourced computation was performed faithfully is a serious
concern for applications that involve critical data, such as medical applications
informing decisions on patients’ health. Equally important, Machine Learning as a
Service (MLaas), which refers to cloud-based services that run pre-trained machine
learning models on demand, has become increasingly popular in the business sector
[33], [64]. An untrusted MLaaS provider can violate the integrity of a computation,
leading to drastically incorrect results.
1.2 OBJECTIVE
The objective in the cloud computing paradigm, the prover is the cloud server, the
verifier is the end user, and the statement to be proved is the computation over the
encrypted values. In simple terms, the process works as follows: the user uploads both
the encrypted data and the function that needs to be executed directly over the
encrypted data. The cloud then performs the computation, generates the computation’s
proof, and sends the encrypted result along with the proof back to the user. The user
then verifies this proof and proceeds to decrypt the result if the proof is validated.
1.3 SCOPE OF THE PROJECT
In this paper, their main goal was to allow verifiable and private delegation of
computation with three properties: privacy, integrity, and efficiency. In addition, they
introduced a protocol based on homomorphic hash functions that allows choosing
homomorphic encryption parameters flexibly. Although this model is efficient.
1.4 EXISTING SYSTEM:
 These schemes support unlimited evaluations of one type of operation, such as
addition or multiplication. Although they are easy to integrate into existing
codebases and are generally computationally efficient, their applications are
limited, such as for access control. Examples of PHE include the unpadded RSA,
ElGamal, and Paillier cryptosystems.
 The existing frameworks is its support for system usability. Unlike the
aforementioned frameworks, PEEV enables users to express computations in a
high-level language, enhancing usability. Consequently, our work bridges the gap
between theory and practice
1.4.1Existing System Disadvantages:
While numerous research efforts have been to counter cloud attacks.
The third-party auditor had expertise and capabilities that data owners did not have, and
could eliminate the involvement of data owners through the verification of data integrity
1.5 LITERATURE SURVEY
TITLE: ‘HELM: Navigating homomorphic encryption through gates and lookup tables
AUTHOR: C. Gouert, D. Mouris, and N. G. Tsoutsos
YEAR: 2023
DESCRIPTION:
As cloud computing continues to gain widespread adoption, safeguarding the confidentiality
of data entrusted to third-party cloud service providers becomes a critical concern. While
traditional encryption methods offer protection for data at rest and in transit, they fall short
when it comes to where it matters the most, i.e., during data processing. To address this
limitation, we present HELM, a framework for privacy-preserving data processing using
homomorphic encryption. HELM automatically transforms arbitrary programs expressed in a
Hardware Description Language (HDL), such as Verilog, into equivalent homomorphic
circuits, which can then be efficiently evaluated using encrypted inputs. HELM features two
modes of encrypted evaluation: a) a gate mode that consists of standard Boolean gates, and b)
a lookup table mode which significantly reduces the size of the circuit by combining multiple
gates into lookup tables. Finally, HELM introduces a scheduler that enables embarrassingly
parallel processing in the encrypted domain. We evaluate HELM with the ISCAS'85 and
ISCAS'89 benchmark suites as well as real-world applications such as AES and image
filtering. Our results outperform prior works.
TITLE: ‘Machine learning as a service (MLaaS)—An enterprise perspective
AUTHOR: I. Grigoriadis, E. Vrochidou, I. Tsiatsiou, and G. A. Papakosta
YEAR: 2023
DESCRIPTION:
Machine learning (ML) algorithms due to their outstanding performances are being
extensively used in applications covering several different domains. Recently, the increased
growth of cloud services provided training infrastructures for complex ML models able to
deal with big data, resulting in the enhancement of ML as a Service (MLaaS). Toward this
end, ML applications have been deployed in systems, production models, and businesses. ML
algorithms involve accessing data, which is often privacy sensitive. The latter may result in
security and privacy risks. Toward this end, this work examines MLaaS and its incorporation
into businesses, covering a wide range of different sectors. Companies that develop ML
applications are reviewed, and trends in ML-related jobs are reported. Moreover, data
protection privacy is discussed and the evolution of graphics processing units (GPUs) as a
necessary supporting technology for ML applications is also considered.
TITLE: Achieving privacy preserving and verifiable support vector machine training in the
cloud
AUTHOR: C. Hu, C. Zhang, D. Lei, T. Wu, X. Liu, and L. Zhu
YEAR: 2023
DESCRIPTION:
With the proliferation of machine learning, the cloud server has been employed to collect
massive data and train machine learning models. Several privacy-preserving machine
learning schemes have been suggested recently to guarantee data and model privacy in the
cloud. However, these schemes either mandate the involvement of the data owner in model
training or utilize high-cost cryptographic techniques, resulting in excessive computational
and communication overheads. Furthermore, none of the existing work considers the
malicious behavior of the cloud server during model training. In this paper, we propose the
first privacy-preserving and verifiable support vector machine training scheme by employing
a two-cloud platform. Specifically, based on the homomorphic verification tag, we design a
verification mechanism to enable verifiable machine learning training. Meanwhile, to
improve the efficiency of model training, we combine homomorphic encryption and data
perturbation to design an efficient multiplication operation for the encryption domain. A
rigorous theoretical analysis demonstrates the security and reliability of our scheme. The
experimental results indicate that our scheme can reduce computational and communication
overheads by at least 43.94% and 99.58%, respectively, compared to state-of-the-art SVM
training methods.
.
TITLE: ‘Zero knowledge proof and ZK-SNARK for private blockchains
AUTHOR: A. Konkin and S. Zapechnikov
YEAR: 2023
DESCRIPTION:
Comprehensive adoption of distributed ledger technology and blockchain in enterprises might
disrupt financial and other sectors. At the same time, there are some barriers to rolling out the
technology in practice. One of the significant issues concerns information security and
privacy in the blockchain. Some methods for private transactions such as mixed networks,
ring signatures, and off-chain protocols address certain data privacy issues, but do not
provide the blockchain characteristics such as decentralized storing systems and immutability
verification of private data. This article examines zero-knowledge proof (ZKP) methods for
corporate blockchain networks. The article reviews existing methods for private transactions,
observes the implementation of ZKP methods, and discusses performance and scalability
issues.
TITLE: Toward both privacy and efficiency of homomorphic MACs for polynomial
functions and its applications
AUTHOR: S. Li, X. Wang, and R. Xue,
YEAR: 2022
DESCRIPTION:
Homomorphic message authentication codes (MACs) allow a user to outsource data to an
untrusted server and verify the correctness of returned computation results over the
outsourced data. Many cloud applications need delegation computations over outsourced data
with dual capabilities. On one hand, they need to keep the outsourced data secret such that the
server cannot trace and infer any sensitive information from the computation results. On the
other hand, the user should be able to efficiently verify the computation results.
Unfortunately, the state-of-the-art homomorphic MAC schemes are not so desirable due to
either poor privacy or low verification efficiency. In this paper, we first put forward a new
cryptographic primitive called privacy-preserving homomorphic MACs (PHMAC) that
simultaneously provides data privacy and efficient verification. Then, we present a PHMAC
construction capable for the evaluation of polynomials of fixed degree |$d\geq 1$|, in which
the tag does not reveal any information of underlying authenticated data while being
verifiable in constant time (in an amortized sense). As an application, we give a generic
construction of homomorphic authenticated encryption (HAE) from proposed PHMAC and
homomorphic encryption. Benefited from the functionalities of underlying PHMAC scheme,
the derived HAE enjoys stronger authenticity and supports larger classes of functions than
that of Lai et al. (Verifiable Computation on Outsourced Encrypted Data. In Computer
Security—ESORICS 2014—19th European Symposium on Research in Computer Security ,
Wroclaw, Poland, September 7–11, Part I, pp. 273–291. Springer, Berlin). Such HAE enables
verifiable delegation computations over growing outsourced encrypted data in an efficient
way.
.
TITLE: Verifiable encodings for secure homomorphic analytics
AUTHOR: S. Chatel, C. Knabenhans, A. Pyrgelis, C. Troncoso, and J.-P.
Hubaux
YEAR: 2022
DESCRIPTION:
Homomorphic encryption has become a practical solution for protecting the privacy of
computations on sensitive data. However, existing homomorphic encryption pipelines do not
guarantee the correctness of the computation result in the presence of a malicious adversary.
We propose two plaintext encodings compatible with state-of-the-art fully homomorphic
encryption schemes that enable practical client-verification of homomorphic computations
while supporting all the operations required for modern privacy-preserving analytics. Based
on these encodings, we introduce VERITAS, a ready-to-use library for the verification of
computations executed over encrypted data. VERITAS is the first library that supports the
verification of any homomorphic operation. We demonstrate its practicality for various
applications and, in particular, we show that it enables verifiability of homomorphic analytics
with less than 3× computation overhead compared to the homomorphic encryption baseline.
1.6 PROPOSED SYSTEM
 We propose PEEV (Parse, Encrypt, Execute, Verify), a framework that allows a
developer with no background in cryptography to write programs operating on encrypted
data, outsource computations to a remote server, and verify the correctness of the
computations.
 The proposed framework relies on homomorphic encryption techniques as well as zero-
knowledge proofs to achieve verifiable privacy-preserving computation.
 It supports practical deployments with low performance overheads and allows developers
to express their encrypted programs in a high-level language, abstracting away the
complexities of encryption and verification.
1.6PROPOSED SYSTEM ADVANTAGE
 In the basic construction, the accumulated element is the hash of the authenticator
 The designed to produce a fixed-size value from arbitrary input data
 CHAPTER 2
PROJECT DESCRIPTION
1.1 GENERAL
The PEEV framework (Parse, Encrypt, Execute, Verify) is a robust methodology
designed to enhance the utility of Fully Homomorphic Encryption (FHE) in privacy-
preserving computing. FHE allows computations to be performed on encrypted data
without decryption, preserving confidentiality. The PEEV framework ensures that
operations on encrypted data can be carried out securely, efficiently, and verifiably,
making it a key tool for applications that require data privacy, such as secure cloud
computing and confidential data analysis.

Key Components of the Framework:

 Parse: Data is initially parsed and pre-processed into an appropriate format for
encryption. This step ensures that the data is structured correctly and ready for
secure handling in the next phase.

 Encrypt: The parsed data is encrypted using a Fully Homomorphic Encryption

scheme. This encryption ensures that sensitive information remains secure and
confidential during subsequent operations.

 Execute: Encrypted data is used to perform computations or operations. The

key advantage of FHE is that the computations can occur directly on the
encrypted data, without needing to decrypt it, ensuring continuous
confidentiality.

 Verify: After execution, the results are verified to ensure correctness and
integrity. Verification is crucial to confirm that the computations have been
carried out correctly, without the need to decrypt the results, maintaining
security throughout the process.

2.2 METHODOLOGIES
Methodologies of PEEV – A Verifiable Fully Homomorphic Encryption (FHE)
Framework
The PEEV framework (Parse, Encrypt, Execute, Verify) utilizes a structured set of
methodologies to facilitate secure, privacy-preserving computations on encrypted data.
Below is an outline of the core methodologies used in this framework
 2.2.1 MODULES NAME
 ADMIN
2.2.2 MODULE EXPLANATION
1. ADMIN
This is the first module a admin. Admin can login from a user id and password.
Admin can also a parse data content. The admin can also have a user request to add a
user’s. Admin can also have a activity information all recorded information.

Admin
Login

Parse Data Content User Request Activity Information Data User

Data Base
2.3 TECHNIQUE OR ALGORITHM
2.3.1 Proposed Algorithm
 Homomorphic Encryption Schemes and Key Generation techniques
Homomorphic encryption is a type of encryption that allows computations to be
performed on cipher text (encrypted data) without decrypting it first. This
enables secure outsourcing of computations to untrusted parties, such as cloud
computing services, while maintaining the confidentiality of the data. In this
section, we will discuss homomorphic encryption techniques in block data. Its
efficiency came from a homomorphic hashing technique, which could verify the
computations on ciphertext data at the same cost as plaintext data. Although
previous works are well-defined and offer concrete solutions to the problem of
verifiable computations on encrypted data, their complexity may render them
unattractive to end-user.
Key Generation Techniques
The key generation process for homomorphic encryption schemes typically
involves the following steps:
1. Choose Parameters:
 Select a security parameter ( k ) that determines the size of the keys
and the complexity of the scheme.
 Choose a suitable modulus ( n ) or a polynomial ring for the
encryption.
2. Generate Key Pair:
 Public Key: This key is used for encryption and is derived from the
parameters chosen.
 Secret Key: This key is used for decryption and is kept private.
3. Randomness:
 Generate random values necessary for the encryption process. This
might include random primes or elements from a specific group.
4. Construct Keys:
For schemes like Encryption:
 Choose two large prime numbers ( p ) and ( q ).
 Compute ( n = p \times q ) and ( \phi(n) = (p-1)(q-1) ).
 Choose a public exponent ( e ) such that ( 1 < e < \phi(n) )
and ( \gcd(e, \phi(n)) = 1 ).
 Compute the private exponent ( d ) such that ( d \equiv e^{-
1} \mod \phi(n) ).
Encryption Steps
1. Choose a Message: Select a plaintext message ( m ) that you wish to
encrypt.
2. Encrypt the Message:
For Data:
 Compute ciphertext ( c = m^e \mod n ).
For Paillier:
 Choose a random ( r ) in ( \mathbb{Z}^*_{n} ).
 Compute ciphertext ( c = g^m \cdot r^n \mod n^2 ).
Decryption Steps
Use the Secret Key:
 For Data:
 Compute ( m = c^d \mod n ).
2.3.2 EXISTING SYSTEM

AES scheme
Another of IBC-based schemes is the difficulty of revoking keys. In traditional
public-key cryptography, keys can be revoked by simply removing them from
the certificate revocation list (CRL). However, in IBC-based schemes, revoking
a key requires updating the master secret key, which can be a complex and
time-consuming process. This makes it challenging to revoke keys in a timely
manner, leaving the system vulnerable to attack-based schemes can be
computationally intensive, which can affect their performance. The use of
bilinear pairings and other cryptographic primitives can result in slower
encryption and decryption times, making them less suitable for high-
performance applications. A promising solution is which allows performing
meaningful computations over encrypted data without decrypting it;
specifically, the decryption of a processed FHE the output of an equivalent
computation over plaintext data.
AES Steps
1. Key Expansion
The original key is expanded into a key schedule, which generates a series of
round keys used in each round of encryption. The key expansion involves:
 Input Key: The original key of size 128, 192, or 256 bits.
 Round Keys: Derived from the original key using a combination of byte
substitution, row shifting, and mixing with round constants.
2. Initial Round
The initial round consists of the following steps:
 Add Round Key: The initial round key is XORed with the plaintext
block.
3. Main Rounds
The main rounds consist of the following four operations (repeated for the
specified number of rounds):
1. Sub Bytes: Each byte of the state is replaced with its corresponding byte
from a predefined substitution box (S-box).
2. Shift Rows: The rows of the state are shifted cyclically to the left. The
first row is unchanged, the second row is shifted by one byte, the third by
two bytes, and the fourth by three bytes.
3. Mix Columns: Each column of the state is mixed by applying a linear
transformation. This step combines the four bytes of each column.
4. Add Round Key: The round key is XORed with the state.
4. Final Round
The final round consists of three operations:
1. Sub Bytes: Same as in the main rounds.
2. Shift Rows: Same as in the main rounds.
3. AddRoundKey: The last round key is XORed with the state.
 CHAPTER 3
REQUIREMENTS ENGINEERING
3.1 GENERAL
Parse Encrypt Execute Verify (PEEV) is a framework designed to enable
verifiable operations on encrypted data using Fully Homomorphic Encryption
(FHE). In the context of Requirements Engineering, it focuses on securing
sensitive information while still allowing computations to be performed on that
data.
3.2 HARDWARE REQUIREMENTS
The Parse Encrypt Execute Verify (PEEV) framework, which utilizes Fully
Homomorphic Encryption (FHE), has specific hardware requirements due to the
resource-intensive nature of FHE operations.

HARDWARE REQUIREMENTS
 Processor : Dual core 2 duos.
 Ram : 8GB DD RAM
 Hard disk : 250 GB
3.3 SOFTWARE REQUIREMENTS
The Parse Encrypt Execute Verify (PEEV) framework, which leverages Fully
Homomorphic Encryption (FHE), has specific software requirements to
efficiently implement and manage encrypted computations.

SOFTWARE REQUIREMENTS
 Front end : J2EE (jsp, servlet)
 Back end : MYSQL 5.5
 Operating system : Windows 10
 IDE : Eclipse
3.4 FUNCTIONAL REQUIREMENTS
The Parse Encrypt Execute Verify (PEEV) framework, built around Fully
Homomorphic Encryption (FHE), defines a series of functional requirements to
ensure secure and verifiable operations on encrypted data. Below is a
breakdown of these functional requirements:
1. Parsing (Parse):
 Requirement Extraction: The system must be able to parse input data or
requirements, identifying the relevant components for computation.
 Data Preprocessing: It must process and structure data, ensuring it is
formatted appropriately for encryption, handling diverse data types and
structures (e.g., numeric, textual).
 Schema Handling: The system should support various data schemas and
formats for seamless integration with different data sources and types.
2. Encryption (Encrypt):
 Data Encryption: The system must support encryption of data using
Fully Homomorphic Encryption (FHE) schemes, ensuring data
confidentiality while retaining the ability to perform computations on the
encrypted data.
 Key Management: The system must provide secure generation, storage,
and management of encryption keys, ensuring that they remain
confidential and are only accessible by authorized entities.
 Efficient Encryption: The encryption process should be optimized for
performance to handle large datasets without excessive computational
overhead.
3. Execution (Execute):
 Homomorphic Computation: The system must enable computations
directly on the encrypted data, supporting basic mathematical operations
such as addition, multiplication, and more complex operations, without
decrypting the data.
  Support for Complex Operations: The system should support complex
queries and algorithms that require homomorphic computations, ensuring
compatibility with the intended application (e.g., machine learning,
statistical analysis).
 Performance Optimization: The execution of computations on
encrypted data should be optimized for speed and efficiency, considering
the heavy computational load of FHE operations.
4. Verification (Verify):
 Result Verification: After performing computations on encrypted data,
the system must be able to verify that the results are correct without
decrypting the data, using appropriate verification mechanisms.
 Consistency Check: The system should verify that the computations
performed on encrypted data are consistent with the expected results,
ensuring that no errors occurred during the encrypted processing.
 Auditability: There must be a traceable and verifiable audit trail for each
operation to ensure accountability, with mechanisms to verify that no
unauthorized access or modification occurred during any part of the
process.
5. Security and Privacy:
 End-to-End Security: All stages (Parse, Encrypt, Execute, Verify) must
maintain high security standards to protect data integrity and
confidentiality throughout the entire process.
 Data Integrity: The system must ensure that data is not tampered with at
any stage, providing mechanisms to detect and prevent unauthorized
modifications.
 Access Control: The system must ensure that only authorized entities can
access sensitive data and the associated encryption keys, implementing
fine-grained access controls and authentication mechanisms.

6. Scalability and Performance:
 Handling Large Datasets: The framework must support large-scale
datasets, enabling efficient parsing, encryption, execution, and
verification of data without significant performance degradation.
 Parallel and Distributed Execution: The system should support parallel
or distributed computation across multiple processors or machines,
ensuring that the heavy computational load of FHE is managed
effectively.
7. User Interface and Interaction:
 User-Friendly Interface: The framework should provide a clear
interface for users to define computations, manage encryption keys, and
interact with encrypted data.
 Error Handling and Feedback: The system must offer informative error
messages and feedback during each step (Parse, Encrypt, Execute,
Verify), helping users identify and resolve issues.
3.5 NON-FUNCTIONAL REQUIREMENTS
The Parse Encrypt Execute Verify (PEEV) framework, leveraging Fully
Homomorphic Encryption (FHE), also has several non-functional
requirements to ensure the system operates effectively and efficiently. Here’s a
brief overview of these non-functional requirements:
1. Performance:
 Efficiency: The system must efficiently handle large-scale computations
on encrypted data, minimizing latency and computational overhead
associated with FHE operations.
 Scalability: It should scale to handle increasing data sizes and
computational complexity without significant performance degradation,
including the ability to distribute computations across multiple systems if
needed.
2. Security:
  Data Confidentiality: Ensure that the data remains confidential
throughout the entire process (Parse, Encrypt, Execute, Verify) by using
strong encryption techniques.
 Integrity: Guarantee the integrity of data, computations, and results,
ensuring that no unauthorized changes or tampering occur during the
process.
 Authentication & Authorization: Implement strict authentication and
access controls to ensure that only authorized entities can access or
modify encrypted data and encryption keys.
3. Reliability:
 Fault Tolerance: The system should be resilient to hardware or software
failures, with mechanisms to recover from failures without data loss or
corruption.
 Consistency: The system must maintain consistency across all modules,
ensuring that operations are accurately reflected in each step, particularly
during parallel or distributed execution.
4. Usability:
 User-Friendliness: The system should have an intuitive interface for
users to interact with, allowing easy configuration of encryption,
computation, and verification processes.
 Error Handling: Provide clear error messages and debugging tools to
help users identify and resolve issues during the parsing, encryption,
execution, or verification stages.
5. Interoperability:
 Integration with Other Systems: The framework should be able to
integrate with existing systems and data sources, supporting common
data formats and protocols (e.g., JSON, XML, SQL databases).
  Cross-Platform Support: It should be compatible across different
operating systems and computing environments, facilitating widespread
deployment.
6. Compliance and Standards:
 Regulatory Compliance: The framework must comply with relevant
privacy and security regulations (e.g., GDPR, HIPAA) to ensure lawful
handling of sensitive data.
 Cryptographic Standards: The system should adhere to established
cryptographic standards and best practices, ensuring the robustness and
trustworthiness of the encryption techniques.
7. Maintainability:
 Code Maintainability: The system should be modular and well-
documented, making it easier to maintain, upgrade, and troubleshoot.
 Extensibility: The framework should allow for easy extensions or
integrations with new cryptographic schemes, algorithms, or additional
processing modules in the future.
8. Resource Efficiency:
 Minimal Resource Consumption: The framework should operate
efficiently with respect to CPU, memory, and storage usage, even when
dealing with large encrypted datasets.
 Energy Efficiency: It should also be mindful of energy consumption,
particularly in large-scale or cloud-based deployments.

3.6 DOMAIN REQUIREMENT

The Parse Encrypt Execute Verify (PEEV) framework, which is built around
Fully Homomorphic Encryption (FHE), operates within a specific domain that
defines the context in which it is used.
1. Data Privacy and Confidentiality:
 The primary domain requirement is the ability to process sensitive data
while maintaining privacy. This is achieved by performing computations
on encrypted data without ever needing to decrypt it, ensuring that the
data remains confidential throughout its lifecycle.
 This is especially important in domains like healthcare, finance, and
government, where handling private, regulated data is a core concern.
2. Support for Complex Computations:
 The framework must be capable of handling complex computations on
encrypted data, such as statistical analysis, machine learning, or data
analytics, that require mathematical operations on large datasets.
 The ability to support advanced algorithms without decrypting the data is
critical in domains where data processing is essential but privacy must be
preserved.
3. Compliance with Regulations:
 The PEEV framework must meet domain-specific regulatory
requirements, such as those found in GDPR (General Data Protection
Regulation), HIPAA (Health Insurance Portability and Accountability
Act), or financial regulations, which govern the handling of personal and
sensitive data.
 This involves ensuring that data processing practices within the
framework are compliant with these legal and regulatory standards.
4. Verification and Accountability:
 In domains requiring transparency (e.g., financial audits or sensitive
government processes), the framework must provide mechanisms for
verifiable results. This includes ensuring that the computations on
encrypted data are traceable and auditable.
 The framework must enable verifiable results without revealing the actual
data, ensuring trust and accountability in the process.
5. Performance for Large-Scale Data:
 The framework must support the processing of large datasets common in
big data applications, such as healthcare data, financial transactions, or
IoT data.
 It should be able to scale efficiently to handle the heavy computational
load associated with FHE, ensuring that performance is not compromised
even with large and complex datasets.
6. Integration with Existing Systems:
 The PEEV framework must be interactable with existing systems in the
relevant domain, such as data storage systems, cloud platforms, or
enterprise software. This includes support for standard data formats and
protocols commonly used in the domain (e.g., SQL databases, REST
APIs).
7. Security Standards:
 The framework must adhere to domain-specific security standards and
best practices, ensuring that encryption, key management, and access
control mechanisms meet industry standards for data protection.
 CHAPTER 4
DESIGN ENGINEERING
4.1 GENERAL
In the context of Design Engineering, the Parse Encrypt Execute Verify (PEEV)
framework, which is based on Fully Homomorphic Encryption (FHE), can be
viewed as a system that integrates cryptographic methods with the design and
engineering processes to ensure secure, private, and verifiable computations on
sensitive data.
4.2 SYSTEM ARCHITECTURE

EXPLANATION
The Parse Encrypt Execute Verify (PEEV) framework, which leverages Fully
Homomorphic Encryption (FHE), has a system architecture designed to enable
secure computations on encrypted data, ensuring privacy and correctness
without needing to decrypt the data.
 Parse Module: Parses and structures data for encryption.
 Encrypt Module: Encrypts data using FHE to ensure confidentiality.
 Execute Module: Performs computations directly on encrypted data
using FHE.
 Verify Module: Verifies the correctness of computations without
decrypting the data.
 System Integration and Communication: Ensures smooth data flow
and secure communication between modules.
 Key Management and Security: Manages encryption keys securely to
maintain confidentiality.
 User Interface: Provides a user-friendly interface for interaction,
configuration, and monitoring