All Classes and Interfaces
Class
Description
A utility for validating the shape of ASTs and filtering them to retrieve.
A type for querying and filtering expression statements.
A type for querying and filtering name expressions.
A type for querying and filtering a single variable declaration.
A type for querying and filtering method call expressions.
A type for querying and filtering name expressions.
A type for querying and filtering generic AST nodes.
A type for querying and filtering string literals.
A type for querying and filtering variable declaration(s).
A static library for querying and returning patterns over AST nodes.
A
Node iterator iterating over all the nodes that precedes a given node in the
pre-order of its AST.Builder for
CallReplacer.Represents the result of changes made during parsing.
The base of a codemod type.
Holds a code directory (e.g., a repository root).
Used to mark types providing codemod functionality and provide the necessary metadata.
Represents a change made to the code.
A description of how important it is that a codemod execute in the list of codemods being run.
A type responsible for executing a codemod on a set of files.
Represents the result of scanning a file for changes.
A codemod and its ID.
The context we provide to each codemod.
This type is responsible for loading codemods and the surrounding subsystem.
A
Describes a codemod parameter.
A type that helps provide functionality codemods.
A type that is relied on to inform our in-flight analysis on whether codemods are allowed.
A type responsible for reporting codemod changes.
A utility class for accessing a codemod's resources in it's "default location" the classpath.
Type responsible for running a codemod on a single file, performing the analysis and file
changes.
A type that plugins can implement to enrich or modify CodeTF results.
A type that allows composing multiple
JavaParserChanger instances are under the same
umbrella.During analysis, this will be the default setting for every rule.
A type that describes a new dependency being added to a project.
Models a Java dependency we might want to add.
The license, if known, of a dependency.
Represents the result of a dependency update operation.
An implementation of the Either monad.
Detects the encoding of a file.
Holds the nodes in the AST that represents a local variable declaration statement.
A cache for file contents.
The potential fix location.
Searches for potential fix locations in the source code.
Builder for
FixCandidateSearcher.The results of a fix candidate search.
A codemod that only fixes issues and does not perform its own detection, instead relying on
external analysis from other tools.
Holds the nodes in the AST that represents a variable declaration in an enhanced for statement .
Holds the nodes in the AST that represents a variable declaration in a for statement init
expression.
Reporter strategies that are useful without mentioning specific APIs.
Remediates header injection vulnerabilities.
Remediates HQL injection vulnerabilities.
Represents the importance of a codemod.
This is the main interaction point with types for detecting if a path should be included.
Matches every file, indicates that the codemods should use their own filtering.
Holds includes and excludes patterns for files
An includes/excludes pattern that matches any files.
An includes/excludes pattern that matches java files.
Remediates Java deserialization vulnerabilities.
Exception that indicates a failure to parse a Java file.
Uses JavaParser to change Java source files.
Responsible for parsing Java files and maintaining the compilation units across different
accesses.
Responsible for generating
JavaParser instances.Strategy interface for remediating SQL injection vulnerabilities using JavaParser.
A utility for making it easy to transform JavaParser ASTs.
Remediates JNDI injection vulnerabilities.
Represents a line of code.
Linearizes a string expression
For a given file, this type provides an API for callers to understand if certain line numbers are
allowed.
Given a set of lines to exclude, determine if we should allow changes to this line.
Given a set of lines to include, determine if we should allow changes to this line.
Utilities related to line numbers.
A local declaration.
Contains the expressions and statements that span the scope of a local declaration.
Holds the nodes in the AST that represents several types of local declaration of a variable.
A configurator for the log levels that defaults to "quiet" mode.
Convenience type to represent a method or constructor call in our APIs that work with both.
Strategy interface for remediating missing secure flag vulnerabilities.
A type that can collect specific types of nodes from a
CompilationUnit.A parameter for a codemod, capable of retrieving the right value for a given path and line.
Represents the declaration of a parameter in a method, constructor, lambda expression, and catch
clause.
This type is used in include/exclude logic for matching paths.
Represents a position in a source file.
A type that plugins can implement to provide a project management functions to codemods.
This class is temporarily public -- it should ideally be hidden behind a package-private
implementor in
io.codemodder.remediation.sqlinjection that abstracts away all logic about
remediating Hibernate injections.Gives access to raw files for performing arbitrary changes.
Remediates reflection injection vulnerabilities.
This type does the heavy lifting for many protections that can work in a simple
"search-and-replace" pattern for non-Java code.
A type that can match a
Region to a Range for determining if we should change the
node at this location.Holds common messages for remediation intended for human consumption as a part of CodeTF
reporting
Represents a codemod author's confidence that changes wll be safe and effective.
Defines a model for interacting with SARIF.
An empty implementation of
RuleSarif for binding codemods with no SARIF results.Builds
RuleSarifs.Provides an entrypoint for CLIs built with the codemodder framework.
Utility class for working with SARIF model objects.
Utility class for building keys for SARIF findings.
SarifPluginJavaParserChanger<T extends com.github.javaparser.ast.Node>
Provides base functionality for making JavaParser-based changes based on results found by a sarif
file.
A
RawFileChanger bundled with a RuleSarif.Describes a region of source code.
A type responsible for extracting a region from a result
Represent a normally-structured Java source code directory and all its files underneath it.
Represents a worker class that reads a list of repository roots and captures the Java source
directories.
Composes several transformations related to SQL injections.
Contains most of the logic for detecting and fixing parameterizable SQL statements for a given
MethodCallExpr.Wrap table name parameters in SQL queries with an alphanumeric blacklist filter.
Holds the nodes in the AST that represents a variable declaration as a try resource.
Type that gets used to modify an XML stream.
A handler for
XMLEvents that match an XPath expression.Represents the results when an XML file is transformed using
XPathStreamProcessor.Performs configurable actions on nodes that match XPath expressions.
Remediates header injection vulnerabilities.
Strategy for remediating XXE vulnerabilities at an intermediate step in
XMLInputFactory.createXMLStreamReader(java.io.Reader).Strategy for remediating XXE vulnerabilities at the sink for multiple parser APIs.