## Contact

## Office Location

805 Columbus Avenue

622 Interdisciplinary Science and Engineering Complex (ISEC)

Boston, MA 02120

## Mailing Address

Northeastern University

ATTN: Daniel Wichs, 435 ISEC

360 Huntington Avenue

Boston, MA 02115

## Research Interests

- Modern cryptography
- Information security

## Education

- PhD in computer science, New York University
- MS in computer science, Stanford University
- BS in mathematics, Stanford University

## Biography

Daniel Wichs is an associate professor of computer science in the Khoury College of Computer Sciences at Northeastern University. Prior to joining Northeastern, he was a postdoctoral researcher at the IBM T.J. Watson Research Center from 2011 to 2013 supported by the prestigious Josef Raviv Memorial Fellowship.

Wichs researches all aspects of modern cryptography, including its theoretical foundations and its applications to information security. His recent research relates to the cryptographic challenges involved in outsourcing data and computation to the cloud. In particular, this includes the construction of homomorphic encryption and signature schemes that allow the cloud to compute on digitally encrypted and signed data while maintaining its privacy and authenticity.

## Recent Publications

### Obfuscating Compute-and-Compare Programs under LWE

Daniel Wichs and Giorgos Zirdelis

## Abstract

We show how to obfuscate a large and expressive class of programs, which we call compute-and-compare programs, under the learning-with-errors (LWE) assumption. Each such program CC[f,y]CC[f,y] is parametrized by an arbitrary polynomial-time computable function ff along with a target value yy and we define CC[f,y](x)CC[f,y](x) to output 11 if f(x)=yf(x)=y and 00 otherwise. In other words, the program performs an arbitrary computation ff and then compares its output against a target yy. Our obfuscator satisfies distributional virtual-black-box security, which guarantees that the obfuscated program does not reveal any partial information about the function ff or the target value yy, as long as they are chosen from some distribution where yy has sufficient pseudo-entropy given ff. We also extend our result to multi-bit compute-and-compare programs MBCC[f,y,z](x)MBCC[f,y,z](x)which output a message zz if f(x)=yf(x)=y.

Compute-and-compare programs are powerful enough to capture many interesting obfuscation tasks as special cases. This includes obfuscating conjunctions, and therefore we improve on the prior work of Brakerski et al. (ITCS ’16) which constructed a conjunction obfuscator under a non-standard “entropic” ring-LWE assumption, while here we obfuscate a significantly broader class of programs under standard LWE. We show that our obfuscator has several interesting applications. For example, we can take any encryption scheme and publish an obfuscated plaintext equality tester that allows users to check whether an arbitrary ciphertext encrypts some target value yy; as long as yy has sufficient pseudo-entropy this will not harm semantic security. We can also use our obfuscator to generically upgrade attribute-based encryption to predicate encryption with one-sided attribute-hiding security, as well as witness encryption to indistinguishability obfuscation which is secure for all null circuits. Furthermore, we show that our obfuscator gives new circular-security counter-examples for public-key bit encryption and for unbounded length key cycles.

Our result uses the graph-induced multi-linear maps of Gentry, Gorbunov and Halevi (TCC ’15), but only in a carefully restricted manner which is provably secure under LWE. Our technique is inspired by ideas introduced in a recent work of Goyal, Koppula and Waters (EUROCRYPT ’17) in a seemingly unrelated context.

### Adaptively Secure Garbled Circuits from One-Way Functions

Brett Hemenway and Zahra Jafargholi and Rafail Ostrovsky and Alessandra Scafuro and Daniel Wichs CRYPTO 2016

## Abstract

A garbling scheme is used to garble a circuit *C* and an input *x* in a way that reveals the output *C*(*x*) but hides everything else. In many settings, the circuit can be garbled *off-line* without strict efficiency constraints, but the input must be garbled very efficiently *on-line*, with much lower complexity than evaluating the circuit. Yao’s garbling scheme [31] has essentially optimal on-line complexity, but only achieves *selective security*, where the adversary must choose the input *x* prior to seeing the garbled circuit. It has remained an open problem to achieve *adaptive security*, where the adversary can choose *x* after seeing the garbled circuit, while preserving on-line efficiency.

