DefaultValidator (ESAPI 2.5.3.1 API)

java.lang.Object
- org.owasp.esapi.reference.DefaultValidator

All Implemented Interfaces:

Validator
```
public class DefaultValidator
extends Object
implements Validator
```
Reference implementation of the Validator interface. This implementation relies on the ESAPI Encoder, Pattern, Date, and several other classes to provide basic validation functions. This library has a heavy emphasis on allow-list validation and canonicalization.
A Note about Canonicalization: The behaviors of objects of this class are largely driven by how the associated Encoder is created and passed to one of this class' constructors. Specifically, what Codec types are referenced by the Encoder instance associated with this particular DefaultValidator instance. In places where the default Encoder instance is used, the behavior is driven by three ESAPI properties as defined in the ESAPI.properties file. These property names and their default values (as delivered in ESAPI's "configuration" jar) are as follows:
```
 Encoder.AllowMultipleEncoding=false
 Encoder.AllowMixedEncoding=false
 Encoder.DefaultCodecList=HTMLEntityCodec,PercentCodec,JavaScriptCodec
 
```
In places where canonicalization is checked, multiple encoding (the first property, which refers to encoding in the same manner more than once) or mixed encoding (the second property, which refers to encoding using multiple different encoding mechanisms) are generally considered attacks unless these respective property values are set to "true".
Note that changing any of these three properties may affect the behavior as documented in this class' methods.
Since:

June 1, 2007

Author:

Jeff Williams (jeff.williams .at. aspectsecurity.com) Aspect Security, Jim Manico ([email protected]) Manico.net, Matt Seil (mseil .at. acm.org)

See Also:

Validator, Encoder, Encoder.canonicalize(String,boolean,boolean)

Constructor Summary

