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.
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- Jean-Yves Girard. 1998. Light Linear Logic. Inf. Comput., 143, 2 (1998), 175–204. https://doi.org/10.1006/inco.1998.2700
Google Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Cross Ref
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- Petr Hájek. 1979. Arithmetical Hierarchy and Complexity of Computation. Theor. Comput. Sci., 8 (1979), 227–237.
Google Scholar
Cross Ref
- 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 Scholar
Digital Library
- Martin Hofmann. 2002. The strength of non-size increasing computation. In POPL 2002. ACM, 260–269. https://doi.org/10.1145/503272.503297
Google Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- Stephen Cole Kleene. 1952. Introduction to metamathematics. North Holland.
Google Scholar
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- John McLean. 1992. Proving noninterference and functional correctness using traces. J. Comput. Secur., 1, 1 (1992), 37–57.
Google Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Cross Ref
- Steve Zdancewic. 2004. Challenges for information-flow security. In PLID’04. 6.
Google Scholar
Index Terms
A General Noninterference Policy for Polynomial Time
Recommendations
Noninterference for a Practical DIFC-Based Operating System
SP '09: Proceedings of the 2009 30th IEEE Symposium on Security and PrivacyThe Flume system is an implementation of decentralized information flow control (DIFC) at the operating system level.Prior work has shown Flume can be implemented as a practical extension tothe Linux operating system, allowing real Web applications to ...
Noninterference via symbolic execution
FMOODS'12/FORTE'12: Proceedings of the 14th joint IFIP WG 6.1 international conference and Proceedings of the 32nd IFIP WG 6.1 international conference on Formal Techniques for Distributed SystemsNoninterference is a high-level security property that guarantees the absence of illicit information flow at runtime. Noninterference can be enforced statically using information flow type systems; however, these are criticized for being overly ...
Reactive noninterference
CCS '09: Proceedings of the 16th ACM conference on Computer and communications securityMany programs operate reactively--patiently waiting for user input, running for a while producing output, and eventually returning to a state where they are ready to accept another input (or occasionally diverging). When a reactive program communicates ...






Comments