In this work, we modify Yao’s scheme in a way that allows us to prove adaptive security under one-way functions. In our main instantiation we achieve on-line complexity only proportional to the width *w* of the circuit. Alternatively we can also get an instantiation with on-line complexity only proportional to the depth *d* (and the output size) of the circuit, albeit incurring in a 2O(d)2O(d) security loss in our reduction. More broadly, we relate the on-line complexity of adaptively secure garbling schemes in our framework to a certain type of *pebble* complexity of the circuit. As our main tool, of independent interest, we develop a new notion of *somewhere equivocal* encryption, which allows us to efficiently equivocate on a small subset of the message bits.

### Be Adaptive, Avoid Overcommitting

Be Adaptive, Avoid Overcommitting Zahra Jafargholi, Chethan Kamath, Karen Klein and Ilan Komargodski and Krzysztof Pietrzak and Daniel Wichs CRYPTO 2017

**Abstract**

For many cryptographic primitives, it is relatively easy to achieve selective security (where the adversary commits a-priori to some of the choices to be made later in the attack) but appears difficult to achieve the more natural notion of adaptive security (where the adversary can make all choices on the go as the attack progresses). A series of several recent works shows how to cleverly achieve adaptive security in several such scenarios including generalized selective decryption (Panjwani, TCC ’07 and Fuchsbauer et al., CRYPTO ’15), constrained PRFs (Fuchsbauer et al., ASIACRYPT ’14), and Yao garbled circuits (Jafargholi and Wichs, TCC ’16b). Although the above works expressed vague intuition that they share a common technique, the connection was never made precise. In this work we present a new framework that connects all of these works and allows us to present them in a unified and simplified fashion. Moreover, we use the framework to derive a new result for adaptively secure secret sharing over access structures defined via monotone circuits. We envision that further applications will follow in the future. Underlying our framework is the following simple idea. It is well known that selective security, where the adversary commits to nn-bits of information about his future choices, automatically implies adaptive security at the cost of amplifying the adversary’s advantage by a factor of up to 2n2n. However, in some cases the proof of selective security proceeds via a sequence of hybrids, where each pair of adjacent hybrids locally only requires some smaller partial information consisting of m≪nm≪n bits. The partial information needed might be completely different between different pairs of hybrids, and if we look across all the hybrids we might rely on the entire nn-bit commitment. Nevertheless, the above is sufficient to prove adaptive security, at the cost of amplifying the adversary’s advantage by a factor of only 2m≪2n2m≪2n. In all of our examples using the above framework, the different hybrids are captured by some sort of a graph pebbling game and the amount of information that the adversary needs to commit to in each pair of hybrids is bounded by the maximum number of pebbles in play at any point in time. Therefore, coming up with better strategies for proving adaptive security translates to various pebbling strategies for different types of graphs.

### The Edited Truth

Shafi Goldwasser, Saleet Klein and Daniel Wichs. The Edited Truth, TCC 2017-- Theory of Cryptography Conference

## Abstract

We introduce two new cryptographic notions in the realm of public and symmetric key encryption.

– Encryption with invisible edits is an encryption scheme with two tiers of users: “privileged” and “unprivileged”. Privileged users know a key pair (pk, sk) and “unprivileged” users know a key pair (pk_e, sk_e) which is associated with an underlying edit e to be applied to messages encrypted. When an unprivileged user attempts to decrypt a ciphertext generated by a privileged user of an underlying plaintext m, it will be decrypted to an edited m’=Edit(m,e). Here, Edit is a supported edit function and e is a description of the particular edit. A user shouldn’t be able to tell whether he’s an unprivileged or a privileged user.

– An encryption with deniable edits is an encryption scheme which allows a user who owns a ciphertext c encrypting a large corpus of data m under a secret key sk, to generate an alternative but legitimate looking secret key sk_{c,e}, that decrypts c to an “edited” version of the data m’=Edit(m,e). This generalizes classical receiver deniable encryption, which is a special case of deniable edits where the edit function completely replaces the original data. The new flexibility allows to design solutions with much smaller key sizes than required in classical receiver deniable encryption allowing the key size to only scale with the description size of the edit e which can be much smaller than the plaintext data m.