Constructors
Constructor and Description
`DefaultValidator()` Default constructor uses the ESAPI standard encoder for canonicalization.
`DefaultValidator(Encoder encoder)` Construct a new DefaultValidator that will use the specified `Encoder` for canonicalization.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addRule(ValidationRule rule)` Add a validation rule to the registry using the "type name" of the rule as the key.
`void`	`assertValidFileUpload(String context, String directorypath, String filename, File parent, byte[] content, int maxBytes, List<String> allowedExtensions, boolean allowNull)` Validates the `filepath`, `filename`, and `content` of a file.
`void`	`assertValidFileUpload(String context, String filepath, String filename, File parent, byte[] content, int maxBytes, List<String> allowedExtensions, boolean allowNull, ValidationErrorList errors)` Validates the `filepath`, `filename`, and `content` of a file, any validation exceptions are added to the supplied `errorList`.
`void`	`assertValidHTTPRequestParameterSet(String context, javax.servlet.http.HttpServletRequest request, Set<String> required, Set<String> optional)` Validates that the parameters in the current request contain all required parameters and only optional ones in addition.
`void`	`assertValidHTTPRequestParameterSet(String context, javax.servlet.http.HttpServletRequest request, Set<String> required, Set<String> optional, ValidationErrorList errors)` Validates that the parameters in the current request contain all required parameters and only optional ones in addition, any validation exceptions are added to the supplied `errorList`.
`static Validator`	`getInstance()`
`URI`	`getRfcCompliantURI(String input)` Will return a `URI` object that will represent a fully parsed and legal URI as specified in RFC-3986.
`ValidationRule`	`getRule(String name)` Get a validation rule from the registry with the "type name" of the rule as the key.
`String`	`getValidCreditCard(String context, String input, boolean allowNull)` Returns a canonicalized and validated credit card number as a String.
`String`	`getValidCreditCard(String context, String input, boolean allowNull, ValidationErrorList errors)` Returns a canonicalized and validated credit card number as a String, any validation exceptions are added to the supplied `errorList`.
`Date`	`getValidDate(String context, String input, DateFormat format, boolean allowNull)` Returns a valid date as a `Date`.
`Date`	`getValidDate(String context, String input, DateFormat format, boolean allowNull, ValidationErrorList errors)` Returns a valid date as a `Date`, any validation exceptions are added to the supplied `errorList`.
`String`	`getValidDirectoryPath(String context, String input, File parent, boolean allowNull)` Returns a canonicalized and validated directory path as a String, provided that the input maps to an existing directory that is an existing subdirectory (at any level) of the specified parent.
`String`	`getValidDirectoryPath(String context, String input, File parent, boolean allowNull, ValidationErrorList errors)` Returns a canonicalized and validated directory path as a String, provided that the input maps to an existing directory that is an existing subdirectory (at any level) of the specified parent; any validation exceptions are added to the supplied `errorList`.
`Double`	`getValidDouble(String context, String input, double minValue, double maxValue, boolean allowNull)` Returns a validated real number as a double.
`Double`	`getValidDouble(String context, String input, double minValue, double maxValue, boolean allowNull, ValidationErrorList errors)` Returns a validated real number as a double, any validation exceptions are added to the supplied `errorList`.
`byte[]`	`getValidFileContent(String context, byte[] input, int maxBytes, boolean allowNull)` Returns validated file content as a byte array.
`byte[]`	`getValidFileContent(String context, byte[] input, int maxBytes, boolean allowNull, ValidationErrorList errors)` Returns validated file content as a byte array, any validation exceptions are added to the supplied `errorList`.
`String`	`getValidFileName(String context, String input, List<String> allowedExtensions, boolean allowNull)` Returns a canonicalized and validated file name as a String.
`String`	`getValidFileName(String context, String input, List<String> allowedParameters, boolean allowNull, ValidationErrorList errors)` Returns a canonicalized and validated file name as a String, any validation exceptions are added to the supplied `errorList`.
`String`	`getValidInput(String context, String input, String type, int maxLength, boolean allowNull)` Returns the validated, canonicalized `input` as a String.
`String`	`getValidInput(String context, String input, String type, int maxLength, boolean allowNull, boolean canonicalize)` Returns validated `input` as a String with optional canonicalization.
`String`	`getValidInput(String context, String input, String type, int maxLength, boolean allowNull, boolean canonicalize, ValidationErrorList errors)` Returns validated `input` as a String with optional canonicalization, and adds validation exceptions to the supplied `errorList`.
`String`	`getValidInput(String context, String input, String type, int maxLength, boolean allowNull, ValidationErrorList errors)` Returns canonicalized validated `input` as a String, and adds validation exceptions to the supplied `errorList`.
`Integer`	`getValidInteger(String context, String input, int minValue, int maxValue, boolean allowNull)` Returns a validated integer, `input` is a valid integer if it is between `minValue` and `maxValue` inclusive.
`Integer`	`getValidInteger(String context, String input, int minValue, int maxValue, boolean allowNull, ValidationErrorList errors)` Returns a validated integer, any validation exceptions are added to the supplied `errorList`.
`String`	`getValidListItem(String context, String input, List<String> list)` Returns the list item that exactly matches the canonicalized input.
`String`	`getValidListItem(String context, String input, List<String> list, ValidationErrorList errors)` Returns the list item that exactly matches the canonicalized input, any validation exceptions are added to the supplied `errorList`.
`Double`	`getValidNumber(String context, String input, long minValue, long maxValue, boolean allowNull)` Returns a validated number as a double within the range of minValue to maxValue.
`Double`	`getValidNumber(String context, String input, long minValue, long maxValue, boolean allowNull, ValidationErrorList errors)` Returns a validated number as a double within the range of [`minValue`, `maxValue`]; any validation exceptions are added to the supplied `errorList`.
`char[]`	`getValidPrintable(String context, char[] input, int maxLength, boolean allowNull)` Returns canonicalized and validated printable characters as a byte array.
`char[]`	`getValidPrintable(String context, char[] input, int maxLength, boolean allowNull, ValidationErrorList errors)` Returns canonicalized and validated printable characters as a byte array, any validation exceptions are added to the supplied `errorList`.
`String`	`getValidPrintable(String context, String input, int maxLength, boolean allowNull)` Returns canonicalized and validated printable characters as a String.
`String`	`getValidPrintable(String context, String input, int maxLength, boolean allowNull, ValidationErrorList errors)` Returns canonicalized and validated printable characters as a String, any validation exceptions are added to the supplied `errorList`.
`String`	`getValidRedirectLocation(String context, String input, boolean allowNull)` Returns a canonicalized and validated redirect location as a String.
`String`	`getValidRedirectLocation(String context, String input, boolean allowNull, ValidationErrorList errors)` Returns a canonicalized and validated redirect location as a String, any validation exceptions are added to the supplied `errorList`.
`String`	`getValidSafeHTML(String context, String input, int maxLength, boolean allowNull)` Canonicalize and then sanitize the input so that it is "safe" for renderinger in an HTML context (i.e., that it does not contain unwanted scripts in the body, attributes, CSS, URLs, or anywhere else).
`String`	`getValidSafeHTML(String context, String input, int maxLength, boolean allowNull, ValidationErrorList errors)` Canonicalize and then sanitize the input so that it is "safe" for renderinger in an HTML context (i.e., that it does not contain unwanted scripts in the body, attributes, CSS, URLs, or anywhere else).
`boolean`	`isValidCreditCard(String context, String input, boolean allowNull)` Returns true if `input` matches the pattern for a valid credit card number.
`boolean`	`isValidCreditCard(String context, String input, boolean allowNull, ValidationErrorList errors)` Returns true if `input` matches the pattern for a valid credit card number, any validation exceptions are added to the supplied `errorList`.
`boolean`	`isValidDate(String context, String input, DateFormat format, boolean allowNull)` Returns true if `input` is valid.
`boolean`	`isValidDate(String context, String input, DateFormat format, boolean allowNull, ValidationErrorList errors)` Returns true if `input` is valid, any validation exceptions are added to the supplied `errorList`.
`boolean`	`isValidDirectoryPath(String context, String input, File parent, boolean allowNull)` Returns true if `input` is valid.
`boolean`	`isValidDirectoryPath(String context, String input, File parent, boolean allowNull, ValidationErrorList errors)` Returns true if `input` is valid, any validation exceptions are added to the supplied `errorList`.
`boolean`	`isValidDouble(String context, String input, double minValue, double maxValue, boolean allowNull)` Returns true if `input` is valid.
`boolean`	`isValidDouble(String context, String input, double minValue, double maxValue, boolean allowNull, ValidationErrorList errors)` Returns true if `input` is valid, any validation exceptions are added to the supplied `errorList`.
`boolean`	`isValidFileContent(String context, byte[] input, int maxBytes, boolean allowNull)` Returns true if `input` is valid.
`boolean`	`isValidFileContent(String context, byte[] input, int maxBytes, boolean allowNull, ValidationErrorList errors)` Returns true if `input` is valid, any validation exceptions are added to the supplied `errorList`.
`boolean`	`isValidFileName(String context, String input, boolean allowNull)` Returns true if `input` is valid.
`boolean`	`isValidFileName(String context, String input, boolean allowNull, ValidationErrorList errors)` Returns true if `input` is valid, any validation exceptions are added to the supplied `errorList`.
`boolean`	`isValidFileName(String context, String input, List<String> allowedExtensions, boolean allowNull)` Returns true if `input` is valid.
`boolean`	`isValidFileName(String context, String input, List<String> allowedExtensions, boolean allowNull, ValidationErrorList errors)` Returns true if `input` is valid, any validation exceptions are added to the supplied `errorList`.
`boolean`	`isValidFileUpload(String context, String directorypath, String filename, File parent, byte[] content, int maxBytes, boolean allowNull)` Returns true if `filepath`, `filename`, and `content` of a file are valid.
`boolean`	`isValidFileUpload(String context, String directorypath, String filename, File parent, byte[] content, int maxBytes, boolean allowNull, ValidationErrorList errors)` Returns true if `filepath`, `filename`, and `content` of a file are valid, any validation exceptions are added to the supplied `errorList`.
`boolean`	`isValidHTTPRequestParameterSet(String context, javax.servlet.http.HttpServletRequest request, Set<String> requiredNames, Set<String> optionalNames)` Returns true if only required and optional parameters are in the request.
`boolean`	`isValidHTTPRequestParameterSet(String context, javax.servlet.http.HttpServletRequest request, Set<String> requiredNames, Set<String> optionalNames, ValidationErrorList errors)` Returns true if only required and optional parameters are in the request, any validation exceptions are added to the supplied `errorList`.
`boolean`	`isValidInput(String context, String input, String type, int maxLength, boolean allowNull)` Returns true if canonicalized input is valid.
`boolean`	`isValidInput(String context, String input, String type, int maxLength, boolean allowNull, boolean canonicalize)` Returns true if `input` is valid.
`boolean`	`isValidInput(String context, String input, String type, int maxLength, boolean allowNull, boolean canonicalize, ValidationErrorList errors)` Returns true if `input` is valid; any validation exceptions are added to the supplied `errorList`.
`boolean`	`isValidInput(String context, String input, String type, int maxLength, boolean allowNull, ValidationErrorList errors)` Returns true if canonicalized input is valid, any validation exceptions are added to the supplied `errorList`.
`boolean`	`isValidInteger(String context, String input, int minValue, int maxValue, boolean allowNull)` Returns true if `input` is a valid integer between `minValue` and `maxValue` inclusive.
`boolean`	`isValidInteger(String context, String input, int minValue, int maxValue, boolean allowNull, ValidationErrorList errors)` Returns true if `input` is a valid integer between `minValue` and `maxValue` inclusive, any validation exceptions are added to the supplied `errorList`.
`boolean`	`isValidListItem(String context, String input, List<String> list)` Returns true if `input` is valid.
`boolean`	`isValidListItem(String context, String input, List<String> list, ValidationErrorList errors)` Returns true if `input` is valid, any validation exceptions are added to the supplied `errorList`.
`boolean`	`isValidNumber(String context, String input, long minValue, long maxValue, boolean allowNull)` Returns true if `input` is valid.
`boolean`	`isValidNumber(String context, String input, long minValue, long maxValue, boolean allowNull, ValidationErrorList errors)` Returns true if `input` is valid, any validation exceptions are added to the supplied `errorList`.
`boolean`	`isValidPrintable(String context, char[] input, int maxLength, boolean allowNull)` Returns true if `input` is valid.
`boolean`	`isValidPrintable(String context, char[] input, int maxLength, boolean allowNull, ValidationErrorList errors)` Returns true if `input` is valid, any validation exceptions are added to the supplied `errorList`.
`boolean`	`isValidPrintable(String context, String input, int maxLength, boolean allowNull)` Returns true if `input` is valid.
`boolean`	`isValidPrintable(String context, String input, int maxLength, boolean allowNull, ValidationErrorList errors)` Returns true if `input` is valid, any validation exceptions are added to the supplied `errorList`.
`boolean`	`isValidRedirectLocation(String context, String input, boolean allowNull)` Returns true if `input` is valid.
`boolean`	`isValidRedirectLocation(String context, String input, boolean allowNull, ValidationErrorList errors)` Returns true if `input` is valid, any validation exceptions are added to the supplied `errorList`.
`boolean`	`isValidSafeHTML(String context, String input, int maxLength, boolean allowNull)` Returns `true` if the parameter `input` is valid and presumably safe.
`boolean`	`isValidSafeHTML(String context, String input, int maxLength, boolean allowNull, ValidationErrorList errors)` Returns `true` if the parameter `input` is valid and presumably safe.
`boolean`	`isValidURI(String context, String input, boolean allowNull)` Parses and ensures that the URI in question is a valid RFC-3986 URI.
`String`	`safeReadLine(InputStream in, int max)` Reads from an input stream until end-of-line or a maximum number of characters.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - DefaultValidator
```
public DefaultValidator()
```
    Default constructor uses the ESAPI standard encoder for canonicalization. This uses an Encoder created based on the Codecs specified by the value of the Encoder.DefaultCodecList ESAPI property as defined in your ESAPI.properties file.
  - DefaultValidator
```
public DefaultValidator(Encoder encoder)
```
    Construct a new DefaultValidator that will use the specified Encoder for canonicalization.
    
    Parameters:
    
    encoder - The specially constructed ESAPI Encoder instance that uses a custom list of Codecs for canonicalization purposes. See Encoder.canonicalize(String,boolean,boolean) for an example of how to create a custom Encoder.
- Method Detail
  - getInstance
```
public static Validator getInstance()
```
  - addRule
```
public void addRule(ValidationRule rule)
```
    Add a validation rule to the registry using the "type name" of the rule as the key.
    
    Specified by:
    
    addRule in interface Validator
    
    Parameters:
    
    rule - The ValidationRule to add.
  - getRule
```
public ValidationRule getRule(String name)
```
    Get a validation rule from the registry with the "type name" of the rule as the key.
    
    Specified by:
    
    getRule in interface Validator
    
    Parameters:
    
    name - The "type" name of a ValidationRule to retrieve.
  - isValidInput
```
public boolean isValidInput(String context,
                            String input,
                            String type,
                            int maxLength,
                            boolean allowNull)
                     throws IntrusionException
