Invalid Inputs Research Articles

Dyadic judgments based on conflicting samples: The failure to ignore invalid input

AbstractThe present research demonstrates a so far unrecognized impediment of group performance, metacognitive myopia (Fiedler, 2012). Judges and decision‐makers follow the given samples of information uncritically and neglect the metacognitive assessment of the samples' validity. Applying this notion to dyadic judgments, we instructed dyads to jointly estimate conditional probabilities p (Win|A) and p (Win|B) of Lotteries A and B. One person per dyad experienced a valid sample (winning rates conditional on lotteries). The other person experienced an invalid, reverse sample (lotteries conditional on winning). Whereas valid samples provide unbiased estimates of lotteries' winning probabilities, invalid samples can greatly misrepresent the association of winning and lotteries (depending on lottery base rates). Across three experiments, metacognitive myopia—both at the individual and at the dyadic group level—prevented participants from discriminating valid and invalid samples. Group judgments were biased toward erroneous implications of invalid samples, reflecting an equality bias among unequal group members.

Smart Contract Fuzzing Based on Taint Analysis and Genetic Algorithms

Smart contract has greatly improved the services and capabilities of blockchain, but it has become the weakest link of blockchain security because of its code nature. Therefore, efficient vulnerability detection of smart contract is the key to ensure the security of blockchain system. Oriented to Ethereum smart contract, the study solves the problems of redundant input and low coverage in the smart contract fuzz. In this paper, a taint analysis method based on EVM is proposed to reduce the invalid input, a dangerous operation database is designed to identify the dangerous input, and genetic algorithm is used to optimize the code coverage of the input, which construct the fuzzing framework for smart contract together. Finally, by comparing Oyente and ContractFuzzer, the performance and efficiency of the framework are proved.

Smart Contract Fuzzing Based on Taint Analysis and Genetic Algorithms

Smart contract has greatly improved the services and capabilities of blockchain, but it has become the weakest link of blockchain security because of its code nature. Therefore, efficient vulnerability detection of smart contract is the key to ensure the security of blockchain system. Oriented to Ethereum smart contract, the study solves the problems of redundant input and low coverage in the smart contract fuzz. In this paper, a taint analysis method based on EVM is proposed to reduce the invalid input, a dangerous operation database is designed to identify the dangerous input, and genetic algorithm is used to optimize the code coverage of the input, which construct the fuzzing framework for smart contract together. Finally, by comparing Oyente and ContractFuzzer, the performance and efficiency of the framework are proved.

Security Testing Tool for NoSQL Systems

NoSQL systems are becoming more popular due to their inherent advantages and solutions it provides to the limits of a relational database. However, despite its benefits, it comes with security challenges. In this paper, an input validation mechanism architecture is proposed for Mongo DB to detect and prevent NoSQL injection attacks, the mechanism employs a Deterministic Finite Automaton (DFA) approach to detect and prevent attacks on NoSQL systems. Furthermore, a security comparison of some NoSQL systems is provided based on recent literature. The security features compared are authentication, authorization, data encryption and input validation. The proposed mechanism will improve the security of Mongo DB system because invalid inputs requests will be detected and prevented from being processed.

Efficient Subgraph Matching on Large RDF Graphs Using MapReduce

With the popularity of knowledge graphs growing rapidly, large amounts of RDF graphs have been released, which raises the need for addressing the challenge of distributed subgraph matching queries. In this paper, we propose an efficient distributed method to answer subgraph matching queries on big RDF graphs using MapReduce. In our method, query graphs are decomposed into a set of stars that utilize the semantic and structural information embedded RDF graphs as heuristics. Two optimization techniques are proposed to further improve the efficiency of our algorithms. One algorithm, called RDF property filtering, filters out invalid input data to reduce intermediate results; the other is to improve the query performance by postponing the Cartesian product operations. The extensive experiments on both synthetic and real-world datasets show that our method outperforms the close competitors S2X and SHARD by an order of magnitude on average.

HSW: Heuristic Shrink-wrapping for automatically repairing solid-based CityGML LOD2 building models

The Level-of-Detail (LOD) 2 building models defined in CityGML are used widely in three-dimensional (3D) city applications. Many of these applications demand valid solid-based geometry (closed 2-manifold), which is crucial for analytical and computational purposes. However, this condition is often violated in practice because of the way LOD2 models are constructed and exchanged. Examples of the resulting errors include missing surfaces, intersecting building parts, and superfluous interior geometry. In this study, we present a heuristic shrink-wrapping algorithm for reconstructing valid solid-based LOD2 buildings by repairing and generalizing invalid input models. A single building model is first decomposed as intersection-free and reassembled by constrained tetrahedralization. The bounding membrane is then shrunk by incrementally carving the selected boundary tetrahedra and wrapping the expected shape of the building. In the algorithm, combinations of heuristics are proposed to guide the carving process. Topological and geometrical constraints are proposed to ensure the validity and exactness of the output model. The semantics of the input geometry are preserved and missing semantics are deduced based on pragmatic rules. We evaluated the performance of the algorithm using 3D building models, including CityGML datasets. The results showed that our method achieved state-of-the-art performance at repairing 3D building models.