We construct encryption schemes with invisible and deniable edits for any polynomial-time computable edit function under minimal assumptions: in the public-key setting we require the existence of standard public-key encryption and in the symmetric-key setting require the existence of one-way functions.

The solutions to both problems use common ideas, however there is a significant conceptual difference between deniable edits and invisible edits. Whereas encryption with deniable edits enables a user to modify the meaning of a single ciphertext in hindsight, the goal of encryption with invisible edits is to enable ongoing modifications of multiple ciphertexts

### Adaptively Indistinguishable Garbled Circuits

Adaptively Indistinguishable Garbled Circuits Zahra Jafargholi, Alessandra Scafuro and Daniel Wichs TCC 2017-- Theory of Cryptography Conference

## Abstract

A garbling scheme is used to garble a circuit C and an input x in a way that reveals the output C(x) but hides everything else. An adaptively secure scheme allows the adversary to specify the input x after

seeing the garbled circuit. Applebaum et al. (CRYPTO ’13) showed that in any garbling scheme with adaptive simulation-based security, the size of the garbled input must exceed the output size of the circuit. Here we show how to circumvent this lower bound and achieve significantly better efficiency under the minimal assumption that one-way functions exist by relaxing the security notion from simulation-based to indistinguishability-based.

We rely on the recent work of Hemenway et al. (CRYPTO ’16) which constructed an adaptive simulation-based garbling scheme under one-way functions. The size of the garbled input in their scheme is as large as the output size of the circuit plus a certain pebble complexity of the circuit, where the latter is (e.g.,) bounded by the space complexity of the computation. By building on top of their construction and adapting their proof technique, we show how to remove the output size dependence in their result when considering indistinguishability-based security.

As an application of the above result, we get a symmetric-key functional encryption based on one-way functions, with indistinguishability-based security where the adversary can obtain an unbounded number of function secret keys and then adaptively a single challenge ciphertext. The size of the ciphertext only depends on the maximal pebble complexity of each of the functions but not on the number of functions or their circuit size.

### Multi-Key Searchable Encryption, Revisited

Ariel Hamlin, Abhi Shelat, Mor Weiss, Daniel Wichs: Multi-Key Searchable Encryption, Revisited. Public Key Cryptography (1) 2018: 95-124

**Abstract**

We consider a setting where users store their encrypted documents on a remote server and can selectively share documents with each other. A user should be able to perform keyword searches over all the documents she has access to, including the ones that others shared with her. The contents of the documents, and the search queries, should remain private from the server.

This setting was considered by Popa et al. (NSDI ’14) who developed a new cryptographic primitive called Multi-Key Searchable Encryption (MKSE), together with an instantiation and an implementation within a system called Mylar, to address this goal. Unfortunately, Grubbs et al. (CCS ’16) showed that the proposed MKSE definition fails to provide basic security guarantees, and that the Mylar system is susceptible to simple attacks. Most notably, if a malicious Alice colludes with the server and shares a document with an honest Bob then the privacy of all of Bob’s search queries is lost.

In this work we revisit the notion of MKSE and propose a new strengthened definition that rules out the above attacks. We then construct MKSE schemes meeting our definition. We first give a simple and efficient construction using only pseudorandom functions. This construction achieves our strong security definition at the cost of increasing the server storage overhead relative to Mylar, essentially replicating the document each time it is shared. We also show that high server storage overhead is not inherent, by giving an alternate (albeit impractical) construction that manages to avoid it using obfuscation.

### On the Plausibility of Fully Homomorphic Encryption for RAMs

Ariel Hamlin, Justin Holmgren, Mor Weiss, Daniel Wichs: On the Plausibility of Fully Homomorphic Encryption for RAMs. CRYPTO (1) 2019: 589-619

## Abstract

We initiate the study of fully homomorphic encryption for RAMs (RAM-FHE). This is a public-key encryption scheme where, given an encryption of a large database DD, anybody can efficiently compute an encryption of P(D)P(D) for an arbitrary RAM program PP. The running time over the encrypted data should be as close as possible to the worst case running time of PP, which may be sub-linear in the data size.