```
    Returns true if canonicalized input is valid.
    Calls Validator.getValidInput(String, String, String, int, boolean, boolean) with canonicalize=true and returns true if no exceptions are thrown.
    Double encoding is treated as an attack. The canonicalization behavior is controlled by the instance's associated ESAPI Encoder and generally driven through the ESAPI property Encoder.DefaultCodecList specified in the ESAPI.properties file. See the class level documentation section "A Note about Canonicalization" for additional details.
    
    Specified by:
    
    isValidInput in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., "LoginPage_UsernameField"). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - The actual user input data to validate.
    
    type - The regular expression name which maps to the actual regular expression from "ESAPI.properties".
    
    maxLength - The maximum String length allowed for input.
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - isValidInput
```
public boolean isValidInput(String context,
                            String input,
                            String type,
                            int maxLength,
                            boolean allowNull,
                            ValidationErrorList errors)
```
    Returns true if canonicalized input is valid, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidInput(String, String, String, int, boolean, boolean) with canonicalize=true and returns true if no exceptions are thrown.
    Double encoding is treated as an attack. The canonicalization behavior is controlled by the instance's associated ESAPI Encoder and generally driven through the ESAPI property Encoder.DefaultCodecList specified in the ESAPI.properties file. See the class level documentation section "A Note about Canonicalization" for additional details.
    
    Specified by:
    
    isValidInput in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., "LoginPage_UsernameField"). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - The actual user input data to validate.
    
    type - The regular expression name which maps to the actual regular expression from "ESAPI.properties".
    
    maxLength - The maximum String length allowed for input.
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    errors - The error list to which any ValidationException messages are added.
  - isValidInput
```
public boolean isValidInput(String context,
                            String input,
                            String type,
                            int maxLength,
                            boolean allowNull,
                            boolean canonicalize)
```
    Returns true if input is valid.
    Calls Validator.getValidInput(String, String, String, int, boolean, boolean) and returns true if no exceptions are thrown.
    Double encoding is treated as an attack. The canonicalization behavior is controlled by the instance's associated ESAPI Encoder and generally driven through the ESAPI property Encoder.DefaultCodecList specified in the ESAPI.properties file. See the class level documentation section "A Note about Canonicalization" for additional details.
    This implementation does not throw IntrusionException.
    
    Specified by:
    
    isValidInput in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., "LoginPage_UsernameField"). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - The actual user input data to validate.
    
    type - The regular expression name which maps to the actual regular expression from "ESAPI.properties".
    
    maxLength - The maximum String length allowed for input.
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    canonicalize - If true, the input if first canonicalized before being validated.
  - isValidInput
```
public boolean isValidInput(String context,
                            String input,
                            String type,
                            int maxLength,
                            boolean allowNull,
                            boolean canonicalize,
                            ValidationErrorList errors)
                     throws IntrusionException
```
    Returns true if input is valid; any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidInput(String, String, String, int, boolean, boolean) and returns true if no exceptions are thrown.
    Double encoding is treated as an attack. The canonicalization behavior is controlled by the instance's associated ESAPI Encoder and generally driven through the ESAPI property Encoder.DefaultCodecList specified in the ESAPI.properties file. See the class level documentation section "A Note about Canonicalization" for additional details.
    
    Specified by:
    
    isValidInput in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., "LoginPage_UsernameField"). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - The actual user input data to validate.
    
    type - The regular expression name which maps to the actual regular expression from "ESAPI.properties".
    
    maxLength - The maximum String length allowed for input.
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    canonicalize - If true, the input if first canonicalized before being validated.
    
    errors - The error list to which any ValidationException messages are added.
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - getValidInput
```
public String getValidInput(String context,
                            String input,
                            String type,
                            int maxLength,
                            boolean allowNull)
                     throws ValidationException
```
    Returns the validated, canonicalized input as a String.
    Calls Validator.getValidInput(String, String, String, int, boolean, boolean) with canonicalize=true.
    Double encoding is treated as an attack. The canonicalization behavior is controlled by the instance's associated ESAPI Encoder and generally driven through the ESAPI property Encoder.DefaultCodecList specified in the ESAPI.properties file. See the class level documentation section "A Note about Canonicalization" for additional details.
    
    Specified by:
    
    getValidInput in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., "LoginPage_UsernameField"). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - The actual user input data to validate.
    
    type - The regular expression name which maps to the actual regular expression from "ESAPI.properties".
    
    maxLength - The maximum String length allowed for input.
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    Throws:
    
    ValidationException - Input is invalid, based on the regex associated with type.
  - getValidInput
```
public String getValidInput(String context,
                            String input,
                            String type,
                            int maxLength,
                            boolean allowNull,
                            boolean canonicalize)
                     throws ValidationException
```
    Returns validated input as a String with optional canonicalization.
    Invalid input will generate a descriptive ValidationException, and input that is clearly an attack will generate a descriptive IntrusionException.
    Double encoding is treated as an attack. The canonicalization behavior is controlled by the instance's associated ESAPI Encoder and generally driven through the ESAPI property Encoder.DefaultCodecList specified in the ESAPI.properties file. See the class level documentation section "A Note about Canonicalization" for additional details.
    
    Specified by:
    
    getValidInput in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., LoginPage_UsernameField). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - The actual user input data to validate.
    
    type - The regular expression name which maps to the actual regular expression from "ESAPI.properties".
    
    maxLength - The maximum post-canonicalized String length allowed.
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    canonicalize - If canonicalize is true then input will be canonicalized before validation.
    
    Returns:
    
    The canonicalized user input.
    
    Throws:
    
    ValidationException - Input is invalid, based on the regex associated with type.
  - getValidInput
```
public String getValidInput(String context,
                            String input,
                            String type,
                            int maxLength,
                            boolean allowNull,
                            ValidationErrorList errors)
                     throws IntrusionException
```
    Returns canonicalized validated input as a String, and adds validation exceptions to the supplied errorList.
    Calls Validator.getValidInput(String, String, String, int, boolean, boolean).
    Double encoding is treated as an attack. The canonicalization behavior is controlled by the instance's associated ESAPI Encoder and generally driven through the ESAPI property Encoder.DefaultCodecList specified in the ESAPI.properties file. See the class level documentation section "A Note about Canonicalization" for additional details.
    
    Specified by:
    
    getValidInput in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - getValidInput
```
public String getValidInput(String context,
                            String input,
                            String type,
                            int maxLength,
                            boolean allowNull,
                            boolean canonicalize,
                            ValidationErrorList errors)
                     throws IntrusionException
```
    Returns validated input as a String with optional canonicalization, and adds validation exceptions to the supplied errorList.
    Returns the result of calling Validator.getValidInput(String, String, String, int, boolean, boolean) with canonicalize=true.
    Double encoding is treated as an attack. The canonicalization behavior is controlled by the instance's associated ESAPI Encoder and generally driven through the ESAPI property Encoder.DefaultCodecList specified in the ESAPI.properties file. See the class level documentation section "A Note about Canonicalization" for additional details.
    
    Specified by:
    
    getValidInput in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - isValidDate
```
public boolean isValidDate(String context,
                           String input,
                           DateFormat format,
                           boolean allowNull)
```
    Returns true if input is valid.
    Calls Validator.getValidDate(String, String, DateFormat, boolean), and returns true if no exceptions are thrown.
    This implementation does not throw IntrusionException.
    
    Specified by:
    
    isValidDate in interface Validator
  - isValidDate
```
public boolean isValidDate(String context,
                           String input,
                           DateFormat format,
                           boolean allowNull,
                           ValidationErrorList errors)
                    throws IntrusionException
