Search

Fairness is a desirable property in secure computation; informally it means that if one party gets the output of the function, then all parties get the output. Alas, an implication of Cleve's result [18th ACM Symposium on the Theory of Computing, 1986] is that when there is no honest majority, in particular in the important case of the two-party setting, there exist functions that cannot be computed with fairness. In a surprising result, Gordon et al. [18th ACM Symposium on the Theory of Computing, 2008; J. ACM, 58 (2011), 24] showed that some interesting functions can be computed with fairness in the two-party setting and reopened the question of understanding which Boolean functions can be computed with fairness, and which cannot. Our main result in this work is a complete characterization of the (symmetric) Boolean functions that can be computed with fairness in the two-party setting; this settles an open problem of Gordon et al. The statement of the characterization is quite simple: A function can be computed with fairness if and only if the all-one vector or the all-zero vector are in the affine span of either the rows or the columns of the matrix describing the function. This is true for both deterministic and randomized functions. To prove the possibility result, we modify the protocol of Gordon et al.; the resulting protocol computes with full security (and in particular with fairness) all functions that are computable with fairness. Complementing this result, we also show that any function that does not satisfy the aforementioned condition can be reduced to a fair sampling protocol, which, by Agrawal and Prabhakaran [Advances in Cryptology - CRYPTO 2013, 2013], cannot be computed with fairness. [ABSTRACT FROM AUTHOR]

The secure computation of symmetric encryption schemes using Yao's garbled circuits, such as AES, allows two parties, where one holds a plaintext block m and the other holds a key k, to compute E n c (k , m) without leaking m and k to one another. Due to its wide application prospects, secure AES computation has received much attention. However, the evaluation of AES circuits using Yao's garbled circuits incurs substantial communication overhead. To further improve its efficiency, this paper, upon observing the special structures of AES circuits and the symmetries of an S-box, proposes a novel ciphertext reduction scheme for garbling an S-box in the last SubBytes step. Unlike the idea of traditional Yao's garbled circuits, where the circuit generator uses the input wire labels to encrypt the corresponding output wire labels, our garbling scheme uses the input wire labels of an S-box to encrypt the corresponding "flip bit strings". This approach leads to a significant performance improvement in our garbling scheme, which necessitates only 2 8 ciphertexts to garble an S-box and a single invocation of a cryptographic primitive for decryption compared to the best result in previous work that requires 8 × 2 8 ciphertexts to garble an S-box and multiple invocations of a cryptographic primitive for decryption. Crucially, the proposed scheme provides a new idea to improve the performance of Yao's garbled circuits. We analyze the security of the proposed scheme in the semi-honest model and experimentally verify its efficiency. [ABSTRACT FROM AUTHOR]

This paper presents a comprehensive exploration into the integration of Internet of Things (IoT), big data analysis, cloud computing, and Artificial Intelligence (AI), which has led to an unprecedented era of connectivity. We delve into the emerging trend of machine learning on embedded devices, enabling tasks in resource-limited environments. However, the widespread adoption of machine learning raises significant privacy concerns, necessitating the development of privacy-preserving techniques. One such technique, secure multi-party computation (MPC), allows collaborative computations without exposing private inputs. Despite its potential, complex protocols and communication interactions hinder performance, especially on resource-constrained devices. Efforts to enhance efficiency have been made, but scalability remains a challenge. Given the success of GPUs in deep learning, leveraging embedded GPUs, such as those offered by NVIDIA, emerges as a promising solution. Therefore, we propose an Embedded GPU-based Secure Two-party Computation (EG-STC) framework for Artificial Intelligence (AI) systems. To the best of our knowledge, this work represents the first endeavor to fully implement machine learning model training based on secure two-party computing on the Embedded GPU platform. Our experimental results demonstrate the effectiveness of EG-STC. On an embedded GPU with a power draw of 5 W, our implementation achieved a secure two-party matrix multiplication throughput of 5881.5 kilo-operations per millisecond (kops/ms), with an energy efficiency ratio of 1176.3 kops/ms/W. Furthermore, lever-aging our EG-STC framework, we achieved an overall time acceleration ratio of 5--6 times compared to solutions running on server-grade CPUs. Our solution also exhibited a reduced runtime, requiring only 60% to 70% of the runtime of previously best-known methods on the same platform. In summary, our research contributes to the advancement of secure and efficient machine learning implementations on resource-constrained embedded devices, paving the way for broader adoption of AI technologies in various applications. [ABSTRACT FROM AUTHOR]

