| /* | |
| * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved. | |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
| * | |
| * This code is free software; you can redistribute it and/or modify it | |
| * under the terms of the GNU General Public License version 2 only, as | |
| * published by the Free Software Foundation. | |
| * | |
| * This code is distributed in the hope that it will be useful, but WITHOUT | |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| * version 2 for more details (a copy is included in the LICENSE file that | |
| * accompanied this code). | |
| * | |
| * You should have received a copy of the GNU General Public License version | |
| * 2 along with this work; if not, write to the Free Software Foundation, | |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| * | |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
| * or visit www.oracle.com if you need additional information or have any | |
| * questions. | |
| */ | |
| /* | |
| * @test | |
| * @bug 8303623 | |
| * @modules jdk.compiler/com.sun.tools.javac.code | |
| * @summary Compiler should disallow non-standard UTF-8 string encodings | |
| */ | |
| import com.sun.tools.javac.code.Source; | |
| import com.sun.tools.javac.Main; | |
| import java.io.File; | |
| import java.io.FileOutputStream; | |
| import java.io.IOException; | |
| import java.io.PrintStream; | |
| import java.io.PrintWriter; | |
| import java.io.StringWriter; | |
| import java.nio.file.Files; | |
| import java.util.Arrays; | |
| public class InvalidModifiedUtf8Test { | |
| // | |
| // What this test does (repeatedly): | |
| // 1. Compile a Java source file for ClassX normally | |
| // 2. Modify the UTF-8 inside the ClassX classfile so that it is | |
| // still valid structurally but uses a non-standard way of | |
| // encoding some character (according to "Modified UTF-8"). | |
| // 3. Compile a Java source file for RefClass that references ClassX | |
| // 4. Verify that the compiler gives a "bad UTF-8" error | |
| // | |
| // We change c3 a8 -> c3 e8 (illegal second byte not of the form 0x10xxxxxx) | |
| private static final String SOURCE_0 = """ | |
| interface CLASSNAME { | |
| void ABC\u00e8(); // encodes to: 41 42 43 c3 a8 | |
| } | |
| """; | |
| // We change e1 80 80 -> e1 80 40 (illegal third byte not of the form 0x10xxxxxx) | |
| private static final String SOURCE_1 = """ | |
| interface CLASSNAME { | |
| void ABC\u1000(); // encodes to: 41 42 43 e1 80 80 | |
| } | |
| """; | |
| // We change c4 80 -> c1 81 (illegal two-byte encoding for one-byte value) | |
| private static final String SOURCE_2 = """ | |
| interface CLASSNAME { | |
| void ABC\u0100(); // encodes to: 41 42 43 c4 00 | |
| } | |
| """; | |
| // We change e1 80 80 -> e0 84 80 (illegal three-byte encoding for two-byte value) | |
| private static final String SOURCE_3 = """ | |
| interface CLASSNAME { | |
| void ABC\u1000(); // encodes to: 41 42 43 e1 80 80 | |
| } | |
| """; | |
| // We change 44 -> 00 (illegal one-byte encoding of 0x0000) | |
| private static final String SOURCE_4 = """ | |
| interface CLASSNAME { | |
| void ABCD(); // encodes to: 41 42 43 44 | |
| } | |
| """; | |
| // We change 43 44 -> e1 80 (illegal truncated three-byte encoding) | |
| private static final String SOURCE_5 = """ | |
| interface CLASSNAME { | |
| void ABCD(); // encodes to: 41 42 43 44 | |
| } | |
| """; | |
| // This is the source file that references one of the above | |
| private static final String REF_SOURCE = """ | |
| interface RefClass extends CLASSNAME { | |
| } | |
| """; | |
| private static TestCase[] TEST_CASES = new TestCase[] { | |
| new TestCase(0, SOURCE_0, "414243c3a8", "414243c3e8"), | |
| new TestCase(1, SOURCE_1, "414243e18080", "414243e18040"), | |
| new TestCase(2, SOURCE_2, "414243c480", "414243c181"), | |
| new TestCase(3, SOURCE_3, "414243e18080", "414243e08480"), | |
| new TestCase(4, SOURCE_4, "41424344", "41424300"), | |
| new TestCase(5, SOURCE_5, "41424344", "4142e180"), | |
| }; | |
| public static String bytes2string(byte[] array) { | |
| char[] buf = new char[array.length * 2]; | |
| for (int i = 0; i < array.length; i++) { | |
| int value = array[i] & 0xff; | |
| buf[i * 2] = Character.forDigit(value >> 4, 16); | |
| buf[i * 2 + 1] = Character.forDigit(value & 0xf, 16); | |
| } | |
| return new String(buf); | |
| } | |
| public static byte[] string2bytes(String string) { | |
| byte[] buf = new byte[string.length() / 2]; | |
| for (int i = 0; i < string.length(); i += 2) { | |
| int value = Integer.parseInt(string.substring(i, i + 2), 16); | |
| buf[i / 2] = (byte)value; | |
| } | |
| return buf; | |
| } | |
| private static void createSourceFile(String content, File file) throws IOException { | |
| System.err.println("creating: " + file); | |
| try (PrintStream output = new PrintStream(new FileOutputStream(file))) { | |
| output.println(content); | |
| } | |
| } | |
| private static void writeFile(File file, byte[] content) throws IOException { | |
| System.err.println("writing: " + file); | |
| try (FileOutputStream output = new FileOutputStream(file)) { | |
| Files.write(file.toPath(), content); | |
| } | |
| } | |
| private static void compileRefClass(File file, boolean expectSuccess, String expectedError) { | |
| final StringWriter diags = new StringWriter(); | |
| final String[] params = new String[] { | |
| "-classpath", | |
| ".", | |
| "-XDrawDiagnostics", | |
| file.toString() | |
| }; | |
| System.err.println("compiling: " + file); | |
| int ret = Main.compile(params, new PrintWriter(diags, true)); | |
| System.err.println("exit value: " + ret); | |
| String output = diags.toString().trim(); | |
| if (!output.isEmpty()) | |
| System.err.println("output:\n" + output); | |
| else | |
| System.err.println("no output"); | |
| if (!expectSuccess && ret == 0) | |
| throw new AssertionError("compilation succeeded, but expected failure"); | |
| else if (expectSuccess && ret != 0) | |
| throw new AssertionError("compilation failed, but expected success"); | |
| if (expectedError != null && !diags.toString().contains(expectedError)) | |
| throw new AssertionError("expected output \"" + expectedError + "\" not found"); | |
| } | |
| public static void main(String... args) throws Exception { | |
| // Create source files | |
| for (TestCase test : TEST_CASES) | |
| test.createSourceFile(); | |
| // Compile source files | |
| for (TestCase test : TEST_CASES) { | |
| int ret = Main.compile(new String[] { test.sourceFile().toString() }); | |
| if (ret != 0) | |
| throw new AssertionError("compilation of " + test.sourceFile() + " failed"); | |
| } | |
| // We should get warnings in JDK 21 and errors in any later release | |
| final boolean expectSuccess = Source.DEFAULT.compareTo(Source.JDK21) <= 0; | |
| // Now compile REF_SOURCE against each classfile without and then with the modification. | |
| // When compiling without the modification, everything should be normal. | |
| // When compiling with the modification, an error should be generated. | |
| for (TestCase test : TEST_CASES) { | |
| System.err.println("==== TEST " + test.index() + " ===="); | |
| // Create reference source file | |
| final File refSource = new File("RefClass.java"); | |
| createSourceFile(REF_SOURCE.replaceAll("CLASSNAME", test.className()), refSource); | |
| // Do a normal compilation | |
| compileRefClass(refSource, true, null); | |
| // Now corrupt the class file | |
| System.err.println("modifying: " + test.classFile()); | |
| final File classFile = test.classFile(); | |
| final byte[] data1 = Files.readAllBytes(classFile.toPath()); | |
| final byte[] data2 = test.modify(data1); | |
| writeFile(classFile, data2); | |
| // Do a corrupt compilation | |
| compileRefClass(refSource, expectSuccess, "compiler.misc.bad.utf8.byte.sequence.at"); | |
| } | |
| } | |
| // TestCase | |
| static class TestCase { | |
| final int index; | |
| final String source; | |
| final String match; | |
| final String replace; | |
| TestCase(int index, String source, String match, String replace) { | |
| this.index = index; | |
| this.source = source.replaceAll("CLASSNAME", className()); | |
| this.match = match; | |
| this.replace = replace; | |
| } | |
| byte[] modify(byte[] input) { | |
| final byte[] output = string2bytes(bytes2string(input).replaceAll(match, replace)); | |
| if (Arrays.equals(output, input)) | |
| throw new AssertionError("modification of " + classFile() + " failed"); | |
| return output; | |
| } | |
| int index() { | |
| return index; | |
| } | |
| String className() { | |
| return "Class" + index; | |
| } | |
| File sourceFile() { | |
| return new File(className() + ".java"); | |
| } | |
| File classFile() { | |
| return new File(className() + ".class"); | |
| } | |
| void createSourceFile() throws IOException { | |
| InvalidModifiedUtf8Test.createSourceFile(source, sourceFile()); | |
| } | |
| } | |
| } |