```
    Returns true if input is valid, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidDate(String, String, DateFormat, boolean) and returns true if no exceptions are thrown.
    
    Specified by:
    
    isValidDate in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - getValidDate
```
public Date getValidDate(String context,
                         String input,
                         DateFormat format,
                         boolean allowNull)
                  throws ValidationException,
                         IntrusionException
```
    Returns a valid date as a Date.
    Invalid input will generate a descriptive ValidationException, and input that is clearly an attack will generate a descriptive IntrusionException.
    
    Specified by:
    
    getValidDate in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., LoginPage_UsernameField). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - The actual user input data to validate.
    
    format - Required formatting of date inputted.
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    Returns:
    
    A valid date as a Date
    
    Throws:
    
    ValidationException - Input is invalid, based on the regex associated with type.
    
    IntrusionException - Input likely indicates an attack.
  - getValidDate
```
public Date getValidDate(String context,
                         String input,
                         DateFormat format,
                         boolean allowNull,
                         ValidationErrorList errors)
                  throws IntrusionException
```
    Returns a valid date as a Date, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidDate(String, String, DateFormat, boolean).
    
    Specified by:
    
    getValidDate in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - isValidSafeHTML
```
public boolean isValidSafeHTML(String context,
                               String input,
                               int maxLength,
                               boolean allowNull)
```
    Returns true if the parameter input is valid and presumably safe.
    WARNING: Note that the only safe way to use this method is if you instead of using the passed-in parameter 'input' (which should not be completely trusted as-is, regardless of whether this method returns true), you first sanitize (i.e., cleanse) the parameter 'input' by first by calling one of the getValidSafeHTML methods on it. For additional details explaining the rationale for this, please see the referenced ESAPI Security Bulletin 12 in the referenced GitHub Security Advisory mentioned in the "See Also" section below.
    This implementation does not throw IntrusionException.
    
    Specified by:
    
    isValidSafeHTML in interface Validator
    
    Parameters:
    
    context - A descriptive tag name for the input that you are validating (e.g., user_comment). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - The actual user input data to validate. Note that the expectation is that this input is allowed to contain "safe" HTML markup, otherwise you should not be using this Validator method at all.
    
    maxLength - The maximum String length allowed for input.
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    Returns:
    
    True if the input is presumably safe, otherwise false.
    
    See Also:
    
    GitHub Security Advisory: Validator.isValidSafeHTML is being deprecated and will be deleted in 1 year
  - isValidSafeHTML
```
public boolean isValidSafeHTML(String context,
                               String input,
                               int maxLength,
                               boolean allowNull,
                               ValidationErrorList errors)
                        throws IntrusionException
```
    Returns true if the parameter input is valid and presumably safe. Any exceptions are added to the supplied errorList parameter.
    
    Calls Validator.getValidSafeHTML(String, String, int, boolean), and returns true if no exceptions are thrown.
    WARNING: Note that the only safe way to use this method is if you instead of using the passed-in parameter 'input' (which should not be completely trusted as-is, regardless of whether this method returns true), you first sanitize (i.e., cleanse) the parameter 'input' by first by calling one of the getValidSafeHTML methods on it. For additional details explaining the rationale for this, please see the referenced ESAPI Security Bulletin 12 in the referenced GitHub Security Advisory mentioned in the "See Also" section below.
    
    Specified by:
    
    isValidSafeHTML in interface Validator
    
    Parameters:
    
    context - A descriptive tag name for the input that you are validating (e.g., user_comment). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - The actual user input data to validate. Note that the expectation is that this input is allowed to contain "safe" HTML markup, otherwise you should not be using this Validator method at all.
    
    maxLength - The maximum String length allowed for input.
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    errors - The error list to which any ValidationException messages are added.
    
    Returns:
    
    True if the input is presumably safe, otherwise false.
    
    Throws:
    
    IntrusionException - The parameter input likely indicates an attack.
    
    See Also:
    
    GitHub Security Advisory: Validator.isValidSafeHTML is being deprecated and will be deleted in 1 year
  - getValidSafeHTML
```
public String getValidSafeHTML(String context,
                               String input,
                               int maxLength,
                               boolean allowNull)
                        throws ValidationException,
                               IntrusionException
```
    Canonicalize and then sanitize the input so that it is "safe" for renderinger in an HTML context (i.e., that it does not contain unwanted scripts in the body, attributes, CSS, URLs, or anywhere else). Note that the resulting returned value may omit input that is considered dangerous and cannot be safely sanitized and other input that gets HTML encoded (e.g., a single quote (') might get chaged to """).
    The default behavior of this check depends on the antisamy-esapi.xml AntiSamy policy configuration file (or an alternate filename, specified via the "Validator.HtmlValidationConfigurationFile" property in your ESAPI.properties file. Implementors wishing to alter the AntiSamy policy configuration file should reference the OWASP AntiSamy project for ideas on how to do HTML validation in a allow-list way, as this is an extremely difficult problem.
    This implementation relies on the OWASP AntiSamy project.
    
    Specified by:
    
    getValidSafeHTML in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., "LoginPage_UsernameField"). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - The actual user input data to validate.
    
    maxLength - The maximum String length allowed for input.
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    Returns:
    
    A string representing the canonicalized and sanitized input that is safe for rendering in an HTML context.
    
    Throws:
    
    ValidationException - Input is invalid, based on the regex associated with type.
    
    IntrusionException - Input likely indicates an attack.
  - getValidSafeHTML
```
public String getValidSafeHTML(String context,
                               String input,
                               int maxLength,
                               boolean allowNull,
                               ValidationErrorList errors)
                        throws IntrusionException
```
    Canonicalize and then sanitize the input so that it is "safe" for renderinger in an HTML context (i.e., that it does not contain unwanted scripts in the body, attributes, CSS, URLs, or anywhere else). Note that the resulting returned value may omit input that is considered dangerous and cannot be safely sanitized and other input that gets HTML encoded (e.g., a single quote (') might get chaged to """).
    The default behavior of this check depends on the antisamy-esapi.xml AntiSamy policy configuration file (or an alternate filename, specified via the "Validator.HtmlValidationConfigurationFile" property in your ESAPI.properties file. Implementors wishing to alter the AntiSamy policy configuration file should reference the OWASP AntiSamy project for ideas on how to do HTML validation in a allow-list way, as this is an extremely difficult problem.
    Calls Validator.getValidSafeHTML(String, String, int, boolean).
    
    Specified by:
    
    getValidSafeHTML in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., "LoginPage_UsernameField"). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - The actual user input data to validate.
    
    maxLength - The maximum String length allowed for input.
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    errors - The error list to which any ValidationException messages are added.
    
    Returns:
    
    A string representing the canonicalized and sanitized input that is safe for rendering in an HTML context.
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - isValidCreditCard
```
public boolean isValidCreditCard(String context,
                                 String input,
                                 boolean allowNull)
```
    Returns true if input matches the pattern for a valid credit card number.
    Calls Validator.getValidCreditCard(String, String, boolean), and returns true if no exceptions are thrown.
    This implementation does not throw IntrusionException.
    
    Specified by:
    
    isValidCreditCard in interface Validator
  - isValidCreditCard
```
public boolean isValidCreditCard(String context,
                                 String input,
                                 boolean allowNull,
                                 ValidationErrorList errors)
                          throws IntrusionException
```
    Returns true if input matches the pattern for a valid credit card number, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidCreditCard(String, String, boolean) and returns true if no exceptions are thrown.
    
    Specified by:
    
    isValidCreditCard in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - getValidCreditCard
```
public String getValidCreditCard(String context,
                                 String input,
                                 boolean allowNull)
                          throws ValidationException,
                                 IntrusionException
```
    Returns a canonicalized and validated credit card number as a String.
    Invalid input will generate a descriptive ValidationException, and input that is clearly an attack will generate a descriptive IntrusionException.
    
    Specified by:
    
    getValidCreditCard in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., PaymentPage_CreditCard). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - The actual user input data to validate.
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    Returns:
    
    A valid credit card number
    
    Throws:
    
    ValidationException - Input is invalid because it doesn't appear to be a valid credit card account number.
    
    IntrusionException - Input likely indicates an attack.
  - getValidCreditCard
```
public String getValidCreditCard(String context,
                                 String input,
                                 boolean allowNull,
                                 ValidationErrorList errors)
                          throws IntrusionException