Summary: Secure two‐party computation allows a pair of parties to compute a function together while keeping their inputs private. Ultimately, each party receives only its own correct output. In this paper, a post‐quantum secure two‐party computation protocol is proposed that can be used to effectively block malicious parties. The protocol solves the problems of traditional protocols based on garbled circuits, which are vulnerable to quantum attacks, high communication costs and low computational efficiency. The input garbled keys of the circuit constructor is structured as a Learning with Error (LWE) equation, enabling the circuit constructor to employ a zero‐knowledge proof that demonstrates the uniformity of inputs across all circuits.In the key transfer phase, an LWE‐based batch single‐choice cut‐and‐choose oblivious transfer is proposed to avoid selective failure attacks. In addition, the protocol employs a penalty mechanism to detect if the circuit constructor has generated an incorrect circuit. We have compared the communication overhead of this protocol with three other secure two‐party computation protocols based on Cut‐and‐Choose technology. The analytical results show that this protocol has the best error probability and is resilient to quantum attacks under the malicious adversary model. In addition, with appropriate parameters, the protocol is able to reduce its communication bandwidth by an average of 40.41%. [ABSTRACT FROM AUTHOR]

In secure two-party computation protocols, the cut-and-choose paradigm is used to prevent the malicious party who constructs the garbled circuits from cheating. In previous realization of the cut-and-choose technique on the garbled circuits, the delivery of the random keys is divided into multiple stages. Thus, the round complexity is high and the consistency of cut-and-choose challenge should be proved. Based on DDH assumption, we build a so-called cut-and-choose bilateral oblivious transfer protocol, which transfers all necessary keys of garbled circuits in one process. Specifically, in our oblivious transfer protocol, the sender inputs two pairs (k 0 1 , k 1 1) , (k 0 2 , k 1 2) and a bit τ ; the receiver inputs two bits σ and j. After the protocol execution, the receiver obtains k τ 1 , k σ 2 for j = 1 , and k 0 1 , k 1 1 , k 0 2 , k 1 2 for j = 0 . The protocol inherit the cut-and-choose OT protocol in Lindell and Pinkas (Proceedings of the 8th conference on theory of cryptography, Springer, 2011), and can be applied into the state-of-the-art cut-and-choose secure two party computation protocol without any obstacles. By the cut-and-choose bilateral oblivious transfer protocol, the cut-and-choose challenge j is no need to be opened anymore, therefore the consistency proof of j is omitted, and the round complexity of secure two-party computation protocol can be decreased. [ABSTRACT FROM AUTHOR]

With the proliferation of data and machine learning techniques, there is a growing need to develop methods that enable collaborative training and prediction of sensitive data while preserving privacy. This paper proposes a new protocol for privacy-preserving Naive Bayes classification using secure two-party computation (STPC). The key idea is to split the training data between two non-colluding servers using STPC to train the model without leaking information. The servers secretly share their data and the intermediate computations using cryptographic techniques like Beaver's multiplication triples and Yao's garbled circuits. We implement and evaluate our protocols on the MNIST dataset, demonstrating that they achieve the same accuracy as plaintext computation with reasonable overhead. A formal security analysis in the semi-honest model shows that the scheme protects the privacy of the training data. Our work advances privacy-preserving machine learning by enabling secure outsourced Naive Bayes classification with applications such as fraud detection, medical diagnosis, and predictive analytics on confidential data from multiple entities. The modular design allows embedding different secure matrix multiplication techniques, making the framework adaptable. This line of research paves the way for practical and secure data mining in a distributed manner, upholding stringent privacy regulations.

