The Experts below are selected from a list of 58113 Experts worldwide ranked by ideXlab platform
Carla Merkle Westphall - One of the best experts on this subject based on the ideXlab platform.
-
proposal and development of the web services Input Validation model
Network Operations and Management Symposium, 2012Co-Authors: Rafael Bosse Brinhosa, Carla Merkle WestphallAbstract:The SOA architecture primarily based on Web services is experiencing a steady adoption, although its growth was lower than expected when it was launched, mainly because of security related concerns. Web services inherited many well-known security problems of Web applications and brought new ones. Major data breaches today are consequences of bad Input Validation at the application level. This paper presents a way to implement an Input Validation model for Web services which can be used to prevent cross-site scripting and SQL injection through the use of predefined models which specify valid Inputs. The proposed WSIVM (Web Services Input Validation Model) consists of an XML schema, an XML specification, and a module for performing Input Validation according to the schema. A case study showing the effectiveness and performance of this mechanism is also presented.
-
NOMS - Proposal and development of the Web services Input Validation model
2012 IEEE Network Operations and Management Symposium, 2012Co-Authors: Rafael Bosse Brinhosa, Carla Merkle WestphallAbstract:The SOA architecture primarily based on Web services is experiencing a steady adoption, although its growth was lower than expected when it was launched, mainly because of security related concerns. Web services inherited many well-known security problems of Web applications and brought new ones. Major data breaches today are consequences of bad Input Validation at the application level. This paper presents a way to implement an Input Validation model for Web services which can be used to prevent cross-site scripting and SQL injection through the use of predefined models which specify valid Inputs. The proposed WSIVM (Web Services Input Validation Model) consists of an XML schema, an XML specification, and a module for performing Input Validation according to the schema. A case study showing the effectiveness and performance of this mechanism is also presented.
-
a security framework for Input Validation
International Conference on Emerging Security Information Systems and Technologies, 2008Co-Authors: Rafael Bosse Brinhosa, Carla Merkle WestphallAbstract:Input manipulation attacks are becoming one of the most common attacks against Web applications and Web services security. As the use of firewalls and other security mechanisms are not effective against application-level attacks, new means of defense are needed. This paper presents a framework proposal to solve this problem, securing applications against Input manipulation attacks. The proposed mechanism offers a reusable approach by the use of XML files and a XML Schema for security parameters specification. Furthermore, a case of study and experiment results are presented. The experiment demonstrates how common Input manipulation flaws could be observed.
-
SECURWARE - A Security Framework for Input Validation
2008 Second International Conference on Emerging Security Information Systems and Technologies, 2008Co-Authors: Rafael Bosse Brinhosa, Carla Merkle Westphall, Carla Merkle WestphallAbstract:Input manipulation attacks are becoming one of the most common attacks against Web applications and Web services security. As the use of firewalls and other security mechanisms are not effective against application-level attacks, new means of defense are needed. This paper presents a framework proposal to solve this problem, securing applications against Input manipulation attacks. The proposed mechanism offers a reusable approach by the use of XML files and a XML Schema for security parameters specification. Furthermore, a case of study and experiment results are presented. The experiment demonstrates how common Input manipulation flaws could be observed.
Tevfik Bultan - One of the best experts on this subject based on the ideXlab platform.
-
Differential String Analysis and Repair
String Analysis for Software Verification and Security, 2017Co-Authors: Tevfik Bultan, Muath Alkhalaf, Abdulbaki AydinAbstract:Effectiveness of policy-based bug detection and repair that we presented in previous chapter depends on the correctness and precision of the written policies in characterizing good and bad string values. It is often possible, for instance, to encode well-known attacks into security policies (in the form of attack patterns) and write down policies for common Input fields such as email address and zip code. In other cases, however, the checks to be performed on the Inputs are specific to the functionality of the web application, and the Input Validation may be tightly coupled with and dependent on the application logic. Because they are specific to individual applications, there are no pre-specified policies that can be used to assess these types of Input checks. In these cases, to make sure that the Input Validation is adequate, it would be necessary to specify a different policy for each different application, which is a tedious and error-prone task.
-
SPIN - String Analysis for Vulnerability Detection and Repair
Model Checking Software, 2015Co-Authors: Tevfik BultanAbstract:String manipulation errors in Input Validation and sanitization code are a common source for security vulnerabilities in web applications. This short survey summarizes the string analysis techniques we developed that can automatically identify and repair such vulnerabilities. Our approach 1 extracts client- and server-side Input Validation and sanitization functions, 2 models them as deterministic finite automata DFA using symbolic fixpoint computations, and 3 identifies errors in Input Validation and sanitization code by either checking them with respect to manually specified attack patterns, or by identifying inconsistencies in Input Validation and sanitization operations at the client and server-side. Furthermore, we developed automated repair techniques that strengthen the Input Validation and sanitization checks in order to eliminate identified vulnerabilities. We implemented these techniques in two tools: Stranger STRing AutomatoN GEneratoR and SemRep SEMantic differential REPair, which are available at: http://www.cs.ucsb.edu/~vlab/tools.html. Our experimental evaluation demonstrates that these techniques are very promising: when applied to a set of real-world web applications, our techniques are able to automatically identify a large number of security vulnerabilities and repair them.
-
semantic differential repair for Input Validation and sanitization
International Symposium on Software Testing and Analysis, 2014Co-Authors: Muath Alkhalaf, Abdulbaki Aydin, Tevfik BultanAbstract:Correct Validation and sanitization of user Input is crucial in web applications for avoiding security vulnerabilities and erroneous application behavior. We present an automated differential repair technique for Input Validation and sanitization functions. Differential repair can be used within an application to repair client and server-side code with respect to each other, or across applications in order to strengthen the Validation and sanitization checks. Given a reference and a target function, our differential repair technique strengthens the Validation and sanitization operations in the target function based on the reference function. It does this by synthesizing three patches: a Validation, a length, and a sanitization patch. Our automated patch synthesis algorithms are based on forward and backward symbolic string analyses that use automata as a symbolic representation. Composition of the three automatically synthesized patches with the original target function results in the repaired function, which provides stronger Validation and sanitization than both the target and the reference functions.
-
ISSTA - Semantic differential repair for Input Validation and sanitization
Proceedings of the 2014 International Symposium on Software Testing and Analysis - ISSTA 2014, 2014Co-Authors: Muath Alkhalaf, Abdulbaki Aydin, Tevfik BultanAbstract:Correct Validation and sanitization of user Input is crucial in web applications for avoiding security vulnerabilities and erroneous application behavior. We present an automated differential repair technique for Input Validation and sanitization functions. Differential repair can be used within an application to repair client and server-side code with respect to each other, or across applications in order to strengthen the Validation and sanitization checks. Given a reference and a target function, our differential repair technique strengthens the Validation and sanitization operations in the target function based on the reference function. It does this by synthesizing three patches: a Validation, a length, and a sanitization patch. Our automated patch synthesis algorithms are based on forward and backward symbolic string analyses that use automata as a symbolic representation. Composition of the three automatically synthesized patches with the original target function results in the repaired function, which provides stronger Validation and sanitization than both the target and the reference functions.
-
viewpoints differential string analysis for discovering client and server side Input Validation inconsistencies
International Symposium on Software Testing and Analysis, 2012Co-Authors: Muath Alkhalaf, Tevfik Bultan, Shauvik Roy Choudhary, Mattia Fazzini, Alessandro Orso, Christopher KruegelAbstract:Since web applications are easily accessible, and often store a large amount of sensitive user information, they are a common target for attackers. In particular, attacks that focus on Input Validation vulnerabilities are extremely effective and dangerous. To address this problem, we developed ViewPoints--a technique that can identify erroneous or insufficient Validation and sanitization of the user Inputs by automatically discovering inconsistencies between client- and server-side Input Validation functions. Developers typically perform redundant Input Validation in both the front-end (client) and the back-end (server) components of a web application. Client- side Validation is used to improve the responsiveness of the application, as it allows for responding without communicating with the server, whereas server-side Validation is necessary for security reasons, as malicious users can easily circumvent client-side checks. ViewPoints (1) automatically extracts client- and server-side Input Validation functions, (2) models them as deterministic finite automata (DFAs), and (3) compares client- and server-side DFAs to identify and report the inconsistencies between the two sets of checks. Our initial evaluation of the technique is promising: when applied to a set of real-world web applications, ViewPoints was able to automatically identify a large number of inconsistencies in their Input Validation functions.
Engin Kirda - One of the best experts on this subject based on the ideXlab platform.
-
preventing Input Validation vulnerabilities in web applications through automated type analysis
Computer Software and Applications Conference, 2012Co-Authors: Theodoor Scholte, William Van B. Robertson, Davide Balzarotti, Engin KirdaAbstract:Web applications have become an integral part of the daily lives of millions of users. Unfortunately, web applications are also frequently targeted by attackers, and criticial vulnerabilities such as cross-site scripting and SQL injection are still common. As a consequence, much effort in the past decade has been spent on mitigating web application vulnerabilities. Current techniques focus mainly on sanitization: either on automated sanitization, the detection of missing sanitizers, the correctness of sanitizers, or the correct placement of sanitizers. However, these techniques are either not able to prevent new forms of Input Validation vulnerabilities such as HTTP Parameter Pollution, come with large runtime overhead, lack precision, or require significant modifications to the client and/or server infrastructure. In this paper, we present IPAAS, a novel technique for preventing the exploitation of cross-site scripting and SQL injection vulnerabilities based on automated data type detection of Input parameters. IPAAS automatically and transparently augments otherwise insecure web application development environments with Input validators that result in significant and tangible security improvements for real systems. We implemented IPAAS for PHP and evaluated it on five real-world web applications with known cross-site scripting and SQL injection vulnerabilities. Our evaluation demonstrates that IPAAS would have prevented 83% of SQL injection vulnerabilities and 65% of cross-site scripting vulnerabilities while incurring no developer burden.
-
COMPSAC - Preventing Input Validation Vulnerabilities in Web Applications through Automated Type Analysis
2012 IEEE 36th Annual Computer Software and Applications Conference, 2012Co-Authors: Theodoor Scholte, William Van B. Robertson, Davide Balzarotti, Engin KirdaAbstract:Web applications have become an integral part of the daily lives of millions of users. Unfortunately, web applications are also frequently targeted by attackers, and criticial vulnerabilities such as cross-site scripting and SQL injection are still common. As a consequence, much effort in the past decade has been spent on mitigating web application vulnerabilities. Current techniques focus mainly on sanitization: either on automated sanitization, the detection of missing sanitizers, the correctness of sanitizers, or the correct placement of sanitizers. However, these techniques are either not able to prevent new forms of Input Validation vulnerabilities such as HTTP Parameter Pollution, come with large runtime overhead, lack precision, or require significant modifications to the client and/or server infrastructure. In this paper, we present IPAAS, a novel technique for preventing the exploitation of cross-site scripting and SQL injection vulnerabilities based on automated data type detection of Input parameters. IPAAS automatically and transparently augments otherwise insecure web application development environments with Input validators that result in significant and tangible security improvements for real systems. We implemented IPAAS for PHP and evaluated it on five real-world web applications with known cross-site scripting and SQL injection vulnerabilities. Our evaluation demonstrates that IPAAS would have prevented 83% of SQL injection vulnerabilities and 65% of cross-site scripting vulnerabilities while incurring no developer burden.
-
Have things changed now? An empirical study on Input Validation vulnerabilities in web applications
Computers & Security, 2012Co-Authors: Theodoor Scholte, Davide Balzarotti, Engin KirdaAbstract:Web applications have become important services in our daily lives. Millions of users use web applications to obtain information, perform financial transactions, have fun, socialize, and communicate. Unfortunately, web applications are also frequently targeted by attackers. Recent data from SANS institute estimates that up to 60% of Internet attacks target web applications. In this paper, we perform an empirical analysis of a large number of web vulnerability reports with the aim of understanding how Input Validation flaws have evolved in the last decade. In particular, we are interested in finding out if developers are more aware of web security problems today than they used to be in the past. Our results suggest that the complexity of the attacks have not changed significantly and that many web problems are still simple in nature. Hence, despite awareness programs provided by organizations such as MITRE, SANS Institute and OWASP, application developers seem to be either not aware of these classes of vulnerabilities, or unable to implement effective countermeasures. Therefore, we believe that there is a growing need for languages and application platforms that attack the root of the problem and secure applications by design.
-
SAC - An empirical analysis of Input Validation mechanisms in web applications and languages
Proceedings of the 27th Annual ACM Symposium on Applied Computing - SAC '12, 2012Co-Authors: Theodoor Scholte, William Van B. Robertson, Davide Balzarotti, Engin KirdaAbstract:Web applications have become an integral part of the daily lives of millions of users. Unfortunately, web applications are also frequently targeted by attackers, and attacks such as XSS and SQL injection are still common. In this paper, we present an empirical study of more than 7000 Input Validation vulnerabilities with the aim of gaining deeper insights into how these common web vulnerabilities can be prevented. In particular, we focus on the relationship between the specific programming language used to develop web applications and the vulnerabilities that are commonly reported. Our findings suggest that most SQL injection and a significant number of XSS vulnerabilities can be prevented using straight-forward Validation mechanisms based on common data types. We elaborate on these common data types, and discuss how support could be provided in web application frameworks.
-
Quo vadis? A study of the evolution of Input Validation vulnerabilities in web applications
Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), 2012Co-Authors: Theodoor Scholte, Davide Balzarotti, Engin KirdaAbstract:Web applications have become important services in our daily lives. Millions of users use web applications to obtain information, perform financial transactions, have fun, socialize, and communicate. Unfortunately, web applications are also frequently targeted by attackers. Recent data from SANS institute estimates that up to 60% of Internet attacks target web applications.\nIn this paper, we perform an empirical analysis of a large number of web vulnerability reports with the aim of understanding how Input Validation flaws have evolved in the last decade. In particular, we are interested in finding out if developers are more aware of web security problems today than they used to be in the past. Our results suggest that the complexity of the attacks have not changed significantly and that many web problems are still simple in nature. Hence, despite awareness programs provided by organizations such as MITRE, SANS Institute and OWASP, application developers seem to be either not aware of these classes of vulnerabilities, or unable to implement effective countermeasures. Therefore, we believe that there is a growing need for languages and application platforms that attack the root of the problem and secure applications by design.
Muath Alkhalaf - One of the best experts on this subject based on the ideXlab platform.
-
Automatic Detection and Repair of Input Validation and Sanitization Bugs
2019Co-Authors: Muath AlkhalafAbstract:Author(s): Alkhalaf, Muath | Advisor(s): Bultan, Tevfik | Abstract: A crucial problem in developing dependable web applications is thecorrectness of the Input Validation and sanitization. Bugs in stringmanipulation operations used for Validation and sanitization are common,resulting in erroneous application behavior and vulnerabilities that areexploitable by malicious users. In this dissertation, we investigate theproblem of automatic detection and repair of Validation and sanitization bugsboth at the client-side (JavaScript) and the server-side (PHP or Java) code.We first present a formal model for Input Validation and sanitizationfunctions along with a new domain specific intermediate languageto represent them. Then, we show how to extract Input Validation andsanitization functions in our intermediate language from both client andserver-side code in web applications. After the extraction phase, we useautomata-based static string-analysis techniques to automatically verifyand fix the extracted functions. One of our contributions is the developmentof efficient automata-based string analysis techniques for frequently used,complex string operations.We developed two basic approaches to bug detection and repair: 1)policy-based, and 2) differential. In the policy-based approach, InputValidation and sanitization policies are expressed using two regularexpressions, one specifying the maximum policy (the upper bound for theset of strings that should be allowed) and the other specifying the minimumpolicy (the lower bound for the set of strings that should be allowed). Usingour string analysis techniques we can identify two types of errors inan Input Validation and sanitization function: 1) it accepts a set of strings thatis not permitted by the maximum policy (i.e., it is under-constrained),or 2) it rejects a set of strings that is permitted by the minimum policy(i.e., it is over-constrained).Our differential bug detection and repair approach does not require anypolicy specifications. It exploits the fact that, in web applications,developers typically perform redundant Input Validation and sanitizationin both the client and the server-side since client-side checks canbe by-passed. Using automata-based string analysis, we compare theInput Validation and sanitization functions extracted from the client- andserver-side code, and identify and report the inconsistencies between them.Finally, we present an automated differential repair technique that canrepair client and server-side code with respect to each other, or acrossapplications in order to strengthen the Validation and sanitizationchecks. Given a reference and a target function, our differential repairtechnique strengthens the Validation and sanitization operations in thetarget function based on the reference function by automatically generatinga set of patches.We experimented with a number of real world web applications and found manybugs and vulnerabilities. Our analysis generates counter-example behaviorsdemonstrating the detected bugs and vulnerabilities to help the developerswith the debugging process. Moreover, we automatically generate patchesthat can be used to mitigate the detected bugs and vulnerabilities untildevelopers write their own patches.
-
viewpoints differential string analysis for discovering client and server side Input Validation inconsistencies
International Symposium on Software Testing and Analysis, 2012Co-Authors: Muath Alkhalaf, Tevfik Bultan, Shauvik Roy Choudhary, Mattia Fazzini, Alessandro Orso, Christopher KruegelAbstract:Since web applications are easily accessible, and often store a large amount of sensitive user information, they are a common target for attackers. In particular, attacks that focus on Input Validation vulnerabilities are extremely effective and dangerous. To address this problem, we developed ViewPoints--a technique that can identify erroneous or insufficient Validation and sanitization of the user Inputs by automatically discovering inconsistencies between client- and server-side Input Validation functions. Developers typically perform redundant Input Validation in both the front-end (client) and the back-end (server) components of a web application. Client- side Validation is used to improve the responsiveness of the application, as it allows for responding without communicating with the server, whereas server-side Validation is necessary for security reasons, as malicious users can easily circumvent client-side checks. ViewPoints (1) automatically extracts client- and server-side Input Validation functions, (2) models them as deterministic finite automata (DFAs), and (3) compares client- and server-side DFAs to identify and report the inconsistencies between the two sets of checks. Our initial evaluation of the technique is promising: when applied to a set of real-world web applications, ViewPoints was able to automatically identify a large number of inconsistencies in their Input Validation functions.
-
ISSTA - ViewPoints: differential string analysis for discovering client- and server-side Input Validation inconsistencies
Proceedings of the 2012 International Symposium on Software Testing and Analysis - ISSTA 2012, 2012Co-Authors: Muath Alkhalaf, Tevfik Bultan, Shauvik Roy Choudhary, Mattia Fazzini, Alessandro Orso, Christopher KruegelAbstract:Since web applications are easily accessible, and often store a large amount of sensitive user information, they are a common target for attackers. In particular, attacks that focus on Input Validation vulnerabilities are extremely effective and dangerous. To address this problem, we developed ViewPoints--a technique that can identify erroneous or insufficient Validation and sanitization of the user Inputs by automatically discovering inconsistencies between client- and server-side Input Validation functions. Developers typically perform redundant Input Validation in both the front-end (client) and the back-end (server) components of a web application. Client- side Validation is used to improve the responsiveness of the application, as it allows for responding without communicating with the server, whereas server-side Validation is necessary for security reasons, as malicious users can easily circumvent client-side checks. ViewPoints (1) automatically extracts client- and server-side Input Validation functions, (2) models them as deterministic finite automata (DFAs), and (3) compares client- and server-side DFAs to identify and report the inconsistencies between the two sets of checks. Our initial evaluation of the technique is promising: when applied to a set of real-world web applications, ViewPoints was able to automatically identify a large number of inconsistencies in their Input Validation functions.
-
verifying client side Input Validation functions using string analysis
International Conference on Software Engineering, 2012Co-Authors: Muath Alkhalaf, Tevfik Bultan, Jose L GallegosAbstract:Client-side computation in web applications is becoming increasingly common due to the popularity of powerful client-side programming languages such as JavaScript. Client-side computation is commonly used to improve an application's responsiveness by validating user Inputs before they are sent to the server. In this paper, we present an analysis technique for checking if a client-side Input Validation function conforms to a given policy. In our approach, Input Validation policies are expressed using two regular expressions, one specifying the maximum policy (the upper bound for the set of Inputs that should be allowed) and the other specifying the minimum policy (the lower bound for the set of Inputs that should be allowed). Using our analysis we can identify two types of errors 1) the Input Validation function accepts an Input that is not permitted by the maximum policy, or 2) the Input Validation function rejects an Input that is permitted by the minimum policy. We implemented our analysis using dynamic slicing to automatically extract the Input Validation functions from web applications and using automata-based string analysis to analyze the extracted functions. Our experiments demonstrate that our approach is effective in finding errors in Input Validation functions that we collected from real-world applications and from tutorials and books for teaching JavaScript.
-
ICSE - Verifying client-side Input Validation functions using string analysis
2012 34th International Conference on Software Engineering (ICSE), 2012Co-Authors: Muath Alkhalaf, Tevfik Bultan, Jose L GallegosAbstract:Client-side computation in web applications is becoming increasingly common due to the popularity of powerful client-side programming languages such as JavaScript. Client-side computation is commonly used to improve an application's responsiveness by validating user Inputs before they are sent to the server. In this paper, we present an analysis technique for checking if a client-side Input Validation function conforms to a given policy. In our approach, Input Validation policies are expressed using two regular expressions, one specifying the maximum policy (the upper bound for the set of Inputs that should be allowed) and the other specifying the minimum policy (the lower bound for the set of Inputs that should be allowed). Using our analysis we can identify two types of errors 1) the Input Validation function accepts an Input that is not permitted by the maximum policy, or 2) the Input Validation function rejects an Input that is permitted by the minimum policy. We implemented our analysis using dynamic slicing to automatically extract the Input Validation functions from web applications and using automata-based string analysis to analyze the extracted functions. Our experiments demonstrate that our approach is effective in finding errors in Input Validation functions that we collected from real-world applications and from tutorials and books for teaching JavaScript.
Marco Vieira - One of the best experts on this subject based on the ideXlab platform.
-
trustworthiness assessment of web applications approach and experimental study using Input Validation coding practices
International Symposium on Software Reliability Engineering, 2019Co-Authors: Cristiano Inacio Lemes, Vincent Naessens, Marco VieiraAbstract:The popularity of web applications and their world-wide use to support business critical operations raised the interest of hackers on exploiting security vulnerabilities to perform malicious operations. Fostering trust calls for assessment techniques that provide indicators about the quality of a web application from a security perspective. This paper studies the problem of using coding practices to characterize the trustworthiness of web applications from a security perspective. The hypothesis is that applying feasible security practices results in applications having a reduced number of unknown vulnerabilities, and can therefore be considered more trustworthy. The proposed approach is instantiated for the concrete case of Input Validation practices, and includes a Quality Model to compute trustworthiness scores that can be used to compare different applications or different code elements in the same application. Experimental results show that the higher scores are obtained for more secure code, suggesting that it can be used in practice to characterize trustworthiness, also providing guidance to compare and/or improve the security of web applications.
-
ISSRE - Trustworthiness Assessment of Web Applications: Approach and Experimental Study using Input Validation Coding Practices
2019 IEEE 30th International Symposium on Software Reliability Engineering (ISSRE), 2019Co-Authors: Cristiano Inacio Lemes, Vincent Naessens, Marco VieiraAbstract:The popularity of web applications and their world-wide use to support business critical operations raised the interest of hackers on exploiting security vulnerabilities to perform malicious operations. Fostering trust calls for assessment techniques that provide indicators about the quality of a web application from a security perspective. This paper studies the problem of using coding practices to characterize the trustworthiness of web applications from a security perspective. The hypothesis is that applying feasible security practices results in applications having a reduced number of unknown vulnerabilities, and can therefore be considered more trustworthy. The proposed approach is instantiated for the concrete case of Input Validation practices, and includes a Quality Model to compute trustworthiness scores that can be used to compare different applications or different code elements in the same application. Experimental results show that the higher scores are obtained for more secure code, suggesting that it can be used in practice to characterize trustworthiness, also providing guidance to compare and/or improve the security of web applications.