```
    Returns a canonicalized and validated credit card number as a String, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidCreditCard(String, String, boolean).
    
    Specified by:
    
    getValidCreditCard in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - isValidDirectoryPath
```
public boolean isValidDirectoryPath(String context,
                                    String input,
                                    File parent,
                                    boolean allowNull)
```
    Returns true if input is valid.
    Calls Validator.getValidDirectoryPath(String, String, File, boolean), and returns true if no exceptions are thrown.
    Note: On platforms that support symlinks, this function will fail canonicalization if directorypath is a symlink. For example, on MacOS X, /etc is actually /private/etc. If you mean to use /etc, use its real path (/private/etc), not the symlink (/etc).
    
    This implementation does not throw IntrusionException.
    
    Specified by:
    
    isValidDirectoryPath in interface Validator
  - isValidDirectoryPath
```
public boolean isValidDirectoryPath(String context,
                                    String input,
                                    File parent,
                                    boolean allowNull,
                                    ValidationErrorList errors)
                             throws IntrusionException
```
    Returns true if input is valid, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidDirectoryPath(String, String, File, boolean) and returns true if no exceptions are thrown.
    Note: On platforms that support symlinks, this function will fail canonicalization if directorypath is a symlink. For example, on MacOS X, /etc is actually /private/etc. If you mean to use /etc, use its real path (/private/etc), not the symlink (/etc).
    
    Specified by:
    
    isValidDirectoryPath in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - getValidDirectoryPath
```
public String getValidDirectoryPath(String context,
                                    String input,
                                    File parent,
                                    boolean allowNull)
                             throws ValidationException,
                                    IntrusionException
```
    Returns a canonicalized and validated directory path as a String, provided that the input maps to an existing directory that is an existing subdirectory (at any level) of the specified parent.
    Invalid input will generate a descriptive ValidationException, and input that is clearly an attack will generate a descriptive IntrusionException.
    Note: On platforms that support symlinks, this function will fail canonicalization if directorypath is a symlink. For example, on MacOS X, /etc is actually /private/etc. If you mean to use /etc, use its real path (/private/etc), not the symlink (/etc).
    
    Specified by:
    
    getValidDirectoryPath in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., LoginPage_UsernameField). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - The actual input data to validate.
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    Returns:
    
    A valid directory path
    
    Throws:
    
    ValidationException - Input is invalid (e.g., the provided input is not a directory).
    
    IntrusionException - Input likely indicates an attack.
  - getValidDirectoryPath
```
public String getValidDirectoryPath(String context,
                                    String input,
                                    File parent,
                                    boolean allowNull,
                                    ValidationErrorList errors)
                             throws IntrusionException
```
    Returns a canonicalized and validated directory path as a String, provided that the input maps to an existing directory that is an existing subdirectory (at any level) of the specified parent; any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidDirectoryPath(String, String, File, boolean).
    Note: On platforms that support symlinks, this function will fail canonicalization if directorypath is a symlink. For example, on MacOS X, /etc is actually /private/etc. If you mean to use /etc, use its real path (/private/etc), not the symlink (/etc).
    
    Specified by:
    
    getValidDirectoryPath in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - isValidFileName
```
public boolean isValidFileName(String context,
                               String input,
                               boolean allowNull)
                        throws IntrusionException
```
    Returns true if input is valid.
    Calls Validator.getValidFileName(String, String, List, boolean) with allowedExtensions set to the configured ESAPI.securityConfiguration().getAllowedFileExtensions() and returns true if no exceptions are thrown.
    
    Specified by:
    
    isValidFileName in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
    
    See Also:
    
    ESAPI.securityConfiguration(), SecurityConfiguration.getAllowedFileExtensions()
  - isValidFileName
```
public boolean isValidFileName(String context,
                               String input,
                               boolean allowNull,
                               ValidationErrorList errors)
                        throws IntrusionException
```
    Returns true if input is valid, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidFileName(String, String, List, boolean) with allowedExtensions set to the configured ESAPI.securityConfiguration().getAllowedFileExtensions() and returns true if no exceptions are thrown.
    
    Specified by:
    
    isValidFileName in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
    
    See Also:
    
    ESAPI.securityConfiguration(), SecurityConfiguration.getAllowedFileExtensions()
  - isValidFileName
```
public boolean isValidFileName(String context,
                               String input,
                               List<String> allowedExtensions,
                               boolean allowNull)
```
    Returns true if input is valid.
    Calls Validator.getValidFileName(String, String, List, boolean), and returns true if no exceptions are thrown.
    This implementation does not throw IntrusionException.
    
    Specified by:
    
    isValidFileName in interface Validator
    
    See Also:
    
    ESAPI.securityConfiguration(), SecurityConfiguration.getAllowedFileExtensions()
  - isValidFileName
```
public boolean isValidFileName(String context,
                               String input,
                               List<String> allowedExtensions,
                               boolean allowNull,
                               ValidationErrorList errors)
                        throws IntrusionException
```
    Returns true if input is valid, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidFileName(String, String, List, boolean) and returns true if no exceptions are thrown.
    
    Specified by:
    
    isValidFileName in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
    
    See Also:
    
    ESAPI.securityConfiguration(), SecurityConfiguration.getAllowedFileExtensions()
  - getValidFileName
```
public String getValidFileName(String context,
                               String input,
                               List<String> allowedExtensions,
                               boolean allowNull)
                        throws ValidationException,
                               IntrusionException
```
    Returns a canonicalized and validated file name as a String. Implementors should check for allowed file extensions here, as well as allowed file name characters, as declared in "ESAPI.properties". Invalid input will generate a descriptive ValidationException, and input that is clearly an attack will generate a descriptive IntrusionException.
    
    Specified by:
    
    getValidFileName in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., LoginPage_UsernameField). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - The actual input data to validate.
    
    allowedExtensions - List of file extensions which will be accepted.
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    Returns:
    
    A valid file name
    
    Throws:
    
    ValidationException - Input is invalid (e.g., input refers to a non-existant file, does not have a valid file extension as per allowedExtensions, does not match the canonicalized path, exceeds a maximum length of 255 characters, etc.
    
    IntrusionException - Input likely indicates an attack.
  - getValidFileName
```
public String getValidFileName(String context,
                               String input,
                               List<String> allowedParameters,
                               boolean allowNull,
                               ValidationErrorList errors)
                        throws IntrusionException
```
    Returns a canonicalized and validated file name as a String, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidFileName(String, String, List, boolean), the supplied errorList is used to capture ValidationExceptions.
    
    Specified by:
    
    getValidFileName in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - isValidNumber
```
public boolean isValidNumber(String context,
                             String input,
                             long minValue,
                             long maxValue,
                             boolean allowNull)
```
    Returns true if input is valid.
    Calls Validator.getValidNumber(String, String, long, long, boolean), and returns true if no exceptions are thrown.
    This implementation does not throw IntrusionException.
    
    Specified by:
    
    isValidNumber in interface Validator
  - isValidNumber
```
public boolean isValidNumber(String context,
                             String input,
                             long minValue,
                             long maxValue,
                             boolean allowNull,
                             ValidationErrorList errors)
                      throws IntrusionException
```
    Returns true if input is valid, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidNumber(String, String, long, long, boolean) and returns true if no exceptions are thrown.
    
    Specified by:
    
    isValidNumber in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - getValidNumber
```
public Double getValidNumber(String context,
                             String input,
                             long minValue,
                             long maxValue,
                             boolean allowNull)
                      throws ValidationException,
                             IntrusionException
```
    Returns a validated number as a double within the range of minValue to maxValue. Invalid input will generate a descriptive ValidationException, and input that is clearly an attack will generate a descriptive IntrusionException.
    
    Specified by:
    
    getValidNumber in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., LoginPage_UsernameField). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - The actual input data to validate.
    
    minValue - Lowest legal value for input.
    
    maxValue - Highest legal value for input.
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    Returns:
    
    A validated number as a double.
    
    Throws:
    
    ValidationException - Input is invalid; that is, not a number in the range of [minValue, maxValue].
    
    IntrusionException - Input likely indicates an attack.
  - getValidNumber
```
public Double getValidNumber(String context,
                             String input,
                             long minValue,
                             long maxValue,
                             boolean allowNull,
                             ValidationErrorList errors)
                      throws IntrusionException
