skip to main content

Oblivious algebraic data types

Published:12 January 2022Publication History
Skip Abstract Section

Abstract

Secure computation allows multiple parties to compute joint functions over private data without leaking any sensitive data, typically using powerful cryptographic techniques. Writing secure applications using these techniques directly can be challenging, resulting in the development of several programming languages and compilers that aim to make secure computation accessible. Unfortunately, many of these languages either lack or have limited support for rich recursive data structures, like trees. In this paper, we propose a novel representation of structured data types, which we call oblivious algebraic data types, and a language for writing secure computations using them. This language combines dependent types with constructs for oblivious computation, and provides a security-type system which ensures that adversaries can learn nothing more than the result of a computation. Using this language, authors can write a single function over private data, and then easily build an equivalent secure computation according to a desired public view of their data.

Skip Supplemental Material Section

Supplemental Material

Auxiliary Presentation Video

This is a 5-minute presentation video for our POPL 2022 paper, Oblivious Algebraic Data Types.

References

  1. Carmine Abate, Philipp G. Haselwarter, Exequiel Rivas, Antoine Van Muylder, Théo Winterhalter, Cătălin Hriţcu, Kenji Maillard, and Bas Spitters. 2021. SSProve: A Foundational Framework for Modular Cryptographic Proofs in Coq. In 2021 IEEE 34th Computer Security Foundations Symposium (CSF). 1–15. issn:2374-8303 https://doi.org/10.1109/CSF51468.2021.00048 Google ScholarGoogle ScholarCross RefCross Ref
  2. Abbas Acar, Hidayet Aksu, A. Selcuk Uluagac, and Mauro Conti. 2018. A Survey on Homomorphic Encryption Schemes: Theory and Implementation. ACM Computing Surveys (CSUR), 51, 4 (2018), July, 79:1–79:35. issn:0360-0300 https://doi.org/10.1145/3214303 Google ScholarGoogle ScholarDigital LibraryDigital Library
  3. Michael Backes, Matteo Maffei, and Esfandiar Mohammadi. 2010. Computationally Sound Abstraction and Verification of Secure Multi-Party Computations. In IARCS Annual Conference on Foundations of Software Technology and Theoretical Computer Science (FSTTCS 2010), Kamal Lodaya and Meena Mahajan (Eds.) (Leibniz International Proceedings in Informatics (LIPIcs), Vol. 8). Schloss Dagstuhl– Leibniz-Zentrum fuer Informatik, Dagstuhl, Germany. 352–363. isbn:978-3-939897-23-1 https://doi.org/10.4230/LIPIcs.FSTTCS.2010.352 Google ScholarGoogle ScholarCross RefCross Ref
  4. Gilles Barthe, Gustavo Betarte, Juan Campo, Carlos Luna, and David Pichardie. 2014. System-Level Non-Interference for Constant-Time Cryptography. In Proceedings of the 2014 ACM SIGSAC Conference on Computer and Communications Security (CCS ’14). Association for Computing Machinery, Scottsdale, Arizona, USA. 1267–1279. isbn:978-1-4503-2957-6 https://doi.org/10.1145/2660267.2660283 Google ScholarGoogle ScholarDigital LibraryDigital Library
  5. Gilles Barthe, Gustavo Betarte, Juan Diego Campo, and Carlos Luna. 2019. System-Level Non-Interference of Constant-Time Cryptography. Part I: Model. Journal of Automated Reasoning, 63, 1 (2019), June, 1–51. issn:1573-0670 https://doi.org/10.1007/s10817-017-9441-5 Google ScholarGoogle ScholarDigital LibraryDigital Library
  6. Gilles Barthe, Sandrine Blazy, Benjamin Grégoire, Rémi Hutin, Vincent Laporte, David Pichardie, and Alix Trieu. 2019. Formal Verification of a Constant-Time Preserving C Compiler. Proceedings of the ACM on Programming Languages, 4, POPL (2019), Dec., 7:1–7:30. https://doi.org/10.1145/3371075 Google ScholarGoogle ScholarDigital LibraryDigital Library
  7. Gilles Barthe, Benjamin Grégoire, Sylvain Heraud, and Santiago Zanella Béguelin. 2011. Computer-Aided Security Proofs for the Working Cryptographer. In Advances in Cryptology – CRYPTO 2011, Phillip Rogaway (Ed.) (Lecture Notes in Computer Science). Springer Berlin Heidelberg, 71–90. isbn:978-3-642-22792-9Google ScholarGoogle ScholarCross RefCross Ref
  8. Gilles Barthe, Benjamin Grégoire, and Santiago Zanella Béguelin. 2009. Formal Certification of Code-Based Cryptographic Proofs. In Proceedings of the 36th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL ’09). ACM, New York, NY, USA. 90–101. isbn:978-1-60558-379-2 https://doi.org/10.1145/1480881.1480894 Google ScholarGoogle ScholarDigital LibraryDigital Library
  9. Amos Beimel. 2011. Secret-Sharing Schemes: A Survey. In Coding and Cryptology, Yeow Meng Chee, Zhenbo Guo, San Ling, Fengjing Shao, Yuansheng Tang, Huaxiong Wang, and Chaoping Xing (Eds.) (Lecture Notes in Computer Science). Springer, Berlin, Heidelberg. 11–46. isbn:978-3-642-20901-7 https://doi.org/10.1007/978-3-642-20901-7_2 Google ScholarGoogle Scholar
  10. Sunjay Cauligi, Gary Soeller, Brian Johannesmeyer, Fraser Brown, Riad S. Wahby, John Renner, Benjamin Grégoire, Gilles Barthe, Ranjit Jhala, and Deian Stefan. 2019. FaCT: A DSL for Timing-Sensitive Computation. In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2019). Association for Computing Machinery, Phoenix, AZ, USA. 174–189. isbn:978-1-4503-6712-7 https://doi.org/10.1145/3314221.3314605 Google ScholarGoogle ScholarDigital LibraryDigital Library
  11. David Darais, Ian Sweet, Chang Liu, and Michael Hicks. 2020. A Language for Probabilistically Oblivious Computation. Proceedings of the ACM on Programming Languages, 4, POPL (2020), Jan., 1–31. issn:2475-1421, 2475-1421 https://doi.org/10.1145/3371118 arxiv:1711.09305. Google ScholarGoogle ScholarDigital LibraryDigital Library
  12. David Evans, Vladimir Kolesnikov, and Mike Rosulek. 2018. A Pragmatic Introduction to Secure Multi-Party Computation. Foundations and Trends® in Privacy and Security, 2, 2-3 (2018), 70–246. issn:2474-1558, 2474-1566 https://doi.org/10.1561/3300000019 Google ScholarGoogle ScholarDigital LibraryDigital Library
  13. Craig Gentry. 2009. Fully Homomorphic Encryption Using Ideal Lattices. In Proceedings of the Forty-First Annual ACM Symposium on Theory of Computing (STOC ’09). Association for Computing Machinery, New York, NY, USA. 169–178. isbn:978-1-60558-506-2 https://doi.org/10.1145/1536414.1536440 Google ScholarGoogle ScholarDigital LibraryDigital Library
  14. J. A. Goguen and J. Meseguer. 1982. Security Policies and Security Models. In 1982 IEEE Symposium on Security and Privacy. 11–11. issn:1540-7993 https://doi.org/10.1109/SP.1982.10014 Google ScholarGoogle Scholar
  15. O. Goldreich. 1987. Towards a Theory of Software Protection and Simulation by Oblivious RAMs. In Proceedings of the Nineteenth Annual ACM Symposium on Theory of Computing (STOC ’87). Association for Computing Machinery, New York, NY, USA. 182–194. isbn:978-0-89791-221-1 https://doi.org/10.1145/28395.28416 Google ScholarGoogle ScholarDigital LibraryDigital Library
  16. O. Goldreich, S. Micali, and A. Wigderson. 1987. How to Play ANY Mental Game. In Proceedings of the Nineteenth Annual ACM Symposium on Theory of Computing (STOC ’87). Association for Computing Machinery, New York, New York, USA. 218–229. isbn:978-0-89791-221-1 https://doi.org/10.1145/28395.28420 Google ScholarGoogle ScholarDigital LibraryDigital Library
  17. Oded Goldreich and Rafail Ostrovsky. 1996. Software Protection and Simulation on Oblivious RAMs. J. ACM, 43, 3 (1996), May, 431–473. issn:0004-5411 https://doi.org/10.1145/233551.233553 Google ScholarGoogle ScholarDigital LibraryDigital Library
  18. Helene Haagh, Aleksandr Karbyshev, Sabine Oechsner, Bas Spitters, and Pierre-Yves Strub. 2018. Computer-Aided Proofs for Multiparty Computation with Active Security. In 2018 IEEE 31st Computer Security Foundations Symposium (CSF). 119–131. issn:2374-8303 https://doi.org/10.1109/CSF.2018.00016 Google ScholarGoogle ScholarCross RefCross Ref
  19. M. Hastings, B. Hemenway, D. Noble, and S. Zdancewic. 2019. SoK: General Purpose Compilers for Secure Multi-Party Computation. In 2019 2019 IEEE Symposium on Security and Privacy (SP). IEEE Computer Society, Los Alamitos, CA, USA. 479–496. https://doi.org/10.1109/SP.2019.00028 Google ScholarGoogle Scholar
  20. Carmit Hazay and Yehuda Lindell. 2010. Efficient Secure Two-Party Protocols: Techniques and Constructions. Springer, Berlin ; London. isbn:978-3-642-14302-1 lccn:Z103 .H29 2010Google ScholarGoogle ScholarCross RefCross Ref
  21. Matthew E Hoekstra. 2015. Intel SGX for Dummies (Intel SGX Design Objectives). https://www.intel.com/content/www/us/en/develop/blogs/protecting-application-secrets-with-intel-sgx.htmlGoogle ScholarGoogle Scholar
  22. Ming Kawaguchi, Patrick Rondon, and Ranjit Jhala. 2009. Type-Based Data Structure Verification. In Proceedings of the 30th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’09). Association for Computing Machinery, Dublin, Ireland. 304–315. isbn:978-1-60558-392-1 https://doi.org/10.1145/1542476.1542510 Google ScholarGoogle ScholarDigital LibraryDigital Library
  23. 2015. Applications of Secure Multiparty Computation, Peeter Laud and Liina Kamm (Eds.) (Cryptology and Information Security Series). IOS Press, Amsterdam, Netherlands. isbn:978-1-61499-532-6 978-1-61499-531-9Google ScholarGoogle Scholar
  24. Xavier Leroy. 2009. Formal Verification of a Realistic Compiler. Commun. ACM, 52, 7 (2009), July, 107. issn:00010782 https://doi.org/10.1145/1538788.1538814 Google ScholarGoogle ScholarDigital LibraryDigital Library
  25. C. Liu, X. S. Wang, K. Nayak, Y. Huang, and E. Shi. 2015. ObliVM: A Programming Framework for Secure Computation. In 2015 IEEE Symposium on Security and Privacy. 359–376. issn:2375-1207 https://doi.org/10.1109/SP.2015.29 Google ScholarGoogle ScholarDigital LibraryDigital Library
  26. Dahlia Malkhi, Noam Nisan, Benny Pinkas, and Yaron Sella. 2004. Fairplay - a Secure Two-Party Computation System. In Proceedings of the 13th Conference on USENIX Security Symposium - Volume 13 (SSYM’04). USENIX Association, USA. 20.Google ScholarGoogle Scholar
  27. Ueli Maurer. 2006. Secure Multi-Party Computation Made Simple. Discrete Applied Mathematics, 154, 2 (2006), Feb., 370–381. issn:0166-218X https://doi.org/10.1016/j.dam.2005.03.020 Google ScholarGoogle Scholar
  28. Aleksandar Nanevski, Anindya Banerjee, and Deepak Garg. 2013. Dependent Type Theory for Verification of Information Flow and Access Control Policies. ACM Transactions on Programming Languages and Systems, 35, 2 (2013), July, 6:1–6:41. issn:0164-0925 https://doi.org/10.1145/2491522.2491523 Google ScholarGoogle ScholarDigital LibraryDigital Library
  29. Ulf Norell. [n.d.]. The Agda Wiki. https://wiki.portal.chalmers.se/agda/Main/HomePageGoogle ScholarGoogle Scholar
  30. Atsushi Ohori and Isao Sasano. 2007. Lightweight Fusion by Fixed Point Promotion. ACM SIGPLAN Notices, 42, 1 (2007), Jan., 143–154. issn:0362-1340 https://doi.org/10.1145/1190215.1190241 Google ScholarGoogle ScholarDigital LibraryDigital Library
  31. A. Rastogi, M. A. Hammer, and M. Hicks. 2014. Wysteria: A Programming Language for Generic, Mixed-Mode Multiparty Computations. In 2014 IEEE Symposium on Security and Privacy. 655–670. https://doi.org/10.1109/SP.2014.48 Google ScholarGoogle ScholarDigital LibraryDigital Library
  32. Aseem Rastogi, Nikhil Swamy, and Michael Hicks. 2019. Wys*: A DSL for Verified Secure Multi-Party Computations. In Principles of Security and Trust, Flemming Nielson and David Sands (Eds.) (Lecture Notes in Computer Science). Springer International Publishing, 99–122. isbn:978-3-030-17138-4 https://doi.org/10.1007/978-3-030-17138-4_5 Google ScholarGoogle Scholar
  33. Patrick M. Rondon, Ming Kawaguci, and Ranjit Jhala. 2008. Liquid Types. In Proceedings of the 29th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’08). ACM, New York, NY, USA. 159–169. isbn:978-1-59593-860-2 https://doi.org/10.1145/1375581.1375602 Google ScholarGoogle ScholarDigital LibraryDigital Library
  34. A. Sabelfeld and A.C. Myers. 2003. Language-Based Information-Flow Security. IEEE Journal on Selected Areas in Communications, 21, 1 (2003), Jan., 5–19. issn:1558-0008 https://doi.org/10.1109/JSAC.2002.806121 Google ScholarGoogle ScholarDigital LibraryDigital Library
  35. Andrei Sabelfeld and Andrew C. Myers. 2004. A Model for Delimited Information Release. In Software Security - Theories and Systems, Kokichi Futatsugi, Fumio Mizoguchi, and Naoki Yonezaki (Eds.) (Lecture Notes in Computer Science). Springer Berlin Heidelberg, 174–191. isbn:978-3-540-37621-7 https://doi.org/10.1007/978-3-540-37621-7_9 Google ScholarGoogle ScholarCross RefCross Ref
  36. Vilhelm Sjöberg. 2015. A Dependently Typed Language with Nontermination. Publicly Accessible Penn Dissertations, Jan., https://repository.upenn.edu/edissertations/1137Google ScholarGoogle Scholar
  37. Vilhelm Sjöberg, Chris Casinghino, Ki Yung Ahn, Nathan Collins, Harley D. Eades III, Peng Fu, Garrin Kimmell, Tim Sheard, Aaron Stump, and Stephanie Weirich. 2012. Irrelevance, Heterogeneous Equality, and Call-by-Value Dependent Type Systems. Electronic Proceedings in Theoretical Computer Science, 76 (2012), Feb., 112–162. issn:2075-2180 https://doi.org/10.4204/EPTCS.76.9 arxiv:1202.2923. Google ScholarGoogle ScholarCross RefCross Ref
  38. Vilhelm Sjöberg and Stephanie Weirich. 2015. Programming up to Congruence. In Proceedings of the 42nd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL ’15). Association for Computing Machinery, New York, NY, USA. 369–382. isbn:978-1-4503-3300-9 https://doi.org/10.1145/2676726.2676974 Google ScholarGoogle ScholarDigital LibraryDigital Library
  39. Emil Stefanov, Marten van Dijk, Elaine Shi, Christopher Fletcher, Ling Ren, Xiangyao Yu, and Srinivas Devadas. 2013. Path ORAM: An Extremely Simple Oblivious RAM Protocol. In Proceedings of the 2013 ACM SIGSAC Conference on Computer & Communications Security (CCS ’13). Association for Computing Machinery, New York, NY, USA. 299–310. isbn:978-1-4503-2477-9 https://doi.org/10.1145/2508859.2516660 Google ScholarGoogle ScholarDigital LibraryDigital Library
  40. Ian Sweet, David Darais, David Heath, Ryan Estes, William Harris, and Michael Hicks. 2021. Symphony: A Concise Language Model for MPC. In Informal Proceedings of the Workshop on Foundations on Computer Secuirty (FCS).Google ScholarGoogle Scholar
  41. The Coq Development Team. 2021. The Coq Proof Assistant. Jan., https://doi.org/10.5281/zenodo.4501022 Google ScholarGoogle ScholarCross RefCross Ref
  42. Philip Wadler. 1990. Deforestation: Transforming Programs to Eliminate Trees. Theoretical Computer Science, 73, 2 (1990), June, 231–248. issn:03043975 https://doi.org/10.1016/0304-3975(90)90147-A Google ScholarGoogle ScholarDigital LibraryDigital Library
  43. Xiao Shaun Wang, Kartik Nayak, Chang Liu, T-H. Hubert Chan, Elaine Shi, Emil Stefanov, and Yan Huang. 2014. Oblivious Data Structures. In Proceedings of the 2014 ACM SIGSAC Conference on Computer and Communications Security (CCS ’14). Association for Computing Machinery, Scottsdale, Arizona, USA. 215–226. isbn:978-1-4503-2957-6 https://doi.org/10.1145/2660267.2660314 Google ScholarGoogle ScholarDigital LibraryDigital Library
  44. Hongwei Xi and Frank Pfenning. 1999. Dependent Types in Practical Programming. In Proceedings of the 26th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL ’99). Association for Computing Machinery, New York, NY, USA. 214–227. isbn:978-1-58113-095-9 https://doi.org/10.1145/292540.292560 Google ScholarGoogle ScholarDigital LibraryDigital Library
  45. Andrew C. Yao. 1982. Protocols for Secure Computations. In 23rd Annual Symposium on Foundations of Computer Science (Sfcs 1982). 160–164. issn:0272-5428 https://doi.org/10.1109/SFCS.1982.38 Google ScholarGoogle Scholar
  46. Qianchuan Ye and Benjamin Delaware. 2021. Oblivious Algebraic Data Types: POPL22 Artifact. Zenodo. https://doi.org/10.5281/zenodo.5652106 Google ScholarGoogle ScholarDigital LibraryDigital Library
  47. Samee Zahur and David Evans. 2015. Obliv-C: A Language for Extensible Data-Oblivious Computation. https://eprint.iacr.org/2015/1153Google ScholarGoogle Scholar
  48. Stephan Arthur Zdancewic. 2002. Programming Languages for Information Security. Ph.D. Dissertation. Cornell University. USA.Google ScholarGoogle ScholarDigital LibraryDigital Library

Index Terms

  1. Oblivious algebraic data types

            Recommendations

            Comments

            Login options

            Check if you have access through your login credentials or your institution to get full access on this article.

            Sign in

            Full Access

            PDF Format

            View or Download as a PDF file.

            PDF

            eReader

            View online with eReader.

            eReader
            About Cookies On This Site

            We use cookies to ensure that we give you the best experience on our website.

            Learn more

            Got it!