CAFA: A Checksum-Aware Fuzzing Assistant Tool for Coverage Improvement

Fuzzing is an effective technique to discover vulnerabilities that involves testing applications by constructing invalid input data. However, for applications with checksum mechanism, fuzzing can only achieve low coverage because samples generated by the fuzzer are possibly incapable of passing the checksum verification. To solve this problem, most current fuzzers advise the user to comment out the checksum verification code manually, but it requires considerable time to audit the source code to identify the checksum point corresponding to checksum verification. In this paper, we present a novel approach based on taint analysis to identify the checksum point automatically. To implement this approach, the checksum-aware fuzzing assistant tool (CAFA) is designed. After the checksum point is identified, the application is statically patched in an antilogical manner at the checksum point. The fuzzing tool then tests the patched program to bypass the checksum verification. To evaluate CAFA, we use it to assist the American Fuzzy Lop (AFL) tool in fuzzing eight real-world applications with known input specification. The experimental results show that CAFA can accurately and quickly identify the checksum points and greatly improve the coverage of AFL. With the help of CAFA, multiple buffer overflow vulnerabilities have been discovered in the newest ImageMagick and RAR applications.

Repairing Inconsistent Curve Networks on Non‐parallel Cross‐sections

AbstractIn this work we present the first algorithm for restoring consistency between curve networks on non‐parallel cross‐sections. Our method addresses a critical but overlooked challenge in the reconstruction process from cross‐sections that stems from the fact that cross‐sectional slices are often generated independently of one another, such as in interactive volume segmentation. As a result, the curve networks on two non‐parallel slices may disagree where the slices intersect, which makes these cross‐sections an invalid input for surfacing. We propose a method that takes as input an arbitrary number of non‐parallel slices, each partitioned into two or more labels by a curve network, and outputs a modified set of curve networks on these slices that are guaranteed to be consistent. We formulate the task of restoring consistency while preserving the shape of input curves as a constrained optimization problem, and we propose an effective solution framework. We demonstrate our method on a data‐set of complex multi‐labeled input cross‐sections. Our technique efficiently produces consistent curve networks even in the presence of large errors.

Test case generation for semantic-based user input validation of web applications

Semantic-based user input validation of web applications is important because of the central role these applications play in our daily lives. An example of such a process is in rejecting a four-digit number as an input that represents the age of a web application user. Testing professionals must write test cases that can be used to check if a web application can handle semantically invalid inputs. Most of the current approaches for test case generation for web applications do not consider the semantics of inputs. And for approaches that do consider input semantics, test case generation is done manually. This paper defines a process that can be used to automate and in some cases, semi-automate the generation of test cases to assess semantic-based user input validation of web applications (TCSUIV). To prove the usefulness of the process in this paper, it is applied to case study web page. A prototype tool has been built also to show the applicability of this paper process for test case generation for web application.

Test case generation for semantic-based user input validation of web applications

Semantic-based user input validation of web applications is important because of the central role these applications play in our daily lives. An example of such a process is in rejecting a four-digit number as an input that represents the age of a web application user. Testing professionals must write test cases that can be used to check if a web application can handle semantically invalid inputs. Most of the current approaches for test case generation for web applications do not consider the semantics of inputs. And for approaches that do consider input semantics, test case generation is done manually. This paper defines a process that can be used to automate and in some cases, semi-automate the generation of test cases to assess semantic-based user input validation of web applications (TCSUIV). To prove the usefulness of the process in this paper, it is applied to case study web page. A prototype tool has been built also to show the applicability of this paper process for test case generation for web application.

Introspection for C and its Applications to Library Robustness