```
    Returns a validated number as a double within the range of [minValue, maxValue]; any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidNumber(String, String, long, long, boolean).
    
    Specified by:
    
    getValidNumber in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., "OrderPage_Quantity"). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - The actual user input data to validate.
    
    minValue - Lowest legal value for input.
    
    maxValue - Highest legal value for input.
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    errors - The error list to which any ValidationException messages are added.
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - isValidDouble
```
public boolean isValidDouble(String context,
                             String input,
                             double minValue,
                             double maxValue,
                             boolean allowNull)
```
    Returns true if input is valid.
    Calls Validator.getValidDouble(String, String, double, double, boolean), and returns true if no exceptions are thrown.
    This implementation does not throw IntrusionException.
    
    Specified by:
    
    isValidDouble in interface Validator
  - isValidDouble
```
public boolean isValidDouble(String context,
                             String input,
                             double minValue,
                             double maxValue,
                             boolean allowNull,
                             ValidationErrorList errors)
                      throws IntrusionException
```
    Returns true if input is valid, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidDouble(String, String, double, double, boolean) and returns true if no exceptions are thrown.
    
    Specified by:
    
    isValidDouble in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - getValidDouble
```
public Double getValidDouble(String context,
                             String input,
                             double minValue,
                             double maxValue,
                             boolean allowNull)
                      throws ValidationException,
                             IntrusionException
```
    Returns a validated real number as a double. Invalid input will generate a descriptive ValidationException, and input that is clearly an attack will generate a descriptive IntrusionException.
    
    Specified by:
    
    getValidDouble in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., LoginPage_UsernameField). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - The actual input data to validate.
    
    minValue - Lowest legal value for input.
    
    maxValue - Highest legal value for input.
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    Returns:
    
    A validated real number as a double.
    
    Throws:
    
    ValidationException - Input is invalid.
    
    IntrusionException - Input likely indicates an attack.
  - getValidDouble
```
public Double getValidDouble(String context,
                             String input,
                             double minValue,
                             double maxValue,
                             boolean allowNull,
                             ValidationErrorList errors)
                      throws IntrusionException
```
    Returns a validated real number as a double, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidDouble(String, String, double, double, boolean), the supplied errorList is used to capture ValidationExceptions.
    
    Specified by:
    
    getValidDouble in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - isValidInteger
```
public boolean isValidInteger(String context,
                              String input,
                              int minValue,
                              int maxValue,
                              boolean allowNull)
                       throws IntrusionException
```
    Returns true if input is a valid integer between minValue and maxValue inclusive.
    Calls Validator.getValidInteger(String, String, int, int, boolean), and returns true if no exceptions are thrown.
    
    Specified by:
    
    isValidInteger in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., "OrderPage_Quantity"). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - The actual user input data to validate.
    
    minValue - Lowest legal value for input.
    
    maxValue - Highest legal value for input.
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - isValidInteger
```
public boolean isValidInteger(String context,
                              String input,
                              int minValue,
                              int maxValue,
                              boolean allowNull,
                              ValidationErrorList errors)
                       throws IntrusionException
```
    Returns true if input is a valid integer between minValue and maxValue inclusive, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidInteger(String, String, int, int, boolean) and returns true if no exceptions are thrown.
    
    Specified by:
    
    isValidInteger in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., "OrderPage_Quantity"). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - The actual user input data to validate.
    
    minValue - Lowest legal value for input.
    
    maxValue - Highest legal value for input.
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    errors - The error list to which any ValidationException messages are added.
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - getValidInteger
```
public Integer getValidInteger(String context,
                               String input,
                               int minValue,
                               int maxValue,
                               boolean allowNull)
                        throws ValidationException,
                               IntrusionException
```
    Returns a validated integer, input is a valid integer if it is between minValue and maxValue inclusive. Invalid input will generate a descriptive ValidationException, and input that is clearly an attack will generate a descriptive IntrusionException.
    
    Specified by:
    
    getValidInteger in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., OrderPage_Quantity). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - The actual input data to validate.
    
    minValue - Lowest legal value for input.
    
    maxValue - Highest legal value for input.
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    Returns:
    
    A validated number as an integer.
    
    Throws:
    
    ValidationException - Input is not a valid integer in the range of [minValue, maxValue].
    
    IntrusionException - Input likely indicates an attack.
  - getValidInteger
```
public Integer getValidInteger(String context,
                               String input,
                               int minValue,
                               int maxValue,
                               boolean allowNull,
                               ValidationErrorList errors)
                        throws IntrusionException
```
    Returns a validated integer, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidInteger(String, String, int, int, boolean).
    
    Specified by:
    
    getValidInteger in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - isValidFileContent
```
public boolean isValidFileContent(String context,
                                  byte[] input,
                                  int maxBytes,
                                  boolean allowNull)
```
    Returns true if input is valid.
    Calls Validator.getValidFileContent(String, byte[], int, boolean), and returns true if no exceptions are thrown.
    This implementation does not throw IntrusionException.
    
    Specified by:
    
    isValidFileContent in interface Validator
  - isValidFileContent
```
public boolean isValidFileContent(String context,
                                  byte[] input,
                                  int maxBytes,
                                  boolean allowNull,
                                  ValidationErrorList errors)
                           throws IntrusionException
```
    Returns true if input is valid, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidFileContent(String, byte[], int, boolean) and returns true if no exceptions are thrown.
    
    Specified by:
    
    isValidFileContent in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - getValidFileContent
```
public byte[] getValidFileContent(String context,
                                  byte[] input,
                                  int maxBytes,
                                  boolean allowNull)
                           throws ValidationException,
                                  IntrusionException
```
    Returns validated file content as a byte array. This is a good place to check for max file size, allowed character sets, and do virus scans. Invalid input will generate a descriptive ValidationException, and input that is clearly an attack will generate a descriptive IntrusionException.
    
    Specified by:
    
    getValidFileContent in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., LoginPage_UsernameField). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - The actual input data to validate.
    
    maxBytes - The maximum number of bytes allowed in a legal file.
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    Returns:
    
    A byte array containing valid file content.
    
    Throws:
    
    ValidationException - Input is invalid.
    
    IntrusionException - Input likely indicates an attack.
  - getValidFileContent
```
public byte[] getValidFileContent(String context,
                                  byte[] input,
                                  int maxBytes,
                                  boolean allowNull,
                                  ValidationErrorList errors)
                           throws IntrusionException
```
    Returns validated file content as a byte array, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidFileContent(String, byte[], int, boolean), the supplied errorList is used to capture ValidationExceptions.
    
    Specified by:
    
    getValidFileContent in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - isValidFileUpload
```
public boolean isValidFileUpload(String context,
                                 String directorypath,
                                 String filename,
                                 File parent,
                                 byte[] content,
                                 int maxBytes,
                                 boolean allowNull)
                          throws IntrusionException
```
    Returns true if filepath, filename, and content of a file are valid.
    Calls Validator.isValidFileName(String, String, boolean), Validator.isValidDirectoryPath(String, String, File, boolean), and Validator.isValidFileContent(String, byte[], int, boolean), and returns true if all three checks pass.
    Note: On platforms that support symlinks, this function will fail canonicalization if directorypath is a symlink. For example, on MacOS X, /etc is actually /private/etc. If you mean to use /etc, use its real path (/private/etc), not the symlink (/etc).
    
    Specified by:
    
    isValidFileUpload in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - isValidFileUpload
```
public boolean isValidFileUpload(String context,
                                 String directorypath,
                                 String filename,
                                 File parent,
                                 byte[] content,
                                 int maxBytes,
                                 boolean allowNull,
                                 ValidationErrorList errors)
                          throws IntrusionException
