#source code analysis tools

Static code survey, as an expression, is entirely bit deluding. Static code survey alludes to two unique strategies for security testing: static code analyis and code audit.

Intelligent Application Security Testing works in essentially unexpected routes in comparison to static or dynamic apparatuses utilizing instrumentation innovation.

What is Static Analysis ??

Analysis of programs by methodically analyzing the program text is called static analysis. Static analysis is usually performed mechanically by the aid of software tools. During static analysis the program itself is not executed, but the program text is the input to the tools .

The aim of the static analysis tools is to detect errors or potential errors or to generate information about the structure of the programs that can be useful for documentation or understanding of the program.

Static analysis can be very useful for exposing errors that may escape other techniques. As the analysis is performed with the help of software tools, static analysis is a very cost-effective way of discovering errors. Data flow analysis is one form of static analysis that concentrate on the uses of data by programs and detects some data flow anomalies . An example of the data anomaly is the live variable problem. In which a variable is assigned some value but then the variable is not used in any later computation.

A static code analysis tool can help with your code review process by

detecting areas in the code that need to be refactored and simplified,

finding areas of the code that may need more testing or deeper review,

identifying design issues such as Cyclomatic complexity and helping reduce the code complexity improve maintainability,

identifying potential software quality issues before the code moves to production.

Dynamic code analysis

Dynamic code analysis is the method of analyzing an application right during its execution. The dynamic analysis process can be divided into several steps: preparing input data, running a test program launch and gathering the necessary parameters, and analyzing the output data. When performing the test launch, the program can be executed both on a real and a virtual processor. The source code should be necessarily compiled into an executable file, i.e. you can't use this method to analyze a code containing compilation or build errors.

Dynamic analysis can be performed on programs written in various programming languages: C, C++, Java, C#, PHP, Python, Erlang, and many others. For Easy setup and cost effective for Static Code Analysis, SnappyTick is known for.

There exist special dynamic code analysis utilities intended for program launch and output data gathering and analysis. Many contemporary development environments already have dynamic analysis tools as one of its modules. Such is, for example, the Microsoft Visual Studio 2012's debugger and profiler.

Dynamic analysis tools differ in the way they interact with the program being checked:

source code instrumentation - a special code is added into the source code before compilation to detect errors;

object code instrumentation - a special code is added directly into the executable file;

compilation stage instrumentation - a checking code is added through special compiler switches (this mode is supported, for instance, by the GNU C/C++ 4.x compiler);

the tool doesn't change the source code; instead, it uses special execution stage libraries - special debugging versions of system libraries are used to detect errors.

Dynamic analysis is executed by passing a set of data to the input of the program being checked. That's why the efficiency of analysis depends directly on the quality and quantity of the input test data. It's them that the fullness of code coverage obtained through the test depends on.

Dynamic testing can provide the following metrics to you:

resources consumed - the time of program execution on the whole or its modules individually, the number of external queries (for example, to the database), the number of memory being used, and other resources;

cyclomatic complexity, the degree of code coverage with tests, and other program metrics;

program errors - division by zero, null pointer dereferencing, memory leaks, "race conditions";

vulnerabilities in the program.

Dynamic testing is most important in the areas where program reliability, response time, and consumed resources are the crucial criteria. It may be, for instance, a real-time system managing a responsible production area or a database server. Any bug that occurs in these systems may be critical.

Dynamic testing can be performed on the principles of white box and black box. Their only difference is that you have information about the program code in case of the "white box", while you don't have it in case of the "black box". There also exists the so called "gray box" method when you know the program structure but these data are not used in the testing itself.

When performing dynamic testing, you also have to minimize the influence of instrumentation on execution of the program being tested (temporal characteristics, resources consumed, or program errors).

Dynamic testing allows you to make sure that the product works well or reveals errors showing that the program doesn't work. The second goal of the testing is a more productive one from the viewpoint of quality enhancement, as it doesn't allow you to ignore the program drawbacks. But if no defects have been revealed during the testing, it doesn't necessarily mean there are no any at all. Even 100% code coverage with tests doesn't mean there are no errors in the code, since dynamic testing cannot reveal logic errors. Another important aspect is whether testing utilities have errors themselves.

A separate task third-party utilities may be used to solve is creation of input test data. Some utilities use the following method: they mark the input data and track their movement as the program is being executed. At the next iteration of test launch the utility will generate a new set of input parameters, and son on - until it gets the needed result.

Thus, dynamic analysis has both weak and strong points.

The pros of dynamic code analysis are the following:

In most cases, generation of false positives is impossible, as error detection occurs right at the moment of its occurrence; thus, the error detected is not a prediction based on the analysis of the program model, but a statement of the fact of its occurrence;

Usually you don't need the source code; it allows you to test proprietary code.

These are the cons of dynamic code analysis:

Dynamic analysis detects defects only on the route defined by the concrete input data; defects in other code fragments won't be found;

It cannot check the correctness of code operation, i.e. if the code does what it must;

Significant computational resources are required to perform the testing;

Only one execution path can be checked at each particular moment, which makes you run the test many times to provide as complete testing as possible;

When the test is run on a real processor, execution of incorrect code may have unpredictable consequences.

Having its own weak and strong points, the dynamic analysis technology can be used most effectively together with the static analysis technology.

Easy setup and cost effective for Static Code Analysis, SnappyTick is known for. It can execute your source code faster than any other tools and it deliver reliable output with maximise positive rate. As we know it is faster enough so you or your team can find the difference by running SnappyTick on your system which will analyze your code within a minute. Have a Snappy tour so that you can explore the new and unique features on this Static testing tool.