Browsing by Author "Pham, Hung T."

Now showing 1 - 12 of 12
  • Thumbnail Image
    Item
    A DSL for cross-domain security
    (High Integrity Language Technology ACM SIGAda’s Annual International Conference (HILT 2012), 2012) Hardin, David; Slind, Konrad; Whalen, Michael; Pham, Hung T.
  • Thumbnail Image
    Item
    A Fast Algorithm to Compute Heap Memory Bounds of Java Card Applets
    (2008) Pham, Hung T.; Truong, Anh-Hoang; Truong, Ninh-Thuan; Chin, Wei-Ngan
    In this paper, we present an approach to find upper bounds of heap space for Java Card applets. Our method first transforms an input bytecode stream into a control flow graph (CFG), and then collapses cycles of the CFG to produce a directed acyclic graph (DAG). Based on the DAG, we propose a linear-time algorithm to solve the problem of finding the single-source largest path in it. We also have implemented a prototype tool, tested it on several sample applications, and then compared the bounds found by our tool with the actual heap bounds of the programs. The experiment shows that our tool returns good estimation of heap bounds, runs fast, and has a small memory footprint.
  • Thumbnail Image
    Item
    Abstractions in Decision Procedures for Algebraic Data Types
    (University of Minnesota, 2013) Pham, Hung T.; Whalen, Michael
    Reasoning about algebraic data types and functions that operate over these data types is an important problem for a large variety of applications. In this paper, we present an unrolling-based decision procedure for reasoning about data types using abstractions that are provided by catamorphisms: fold functions that map instances of algebraic data types into values in a decidable domain. We show that the procedure is sound and complete for a class of monotonic catamorphisms. Our work extends previous work in catamorphism-based reasoning in a number of directions. First, we propose the categories of monotonic catamorphisms and associative-commutative catamorphisms, which we argue provide a better formal foundation than previous categorizations of catamorphisms. We use monotonic catamorphisms to fix an incompleteness in a previous unrolling algorithm (and associated proof). We then use these notions to address two open questions from previous work: (1) we provide a bound on the number of unrollings necessary for completeness, showing that it is exponentially small with respect to formula size for associative-commutative catamorphisms, and (2) demonstrate that associative-commutative catamorphisms can be combined within a formula whilst preserving completeness.
  • Thumbnail Image
    Item
    An Improved Unrolling-Based Decision Procedure for Algebraic Data Types
    (Springer, 2013) Pham, Hung T.; Whalen, Michael
    Reasoning about algebraic data types and functions that operate over these data types is an important problem for a large variety of applications. In this paper, we present a decision procedure for reasoning about data types using abstractions that are provided by catamorphisms: fold functions that map instances of algebraic data types into values in a decidable domain. We show that the procedure is sound and complete for a class of monotonic catamorphisms. Our work extends a previous decision procedure that solves formulas involving algebraic data types via successive unrollings of catamorphism functions. First, we propose the categories of monotonic catamorphisms and associative-commutative catamorphisms, which we argue provide a better formal foundation than previous categorizations of catamorphisms. We use monotonic catamorphisms to fix an incompleteness in the previous unrolling algorithm (and associated proof). We then use these notions to address two open problems from previous work: (1) we provide a bound on the number of unrollings necessary for completeness, showing that it is exponentially small with respect to formula size for associative-commutative catamorphisms, and (2) we demonstrate that associative-commutative catamorphisms can be combined within a formula whilst preserving completeness.
  • Thumbnail Image
    Item
    Analyzing RBAC Security Policy of Implementation Using AST
    (2009) Pham, Hung T.; Truong, Ninh-Thuan; Nguyen, Viet-Ha
    Security policy is a critical property in software applications which require high levels of safety and security. It has to be clearly specified in requirement documents and its implementation must be conformed to the specification. In this paper, we propose an approach to check if the implementation is in accordance with its security policy specification. We use the Abstract Syntax Tree (AST), another manner of expressing the program, to analyze the source code and specify user permission policy in software systems by Role-Based Access Control (RBAC).
  • Thumbnail Image
    Item
    Computing heap space cost of Java Card applets
    (2008) Pham, Hung T.; Truong, Anh-Hoang; Truong, Ninh-Thuan
    We introduce an approach to find upper bounds of heap space for Java Card applets. Our approach analyzes and transforms bytecodes of Java Card applets into equivalent programs in a language that already has a type system for finding the sharp upper bounds of resource use. We then point out a linear-time algorithm to compute the maximum heap units that may be allocated during the lifetime of Java Card applets. We also have implemented a prototype tool and tested it on several examples and the results are good.
  • Thumbnail Image
    Item
    FixBag: A Fixpoint Calculator for Quantified Bag Constraints
    (2011) Pham, Hung T.; Trinh, Minh-Thai; Truong, Anh-Hoang; Chin, Wei-Ngan
    Abstract interpretation techniques have played a major role in advancing the state-of-the-art in program analysis. Traditionally, stand- alone tools for these techniques have been developed for the numerical domains which may be sucient for lower levels of program correctness. To analyze a wider range of programs, we have developed a tool to compute symbolic xpoints for quantied bag domain. This domain is useful for programs that deal with collections of values. Our tool is able to derive both loop invariants and method pre/post conditions via fixpoint analysis of recursive bag constraints. To support better precision, we have allowed disjunctive formulae to be inferred, where appropriate. As a stand-alone tool, we have tested it on a range of small but challenging examples with acceptable precision and performance.
  • Thumbnail Image
    Item
    Introduction to the Guardol Language and Verification System
    (2011) Hardin, David; Slind, Konrad; Whalen, Michael; Pham, Hung T.
    Guardol is a high-level programming language intended to facilitate the construction of correct network guards. The Guardol system generates Ada code from Guardol programs. It also provides specification and automated verification support: guard specifications are formally translated to SMT format and passed to a new decision procedure dealing with functions over tree-structured data. The result is that difficult properties of Guardol programs can be proved fully automatically.
  • Thumbnail Image
    Item
    Parameterized Abstractions for Reasoning about Algebraic Data Types
    (2013) Pham, Hung T.; Whalen, Michael
    Reasoning about algebraic data types is an important problem for a variety of proof tasks. Recently, decision procedures have been proposed for algebraic data types that create suitable abstractions of values in the types. A class of abstractions created from catamorphism functions has been shown to be theoretically applicable to a wide variety of reasoning tasks as well as efficient in practice. However, in previous work, the decidability of catamorphism functions involving parameters in addition to the data type argument has not been studied. In this paper, we generalize certain kinds of catamorphism functions to support additional parameters. This extension, called parameterized associative-commutative catamorphisms subsumes the associative-commutative class from earlier work, widens the set of functions that are known to be decidable, and makes several practically important functions (such as forall, exists, and member) over elements of algebraic data types straightforward to express.
  • Thumbnail Image
    Item
    RADA: A Tool for Reasoning about Algebraic Data Types with Abstractions
    (2013) Pham, Hung T.; Whalen, Michael
    We present RADA, a portable, scalable tool for reasoning about formulas containing algebraic data types using catamorphism (fold) functions. It can work as a back-end for reasoning about recursive programs that manipulate algebraic types. RADA operates by successively unrolling catamorphisms and uses either CVC4 and Z3 as reasoning engines. We have used RADA for reasoning about functional implementations of complex data structures and to reason about guard applications that determine whether XML messages should be allowed to cross network security domains. Promising experimental results demonstrate that RADA can be used in several practical contexts.
  • Thumbnail Image
    Item
    Test Case Generation for Adequacy of Floating-point to Fixed-point Conversion
    (2010) Pham, Hung T.; Truong, Anh-Hoang; Chin, Wei-Ngan; Aoshima, Takenobu
    Porting an application written for personal computer to embedded devices requires conversion of floating-point numbers and operations into fixed-point ones. Testing the conversion hence requires the latter be as close as possible to the former. The closeness is orthogonal to code coverage and requires different strategies to generate a test suite that reveals the gap between the two functions. We introduce a new test adequacy criterion and propose several metrics to quantify the closeness of two functions. After that we propose a method to generate a better test suite from a given one for the test adequacy criteria. We also show experimental results on some well-known mathematical functions.
  • Thumbnail Image
    Item
    The Guardol Language and Verification System
    (Springer-Verlag, 2012) Hardin, David; Slind, Konrad; Whalen, Michael; Pham, Hung T.
    Guardol is a domain-specific language designed to facilitate the construction of correct network guards operating over tree-shaped data. The Guardol system generates Ada code from Guardol programs and also provides specification and automated verification support. Guard programs and specifications are translated to higher order logic, deductively transformed to a form suitable for a SMT-style decision procedure for recursive functions over tree-structured data. The result is that difficult properties of Guardol programs can be proved fully automatically.