```
    Returns true if filepath, filename, and content of a file are valid, any validation exceptions are added to the supplied errorList.
    Calls Validator.isValidFileName(String, String, boolean, ValidationErrorList) Validator.isValidDirectoryPath(String, String, File, boolean, ValidationErrorList) and Validator.isValidFileContent(String, byte[], int, boolean, ValidationErrorList), and returns true if all three checks pass.
    Note: On platforms that support symlinks, this function will fail canonicalization if directorypath is a symlink. For example, on MacOS X, /etc is actually /private/etc. If you mean to use /etc, use its real path (/private/etc), not the symlink (/etc).
    
    Specified by:
    
    isValidFileUpload in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - assertValidFileUpload
```
public void assertValidFileUpload(String context,
                                  String directorypath,
                                  String filename,
                                  File parent,
                                  byte[] content,
                                  int maxBytes,
                                  List<String> allowedExtensions,
                                  boolean allowNull)
                           throws ValidationException,
                                  IntrusionException
```
    Validates the filepath, filename, and content of a file. Invalid input will generate a descriptive ValidationException, and input that is clearly an attack will generate a descriptive IntrusionException.
    
    Specified by:
    
    assertValidFileUpload in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., LoginPage_UsernameField). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    directorypath - The file path of the uploaded file.
    
    filename - The filename of the uploaded file
    
    content - A byte array containing the content of the uploaded file.
    
    maxBytes - The max number of bytes allowed for a legal file upload.
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    Throws:
    
    ValidationException - Input is invalid.
    
    IntrusionException - Input likely indicates an attack.
  - assertValidFileUpload
```
public void assertValidFileUpload(String context,
                                  String filepath,
                                  String filename,
                                  File parent,
                                  byte[] content,
                                  int maxBytes,
                                  List<String> allowedExtensions,
                                  boolean allowNull,
                                  ValidationErrorList errors)
                           throws IntrusionException
```
    Validates the filepath, filename, and content of a file, any validation exceptions are added to the supplied errorList.
    Calls Validator.assertValidFileUpload(String, String, String, File, byte[], int, List, boolean), the supplied errorList is used to capture ValidationExceptions.
    
    Specified by:
    
    assertValidFileUpload in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - isValidListItem
```
public boolean isValidListItem(String context,
                               String input,
                               List<String> list)
```
    Returns true if input is valid.
    Calls Validator.getValidListItem(String, String, List) and returns true if no exceptions are thrown.
    This implementation does not throw IntrusionException.
    
    Specified by:
    
    isValidListItem in interface Validator
  - isValidListItem
```
public boolean isValidListItem(String context,
                               String input,
                               List<String> list,
                               ValidationErrorList errors)
```
    Returns true if input is valid, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidListItem(String, String, List) and returns true if no exceptions are thrown.
    
    Specified by:
    
    isValidListItem in interface Validator
  - getValidListItem
```
public String getValidListItem(String context,
                               String input,
                               List<String> list)
                        throws ValidationException,
                               IntrusionException
```
    Returns the list item that exactly matches the canonicalized input. Invalid or non-matching input will generate a descriptive ValidationException, and input that is clearly an attack will generate a descriptive IntrusionException.
    
    Specified by:
    
    getValidListItem in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., LoginPage_UsernameField). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - The value to search 'list' for.
    
    list - The list to search for 'input'.
    
    Returns:
    
    The list item that exactly matches the canonicalized input.
    
    Throws:
    
    ValidationException - Input is invalid.
    
    IntrusionException - Input likely indicates an attack.
  - getValidListItem
```
public String getValidListItem(String context,
                               String input,
                               List<String> list,
                               ValidationErrorList errors)
                        throws IntrusionException
```
    Returns the list item that exactly matches the canonicalized input, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidListItem(String, String, List)
    
    Specified by:
    
    getValidListItem in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - isValidHTTPRequestParameterSet
```
public boolean isValidHTTPRequestParameterSet(String context,
                                              javax.servlet.http.HttpServletRequest request,
                                              Set<String> requiredNames,
                                              Set<String> optionalNames)
```
    Returns true if only required and optional parameters are in the request.
    Calls Validator.assertValidHTTPRequestParameterSet(String, HttpServletRequest, Set, Set) and returns true if no exceptions are thrown.
    This implementation does not throw IntrusionException.
    
    Specified by:
    
    isValidHTTPRequestParameterSet in interface Validator
  - isValidHTTPRequestParameterSet
```
public boolean isValidHTTPRequestParameterSet(String context,
                                              javax.servlet.http.HttpServletRequest request,
                                              Set<String> requiredNames,
                                              Set<String> optionalNames,
                                              ValidationErrorList errors)
```
    Returns true if only required and optional parameters are in the request, any validation exceptions are added to the supplied errorList.
    Calls Validator.assertValidHTTPRequestParameterSet(String, HttpServletRequest, Set, Set) and returns true if no exceptions are thrown.
    
    Specified by:
    
    isValidHTTPRequestParameterSet in interface Validator
  - assertValidHTTPRequestParameterSet
```
public void assertValidHTTPRequestParameterSet(String context,
                                               javax.servlet.http.HttpServletRequest request,
                                               Set<String> required,
                                               Set<String> optional)
                                        throws ValidationException,
                                               IntrusionException
```
    Validates that the parameters in the current request contain all required parameters and only optional ones in addition. Invalid input will generate a descriptive ValidationException, and input that is clearly an attack will generate a descriptive IntrusionException.
    
    Specified by:
    
    assertValidHTTPRequestParameterSet in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., LoginPage_UsernameField). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    required - parameters that are required to be in HTTP request
    
    optional - additional parameters that may be in HTTP request
    
    Throws:
    
    ValidationException - Input is invalid.
    
    IntrusionException - Input likely indicates an attack.
  - assertValidHTTPRequestParameterSet
```
public void assertValidHTTPRequestParameterSet(String context,
                                               javax.servlet.http.HttpServletRequest request,
                                               Set<String> required,
                                               Set<String> optional,
                                               ValidationErrorList errors)
                                        throws IntrusionException
```
    Validates that the parameters in the current request contain all required parameters and only optional ones in addition, any validation exceptions are added to the supplied errorList.
    Calls Validator.assertValidHTTPRequestParameterSet(String, HttpServletRequest, Set, Set).
    
    Specified by:
    
    assertValidHTTPRequestParameterSet in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - isValidPrintable
```
public boolean isValidPrintable(String context,
                                char[] input,
                                int maxLength,
                                boolean allowNull)
```
    Returns true if input is valid.
    Calls Validator.getValidPrintable(String, char[], int, boolean) and returns true if no exceptions are thrown.
    Checks that all bytes are valid ASCII characters (between 33 and 126 inclusive). This implementation does no decoding.
    This implementation does not throw IntrusionException.
    
    Specified by:
    
    isValidPrintable in interface Validator
    
    See Also:
    
    Wikipedia - ASCII
  - isValidPrintable
```
public boolean isValidPrintable(String context,
                                char[] input,
                                int maxLength,
                                boolean allowNull,
                                ValidationErrorList errors)
                         throws IntrusionException
```
    Returns true if input is valid, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidPrintable(String, char[], int, boolean) and returns true if no exceptions are thrown.
    Checks that all bytes are valid ASCII characters (between 33 and 126 inclusive). This implementation does no decoding.
    
    Specified by:
    
    isValidPrintable in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
    
    See Also:
    
    Wikipedia - ASCII
  - getValidPrintable
```
public char[] getValidPrintable(String context,
                                char[] input,
                                int maxLength,
                                boolean allowNull)
                         throws ValidationException,
                                IntrusionException
```
    Returns canonicalized and validated printable characters as a byte array. Invalid input will generate a descriptive ValidationException, and input that is clearly an attack will generate a descriptive IntrusionException.
    Input is valid if it only contains printable ASCII characters (33-126 inclusive).
    
    Specified by:
    
    getValidPrintable in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., LoginPage_UsernameField). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - data to be returned as valid and printable
    
    maxLength - Maximum number of bytes stored in 'input'
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    Returns:
    
    a byte array containing only printable characters, made up of data from 'input'
    
    Throws:
    
    ValidationException - Input is invalid.
    
    IntrusionException
    
    See Also:
    
    Wikipedia - ASCII
  - getValidPrintable
```
public char[] getValidPrintable(String context,
                                char[] input,
                                int maxLength,
                                boolean allowNull,
                                ValidationErrorList errors)
                         throws IntrusionException
