SecureASTCustomizer (Groovy 1.8.9)

Overview

Package

Class

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.codehaus.groovy.control.customizers
Class SecureASTCustomizer

java.lang.Object
  org.codehaus.groovy.control.CompilationUnit.PrimaryClassNodeOperation
      org.codehaus.groovy.control.customizers.CompilationCustomizer
          org.codehaus.groovy.control.customizers.SecureASTCustomizer

public class SecureASTCustomizer
extends CompilationCustomizer
extends CompilationCustomizer

This customizer allows securing source code by controlling what code constructs are allowed. For example, if you only want to allow arithmetic operations in a groovy shell, you can configure this customizer to restrict package imports, method calls and so on.

Most of the securization options found in this class work with either blacklist or whitelist. This means that, for a single option, you can set a whitelist OR a blacklist, but not both. You can mix whitelist/blacklist strategies for different options. For example, you can have import whitelist and tokens blacklist.

The recommanded way of securing shells is to use whitelists because it is guaranteed that future features of the Groovy language won't be allowed by defaut. Using blacklists, you can limit the features of the languages by opting out, but new language features would require you to update your configuration.

If you set neither a whitelist nor a blacklist, then everything is authorized.

Combinations of import and star imports constraints are authorized as long as you use the same type of list for both. For example, you may use an import whitelist and a star import whitelist together, but you cannot use an import white list with a star import blacklist. static imports are handled separately, meaning that blacklisting an import does not prevent from using a static import.

Eventually, if the features provided here are not sufficient, you may implement custom AST filtering handlers, either implementing the SecureASTCustomizer.StatementChecker interface or SecureASTCustomizer.ExpressionChecker interface then register your handlers thanks to the addExpressionCheckers(org.codehaus.groovy.control.customizers.SecureASTCustomizer.ExpressionChecker...) and addStatementCheckers(org.codehaus.groovy.control.customizers.SecureASTCustomizer.StatementChecker...) methods.

Here is an example of usage. We will create a groovy classloader which only supports arithmetic operations and imports the java.lang.Math classes by default.

 final ImportCustomizer imports = new ImportCustomizer().addStaticStars('java.lang.Math') // add static import of java.lang.Math
             final SecureASTCustomizer secure = new SecureASTCustomizer()
             secure.with {
                 closuresAllowed = false
                 methodDefinitionAllowed = false

                 importsWhitelist = []
                 staticImportsWhitelist = []
                 staticStarImportsWhitelist = ['java.lang.Math'] // only java.lang.Math is allowed

                 tokensWhitelist = [
                         PLUS,
                         MINUS,
                         MULTIPLY,
                         DIVIDE,
                         MOD,
                         POWER,
                         PLUS_PLUS,
                         MINUS_MINUS,
                         COMPARE_EQUAL,
                         COMPARE_NOT_EQUAL,
                         COMPARE_LESS_THAN,
                         COMPARE_LESS_THAN_EQUAL,
                         COMPARE_GREATER_THAN,
                         COMPARE_GREATER_THAN_EQUAL,
                 ].asImmutable()

                 constantTypesClassesWhiteList = [
                         Integer,
                         Float,
                         Long,
                         Double,
                         BigDecimal,
                         Integer.TYPE,
                         Long.TYPE,
                         Float.TYPE,
                         Double.TYPE
                 ].asImmutable()

                 receiversClassesWhiteList = [
                         Math,
                         Integer,
                         Float,
                         Double,
                         Long,
                         BigDecimal
                 ].asImmutable()
             }
             CompilerConfiguration config = new CompilerConfiguration()
             config.addCompilationCustomizers(imports, secure)
             GroovyClassLoader loader = new GroovyClassLoader(this.class.classLoader, config)

Since:: 1.8.0
Author:: Cedric Champeau, Guillaume Laforge, Hamlet D'Arcy

Nested Class Summary
`static interface`	`SecureASTCustomizer.ExpressionChecker` This interface allows the user to plugin custom expression checkers if expression blacklist or whitelist are not sufficient
`static interface`	`SecureASTCustomizer.StatementChecker` This interface allows the user to plugin custom statement checkers if statement blacklist or whitelist are not sufficient

Constructor Summary
`SecureASTCustomizer()`