We consider the problem of constant-round secure two-party computation in the presence of active (malicious) adversaries. We present the first protocol that has only a constant multiplicative communication overhead compared to Yao’s protocol for passive adversaries, and can be implemented in the plain model by only making a black-box use of (parallel) oblivious transfer and a pseudo-random generator. This improves over the polylogarithmic overhead of the previous best protocol. A similar result could previously be obtained only in an amortized setting, using preprocessing, or by assuming bit-oblivious-transfer as an ideal primitive that has a constant cost. We present two variants of this result, one which is aimed at minimizing the number of oblivious transfers and another which is aimed at optimizing concrete efficiency. Our protocols are based on a novel combination of previous techniques together with a new efficient protocol to certify that pairs of strings transmitted via oblivious transfer satisfy a global relation. Settling for “security with correlated abort”, the concrete communication complexity of the second variant of our protocol can beat the best previous protocols with the same kind of security even for realistic values of the circuit size and the security parameter. This variant is particularly attractive in the offline–online setting, where the online cost is dominated by a single evaluation of an authenticated garbled circuit, and can also be made non-interactive using the Fiat–Shamir heuristic. [ABSTRACT FROM AUTHOR]

In order to solve the problem that excessive false positives in the detection of encrypted malicious traffic based on machine learning, secure two-party computation was used to compare character segments between network traffic and intrusion detection rulers without revealing the data content.Based on the comparison results, an intrusion detection feature matching algorithm was designed to accurately match keywords.A random verification strategy for users’ input was also proposed to facilitate the method.As a result, malicious users couldn’t use arbitrary data to participate in secure two-party calculations and avoid confirmation.The security and resource consumption of the method were theoretically analyzed and verified by a combination of real deployment and simulation experiments.The experimental results show that the proposed method can significantly improve the detection performance with low system resources.

Online medicine diagnosis based on pathological images has been regarded as a pervasive method due to the advances in electronic healthcare and Internet of Things (IoT), however, it also causes storage and computing stress on the local IoT devices. To solve this problem, a nature way is to outsource images to cloud servers. Unfortunately, a range of security and privacy issues arise while delegating both storage and computing to the untrusted external servers. In this paper, we present a privacy‐preserving feature extraction and retrieval scheme over medical images, which allows images storage and processing on two separate cloud servers. We share the images using secret sharing technology and design a set of secure two‐party computation protocols between the two cloud servers. Then a privacy‐preserving convolutional neural networks (CNN) framework is constructed to achieve feature extraction, classification and retrieval of images in the encrypted domain. We analyse and evaluate our scheme in terms of both security and efficiency. The results indicate that the proposed secure protocols in our scheme can significantly reduce the computation overhead while protecting the privacy of images as well as the data generated during execution on cloud servers and final results. The performance of our scheme in image feature extraction, classification and retrieval is at a similar level comparable to the scheme based on original CNN in plaintext. [ABSTRACT FROM AUTHOR]

We present a secure static-analysis-as-a-service (SaaaS) system where a client may outsource static analysis to the cloud. To address copyright concerns associated with SaaaS, clients are allowed to encrypt the source code of a target program and upload it to the cloud. Our goal is to secure the privacy of the design and implementation of static analysis as well as the source code of the target program. Considering a family of static analyses written in Datalog, we propose a generic protocol that combines homomorphic encryption (HE) with secure two-party computation to manage the huge cost of HE operations. The server occasionally delegates sub-parts of analysis which are costly in the cipher-world to the client without exposing the design of analysis. During server-client interactions, the information of both sides (client and server) is not leaked to the opposite. We evaluated our system on two static analyses in Datalog in secrecy, which have not been feasible using the previous techniques. For example, Andersen pointer analysis is completed in an average of 45 mins for 14 C programs comprising up to 1.6 KLoC.

Emerging privacy-preserving technologies help protect sensitive data during application executions. Recently, the secure two-party computing (TPC) scheme has demonstrated its potential, especially for the secure model inference of a deep learning application by protecting both the user input data and the model parameters. Nevertheless, existing TPC protocols incur excessive communications during the program execution, which lengthens the execution time. In this work, we propose the precomputing scheme, POPS, to address the problem, which is done by shifting the required communications from during the execution to the time prior to the execution. Particular, the multiplication triple generation is computed beforehand with POPS to remove the overhead at runtime. We have analyzed the TPC protocols to ensure that the precomputing scheme conforms the existing secure protocols. Our results show that POPS takes a step forward in the secure inference by delivering up to 20 × and 5 × speedups against the prior work for the microbenchmark and the convolutional neural network experiments, respectively. [ABSTRACT FROM AUTHOR]

