MEDIC: A static analysis framework for equivalent mutant identification

2015 ◽  
Vol 68 ◽  
pp. 1-17 ◽  
Author(s):  
Marinos Kintis ◽  
Nicos Malevris
Keyword(s):  
Static Analysis ◽  
Analysis Framework ◽  
Mutant Identification

A Unified Kinetostatic Analysis Framework for Planar Compliant and Rigid Body Mechanisms

2014 ◽  
Author(s):  
Omer Anil Turkkan ◽  
Hai-Jun Su
Keyword(s):  
Mechanism Design ◽  
Static Analysis ◽  
Compliant Mechanisms ◽  
Daily Life ◽  
Analysis Framework ◽  
Planar Mechanisms ◽  
Simulation Tools ◽  
Compliant Joints ◽  
Adams Software ◽  
Simulation Results

Although many dynamic solvers are available for planar mechanisms, there is no readily accessible static solver that can be used in analysis of planar mechanisms with elastic components which achieve motion utilizing deformation of elastic members. New simulation tools are necessary to better understand the compliant mechanisms and to increase their usage in daily life. This framework was developed to fill this gap in planar mechanism design and analysis. The framework was written in MATLAB and is capable of kinematic and static analysis of planar mechanisms with compliant joints or links. Detailed information on implementation of the code is presented and is followed by the capabilities of the framework. Finally, the simulation results were compared with the Adams software to test the validity of the framework.

CODE-CHANGE IMPACT ANALYSIS USING COUNTERFACTUALS: THEORY AND IMPLEMENTATION

2013 ◽  
Vol 23 (10) ◽  
pp. 1459-1486
Author(s):  
MANUEL PERALTA ◽  
SUPRATIK MUKHOPADHYAY
Keyword(s):  
Static Analysis ◽  
Theorem Proving ◽  
Program Analysis ◽  
Impact Analysis ◽  
Source Code ◽  
Analysis Framework ◽  
Change Impact Analysis ◽  
Code Change ◽  
Change Impact ◽  
Automated Tool

This article shows a novel program analysis framework based on Lewis' theory of counterfactuals. Using this framework we are capable of performing change-impact static analysis on a program's source code. In other words, we are able to prove the properties induced by changes to a given program before applying these changes. Our contribution is two-fold; we show how to use Lewis' logic of counterfactuals to prove that proposed changes to a program preserve its correctness. We report the development of an automated tool based on resolution and theorem proving for performing code change-impact analysis.

scholarly journals Goblint: Thread-Modular Abstract Interpretation Using Side-Effecting Constraints

2021 ◽  
pp. 438-442
Author(s):  
Simmo Saan ◽  
Michael Schwarz ◽  
Kalmer Apinis ◽  
Julian Erhard ◽  
Helmut Seidl ◽  
...  
Keyword(s):  
Static Analysis ◽  
Abstract Interpretation ◽  
Analysis Framework ◽  
Data Race ◽  
C Programs ◽  
Global Invariants ◽  
Race Analysis

AbstractGoblintis a static analysis framework for C programs specializing in data race analysis. It relies on thread-modular abstract interpretation where thread interferences are accounted for by means of flow-insensitive global invariants.

scholarly journals ELAID: detecting integer-Overflow-to-Buffer-Overflow vulnerabilities by light-weight and accurate static analysis

Cybersecurity ◽  
2020 ◽  
Vol 3 (1) ◽  
Author(s):  
Lili Xu ◽  
Mingjie Xu ◽  
Feng Li ◽  
Wei Huo
Keyword(s):  
Static Analysis ◽  
Software Security ◽  
False Positives ◽  
Buffer Overflow ◽  
Prototype System ◽  
Light Weight ◽  
Analysis Framework ◽  
Smt Solver ◽  
Call Graph ◽  
Weight Method

Abstract The Integer-Overflow-to-Buffer-Overflow (IO2BO) vulnerability has been widely exploited by attackers to cause severe damages to computer systems. Automatically identifying this kind of vulnerability is critical for software security. Despite many works have been done to mitigate integer overflow, existing tools either report large number of false positives or introduce unacceptable time consumption. To address this problem, in this article we present a static analysis framework. It first constructs an inter-procedural call graph and utilizes taint analysis to accurately identify potential IO2BO vulnerabilities. Then it uses a light-weight method to further filter out false positives. Specifically, it generates constraints representing the conditions under which a potential IO2BO vulnerability can be triggered, and feeds the constraints to SMT solver to decide their satisfiability. We have implemented a prototype system ELAID based on LLVM, and evaluated it on 228 programs of the NIST’s SAMATE Juliet test suite and 14 known IO2BO vulnerabilities in real world. The experiment results show that our system can effectively and efficiently detect all known IO2BO vulnerabilities.

Sign in / Sign up

Export Citation Format

Share Document