Painless: Only allow Painless type names to be the same as the equivalent Java class. (elastic#27264)

Also adds a parameter called only_fqn to the whitelist to enforce that a painless type must be specified as the fully-qualifed java class name.

Author: jdconrad

docs/painless/painless-debugging.asciidoc

@@ -78,7 +78,7 @@ The response looks like:
     "caused_by": {
       "type": "script_exception",
       "to_string": "{gp=[26, 82, 1], last=gaudreau, assists=[17, 46, 0], first=johnny, goals=[9, 27, 1]}",
-      "painless_class": "LinkedHashMap",
+      "painless_class": "java.util.LinkedHashMap",
       "java_class": "java.util.LinkedHashMap",
       ...
     }

modules/lang-painless/src/main/java/org/elasticsearch/painless/Definition.java

@@ -33,13 +33,16 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.Stack;
+import java.util.regex.Pattern;
 
 /**
  * The entire API for Painless.  Also used as a whitelist for checking for legal
  * methods and fields during at both compile-time and runtime.
  */
 public final class Definition {
 
+    private static final Pattern TYPE_NAME_PATTERN = Pattern.compile("^[_a-zA-Z][._a-zA-Z0-9]*$");
+
     private static final String[] DEFINITION_FILES = new String[] {
             "org.elasticsearch.txt",
             "java.lang.txt",
@@ -535,7 +538,8 @@ private Definition(List<Whitelist> whitelists) {
             // are used for validation during the second iteration
             for (Whitelist whitelist : whitelists) {
                 for (Whitelist.Struct whitelistStruct : whitelist.whitelistStructs) {
-                    Struct painlessStruct = structsMap.get(whitelistStruct.painlessTypeName);
+                    String painlessTypeName = whitelistStruct.javaClassName.replace('$', '.');
+                    Struct painlessStruct = structsMap.get(painlessTypeName);
 
                     if (painlessStruct != null && painlessStruct.clazz.getName().equals(whitelistStruct.javaClassName) == false) {
                         throw new IllegalArgumentException("struct [" + painlessStruct.name + "] cannot represent multiple classes " +
@@ -545,7 +549,7 @@ private Definition(List<Whitelist> whitelists) {
                     origin = whitelistStruct.origin;
                     addStruct(whitelist.javaClassLoader, whitelistStruct);
 
-                    painlessStruct = structsMap.get(whitelistStruct.painlessTypeName);
+                    painlessStruct = structsMap.get(painlessTypeName);
                     javaClassesToPainlessStructs.put(painlessStruct.clazz, painlessStruct);
                 }
             }
@@ -555,19 +559,21 @@ private Definition(List<Whitelist> whitelists) {
             // been white-listed during the first iteration
             for (Whitelist whitelist : whitelists) {
                 for (Whitelist.Struct whitelistStruct : whitelist.whitelistStructs) {
+                    String painlessTypeName = whitelistStruct.javaClassName.replace('$', '.');
+
                     for (Whitelist.Constructor whitelistConstructor : whitelistStruct.whitelistConstructors) {
                         origin = whitelistConstructor.origin;
-                        addConstructor(whitelistStruct.painlessTypeName, whitelistConstructor);
+                        addConstructor(painlessTypeName, whitelistConstructor);
                     }
 
                     for (Whitelist.Method whitelistMethod : whitelistStruct.whitelistMethods) {
                         origin = whitelistMethod.origin;
-                        addMethod(whitelist.javaClassLoader, whitelistStruct.painlessTypeName, whitelistMethod);
+                        addMethod(whitelist.javaClassLoader, painlessTypeName, whitelistMethod);
                     }
 
                     for (Whitelist.Field whitelistField : whitelistStruct.whitelistFields) {
                         origin = whitelistField.origin;
-                        addField(whitelistStruct.painlessTypeName, whitelistField);
+                        addField(painlessTypeName, whitelistField);
                     }
                 }
             }
@@ -577,7 +583,14 @@ private Definition(List<Whitelist> whitelists) {
 
         // goes through each Painless struct and determines the inheritance list,
         // and then adds all inherited types to the Painless struct's whitelist
-        for (Struct painlessStruct : structsMap.values()) {
+        for (Map.Entry<String, Struct> painlessNameStructEntry : structsMap.entrySet()) {
+            String painlessStructName = painlessNameStructEntry.getKey();
+            Struct painlessStruct = painlessNameStructEntry.getValue();
+
+            if (painlessStruct.name.equals(painlessStructName) == false) {
+                continue;
+            }
+
             List<String> painlessSuperStructs = new ArrayList<>();
             Class<?> javaSuperClass = painlessStruct.clazz.getSuperclass();
 
@@ -633,16 +646,33 @@ private Definition(List<Whitelist> whitelists) {
         }
 
         // mark functional interfaces (or set null, to mark class is not)
-        for (Struct clazz : structsMap.values()) {
-            clazz.functionalMethod.set(computeFunctionalInterfaceMethod(clazz));
+        for (String painlessStructName : structsMap.keySet()) {
+            Struct painlessStruct = structsMap.get(painlessStructName);
+
+            if (painlessStruct.name.equals(painlessStructName) == false) {
+                continue;
+            }
+
+            painlessStruct.functionalMethod.set(computeFunctionalInterfaceMethod(painlessStruct));
         }
 
         // precompute runtime classes
-        for (Struct struct : structsMap.values()) {
-            addRuntimeClass(struct);
+        for (String painlessStructName : structsMap.keySet()) {
+            Struct painlessStruct = structsMap.get(painlessStructName);
+
+            if (painlessStruct.name.equals(painlessStructName) == false) {
+                continue;
+            }
+
+            addRuntimeClass(painlessStruct);
         }
+
         // copy all structs to make them unmodifiable for outside users:
-        for (final Map.Entry<String,Struct> entry : structsMap.entrySet()) {
+        for (Map.Entry<String,Struct> entry : structsMap.entrySet()) {
+            if (entry.getKey().equals(entry.getValue().name) == false) {
+                continue;
+            }
+
             entry.setValue(entry.getValue().freeze());
         }
 
@@ -678,8 +708,17 @@ private Definition(List<Whitelist> whitelists) {
     }
 
     private void addStruct(ClassLoader whitelistClassLoader, Whitelist.Struct whitelistStruct) {
-        if (!whitelistStruct.painlessTypeName.matches("^[_a-zA-Z][._a-zA-Z0-9]*")) {
-            throw new IllegalArgumentException("invalid struct type name [" + whitelistStruct.painlessTypeName + "]");
+        String painlessTypeName = whitelistStruct.javaClassName.replace('$', '.');
+        String importedPainlessTypeName = painlessTypeName;
+
+        if (TYPE_NAME_PATTERN.matcher(painlessTypeName).matches() == false) {
+            throw new IllegalArgumentException("invalid struct type name [" + painlessTypeName + "]");
+        }
+
+        int index = whitelistStruct.javaClassName.lastIndexOf('.');
+
+        if (index != -1) {
+            importedPainlessTypeName = whitelistStruct.javaClassName.substring(index + 1).replace('$', '.');
         }
 
         Class<?> javaClass;
@@ -698,21 +737,34 @@ private void addStruct(ClassLoader whitelistClassLoader, Whitelist.Struct whitel
                 javaClass = Class.forName(whitelistStruct.javaClassName, true, whitelistClassLoader);
             } catch (ClassNotFoundException cnfe) {
                 throw new IllegalArgumentException("invalid java class name [" + whitelistStruct.javaClassName + "]" +
-                        " for struct [" + whitelistStruct.painlessTypeName + "]");
+                        " for struct [" + painlessTypeName + "]");
             }
         }
 
-        Struct existingStruct = structsMap.get(whitelistStruct.painlessTypeName);
+        Struct existingStruct = structsMap.get(painlessTypeName);
 
         if (existingStruct == null) {
-            Struct struct = new Struct(whitelistStruct.painlessTypeName, javaClass, org.objectweb.asm.Type.getType(javaClass));
-
-            structsMap.put(whitelistStruct.painlessTypeName, struct);
-            simpleTypesMap.put(whitelistStruct.painlessTypeName, getTypeInternal(whitelistStruct.painlessTypeName));
+            Struct struct = new Struct(painlessTypeName, javaClass, org.objectweb.asm.Type.getType(javaClass));
+            structsMap.put(painlessTypeName, struct);
+
+            if (whitelistStruct.onlyFQNJavaClassName) {
+                simpleTypesMap.put(painlessTypeName, getType(painlessTypeName));
+            } else if (simpleTypesMap.containsKey(importedPainlessTypeName) == false) {
+                simpleTypesMap.put(importedPainlessTypeName, getType(painlessTypeName));
+                structsMap.put(importedPainlessTypeName, struct);
+            } else {
+                throw new IllegalArgumentException("duplicate short name [" + importedPainlessTypeName + "] " +
+                        "found for struct [" + painlessTypeName + "]");
+            }
         } else if (existingStruct.clazz.equals(javaClass) == false) {
-            throw new IllegalArgumentException("struct [" + whitelistStruct.painlessTypeName + "] is used to " +
+            throw new IllegalArgumentException("struct [" + painlessTypeName + "] is used to " +
                     "illegally represent multiple java classes [" + whitelistStruct.javaClassName + "] and " +
                     "[" + existingStruct.clazz.getName() + "]");
+        } else if (whitelistStruct.onlyFQNJavaClassName && simpleTypesMap.containsKey(importedPainlessTypeName) &&
+                simpleTypesMap.get(importedPainlessTypeName).clazz == javaClass ||
+                whitelistStruct.onlyFQNJavaClassName == false && (simpleTypesMap.containsKey(importedPainlessTypeName) == false ||
+                simpleTypesMap.get(importedPainlessTypeName).clazz != javaClass)) {
+            throw new IllegalArgumentException("inconsistent only_fqn parameters found for type [" + painlessTypeName + "]");
         }
     }
 
@@ -783,7 +835,7 @@ private void addMethod(ClassLoader whitelistClassLoader, String ownerStructName,
                     "name [" + whitelistMethod.javaMethodName + "] and parameters " + whitelistMethod.painlessParameterTypeNames);
         }
 
-        if (!whitelistMethod.javaMethodName.matches("^[_a-zA-Z][_a-zA-Z0-9]*$")) {
+        if (TYPE_NAME_PATTERN.matcher(whitelistMethod.javaMethodName).matches() == false) {
             throw new IllegalArgumentException("invalid method name" +
                     " [" + whitelistMethod.javaMethodName + "] for owner struct [" + ownerStructName + "].");
         }
@@ -913,7 +965,7 @@ private void addField(String ownerStructName, Whitelist.Field whitelistField) {
                     "name [" + whitelistField.javaFieldName + "] and type " + whitelistField.painlessFieldTypeName);
         }
 
-        if (!whitelistField.javaFieldName.matches("^[_a-zA-Z][_a-zA-Z0-9]*$")) {
+        if (TYPE_NAME_PATTERN.matcher(whitelistField.javaFieldName).matches() == false) {
             throw new IllegalArgumentException("invalid field name " +
                     "[" + whitelistField.painlessFieldTypeName + "] for owner struct [" + ownerStructName + "].");
         }

modules/lang-painless/src/main/java/org/elasticsearch/painless/Whitelist.java

@@ -56,12 +56,14 @@ public static final class Struct {
         /** Information about where this struct was white-listed from.  Can be used for error messages. */
         public final String origin;
 
-        /** The Painless name of this struct which will also be the name of a type in a Painless script.  */
-        public final String painlessTypeName;
-
         /** The Java class name this struct represents. */
         public final String javaClassName;
 
+        /**
+         * Allow the Java class name to only be specified as the fully-qualified name.
+         */
+        public final boolean onlyFQNJavaClassName;
+
         /** The {@link List} of white-listed ({@link Constructor}s) available to this struct. */
         public final List<Constructor> whitelistConstructors;
 
@@ -72,11 +74,11 @@ public static final class Struct {
         public final List<Field> whitelistFields;
 
         /** Standard constructor. All values must be not {@code null}. */
-        public Struct(String origin, String painlessTypeName, String javaClassName,
+        public Struct(String origin, String javaClassName, boolean onlyFQNJavaClassName,
                       List<Constructor> whitelistConstructors, List<Method> whitelistMethods, List<Field> whitelistFields) {
             this.origin = Objects.requireNonNull(origin);
-            this.painlessTypeName = Objects.requireNonNull(painlessTypeName);
             this.javaClassName = Objects.requireNonNull(javaClassName);
+            this.onlyFQNJavaClassName = onlyFQNJavaClassName;
 
             this.whitelistConstructors = Collections.unmodifiableList(Objects.requireNonNull(whitelistConstructors));
             this.whitelistMethods = Collections.unmodifiableList(Objects.requireNonNull(whitelistMethods));