Private integer comparison has been an essential computation function for many applications, including online auction, credential identification, data mining, and joint bidding. In the setting of two-party computation, two parties with private inputs ( $x$ and $y$ ) want to jointly compare them without revealing the value of those inputs to others (also known as the Millionaires’ problem) while the output should ensure correctness and preserve data privacy. The private inputs only can be revealed if they are equal, i.e., $x=y$ . Many related works have been proposed to solve the integer comparison problem in various settings, focusing on different properties such as round and computation complexity. Most solutions decompose integers into bitwise representation and then securely evaluate the function in a Boolean circuit on encrypted bits. However, this type of solution is costly (especially for large integers) as each bit requires encryption and decryption. In this paper, we transform the private integer comparison into a block comparison problem. In particular, we employ a block vectorization mechanism to encode the private inputs into blocks. We show the security of our two-party protocol in the semi-honest model. Also, we implement the protocol to demonstrate its efficiency using block vectorization mechanism and homomorphic encryption. The experimental result proves that our proposed solution achieves high efficiency, particularly for large integer comparisons.

Two-party computation allows two clients to jointly compute an arbitrary function of their inputs without revealing these inputs to each other. In this study, we adopt a server-aided model, in which a set of computing servers performs computation using the inputs of two clients. In the (k, $n$ ) threshold secret sharing scheme, input $s$ is divided into $n$ shares and can be recovered from $k$ shares, where $k$ is a threshold. Typically, the multiplication of shares increases the polynomial’s degree from $(k-1)$ to $(2k-2)$ , thus increasing the number of shares required from $k$ to $2k-1$ . Because each server typically holds only one share, the number of servers required also increases to $2k-1$ . Therefore, a set of $n$ servers can compute multiplication securely only if the adversary corrupts at most $k-1 < n/2$ servers. In this study, we differentiate ${N}$ , which is the number of required servers, and ${n}$ , which is the parameter of the (k, $n$ ) threshold secret sharing scheme. We propose a method of multiplication by using only $N\ge k$ servers. This is implemented by sending two shares of the same input to each server. In a “normal” method, sending multiple shares to one server violates security because $k$ shares can be leaked from $k-1$ servers. We overcome this by implementing a different functionality, where each share is first encrypted with a different random number (encrypted share) before being sent to a server. Instead of the “normal shares” of ab, our protocol computes the encrypted shares of ab using the encrypted shares of $a$ and $b$ . We show that the proposed method is secure against a non-colluding semi-honest adversary. Moreover, we implement our method in MATLAB and show its efficiency.

