[Paper Review] Implementing Support for Pointers to Private Data in a General-Purpose Secure Multi-Party Compiler

Yihua Zhang, Marina Blanton+1 more|arXiv (Cornell University)|Sep 6, 2015

Cryptography and Data Security20 references3 citations

TL;DR

This paper introduces the first support for pointers to private data in a general-purpose secure multi-party computation (SMC) compiler, extending the PICCO compiler to enable dynamic memory allocation and complex data structures. By distinguishing between public and private pointers and using secret sharing, the approach maintains efficiency while enabling secure, scalable programs with minimal performance overhead for common data structures.

ABSTRACT

Recent compilers allow a general-purpose program (written in a conventional programming language) that handles private data to be translated into secure distributed implementation of the corresponding functionality. The resulting program is then guaranteed to provably protect private data using secure multi-party computation techniques. The goals of such compilers are generality, usability, and efficiency, but the complete set of features of a modern programming language has not been supported to date by the existing compilers. In particular, recent compilers PICCO and the two-party ANSI C compiler strive to translate any C program into its secure multi-party implementation, but currently lack support for pointers and dynamic memory allocation, which are important components of many C programs. In this work, we mitigate the limitation and add support for pointers to private data and consequently dynamic memory allocation to the PICCO compiler, enabling it to handle a more diverse set of programs over private data. Because doing so opens up a new design space, we investigate the use of pointers to private data (with known as well as private locations stored in them) in programs and report our findings. Besides dynamic memory allocation, we examine other important topics associated with common pointer use such as reference by pointer/address, casting, and building various data structures in the context of secure multi-party computation. This results in enabling the compiler to automatically translate a user program that uses pointers to private data into its distributed implementation that provably protects private data throughout the computation. We empirically evaluate the constructions and report on performance of representative programs.

Motivation & Objective

• To extend the PICCO compiler to support pointers to private data, enabling secure computation on dynamic data structures.
• To address the lack of dynamic memory allocation and pointer semantics in existing SMC compilers, which limits their usability for real-world C programs.
• To maintain efficiency and security by distinguishing between public and private pointers and applying private addressing only when necessary.
• To evaluate the performance impact of pointer-based data structures in secure computation, comparing them to array-based alternatives.
• To provide practical insights for SMC compiler developers on the benefits and limitations of pointer-based designs.

Proposed method

• Extending the PICCO source-to-source compiler to handle private pointers by introducing a new pointer representation that distinguishes public and private addresses.
• Using linear secret sharing to securely distribute and compute on private data, with private pointers storing secret-shared addresses.
• Designing a secure memory management system that supports dynamic allocation and deallocation of private data structures.
• Implementing secure operations for common pointer patterns: reference by pointer, casting, and building linked lists and balanced search trees.
• Integrating the new pointer support into the compiler’s intermediate representation and type system to enforce private data flow.
• Evaluating performance using representative programs, including sorted linked lists and shift-reduce parsers, comparing pointer-based and array-based implementations.

Experimental results

Research questions

• RQ1 How can pointers to private data be securely and efficiently supported in a general-purpose SMC compiler?
• RQ2 What is the performance overhead of using private pointers compared to public pointers or array-based alternatives?
• RQ3 Which pointer-based data structures retain their theoretical time complexity under secure computation?
• RQ4 How do common pointer operations—such as dereferencing, casting, and dynamic allocation—behave in a secret-sharing-based SMC setting?
• RQ5 What are the practical trade-offs between using pointer-based and array-based data structures in secure computation?

Key findings

• The performance of array-based sorted linked lists is about 20% faster for list construction and 9% slower for traversal compared to pointer-based implementations, indicating comparable efficiency.
• For small data sets, pointer-based implementations are significantly slower than array-based ones due to higher per-operation cost, but the gap narrows with larger inputs.
• Balanced search trees exhibit increased complexity due to private data flow, suggesting the need for custom oblivious data structures for optimal performance.
• Pointer-based data structures can outperform array-based ones in secure computation when data is large, especially for sequential operations.
• The cost of using private pointers is minimal in many cases, and several data structures retain their best-known asymptotic complexities when secured.
• Custom, internally built implementations of oblivious data structures are recommended for secure computation with private data.