A static analysis technique based on Integrity Breach Conditions (IBCs) effectively identifies sensitive methods or security spots that may contain malicious code injected by insiders in the program source code.However, static IBC analysis does not account for runtime execution behavior, where user inputs may trigger sensitive methods dynamically.This paper extends the application of IBCs beyond static analysis by analyzing control paths in functions to identify sensitive control (execution) paths in runtime contexts.Constructing and comparing control flow graphs (CFGs) with IBCs assists programmers in systematically tracing sensitive control paths that might otherwise be overlooked during code reviews.The methodology is applied across singlethreaded programs, multi-threaded environments, client-server architectures, and blackboard models, demonstrating the effectiveness of IBCs in identifying direct and indirect interactions with sensitive methods.Through real-world examples, we show how the application of IBCs enhances code review by providing a structured way to analyze runtime control paths and validate sensitive methods.

This paper describes an extension to the Integrity Breach Conditions (IBCs) by introducing a set of IBCs for interfaces and lambda expressions in Java.This paper addresses the integrity breaches caused by exploitation of interfaces and lambda expressions, proposing the IBCs to detect the potential breaches.A prototype tool is developed to identify the security spots that might indicate integrity breaches in code.An online banking system is developed to validate our approach using the developed prototype tool.

The malicious code injected by an insider into a program can compromise sensitive data that is one of the most valuable assets in an organization. This paper describes the Integrity Breach Conditions (IBCs) used to determine security spots that change sensitive data values in a program. A malicious insider can create a security spot to compromise sensitive data using the reference to a class object. We have specified the IBCs by considering object references in the coupling relationships between objects. The IBCs have been implemented in a prototype tool to validate our approach with a case study.

This paper describes an approach to detecting malicious code introduced by insiders, which can compromise the data integrity in a program. The approach identifies security spots in a program, which are either malicious code or benign code. Malicious code is detected by reviewing each security spot to determine whether it is malicious or benign. The integrity breach conditions (IBCs) for object-oriented programs are specified to identify security spots in the programs. The IBCs are specified by means of the concepts of coupling within an object or between objects. A prototype tool is developed to validate the approach with a case study.

We have designed an interactive visualization framework for the automated trust negotiation (ATN) protocol and we have implemented a prototype of the visualizer in Java. This framework provides capabilities to perform the interactive visualization of an ATN session, display credentials and policies, analyze the relations of negotiated components, and refine access control policies and negotiation strategies. We give examples of the visualization of ATN sessions and demonstrate the interactive features of the visualizer for the incremental construction of a trust target graph (TTG). Our prototype, which implements most components of the visualization framework, has played a key role in a research project that has developed working trust negotiation systems in an industrial environment.

The open nature of the Web makes it possible to create spoofed Web pages which, to the casual observer, are indistinguishable from authentic pages. The defense against Web spoofing attacks is a challenging problem since most users are unwilling (or unable) to follow complex interactive authentication procedures (e.g., inspect a Web server certificate). In this paper, we present a visual scheme that protects users against Web spoofing attacks while requiring minimal interaction.