We study the problem of private set intersection (PSI). In this problem, there are two entities $E_{i}$ , for $i=1, 2$ , each storing a set $\mathcal {P}_{i}$ , whose elements are picked from a finite set $\mathbb {S}_{K}$ , on $N_{i}$ replicated and non-colluding databases. It is required to determine the set intersection ${\mathcal {P}}_{1} \cap {\mathcal {P}} _{2}$ without leaking any information about the remaining elements to the other entity, and to do this with the least amount of downloaded bits. We first show that the PSI problem can be recast as a multi-message symmetric private information retrieval (MM-SPIR) problem with certain added restrictions. Next, as a stand-alone result, we derive the information-theoretic sum capacity of MM-SPIR, $C_{MM-SPIR}$. We show that with $K$ messages, $N$ databases, and a given size of the desired message set $P$ , the exact capacity of MM-SPIR is $C_{MM-SPIR} = 1 - \frac {1}{N}$ when $P \leq K-1$ , provided that the entropy of the common randomness $S$ satisfies $H(S) \geq \frac {P}{N-1}$ per desired symbol. When $P = K$ , the MM-SPIR capacity is trivially 1 without the need for any common randomness $S$. This result implies that there is no gain for MM-SPIR over successive single-message SPIR (SM-SPIR). For the MM-SPIR problem, we present a novel capacity-achieving scheme which builds seamlessly over the near-optimal scheme of Banawan-Ulukus originally proposed for the multi-message PIR (MM-PIR) problem without any database privacy constraints. Surprisingly, our scheme here is exactly optimal for the MM-SPIR problem for any $P$ , in contrast to the scheme for the MM-PIR problem, which was proved only to be near-optimal. Our scheme is an alternative to the successive usage of the SM-SPIR scheme of Sun-Jafar. Based on this capacity result for the MM-SPIR problem, and after addressing the added requirements in its conversion to the PSI problem, we show that the optimal download cost for the PSI problem is given by $\min \left \{{\left \lceil{ \frac {P_{1} N_{2}}{N_{2}-1}}\right \rceil, \left \lceil{ \frac {P_{2} N_{1}}{N_{1}-1}}\right \rceil }\right \}$ , where $P_{i}$ is the cardinality of set ${\mathcal {P}}_{i}$. [ABSTRACT FROM AUTHOR]

Copyright of Journal on Communication / Tongxin Xuebao is the property of Journal on Communications Editorial Office and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

Copyright of Journal of Computer Engineering & Applications is the property of Beijing Journal of Computer Engineering & Applications Journal Co Ltd. and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

Oblivious transfer (OT) is a significant primitive with wide use in secure two-party computation, private set intersection private and other cryptographic schemes. In the past ten years, different variants of OT primitive like cut-and-choose OT (CCOT) and outsourced OT (OOT), have been proposed so as to satisfy various emerging models. In this paper, we firstly propose and formalize a new primitive called permutable cut-and-choose OT (PCCOT) which generalizes the original CCOT functionality. Furthermore, we construct an efficient PCCOT protocol in the presence of malicious adversaries using the Decisional Diffie-Hellman (DDH) hard assumption. It is worth mentioning that we apply the PCCOT primitive to the efficient construction of secure wildcard pattern matching (WPM) protocol. The WPM functionality allows a party to determine the locations of its pattern with wildcard characters occurs in a long text of another party while revealing nothing to either party in addition to the length of their own inputs. Our proposed secure WPM protocol via PCCOT is secure against semi-honest adversary with 2 rounds and has identical communication cost as the the state-of-the-art scheme.

Biometric verification has been widely deployed in current authentication solutions as it proves the physical presence of individuals. Several solutions have been developed to protect the sensitive biometric data in such systems that provide security against honest-but-curious (a.k.a. semi-honest) attackers. However, in practice, attackers typically do not act honestly and multiple studies have shown severe biometric information leakage in such honest-but-curious solutions when considering dishonest, malicious attackers. In this paper, we propose a provably secure biometric verification protocol to withstand malicious attackers and prevent biometric data from any leakage. The proposed protocol is based on a homomorphically encrypted log likelihood-ratio (HELR) classifier that supports any biometric modality (e.g., face, fingerprint, dynamic signature, etc.) encoded as a fixed-length real-valued feature vector. The HELR classifier performs an accurate and fast biometric recognition. Furthermore, our protocol, which is secure against malicious adversaries, is designed from a protocol secure against semi-honest adversaries enhanced by zero-knowledge proofs. We evaluate both protocols for various security levels and record a sub-second speed (between 0.37s and 0.88s) for the protocol secure against semi-honest adversaries and between 0.95s and 2.50s for the protocol secure against malicious adversaries. [ABSTRACT FROM AUTHOR]