Method Summary
`void`	`addExpressionCheckers(SecureASTCustomizer.ExpressionChecker... checkers)`
`void`	`addStatementCheckers(SecureASTCustomizer.StatementChecker... checkers)`
`void`	`call(SourceUnit source, GeneratorContext context, ClassNode classNode)`
`List<String>`	`getConstantTypesBlackList()`
`List<String>`	`getConstantTypesWhiteList()`
`List<Class<? extends Expression>>`	`getExpressionsBlacklist()`
`List<Class<? extends Expression>>`	`getExpressionsWhitelist()`
`List<String>`	`getImportsBlacklist()`
`List<String>`	`getImportsWhitelist()`
`List<String>`	`getReceiversBlackList()`
`List<String>`	`getReceiversWhiteList()`
`List<String>`	`getStarImportsBlacklist()`
`List<String>`	`getStarImportsWhitelist()`
`List<Class<? extends Statement>>`	`getStatementsBlacklist()`
`List<Class<? extends Statement>>`	`getStatementsWhitelist()`
`List<String>`	`getStaticImportsBlacklist()`
`List<String>`	`getStaticImportsWhitelist()`
`List<String>`	`getStaticStarImportsBlacklist()`
`List<String>`	`getStaticStarImportsWhitelist()`
`List<Integer>`	`getTokensBlacklist()`
`List<Integer>`	`getTokensWhitelist()`
`boolean`	`isClosuresAllowed()`
`boolean`	`isIndirectImportCheckEnabled()`
`boolean`	`isMethodDefinitionAllowed()`
`boolean`	`isPackageAllowed()`
`void`	`setClosuresAllowed(boolean closuresAllowed)`
`void`	`setConstantTypesBlackList(List<String> constantTypesBlackList)`
`void`	`setConstantTypesClassesBlackList(List<Class> constantTypesBlackList)` An alternative way of setting constant types.
`void`	`setConstantTypesClassesWhiteList(List<Class> constantTypesWhiteList)` An alternative way of setting constant types.
`void`	`setConstantTypesWhiteList(List<String> constantTypesWhiteList)`
`void`	`setExpressionsBlacklist(List<Class<? extends Expression>> expressionsBlacklist)`
`void`	`setExpressionsWhitelist(List<Class<? extends Expression>> expressionsWhitelist)`
`void`	`setImportsBlacklist(List<String> importsBlacklist)`
`void`	`setImportsWhitelist(List<String> importsWhitelist)`
`void`	`setIndirectImportCheckEnabled(boolean indirectImportCheckEnabled)` Set this option to true if you want your import rules to be checked against every class node.
`void`	`setMethodDefinitionAllowed(boolean methodDefinitionAllowed)`
`void`	`setPackageAllowed(boolean packageAllowed)`
`void`	`setReceiversBlackList(List<String> receiversBlackList)` Sets the list of classes which deny method calls.
`void`	`setReceiversClassesBlackList(List<Class> receiversBlacklist)` An alternative way of setting `receiver classes`.
`void`	`setReceiversClassesWhiteList(List<Class> receiversWhitelist)` An alternative way of setting `receiver classes`.
`void`	`setReceiversWhiteList(List<String> receiversWhiteList)` Sets the list of classes which may accept method calls.
`void`	`setStarImportsBlacklist(List<String> starImportsBlacklist)`
`void`	`setStarImportsWhitelist(List<String> starImportsWhitelist)`
`void`	`setStatementsBlacklist(List<Class<? extends Statement>> statementsBlacklist)`
`void`	`setStatementsWhitelist(List<Class<? extends Statement>> statementsWhitelist)`
`void`	`setStaticImportsBlacklist(List<String> staticImportsBlacklist)`
`void`	`setStaticImportsWhitelist(List<String> staticImportsWhitelist)`
`void`	`setStaticStarImportsBlacklist(List<String> staticStarImportsBlacklist)`
`void`	`setStaticStarImportsWhitelist(List<String> staticStarImportsWhitelist)`
`void`	`setTokensBlacklist(List<Integer> tokensBlacklist)` Sets the list of tokens which are blacklisted.
`void`	`setTokensWhitelist(List<Integer> tokensWhitelist)` Sets the list of tokens which are whitelisted.

Methods inherited from class org.codehaus.groovy.control.customizers.CompilationCustomizer
`getPhase`

Methods inherited from class org.codehaus.groovy.control.CompilationUnit.PrimaryClassNodeOperation
`needSortedInput`

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

Constructor Detail