Context: In C, low-level errors, such as buffer overflow and use-after-free, are a major problem, as they cause security vulnerabilities and hard-to-find bugs. C lacks automatic checks, and programmers cannot apply defensive programming techniques because objects (e.g., arrays or structs) lack run-time information about bounds, lifetime, and types. Inquiry: Current approaches to tackling low-level errors include dynamic tools, such as bounds or type checkers, that check for certain actions during program execution. If they detect an error, they typically abort execution. Although they track run-time information as part of their runtimes, they do not expose this information to programmers. Approach: We devised an introspection interface that allows C programmers to access run-time information and to query object bounds, object lifetimes, object types, and information about variadic arguments. This enables library writers to check for invalid input or program states and thus, for example, to implement custom error handling that maintains system availability and does not terminate on benign errors. As we assume that introspection is used together with a dynamic tool that implements automatic checks, errors that are not handled in the application logic continue to cause the dynamic tool to abort execution. Knowledge: Using the introspection interface, we implemented a more robust, source-compatible version of the C standard library that validates parameters to its functions. The library functions react to otherwise undefined behavior; for example, they can detect lurking flaws, handle unterminated strings, check format string arguments, and set errno when they detect benign usage errors. Grounding: Existing dynamic tools maintain run-time information that can be used to implement the introspection interface, and we demonstrate its implementation in Safe Sulong, an interpreter and dynamic bug-finding tool for C that runs on a Java Virtual Machine and can thus easily expose relevant run-time information. Importance: Using introspection in user code is a novel approach to tackling the long-standing problem of low-level errors in C. As new approaches are lowering the performance overhead of run-time information maintenance, the usage of dynamic runtimes for C could become more common, which could ultimately facilitate a more widespread implementation of such an introspection interface.

Suite de pruebas para un generador de aplicaciones TVDI usando modelos de características

Un generador de aplicaciones es una herramienta cuya salida es una especificación de código. La prueba de un generador de código implica identificar las entradas válidas e inválidas que producen esas especificaciones de salida. A la vez, cuando los procesos de construcción son incrementales y producen versiones de los productos de software en las distintas etapas, se requieren estrategias de generación de prueba que sistemáticamente puedan ser aplicadas y replicadas para generar los test. Dr Nau es un generador de aplicaciones interactivas para TV Digital, basado en el uso de patrones de diseño de interacción centrados en el usuario, que se construye a partir de incrementos, obteniendo en cada uno de estos, una versión funcional de la herramienta. Este trabajo presenta una suite de pruebas para el primer incremento de Dr Nau, creada a partir de modelos de características y los diferentes patrones de diseño. La suite representa el conjunto de posibles aplicaciones que puede desarrollar Dr Nau en la etapa en que se encuentra. Al ser elaborada por medio de modelos de características, es posible determinar su completitud y exactitud por medio de software automatizado para tal fin, como Fama test suite, que es el que se utilizó en esta oportunidad. Se demuestra así que el trabajo realizado manualmente es efectivo y contempla la totalidad de posibles aplicaciones.

Estimating software robustness in relation to input validation vulnerabilities using Bayesian networks

Estimating the robustness of software in the presence of invalid inputs has long been a challenging task owing to the fact that developers usually fail to take the necessary action to validate inputs during the design and implementation of software. We propose a method for estimating the robustness of software in relation to input validation vulnerabilities using Bayesian networks. The proposed method runs on all program functions and/or methods. It calculates a robustness value using information on the existence of input validation code in the functions and utilizing common weakness scores of known input validation vulnerabilities. In the case study, ten well-known software libraries implemented in the JavaScript language, which are chosen because of their increasing popularity among software developers, are evaluated. Using our method, software development teams can track changes made to software to deal with invalid inputs.

Black-box detection of XQuery injection and parameter tampering vulnerabilities in web applications

As web applications become the most popular way to deliver essential services to customers, they also become attractive targets for attackers. The attackers craft injection attacks in database-driven applications through the user-input fields intended for interacting with the applications. Even though precautionary measures such as user-input sanitization is employed at the client side of the application, the attackers can disable the JavaScript at client side and still inject attacks through HTTP parameters. The injected parameters result in attacks due to improper server-side validation of user input. The injected parameters may either contain malicious SQL/XML commands leading to SQL/XPath/XQuery injection or be invalid input that intend to violate the expected behavior of the web application. The former is known as an injection attack, while the latter is called a parameter tampering attack. While SQL injection has been intensively examined by the research community, limited work has been done so far for identifying XML injection and parameter tampering vulnerabilities. Database-driven web applications today rely on XML databases, as XML has gained rapid acceptance due to the fact that it favors integration of data with other applications and handles diverse information. Hence, this work proposes a black-box fuzzing approach to detect XQuery injection and parameter tampering vulnerabilities in web applications driven by native XML databases. A prototype XiParam is developed and tested on vulnerable applications developed with a native XML database, BaseX, as the backend. The experimental evaluation clearly demonstrates that the prototype is effective against detection of both XQuery injection and parameter tampering vulnerabilities.

A Formal Model of Robustness Testing for an Object-Oriented Specification

The work presented in this paper proposes a formal model of constraints for testing the conformity of an implementation from its specification. The principal idea of our approach is based on an equivalence partitioning of input domains for each method type in an object oriented (OO) paradigm for detecting the different classes of errors. The main contribution of our approach is the use of invalid data which do not satisfy the precondition constraints for testing the robustness of entities in an OO model. Indeed, the first objective of the proposed work is to develop a theoretical model of constraint in order to test the conformity of classes. The second objective of our approach is to detect anomalies in invalid input data which induce valid output constraints. The implementation of this approach is based on a random generation of test data and analysis by formal proof.