We propose a privacy-preserving face authentication system for smartphones that guarantees security against malicious clients. Using the proposed system, a face feature vector is stored on a remote server in encrypted form. To guarantee security against an honest-but-curious server who may try to learn the private feature vector, we perform a Euclidean distance-based matching score computation on encrypted feature vectors using homomorphic encryption. To provide security against malicious clients, we adopt a blinding technique. We implement the proposed system on a mobile client and a desktop server. Through an experiment with real-world participants, we demonstrate that secure face verification can be completed in real time (within 1.3 s) even when a smartphone is involved, with an Equal Error Rate (EER) of 3.04%. In further experiments with two public face datasets, CFP and ORL, face verification is completed in approximately 1 s with EER of 1.17% and 0.37%, respectively. Our system is two orders of magnitude faster than previous privacy-preserving face verification method with the same security assumptions and functionalities. To achieve this secure real-time computation, we improve the Catalano-Fiore transformation which converts a linear homomorphic encryption scheme into a quadratic scheme, and parallelize the decryption procedure of our system. [ABSTRACT FROM AUTHOR]

Most existing quantum private query (QPQ) protocols can hardly work in the presence of noise. The user Alice may obtain a false database item in noisy environments and both participants may cheat under the disguise of noise, so dealing with the noise needs an overall consideration of error correction, user privacy and database security. However, the only two existing protocols aiming to correct errors in QPQ lack such an overall consideration (at least one party’s privacy can be revealed), and they did not estimate what extent of errors can be tolerated (actually, noise is seldom discussed in quantum two-party secure computations, and to the best of our knowledge, relevant bounds on tolerable errors remain unattainable so far). To solve this problem, we first exemplify how one participant reveals the other party’s privacy in the existing QPQ protocols aiming to correct errors. Then we propose a practical protocol which can really work via noisy channel, that is, the error rate of the retrieved database item is reduced significantly and both parties’ privacy are well protected. Besides, we deduce that the final error rate, user privacy and database security are pairwise in a “trade-off” relationship. By balancing them according to the required level of security and reliability, we obtain an upper bound on tolerable errors. [ABSTRACT FROM AUTHOR]

Ishai, Kushilevitz, Ostrovsky and Sahai (STOC 2007; SIAM J Comput 39(3):1121–1152, 2009) introduced the powerful "MPC-in-the-head" technique that provided a general transformation of information-theoretic MPC protocols secure against passive adversaries to a ZK proof in a "black-box" way. In this work, we extend this technique and provide a generic transformation of any semi-honest secure two-party computation (2PC) protocol (with mild adaptive security guarantees) in the so-called oblivious-transfer hybrid model to an adaptive ZK proof for any NP language, in a "black-box" way assuming only one-way functions. Our basic construction based on Goldreich–Micali–Wigderson's 2PC protocol yields an adaptive ZK proof with communication complexity proportional to quadratic in the size of the circuit implementing the NP relation. Previously such proofs relied on an expensive Karp reduction of the NP language to Graph Hamiltonicity [Lindell and Zarosim (TCC 2009; J Cryptol 24(4):761–799, 2011)]. As an application of our techniques, we show how to obtain a ZK proof with an "input-delayed" property for any NP language without relying on expensive Karp reductions that is black box in the underlying one-way function. Namely, the input-delayed property allows the honest prover's algorithm to receive the actual statement to be proved only in the final round. We further generalize this to obtain a "commit-and-prove" protocol with the same property where the prover commits to a witness w in the second message and proves a statement x regarding the witness w in zero-knowledge where the statement is determined only in the last round. This improves a previous construction of Lapidot and Shamir (Crypto 1990) that was designed specifically for the Graph Hamiltonicity problem and relied on the underlying primitives in a non-black-box way. Additionally, we provide a general transformation to construct a randomized encoding of a function f from any 2PC protocol that securely computes a related functionality (in a black-box way) from one-way functions. We show that if the 2PC protocol has mild adaptive security guarantees (which are satisfied by both the Yao's and GMW's protocol), then the resulting randomized encoding can be decomposed to an offline/online encoding. [ABSTRACT FROM AUTHOR]

