Learn More on Static Security Source Code Analysis

Hackers are keen on exploiting weaknesses in your software causing huge financial and reputation loss. However, having the code produced by your development team, you have the upper hand on hackers with the ability to analyze your software looking for security weaknesses.



Program analysis is a well-known and seemingly fruitful field of computer science both for academical studies and commerical markets. The goal of the program analysis is to automatically analyze the behavior of a target application against certain properties such as robustness, security or trustworthiness.

There are mainly two types of program analysis; static and dynamic. As their names imply, static program analysis is realized without actually running the target program, most of the time using the source code or intermediary code. On the other hand, dynamic program analysis is performed against the executing target program.

Having pros and cons, both techniques are extremely important to figure out certain hard to reveal behaviors of software programs such as security.


Historically static code analysis has been extensively used for compiler optimizations. However, usually performed by automated tools they are also being used for understanding and therefore, simplifying the complexities of software projects integrated right into the programming integrated development environments (IDEs).

Helpful to software developers most of the IDEs have built-in checkers, such as plugins for Eclipse or code analysis for Visual Studio, for easing the task of analyzing the source code producing meaningful pointers for further optimization and correctness. Security analysis is also somewhat performed by these checkers, however, stays short because of their way of intra-procedural analysis and small security finding type ranges.

Intra-procedural analysis, as opposed to inter-procedural analysis, only a single procedure, class or file is analyzed, as if this block of code doesn't interact with the rest of the project. Hence, albeit producing results hardly hitting the fruitful findings that may help hackers to cause the real trouble.



Inherently, finding every possible security weaknesses in a software program using static code analysis, or any other automated mechanism for that matter, correctly is impossible due to proven Halting Problem.

However, following untrusted data, in other words tainted data, right to the dangerous APIs of the target programming framework or language substantially increases the precision and soundness of the security static code analysis done.

AttackFlow security static source solutions utilize Just-in-Time reverse call graph, flow-sensitive points-to analysis methods in order to reveal critical security and quality problems that a software harbors.


Why is it important to catch security bugs?

Because software is a complex piece of technology in the very heart of our lives from health to entertainment, from finance to connectivity. No doubt, security should be an integral part of this technology. As the history incessantly reveals malicious intentions against services are not new and software open to whole Internet usage is not an exception. Software products are constant and increasing targets for activists, organized or unorganized hackers, script kiddies, bug hunters and even the governments.

One of most important and widely adopted software security action is the security static code analysis. Security static code analysis is executed on the static code by the help of another software with a mainly security perspective focusing on finding weaknesses without running it. There are many challenges to static code analysis such as hard to perform flow and control analysis, possible false-positives, performance issues on huge projects. However, being automatic static code analysis has also huge advantages;

  • Repeatable
  • Doesn't need expertise
  • Takes short time

Finding A Way To Try AttackFlow Enterprise Edition?

If so, click to download 15 days full version for free!

A phenomenon that nearly every software security expert agrees upon is that in the software process “the early the bugs are found, the less cost they induce logarithmically”. The cost here is not only the money or time, it also means the level of stress on the shoulders of a developer in case of a successful hack.