Composition of complex numbers: Delineating the computational role of the left anterior temporal lobe

What is the neurobiological basis of our ability to create complex messages with language? Results from multiple methodologies have converged on a set of brain regions as relevant for this general process, but the computational details of these areas remain to be characterized. The left anterior temporal lobe (LATL) has been a consistent node within this network, with results suggesting that although it rather systematically shows increased activation for semantically complex structured stimuli, this effect does not extend to number phrases such as ‘three books.’ In the present work we used magnetoencephalography to investigate whether numbers in general are an invalid input to the combinatory operations housed in the LATL or whether the lack of LATL engagement for stimuli such as ‘three books’ is due to the quantificational nature of such phrases. As a relevant test case, we employed complex number terms such as ‘twenty-three’, where one number term is not a quantifier of the other but rather, the two terms form a type of complex concept. In a number naming paradigm, participants viewed rows of numbers and depending on task instruction, named them as complex number terms (‘twenty-three’), numerical quantifications (‘two threes’), adjectival modifications (‘blue threes’) or non-combinatory lists (e.g., ‘two, three’). While quantificational phrases failed to engage the LATL as compared to non-combinatory controls, both complex number terms and adjectival modifications elicited a reliable activity increase in the LATL. Our results show that while the LATL does not participate in the enumeration of tokens within a set, exemplified by the quantificational phrases, it does support conceptual combination, including the composition of complex number concepts.

안드로이드 기반 문서 어플리케이션의 퍼징 방법론 연구

ABSTRACT As the forms of cyberattacks become diverse, there has been rep orted another case of exploiting vulnerabilities revealed while processing either a document or multimedia file that was distri buted for attacking purpose, which would replace the traditiona l method of distributing malwares directly. The attack is based upon the observation that the softwares such as document editer or multimedia player may reveal inherent vulnerabilities on som e specific inputs. The fuzzing methods that provide invalid random inputs for test purpose could discover such exploits.This paper suggests a new fuzzing method on document applicatio ns that could work in mobile environments, in order to resolve the drawback that the existing methods run only in PC e nvironments. Our methods could effectively discover the exploit s of mobile applications, and thus could be utilized as a means o f dealing with APT attacks in mobile environments.Keywords: SmartPhone, Android, Fuzzing, Document, Vulnerability

Analysis of Security Protocols using Finite-State Machines

This paper demonstrates a comprehensive analysis method using formal methods such as finite-state machine. First, we describe the modified version of our new protocol and briefly explain the encrypt-then-authenticate mechanism, which is regarded as more a secure mechanism than the one used in our protocol. Then, we use a finite-state verification to study the behaviour of each machine created for each phase of the protocol and examine their behaviours together. Modelling with finite-state machines shows that the modified protocol can function correctly and behave properly even with invalid input or time delay.

Generating semantically valid test inputs using constrained input grammars

ContextGenerating test cases based on software input interface is a black-box testing technique that can be made more effective by using structured input models such as input grammars. Automatically generating grammar-based test inputs may lead to structurally valid but semantically invalid inputs that may be rejected in early semantic error checking phases of a system under test. ObjectiveThis paper aims to introduce a method for specifying a grammar-based input model with the model’s semantic constraints to be used in the generation of positive test inputs. It is also important that the method can generate effective test suites based on appropriate grammar-based coverage criteria. MethodFormal specification of both input structure and input semantics provides the opportunity to use model instantiation techniques to create model instances that satisfy all specified constraints. The input interface of a subject system can be specified using a high-level specification scheme such as attribute grammars, and a transformation function from this scheme to an instantiable formal modeling language can generate the desired model instances. ResultsWe propose a declarative grammar-based input specification method that is based on a variation of attribute grammars and allows the user to specify input constraints in addition to input structure. The model can be instantiated automatically to generate structurally and semantically valid test inputs. The proposed method has the capability to specify test requirements and coverage criteria and use them to generate valid test suites that satisfy test coverage criteria requirements. ConclusionThe work presented in this paper provides a black-box test generation method for grammar-based software inputs that can automatically generate criteria-covering test suites.

Novel Modified Playfair Cipher using a SquareMatrix

This paper is about encryption and decryption of text using a secret password provided by the user. The encryption machine takes the password and source message as input and generates acipher text based on Modified Playfair Algorithm using dynamic rectangular matrix. The decryption machine takes the same password and the cipher text generated by the encryption engine as input to produce the original message. It also checks if the input is valid and blocks the user when an invalid input is provided. In this paper the entire program will be simulated by using an PHP application.