```
    Returns canonicalized and validated printable characters as a byte array, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidPrintable(String, char[], int, boolean).
    Input is valid if it only contains printable ASCII characters (33-126 inclusive).
    
    Specified by:
    
    getValidPrintable in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
    
    See Also:
    
    Wikipedia - ASCII
  - isValidPrintable
```
public boolean isValidPrintable(String context,
                                String input,
                                int maxLength,
                                boolean allowNull)
```
    Returns true if input is valid.
    Calls Validator.getValidPrintable(String, String, int, boolean) and returns true if no exceptions are thrown.
    Returns true if input is valid printable ASCII characters (33-126 inclusive).
    This implementation does not throw IntrusionException.
    
    Specified by:
    
    isValidPrintable in interface Validator
    
    See Also:
    
    Wikipedia - ASCII
  - isValidPrintable
```
public boolean isValidPrintable(String context,
                                String input,
                                int maxLength,
                                boolean allowNull,
                                ValidationErrorList errors)
                         throws IntrusionException
```
    Returns true if input is valid, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidPrintable(String, String, int, boolean) and returns true if no exceptions are thrown. Returns true if input is valid printable ASCII characters (33-126 inclusive).
    
    Specified by:
    
    isValidPrintable in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
    
    See Also:
    
    Wikipedia - ASCII
  - getValidPrintable
```
public String getValidPrintable(String context,
                                String input,
                                int maxLength,
                                boolean allowNull)
                         throws ValidationException
```
    Returns canonicalized and validated printable characters as a String. Invalid input will generate a descriptive ValidationException, and input that is clearly an attack will generate a descriptive IntrusionException.
    Input is valid if it only contains printable ASCII characters (33-126 inclusive).
    
    Specified by:
    
    getValidPrintable in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., LoginPage_UsernameField). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - data to be returned as valid and printable
    
    maxLength - Maximum number of bytes stored in 'input' after canonicalization
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    Returns:
    
    a String containing only printable characters, made up of data from 'input'
    
    Throws:
    
    ValidationException - Input is invalid.
    
    See Also:
    
    Wikipedia - ASCII
  - getValidPrintable
```
public String getValidPrintable(String context,
                                String input,
                                int maxLength,
                                boolean allowNull,
                                ValidationErrorList errors)
                         throws IntrusionException
```
    Returns canonicalized and validated printable characters as a String, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidPrintable(String, String, int, boolean). Input is valid if it only contains printable ASCII characters (33-126 inclusive).
    
    Specified by:
    
    getValidPrintable in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
    
    See Also:
    
    Wikipedia - ASCII
  - isValidRedirectLocation
```
public boolean isValidRedirectLocation(String context,
                                       String input,
                                       boolean allowNull)
                                throws IntrusionException
```
    Returns true if input is valid.
    Calls Validator.getValidRedirectLocation(String, String, boolean) and returns true if no exceptions are thrown.
    
    Specified by:
    
    isValidRedirectLocation in interface Validator
    
    Throws:
    
    IntrusionException
  - isValidRedirectLocation
```
public boolean isValidRedirectLocation(String context,
                                       String input,
                                       boolean allowNull,
                                       ValidationErrorList errors)
                                throws IntrusionException
```
    Returns true if input is valid, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidRedirectLocation(String, String, boolean) and returns true if no exceptions are thrown.
    
    Specified by:
    
    isValidRedirectLocation in interface Validator
    
    Throws:
    
    IntrusionException
  - getValidRedirectLocation
```
public String getValidRedirectLocation(String context,
                                       String input,
                                       boolean allowNull)
                                throws ValidationException,
                                       IntrusionException
```
    Returns a canonicalized and validated redirect location as a String. Invalid input will generate a descriptive ValidationException, and input that is clearly an attack will generate a descriptive IntrusionException.
    
    Specified by:
    
    getValidRedirectLocation in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., LoginPage_UsernameField). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - redirect location to be returned as valid, according to encoding rules set in "ESAPI.properties"
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    Returns:
    
    A canonicalized and validated redirect location, as defined in "ESAPI.properties"
    
    Throws:
    
    ValidationException - Input is invalid.
    
    IntrusionException - Input likely indicates an attack.
  - getValidRedirectLocation
```
public String getValidRedirectLocation(String context,
                                       String input,
                                       boolean allowNull,
                                       ValidationErrorList errors)
                                throws IntrusionException
```
    Returns a canonicalized and validated redirect location as a String, any validation exceptions are added to the supplied errorList.
    Calls Validator.getValidRedirectLocation(String, String, boolean).
    
    Specified by:
    
    getValidRedirectLocation in interface Validator
    
    Throws:
    
    IntrusionException - Input likely indicates an attack.
  - safeReadLine
```
public String safeReadLine(InputStream in,
                           int max)
                    throws ValidationException
```
    Reads from an input stream until end-of-line or a maximum number of characters. This method protects against the inherent denial of service attack in reading until the end of a line. If an attacker doesn't ever send a newline character, then a normal input stream reader will read until all memory is exhausted and the platform throws an OutOfMemoryError and probably terminates.
    This implementation reads until a newline or the specified number of characters.
    
    Specified by:
    
    safeReadLine in interface Validator
    
    Parameters:
    
    in - The InputStream from which to read data
    
    max - Maximum characters allowed to be read in per line
    
    Returns:
    
    a String containing the current line of inputStream
    
    Throws:
    
    ValidationException - Input is invalid.
  - isValidURI
```
public boolean isValidURI(String context,
                          String input,
                          boolean allowNull)
```
    Parses and ensures that the URI in question is a valid RFC-3986 URI. This simplifies the kind of regex required for subsequent validation to mitigate regex-based DoS attacks.
    
    Specified by:
    
    isValidURI in interface Validator
    
    Parameters:
    
    context - A descriptive name of the parameter that you are validating (e.g., LoginPage_UsernameField). This value is used by any logging or error handling that is done with respect to the value passed in.
    
    input - redirect location to be returned as valid, according to encoding rules set in "ESAPI.properties"
    
    allowNull - If allowNull is true then an input that is NULL or an empty string will be legal. If allowNull is false then NULL or an empty String will throw a ValidationException.
    
    Returns:
    
    True if the URI is valid
    
    See Also:
    
    RFC-3986.
  - getRfcCompliantURI
```
public URI getRfcCompliantURI(String input)
```
    Will return a URI object that will represent a fully parsed and legal URI as specified in RFC-3986.
    
    Specified by:
    
    getRfcCompliantURI in interface Validator
    
    Parameters:
    
    input - String
    
    Returns:
    
    URI object representing a parsed URI, or null if the URI was non-compliant in some way.

Class DefaultValidator

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DefaultValidator

DefaultValidator

Method Detail

getInstance

addRule

getRule

isValidInput

isValidInput

isValidInput

isValidInput

getValidInput

getValidInput

getValidInput

getValidInput

isValidDate

isValidDate

getValidDate

getValidDate

isValidSafeHTML

isValidSafeHTML

getValidSafeHTML

getValidSafeHTML

isValidCreditCard

isValidCreditCard

getValidCreditCard

getValidCreditCard

isValidDirectoryPath

isValidDirectoryPath

getValidDirectoryPath

getValidDirectoryPath

isValidFileName

isValidFileName

isValidFileName

isValidFileName

getValidFileName

getValidFileName

isValidNumber

isValidNumber

getValidNumber

getValidNumber

isValidDouble

isValidDouble

getValidDouble

getValidDouble

isValidInteger

isValidInteger

getValidInteger

getValidInteger

isValidFileContent

isValidFileContent

getValidFileContent

getValidFileContent

isValidFileUpload

isValidFileUpload

assertValidFileUpload

assertValidFileUpload

isValidListItem

isValidListItem

getValidListItem

getValidListItem

isValidHTTPRequestParameterSet

isValidHTTPRequestParameterSet

assertValidHTTPRequestParameterSet

assertValidHTTPRequestParameterSet

isValidPrintable

isValidPrintable

getValidPrintable

getValidPrintable

isValidPrintable

isValidPrintable

getValidPrintable

getValidPrintable

isValidRedirectLocation

isValidRedirectLocation

getValidRedirectLocation