A central difficulty in constructing a RAM-FHE scheme is hiding the sequence of memory addresses accessed by PP. This is particularly problematic because an adversary may homomorphically evaluate many programs over the same ciphertext, therefore effectively “rewinding” any mechanism for making memory accesses oblivious.

We identify a necessary prerequisite towards constructing RAM-FHE that we call \emph{rewindable oblivious RAM} (rewindable ORAM), which provides security even in this strong adversarial setting. We show how to construct rewindable ORAM using \emph{symmetric-key doubly efficient PIR (SK-DEPIR)} (Canetti-Holmgren-Richelson, Boyle-Ishai-Pass-Wootters: TCC ’17). We then show how to use rewindable ORAM, along with virtual black-box (VBB) obfuscation for specific circuits, to construct RAM-FHE. The latter primitive can be heuristically instantiated using existing indistinguishability obfuscation candidates. Overall, we obtain a RAM-FHE scheme where the multiplicative overhead in running time is polylogarithmic in the data size NN. Our basic scheme is single-hop, but we also extend it to get multi-hop RAM-FHE with overhead NϵNϵ for arbitrarily small ϵ>0ϵ>0.

### Tamper Detection and Continuous Non-malleable Codes

Jafargholi, Z. and Wichs, D., 2015. Tamper detection and continuous non-malleable codes. In Theory of Cryptography (pp. 451-480). Springer Berlin Heidelberg.

## Abstract

WeN consider a public and keyless code (Enc,Dec) which is used to encode a message *m* and derive a codeword *c* = Enc(*m*). The codeword can be adversarially tampered via a function f∈Ff∈F from some “tampering function family” FF, resulting in a tampered value *c*′ = *f*(*c*). We study the different types of security guarantees that can be achieved in this scenario for different families FF of tampering attacks.

Firstly, we initiate the general study of *tamper-detection codes*, which must detect that tampering occurred and output Dec (c′)=⊥(c′)=⊥. We show that such codes exist for any family of functions FF over *n* bit codewords, as long as |F|<22n|F|<22n is sufficiently smaller than the set of all possible functions, and the functions f∈Ff∈F are further *restricted* in two ways: (1) they can only have a *few fixed points* *x* such that *f*(*x*) = *x*, (2) they must have *high entropy* of *f*(*x*) over a random *x*. Such codes can also be made efficient when |F|=2poly(n)|F|=2poly(n).

Next, we revisit *non-malleable codes*, which were introduced by Dziembowski, Pietrzak and Wichs (ICS ’10) and require that Dec(*c*′) either decodes to the original message *m*, or to some unrelated value (possibly ⊥⊥) that doesn’t provide any information about *m*. We give a modular construction of non-malleable codes by combining tamper-detection codes and leakage-resilient codes. The resulting construction matches that of Faust et al. (EUROCRYPT ’14) but has a more modular proof and improved parameters.

Finally, we initiate the general study of *continuous non-malleable codes*, which provide a non-malleability guarantee against an attacker that can tamper a codeword multiple times. We define several variants of the problem depending on: (I) whether tampering is *persistent* and each successive attack modifies the codeword that has been modified by previous attacks, or whether tampering is non-persistent and is always applied to the original codeword, (II) whether we can “*self-destruct*” and stop the experiment if a tampered codeword is ever detected to be invalid or whether the attacker can always tamper more. In the case of persistent tampering and self-destruct (weakest case), we get a broad existence results, essentially matching what’s known for standard non-malleable codes. In the case of non-persistent tampering and no self-destruct (strongest case), we must further restrict the tampering functions to have few fixed points and high entropy. The two intermediate cases correspond to requiring only one of the above two restrictions.

## Related News

## Khoury PhD Students & Post-Docs

PhD Students

### Ariel Hamlin

PhD Student

PhD Students

### Giorgos Zirdelis

PhD Student

## Past PhD Students & Post-Docs

### Zahra Jafargholi

PhD Student

### Alessandra Scafuro

Postdoctoral Research Associate