The outsourcing process is computationally secure if it is performed without unveiling to the other external agent or cloud, either the original data or the actual solution to the computations. Secure multiparty computation computes a certain function without revealing their private secret information.
We focus on how to securely outsource computation task to the cloud and propose a secure outsourcing multiparty computation protocol on lattice-based encrypted data in two-cloud-servers scenario. Our main idea is to transform the outsourced data respectively encrypted by different users' public keys to the ones that are encrypted by the same two private keys of the two assisted servers so that it is feasible to operate on the transformed ciphertexts to compute an encrypted result following the function to be computed. In order to keep the privacy of the result, the two servers cooperatively produce a custom-made result for each user that is authorized to get the result so that all authorized users can recover the desired result while other unauthorized ones including the two servers cannot. Compared with previous research, our protocol is completely noninteractive between any users, and both of the computation and the communication complexities of each user in our solution are independent of the computing function.
Cloud computing is becoming concerned both in academia and industry and one of the most important applications is outsourced computation. A computationally weak client out sources tasks to one or more workers in cloud, and this is called outsourced computation. This paper presents an outsourced protocol based on Kamara's scheme [19], and it allows the client to outsource their computation to more than one workers while keeping privacy and correctness. Kamara proposed security definitions, while regretfully, didn't show the description of the protocol. This paper presents a specific scheme in which the workers computes directly on shares that client send to them, so the workers don't have to interactive with each other. This protocol has these advantages: the protocol keeps privacy of the original input, the workers have no interactivity with each other during the execution, the protocol keeps the threshold unchanged.
Secure Outsourced Computation (SOC) is a computing paradigm where resource-constrained clients can offload their data to servers for compute-intensive tasks on a pay-per-work model, while ensuring the security and privacy of clients’ data. Rooted in Secure Multi-Party Computation (MPC), SOC supports an arbitrary number of clients and a wide range of computational tasks, thus attracting growing attention in recent years. Existing research has focused predominantly on specific features of SOC, failing to fully address multiple critical requirements for real-world deployment—including privacy, robustness, cost-effectiveness, and efficiency. This creates a disconnect between theoretical frameworks and practical application scenarios. In this paper, we propose a secure outsourced computation scheme based on Three-Party Computation (3PC) over a ring. Our scheme is distinguished by its support for multiple security settings, while guaranteeing Guaranteed Output Delivery (GOD) and achieving high efficiency. We further formally prove the security of our scheme under each security model in the setting of honest-majority. In addition, we present a detailed complexity analysis and perform extensive practical performance evaluations, wherein the results validate its efficiency.
A client wishes to outsource computation on confidential data to a network of parties. He does not trust a single party but believes that multiple parties do not collude. To solve this problem, we use the idea of treating one of the parties as a helper. A helper assists computation only. Often using more parties ensures confidentiality despite more corrupted parties. This does not hold for adding a helper. But a helper can in some cases lower the amount of communication asymptotically to the theoretical minimum of one bit per AND gate, improving significantly on schemes without a helper. It can also allow for very efficient computations of certain functions, as we show for the exponential function with public base.
Abstract. In secure delegatable computation, computationally weak devices (or clients) wish to outsource their computation and data to an untrusted server in the cloud. While most earlier work considers the general question of how to securely outsource any computation to the cloud server, we focus on concrete and important functionalities and give the first protocol for the pattern matching problem in the cloud. Loosely speaking, this problem considers a text T that is outsourced to the cloud S by a client CT. In a query phase, clients C1,...,Cl runanefficientprotocol with the server S and the client CT in order to learn the positions at which a pattern of length m matches the text (and nothing beyond that). This is called the outsourced pattern matching problem and is highly motivated in the context of delegatable computing since it offers storage alternatives for massive databases that contain confidential data (e.g., health related data about patient history). Our constructions offer simulation-based security in the presence of semi-honest and malicious adversaries (in the random oracle model) and limit the communication in the query phase to O(m) bits plus the number of occurrences — which is optimal. In contrast to generic solutions for delegatable computation, our schemes do not rely on fully homomorphic encryption but instead uses novel ideas for solving pattern matching, based on efficiently solvable instances of the subset sum problem. 1