skip to main content
research-article
Open Access

A General Noninterference Policy for Polynomial Time

Published:11 January 2023Publication History
Skip Abstract Section

Abstract

We introduce a new noninterference policy to capture the class of functions computable in polynomial time on an object-oriented programming language. This policy makes a clear separation between the standard noninterference techniques for the control flow and the layering properties required to ensure that each “security” level preserves polynomial time soundness, and is thus very powerful as for the class of programs it can capture. This new characterization is a proper extension of existing tractable characterizations of polynomial time based on safe recursion. Despite the fact that this noninterference policy is Π10-complete, we show that it can be instantiated to some decidable and conservative instance using shape analysis techniques.

References

  1. Robert Atkey. 2010. Amortised Resource Analysis with Separation Logic. In ESOP 2010. 85–103. https://doi.org/10.1007/978-3-642-11957-6_6 Google ScholarGoogle ScholarDigital LibraryDigital Library
  2. John W Backus, Friedrich L Bauer, Julien Green, Charles Katz, John McCarthy, Peter Naur, Alan J Perlis, Heinz Rutishauser, Klaus Samelson, and Bernard Vauquois. 1963. Revised report on the algorithmic language Algol 60. Comput. J., 5, 4 (1963), 349–367. Google ScholarGoogle ScholarCross RefCross Ref
  3. Patrick Baillot and Damiano Mazza. 2010. Linear logic by levels and bounded time complexity. Theor. Comput. Sci., 411, 2 (2010), 470–503. https://doi.org/10.1016/j.tcs.2009.09.015 Google ScholarGoogle ScholarDigital LibraryDigital Library
  4. Patrick Baillot and Kazushige Terui. 2004. Light Types for Polynomial Time Computation in Lambda-Calculus. In LICS 2004. IEEE, 266–275. https://doi.org/10.1109/LICS.2004.1319621 Google ScholarGoogle ScholarCross RefCross Ref
  5. Stephen Bellantoni and Stephen Cook. 1992. A New Recursion-Theoretic Characterization of the Polytime Functions. Computational Complexity, 2 (1992), 97–110. https://doi.org/10.1007/BF01201998 Google ScholarGoogle ScholarDigital LibraryDigital Library
  6. Josh Berdine, Byron Cook, Dino Distefano, and Peter W. O’Hearn. 2006. Automatic Termination Proofs for Programs with Shape-Shifting Heaps. In CAV 2006. Springer, 386–400. https://doi.org/10.1007/11817963_35 Google ScholarGoogle ScholarDigital LibraryDigital Library
  7. Ahmed Bouajjani, Marius Bozga, Peter Habermehl, Radu Iosif, Pierre Moro, and Tomás Vojnar. 2011. Programs with lists are counter automata. Formal Methods Syst. Des., 38, 2 (2011), 158–192. https://doi.org/10.1007/s10703-011-0111-7 Google ScholarGoogle ScholarDigital LibraryDigital Library
  8. Patrick Cousot and Radhia Cousot. 2002. Systematic design of program transformation frameworks by abstract interpretation. In POPL 2002. ACM, 178–190. https://doi.org/10.1145/503272.503290 Google ScholarGoogle ScholarDigital LibraryDigital Library
  9. Jörg Endrullis, Herman Geuvers, Jakob Grue Simonsen, and Hans Zantema. 2011. Levels of undecidability in rewriting. Inf. Comput., 209, 2 (2011), 227–245. https://doi.org/10.1016/j.ic.2010.09.003 Google ScholarGoogle ScholarDigital LibraryDigital Library
  10. Marco Gaboardi, Jean-Yves Marion, and Simona Ronchi Della Rocca. 2008. A logical account of pspace. In POPL 2008. ACM, 121–131. https://doi.org/10.1145/1328438.1328456 Google ScholarGoogle ScholarDigital LibraryDigital Library
  11. Jean-Yves Girard. 1971. Une extension de l’interprétation de Gödel à l’analyse, et son application à l’élimination des coupures dans l’analyse et la théorie des types. In Proceedings of the Second Scandinavian Logic Symposium. Elsevier, 63–92. https://doi.org/10.1016/s0049-237x(08)70843-7 Google ScholarGoogle ScholarCross RefCross Ref
  12. Jean-Yves Girard. 1998. Light Linear Logic. Inf. Comput., 143, 2 (1998), 175–204. https://doi.org/10.1006/inco.1998.2700 Google ScholarGoogle ScholarDigital LibraryDigital Library
  13. Joseph A Goguen and José Meseguer. 1982. Security policies and security models. In 1982 IEEE Symposium on Security and Privacy. IEEE. https://doi.org/10.1109/sp.1982.10014 Google ScholarGoogle ScholarCross RefCross Ref
  14. Joseph A Goguen and José Meseguer. 1984. Unwinding and inference control. In 1984 IEEE Symposium on Security and Privacy. IEEE. https://doi.org/10.1109/sp.1984.10019 Google ScholarGoogle ScholarCross RefCross Ref
  15. Emmanuel Hainry, Bruce M. Kapron, Jean-Yves Marion, and Romain Péchoux. 2022. A tier-based typed programming language characterizing Feasible Functionals. Logical Methods in Computer Science, Volume 18, Issue 1 (2022), feb, https://doi.org/10.46298/lmcs-18(1:33)2022 Google ScholarGoogle ScholarCross RefCross Ref
  16. Emmanuel Hainry, Jean-Yves Marion, and Romain Péchoux. 2013. Type-based complexity analysis for fork processes. In FoSSaCS 2013. Springer, 305–320. https://doi.org/10.1007/978-3-642-37075-5_20 Google ScholarGoogle ScholarDigital LibraryDigital Library
  17. Emmanuel Hainry and Romain Péchoux. 2018. A type-based complexity analysis of Object Oriented programs. Inf. Comput., 261, 1 (2018), 78–115. https://doi.org/10.1016/j.ic.2018.05.006 Google ScholarGoogle ScholarCross RefCross Ref
  18. Petr Hájek. 1979. Arithmetical Hierarchy and Complexity of Computation. Theor. Comput. Sci., 8 (1979), 227–237. Google ScholarGoogle ScholarCross RefCross Ref
  19. Nevin Heintze and Jon G Riecke. 1998. The SLam calculus: programming with secrecy and integrity. In POPL 1998. ACM, 365–377. https://doi.org/10.1145/268946.268976 Google ScholarGoogle ScholarDigital LibraryDigital Library
  20. Martin Hofmann. 2002. The strength of non-size increasing computation. In POPL 2002. ACM, 260–269. https://doi.org/10.1145/503272.503297 Google ScholarGoogle ScholarDigital LibraryDigital Library
  21. Martin Hofmann. 2003. Linear types and non-size-increasing polynomial time computation. Information and Computation, 183, 1 (2003), may, 57–85. https://doi.org/10.1016/s0890-5401(03)00009-9 Google ScholarGoogle ScholarDigital LibraryDigital Library
  22. John Hughes, Lars Pareto, and Amr Sabry. 1996. Proving the correctness of reactive systems using sized types. In Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages. ACM, 410–423. https://doi.org/10.1145/237721.240882 Google ScholarGoogle ScholarDigital LibraryDigital Library
  23. Neil D. Jones. 2001. The expressive power of higher-order types or, life without CONS. J. Funct. Program., 11, 1 (2001), 5–94. https://doi.org/10.1017/S0956796800003889 Google ScholarGoogle ScholarDigital LibraryDigital Library
  24. Stephen Cole Kleene. 1952. Introduction to metamathematics. North Holland. Google ScholarGoogle Scholar
  25. Cynthia Kop and Jakob Grue Simonsen. 2017. Complexity Hierarchies and Higher-order Cons-free Term Rewriting. Log. Methods Comput. Sci., 13, 3 (2017), https://doi.org/10.23638/LMCS-13(3:8)2017 Google ScholarGoogle ScholarCross RefCross Ref
  26. Yves Lafont. 2004. Soft linear logic and polynomial time. Theor. Comput. Sci., 318, 1-2 (2004), 163–180. https://doi.org/10.1016/j.tcs.2003.10.018 Google ScholarGoogle ScholarDigital LibraryDigital Library
  27. Daniel Leivant and Jean-Yves Marion. 2013. Evolving Graph-Structures and Their Implicit Computational Complexity. In ICALP 2013, Part II (Lecture Notes in Computer Science). Springer, 349–360. https://doi.org/10.1007/978-3-642-39212-2_32 Google ScholarGoogle ScholarDigital LibraryDigital Library
  28. Daniel Leivant and Jean-Yves Marion. 1993. Lambda Calculus Characterizations of Poly-Time. Fundam. Inform., 19, 1/2 (1993), 167–184. https://doi.org/10.3233/fi-1993-191-207 Google ScholarGoogle ScholarCross RefCross Ref
  29. Roman Manevich, Boris Dogadov, and Noam Rinetzky. 2016. From Shape Analysis to Termination Analysis in Linear Time. In CAV 2016, Part I. 426–446. https://doi.org/10.1007/978-3-319-41528-4_23 Google ScholarGoogle ScholarCross RefCross Ref
  30. Jean-Yves Marion. 2011. A Type System for Complexity Flow Analysis. In LICS 2011. 123–132. https://doi.org/10.1109/LICS.2011.41 Google ScholarGoogle ScholarDigital LibraryDigital Library
  31. John McLean. 1992. Proving noninterference and functional correctness using traces. J. Comput. Secur., 1, 1 (1992), 37–57. Google ScholarGoogle ScholarDigital LibraryDigital Library
  32. Andrew C. Myers and Barbara Liskov. 1997. A decentralized model for information flow control. ACM SIGOPS Operating Systems Review, 31, 5 (1997), 129–142. https://doi.org/10.1145/268998.266669 Google ScholarGoogle ScholarDigital LibraryDigital Library
  33. Thomas W. Reps, Mooly Sagiv, and Alexey Loginov. 2010. Finite differencing of logical formulas for static analysis. ACM Trans. Program. Lang. Syst., 32, 6 (2010), 24:1–24:55. https://doi.org/10.1145/1749608.1749613 Google ScholarGoogle ScholarDigital LibraryDigital Library
  34. Thomas W. Reps, Mooly Sagiv, and Reinhard Wilhelm. 2004. Static Program Analysis via 3-Valued Logic. In CAV 2004. 15–30. https://doi.org/10.1007/978-3-540-27813-9_2 Google ScholarGoogle ScholarCross RefCross Ref
  35. John C. Reynolds. 1974. Towards a theory of type structure. In Programming Symposium. 408–425. https://doi.org/10.1007/3-540-06859-7_148 Google ScholarGoogle ScholarCross RefCross Ref
  36. Andrei Sabelfeld and Andrew C. Myers. 2003. Language-based information-flow security. IEEE J. Sel. Areas Commun., 21, 1 (2003), 5–19. https://doi.org/10.1109/jsac.2002.806121 Google ScholarGoogle ScholarDigital LibraryDigital Library
  37. Mooly Sagiv, Thomas W. Reps, and Reinhard Wilhelm. 1996. Solving Shape-Analysis Problems in Languages with Destructive Updating. In POPL 1996. 16–31. https://doi.org/10.1145/237721.237725 Google ScholarGoogle ScholarDigital LibraryDigital Library
  38. Mooly Sagiv, Thomas W. Reps, and Reinhard Wilhelm. 2002. Parametric shape analysis via 3-valued logic. ACM Trans. Program. Lang. Syst., 24, 3 (2002), 217–298. https://doi.org/10.1145/514188.514190 Google ScholarGoogle ScholarDigital LibraryDigital Library
  39. Dennis Volpano, Cynthia Irvine, and Geoffrey Smith. 1996. A sound type system for secure flow analysis. J. Comput. Secur., 4, 2-3 (1996), 167–187. https://doi.org/10.3233/JCS-1996-42-304 Google ScholarGoogle ScholarCross RefCross Ref
  40. Dennis Volpano and Geoffrey Smith. 1997. A type-based approach to program security. In TAPSOFT ' 97: Theory and Practice of Software Development. Springer, 607–621. https://doi.org/10.1007/bfb0030629 Google ScholarGoogle ScholarCross RefCross Ref
  41. Steve Zdancewic. 2004. Challenges for information-flow security. In PLID’04. 6. Google ScholarGoogle Scholar

Index Terms

  1. A General Noninterference Policy for Polynomial Time

        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

        • Article Metrics

          • Downloads (Last 12 months)110
          • Downloads (Last 6 weeks)14

          Other Metrics

        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!