Static Analyzers and Potential Future Research Directions for Scala: An Overview
---
paper_title: The Real Cost of Software Errors

paper_content:

Software is no longer creeping into every aspect of our lives - it's already there. In fact, failing to recognize just how much everything we do depends on software functioning correctly makes modern society vulnerable to software errors.
---
paper_title: IDE Plugins for Detecting Input-Validation Vulnerabilities

paper_content:

Many vulnerabilities in products and systems could be avoided if better secure coding practices were in place. There exist a number of Integrated Development Environment (IDE) plugins which help developers check for security flaws while they code. In this work, we present a review of these plugins. We specifically focus on the plugins that detect input-validation-related vulnerabilities. We list salient features such as their supported IDEs, applicable languages and specific types of vulnerability checks. We believe this work synthesizes information useful for future research on IDE plugins for detecting input-validation-related vulnerabilities.
---
paper_title: Memory and Resource Leak Defects and their Repairs in Java Projects

paper_content:

Despite huge software engineering efforts and programming language support, resource and memory leaks are still a troublesome issue, even in memory-managed languages such as Java. Understanding the properties of leak-inducing defects, how the leaks manifest, and how they are repaired is an essential prerequisite for designing better approaches for avoidance, diagnosis, and repair of leak-related bugs. We conduct a detailed empirical study on 491 issues from 15 large open-source Java projects. The study proposes taxonomies for the leak types, for the defects causing them, and for the repair actions. We investigate, under several aspects, the distributions within each taxonomy and the relationships between them. We find that manual code inspection and manual runtime detection are still the main methods for leak detection. We find that most of the errors manifest on error-free execution paths, and developers repair the leak defects in a shorter time than non-leak defects. We also identify 13 recurring code transformations in the repair patches. Based on our findings, we draw a variety of implications on how developers can avoid, detect, isolate and repair leak-related bugs.
---
paper_title: Compile-time Detection of Uncaught Exceptions in Standard ML Programs

paper_content:

We present a static analysis that detects potential runtime exceptions that are raised and never handled inside Standard ML programs. This analysis enhances the software safety by predicting, prior to the program execution, the abnormal termination caused by unhandled exceptions.
---
paper_title: Automated Security Analysis of Dynamic Web Applications through Symbolic Code Execution

paper_content:

The automatic identification of security vulnerabilities is a critical issue in the development of web-based applications. We present a methodology and tool for vulnerability identification based on symbolic code execution exploiting Static Taint Analysis to improve the efficiency of the analysis. The tool targets PHP web applications, and demonstrates the effectiveness of our approach in identifying cross-site scripting and SQL injection vulnerabilities on both NIST synthetic benchmarks and real world applications. It proves to be faster and more effective than its main competitors, both open source and commercial.
---
paper_title: Pixy: a static analysis tool for detecting Web application vulnerabilities

paper_content:

The number and the importance of Web applications have increased rapidly over the last years. At the same time, the quantity and impact of security vulnerabilities in such applications have grown as well. Since manual code reviews are time-consuming, error-prone and costly, the need for automated solutions has become evident. In this paper, we address the problem of vulnerable Web applications by means of static source code analysis. More precisely, we use flow-sensitive, interprocedural and context-sensitive dataflow analysis to discover vulnerable points in a program. In addition, alias and literal analysis are employed to improve the correctness and precision of the results. The presented concepts are targeted at the general class of taint-style vulnerabilities and can be applied to the detection of vulnerability types such as SQL injection, cross-site scripting, or command injection. Pixy, the open source prototype implementation of our concepts, is targeted at detecting cross-site scripting vulnerabilities in PHP scripts. Using our tool, we discovered and reported 15 previously unknown vulnerabilities in three Web applications, and reconstructed 36 known vulnerabilities in three other Web applications. The observed false positive rate is at around 50% (i.e., one false positive for each vulnerability) and therefore, low enough to permit effective security audits.
---
paper_title: Avoiding security pitfalls with functional programming: a report on the development of a secure XML validator

paper_content:

While the use of XML is pervading all areas of IT, security challenges arise when XML files are used to transfer security data such as security policies. To tackle this issue, we have developed a lightweight secure XML validator and have chosen to base the development on the strongly typed functional language OCaml. The initial development took place as part of the LaFoSec Study which aimed at investigating the impact of using functional languages for security. We then turned the validator into an industrial application, which was successfully evaluated at EAL4+ level by independent assessors. In this paper, we explain the challenges involved in processing XML data in a critical context, we describe our choices in designing a secure XML validator, and we detail how we used features of functional languages to enforce security requirements.
---
paper_title: Checkmate: A Generic Static Analyzer of Java Multithreaded Programs

paper_content:

In this paper we present Checkmate, a generic static analyzer of Java multithreaded programs based on the abstract interpretation theory. It supports all the most relevant features of Java multithreading, as dynamic unbounded thread creation, runtime creation of monitors, and dynamic allocation of shared memory. We implement a wide set of properties, from the ones interesting also for sequential programs, e.g. division by zero, to the ones typical of multithtreaded programs, e.g. data races. We analyze several external case studies and benchmarks with Checkmate, and we study the experimental results both in term of precision and efficiency. It turns out that the analysis is particularly accurate and we are in position to analyze programs composed by some thousands of statements and a potentially infinite number of threads. As far as we know, Checkmate is the first generic static analyzer of Java multithreaded programs.
---

Title: Static Analyzers and Potential Future Research Directions for Scala: An Overview

Section 1: INTRODUCTION
Description 1: This section introduces the need for static analyzers in software development, highlighting their importance in detecting defects early in the development phase, and the specific focus on Scala static analysis.

Section 2: SCALA LANGUAGE
Description 2: This section provides an overview of the Scala programming language, its features, and its design paradigms including object-oriented and functional programming.

Section 3: CURRENT STATE OF STATIC ANALYSIS TOOLS AND RESEARCH TARGETING SCALA
Description 3: This section discusses the existing static analysis tools available for Scala, evaluating their capabilities, limitations, and the specific types of vulnerabilities they can detect.

Section 4: CONCLUSIONS AND FUTURE WORK
Description 4: This section summarizes the findings regarding the current state of static analyzers for Scala, identifies the gaps in the current tools, and proposes potential future research directions to improve static analysis for Scala.

Section 5: Memory leaks
Description 5: This subsection discusses memory safety issues in Scala, the challenges in detecting memory leaks through static analysis, and suggests incorporating semantic analysis in addition to syntactic analysis.

Section 6: Unhandled exceptions
Description 6: This subsection highlights the risks associated with unhandled exceptions in Scala, the current capabilities of static analysis tools in detecting such issues, and the lack of static checking for exceptions in Scala.

Section 7: Null references
Description 7: This subsection addresses the issues related to null references in Scala, the existing tools' capability to detect such issues, and the best practices to avoid null references in production code.

Section 8: Cross-site scripting
Description 8: This subsection explores the prevalence and risks of Cross-Site-Scripting (XSS) attacks in web applications written in Scala, the effectiveness of static analysis in detecting XSS, and the limitations of existing tools in this area.

Section 9: XML external entity
Description 9: This subsection discusses the vulnerabilities associated with XML External Entity (XXE) attacks in Scala applications, the current static analysis tools’ capabilities, and the need for secure XML validators for functional programming languages like Scala.

Section 10: Multithreaded synchronization
Description 10: This subsection examines the challenges of multithreaded synchronization in Scala, the capabilities of current static analyzers to handle concurrent program execution, and the potential for future research to develop native synchronization detection approaches.