Hostname: page-component-89b8bd64d-shngb Total loading time: 0 Render date: 2026-05-06T08:10:54.340Z Has data issue: false hasContentIssue false

Security monitor inlining and certification for multithreaded Java

Published online by Cambridge University Press:  17 December 2014

MADS DAM
Affiliation:
Royal Institute of Technology (KTH), Lindstedtsvägen 3, SE-100 44, Stockholm, Sweden
BART JACOBS
Affiliation:
Katholieke Universiteit Leuven, Celestijnenlaan 200A, B-3001 Leuven, Belgium Email: landreas@kth.se
ANDREAS LUNDBLAD
Affiliation:
Royal Institute of Technology (KTH), Lindstedtsvägen 3, SE-100 44, Stockholm, Sweden
FRANK PIESSENS
Affiliation:
Katholieke Universiteit Leuven, Celestijnenlaan 200A, B-3001 Leuven, Belgium Email: landreas@kth.se

Abstract

Security monitor inlining is a technique for security policy enforcement whereby monitor functionality is injected into application code in the style of aspect-oriented programming. The intention is that the injected code enforces compliance with the policy (security), and otherwise interferes with the application as little as possible (conservativity and transparency). Such inliners are said to be correct. For sequential Java-like languages, inlining is well understood, and several provably correct inliners have been proposed. For multithreaded Java one difficulty is the need to maintain a shared monitor state. We show that this problem introduces fundamental limitations in the type of security policies that can be correctly enforced by inlining. A class of race-free policies is identified that precisely characterizes the inlineable policies by showing that inlining of a policy outside this class is either not secure or not transparent, and by exhibiting a concrete inliner for policies inside the class which is secure, conservative and transparent. The inliner is implemented for Java and applied to a number of practical application security policies. Finally, we discuss how certification in the style of proof-carrying code could be supported for inlined programs by using annotations to reduce a potentially complex verification problem for multithreaded Java bytecode to sequential verification of just the inlined code snippets.

Information

Type
Special Issue: Objects and Services
Copyright
Copyright © Cambridge University Press 2014 

Access options

Get access to the full version of this content by using one of the access options below. (Log in options will check for institutional or personal access. Content may require purchase if you do not have access.)

Article purchase

Temporarily unavailable