Secure two-party computation evaluates a function among two distributed parties without revealing the parties' inputs except for the function's outputs. Secure two-party computation can be applied into various fields like cloud computing, which is a composition of distribute computing, parallel computing and utility computing etc. Rational secure two-party computation may achieve some desirable properties under two assumptions deriving from STOC 2004. However, the emergence of new computing paradigms like pay-as-you-go model restricts the application of rational protocols. Previous adversaries does not consider payment in secure two-party protocols. Therefore, new type of adversaries should be propose for these new paradigms. In this paper, we address this problem by proposing a new kind of rational adversary, who consider payment in his relaxed utilities. The utilities are based on economic incentives instead of standard assumptions. Furthermore, the new rational adversary is assumed to negotiate with rational parties in protocols. It's similar to "cost corruption" but more flexible. Our new adversary can dynamically negotiate with each rational party in different phases in order to maximize his utilities. To verify the validity of the new adversary, we model a rational secure two-party protocol, which inherits the hybrid framework of STOC 2007. We also prove the security in the presence of the new rational adversary under ideal/real paradigm. [ABSTRACT FROM AUTHOR]

Speech recognition technology has been in use for a long time but with the last advancements of mobile device technology, it is now easier to get access to it. Nowadays, people use speech recognition speaking to their smartphones, using their voices to interact with it. The recognition process is also faster, more effective and more efficient due to new computer architectures that bring more computational power and as a result of machine learning advancements. Nowadays, to conduct speech recognition, we can consider a scenario where a user records its speech with a smartphone, sends it to a server, and the server performs the recognition using the recognition models and the computational power it has. But Security system may be defined as mixing between multi method and tools to improve goal. The use of Garbled Circuits was only been seen as of theoretical interest for a long time, but with last year advances, they are now starting to be tested and used in some practical scenarios. Hidden Markov Models are widely used models in speech recognition representing the acoustic characteristics of spoken language. This paper introduces the study security-preserving speech recognition and walk. Using Hidden Markov Models and Garbled Circuits. [ABSTRACT FROM AUTHOR]

The problem of generating an RSA composite in a distributed manner without leaking its factorization is particularly challenging and useful in many cryptographic protocols. Our first contribution is the first non-generic fully simulatable protocol for distributively generating an RSA composite with security against malicious behavior. Our second contribution is a complete Paillier (in: EUROCRYPT, pp 223-238, 1999) threshold encryption scheme in the two-party setting with security against malicious attacks. We further describe how to extend our protocols to the multiparty setting with dishonest majority. Our RSA key generation protocol is comprised of the following subprotocols: (i) a distributed protocol for generation of an RSA composite and (ii) a biprimality test for verifying the validity of the generated composite. Our Paillier threshold encryption scheme uses the RSA composite for the public key and is comprised of the following subprotocols: (i) a distributed generation of the corresponding secret key shares and (ii) a distributed decryption protocol for decrypting according to Paillier. [ABSTRACT FROM AUTHOR]

Publicly Verifiable Computation (PVC) enables computationally weak trusted sources to outsource several computations to some more powerful public untrusted clouds. On issuing a query, the public cloud replies the result of the function evaluation with a witness vouching for correctness of computation. This primitive requires high efficiency and public verifiability. However, existing PVC constructions all request trusted sources to know delegated function beforehand, and thus it fails to meet diverse requirements, especially outsourced target unknown need to be jointly computed among different entities in a privacy-preserving manner. To strengthen current PVC's flexibility, we proposed a new primitive called Secure Collaborative PVC (SCPVC), where TTP is responsible only for initializing system parameter and publishing some information in its bulletin. After some rounds, the public cloud owns lots of functions outsourced in PVC ways. The private cloud works out an algebraic operation structure L, which involves some functions provided by public cloud and himself. Based on L, they jointly perform the protocol to generate the target function. At the end of the protocol, the public cloud obtains target function while not disclosing respective secrets. Due to the misbehavior of the public cloud, this mechanism allows the private cloud to check the integrity of target function and any client to verify the correctness of results. Our scheme without jointly computing is a typical existing PVC scheme. Therefore, our protocol is compatible with the prevailing publicly verifiable computation Scheme. Before investigating SCPVC, we tailored two secure two-party polynomial computation protocols using 1-out-of-l Oblivious Transfer protocol as the main building block to SCPVC. More preciously, polynomial multiplication protocol transforms two polynomials multiplication into another two addition such that the result of sum is equal to the result of multiplication. Similarly, polynomial addition protocol is as same as multiplication protocol converts two polynomials addition into another two multiplication.